Skip to main content

glass_browser/browser/session/
task.rs

1//! Browser-backed execution for the bounded Task Protocol families.
2
3use super::{
4    BrowserResult, BrowserSession, ExtractionField, ExtractionKind, FillFormOutcome,
5    InspectPageResult, PendingDialog, SemanticObservationLevel, SemanticRegion, SemanticRegionKind,
6    StructuredExtractionLimits, StructuredExtractionProvenance, StructuredExtractionRecord,
7    StructuredExtractionRequest, StructuredExtractionResult, parse_revisioned_reference,
8};
9use crate::browser::session::{
10    KnowledgeLearningPolicy, KnowledgeLearningRequest, KnowledgeLearningResult,
11    KnowledgeLookupContext, KnowledgeLookupOptions, KnowledgeRecordBuildOptions, KnowledgeStore,
12    KnowledgeVerifiedWorkflowEvidence,
13};
14use crate::extraction::{
15    EvidenceCoverage, EvidenceFact, EvidenceQuality, EvidenceSource, ExtractionBudgets,
16    ExtractionEvidence, ExtractionEvidenceLimits, ExtractionRequest, ExtractionScope,
17    MAX_EXTRACTION_DURATION_MS,
18};
19use crate::protocol::{RetryClassification, RetryGuidance};
20use crate::task_compiler::{
21    TaskCompilationOptions, TaskExecutionPlan, TaskPlanOperation, TaskRuntimeCapability,
22    compile_task, compile_task_with_options, effective_postconditions,
23};
24use crate::task_protocol::{
25    GlassTask, TaskKind, TaskPostconditionKind, TaskRevisionPolicy, TaskRiskClass,
26};
27use serde::Serialize;
28use serde_json::json;
29use std::collections::BTreeMap;
30use std::io::{Error as IoError, ErrorKind};
31use std::time::{Duration, Instant};
32
33/// A bounded result for one browser-backed Task Protocol execution.
34#[derive(Debug, Clone, Serialize)]
35#[serde(rename_all = "camelCase")]
36pub struct TaskExecutionResult {
37    pub task: TaskKind,
38    pub status: String,
39    pub phase: String,
40    pub mutation_possible: bool,
41    pub source_revision: u64,
42    pub current_revision: u64,
43    pub steps: Vec<TaskStepResult>,
44    pub retry: RetryGuidance,
45    pub receipt: TaskExecutionReceipt,
46    #[serde(skip_serializing_if = "Option::is_none")]
47    pub form: Option<FillFormOutcome>,
48    #[serde(skip_serializing_if = "Option::is_none")]
49    pub extraction: Option<StructuredExtractionResult>,
50    #[serde(skip_serializing_if = "Option::is_none")]
51    pub dialog: Option<PendingDialog>,
52    #[serde(default, skip_serializing_if = "Vec::is_empty")]
53    pub alerts: Vec<String>,
54}
55
56/// Compact, value-free explanation of why a task was allowed and whether its
57/// verification obligations held.
58#[derive(Debug, Clone, Serialize)]
59#[serde(rename_all = "camelCase")]
60pub struct TaskExecutionReceipt {
61    pub source_revision: u64,
62    pub selected_entity_ids: Vec<String>,
63    /// Entities for which the plan required an ephemeral, revision-bound
64    /// browser reference. This is deliberately not called `bound`: a
65    /// preflight-failure receipt must not imply that binding succeeded.
66    pub binding_candidate_entity_ids: Vec<String>,
67    pub required_runtime_capabilities: Vec<TaskRuntimeCapability>,
68    pub evidence_requirements: Vec<crate::task_compiler::TaskEntityEvidenceRequirement>,
69    pub confirmation_required: bool,
70    #[serde(default, skip_serializing_if = "Vec::is_empty")]
71    pub postconditions: Vec<TaskPostconditionReceipt>,
72}
73
74#[derive(Debug, Clone, Serialize)]
75#[serde(rename_all = "camelCase")]
76pub struct TaskPostconditionReceipt {
77    pub kind: TaskPostconditionKind,
78    pub held: bool,
79}
80
81impl TaskExecutionReceipt {
82    fn from_plan(plan: &TaskExecutionPlan) -> Self {
83        let binding_candidate_entity_ids = plan
84            .entity_binding_keys
85            .iter()
86            .filter(|key| {
87                matches!(
88                    key.kind,
89                    crate::web_ir::WebIrEntityKind::Field
90                        | crate::web_ir::WebIrEntityKind::Action
91                        | crate::web_ir::WebIrEntityKind::Link
92                        | crate::web_ir::WebIrEntityKind::NavigationItem
93                        | crate::web_ir::WebIrEntityKind::Tab
94                        | crate::web_ir::WebIrEntityKind::PaginationControl
95                        | crate::web_ir::WebIrEntityKind::UnknownInteractive
96                )
97            })
98            .map(|key| key.entity_id.clone())
99            .collect();
100        Self {
101            source_revision: plan.source_ir_revision,
102            selected_entity_ids: plan.selected_entity_ids.clone(),
103            binding_candidate_entity_ids,
104            required_runtime_capabilities: plan.required_runtime_capabilities.clone(),
105            evidence_requirements: plan.entity_evidence_requirements.clone(),
106            confirmation_required: plan.confirmation_required,
107            postconditions: Vec::new(),
108        }
109    }
110}
111
112/// Outcome of one plan step without exposing authored input values.
113#[derive(Debug, Clone, Serialize)]
114#[serde(rename_all = "camelCase")]
115pub struct TaskStepResult {
116    pub ordinal: u16,
117    pub operation: TaskPlanOperation,
118    pub status: String,
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub detail: Option<String>,
121}
122
123/// Ephemeral browser references resolved from a compiled semantic key at the
124/// exact source revision. These bindings never cross the process boundary.
125struct LiveTaskBindings {
126    revision: u64,
127    references: BTreeMap<String, String>,
128}
129
130impl LiveTaskBindings {
131    fn resolve(
132        plan: &TaskExecutionPlan,
133        regions: &[&SemanticRegion],
134        revision: u64,
135    ) -> Result<Self, String> {
136        if revision != plan.source_ir_revision {
137            return Err("cannot bind a plan against a different page revision".into());
138        }
139        let mut references = BTreeMap::new();
140        for key in &plan.entity_binding_keys {
141            if !matches!(
142                key.kind,
143                crate::web_ir::WebIrEntityKind::Field
144                    | crate::web_ir::WebIrEntityKind::Action
145                    | crate::web_ir::WebIrEntityKind::Link
146                    | crate::web_ir::WebIrEntityKind::NavigationItem
147                    | crate::web_ir::WebIrEntityKind::Tab
148                    | crate::web_ir::WebIrEntityKind::PaginationControl
149                    | crate::web_ir::WebIrEntityKind::UnknownInteractive
150            ) {
151                continue;
152            }
153            let mut candidates = regions
154                .iter()
155                .flat_map(|region| region.targets.iter())
156                .filter(|target| {
157                    key.role
158                        .as_deref()
159                        .is_none_or(|role| target.role.eq_ignore_ascii_case(role))
160                        && key
161                            .name
162                            .as_deref()
163                            .is_none_or(|name| target.name.eq_ignore_ascii_case(name))
164                });
165            let Some(target) = candidates.next() else {
166                return Err(format!(
167                    "selected entity {} did not resolve to exactly one revision-bound browser target",
168                    key.entity_id
169                ));
170            };
171            if candidates.next().is_some() {
172                return Err(format!(
173                    "selected entity {} resolved to multiple revision-bound browser targets",
174                    key.entity_id
175                ));
176            }
177            let parsed = parse_revisioned_reference(&target.reference)
178                .map_err(|error| format!("invalid live binding reference: {error}"))?
179                .ok_or_else(|| "live binding is not revisioned".to_string())?;
180            if parsed.revision != revision {
181                return Err(format!(
182                    "selected entity {} resolved to a stale browser target",
183                    key.entity_id
184                ));
185            }
186            references.insert(key.entity_id.clone(), target.reference.clone());
187        }
188        Ok(Self {
189            revision,
190            references,
191        })
192    }
193
194    fn reference_for_name<'a>(
195        &'a self,
196        plan: &TaskExecutionPlan,
197        name: &str,
198    ) -> Result<&'a str, String> {
199        let mut candidates = plan.entity_binding_keys.iter().filter(|key| {
200            key.name
201                .as_deref()
202                .is_some_and(|candidate| candidate.eq_ignore_ascii_case(name))
203                && self.references.contains_key(&key.entity_id)
204        });
205        let Some(key) = candidates.next() else {
206            return Err(format!(
207                "compiled entity named {name:?} does not have one live binding"
208            ));
209        };
210        if candidates.next().is_some() {
211            return Err(format!(
212                "compiled entity named {name:?} has multiple live bindings"
213            ));
214        }
215        self.references
216            .get(&key.entity_id)
217            .map(String::as_str)
218            .ok_or_else(|| "live binding disappeared before dispatch".into())
219    }
220
221    fn bound_fields(
222        &self,
223        plan: &TaskExecutionPlan,
224        inputs: &BTreeMap<String, String>,
225    ) -> Result<Vec<(String, String, String)>, String> {
226        if self.revision != plan.source_ir_revision {
227            return Err("live field bindings are stale".into());
228        }
229        inputs
230            .iter()
231            .map(|(name, value)| {
232                self.reference_for_name(plan, name)
233                    .map(|reference| (reference.to_string(), name.clone(), value.clone()))
234            })
235            .collect()
236    }
237}
238
239fn live_task_evidence_sources() -> Vec<EvidenceSource> {
240    vec![
241        EvidenceSource::Accessibility,
242        EvidenceSource::Dom,
243        EvidenceSource::Forms,
244        EvidenceSource::Layout,
245        EvidenceSource::Navigation,
246        EvidenceSource::Tables,
247        EvidenceSource::Collections,
248        EvidenceSource::Dialogs,
249        EvidenceSource::Frames,
250        EvidenceSource::ShadowDom,
251        EvidenceSource::Svg,
252        EvidenceSource::CanvasDetection,
253        EvidenceSource::MediaMetadata,
254        EvidenceSource::EmbeddedDocument,
255        EvidenceSource::Pdf,
256        EvidenceSource::BrowserNative,
257        EvidenceSource::Bridge,
258        EvidenceSource::BoundedProbe,
259    ]
260}
261
262impl BrowserSession {
263    async fn compile_live_task(&self, task: &GlassTask) -> BrowserResult<TaskExecutionPlan> {
264        self.compile_live_task_with_memory(task, None).await
265    }
266
267    /// Compile a task from one fresh live Web IR revision while consulting
268    /// caller-owned advisory memory.
269    ///
270    /// Memory is explicitly opt-in. The current extraction remains
271    /// authoritative: the store receives only a lookup context built from a
272    /// fresh semantic observation whose revision must equal the compiled IR.
273    /// Historical records can explain ranking, but cannot provide entity
274    /// handles, actions, or postconditions.
275    pub async fn compile_live_task_with_knowledge(
276        &self,
277        task: &GlassTask,
278        store: &KnowledgeStore,
279        options: KnowledgeLookupOptions,
280    ) -> BrowserResult<TaskExecutionPlan> {
281        self.compile_live_task_with_memory(task, Some((store, options)))
282            .await
283    }
284
285    /// Persist one verified-learning witness after re-observing the live page.
286    ///
287    /// This is an explicit opt-in update path. The caller supplies a successful
288    /// guarded workflow witness and privacy scope; the session supplies the
289    /// fresh semantic observation, so a stale or mismatched revision cannot be
290    /// promoted into persistent memory.
291    pub async fn learn_verified_knowledge(
292        &self,
293        store: &mut KnowledgeStore,
294        build: KnowledgeRecordBuildOptions,
295        evidence: KnowledgeVerifiedWorkflowEvidence,
296        policy: KnowledgeLearningPolicy,
297    ) -> BrowserResult<KnowledgeLearningResult> {
298        let observation = self
299            .semantic_observe(SemanticObservationLevel::Structured)
300            .await?;
301        if observation.revision != evidence.guarded_revision {
302            return Err(format!(
303                "verified-learning witness revision {} does not match fresh observation revision {}",
304                evidence.guarded_revision, observation.revision
305            )
306            .into());
307        }
308        store
309            .learn_verified(KnowledgeLearningRequest {
310                observation: &observation,
311                build,
312                evidence,
313                policy,
314            })
315            .map_err(|error| error.to_string().into())
316    }
317
318    async fn compile_live_task_with_memory(
319        &self,
320        task: &GlassTask,
321        memory: Option<(&KnowledgeStore, KnowledgeLookupOptions)>,
322    ) -> BrowserResult<TaskExecutionPlan> {
323        if matches!(
324            task.task,
325            TaskKind::DialogInspect | TaskKind::DialogConfirm | TaskKind::DialogCancel
326        ) && self.pending_dialog().await.is_some()
327        {
328            let revision = self
329                .page_revision
330                .load(std::sync::atomic::Ordering::Relaxed);
331            let evidence = ExtractionEvidence {
332                schema_version: crate::extraction::EXTRACTION_CONTRACT_SCHEMA_VERSION,
333                revision,
334                scope: ExtractionScope::Document,
335                sources: vec![EvidenceSource::Dialogs],
336                facts: vec![EvidenceFact {
337                    source: EvidenceSource::Dialogs,
338                    kind: "semantic".into(),
339                    quality: EvidenceQuality::Confirmed,
340                    role: Some("dialog".into()),
341                    name: Some("Pending dialog".into()),
342                    input_type: None,
343                    autocomplete: None,
344                    required: None,
345                    read_only: None,
346                    empty: None,
347                    checked: None,
348                    disabled: None,
349                    geometry_present: None,
350                    parent_role: None,
351                    relationship_hint: None,
352                }],
353                limits: ExtractionEvidenceLimits {
354                    truncated: false,
355                    omitted_facts: 0,
356                    text_bytes: 14,
357                    missing_sources: Vec::new(),
358                },
359                coverage: EvidenceCoverage {
360                    structural: EvidenceQuality::Strong,
361                    semantic: EvidenceQuality::Confirmed,
362                    interactive_entities_observed: 1,
363                    opaque_regions: 0,
364                    reasons: Vec::new(),
365                },
366                surface_set: None,
367            };
368            let ir = crate::web_ir::reconcile_evidence(&evidence)?;
369            return compile_task(task, &ir).map_err(|error| error.to_string().into());
370        }
371        let budgets = ExtractionBudgets {
372            max_duration_ms: task.limits.timeout_ms.clamp(1, MAX_EXTRACTION_DURATION_MS),
373            ..ExtractionBudgets::default()
374        };
375        let request = ExtractionRequest {
376            schema_version: crate::extraction::EXTRACTION_CONTRACT_SCHEMA_VERSION,
377            scope: ExtractionScope::Document,
378            sources: live_task_evidence_sources(),
379            budgets,
380        };
381        let ir = self.extract_web_ir(&request).await?;
382        let plan = if let Some((store, options)) = memory {
383            let observation = self
384                .semantic_observe(SemanticObservationLevel::Structured)
385                .await?;
386            if observation.revision != ir.revision {
387                return Err(format!(
388                    "live semantic observation revision {} disagrees with extracted Web IR revision {}",
389                    observation.revision, ir.revision
390                )
391                .into());
392            }
393            let context = KnowledgeLookupContext::from_observation(&observation, options)?;
394            compile_task_with_options(
395                task,
396                &ir,
397                TaskCompilationOptions {
398                    knowledge_store: Some(store),
399                    knowledge_context: Some(&context),
400                },
401            )
402        } else {
403            compile_task(task, &ir)
404        };
405        plan.map_err(|error| error.to_string().into())
406    }
407
408    /// Execute a validated form task against one caller-observed revision.
409    ///
410    /// `expected_revision` is supplied by the caller's preceding semantic
411    /// observation. The runtime always re-observes before mutation, resolves
412    /// targets from that observation, and passes the resulting revision into
413    /// the guarded action APIs.
414    async fn execute_form_task_unchecked(
415        &self,
416        task: &GlassTask,
417        expected_revision: u64,
418        confirmed: bool,
419    ) -> BrowserResult<TaskExecutionResult> {
420        let plan = self.compile_live_task(task).await?;
421        if let Some(detail) = unsupported_runtime_capability(&plan) {
422            return Ok(preflight_result(task, &plan, expected_revision, detail));
423        }
424        if !matches!(
425            task.task,
426            TaskKind::FormInspect
427                | TaskKind::FormFill
428                | TaskKind::FormValidate
429                | TaskKind::FormSubmit
430                | TaskKind::FieldRead
431                | TaskKind::NavigationSelectTab
432                | TaskKind::NavigationOpenMenu
433                | TaskKind::PaginationNext
434                | TaskKind::PaginationCollect
435                | TaskKind::TableExtract
436                | TaskKind::CollectionExtract
437                | TaskKind::RegionExtract
438        ) {
439            return Ok(preflight_result(
440                task,
441                &plan,
442                expected_revision,
443                "unsupported task family; browser execution currently supports form, field, table, collection, region extraction, navigation menu, and pagination tasks",
444            ));
445        }
446        if let Some(detail) = compiled_revision_mismatch(&plan, expected_revision) {
447            return Ok(preflight_result(task, &plan, expected_revision, &detail));
448        }
449        let expected_revision = plan.source_ir_revision;
450        if plan.confirmation_required && !confirmed {
451            return Ok(preflight_result(
452                task,
453                &plan,
454                expected_revision,
455                "confirmation is required before this task can mutate the browser",
456            ));
457        }
458
459        let current_revision = self
460            .page_revision
461            .load(std::sync::atomic::Ordering::Relaxed);
462        if current_revision != expected_revision {
463            return Ok(preflight_result(
464                task,
465                &plan,
466                current_revision,
467                "source revision is stale; no browser mutation was dispatched",
468            ));
469        }
470        let observation = bounded(self.inspect_page(), task.limits.timeout_ms).await?;
471        if observation.revision != expected_revision {
472            return Ok(preflight_result(
473                task,
474                &plan,
475                observation.revision,
476                "source revision changed during preflight observation; no browser mutation was dispatched",
477            ));
478        }
479
480        let scoped_regions = match scoped_regions_for_observation(&observation, task) {
481            Ok(regions) => regions,
482            Err(error) => {
483                return Ok(preflight_result(
484                    task,
485                    &plan,
486                    observation.revision,
487                    &error.to_string(),
488                ));
489            }
490        };
491        let live_bindings =
492            match LiveTaskBindings::resolve(&plan, &scoped_regions, observation.revision) {
493                Ok(bindings) => bindings,
494                Err(detail) => {
495                    return Ok(preflight_result(task, &plan, observation.revision, &detail));
496                }
497            };
498        let mut steps = vec![step(
499            &plan,
500            TaskPlanOperation::ObserveScope,
501            "succeeded",
502            None,
503        )];
504
505        match task.task {
506            TaskKind::NavigationOpenMenu => {
507                Box::pin(self.execute_open_menu_task(task, &plan, &observation, &live_bindings))
508                    .await
509            }
510            TaskKind::NavigationSelectTab => {
511                let Some(tab_name) = task.inputs.get("tab") else {
512                    return Ok(preflight_result(
513                        task,
514                        &plan,
515                        observation.revision,
516                        "navigation.selectTab requires the semantic tab input",
517                    ));
518                };
519                let target_reference = match live_bindings.reference_for_name(&plan, tab_name) {
520                    Ok(reference) => reference,
521                    Err(error) => {
522                        return Ok(preflight_result(task, &plan, observation.revision, &error));
523                    }
524                };
525                let outcome = bounded(
526                    self.click_with_revision(target_reference, observation.revision),
527                    task.limits.timeout_ms,
528                )
529                .await;
530                let after = match bounded(self.inspect_page(), task.limits.timeout_ms).await {
531                    Ok(after) => after,
532                    Err(error) => {
533                        let current_revision = self
534                            .page_revision
535                            .load(std::sync::atomic::Ordering::Relaxed);
536                        return Ok(mutation_failure_result(
537                            task,
538                            &plan,
539                            (observation.revision, current_revision),
540                            steps,
541                            TaskPlanOperation::SelectTab,
542                            "navigation-verification",
543                            format!("post-action observation failed: {error}"),
544                        ));
545                    }
546                };
547                let succeeded = outcome.is_ok()
548                    && wait_for_aria_true(
549                        self,
550                        target_reference,
551                        "aria-selected",
552                        task.limits.timeout_ms,
553                    )
554                    .await;
555                steps.push(step(
556                    &plan,
557                    TaskPlanOperation::SelectTab,
558                    if succeeded {
559                        "succeeded"
560                    } else {
561                        "indeterminate"
562                    },
563                    (!succeeded).then(|| "tab selection outcome was not verified".into()),
564                ));
565                Ok(TaskExecutionResult {
566                    task: task.task,
567                    receipt: TaskExecutionReceipt::from_plan(&plan),
568                    status: if succeeded {
569                        "succeeded"
570                    } else {
571                        "indeterminate"
572                    }
573                    .into(),
574                    phase: "navigation-verification".into(),
575                    mutation_possible: true,
576                    source_revision: observation.revision,
577                    current_revision: self
578                        .page_revision
579                        .load(std::sync::atomic::Ordering::Relaxed)
580                        .max(after.revision),
581                    steps,
582                    retry: if succeeded {
583                        retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
584                    } else {
585                        retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run")
586                    },
587                    form: None,
588                    extraction: None,
589                    dialog: None,
590                    alerts: alert_labels(after.regions.iter()),
591                })
592            }
593            TaskKind::PaginationCollect => {
594                let Some(next_name) = task.inputs.get("next") else {
595                    return Ok(preflight_result(
596                        task,
597                        &plan,
598                        observation.revision,
599                        "pagination.collect requires the semantic next control input",
600                    ));
601                };
602                let max_pages = task.limits.max_items.min(task.limits.max_actions).max(1) as usize;
603                let source_revision = observation.revision;
604                let mut current = observation;
605                let mut completed = 0usize;
606                let mut stopped = false;
607                let mut unsafe_until_reconciled = false;
608                let deadline =
609                    tokio::time::Instant::now() + Duration::from_millis(task.limits.timeout_ms);
610                let mut pagination_extraction: Option<StructuredExtractionResult> = None;
611                while completed < max_pages {
612                    let regions = match scoped_regions_for_observation(&current, task) {
613                        Ok(regions) => regions,
614                        Err(error) if completed == 0 => {
615                            return Ok(preflight_result(
616                                task,
617                                &plan,
618                                current.revision,
619                                &error.to_string(),
620                            ));
621                        }
622                        Err(error) => {
623                            let current_revision = self
624                                .page_revision
625                                .load(std::sync::atomic::Ordering::Relaxed);
626                            return Ok(mutation_failure_result(
627                                task,
628                                &plan,
629                                (source_revision, current_revision),
630                                steps,
631                                TaskPlanOperation::CollectPages,
632                                "pagination-collection",
633                                format!("post-action scope reconciliation failed: {error}"),
634                            ));
635                        }
636                    };
637                    let region = regions
638                        .first()
639                        .expect("scoped_regions contains exactly one region");
640                    let page_extraction = match bounded(
641                        self.extract_structured(&StructuredExtractionRequest {
642                            fields: vec![ExtractionField {
643                                name: "items".into(),
644                                path: "$.structuredRecords".into(),
645                                kind: ExtractionKind::RepeatedItems,
646                            }],
647                            region_id: Some(region.id.clone()),
648                            start_index: 0,
649                            continuation: None,
650                            max_items: task.limits.max_items as usize,
651                            max_bytes: 64 * 1024,
652                        }),
653                        remaining_timeout(deadline),
654                    )
655                    .await
656                    {
657                        Ok(extraction) => extraction,
658                        Err(error) if completed == 0 => {
659                            return Ok(preflight_result(
660                                task,
661                                &plan,
662                                current.revision,
663                                &format!("pagination extraction failed: {error}"),
664                            ));
665                        }
666                        Err(error) => {
667                            let current_revision = self
668                                .page_revision
669                                .load(std::sync::atomic::Ordering::Relaxed);
670                            return Ok(mutation_failure_result(
671                                task,
672                                &plan,
673                                (source_revision, current_revision),
674                                steps,
675                                TaskPlanOperation::CollectPages,
676                                "pagination-collection",
677                                format!("pagination extraction failed: {error}"),
678                            ));
679                        }
680                    };
681                    merge_pagination_extraction(
682                        &mut pagination_extraction,
683                        page_extraction,
684                        task.limits.max_items as usize,
685                        64 * 1024,
686                    );
687                    let initial_reference = (completed == 0)
688                        .then(|| live_bindings.reference_for_name(&plan, next_name))
689                        .transpose();
690                    let initial_reference = match initial_reference {
691                        Ok(reference) => reference,
692                        Err(error) => {
693                            return Ok(preflight_result(task, &plan, current.revision, &error));
694                        }
695                    };
696                    let candidates = region
697                        .targets
698                        .iter()
699                        .filter(|target| {
700                            initial_reference.map_or_else(
701                                || target.name.eq_ignore_ascii_case(next_name),
702                                |reference| target.reference == reference,
703                            )
704                        })
705                        .collect::<Vec<_>>();
706                    if candidates.is_empty() {
707                        stopped = true;
708                        break;
709                    }
710                    if candidates.len() > 1 {
711                        if completed == 0 {
712                            return Ok(preflight_result(
713                                task,
714                                &plan,
715                                current.revision,
716                                "pagination.collect next control is ambiguous",
717                            ));
718                        }
719                        return Ok(mutation_failure_result(
720                            task,
721                            &plan,
722                            (source_revision, current.revision),
723                            steps,
724                            TaskPlanOperation::CollectPages,
725                            "pagination-collection",
726                            "pagination.collect next control became ambiguous after mutation",
727                        ));
728                    }
729                    let target = candidates[0];
730                    if !matches!(target.role.as_str(), "button" | "link" | "tab") {
731                        if completed == 0 {
732                            return Ok(preflight_result(
733                                task,
734                                &plan,
735                                current.revision,
736                                "pagination.collect target is not a semantic navigation control",
737                            ));
738                        }
739                        return Ok(mutation_failure_result(
740                            task,
741                            &plan,
742                            (source_revision, current.revision),
743                            steps,
744                            TaskPlanOperation::CollectPages,
745                            "pagination-collection",
746                            "pagination.collect target became non-navigational after mutation",
747                        ));
748                    }
749                    let before_revision = current.revision;
750                    let outcome = bounded(
751                        self.click_with_revision(&target.reference, before_revision),
752                        remaining_timeout(deadline),
753                    )
754                    .await;
755                    let after =
756                        match bounded(self.inspect_page(), remaining_timeout(deadline)).await {
757                            Ok(after) => after,
758                            Err(error) => {
759                                let current_revision = self
760                                    .page_revision
761                                    .load(std::sync::atomic::Ordering::Relaxed);
762                                return Ok(mutation_failure_result(
763                                    task,
764                                    &plan,
765                                    (source_revision, current_revision),
766                                    steps,
767                                    TaskPlanOperation::CollectPages,
768                                    "pagination-collection",
769                                    format!("post-action observation failed: {error}"),
770                                ));
771                            }
772                        };
773                    let after = match Box::pin(wait_for_semantic_page_change(
774                        self,
775                        &current,
776                        after,
777                        remaining_timeout(deadline),
778                    ))
779                    .await
780                    {
781                        Ok(after) => after,
782                        Err(error) => {
783                            let current_revision = self
784                                .page_revision
785                                .load(std::sync::atomic::Ordering::Relaxed);
786                            return Ok(mutation_failure_result(
787                                task,
788                                &plan,
789                                (source_revision, current_revision),
790                                steps,
791                                TaskPlanOperation::CollectPages,
792                                "pagination-collection",
793                                format!("post-action transition observation failed: {error}"),
794                            ));
795                        }
796                    };
797                    let succeeded = outcome.is_ok();
798                    steps.push(step(
799                        &plan,
800                        TaskPlanOperation::CollectPages,
801                        if succeeded {
802                            "succeeded"
803                        } else {
804                            "indeterminate"
805                        },
806                        (!succeeded).then(|| "pagination outcome was not verified".into()),
807                    ));
808                    if !succeeded {
809                        return Ok(TaskExecutionResult {
810                            task: task.task,
811                            receipt: TaskExecutionReceipt::from_plan(&plan),
812                            status: "indeterminate".into(),
813                            phase: "pagination-collection".into(),
814                            mutation_possible: true,
815                            source_revision,
816                            current_revision: self
817                                .page_revision
818                                .load(std::sync::atomic::Ordering::Relaxed)
819                                .max(after.revision),
820                            steps,
821                            retry: retry_guidance(
822                                RetryClassification::UnsafeUntilReconciled,
823                                "recover_run",
824                            ),
825                            form: None,
826                            extraction: None,
827                            dialog: None,
828                            alerts: alert_labels(after.regions.iter()),
829                        });
830                    }
831                    completed += 1;
832                    let page_changed = semantic_page_changed(&current, &after);
833                    current = after;
834                    if !page_changed {
835                        let regions = match scoped_regions_for_observation(&current, task) {
836                            Ok(regions) => regions,
837                            Err(error) => {
838                                let current_revision = self
839                                    .page_revision
840                                    .load(std::sync::atomic::Ordering::Relaxed);
841                                return Ok(mutation_failure_result(
842                                    task,
843                                    &plan,
844                                    (source_revision, current_revision),
845                                    steps,
846                                    TaskPlanOperation::CollectPages,
847                                    "pagination-collection",
848                                    format!("post-action scope reconciliation failed: {error}"),
849                                ));
850                            }
851                        };
852                        if pagination_next_is_usable(&regions, next_name) {
853                            let step = steps
854                                .last_mut()
855                                .expect("pagination click always records one step");
856                            step.status = "indeterminate".into();
857                            step.detail = Some(
858                                "pagination click produced no semantic page change while the next control remained available"
859                                    .into(),
860                            );
861                            unsafe_until_reconciled = true;
862                        } else {
863                            stopped = true;
864                        }
865                        break;
866                    }
867                }
868                let mut alerts = alert_labels(current.regions.iter());
869                if !stopped && completed == max_pages {
870                    alerts.push("pagination-limit-reached".into());
871                }
872                Ok(TaskExecutionResult {
873                    task: task.task,
874                    receipt: TaskExecutionReceipt::from_plan(&plan),
875                    status: if unsafe_until_reconciled {
876                        "indeterminate"
877                    } else {
878                        "succeeded"
879                    }
880                    .into(),
881                    phase: "pagination-collection".into(),
882                    mutation_possible: completed > 0,
883                    source_revision,
884                    current_revision: current.revision,
885                    steps,
886                    retry: retry_guidance(
887                        if unsafe_until_reconciled {
888                            RetryClassification::UnsafeUntilReconciled
889                        } else {
890                            RetryClassification::SafeImmediate
891                        },
892                        if unsafe_until_reconciled {
893                            "recover_run"
894                        } else {
895                            "inspect_page"
896                        },
897                    ),
898                    form: None,
899                    extraction: pagination_extraction,
900                    dialog: None,
901                    alerts,
902                })
903            }
904            TaskKind::PaginationNext => {
905                let Some(next_name) = task.inputs.get("next") else {
906                    return Ok(preflight_result(
907                        task,
908                        &plan,
909                        observation.revision,
910                        "pagination.next requires the semantic next control input",
911                    ));
912                };
913                let target_reference = match live_bindings.reference_for_name(&plan, next_name) {
914                    Ok(reference) => reference,
915                    Err(error) => {
916                        return Ok(preflight_result(task, &plan, observation.revision, &error));
917                    }
918                };
919                let outcome = bounded(
920                    self.click_with_revision(target_reference, observation.revision),
921                    task.limits.timeout_ms,
922                )
923                .await;
924                let after = match bounded(self.inspect_page(), task.limits.timeout_ms).await {
925                    Ok(after) => after,
926                    Err(error) => {
927                        let current_revision = self
928                            .page_revision
929                            .load(std::sync::atomic::Ordering::Relaxed);
930                        return Ok(mutation_failure_result(
931                            task,
932                            &plan,
933                            (observation.revision, current_revision),
934                            steps,
935                            TaskPlanOperation::NextPage,
936                            "pagination-verification",
937                            format!("post-action observation failed: {error}"),
938                        ));
939                    }
940                };
941                let after = match wait_for_semantic_page_change(
942                    self,
943                    &observation,
944                    after,
945                    task.limits.timeout_ms,
946                )
947                .await
948                {
949                    Ok(after) => after,
950                    Err(error) => {
951                        let current_revision = self
952                            .page_revision
953                            .load(std::sync::atomic::Ordering::Relaxed);
954                        return Ok(mutation_failure_result(
955                            task,
956                            &plan,
957                            (observation.revision, current_revision),
958                            steps,
959                            TaskPlanOperation::NextPage,
960                            "pagination-verification",
961                            format!("post-action transition observation failed: {error}"),
962                        ));
963                    }
964                };
965                let succeeded = outcome.is_ok() && semantic_page_changed(&observation, &after);
966                steps.push(step(
967                    &plan,
968                    TaskPlanOperation::NextPage,
969                    if succeeded {
970                        "succeeded"
971                    } else {
972                        "indeterminate"
973                    },
974                    (!succeeded).then(|| "pagination outcome was not verified".into()),
975                ));
976                Ok(TaskExecutionResult {
977                    task: task.task,
978                    receipt: TaskExecutionReceipt::from_plan(&plan),
979                    status: if succeeded {
980                        "succeeded"
981                    } else {
982                        "indeterminate"
983                    }
984                    .into(),
985                    phase: "pagination-verification".into(),
986                    mutation_possible: true,
987                    source_revision: observation.revision,
988                    current_revision: self
989                        .page_revision
990                        .load(std::sync::atomic::Ordering::Relaxed)
991                        .max(after.revision),
992                    steps,
993                    retry: if succeeded {
994                        retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
995                    } else {
996                        retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run")
997                    },
998                    form: None,
999                    extraction: None,
1000                    dialog: None,
1001                    alerts: alert_labels(after.regions.iter()),
1002                })
1003            }
1004            TaskKind::FieldRead => {
1005                let Some(field_name) = task.inputs.get("field") else {
1006                    return Ok(preflight_result(
1007                        task,
1008                        &plan,
1009                        observation.revision,
1010                        "field.read requires the semantic field name in inputs.field",
1011                    ));
1012                };
1013                let target_reference = match live_bindings.reference_for_name(&plan, field_name) {
1014                    Ok(reference) => reference,
1015                    Err(error) => {
1016                        return Ok(preflight_result(task, &plan, observation.revision, &error));
1017                    }
1018                };
1019                let Some(target) = scoped_regions
1020                    .iter()
1021                    .flat_map(|region| region.targets.iter())
1022                    .find(|target| target.reference == target_reference)
1023                else {
1024                    return Ok(preflight_result(
1025                        task,
1026                        &plan,
1027                        observation.revision,
1028                        "compiled field binding disappeared before dispatch",
1029                    ));
1030                };
1031                let semantic = bounded(
1032                    self.semantic_observe(SemanticObservationLevel::Structured),
1033                    task.limits.timeout_ms,
1034                )
1035                .await?;
1036                if semantic.revision != expected_revision {
1037                    return Ok(preflight_result(
1038                        task,
1039                        &plan,
1040                        semantic.revision,
1041                        "source revision changed during field read preflight",
1042                    ));
1043                }
1044                let values =
1045                    bounded(self.observe_with_form_values(), task.limits.timeout_ms).await?;
1046                let values_revision = self
1047                    .page_revision
1048                    .load(std::sync::atomic::Ordering::Relaxed);
1049                if values_revision != expected_revision {
1050                    return Ok(preflight_result(
1051                        task,
1052                        &plan,
1053                        values_revision,
1054                        "source revision changed while reading field values",
1055                    ));
1056                }
1057                let Some(control) = values
1058                    .accessibility
1059                    .interactive
1060                    .iter()
1061                    .find(|control| control.reference == target.reference)
1062                else {
1063                    return Ok(preflight_result(
1064                        task,
1065                        &plan,
1066                        semantic.revision,
1067                        "field target was not present in the bounded form-value observation",
1068                    ));
1069                };
1070                let record = json!({
1071                    "field": target.name,
1072                    "reference": target.reference,
1073                    "role": target.role,
1074                    "inputType": target.input_type,
1075                    "value": control.value,
1076                    "checked": control.checked,
1077                    "selectedOption": control.selected_option,
1078                    "empty": control.empty,
1079                    "readOnly": control.read_only,
1080                    "required": control.required,
1081                });
1082                steps.push(step(&plan, TaskPlanOperation::ReadField, "succeeded", None));
1083                Ok(TaskExecutionResult {
1084                    task: task.task,
1085                    receipt: TaskExecutionReceipt::from_plan(&plan),
1086                    status: "succeeded".into(),
1087                    phase: "field-read".into(),
1088                    mutation_possible: false,
1089                    source_revision: semantic.revision,
1090                    current_revision: semantic.revision,
1091                    steps,
1092                    retry: retry_guidance(RetryClassification::SafeImmediate, "inspect_page"),
1093                    form: None,
1094                    extraction: Some(StructuredExtractionResult {
1095                        source_revision: semantic.revision,
1096                        source_route: semantic.route,
1097                        records: vec![record.clone()],
1098                        record_items: Vec::new(),
1099                        provenance: vec!["$.interactive".into()],
1100                        truncated: false,
1101                        continuation: None,
1102                        field_provenance: vec![StructuredExtractionProvenance {
1103                            field: "field".into(),
1104                            path: "$.interactive".into(),
1105                            region_id: scoped_regions.first().map(|region| region.id.clone()),
1106                            entity_ids: vec![target.reference.clone()],
1107                        }],
1108                        limits: StructuredExtractionLimits {
1109                            max_items: task.limits.max_items as usize,
1110                            max_bytes: 64 * 1024,
1111                            observed_items: 1,
1112                            serialized_bytes: serde_json::to_vec(&record)
1113                                .map_or(0, |bytes| bytes.len()),
1114                            truncated: false,
1115                        },
1116                    }),
1117                    dialog: None,
1118                    alerts: alert_labels(scoped_regions.iter().copied()),
1119                })
1120            }
1121            TaskKind::TableExtract => {
1122                let region = scoped_regions
1123                    .first()
1124                    .expect("scoped_regions contains exactly one region");
1125                if region.kind != SemanticRegionKind::Table {
1126                    return Ok(preflight_result(
1127                        task,
1128                        &plan,
1129                        observation.revision,
1130                        "table.extract scope is not a semantic table region",
1131                    ));
1132                }
1133                let request = StructuredExtractionRequest {
1134                    fields: vec![ExtractionField {
1135                        name: "rows".into(),
1136                        path: "$.structuredRecords".into(),
1137                        kind: ExtractionKind::Table,
1138                    }],
1139                    region_id: Some(region.id.clone()),
1140                    start_index: 0,
1141                    continuation: None,
1142                    max_items: task.limits.max_items as usize,
1143                    max_bytes: 64 * 1024,
1144                };
1145                let extraction =
1146                    bounded(self.extract_structured(&request), task.limits.timeout_ms).await?;
1147                if !extraction_matches_observation(&extraction, &observation) {
1148                    return Ok(preflight_result(
1149                        task,
1150                        &plan,
1151                        extraction.source_revision,
1152                        "source revision or route changed during table extraction",
1153                    ));
1154                }
1155                steps.push(step(
1156                    &plan,
1157                    TaskPlanOperation::ExtractTable,
1158                    "succeeded",
1159                    None,
1160                ));
1161                Ok(TaskExecutionResult {
1162                    task: task.task,
1163                    receipt: TaskExecutionReceipt::from_plan(&plan),
1164                    status: "succeeded".into(),
1165                    phase: "extraction".into(),
1166                    mutation_possible: false,
1167                    source_revision: observation.revision,
1168                    current_revision: extraction.source_revision,
1169                    steps,
1170                    retry: retry_guidance(RetryClassification::SafeImmediate, "inspect_page"),
1171                    form: None,
1172                    extraction: Some(extraction),
1173                    alerts: alert_labels(scoped_regions.iter().copied()),
1174                    dialog: None,
1175                })
1176            }
1177            TaskKind::CollectionExtract => {
1178                let region = scoped_regions
1179                    .first()
1180                    .expect("scoped_regions contains exactly one region");
1181                if region.kind != SemanticRegionKind::Collection {
1182                    return Ok(preflight_result(
1183                        task,
1184                        &plan,
1185                        observation.revision,
1186                        "collection.extract scope is not a semantic collection region",
1187                    ));
1188                }
1189                let request = StructuredExtractionRequest {
1190                    fields: vec![ExtractionField {
1191                        name: "items".into(),
1192                        path: "$.structuredRecords".into(),
1193                        kind: ExtractionKind::RepeatedItems,
1194                    }],
1195                    region_id: Some(region.id.clone()),
1196                    start_index: 0,
1197                    continuation: None,
1198                    max_items: task.limits.max_items as usize,
1199                    max_bytes: 64 * 1024,
1200                };
1201                let extraction =
1202                    bounded(self.extract_structured(&request), task.limits.timeout_ms).await?;
1203                if !extraction_matches_observation(&extraction, &observation) {
1204                    return Ok(preflight_result(
1205                        task,
1206                        &plan,
1207                        extraction.source_revision,
1208                        "source revision or route changed during collection extraction",
1209                    ));
1210                }
1211                steps.push(step(
1212                    &plan,
1213                    TaskPlanOperation::ExtractCollection,
1214                    "succeeded",
1215                    None,
1216                ));
1217                Ok(TaskExecutionResult {
1218                    task: task.task,
1219                    receipt: TaskExecutionReceipt::from_plan(&plan),
1220                    status: "succeeded".into(),
1221                    phase: "extraction".into(),
1222                    mutation_possible: false,
1223                    source_revision: observation.revision,
1224                    current_revision: extraction.source_revision,
1225                    steps,
1226                    retry: retry_guidance(RetryClassification::SafeImmediate, "inspect_page"),
1227                    form: None,
1228                    extraction: Some(extraction),
1229                    alerts: alert_labels(scoped_regions.iter().copied()),
1230                    dialog: None,
1231                })
1232            }
1233            TaskKind::RegionExtract => {
1234                let region_id = scoped_regions
1235                    .first()
1236                    .map(|region| region.id.clone())
1237                    .expect("scoped_regions contains exactly one region");
1238                let request = StructuredExtractionRequest {
1239                    fields: vec![ExtractionField {
1240                        name: "region".into(),
1241                        path: "$".into(),
1242                        kind: ExtractionKind::Object,
1243                    }],
1244                    region_id: Some(region_id),
1245                    start_index: 0,
1246                    continuation: None,
1247                    max_items: task.limits.max_items as usize,
1248                    max_bytes: 64 * 1024,
1249                };
1250                let extraction =
1251                    bounded(self.extract_structured(&request), task.limits.timeout_ms).await?;
1252                if !extraction_matches_observation(&extraction, &observation) {
1253                    return Ok(preflight_result(
1254                        task,
1255                        &plan,
1256                        extraction.source_revision,
1257                        "source revision or route changed during region extraction",
1258                    ));
1259                }
1260                steps.push(step(
1261                    &plan,
1262                    TaskPlanOperation::ExtractRegion,
1263                    "succeeded",
1264                    None,
1265                ));
1266                Ok(TaskExecutionResult {
1267                    task: task.task,
1268                    receipt: TaskExecutionReceipt::from_plan(&plan),
1269                    status: "succeeded".into(),
1270                    phase: "extraction".into(),
1271                    mutation_possible: false,
1272                    source_revision: observation.revision,
1273                    current_revision: extraction.source_revision,
1274                    steps,
1275                    retry: retry_guidance(RetryClassification::SafeImmediate, "inspect_page"),
1276                    form: None,
1277                    extraction: Some(extraction),
1278                    alerts: alert_labels(scoped_regions.iter().copied()),
1279                    dialog: None,
1280                })
1281            }
1282            TaskKind::FormInspect => {
1283                let alerts = alert_labels(scoped_regions.iter().copied());
1284                steps.push(step(
1285                    &plan,
1286                    TaskPlanOperation::InspectForm,
1287                    "succeeded",
1288                    None,
1289                ));
1290                Ok(TaskExecutionResult {
1291                    task: task.task,
1292                    receipt: TaskExecutionReceipt::from_plan(&plan),
1293                    status: "succeeded".into(),
1294                    phase: "inspection".into(),
1295                    mutation_possible: false,
1296                    source_revision: observation.revision,
1297                    current_revision: observation.revision,
1298                    steps,
1299                    retry: retry_guidance(RetryClassification::SafeImmediate, "inspect_page"),
1300                    form: None,
1301                    extraction: None,
1302                    alerts,
1303                    dialog: None,
1304                })
1305            }
1306            TaskKind::FormValidate => {
1307                let alerts = alert_labels(scoped_regions.iter().copied());
1308                let values =
1309                    match bounded(self.observe_with_form_values(), task.limits.timeout_ms).await {
1310                        Ok(values) => values,
1311                        Err(error) => {
1312                            steps.push(step(
1313                                &plan,
1314                                TaskPlanOperation::ValidateForm,
1315                                "verification-failed",
1316                                Some(format!("form validity observation failed: {error}")),
1317                            ));
1318                            return Ok(TaskExecutionResult {
1319                                task: task.task,
1320                                receipt: TaskExecutionReceipt::from_plan(&plan),
1321                                status: "verification-failed".into(),
1322                                phase: "validation".into(),
1323                                mutation_possible: false,
1324                                source_revision: observation.revision,
1325                                current_revision: self
1326                                    .page_revision
1327                                    .load(std::sync::atomic::Ordering::Relaxed),
1328                                steps,
1329                                retry: retry_guidance(
1330                                    RetryClassification::SafeAfterReconcile,
1331                                    "inspect_page",
1332                                ),
1333                                form: None,
1334                                extraction: None,
1335                                dialog: None,
1336                                alerts,
1337                            });
1338                        }
1339                    };
1340                let values_revision = self
1341                    .page_revision
1342                    .load(std::sync::atomic::Ordering::Relaxed);
1343                if values_revision != observation.revision {
1344                    steps.push(step(
1345                        &plan,
1346                        TaskPlanOperation::ValidateForm,
1347                        "stale",
1348                        Some("form value observation crossed revisions".into()),
1349                    ));
1350                    return Ok(TaskExecutionResult {
1351                        task: task.task,
1352                        receipt: TaskExecutionReceipt::from_plan(&plan),
1353                        status: "stale".into(),
1354                        phase: "validation".into(),
1355                        mutation_possible: false,
1356                        source_revision: observation.revision,
1357                        current_revision: values_revision,
1358                        steps,
1359                        retry: retry_guidance(
1360                            RetryClassification::SafeAfterReconcile,
1361                            "inspect_page",
1362                        ),
1363                        form: None,
1364                        extraction: None,
1365                        dialog: None,
1366                        alerts,
1367                    });
1368                }
1369                let validity_deadline =
1370                    Instant::now() + Duration::from_millis(task.limits.timeout_ms);
1371                let mut native_valid = true;
1372                for target in scoped_regions
1373                    .iter()
1374                    .flat_map(|region| region.targets.iter())
1375                {
1376                    let remaining_ms = validity_deadline
1377                        .saturating_duration_since(Instant::now())
1378                        .as_millis()
1379                        .min(u64::MAX as u128) as u64;
1380                    if remaining_ms == 0 {
1381                        native_valid = false;
1382                        break;
1383                    }
1384                    let validity = bounded(
1385                        async { Ok(native_control_validity(self, &target.reference).await) },
1386                        remaining_ms,
1387                    )
1388                    .await
1389                    .ok()
1390                    .flatten();
1391                    native_valid &= validity.is_some_and(|(valid, required, value_missing)| {
1392                        valid && !(required && value_missing)
1393                    });
1394                }
1395                let required_values_present = scoped_regions
1396                    .iter()
1397                    .flat_map(|region| region.targets.iter())
1398                    .all(|target| {
1399                        values
1400                            .accessibility
1401                            .interactive
1402                            .iter()
1403                            .find(|control| control.reference == target.reference)
1404                            .is_some_and(|control| !control.required || !control.empty)
1405                    });
1406                let valid = alerts.is_empty() && native_valid && required_values_present;
1407                steps.push(step(
1408                    &plan,
1409                    TaskPlanOperation::ValidateForm,
1410                    if valid {
1411                        "succeeded"
1412                    } else {
1413                        "verification-failed"
1414                    },
1415                    (!valid).then(|| "native form validity or required state failed".into()),
1416                ));
1417                Ok(TaskExecutionResult {
1418                    task: task.task,
1419                    receipt: TaskExecutionReceipt::from_plan(&plan),
1420                    status: if valid {
1421                        "succeeded"
1422                    } else {
1423                        "verification-failed"
1424                    }
1425                    .into(),
1426                    phase: "validation".into(),
1427                    mutation_possible: false,
1428                    source_revision: observation.revision,
1429                    current_revision: values.accessibility.interactive.first().map_or(
1430                        observation.revision,
1431                        |_| {
1432                            self.page_revision
1433                                .load(std::sync::atomic::Ordering::Relaxed)
1434                        },
1435                    ),
1436                    steps,
1437                    retry: if valid {
1438                        retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
1439                    } else {
1440                        retry_guidance(RetryClassification::RequiresUserDecision, "form.validate")
1441                    },
1442                    form: None,
1443                    extraction: None,
1444                    dialog: None,
1445                    alerts,
1446                })
1447            }
1448            TaskKind::FormFill => {
1449                let fields = match live_bindings.bound_fields(&plan, &task.inputs) {
1450                    Ok(fields) => fields,
1451                    Err(error) => {
1452                        return Ok(preflight_result(
1453                            task,
1454                            &plan,
1455                            observation.revision,
1456                            &error.to_string(),
1457                        ));
1458                    }
1459                };
1460                let borrowed = fields
1461                    .iter()
1462                    .map(|(target, _, value)| (target.as_str(), value.as_str()))
1463                    .collect::<Vec<_>>();
1464                let form = match bounded(
1465                    self.fill_form_with_expected_revision(&borrowed, Some(observation.revision)),
1466                    task.limits.timeout_ms,
1467                )
1468                .await
1469                {
1470                    Ok(form) => form,
1471                    Err(error) => {
1472                        let current_revision = self
1473                            .page_revision
1474                            .load(std::sync::atomic::Ordering::Relaxed);
1475                        return Ok(form_fill_failure_result(
1476                            task,
1477                            &plan,
1478                            observation.revision,
1479                            current_revision,
1480                            steps,
1481                            None,
1482                            error.to_string(),
1483                        ));
1484                    }
1485                };
1486                let after = match bounded(self.inspect_page(), task.limits.timeout_ms).await {
1487                    Ok(after) => after,
1488                    Err(error) => {
1489                        let current_revision = self
1490                            .page_revision
1491                            .load(std::sync::atomic::Ordering::Relaxed);
1492                        return Ok(form_fill_failure_result(
1493                            task,
1494                            &plan,
1495                            observation.revision,
1496                            current_revision,
1497                            steps,
1498                            Some(form),
1499                            error.to_string(),
1500                        ));
1501                    }
1502                };
1503                let values =
1504                    match bounded(self.observe_with_form_values(), task.limits.timeout_ms).await {
1505                        Ok(values) => values,
1506                        Err(error) => {
1507                            let current_revision = self
1508                                .page_revision
1509                                .load(std::sync::atomic::Ordering::Relaxed);
1510                            return Ok(form_fill_failure_result(
1511                                task,
1512                                &plan,
1513                                observation.revision,
1514                                current_revision,
1515                                steps,
1516                                Some(form),
1517                                format!("form fill verification failed: {error}"),
1518                            ));
1519                        }
1520                    };
1521                let verified = form.filled == form.total && form_values_match(&values, &fields);
1522                let current_revision = self
1523                    .page_revision
1524                    .load(std::sync::atomic::Ordering::Relaxed);
1525                steps.push(step(
1526                    &plan,
1527                    TaskPlanOperation::FillInputs,
1528                    if verified {
1529                        "succeeded"
1530                    } else {
1531                        "indeterminate"
1532                    },
1533                    (!verified).then(|| "form values did not match requested values".into()),
1534                ));
1535                Ok(TaskExecutionResult {
1536                    task: task.task,
1537                    receipt: TaskExecutionReceipt::from_plan(&plan),
1538                    status: if verified {
1539                        "succeeded"
1540                    } else {
1541                        "indeterminate"
1542                    }
1543                    .into(),
1544                    phase: "mutation-verification".into(),
1545                    mutation_possible: form.filled > 0,
1546                    source_revision: observation.revision,
1547                    current_revision,
1548                    steps,
1549                    retry: if verified {
1550                        retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
1551                    } else {
1552                        retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run")
1553                    },
1554                    form: Some(form),
1555                    extraction: None,
1556                    dialog: None,
1557                    alerts: alert_labels(after.regions.iter()),
1558                })
1559            }
1560            TaskKind::FormSubmit => {
1561                let Some(submit_name) = task.inputs.get("submit") else {
1562                    return Ok(preflight_result(
1563                        task,
1564                        &plan,
1565                        observation.revision,
1566                        "form.submit requires the semantic submit target in inputs.submit",
1567                    ));
1568                };
1569                let target_reference = match live_bindings.reference_for_name(&plan, submit_name) {
1570                    Ok(reference) => reference,
1571                    Err(error) => {
1572                        return Ok(preflight_result(
1573                            task,
1574                            &plan,
1575                            observation.revision,
1576                            &error.to_string(),
1577                        ));
1578                    }
1579                };
1580                let outcome = bounded(
1581                    self.click_with_revision(target_reference, observation.revision),
1582                    task.limits.timeout_ms,
1583                )
1584                .await;
1585                let after = match bounded(self.inspect_page(), task.limits.timeout_ms).await {
1586                    Ok(after) => after,
1587                    Err(error) => {
1588                        let current_revision = self
1589                            .page_revision
1590                            .load(std::sync::atomic::Ordering::Relaxed);
1591                        return Ok(mutation_failure_result(
1592                            task,
1593                            &plan,
1594                            (observation.revision, current_revision),
1595                            steps,
1596                            TaskPlanOperation::SubmitForm,
1597                            "submit-verification",
1598                            format!("post-action observation failed: {error}"),
1599                        ));
1600                    }
1601                };
1602                let succeeded = outcome.is_ok();
1603                steps.push(step(
1604                    &plan,
1605                    TaskPlanOperation::SubmitForm,
1606                    if succeeded {
1607                        "succeeded"
1608                    } else {
1609                        "indeterminate"
1610                    },
1611                    (!succeeded).then(|| "submit action failed".into()),
1612                ));
1613                Ok(TaskExecutionResult {
1614                    task: task.task,
1615                    receipt: TaskExecutionReceipt::from_plan(&plan),
1616                    status: if succeeded {
1617                        "succeeded"
1618                    } else {
1619                        "indeterminate"
1620                    }
1621                    .into(),
1622                    phase: "submit-verification".into(),
1623                    mutation_possible: true,
1624                    source_revision: observation.revision,
1625                    current_revision: self
1626                        .page_revision
1627                        .load(std::sync::atomic::Ordering::Relaxed)
1628                        .max(after.revision),
1629                    steps,
1630                    retry: if succeeded {
1631                        retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
1632                    } else {
1633                        retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run")
1634                    },
1635                    form: None,
1636                    extraction: None,
1637                    dialog: None,
1638                    alerts: alert_labels(after.regions.iter()),
1639                })
1640            }
1641            _ => unreachable!(),
1642        }
1643    }
1644}
1645
1646impl BrowserSession {
1647    /// Execute a bounded navigation task against one caller-observed revision.
1648    async fn execute_navigation_task_unchecked(
1649        &self,
1650        task: &GlassTask,
1651        expected_revision: u64,
1652        confirmed: bool,
1653    ) -> BrowserResult<TaskExecutionResult> {
1654        let plan = self.compile_live_task(task).await?;
1655        if let Some(detail) = unsupported_runtime_capability(&plan) {
1656            return Ok(preflight_result(task, &plan, expected_revision, detail));
1657        }
1658        if task.task != TaskKind::NavigationFollow {
1659            return Ok(preflight_result(
1660                task,
1661                &plan,
1662                expected_revision,
1663                "navigation execution only supports navigation.follow tasks",
1664            ));
1665        }
1666        if let Some(detail) = compiled_revision_mismatch(&plan, expected_revision) {
1667            return Ok(preflight_result(task, &plan, expected_revision, &detail));
1668        }
1669        let expected_revision = plan.source_ir_revision;
1670        if plan.confirmation_required && !confirmed {
1671            return Ok(preflight_result(
1672                task,
1673                &plan,
1674                expected_revision,
1675                "confirmation is required before this task can navigate the browser",
1676            ));
1677        }
1678        let current_revision = self
1679            .page_revision
1680            .load(std::sync::atomic::Ordering::Relaxed);
1681        if current_revision != expected_revision {
1682            return Ok(preflight_result(
1683                task,
1684                &plan,
1685                current_revision,
1686                "source revision is stale; no browser navigation was dispatched",
1687            ));
1688        }
1689        let Some(url) = task.inputs.get("url") else {
1690            return Ok(preflight_result(
1691                task,
1692                &plan,
1693                expected_revision,
1694                "navigation.follow requires the semantic url input",
1695            ));
1696        };
1697        let mut steps = vec![step(
1698            &plan,
1699            TaskPlanOperation::ObserveScope,
1700            "succeeded",
1701            None,
1702        )];
1703        match bounded(
1704            self.navigate_with_revision(
1705                url,
1706                Duration::from_millis(task.limits.timeout_ms),
1707                expected_revision,
1708            ),
1709            task.limits.timeout_ms,
1710        )
1711        .await
1712        {
1713            Ok(outcome) => {
1714                let verified = navigation_destination_matches(url, &outcome.page.url);
1715                steps.push(step(
1716                    &plan,
1717                    TaskPlanOperation::FollowNavigation,
1718                    if verified {
1719                        "succeeded"
1720                    } else {
1721                        "indeterminate"
1722                    },
1723                    (!verified).then(|| "navigation destination was not verified".into()),
1724                ));
1725                Ok(TaskExecutionResult {
1726                    task: task.task,
1727                    receipt: TaskExecutionReceipt::from_plan(&plan),
1728                    status: if verified {
1729                        "succeeded"
1730                    } else {
1731                        "indeterminate"
1732                    }
1733                    .into(),
1734                    phase: "navigation-verification".into(),
1735                    mutation_possible: true,
1736                    source_revision: expected_revision,
1737                    current_revision: outcome.current_revision,
1738                    steps,
1739                    retry: if verified {
1740                        retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
1741                    } else {
1742                        retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run")
1743                    },
1744                    form: None,
1745                    extraction: None,
1746                    alerts: Vec::new(),
1747                    dialog: None,
1748                })
1749            }
1750            Err(error) => {
1751                steps.push(step(
1752                    &plan,
1753                    TaskPlanOperation::FollowNavigation,
1754                    "indeterminate",
1755                    Some(error.to_string()),
1756                ));
1757                let current_revision = self
1758                    .page_revision
1759                    .load(std::sync::atomic::Ordering::Relaxed);
1760                Ok(TaskExecutionResult {
1761                    task: task.task,
1762                    receipt: TaskExecutionReceipt::from_plan(&plan),
1763                    status: "indeterminate".into(),
1764                    phase: "navigation-verification".into(),
1765                    mutation_possible: true,
1766                    source_revision: expected_revision,
1767                    current_revision,
1768                    steps,
1769                    retry: retry_guidance(
1770                        RetryClassification::UnsafeUntilReconciled,
1771                        "recover_run",
1772                    ),
1773                    form: None,
1774                    extraction: None,
1775                    alerts: Vec::new(),
1776                    dialog: None,
1777                })
1778            }
1779        }
1780    }
1781}
1782
1783impl BrowserSession {
1784    async fn finalize_task_result(
1785        &self,
1786        task: &GlassTask,
1787        mut result: TaskExecutionResult,
1788    ) -> BrowserResult<TaskExecutionResult> {
1789        if result.status == "succeeded" {
1790            let observation = match bounded(self.inspect_page(), task.limits.timeout_ms).await {
1791                Ok(observation) => observation,
1792                Err(error) => {
1793                    let current_revision = self
1794                        .page_revision
1795                        .load(std::sync::atomic::Ordering::Relaxed);
1796                    return Ok(postcondition_failure_result(
1797                        result,
1798                        current_revision,
1799                        format!("postcondition observation failed: {error}"),
1800                    ));
1801                }
1802            };
1803            let regions = match scoped_regions_for_observation(&observation, task) {
1804                Ok(regions) => regions,
1805                Err(_error)
1806                    if matches!(
1807                        task.task,
1808                        TaskKind::NavigationFollow
1809                            | TaskKind::DialogInspect
1810                            | TaskKind::DialogConfirm
1811                            | TaskKind::DialogCancel
1812                    ) =>
1813                {
1814                    Vec::new()
1815                }
1816                Err(error) => {
1817                    return Ok(postcondition_failure_result(
1818                        result,
1819                        self.page_revision
1820                            .load(std::sync::atomic::Ordering::Relaxed)
1821                            .max(observation.revision),
1822                        format!("postcondition scope reconciliation failed: {error}"),
1823                    ));
1824                }
1825            };
1826            let pending_dialog = self.pending_dialog().await;
1827            result.receipt.postconditions = effective_postconditions(task)
1828                .iter()
1829                .map(|postcondition| TaskPostconditionReceipt {
1830                    kind: postcondition.kind,
1831                    held: postcondition_holds(
1832                        postcondition,
1833                        &observation,
1834                        &regions,
1835                        result.source_revision,
1836                        result.extraction.as_ref(),
1837                        pending_dialog.as_ref(),
1838                    ),
1839                })
1840                .collect();
1841            if result
1842                .receipt
1843                .postconditions
1844                .iter()
1845                .any(|postcondition| !postcondition.held)
1846            {
1847                result.status = "indeterminate".into();
1848                result.phase = "postcondition-verification".into();
1849                result.current_revision = self
1850                    .page_revision
1851                    .load(std::sync::atomic::Ordering::Relaxed)
1852                    .max(observation.revision);
1853                result.retry =
1854                    retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run");
1855                if let Some(last) = result.steps.last_mut() {
1856                    last.status = "indeterminate".into();
1857                    last.detail = Some("compiled postcondition did not hold".into());
1858                }
1859            }
1860        }
1861        Ok(result)
1862    }
1863}
1864
1865impl BrowserSession {
1866    /// Execute a validated form task and enforce authored postconditions.
1867    pub async fn execute_form_task(
1868        &self,
1869        task: &GlassTask,
1870        expected_revision: u64,
1871        confirmed: bool,
1872    ) -> BrowserResult<TaskExecutionResult> {
1873        let result = self
1874            .execute_form_task_unchecked(task, expected_revision, confirmed)
1875            .await?;
1876        self.finalize_task_result(task, result).await
1877    }
1878}
1879
1880impl BrowserSession {
1881    /// Execute any currently supported browser-backed Task Protocol family.
1882    pub async fn execute_task(
1883        &self,
1884        task: &GlassTask,
1885        expected_revision: u64,
1886        confirmed: bool,
1887    ) -> BrowserResult<TaskExecutionResult> {
1888        task.validate()?;
1889
1890        let result = match task.task {
1891            TaskKind::NavigationFollow => {
1892                Box::pin(self.execute_navigation_task(task, expected_revision, confirmed)).await?
1893            }
1894            TaskKind::DialogInspect | TaskKind::DialogConfirm | TaskKind::DialogCancel => {
1895                Box::pin(self.execute_dialog_task(task, expected_revision, confirmed)).await?
1896            }
1897            _ => Box::pin(self.execute_form_task(task, expected_revision, confirmed)).await?,
1898        };
1899        Ok(result)
1900    }
1901}
1902
1903impl BrowserSession {
1904    /// Execute a bounded navigation task and enforce authored postconditions.
1905    pub async fn execute_navigation_task(
1906        &self,
1907        task: &GlassTask,
1908        expected_revision: u64,
1909        confirmed: bool,
1910    ) -> BrowserResult<TaskExecutionResult> {
1911        let result = self
1912            .execute_navigation_task_unchecked(task, expected_revision, confirmed)
1913            .await?;
1914        self.finalize_task_result(task, result).await
1915    }
1916}
1917
1918impl BrowserSession {
1919    /// Inspect or resolve one pending JavaScript dialog through the Task Protocol.
1920    async fn execute_dialog_task_unchecked(
1921        &self,
1922        task: &GlassTask,
1923        expected_revision: u64,
1924        confirmed: bool,
1925    ) -> BrowserResult<TaskExecutionResult> {
1926        let plan = self.compile_live_task(task).await?;
1927        if let Some(detail) = unsupported_runtime_capability(&plan) {
1928            return Ok(preflight_result(task, &plan, expected_revision, detail));
1929        }
1930        if !matches!(
1931            task.task,
1932            TaskKind::DialogInspect | TaskKind::DialogConfirm | TaskKind::DialogCancel
1933        ) {
1934            return Ok(preflight_result(
1935                task,
1936                &plan,
1937                expected_revision,
1938                "dialog execution only supports dialog.inspect, dialog.confirm, and dialog.cancel tasks",
1939            ));
1940        }
1941        if let Some(detail) = compiled_revision_mismatch(&plan, expected_revision) {
1942            return Ok(preflight_result(task, &plan, expected_revision, &detail));
1943        }
1944        let expected_revision = plan.source_ir_revision;
1945        if plan.confirmation_required && !confirmed {
1946            return Ok(preflight_result(
1947                task,
1948                &plan,
1949                expected_revision,
1950                "confirmation is required before this dialog task can mutate the browser",
1951            ));
1952        }
1953        let current_revision = self
1954            .page_revision
1955            .load(std::sync::atomic::Ordering::Relaxed);
1956        if current_revision != expected_revision {
1957            return Ok(preflight_result(
1958                task,
1959                &plan,
1960                current_revision,
1961                "source revision is stale; no dialog action was dispatched",
1962            ));
1963        }
1964        let pending = self.pending_dialog().await;
1965        let mut steps = vec![step(
1966            &plan,
1967            TaskPlanOperation::ObserveScope,
1968            "succeeded",
1969            None,
1970        )];
1971        if task.task == TaskKind::DialogInspect {
1972            steps.push(step(
1973                &plan,
1974                TaskPlanOperation::InspectDialog,
1975                "succeeded",
1976                None,
1977            ));
1978            return Ok(TaskExecutionResult {
1979                task: task.task,
1980                receipt: TaskExecutionReceipt::from_plan(&plan),
1981                status: "succeeded".into(),
1982                phase: "dialog-inspection".into(),
1983                mutation_possible: false,
1984                source_revision: expected_revision,
1985                current_revision,
1986                steps,
1987                retry: retry_guidance(RetryClassification::SafeImmediate, "inspect_page"),
1988                form: None,
1989                extraction: None,
1990                dialog: pending.clone(),
1991                alerts: if pending.is_some() {
1992                    vec!["dialog-pending".into()]
1993                } else {
1994                    Vec::new()
1995                },
1996            });
1997        }
1998        if pending.is_none() {
1999            return Ok(preflight_result(
2000                task,
2001                &plan,
2002                current_revision,
2003                "no pending JavaScript dialog is available",
2004            ));
2005        }
2006        let action = match task.task {
2007            TaskKind::DialogConfirm => self.accept_dialog_with_revision(expected_revision).await,
2008            TaskKind::DialogCancel => self.dismiss_dialog_with_revision(expected_revision).await,
2009            _ => unreachable!(),
2010        };
2011        let still_pending = !wait_for_dialog_closed(self, task.limits.timeout_ms).await;
2012        let succeeded = dialog_action_succeeded(&action, still_pending);
2013        let operation = if task.task == TaskKind::DialogConfirm {
2014            TaskPlanOperation::ConfirmDialog
2015        } else {
2016            TaskPlanOperation::CancelDialog
2017        };
2018        steps.push(step(
2019            &plan,
2020            operation,
2021            if succeeded {
2022                "succeeded"
2023            } else {
2024                "indeterminate"
2025            },
2026            (!succeeded).then(|| "dialog outcome was not verified".into()),
2027        ));
2028        let current_revision = self
2029            .page_revision
2030            .load(std::sync::atomic::Ordering::Relaxed);
2031        Ok(TaskExecutionResult {
2032            task: task.task,
2033            receipt: TaskExecutionReceipt::from_plan(&plan),
2034            status: if succeeded {
2035                "succeeded"
2036            } else {
2037                "indeterminate"
2038            }
2039            .into(),
2040            phase: "dialog-verification".into(),
2041            mutation_possible: true,
2042            source_revision: expected_revision,
2043            current_revision,
2044            steps,
2045            retry: if succeeded {
2046                retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
2047            } else {
2048                retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run")
2049            },
2050            form: None,
2051            extraction: None,
2052            dialog: None,
2053            alerts: Vec::new(),
2054        })
2055    }
2056}
2057
2058impl BrowserSession {
2059    /// Execute a dialog task and enforce authored postconditions.
2060    pub async fn execute_dialog_task(
2061        &self,
2062        task: &GlassTask,
2063        expected_revision: u64,
2064        confirmed: bool,
2065    ) -> BrowserResult<TaskExecutionResult> {
2066        let result = self
2067            .execute_dialog_task_unchecked(task, expected_revision, confirmed)
2068            .await?;
2069        self.finalize_task_result(task, result).await
2070    }
2071}
2072
2073fn dialog_action_succeeded(action: &BrowserResult<()>, still_pending: bool) -> bool {
2074    action.is_ok() && !still_pending
2075}
2076
2077fn step(
2078    plan: &TaskExecutionPlan,
2079    operation: TaskPlanOperation,
2080    status: &str,
2081    detail: Option<String>,
2082) -> TaskStepResult {
2083    let ordinal = plan
2084        .steps
2085        .iter()
2086        .find(|candidate| candidate.operation == operation)
2087        .map_or(0, |candidate| candidate.ordinal);
2088    TaskStepResult {
2089        ordinal,
2090        operation,
2091        status: status.into(),
2092        detail,
2093    }
2094}
2095
2096fn form_fill_failure_result(
2097    task: &GlassTask,
2098    plan: &TaskExecutionPlan,
2099    source_revision: u64,
2100    current_revision: u64,
2101    mut steps: Vec<TaskStepResult>,
2102    form: Option<FillFormOutcome>,
2103    detail: String,
2104) -> TaskExecutionResult {
2105    steps.push(step(
2106        plan,
2107        TaskPlanOperation::FillInputs,
2108        "indeterminate",
2109        Some(detail),
2110    ));
2111    TaskExecutionResult {
2112        task: task.task,
2113        receipt: TaskExecutionReceipt::from_plan(plan),
2114        status: "indeterminate".into(),
2115        phase: "mutation-verification".into(),
2116        mutation_possible: true,
2117        source_revision,
2118        current_revision,
2119        steps,
2120        retry: retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run"),
2121        form,
2122        extraction: None,
2123        dialog: None,
2124        alerts: Vec::new(),
2125    }
2126}
2127async fn wait_for_dialog_closed(session: &BrowserSession, timeout_ms: u64) -> bool {
2128    let deadline = tokio::time::Instant::now() + Duration::from_millis(timeout_ms);
2129    loop {
2130        if session.pending_dialog().await.is_none() {
2131            return true;
2132        }
2133        let now = tokio::time::Instant::now();
2134        if now >= deadline {
2135            return false;
2136        }
2137        tokio::time::sleep((deadline - now).min(Duration::from_millis(10))).await;
2138    }
2139}
2140
2141fn mutation_failure_result(
2142    task: &GlassTask,
2143    plan: &TaskExecutionPlan,
2144    revisions: (u64, u64),
2145    mut steps: Vec<TaskStepResult>,
2146    operation: TaskPlanOperation,
2147    phase: &str,
2148    detail: impl Into<String>,
2149) -> TaskExecutionResult {
2150    steps.push(step(plan, operation, "indeterminate", Some(detail.into())));
2151    TaskExecutionResult {
2152        task: task.task,
2153        receipt: TaskExecutionReceipt::from_plan(plan),
2154        status: "indeterminate".into(),
2155        phase: phase.into(),
2156        mutation_possible: true,
2157        source_revision: revisions.0,
2158        current_revision: revisions.1,
2159        steps,
2160        retry: retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run"),
2161        form: None,
2162        extraction: None,
2163        dialog: None,
2164        alerts: Vec::new(),
2165    }
2166}
2167fn postcondition_failure_result(
2168    mut result: TaskExecutionResult,
2169    current_revision: u64,
2170    detail: impl Into<String>,
2171) -> TaskExecutionResult {
2172    result.status = "indeterminate".into();
2173    result.phase = "postcondition-verification".into();
2174    result.current_revision = current_revision;
2175    result.retry = retry_guidance(
2176        if result.mutation_possible {
2177            RetryClassification::UnsafeUntilReconciled
2178        } else {
2179            RetryClassification::SafeAfterReconcile
2180        },
2181        if result.mutation_possible {
2182            "recover_run"
2183        } else {
2184            "inspect_page"
2185        },
2186    );
2187    if let Some(last) = result.steps.last_mut() {
2188        last.status = "indeterminate".into();
2189        last.detail = Some(detail.into());
2190    }
2191    result
2192}
2193
2194async fn aria_boolean_state(
2195    session: &BrowserSession,
2196    reference: &str,
2197    attribute: &str,
2198) -> Option<bool> {
2199    let reference = parse_revisioned_reference(reference).ok().flatten()?;
2200    let object_id = session
2201        .cdp
2202        .resolve_node_object(None, Some(reference.backend_dom_node_id))
2203        .await
2204        .ok()?;
2205    let function = format!(
2206        "function(){{const value=this.getAttribute({attribute:?});return value === null ? null : value === 'true';}}"
2207    );
2208    let result = session
2209        .cdp
2210        .send(
2211            "Runtime.callFunctionOn",
2212            Some(json!({
2213                "objectId": object_id,
2214                "functionDeclaration": function,
2215                "returnByValue": true,
2216                "awaitPromise": false,
2217            })),
2218        )
2219        .await
2220        .ok();
2221    let _ = session
2222        .cdp
2223        .send(
2224            "Runtime.releaseObject",
2225            Some(json!({"objectId": object_id})),
2226        )
2227        .await;
2228    result
2229        .as_ref()
2230        .and_then(|value| value["result"]["value"].as_bool())
2231}
2232
2233fn navigation_destination_matches(requested: &str, actual: &str) -> bool {
2234    let requested = requested.split('#').next().unwrap_or(requested);
2235    let actual = actual.split('#').next().unwrap_or(actual);
2236    requested == actual || requested.trim_end_matches('/') == actual.trim_end_matches('/')
2237}
2238
2239async fn native_control_validity(
2240    session: &BrowserSession,
2241    reference: &str,
2242) -> Option<(bool, bool, bool)> {
2243    let reference = parse_revisioned_reference(reference).ok().flatten()?;
2244    let object_id = session
2245        .cdp
2246        .resolve_node_object(None, Some(reference.backend_dom_node_id))
2247        .await
2248        .ok()?;
2249    let result = session
2250        .cdp
2251        .send(
2252            "Runtime.callFunctionOn",
2253            Some(json!({
2254                "objectId": object_id,
2255                "functionDeclaration": "function(){const validity=this.validity;return {valid: validity ? validity.valid : true, required: !!this.required, valueMissing: !!(validity && validity.valueMissing)};}",
2256                "returnByValue": true,
2257                "awaitPromise": false,
2258            })),
2259        )
2260        .await
2261        .ok();
2262    let _ = session
2263        .cdp
2264        .send(
2265            "Runtime.releaseObject",
2266            Some(json!({"objectId": object_id})),
2267        )
2268        .await;
2269    let result = result?;
2270    let value = result.get("result")?.get("value")?;
2271    Some((
2272        value.get("valid")?.as_bool()?,
2273        value.get("required")?.as_bool()?,
2274        value.get("valueMissing")?.as_bool()?,
2275    ))
2276}
2277
2278async fn wait_for_aria_true(
2279    session: &BrowserSession,
2280    reference: &str,
2281    attribute: &str,
2282    timeout_ms: u64,
2283) -> bool {
2284    let deadline = tokio::time::Instant::now() + Duration::from_millis(timeout_ms);
2285    loop {
2286        if aria_boolean_state(session, reference, attribute).await == Some(true) {
2287            return true;
2288        }
2289        let now = tokio::time::Instant::now();
2290        if now >= deadline {
2291            return false;
2292        }
2293        tokio::time::sleep((deadline - now).min(Duration::from_millis(10))).await;
2294    }
2295}
2296
2297async fn wait_for_semantic_page_change(
2298    session: &BrowserSession,
2299    before: &InspectPageResult,
2300    mut after: InspectPageResult,
2301    timeout_ms: u64,
2302) -> BrowserResult<InspectPageResult> {
2303    if semantic_page_changed(before, &after) {
2304        return Ok(after);
2305    }
2306    let deadline = tokio::time::Instant::now() + Duration::from_millis(timeout_ms);
2307    loop {
2308        let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
2309        if remaining.is_zero() {
2310            return Ok(after);
2311        }
2312        tokio::time::sleep(remaining.min(Duration::from_millis(10))).await;
2313        after = match tokio::time::timeout(remaining, session.inspect_page()).await {
2314            Ok(Ok(next)) => next,
2315            _ => return Ok(after),
2316        };
2317        if semantic_page_changed(before, &after) {
2318            return Ok(after);
2319        }
2320    }
2321}
2322
2323fn retry_guidance(classification: RetryClassification, operation: &str) -> RetryGuidance {
2324    RetryGuidance {
2325        classification,
2326        recommended_operation: operation.into(),
2327    }
2328}
2329
2330fn compiled_revision_mismatch(plan: &TaskExecutionPlan, caller_revision: u64) -> Option<String> {
2331    let regression = plan.source_ir_revision < caller_revision;
2332    let incompatible_drift = match plan.revision {
2333        TaskRevisionPolicy::Exact => plan.source_ir_revision != caller_revision,
2334        TaskRevisionPolicy::Compatible => {
2335            plan.source_ir_revision != caller_revision && plan.risk != TaskRiskClass::ReadOnly
2336        }
2337        TaskRevisionPolicy::Reextract => false,
2338    };
2339    (regression || incompatible_drift).then(|| {
2340        format!(
2341            "compiled Web IR revision {} is not safe for caller-observed revision {} under {:?} policy; no browser action was dispatched",
2342            plan.source_ir_revision, caller_revision, plan.revision
2343        )
2344    })
2345}
2346
2347fn preflight_result(
2348    task: &GlassTask,
2349    plan: &TaskExecutionPlan,
2350    revision: u64,
2351    detail: &str,
2352) -> TaskExecutionResult {
2353    TaskExecutionResult {
2354        task: task.task,
2355        receipt: TaskExecutionReceipt::from_plan(plan),
2356        status: "preflight-failed".into(),
2357        phase: "preflight".into(),
2358        mutation_possible: false,
2359        source_revision: revision,
2360        current_revision: revision,
2361        steps: plan
2362            .steps
2363            .iter()
2364            .map(|step| TaskStepResult {
2365                ordinal: step.ordinal,
2366                operation: step.operation,
2367                status: "not-run".into(),
2368                detail: Some(detail.into()),
2369            })
2370            .collect(),
2371        retry: retry_guidance(RetryClassification::SafeAfterReobserve, "inspect_page"),
2372        form: None,
2373        alerts: Vec::new(),
2374        extraction: None,
2375        dialog: None,
2376    }
2377}
2378
2379impl BrowserSession {
2380    async fn execute_open_menu_task(
2381        &self,
2382        task: &GlassTask,
2383        plan: &TaskExecutionPlan,
2384        observation: &InspectPageResult,
2385        live_bindings: &LiveTaskBindings,
2386    ) -> BrowserResult<TaskExecutionResult> {
2387        let Some(menu_name) = task.inputs.get("menu") else {
2388            return Ok(preflight_result(
2389                task,
2390                plan,
2391                observation.revision,
2392                "navigation.openMenu requires the semantic menu input",
2393            ));
2394        };
2395        let target_reference = match live_bindings.reference_for_name(plan, menu_name) {
2396            Ok(reference) => reference,
2397            Err(error) => {
2398                return Ok(preflight_result(task, plan, observation.revision, &error));
2399            }
2400        };
2401        let outcome = bounded(
2402            self.click_with_revision(target_reference, observation.revision),
2403            task.limits.timeout_ms,
2404        )
2405        .await;
2406        let after = match bounded(self.inspect_page(), task.limits.timeout_ms).await {
2407            Ok(after) => after,
2408            Err(error) => {
2409                let current_revision = self
2410                    .page_revision
2411                    .load(std::sync::atomic::Ordering::Relaxed);
2412                return Ok(mutation_failure_result(
2413                    task,
2414                    plan,
2415                    (observation.revision, current_revision),
2416                    vec![step(
2417                        plan,
2418                        TaskPlanOperation::ObserveScope,
2419                        "succeeded",
2420                        None,
2421                    )],
2422                    TaskPlanOperation::OpenMenu,
2423                    "navigation-verification",
2424                    format!("post-action observation failed: {error}"),
2425                ));
2426            }
2427        };
2428        let menu_open = wait_for_aria_true(
2429            self,
2430            target_reference,
2431            "aria-expanded",
2432            task.limits.timeout_ms,
2433        )
2434        .await;
2435        let succeeded = outcome.is_ok() && menu_open;
2436        let detail = if let Err(error) = &outcome {
2437            Some(format!("menu control click was not dispatched: {error}"))
2438        } else if !menu_open {
2439            Some("menu expanded state was not observed after the click".into())
2440        } else {
2441            None
2442        };
2443        let steps = vec![
2444            step(plan, TaskPlanOperation::ObserveScope, "succeeded", None),
2445            step(
2446                plan,
2447                TaskPlanOperation::OpenMenu,
2448                if succeeded {
2449                    "succeeded"
2450                } else {
2451                    "indeterminate"
2452                },
2453                detail,
2454            ),
2455        ];
2456        Ok(TaskExecutionResult {
2457            task: task.task,
2458            receipt: TaskExecutionReceipt::from_plan(plan),
2459            status: if succeeded {
2460                "succeeded"
2461            } else {
2462                "indeterminate"
2463            }
2464            .into(),
2465            phase: "mutation-verification".into(),
2466            mutation_possible: outcome.is_ok(),
2467            source_revision: observation.revision,
2468            current_revision: self
2469                .page_revision
2470                .load(std::sync::atomic::Ordering::Relaxed)
2471                .max(after.revision),
2472            steps,
2473            retry: if succeeded {
2474                retry_guidance(RetryClassification::SafeImmediate, "inspect_page")
2475            } else {
2476                retry_guidance(RetryClassification::UnsafeUntilReconciled, "recover_run")
2477            },
2478            form: None,
2479            extraction: None,
2480            dialog: None,
2481            alerts: alert_labels(after.regions.iter()),
2482        })
2483    }
2484}
2485
2486fn scoped_regions_for_observation<'a>(
2487    observation: &'a InspectPageResult,
2488    task: &GlassTask,
2489) -> BrowserResult<Vec<&'a SemanticRegion>> {
2490    let Some(region_name) = task.scope.region_name.as_deref() else {
2491        return Err("browser-backed task requires a semantic region scope".into());
2492    };
2493    let regions = observation
2494        .regions
2495        .iter()
2496        .filter(|region| {
2497            region.label.eq_ignore_ascii_case(region_name)
2498                && task
2499                    .scope
2500                    .entity_kind
2501                    .is_none_or(|kind| semantic_region_matches_entity(region, kind))
2502                && task.scope.entity_name.as_deref().is_none_or(|entity_name| {
2503                    region.label.eq_ignore_ascii_case(entity_name)
2504                        || region
2505                            .targets
2506                            .iter()
2507                            .any(|target| target.name.eq_ignore_ascii_case(entity_name))
2508                })
2509        })
2510        .collect::<Vec<_>>();
2511    match regions.len() {
2512        1 => Ok(regions),
2513        0 => Err(format!("semantic region not found: {region_name}").into()),
2514        _ => Err(format!("semantic region is ambiguous: {region_name}").into()),
2515    }
2516}
2517
2518fn semantic_region_matches_entity(
2519    region: &SemanticRegion,
2520    kind: crate::web_ir::WebIrEntityKind,
2521) -> bool {
2522    use crate::web_ir::WebIrEntityKind;
2523    match kind {
2524        WebIrEntityKind::Page
2525        | WebIrEntityKind::Region
2526        | WebIrEntityKind::OpaqueRegion
2527        | WebIrEntityKind::UnknownInteractive => true,
2528        WebIrEntityKind::Form => region.kind == SemanticRegionKind::Form,
2529        WebIrEntityKind::Dialog => region.kind == SemanticRegionKind::Dialog,
2530        WebIrEntityKind::Table => region.kind == SemanticRegionKind::Table,
2531        WebIrEntityKind::Collection => region.kind == SemanticRegionKind::Collection,
2532        WebIrEntityKind::PaginationControl => region.kind == SemanticRegionKind::Pagination,
2533        WebIrEntityKind::Field => region.targets.iter().any(|target| {
2534            target.input_type.is_some()
2535                || matches!(target.role.as_str(), "textbox" | "combobox" | "listbox")
2536        }),
2537        WebIrEntityKind::Action => region.targets.iter().any(|target| {
2538            matches!(
2539                target.role.as_str(),
2540                "button" | "checkbox" | "radio" | "switch" | "menuitem"
2541            )
2542        }),
2543        WebIrEntityKind::Link => region.targets.iter().any(|target| target.role == "link"),
2544        WebIrEntityKind::NavigationItem => region.kind == SemanticRegionKind::Navigation,
2545        WebIrEntityKind::Tab => region.targets.iter().any(|target| target.role == "tab"),
2546        WebIrEntityKind::Row | WebIrEntityKind::Cell | WebIrEntityKind::CollectionItem => true,
2547        WebIrEntityKind::Text => true,
2548        WebIrEntityKind::Frame | WebIrEntityKind::ShadowRoot | WebIrEntityKind::Probe => false,
2549    }
2550}
2551fn form_values_match(values: &super::PageContext, fields: &[(String, String, String)]) -> bool {
2552    fields.iter().all(|(reference, name, expected)| {
2553        let Some(control) = values.accessibility.interactive.iter().find(|control| {
2554            control.reference == *reference || control.name.eq_ignore_ascii_case(name)
2555        }) else {
2556            return false;
2557        };
2558        if matches!(control.role.as_str(), "checkbox" | "radio")
2559            || control
2560                .input_type
2561                .as_deref()
2562                .is_some_and(|input_type| matches!(input_type, "checkbox" | "radio"))
2563        {
2564            let expected_checked =
2565                !expected.is_empty() && expected != "false" && expected != "0" && expected != "off";
2566            control.checked == Some(expected_checked)
2567        } else if matches!(control.role.as_str(), "combobox" | "listbox") {
2568            control.selected_option.as_deref() == Some(expected.as_str())
2569                || control.value.as_deref() == Some(expected.as_str())
2570        } else {
2571            control.value.as_deref() == Some(expected.as_str())
2572        }
2573    })
2574}
2575
2576fn pagination_next_is_usable(regions: &[&SemanticRegion], next_name: &str) -> bool {
2577    regions
2578        .iter()
2579        .flat_map(|region| region.targets.iter())
2580        .any(|target| {
2581            target.name.eq_ignore_ascii_case(next_name)
2582                && matches!(target.role.as_str(), "button" | "link" | "tab")
2583        })
2584}
2585fn merge_pagination_extraction(
2586    aggregate: &mut Option<StructuredExtractionResult>,
2587    page: StructuredExtractionResult,
2588    max_items: usize,
2589    max_bytes: usize,
2590) {
2591    let Some(result) = aggregate.as_mut() else {
2592        let mut initial = page;
2593        let observed_items = initial.limits.observed_items;
2594        let mut seen = std::collections::BTreeSet::new();
2595        let mut items = Vec::new();
2596        for item in initial.record_items.drain(..) {
2597            let duplicate = item
2598                .entity_ids
2599                .first()
2600                .is_some_and(|entity_id| !seen.insert(entity_id.clone()));
2601            if duplicate {
2602                continue;
2603            }
2604            items.push(item);
2605            if items.len() >= max_items {
2606                break;
2607            }
2608        }
2609        initial.record_items = items;
2610        initial.truncated |= initial.record_items.len() < observed_items;
2611        initial.limits.observed_items = initial.record_items.len();
2612        initial.limits.truncated = initial.truncated;
2613        initial.limits.serialized_bytes =
2614            serde_json::to_vec(&initial).map_or(0, |bytes| bytes.len());
2615        *aggregate = Some(initial);
2616        return;
2617    };
2618    result.truncated |= page.truncated;
2619    if page.continuation.is_some() {
2620        result.continuation = page.continuation;
2621    }
2622    result.source_revision = page.source_revision;
2623    result.source_route = page.source_route;
2624    let mut seen = result
2625        .record_items
2626        .iter()
2627        .filter_map(|item| item.entity_ids.first().cloned())
2628        .collect::<std::collections::BTreeSet<_>>();
2629    for item in page.record_items {
2630        if result.record_items.len() >= max_items {
2631            result.truncated = true;
2632            break;
2633        }
2634        let duplicate = item
2635            .entity_ids
2636            .first()
2637            .is_some_and(|entity_id| !seen.insert(entity_id.clone()));
2638        if duplicate {
2639            continue;
2640        }
2641        result.record_items.push(StructuredExtractionRecord {
2642            index: result.record_items.len(),
2643            ..item
2644        });
2645        if serde_json::to_vec(result).is_ok_and(|bytes| bytes.len() > max_bytes) {
2646            result.record_items.pop();
2647            result.truncated = true;
2648            break;
2649        }
2650    }
2651    result.limits.observed_items = result.record_items.len();
2652    result.limits.serialized_bytes = serde_json::to_vec(result).map_or(0, |bytes| bytes.len());
2653    result.limits.truncated = result.truncated;
2654}
2655
2656fn extraction_matches_observation(
2657    extraction: &StructuredExtractionResult,
2658    observation: &InspectPageResult,
2659) -> bool {
2660    extraction.source_revision == observation.revision
2661        && extraction.source_route.target_id == observation.page.target_id
2662        && extraction.source_route.frame_id == observation.page.frame_id
2663        && diagnostic_route_url(&extraction.source_route.url)
2664            == diagnostic_route_url(&observation.page.url)
2665}
2666
2667fn diagnostic_route_url(url: &str) -> String {
2668    let Ok(mut parsed) = url::Url::parse(url) else {
2669        return url.split(['?', '#']).next().unwrap_or_default().to_owned();
2670    };
2671    let _ = parsed.set_username("");
2672    let _ = parsed.set_password(None);
2673    parsed.set_query(None);
2674    parsed.set_fragment(None);
2675    parsed.to_string()
2676}
2677
2678fn semantic_page_changed(before: &InspectPageResult, after: &InspectPageResult) -> bool {
2679    before.page.kind != after.page.kind
2680        || before.page.title != after.page.title
2681        || before.page.url != after.page.url
2682        || before.page.target_id != after.page.target_id
2683        || before.page.frame_id != after.page.frame_id
2684        || before.page.confidence != after.page.confidence
2685        || before.page.evidence != after.page.evidence
2686        || semantic_regions_changed(&before.regions, &after.regions)
2687}
2688
2689fn semantic_regions_changed(before: &[SemanticRegion], after: &[SemanticRegion]) -> bool {
2690    before.len() != after.len()
2691        || before.iter().zip(after).any(|(before, after)| {
2692            before.id != after.id
2693                || before.kind != after.kind
2694                || before.label != after.label
2695                || before.interactive_count != after.interactive_count
2696                || before.item_count != after.item_count
2697                || before.confidence != after.confidence
2698                || before.structured_records != after.structured_records
2699                || before.evidence != after.evidence
2700                || before.targets.len() != after.targets.len()
2701                || before
2702                    .targets
2703                    .iter()
2704                    .zip(&after.targets)
2705                    .any(|(before, after)| {
2706                        before.role != after.role
2707                            || before.name != after.name
2708                            || before.input_type != after.input_type
2709                    })
2710        })
2711}
2712
2713fn alert_labels<'a, I>(regions: I) -> Vec<String>
2714where
2715    I: IntoIterator<Item = &'a SemanticRegion>,
2716{
2717    regions
2718        .into_iter()
2719        .filter(|region| matches!(region.kind, super::SemanticRegionKind::Alert))
2720        .map(|region| region.label.clone())
2721        .collect()
2722}
2723fn unsupported_runtime_capability(plan: &TaskExecutionPlan) -> Option<&'static str> {
2724    const SUPPORTED: &[TaskRuntimeCapability] = &[
2725        TaskRuntimeCapability::Observe,
2726        TaskRuntimeCapability::Read,
2727        TaskRuntimeCapability::Mutate,
2728        TaskRuntimeCapability::Navigate,
2729        TaskRuntimeCapability::Extract,
2730        TaskRuntimeCapability::Dialog,
2731        TaskRuntimeCapability::Pagination,
2732        TaskRuntimeCapability::VerifyEntityState,
2733    ];
2734    plan.required_runtime_capabilities
2735        .iter()
2736        .find(|capability| !SUPPORTED.contains(capability))
2737        .map(|_| "compiled plan requires a capability unsupported by this browser runtime")
2738}
2739
2740fn postcondition_holds(
2741    postcondition: &crate::task_protocol::TaskPostcondition,
2742    observation: &InspectPageResult,
2743    _regions: &[&SemanticRegion],
2744    source_revision: u64,
2745    extraction: Option<&StructuredExtractionResult>,
2746    dialog: Option<&PendingDialog>,
2747) -> bool {
2748    match postcondition.kind {
2749        TaskPostconditionKind::ValidationClear => {
2750            alert_labels(observation.regions.iter()).is_empty()
2751        }
2752        TaskPostconditionKind::RegionPresent => {
2753            postcondition.expected.as_ref().is_some_and(|expected| {
2754                observation
2755                    .regions
2756                    .iter()
2757                    .any(|region| region.label.eq_ignore_ascii_case(expected))
2758            })
2759        }
2760        TaskPostconditionKind::NavigationOccurred => observation.revision > source_revision,
2761        TaskPostconditionKind::PageKind => postcondition.expected.as_ref().is_none_or(|expected| {
2762            format!("{:?}", observation.page.kind).eq_ignore_ascii_case(expected)
2763        }),
2764        TaskPostconditionKind::DialogClosed => dialog.is_none(),
2765        TaskPostconditionKind::RecordsExtracted => extraction.is_some_and(|result| {
2766            postcondition.expected.as_ref().is_none_or(|expected| {
2767                expected
2768                    .parse::<usize>()
2769                    .ok()
2770                    .is_some_and(|minimum| result.record_items.len() >= minimum)
2771            })
2772        }),
2773        TaskPostconditionKind::EntityState => postcondition
2774            .expected
2775            .as_deref()
2776            .is_some_and(|expected| entity_state_holds(observation, expected)),
2777    }
2778}
2779
2780fn entity_state_holds(observation: &InspectPageResult, expected: &str) -> bool {
2781    let Some((selector, expected_value)) = expected.rsplit_once('=') else {
2782        return false;
2783    };
2784    let Some((entity_name, state)) = selector.rsplit_once('.') else {
2785        return false;
2786    };
2787    let Some(expected_value) = (match expected_value {
2788        "true" => Some(true),
2789        "false" => Some(false),
2790        _ => None,
2791    }) else {
2792        return false;
2793    };
2794    let candidates = observation
2795        .regions
2796        .iter()
2797        .flat_map(|region| &region.targets)
2798        .filter(|target| target.name.eq_ignore_ascii_case(entity_name))
2799        .collect::<Vec<_>>();
2800    let [target] = candidates.as_slice() else {
2801        return false;
2802    };
2803    let observed = match state {
2804        "disabled" => target.disabled,
2805        "readOnly" => target.read_only,
2806        "required" => target.required,
2807        "checked" => target.checked,
2808        "empty" => target.empty,
2809        _ => None,
2810    };
2811    observed == Some(expected_value)
2812}
2813fn remaining_timeout(deadline: tokio::time::Instant) -> u64 {
2814    deadline
2815        .saturating_duration_since(tokio::time::Instant::now())
2816        .as_millis()
2817        .clamp(1, u64::MAX as u128) as u64
2818}
2819
2820async fn bounded<T, F>(future: F, timeout_ms: u64) -> BrowserResult<T>
2821where
2822    F: Future<Output = BrowserResult<T>>,
2823{
2824    tokio::time::timeout(Duration::from_millis(timeout_ms), future)
2825        .await
2826        .map_err(|_| {
2827            Box::new(IoError::new(
2828                ErrorKind::TimedOut,
2829                "task execution exceeded its timeout budget",
2830            )) as Box<dyn std::error::Error>
2831        })?
2832}
2833
2834#[cfg(test)]
2835mod tests {
2836    use super::*;
2837    use crate::browser::session::{
2838        SemanticConfidence, SemanticPage, SemanticPageKind, SemanticRegionKind,
2839        SemanticStructuredRecord, SemanticTarget,
2840    };
2841    use crate::task_protocol::{
2842        TASK_PROTOCOL_SCHEMA_VERSION, TaskAmbiguityPolicy, TaskLimits, TaskRiskClass, TaskScope,
2843    };
2844    use std::collections::BTreeMap;
2845
2846    fn target(name: &str, reference: &str) -> SemanticTarget {
2847        SemanticTarget {
2848            reference: reference.into(),
2849            role: "textbox".into(),
2850            name: name.into(),
2851            input_type: Some("text".into()),
2852            disabled: None,
2853            read_only: None,
2854            required: None,
2855            checked: None,
2856            empty: None,
2857        }
2858    }
2859
2860    fn region(label: &str, targets: Vec<SemanticTarget>) -> SemanticRegion {
2861        SemanticRegion {
2862            id: label.into(),
2863            kind: SemanticRegionKind::Form,
2864            label: label.into(),
2865            interactive_count: targets.len(),
2866            item_count: None,
2867            structured_records: Vec::new(),
2868            confidence: SemanticConfidence::Exact,
2869            evidence: Vec::new(),
2870            targets,
2871            expansion: None,
2872        }
2873    }
2874
2875    fn observation(revision: u64, regions: Vec<SemanticRegion>) -> InspectPageResult {
2876        InspectPageResult {
2877            page: SemanticPage {
2878                kind: SemanticPageKind::Form,
2879                title: "Checkout".into(),
2880                url: "https://example.test/checkout".into(),
2881                target_id: "page".into(),
2882                frame_id: "frame".into(),
2883                confidence: SemanticConfidence::Exact,
2884                evidence: Vec::new(),
2885            },
2886            revision,
2887            regions,
2888            limits: Default::default(),
2889            focused_target: None,
2890            alerts: Vec::new(),
2891        }
2892    }
2893
2894    #[test]
2895    fn pagination_noop_with_usable_next_is_not_terminal() {
2896        let mut next = target("Next", "next");
2897        next.role = "button".into();
2898        let page = region("Results", vec![next]);
2899
2900        assert!(pagination_next_is_usable(&[&page], "next"));
2901    }
2902
2903    #[test]
2904    fn pagination_noop_with_disappeared_next_is_terminal() {
2905        let page = region("Results", Vec::new());
2906
2907        assert!(!pagination_next_is_usable(&[&page], "Next"));
2908    }
2909
2910    #[test]
2911    fn structured_record_changes_count_as_page_changes() {
2912        let before = region("Results", Vec::new());
2913        let mut after = before.clone();
2914        assert!(!semantic_regions_changed(
2915            std::slice::from_ref(&before),
2916            std::slice::from_ref(&after)
2917        ));
2918        after.structured_records.push(SemanticStructuredRecord {
2919            fields: BTreeMap::from([("Status".into(), "Ready".into())]),
2920        });
2921        assert!(semantic_regions_changed(
2922            std::slice::from_ref(&before),
2923            std::slice::from_ref(&after)
2924        ));
2925    }
2926
2927    fn task() -> GlassTask {
2928        GlassTask {
2929            schema_version: TASK_PROTOCOL_SCHEMA_VERSION,
2930            task: TaskKind::FormFill,
2931            scope: TaskScope {
2932                region_name: Some("Checkout".into()),
2933
2934                ..TaskScope::default()
2935            },
2936            inputs: BTreeMap::from([(String::from("Email"), String::from("a@example.test"))]),
2937            limits: TaskLimits::default(),
2938            risk: TaskRiskClass::LocalMutation,
2939            ambiguity: TaskAmbiguityPolicy::Fail,
2940            revision: Default::default(),
2941            postconditions: Vec::new(),
2942        }
2943    }
2944
2945    #[test]
2946    fn entity_state_postcondition_is_verified_from_one_unique_target() {
2947        let mut authored = task();
2948        authored.postconditions = vec![crate::task_protocol::TaskPostcondition {
2949            kind: TaskPostconditionKind::EntityState,
2950            expected: Some("Email.checked=true".into()),
2951        }];
2952        authored.validate().unwrap();
2953        let mut checked = target("Email", "r7:b1");
2954        checked.checked = Some(true);
2955        let observation = observation(7, vec![region("Checkout", vec![checked])]);
2956        assert!(entity_state_holds(&observation, "Email.checked=true"));
2957        assert!(!entity_state_holds(&observation, "Email.checked=false"));
2958    }
2959
2960    #[test]
2961    fn task_retry_guidance_uses_canonical_recovery_shape() {
2962        let value = serde_json::to_value(retry_guidance(
2963            RetryClassification::UnsafeUntilReconciled,
2964            "recover_run",
2965        ))
2966        .unwrap();
2967        assert_eq!(value["classification"], "unsafeUntilReconciled");
2968        assert_eq!(value["recommendedOperation"], "recover_run");
2969    }
2970
2971    #[test]
2972    fn live_bindings_fail_closed_without_collecting_duplicate_candidates() {
2973        let authored = task();
2974        let plan = compile_task(&authored, &crate::task_compiler::test_compiler_ir()).unwrap();
2975        let unique = region("Checkout", vec![target("Email", "r7:b1")]);
2976        let bindings = LiveTaskBindings::resolve(&plan, &[&unique], 7).unwrap();
2977        assert_eq!(
2978            bindings.reference_for_name(&plan, "Email").unwrap(),
2979            "r7:b1"
2980        );
2981
2982        let duplicate = region(
2983            "Checkout",
2984            vec![target("Email", "r7:b1"), target("Email", "r7:b2")],
2985        );
2986        let error = LiveTaskBindings::resolve(&plan, &[&duplicate], 7)
2987            .err()
2988            .expect("duplicate binding must fail");
2989        assert!(error.contains("multiple revision-bound browser targets"));
2990
2991        let missing = region("Checkout", Vec::new());
2992        let error = LiveTaskBindings::resolve(&plan, &[&missing], 7)
2993            .err()
2994            .expect("missing binding must fail");
2995        assert!(error.contains("did not resolve to exactly one"));
2996    }
2997
2998    #[test]
2999    fn form_fill_failure_returns_recovery_result() {
3000        let task = task();
3001        let plan = compile_task(&task, &crate::task_compiler::test_compiler_ir()).unwrap();
3002        let result = form_fill_failure_result(
3003            &task,
3004            &plan,
3005            7,
3006            8,
3007            Vec::new(),
3008            None,
3009            "task execution exceeded its timeout budget".into(),
3010        );
3011        assert_eq!(result.status, "indeterminate");
3012        assert!(result.mutation_possible);
3013        assert_eq!(result.current_revision, 8);
3014        assert_eq!(result.steps[0].status, "indeterminate");
3015        assert_eq!(
3016            result.retry.classification,
3017            RetryClassification::UnsafeUntilReconciled
3018        );
3019    }
3020
3021    #[test]
3022    fn execution_receipt_never_serializes_authored_values_or_browser_references() {
3023        let mut task = task();
3024        task.inputs
3025            .insert("Email".into(), "private@example.test".into());
3026        let plan = compile_task(&task, &crate::task_compiler::test_compiler_ir()).unwrap();
3027        let encoded = serde_json::to_string(&TaskExecutionReceipt::from_plan(&plan)).unwrap();
3028        assert!(!encoded.contains("private@example.test"));
3029        assert!(!encoded.contains("r7:"));
3030        assert!(encoded.contains("bindingCandidateEntityIds"));
3031    }
3032
3033    #[test]
3034    fn stale_dialog_action_is_indeterminate_without_dialog_payload() {
3035        let action: BrowserResult<()> = Err("stale revision".into());
3036        assert!(!dialog_action_succeeded(&action, true));
3037
3038        let mut task = task();
3039        task.task = TaskKind::DialogConfirm;
3040        task.inputs.clear();
3041        let plan = compile_task(&task, &crate::task_compiler::test_compiler_ir()).unwrap();
3042        let result = mutation_failure_result(
3043            &task,
3044            &plan,
3045            (7, 8),
3046            Vec::new(),
3047            TaskPlanOperation::ConfirmDialog,
3048            "dialog-verification",
3049            "dialog outcome was not verified",
3050        );
3051        assert_eq!(result.status, "indeterminate");
3052        assert!(result.mutation_possible);
3053        assert_eq!(result.current_revision, 8);
3054        assert!(result.dialog.is_none());
3055        let serialized = serde_json::to_string(&result).unwrap();
3056        assert!(!serialized.contains("secret dialog message"));
3057        assert!(!serialized.contains("\"dialog\":"));
3058    }
3059
3060    #[test]
3061    fn mutation_failure_returns_bounded_recovery_result() {
3062        let task = task();
3063        let plan = compile_task(&task, &crate::task_compiler::test_compiler_ir()).unwrap();
3064        let result = mutation_failure_result(
3065            &task,
3066            &plan,
3067            (7, 9),
3068            Vec::new(),
3069            TaskPlanOperation::SubmitForm,
3070            "submit-verification",
3071            "post-action observation failed",
3072        );
3073        assert_eq!(result.status, "indeterminate");
3074        assert_eq!(result.phase, "submit-verification");
3075        assert!(result.mutation_possible);
3076        assert_eq!(result.source_revision, 7);
3077        assert_eq!(result.current_revision, 9);
3078        assert_eq!(
3079            result.steps[0].detail.as_deref(),
3080            Some("post-action observation failed")
3081        );
3082        assert_eq!(
3083            result.retry.classification,
3084            RetryClassification::UnsafeUntilReconciled
3085        );
3086    }
3087
3088    #[test]
3089    fn postcondition_observation_failure_preserves_recovery_guidance() {
3090        let task = task();
3091        let plan = compile_task(&task, &crate::task_compiler::test_compiler_ir()).unwrap();
3092        let initial = mutation_failure_result(
3093            &task,
3094            &plan,
3095            (7, 9),
3096            Vec::new(),
3097            TaskPlanOperation::SubmitForm,
3098            "submit-verification",
3099            "dispatch completed but verification was unavailable",
3100        );
3101        let result = postcondition_failure_result(initial, 10, "postcondition observation failed");
3102        assert_eq!(result.status, "indeterminate");
3103        assert_eq!(result.phase, "postcondition-verification");
3104        assert_eq!(result.current_revision, 10);
3105        assert_eq!(
3106            result.retry.classification,
3107            RetryClassification::UnsafeUntilReconciled
3108        );
3109        assert_eq!(
3110            result.steps[0].detail.as_deref(),
3111            Some("postcondition observation failed")
3112        );
3113    }
3114
3115    #[test]
3116    fn form_scope_requires_one_matching_region() {
3117        let observation = InspectPageResult {
3118            page: SemanticPage {
3119                kind: SemanticPageKind::Form,
3120                title: "Checkout".into(),
3121                url: "https://example.test/checkout".into(),
3122                target_id: "page".into(),
3123                frame_id: "frame".into(),
3124                confidence: SemanticConfidence::Exact,
3125                evidence: Vec::new(),
3126            },
3127            revision: 7,
3128            regions: vec![region("Shipping", Vec::new())],
3129            limits: Default::default(),
3130            focused_target: None,
3131            alerts: Vec::new(),
3132        };
3133        let error = scoped_regions_for_observation(&observation, &task()).unwrap_err();
3134        assert!(error.to_string().contains("not found"));
3135    }
3136
3137    #[test]
3138    fn navigation_destination_matching_ignores_fragment_and_trailing_slash() {
3139        assert!(navigation_destination_matches(
3140            "https://example.test/account/#section",
3141            "https://example.test/account"
3142        ));
3143        assert!(!navigation_destination_matches(
3144            "https://example.test/account",
3145            "https://example.test/settings"
3146        ));
3147    }
3148
3149    #[test]
3150    fn compiled_revision_policies_fail_closed_or_reconcile_explicitly() {
3151        let exact =
3152            crate::task_compiler::compile_task(&task(), &crate::task_compiler::test_compiler_ir())
3153                .unwrap();
3154        assert!(compiled_revision_mismatch(&exact, exact.source_ir_revision).is_none());
3155        assert!(compiled_revision_mismatch(&exact, exact.source_ir_revision + 1).is_some());
3156
3157        let mut compatible_read = task();
3158        compatible_read.task = TaskKind::RegionExtract;
3159        compatible_read.scope.entity_kind = Some(crate::web_ir::WebIrEntityKind::Region);
3160        compatible_read.inputs.clear();
3161        compatible_read.risk = TaskRiskClass::ReadOnly;
3162        compatible_read.revision = TaskRevisionPolicy::Compatible;
3163        let compatible_read = crate::task_compiler::compile_task(
3164            &compatible_read,
3165            &crate::task_compiler::test_compiler_ir(),
3166        )
3167        .unwrap();
3168        assert!(
3169            compiled_revision_mismatch(&compatible_read, compatible_read.source_ir_revision - 1)
3170                .is_none()
3171        );
3172
3173        let mut compatible_mutation = task();
3174        compatible_mutation.revision = TaskRevisionPolicy::Compatible;
3175        let compatible_mutation = crate::task_compiler::compile_task(
3176            &compatible_mutation,
3177            &crate::task_compiler::test_compiler_ir(),
3178        )
3179        .unwrap();
3180        assert!(
3181            compiled_revision_mismatch(
3182                &compatible_mutation,
3183                compatible_mutation.source_ir_revision - 1
3184            )
3185            .is_some()
3186        );
3187
3188        let mut reextract = task();
3189        reextract.revision = TaskRevisionPolicy::Reextract;
3190        let reextract = crate::task_compiler::compile_task(
3191            &reextract,
3192            &crate::task_compiler::test_compiler_ir(),
3193        )
3194        .unwrap();
3195        assert!(reextract.confirmation_required);
3196        assert!(compiled_revision_mismatch(&reextract, reextract.source_ir_revision - 1).is_none());
3197    }
3198    #[test]
3199    fn live_task_evidence_sources_cover_boundaries_and_bridge() {
3200        let sources = live_task_evidence_sources();
3201        for source in [
3202            EvidenceSource::Frames,
3203            EvidenceSource::ShadowDom,
3204            EvidenceSource::Svg,
3205            EvidenceSource::CanvasDetection,
3206            EvidenceSource::MediaMetadata,
3207            EvidenceSource::EmbeddedDocument,
3208            EvidenceSource::Pdf,
3209            EvidenceSource::BrowserNative,
3210            EvidenceSource::Bridge,
3211            EvidenceSource::BoundedProbe,
3212        ] {
3213            assert!(sources.contains(&source), "missing live source {source:?}");
3214        }
3215        let mut sorted = sources.clone();
3216        sorted.sort();
3217        sorted.dedup();
3218        assert_eq!(sorted.len(), sources.len());
3219    }
3220}