1use 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#[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#[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 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#[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
123struct 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 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 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 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(¤t, 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 ¤t,
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(¤t, &after);
833 current = after;
834 if !page_changed {
835 let regions = match scoped_regions_for_observation(¤t, 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(®ions, 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 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 ®ions,
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 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 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 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 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 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| ®ion.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}