diff --git a/application/single_app/config.py b/application/single_app/config.py
index dc1de5f1b..0ea5593ff 100644
--- a/application/single_app/config.py
+++ b/application/single_app/config.py
@@ -97,7 +97,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.261.115"
+VERSION = "0.261.116"
 IS_DEVELOPMENT = is_development_env_enabled()
 
 SESSION_COOKIE_SAMESITE = os.getenv('SESSION_COOKIE_SAMESITE', 'Lax')
diff --git a/application/single_app/functions_document_analysis_checkpoints.py b/application/single_app/functions_document_analysis_checkpoints.py
index b44487eb4..6dd364d1d 100644
--- a/application/single_app/functions_document_analysis_checkpoints.py
+++ b/application/single_app/functions_document_analysis_checkpoints.py
@@ -10,6 +10,7 @@
 """
 
 import hashlib
+import json
 import uuid
 from copy import deepcopy
 
@@ -118,7 +119,8 @@ def _lineage(self):
         seen = set()
         expected_child = None
         while binding is not None:
-            identity = tuple(sorted(binding.items()))
+            identity = tuple((key, json.dumps(value, sort_keys=True, separators=(',', ':')))
+                             for key, value in sorted(binding.items()))
             if identity in seen or len(seen) >= 128:
                 raise WorkflowResultIntegrityError('Analysis checkpoint retry lineage is invalid.')
             seen.add(identity)
@@ -243,12 +245,23 @@ def analysis_checkpoints_for_workflow(
     attempt_token=None, settings=None, store=None, source_authorizer=None,
     operation_request=None, operation_sources=None,
     recover_running_unit=None,
+    execution_id=None, node_id=None, attempt=None, iteration_path=None,
 ):
-    binding = _identity(workflow, run_id, task_id)
+    selectors = {}
+    if execution_id is not None:
+        selectors = {"execution_id": execution_id, "node_id": node_id, "attempt": attempt,
+                     "iteration_path": [] if iteration_path is None else iteration_path}
+    binding = _identity(workflow, run_id, task_id, **selectors)
+    result_store = store or _configured_result_store(binding, settings=settings, for_write=True)
+    resume_from = _identity(workflow, resume_run_id, task_id) if resume_run_id else None
+    if selectors and attempt > 1:
+        prior_binding = _identity(workflow, run_id, task_id, **{**selectors, "attempt": attempt - 1})
+        if result_store._analysis_guard(prior_binding) is not None:
+            resume_from = prior_binding
     return AnalysisWorkUnitCheckpoints(
-        store or _configured_result_store(binding, settings=settings, for_write=True),
+        result_store,
         binding, user_id=user_id, authorize=authorize, attempt_token=attempt_token,
-        resume_from=_identity(workflow, resume_run_id, task_id) if resume_run_id else None,
+        resume_from=resume_from,
         source_authorizer=source_authorizer,
         operation_request=operation_request, operation_sources=operation_sources,
         recover_running_unit=recover_running_unit,
diff --git a/application/single_app/functions_group_workflows.py b/application/single_app/functions_group_workflows.py
index 24a6cef20..0bcaeba20 100644
--- a/application/single_app/functions_group_workflows.py
+++ b/application/single_app/functions_group_workflows.py
@@ -503,7 +503,10 @@ def save_group_workflow(group_id, workflow_data, actor_user_id, user_info=None):
             reference, actor_user_id=actor_user_id,
         )
     task_prompt = _normalize_text(
-        workflow_data.get('task_prompt') or (tasks[0].get('instructions') if tasks else ''),
+        workflow_data.get('task_prompt') or (
+            workflow_name if definition_fields['definition_version'] == 3
+            else tasks[0].get('instructions') if tasks else ''
+        ),
         'Task prompt',
         required=True,
     )
diff --git a/application/single_app/functions_personal_workflows.py b/application/single_app/functions_personal_workflows.py
index 407258183..943ace918 100644
--- a/application/single_app/functions_personal_workflows.py
+++ b/application/single_app/functions_personal_workflows.py
@@ -215,9 +215,15 @@ def _normalize_workflow_tasks(
 
     normalized_tasks = []
     seen_task_ids = set()
+    structured = workflow_data.get('definition_version') == 3
     for index, raw_task in enumerate(raw_tasks):
         if not isinstance(raw_task, dict):
             raise ValueError(f'Workflow task {index + 1} is invalid.')
+        if structured and raw_task.keys() - {
+            'id', 'type', 'name', 'instructions', 'order', 'runner', 'document_action', 'inputs',
+            'reference_ids', 'output_contract', 'approval', 'publication',
+        }:
+            raise ValueError('A structured task contains unsupported executable fields.')
 
         task_type = _normalize_text(raw_task.get('type') or 'instructions', 'Task type').lower()
         if task_type != 'instructions':
@@ -235,7 +241,7 @@ def _normalize_workflow_tasks(
         publication = None
         if raw_task.get('publication') is not None:
             publication = normalize_workflow_publication(raw_task['publication'])
-            if index == 0:
+            if index == 0 and not structured:
                 raise ValueError('Add an analysis task before its publication task.')
             publication_action = raw_task.get('document_action')
             if publication_action is not None and (
@@ -253,6 +259,10 @@ def _normalize_workflow_tasks(
             )
 
         raw_runner = raw_task.get('runner') if isinstance(raw_task.get('runner'), dict) else {}
+        if structured and raw_runner.keys() - {
+            'type', 'selected_agent', 'model_endpoint_id', 'model_id', 'model_provider', 'model_binding_summary',
+        }:
+            raise ValueError('A structured task runner contains unsupported executable fields.')
         runner_type = _normalize_text(raw_runner.get('type') or 'inherit', 'Task runner type').lower()
         if runner_type not in WORKFLOW_TASK_RUNNER_TYPES:
             raise ValueError(f'Workflow task {index + 1} has an unsupported runner type.')
@@ -278,7 +288,7 @@ def _normalize_workflow_tasks(
 
         if callable(task_document_action_normalizer):
             raw_document_action = raw_task.get('document_action')
-            if not isinstance(raw_document_action, dict) and index == 0:
+            if not isinstance(raw_document_action, dict) and index == 0 and not structured:
                 # Workflows saved before per-task documents kept a single workflow-level
                 # action that only ever executed on the first task.
                 raw_document_action = default_document_action
@@ -815,7 +825,10 @@ def save_personal_workflow(user_id, workflow_data, actor_user_id=None):
     for reference in definition_fields.get('reference_inputs', []):
         authorize_workflow_reference({'user_id': user_id}, reference, actor_user_id=modifying_user_id)
     task_prompt = _normalize_text(
-        workflow_data.get('task_prompt') or (tasks[0].get('instructions') if tasks else ''),
+        workflow_data.get('task_prompt') or (
+            workflow_name if definition_fields['definition_version'] == 3
+            else tasks[0].get('instructions') if tasks else ''
+        ),
         'Task prompt',
         required=True,
     )
@@ -1103,7 +1116,7 @@ def is_public_workflow_run_item(item):
     private_types = (
         "workflow_result_chunk", "chat_analysis_result_chunk",
         "orchestration_analysis_result_chunk", "analysis_work_unit_checkpoint",
-        "workflow_runtime_control",
+        "workflow_runtime_control", "workflow_runtime_journal",
     )
     return isinstance(item, dict) and not any(
         item.get(field) in private_types for field in ("type", "item_type")
@@ -1113,10 +1126,10 @@ def is_public_workflow_run_item(item):
 WORKFLOW_PUBLIC_RUN_ITEMS_FILTER = (
     'AND (NOT IS_DEFINED(c.type) OR c.type NOT IN '
     '("workflow_result_chunk", "chat_analysis_result_chunk", '
-    '"orchestration_analysis_result_chunk", "analysis_work_unit_checkpoint", "workflow_runtime_control")) '
+    '"orchestration_analysis_result_chunk", "analysis_work_unit_checkpoint", "workflow_runtime_control", "workflow_runtime_journal")) '
     'AND (NOT IS_DEFINED(c.item_type) OR c.item_type NOT IN '
     '("workflow_result_chunk", "chat_analysis_result_chunk", '
-    '"orchestration_analysis_result_chunk", "analysis_work_unit_checkpoint", "workflow_runtime_control")) '
+    '"orchestration_analysis_result_chunk", "analysis_work_unit_checkpoint", "workflow_runtime_control", "workflow_runtime_journal")) '
 )
 
 
diff --git a/application/single_app/functions_saved_analysis.py b/application/single_app/functions_saved_analysis.py
index 073a4fbdf..41952fcfc 100644
--- a/application/single_app/functions_saved_analysis.py
+++ b/application/single_app/functions_saved_analysis.py
@@ -18,6 +18,7 @@
 from functions_generated_file_exports import build_saved_analysis_export
 from functions_workflow_context import WorkflowContextBudgetError, calculate_workflow_context_budget
 from functions_workflow_result_store import WorkflowResultStorageUnavailableError, _quota_bytes
+from functions_workflow_runtime_store import WorkflowRuntimeConflict
 from functions_workflow_results import (
     ANALYSIS_SOURCE_ACCESS_VERSION,
     WorkflowResultNotReadyError,
@@ -172,18 +173,22 @@ def _load_authorized_workflow(user_id, binding):
     from functions_workflow_runner import _workflow_task_run_item_id
 
     group_id = binding.get("group_id")
+    item_id = (
+        _workflow_task_run_item_id(binding["run_id"], binding["task_id"], binding["execution_id"])
+        if binding.get("execution_id") else _workflow_task_run_item_id(binding["run_id"], binding["task_id"])
+    )
     if group_id:
         assert_group_role(user_id, group_id, allowed_roles=("Owner", "Admin", "DocumentManager", "User"))
         workflow = get_group_workflow(group_id, binding["workflow_id"])
         run = get_group_workflow_run(group_id, binding["run_id"])
         item = get_group_workflow_run_item(
-            binding["run_id"], _workflow_task_run_item_id(binding["run_id"], binding["task_id"]),
+            binding["run_id"], item_id,
         )
     else:
         workflow = get_personal_workflow(user_id, binding["workflow_id"])
         run = get_personal_workflow_run(user_id, binding["run_id"])
         item = get_personal_workflow_run_item(
-            binding["run_id"], _workflow_task_run_item_id(binding["run_id"], binding["task_id"]),
+            binding["run_id"], item_id,
         )
     if (
         not workflow or workflow.get("id") != binding["workflow_id"]
@@ -367,6 +372,8 @@ def workflow_saved_analysis_descriptor(summary, workflow, *, conversation_id, me
             "kind": "workflow", "workflow_id": workflow["id"],
             "run_id": producer["run_id"], "task_id": producer["task_id"],
             "group_id": workflow.get("group_id"),
+            **({key: producer[key] for key in ("node_id", "execution_id", "iteration_path", "attempt")}
+               if producer.get("execution_id") else {}),
         },
         "record_count": summary.get("record_count"),
         "source_count": summary.get("source_count"),
@@ -467,6 +474,15 @@ def analysis_artifact_metadata(producer):
         if not isinstance(value, str) or not value.strip() or len(value.encode("utf-8")) > 1024:
             raise ValueError("The analysis artifact producer is incomplete.")
         normalized[field] = value.strip()
+    if producer["kind"] == "workflow" and producer.get("execution_id"):
+        for field in ("node_id", "execution_id"):
+            value = producer.get(field)
+            if not isinstance(value, str) or not value or len(value) > 128:
+                raise ValueError("The exact analysis execution identity is incomplete.")
+            normalized[field] = value
+        if type(producer.get("attempt")) is not int or producer["attempt"] < 1 or producer.get("iteration_path") != []:
+            raise ValueError("The exact analysis attempt identity is incomplete.")
+        normalized.update(attempt=producer["attempt"], iteration_path=[])
     return {"analysis_result_required": True, "analysis_producer": normalized}
 
 
@@ -501,7 +517,10 @@ def _workflow_analysis_artifact_manifest(user_id, artifact, producer):
     from functions_personal_workflows import get_personal_workflow_run_item
     from functions_workflow_runner import _workflow_task_run_item_id
 
-    item_id = _workflow_task_run_item_id(producer["run_id"], producer["task_id"])
+    item_id = (
+        _workflow_task_run_item_id(producer["run_id"], producer["task_id"], producer["execution_id"])
+        if producer.get("execution_id") else _workflow_task_run_item_id(producer["run_id"], producer["task_id"])
+    )
     items = [
         item for item in (
             get_personal_workflow_run_item(producer["run_id"], item_id),
@@ -516,11 +535,25 @@ def _workflow_analysis_artifact_manifest(user_id, artifact, producer):
     binding = {**producer, "group_id": item.get("group_id")}
     workflow = _load_authorized_workflow(user_id, binding)
     summary = item.get("workflow_result") or {}
+    selectors = {}
+    if producer.get("execution_id"):
+        from functions_workflow_runtime_store import workflow_runtime_store
+
+        journal = workflow_runtime_store(workflow, producer["run_id"])
+        workflow = journal.run_definition()
+        row = journal.journal_read(
+            "attempt", [producer["execution_id"], producer["attempt"]],
+        )
+        if row is None or row["payload"].get("task_id") != producer["task_id"] or row["payload"].get("node_id") != producer["node_id"]:
+            raise AnalysisResultUnavailable("analysis_artifact_unbound")
+        summary = row["payload"].get("workflow_result") or {}
+        selectors = {key: producer[key] for key in ("node_id", "execution_id", "iteration_path", "attempt")}
     reference = summary.get("result_ref")
     if not isinstance(reference, Mapping):
         raise AnalysisResultUnavailable("analysis_artifact_unbound")
     manifest, _ = authorize_workflow_task_result_read(
         workflow, producer["run_id"], producer["task_id"], reference, reader_user_id=user_id,
+        **selectors,
     )
     if not any(
         value.get("artifact_message_id") == artifact.get("id")
@@ -711,11 +744,21 @@ def load_saved_analysis(
             if not isinstance(binding.get(field), str) or not binding[field]:
                 raise AnalysisResultUnavailable("analysis_lineage_invalid")
         workflow = (workflow_getter or _load_authorized_workflow)(user_id, binding)
-        loader = workflow_loader or _workflow_load
-        load = lambda ref: loader(workflow, binding["run_id"], binding["task_id"], ref)
+        selectors = {}
+        if binding.get("execution_id"):
+            from functions_workflow_result_store import load_workflow_node_result
+            from functions_workflow_runtime_store import workflow_runtime_store
+
+            workflow = workflow_runtime_store(workflow, binding["run_id"]).run_definition()
+            selectors = {key: binding[key] for key in ("node_id", "execution_id", "iteration_path", "attempt")}
+            loader = workflow_loader or load_workflow_node_result
+        else:
+            loader = workflow_loader or _workflow_load
+        load = lambda ref: loader(workflow, binding["run_id"], binding["task_id"], ref, **selectors)
         manifest, checked = authorize_workflow_task_result_read(
             workflow, binding["run_id"], binding["task_id"], reference,
             reader_user_id=user_id, load_result=loader, source_resolver=source_resolver,
+            **selectors,
         )
     elif binding.get("kind") == "orchestration":
         for field in ("user_id", "conversation_id", "run_id", "step_id"):
@@ -1647,33 +1690,44 @@ def sanitize_workflow_analysis_history(workflow, run_record, user_id, *, items=N
     tasks = list(run_record.get("task_results") or []) + list(items or [])
     denied = set()
     checked = {}
+    bound_workflow = None
     for task in tasks:
         if not isinstance(task, Mapping):
             continue
         task_id = task.get("task_id")
         summary = task.get("workflow_result") or {}
-        candidates = [summary] if isinstance(summary, Mapping) and summary.get("analysis_result") else []
+        candidates = [summary] if isinstance(summary, Mapping) and (
+            summary.get("analysis_result") or summary.get("contract_version") == "workflow-result-v2"
+        ) else []
         candidates.extend(
             consumed for consumed in task.get("consumed_inputs") or []
-            if isinstance(consumed, Mapping) and consumed.get("analysis_result")
+            if isinstance(consumed, Mapping) and (consumed.get("analysis_result") or (consumed.get("producer") or {}).get("execution_id"))
         )
         for candidate in candidates:
             producer = candidate.get("producer") or {}
             reference = candidate.get("result_ref") or {}
-            key = (producer.get("run_id"), producer.get("task_id"), reference.get("sha256"))
+            key = (producer.get("run_id"), producer.get("task_id"), producer.get("execution_id"),
+                   producer.get("attempt"), reference.get("sha256"))
             if key not in checked:
                 try:
                     if (
                         producer.get("workflow_id") != workflow.get("id")
                         or producer.get("run_id") != run_record.get("id")
-                        or not producer.get("task_id")
+                        or not producer.get("task_id") and not producer.get("execution_id")
                     ):
                         raise AnalysisResultUnavailable("analysis_lineage_invalid")
+                    selectors = {}
+                    if producer.get("execution_id"):
+                        selectors = {name: producer.get(name) for name in ("node_id", "execution_id", "iteration_path", "attempt")}
+                        if result_reader is None and bound_workflow is None:
+                            from functions_workflow_runtime_store import workflow_runtime_store
+
+                            bound_workflow = workflow_runtime_store(workflow, producer["run_id"]).run_definition()
                     read(
-                        workflow, producer["run_id"], producer["task_id"], reference,
-                        reader_user_id=user_id,
+                        bound_workflow or workflow, producer["run_id"], producer.get("task_id"), reference,
+                        reader_user_id=user_id, **selectors,
                     )
-                except (PermissionError, LookupError, ValueError, AzureError, WorkflowResultStorageUnavailableError) as exc:
+                except (PermissionError, LookupError, ValueError, AzureError, WorkflowResultStorageUnavailableError, WorkflowRuntimeConflict) as exc:
                     log_event(
                         "[DOCUMENT_ANALYSIS] Workflow analysis preview withheld.",
                         extra={"run_id": run_record.get("id"), "task_id": task_id, "error_type": type(exc).__name__},
diff --git a/application/single_app/functions_workflow_activity.py b/application/single_app/functions_workflow_activity.py
index 1a8a491bf..da3ede597 100644
--- a/application/single_app/functions_workflow_activity.py
+++ b/application/single_app/functions_workflow_activity.py
@@ -117,6 +117,7 @@ def _serialize_run(run_record):
                 field: task.get(field)
                 for field in (
                     'task_id', 'task_name', 'task_order', 'status',
+                    'execution_id', 'node_id', 'iteration_path', 'attempt',
                     'workflow_result', 'context_budget', 'consumed_inputs', 'workflow_validation',
                 )
             }
diff --git a/application/single_app/functions_workflow_definition_store.py b/application/single_app/functions_workflow_definition_store.py
index 0a8af2368..b5a3a2fab 100644
--- a/application/single_app/functions_workflow_definition_store.py
+++ b/application/single_app/functions_workflow_definition_store.py
@@ -36,9 +36,10 @@ def save_workflow_definition_record(container, partition_key, workflow, existing
             raise WorkflowDefinitionConflict("This workflow is being deleted. Your draft was not saved.")
         if workflow_definition_revision(current) != expected:
             raise WorkflowDefinitionConflict("This workflow changed since it was opened. Reload it before saving.")
-        if workflow.get("definition_version") == 2 and current.get("active_run_id"):
+        if workflow.get("definition_version") in {2, 3} and current.get("active_run_id"):
             raise WorkflowDefinitionConflict("An active run started while editing. Wait or cancel it before saving.")
-        body = dict(workflow)
+        body = {key: value for key, value in current.items() if not key.startswith("_")}
+        body.update(workflow)
         body.update({key: current[key] for key in WORKFLOW_RUNTIME_FIELDS if key in current})
         # A schedule edit intentionally computes a new next run; preserve the
         # live scheduler value only when its authored inputs stayed the same.
diff --git a/application/single_app/functions_workflow_definitions.py b/application/single_app/functions_workflow_definitions.py
index cee7ed7f3..1edb9817c 100644
--- a/application/single_app/functions_workflow_definitions.py
+++ b/application/single_app/functions_workflow_definitions.py
@@ -19,7 +19,7 @@
     "trigger_type", "is_enabled", "schedule", "error_handling", "document_action", "analyze",
     "file_sync", "selected_agent", "model_endpoint_id", "model_id", "model_provider",
     "url_access_enabled", "alert_priority", "alert_mode", "alert_rules", "alert_evaluation",
-    "definition_version", "reference_inputs", "durable_execution",
+    "definition_version", "reference_inputs", "durable_execution", "flow", "limits",
 )
 SCHEMA_KEYWORDS = frozenset({
     "type", "properties", "required", "additionalProperties", "items",
@@ -142,7 +142,7 @@ def normalize_workflow_output_contract(value):
         "kind", "schema", "expected_count", "identity_field", "require_complete_coverage", "allow_partial",
     }, "Output contract")
     kind = contract.get("kind", "any")
-    if kind not in WORKFLOW_OUTPUT_KINDS:
+    if not isinstance(kind, str) or kind not in WORKFLOW_OUTPUT_KINDS:
         raise WorkflowDefinitionError("Choose a supported output kind.")
     normalized = {
         "kind": kind,
@@ -235,13 +235,26 @@ def normalize_workflow_definition(payload, existing, tasks, *, user_id, group_id
     existing = existing or {}
     version = payload.get("definition_version", 1)
     stored_version = existing.get("definition_version", 1)
-    if type(version) is not int or version not in {1, WORKFLOW_DEFINITION_VERSION}:
+    if type(version) is not int or version not in {1, 2, 3}:
         raise WorkflowDefinitionConflict("This workflow definition version is not supported by this editor.")
-    if type(stored_version) is not int or stored_version not in {1, WORKFLOW_DEFINITION_VERSION}:
+    if type(stored_version) is not int or stored_version not in {1, 2, 3}:
         raise WorkflowDefinitionConflict("This saved workflow requires a newer editor. Its definition was not changed.")
-    if stored_version == WORKFLOW_DEFINITION_VERSION and version != WORKFLOW_DEFINITION_VERSION:
+    if version == 3:
+        managed_fields = {
+            "id", "definition_revision", "conversation_id", "user_id", "group_id",
+            "url_access_authorized", "url_access_authorized_by", "url_access_authorized_at",
+            "model_binding_summary", "created_at", "created_by", "modified_at", "modified_by",
+            "updated_at", "status", "last_run_started_at", "last_run_at", "last_run_status",
+            "last_run_error", "last_run_response_preview", "last_run_trigger_source", "run_count",
+            "active_run_id", "active_runtime_version", "last_run_id", "next_run_at",
+            "cancellation_requested_at", "cancellation_requested_by", "result_access",
+        }
+        extras = payload.keys() - set(WORKFLOW_DEFINITION_FIELDS) - managed_fields
+        if any(key not in existing or payload[key] != existing[key] for key in extras):
+            raise WorkflowDefinitionError("The structured workflow contains unsupported fields.")
+    if stored_version >= 2 and version < stored_version:
         raise WorkflowDefinitionConflict("This workflow uses advanced data flow. Open it in V2 to edit without losing its configuration.")
-    if version == WORKFLOW_DEFINITION_VERSION and existing:
+    if version >= 2 and existing:
         if payload.get("definition_revision") != workflow_definition_revision(existing):
             raise WorkflowDefinitionConflict("This workflow changed since it was opened. Reload it before saving.")
         if existing.get("active_run_id"):
@@ -249,7 +262,7 @@ def normalize_workflow_definition(payload, existing, tasks, *, user_id, group_id
     raw_tasks = payload.get("tasks", existing.get("tasks", []))
     if len(raw_tasks) != len(tasks):
         raise WorkflowDefinitionError("Task data does not match the normalized task list.")
-    has_flow = "reference_inputs" in payload or payload.get("durable_execution") is True or any(
+    has_flow = "reference_inputs" in payload or "flow" in payload or payload.get("durable_execution") is True or any(
         WORKFLOW_FLOW_TASK_FIELDS.intersection(task) for task in raw_tasks
     )
     if version == 1:
@@ -268,7 +281,10 @@ def normalize_workflow_definition(payload, existing, tasks, *, user_id, group_id
         prepared = dict(task)
         if "output_contract" in raw and raw["output_contract"] is not None:
             prepared["output_contract"] = normalize_workflow_output_contract(raw["output_contract"])
-        if "inputs" in raw and raw["inputs"] is not None:
+        if version == 3:
+            # The structured compiler owns node bindings; legacy predecessor rules do not apply.
+            prepared["inputs"] = raw.get("inputs", [])
+        elif "inputs" in raw and raw["inputs"] is not None:
             prepared["inputs"] = _normalize_bindings(raw["inputs"], earlier)
         if "reference_ids" in raw and raw["reference_ids"] is not None:
             selected_ids = _unique_identifiers(raw["reference_ids"], "Task reference ids")
@@ -286,9 +302,18 @@ def normalize_workflow_definition(payload, existing, tasks, *, user_id, group_id
             prepared["approval"] = {"required": required, "message": message.strip()}
         normalized_tasks.append(prepared)
         earlier[prepared["id"]] = prepared
-    return {
-        "definition_version": WORKFLOW_DEFINITION_VERSION,
+    result = {
+        "definition_version": version,
         "reference_inputs": references,
         "durable_execution": durable,
         "tasks": normalized_tasks,
     }
+    if version == 3:
+        # The compiler shares definition helpers, so import at the normalization boundary.
+        from functions_workflow_flow import compile_workflow_flow
+
+        compiled = compile_workflow_flow({**payload, **result})
+        result.update({key: compiled[key] for key in ("flow", "tasks", "limits")})
+    elif any(key in payload for key in ("flow", "limits", "max_executions", "deadline_seconds")):
+        raise WorkflowDefinitionError("Structured flow and run limits require definition version 3.")
+    return result
diff --git a/application/single_app/functions_workflow_editor.py b/application/single_app/functions_workflow_editor.py
index 083f7f300..e77f14eca 100644
--- a/application/single_app/functions_workflow_editor.py
+++ b/application/single_app/functions_workflow_editor.py
@@ -3,6 +3,7 @@
 
 from functions_ai_connections import supports_model_capability
 from functions_workflow_definitions import WORKFLOW_DEFINITION_VERSION
+from functions_workflow_flow import FLOW_LIMITS
 
 
 def build_workflow_editor_options(*, scope_type, scope_id, can_manage, max_tasks,
@@ -43,6 +44,9 @@ def build_workflow_editor_options(*, scope_type, scope_id, can_manage, max_tasks
     default_model = default_model or {}
     return {
         "definition_version": WORKFLOW_DEFINITION_VERSION,
+        "supported_definition_versions": [1, 2, 3],
+        "supported_node_kinds": ["task", "if", "route"],
+        "flow_limits": dict(FLOW_LIMITS),
         "scope": {"type": scope_type, "id": str(scope_id)},
         "can_manage": bool(can_manage),
         "max_tasks": max_tasks,
diff --git a/application/single_app/functions_workflow_execution.py b/application/single_app/functions_workflow_execution.py
index 194dd3cec..9c25606f8 100644
--- a/application/single_app/functions_workflow_execution.py
+++ b/application/single_app/functions_workflow_execution.py
@@ -65,10 +65,7 @@ def workflow_checkpoint_scope_guard(record):
     execution = current_workflow_execution()
     if execution is not None:
         execution.check()
-        reference = execution.save_result(
-            execution.workflow, execution.run_id, "runtime:run-record",
-            {"run_record": record}, settings=execution.settings,
-        )
+        reference = execution.save_runtime_record(record)
         execution._update(execution.check(), {"run_record_ref": reference})
 
 
@@ -88,6 +85,14 @@ def __init__(self, store, lease, workflow, run_id, *, settings=None,
     def check(self):
         return self.lease.check()
 
+    def unit(self, key):
+        return deepcopy((self.check().get("units") or {}).get(key) or {})
+
+    def save_runtime_record(self, record):
+        return self.save_result(
+            self.workflow, self.run_id, "runtime:run-record", {"run_record": record}, settings=self.settings,
+        )
+
     def _update(self, record, updates):
         return self.store.update(self.lease.token, updates, expected_version=record["version"])
 
diff --git a/application/single_app/functions_workflow_execution_history.py b/application/single_app/functions_workflow_execution_history.py
new file mode 100644
index 000000000..cdac7af16
--- /dev/null
+++ b/application/single_app/functions_workflow_execution_history.py
@@ -0,0 +1,99 @@
+# functions_workflow_execution_history.py
+"""Authorized safe projections of the schema-2 execution journal."""
+
+from functions_analysis_access import authorize_analysis_sources, build_analysis_access
+from functions_workflow_identity import workflow_node_identity
+from functions_workflow_node_results import authorize_workflow_node_result_read, result_selectors
+from functions_workflow_result_store import read_workflow_node_result_page
+from functions_workflow_runtime_store import workflow_runtime_store
+
+
+def authorize_execution_payload(workflow, run_id, payload, *, reader_user_id):
+    references = payload.get("reference_sources") or []
+    if references:
+        policy = build_analysis_access(references)
+        authorize_analysis_sources(reader_user_id, policy["sources"])
+    summary = payload.get("workflow_result") or {}
+    if summary.get("result_ref"):
+        authorize_workflow_node_result_read(
+            workflow, run_id, summary["producer"], summary["result_ref"], reader_user_id=reader_user_id,
+        )
+    for receipt in payload.get("consumed_inputs") or []:
+        authorize_workflow_node_result_read(
+            workflow, run_id, receipt["producer"], receipt["result_ref"], reader_user_id=reader_user_id,
+        )
+
+
+def workflow_execution_history(workflow, run_id, *, reader_user_id, kind="execution", execution_id=None,
+                               cursor=None, limit=50):
+    store = workflow_runtime_store(workflow, run_id)
+    if store.read().get("schema_version") != 2:
+        raise ValueError("Execution history is available only for structured workflow runs.")
+    workflow = store.run_definition()
+    if execution_id:
+        execution = store.journal_read("execution", execution_id)
+        if execution is None:
+            raise LookupError("Execution not found.")
+    page = store.journal_page(kind, execution_id=execution_id, cursor=cursor, limit=limit)
+    # Read the bound internal records too: safe decision projections intentionally omit source references.
+    for item in page["items"]:
+        if kind == "decision":
+            key = ["gate", item["gate_id"]] if item.get("gate_id") else ["control", item["execution_id"]]
+            row = store.journal_read("decision", key)
+            payload = row["payload"]
+        else:
+            key = item["execution_id"] if kind == "execution" else [item["execution_id"], item["attempt"]]
+            row = store.journal_read(kind, key)
+            if row is None:
+                raise LookupError("The execution journal changed while it was being read.")
+            payload = row["payload"]
+        authorize_execution_payload(workflow, run_id, payload, reader_user_id=reader_user_id)
+    name = {"execution": "executions", "attempt": "attempts", "decision": "decisions"}[kind]
+    result = {name: page["items"], "next_cursor": page["next_cursor"]}
+    if kind == "execution":
+        result["total_count"] = page["total_count"]
+    return result
+
+
+def workflow_execution_result_page(workflow, run_id, execution_id, attempt, *, reader_user_id,
+                                   output="authoritative", offset=0, limit=2000):
+    store = workflow_runtime_store(workflow, run_id)
+    workflow = store.run_definition()
+    record = store.journal_read("attempt", [execution_id, attempt])
+    if record is None:
+        raise LookupError("Execution attempt not found.")
+    payload = record["payload"]
+    summary = payload.get("workflow_result") or {}
+    identity = summary.get("producer") or {}
+    expected = workflow_node_identity(
+        workflow, run_id, payload["node_id"], execution_id, attempt, task_id=payload.get("task_id"), iteration_path=[],
+    )
+    if identity != expected or not summary.get("result_ref"):
+        raise ValueError("This exact attempt has no saved result.")
+    manifest, _ = authorize_workflow_node_result_read(
+        workflow, run_id, identity, summary["result_ref"], reader_user_id=reader_user_id,
+    )
+    name = manifest.get("authoritative_output") if output == "authoritative" else output
+    reference = summary["result_ref"] if name == "manifest" else (manifest.get("outputs", {}).get(name) or {}).get("result_ref")
+    if not reference:
+        raise LookupError("The selected output was not produced.")
+    descriptor = (manifest.get("outputs") or {}).get(name) or {}
+    for _ in range(256):
+        selected = descriptor.get("selected_producer")
+        if not selected or name == "manifest":
+            break
+        identity = selected["producer"]
+        manifest, _ = authorize_workflow_node_result_read(
+            workflow, run_id, identity, selected["result_ref"], reader_user_id=reader_user_id,
+        )
+        descriptor = (manifest.get("outputs") or {}).get(selected["output_name"]) or {}
+        if descriptor.get("result_ref") != selected["output_ref"]:
+            raise ValueError("The selected producer output changed.")
+        reference = descriptor["result_ref"]
+    else:
+        raise ValueError("The selected producer lineage is invalid.")
+    return {
+        **read_workflow_node_result_page(
+            workflow, run_id, identity.get("task_id"), reference, **result_selectors(identity), offset=offset, limit=limit,
+        ), "output_name": name,
+    }
diff --git a/application/single_app/functions_workflow_flow.py b/application/single_app/functions_workflow_flow.py
new file mode 100644
index 000000000..e8823f6cd
--- /dev/null
+++ b/application/single_app/functions_workflow_flow.py
@@ -0,0 +1,495 @@
+# functions_workflow_flow.py
+"""Bounded structured workflow compiler and deterministic, data-only predicates."""
+
+import json
+import math
+import re
+from copy import deepcopy
+
+from functions_workflow_definitions import (
+    WORKFLOW_BINDABLE_OUTPUTS, WORKFLOW_OUTPUT_KINDS, WorkflowDefinitionError,
+    _boolean, _name, _object, normalize_workflow_output_contract, workflow_output_kind_matches,
+)
+
+
+FLOW_LIMITS = {
+    "max_nodes": 256, "max_depth": 4, "max_predicate_nodes": 100,
+    "max_predicate_depth": 8, "max_executions": 5000, "deadline_seconds": 86400,
+}
+MISSING = object()
+_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}\Z")
+_BAD_POINTER_ESCAPE = re.compile(r"~(?![01])")
+
+
+def _id(value):
+    if not isinstance(value, str) or not _ID.fullmatch(value):
+        raise WorkflowDefinitionError("Flow ids must be stable letters, numbers, dots, colons, underscores or hyphens.")
+    return value
+
+
+def normalize_flow_bindings(values):
+    if not isinstance(values, list) or len(values) > 100:
+        raise WorkflowDefinitionError("Flow inputs must be a list of at most 100 bindings; null is not supported.")
+    result, names = [], set()
+    for value in values:
+        binding = _object(value, {"name", "source", "required", "expected_kind", "allow_partial"}, "Flow binding")
+        name = _name(binding.get("name"), "Binding name")
+        if name in names:
+            raise WorkflowDefinitionError("Binding names must be unique.")
+        names.add(name)
+        source = _object(binding.get("source"), {"kind", "node_id", "output", "scope"}, "Binding source")
+        if source.get("kind") != "node_output" or source.get("scope", "current") != "current":
+            raise WorkflowDefinitionError("M4A bindings support only node_output in the current scope.")
+        output = source.get("output", "authoritative")
+        if not isinstance(output, str) or not output or len(output) > 64:
+            raise WorkflowDefinitionError("A binding output selector is required.")
+        kind = binding.get("expected_kind", "any")
+        if not isinstance(kind, str) or kind not in WORKFLOW_OUTPUT_KINDS:
+            raise WorkflowDefinitionError("Unsupported binding output kind.")
+        result.append({
+            "name": name,
+            "source": {"kind": "node_output", "node_id": _id(source.get("node_id")),
+                       "output": output, "scope": "current"},
+            "required": _boolean(binding.get("required", True), "Required input"),
+            "expected_kind": kind,
+            "allow_partial": _boolean(binding.get("allow_partial", False), "Partial input"),
+        })
+    return result
+
+
+def normalize_predicate(value, bindings):
+    try:
+        encoded = json.dumps(value, allow_nan=False, ensure_ascii=True)
+    except (ValueError, TypeError, RecursionError) as exc:
+        raise WorkflowDefinitionError("A condition must be finite JSON.") from exc
+    if len(encoded) > 16384:
+        raise WorkflowDefinitionError("A condition must be at most 16 KiB.")
+    names = {binding["name"] for binding in bindings}
+    count = 0
+
+    def operand(raw, *, reference_only=False):
+        nonlocal count
+        count += 1
+        if count > 100:
+            raise WorkflowDefinitionError("Conditions are limited to 100 AST nodes.")
+        allowed = {"input", "path"} if reference_only else {"input", "path", "literal"}
+        _object(raw, allowed, "Condition operand")
+        if "literal" in raw:
+            literal = raw["literal"]
+            if len(raw) != 1 or not (
+                literal is None or type(literal) in {str, bool, int}
+                or type(literal) is float and math.isfinite(literal)
+            ):
+                raise WorkflowDefinitionError("Condition literals must be finite JSON scalars.")
+            return {"literal": literal}
+        path = raw.get("path", "")
+        if not isinstance(raw.get("input"), str) or raw["input"] not in names:
+            raise WorkflowDefinitionError("A condition must reference a declared input name.")
+        if not isinstance(path, str) or (path and not path.startswith("/")) or _BAD_POINTER_ESCAPE.search(path):
+            raise WorkflowDefinitionError("Condition paths must be RFC 6901 JSON pointers.")
+        return {"input": raw["input"], "path": path}
+
+    def visit(raw, depth=1):
+        nonlocal count
+        count += 1
+        if count > 100 or depth > 8 or not isinstance(raw, dict):
+            raise WorkflowDefinitionError("Conditions are limited to 100 AST nodes and depth 8.")
+        op = raw.get("op")
+        if not isinstance(op, str):
+            raise WorkflowDefinitionError("A condition requires a supported operator.")
+        if op in {"all", "any"}:
+            _object(raw, {"op", "conditions"}, "Condition")
+            children = raw.get("conditions")
+            if not isinstance(children, list) or not children:
+                raise WorkflowDefinitionError("All/any conditions require a nonempty conditions list.")
+            return {"op": op, "conditions": [visit(child, depth + 1) for child in children]}
+        if op == "not":
+            _object(raw, {"op", "condition"}, "Condition")
+            return {"op": op, "condition": visit(raw.get("condition"), depth + 1)}
+        if op == "exists":
+            _object(raw, {"op", "value"}, "Condition")
+            return {"op": op, "value": operand(raw.get("value"), reference_only=True)}
+        if op in {"eq", "ne", "lt", "lte", "gt", "gte"}:
+            _object(raw, {"op", "left", "right"}, "Condition")
+            return {"op": op, "left": operand(raw.get("left")), "right": operand(raw.get("right"))}
+        raise WorkflowDefinitionError("Unsupported condition operator.")
+
+    return visit(value)
+
+
+def evaluate_predicate(predicate, values):
+    """Values must already have passed authorization and structural validation."""
+    def resolve(operand):
+        if "literal" in operand:
+            return operand["literal"]
+        value = values.get(operand["input"], MISSING)
+        pointer = operand["path"]
+        for token in pointer.split("/")[1:] if pointer else []:
+            token = token.replace("~1", "/").replace("~0", "~")
+            if isinstance(value, dict):
+                value = value.get(token, MISSING)
+            elif isinstance(value, list) and re.fullmatch(r"0|[1-9][0-9]*", token):
+                index = int(token)
+                value = value[index] if index < len(value) else MISSING
+            else:
+                value = MISSING
+        return value
+
+    def json_type(value):
+        if type(value) in {int, float}:
+            return "number"
+        return type(value)
+
+    def equal(left, right):
+        if json_type(left) != json_type(right):
+            return False
+        if isinstance(left, dict):
+            return left.keys() == right.keys() and all(equal(left[key], right[key]) for key in left)
+        if isinstance(left, list):
+            return len(left) == len(right) and all(equal(a, b) for a, b in zip(left, right))
+        return left == right
+
+    def visit(node):
+        op = node["op"]
+        if op == "all":
+            return all(visit(child) for child in node["conditions"])
+        if op == "any":
+            return any(visit(child) for child in node["conditions"])
+        if op == "not":
+            return not visit(node["condition"])
+        if op == "exists":
+            return resolve(node["value"]) is not MISSING
+        left, right = resolve(node["left"]), resolve(node["right"])
+        if left is MISSING or right is MISSING:
+            raise WorkflowDefinitionError("A condition referenced missing data without an exists guard.")
+        if op in {"eq", "ne"}:
+            if any(isinstance(value, (dict, list)) for value in (left, right)):
+                raise WorkflowDefinitionError("Condition comparisons require scalar fields.")
+            return equal(left, right) if op == "eq" else not equal(left, right)
+        if not all(type(value) is int or type(value) is float and math.isfinite(value) for value in (left, right)):
+            raise WorkflowDefinitionError("Ordered condition comparisons require finite numbers.")
+        return {"lt": lambda: left < right, "lte": lambda: left <= right,
+                "gt": lambda: left > right, "gte": lambda: left >= right}[op]()
+
+    return visit(predicate)
+
+
+def compile_workflow_flow(workflow):
+    """Normalize and prove lexical visibility and definite availability on every path."""
+    if workflow.get("definition_version") != 3 or workflow.get("durable_execution") is not True:
+        raise WorkflowDefinitionError("Structured workflows require definition version 3 and durable execution.")
+    tasks = workflow.get("tasks")
+    if not isinstance(tasks, list) or not tasks or len(tasks) > 100:
+        raise WorkflowDefinitionError("A workflow catalogue requires 1 to 100 tasks.")
+    catalogue = {}
+    for task in tasks:
+        if not isinstance(task, dict):
+            raise WorkflowDefinitionError("A task catalogue entry must be an object.")
+        if task.keys() - {
+            "id", "type", "name", "instructions", "order", "runner", "document_action", "inputs",
+            "reference_ids", "output_contract", "approval", "publication",
+        }:
+            raise WorkflowDefinitionError("A catalogue task contains unsupported executable fields.")
+        if task.get("type", "instructions") != "instructions":
+            raise WorkflowDefinitionError("The task catalogue supports only existing instruction tasks.")
+        instructions = task.get("instructions")
+        if not isinstance(instructions, str) or not instructions.strip() or len(instructions) > 12000:
+            raise WorkflowDefinitionError("Task instructions must be nonempty text of at most 12000 characters.")
+        runner = task.get("runner", {"type": "inherit"})
+        if not isinstance(runner, dict) or runner.get("type", "inherit") not in ("inherit", "model", "agent"):
+            raise WorkflowDefinitionError("A task requires an existing workflow runner.")
+        _object(runner, {
+            "type", "selected_agent", "model_endpoint_id", "model_id", "model_provider", "model_binding_summary",
+        }, "Task runner")
+        identifier = _id(task.get("id"))
+        if identifier in catalogue:
+            raise WorkflowDefinitionError("Task catalogue ids must be unique.")
+        catalogue[identifier] = {**deepcopy(task), "inputs": normalize_flow_bindings(task.get("inputs", []))}
+        if task.get("output_contract") is not None:
+            catalogue[identifier]["output_contract"] = normalize_workflow_output_contract(task["output_contract"])
+        if task.get("approval") is not None:
+            approval = _object(task["approval"], {"required", "message"}, "Task approval")
+            _boolean(approval.get("required", False), "Task approval requirement")
+            if not isinstance(approval.get("message", ""), str) or len(approval.get("message", "")) > 1000:
+                raise WorkflowDefinitionError("Task approval text must be at most 1000 characters.")
+    error_handling = workflow.get("error_handling") or {}
+    _object(error_handling, {"strategy", "retry_count"}, "Error handling")
+    retries = error_handling.get("retry_count", 0)
+    if type(retries) is not int or not 0 <= retries <= 5 or error_handling.get("strategy", "halt") not in ("halt", "continue"):
+        raise WorkflowDefinitionError("Error handling supports halt/continue with zero to five retries.")
+    if any(key in workflow for key in ("max_executions", "deadline_seconds")):
+        raise WorkflowDefinitionError("Run budgets belong in the explicit limits object.")
+    raw_limits = _object(workflow.get("limits", {}), {"max_executions", "deadline_seconds"}, "Run limits")
+    limits = {}
+    for key in ("max_executions", "deadline_seconds"):
+        value = raw_limits.get(key, FLOW_LIMITS[key])
+        if type(value) is not int or not 1 <= value <= FLOW_LIMITS[key]:
+            raise WorkflowDefinitionError(f"{key} must be an integer between 1 and {FLOW_LIMITS[key]}.")
+        limits[key] = value
+    ids, nodes, regions, task_nodes, successor, dependencies = set(), {}, {}, {}, {}, {}
+
+    def register(identifier):
+        identifier = _id(identifier)
+        if identifier in ids or len(ids) >= FLOW_LIMITS["max_nodes"]:
+            raise WorkflowDefinitionError("All flow region, node and join ids must be unique; at most 256 are supported.")
+        ids.add(identifier)
+        return identifier
+
+    def region(raw, depth, *, root=False, parent=None):
+        if depth > 4:
+            raise WorkflowDefinitionError("Flow regions are limited to depth 4.")
+        _object(raw, {"id", "nodes", "outputs"} if root else {"id", "nodes"}, "Flow region")
+        result = {"id": register(raw.get("id")), "nodes": []}
+        children = raw.get("nodes")
+        if not isinstance(children, list) or len(children) > 256:
+            raise WorkflowDefinitionError("A flow region requires a bounded nodes list.")
+        regions[result["id"]] = {"region": result, "parent": parent}
+        for child in children:
+            if not isinstance(child, dict):
+                raise WorkflowDefinitionError("A flow node must be an object.")
+            kind = child.get("kind")
+            allowed = {
+                "task": {"id", "kind", "task_id", "run_when"},
+                "if": {"id", "kind", "inputs", "condition", "then", "else", "join"},
+                "route": {"id", "kind", "inputs", "condition", "target"},
+            }
+            if not isinstance(kind, str) or kind not in allowed:
+                raise WorkflowDefinitionError("Only task, if and route nodes are executable in M4A.")
+            _object(child, allowed[kind], "Flow node")
+            node = {"id": register(child.get("id")), "kind": kind}
+            nodes[node["id"]] = {"node": node, "region_id": result["id"]}
+            if kind == "task":
+                task_id = _id(child.get("task_id"))
+                if task_id not in catalogue or task_id in task_nodes:
+                    raise WorkflowDefinitionError("Each catalogue task must occur exactly once in the flow.")
+                task_nodes[task_id] = node["id"]
+                node["task_id"] = task_id
+                if "run_when" in child:
+                    node["run_when"] = normalize_predicate(child["run_when"], catalogue[task_id]["inputs"])
+            else:
+                node["inputs"] = normalize_flow_bindings(child.get("inputs"))
+                node["condition"] = normalize_predicate(child.get("condition"), node["inputs"])
+                if kind == "route":
+                    target = _object(child.get("target"), {"node_id", "exit_region_id"}, "Route target")
+                    if len(target) != 1:
+                        raise WorkflowDefinitionError("A route needs one explicit forward or region-exit target.")
+                    node["target"] = {key: _id(value) for key, value in target.items()}
+                else:
+                    node["then"] = region(child.get("then"), depth + 1, parent=node["id"])
+                    node["else"] = region(child.get("else"), depth + 1, parent=node["id"])
+                    join = _object(child.get("join"), {"id", "exports"}, "If join")
+                    join_id = register(join.get("id"))
+                    exports = join.get("exports")
+                    if not isinstance(exports, list) or len(exports) > 100:
+                        raise WorkflowDefinitionError("A join requires an exports list of at most 100 entries.")
+                    normalized, names = [], set()
+                    for export in exports:
+                        _object(export, {"name", "expected_kind", "required", "then", "else"}, "Join export")
+                        name = _name(export.get("name"), "Join export name")
+                        expected = export.get("expected_kind", "any")
+                        if name in names or not isinstance(expected, str) or expected not in WORKFLOW_OUTPUT_KINDS:
+                            raise WorkflowDefinitionError("Join exports require unique names and a supported kind.")
+                        names.add(name)
+                        entry = {"name": name, "expected_kind": expected,
+                                 "required": _boolean(export.get("required", True), "Required join export")}
+                        for branch in ("then", "else"):
+                            source = _object(export.get(branch), {"node_id", "output"}, "Join producer")
+                            output = source.get("output", "authoritative")
+                            if not isinstance(output, str) or not output or len(output) > 64:
+                                raise WorkflowDefinitionError("A join needs an exact output selector.")
+                            entry[branch] = {"node_id": _id(source.get("node_id")), "output": output}
+                        normalized.append(entry)
+                    node["join"] = {"id": join_id, "exports": normalized}
+                    nodes[join_id] = {"node": {"id": join_id, "kind": "join", "exports": normalized},
+                                      "region_id": result["id"], "if_id": node["id"]}
+            result["nodes"].append(node)
+        if root:
+            if "outputs" not in raw:
+                raise WorkflowDefinitionError("The root flow must declare outputs, including an explicit empty list.")
+            result["outputs"] = normalize_flow_bindings(raw["outputs"])
+        return result
+
+    flow = region(workflow.get("flow"), 1, root=True)
+    if set(catalogue) != set(task_nodes):
+        raise WorkflowDefinitionError("Every catalogue task must occur exactly once in the executable flow.")
+
+    def descriptor(node_id, output):
+        entry = nodes.get(node_id)
+        if not entry:
+            raise WorkflowDefinitionError("A binding references a missing producer node.")
+        node = entry["node"]
+        if node["kind"] == "join":
+            export = next((item for item in node["exports"] if item["name"] == output), None)
+            if export is None:
+                raise WorkflowDefinitionError("The selected join output is not declared.")
+            return export["expected_kind"]
+        if node["kind"] != "task" or output not in WORKFLOW_BINDABLE_OUTPUTS:
+            raise WorkflowDefinitionError("Only task final representations and declared join exports can supply inputs.")
+        contract = catalogue[node["task_id"]].get("output_contract") or {}
+        declared = contract.get("kind", "any")
+        if output not in {"authoritative", "text"} and declared not in {
+            "any", {"records": "records", "json": "json", "documents": "document_results"}[output],
+        }:
+            raise WorkflowDefinitionError("The selected representation does not match its producer's output contract.")
+        kind = {"text": "text", "records": "records", "json": "json", "documents": "document_results"}.get(
+            output, contract.get("kind", "any"),
+        )
+        return kind
+
+    def check_bindings(bindings, definite, possible, consumer):
+        dependencies.setdefault(consumer, [])
+        for binding in bindings:
+            source = binding["source"]
+            key = (source["node_id"], source["output"])
+            kind = descriptor(*key)
+            if key not in possible:
+                raise WorkflowDefinitionError("An input references a future, unreachable or out-of-region producer.")
+            if binding["required"] and key not in definite:
+                raise WorkflowDefinitionError("A required producer is unavailable on a reachable path; use an optional input or join export.")
+            if kind != "any" and not workflow_output_kind_matches(kind, binding["expected_kind"]):
+                raise WorkflowDefinitionError("A binding's expected kind does not match its producer.")
+            dependencies[consumer].append(key)
+
+    def task_keys(node):
+        declared = (catalogue[node["task_id"]].get("output_contract") or {}).get("kind", "any")
+        selectors = {"authoritative", "text"}
+        selectors.update({"json": {"json"}, "records": {"records"}, "document_results": {"documents"}}.get(declared, set()))
+        return {(node["id"], output) for output in selectors}
+
+    def structured_output(node_id, output, active=None):
+        active = set() if active is None else set(active)
+        key = (node_id, output)
+        if key in active:
+            return False
+        active.add(key)
+        node = nodes[node_id]["node"]
+        if node["kind"] == "join":
+            export = next(item for item in node["exports"] if item["name"] == output)
+            return all(structured_output(export[branch]["node_id"], export[branch]["output"], active)
+                       for branch in ("then", "else"))
+        contract = catalogue[node["task_id"]].get("output_contract") or {}
+        schema = contract.get("schema") or {}
+        root_types = schema.get("type")
+        root_types = {root_types} if isinstance(root_types, str) else set(root_types or [])
+        return (
+            bool(root_types) and root_types <= {"object", "array"}
+            and contract.get("kind", "any") in {"any", "json", "records", "document_results"}
+            and output in {"authoritative", "json", "records", "documents"}
+        )
+
+    def check_predicate(predicate, bindings):
+        used = {binding["name"]: binding for binding in bindings}
+
+        def schemas(node_id, output):
+            node = nodes[node_id]["node"]
+            if node["kind"] == "join":
+                export = next(item for item in node["exports"] if item["name"] == output)
+                return [schema for branch in ("then", "else")
+                        for schema in schemas(export[branch]["node_id"], export[branch]["output"])]
+            return [catalogue[node["task_id"]]["output_contract"]["schema"]]
+
+        def operand_types(operand, *, scalar=True):
+            if "literal" in operand:
+                value = operand["literal"]
+                return [{"null" if value is None else "boolean" if type(value) is bool
+                         else "number" if type(value) in {int, float} else "string"}]
+            source = used[operand["input"]]["source"]
+            if not structured_output(source["node_id"], source["output"]):
+                raise WorkflowDefinitionError("Conditions require JSON or record fields with an explicit schema on every possible producer.")
+            types = []
+            for schema in schemas(source["node_id"], source["output"]):
+                field = schema
+                for token in operand["path"].split("/")[1:] if operand["path"] else []:
+                    token = token.replace("~1", "/").replace("~0", "~")
+                    if field.get("type") == "array" and re.fullmatch(r"0|[1-9][0-9]*", token):
+                        field = field.get("items")
+                    else:
+                        field = field.get("properties", {}).get(token)
+                    if not isinstance(field, dict):
+                        raise WorkflowDefinitionError("A condition field must be declared in every possible producer schema.")
+                field_type = field.get("type")
+                selected = {field_type} if isinstance(field_type, str) else set(field_type or [])
+                if not selected or scalar and not selected <= {"string", "boolean", "number", "integer", "null"}:
+                    raise WorkflowDefinitionError("Condition comparisons require explicitly typed scalar fields.")
+                types.append(selected)
+            return types
+
+        def visit(node):
+            if node["op"] in {"all", "any"}:
+                for child in node["conditions"]:
+                    visit(child)
+            elif node["op"] == "not":
+                visit(node["condition"])
+            elif node["op"] == "exists":
+                operand_types(node["value"], scalar=False)
+            else:
+                types = operand_types(node["left"]) + operand_types(node["right"])
+                if node["op"] in {"lt", "lte", "gt", "gte"} and any(
+                    not values.intersection({"number", "integer"}) for values in types
+                ):
+                    raise WorkflowDefinitionError("Ordered conditions require numeric fields and literal values.")
+
+        visit(predicate)
+
+    def intersect(states):
+        return set.intersection(*(state[0] for state in states)), set.union(*(state[1] for state in states))
+
+    def analyze(current, initial, *, branch=False):
+        children = current["nodes"]
+        positions = {node["id"]: index for index, node in enumerate(children)}
+        incoming = {0: [initial]}
+        exits = []
+        for index, node in enumerate(children):
+            if index not in incoming:
+                raise WorkflowDefinitionError("The flow contains an unreachable node.")
+            definite, possible = intersect(incoming[index])
+            after_definite, after_possible = set(definite), set(possible)
+            kind = node["kind"]
+            bindings = catalogue[node["task_id"]]["inputs"] if kind == "task" else node["inputs"]
+            check_bindings(bindings, definite, possible, node["id"])
+            if kind != "task" or "run_when" in node:
+                check_predicate(node["run_when"] if kind == "task" else node["condition"], bindings)
+            if kind == "task":
+                keys = task_keys(node)
+                after_possible.update({(node["id"], output) for output in WORKFLOW_BINDABLE_OUTPUTS})
+                if "run_when" not in node:
+                    after_definite.update(keys)
+                if catalogue[node["task_id"]].get("publication") is not None and len(bindings) != 1:
+                    raise WorkflowDefinitionError("A v3 publication task requires exactly one explicit upstream input.")
+            elif kind == "if":
+                ends = {name: analyze(node[name], (set(definite), set(possible)), branch=True)
+                        for name in ("then", "else")}
+                for export in node["join"]["exports"]:
+                    for name in ("then", "else"):
+                        producer = export[name]
+                        binding = {"name": export["name"], "source": producer, "required": export["required"],
+                                   "expected_kind": export["expected_kind"]}
+                        check_bindings([binding], *ends[name], node["join"]["id"])
+                    key = (node["join"]["id"], export["name"])
+                    after_possible.add(key)
+                    if export["required"]:
+                        after_definite.add(key)
+            elif kind == "route":
+                target = node["target"]
+                if "exit_region_id" in target:
+                    if not branch or target["exit_region_id"] != current["id"]:
+                        raise WorkflowDefinitionError("A region exit may target only its current structured branch join.")
+                    exits.append((set(definite), set(possible)))
+                else:
+                    destination = positions.get(target["node_id"])
+                    if destination is None or destination <= index:
+                        raise WorkflowDefinitionError("Routes may target only a later sibling node.")
+                    incoming.setdefault(destination, []).append((set(definite), set(possible)))
+            successor[node["id"]] = children[index + 1]["id"] if index + 1 < len(children) else None
+            incoming.setdefault(index + 1, []).append((after_definite, after_possible))
+        exits.extend(incoming.get(len(children), []))
+        return intersect(exits or [initial])
+
+    definite, possible = analyze(flow, (set(), set()))
+    check_bindings(flow["outputs"], definite, possible, flow["id"])
+    return {
+        "flow": flow, "tasks": list(catalogue.values()), "limits": limits,
+        "nodes": nodes, "regions": regions, "task_nodes": task_nodes,
+        "successor": successor, "dependencies": dependencies,
+        "definite_outputs": definite, "possible_outputs": possible,
+    }
diff --git a/application/single_app/functions_workflow_flow_runner.py b/application/single_app/functions_workflow_flow_runner.py
new file mode 100644
index 000000000..594b67bb0
--- /dev/null
+++ b/application/single_app/functions_workflow_flow_runner.py
@@ -0,0 +1,299 @@
+# functions_workflow_flow_runner.py
+"""Structured traversal around the existing task dispatcher, with frozen decisions."""
+
+import json
+from copy import deepcopy
+
+from functions_workflow_bindings import WorkflowInputError
+from functions_analysis_access import AnalysisResultUnavailable
+from functions_workflow_definitions import workflow_output_kind_matches
+from functions_workflow_flow import MISSING, compile_workflow_flow, evaluate_predicate
+from functions_workflow_identity import canonical_digest, workflow_node_identity
+from functions_workflow_node_results import load_workflow_node_input
+from functions_workflow_results import _build_task_result, persist_workflow_task_result, workflow_result_summary
+
+
+class WorkflowFlowRunner:
+    def __init__(self, workflow, run_id, execution, task_results, *, actor_user_id, settings=None,
+                 load_output=load_workflow_node_input, persist=persist_workflow_task_result):
+        self.workflow = workflow
+        self.run_id = run_id
+        self.execution = execution
+        self.task_results = task_results
+        self.actor_user_id = actor_user_id
+        self.settings = settings or {}
+        self.load_output = load_output
+        self.persist = persist
+        self.compiled = compile_workflow_flow(workflow)
+        self.catalogue = {task["id"]: task for task in self.compiled["tasks"]}
+        self.completed = {}
+        self.final_outputs = []
+        self.partial = False
+        self.failed = False
+        self.finished = False
+        self.control_receipts = []
+
+    @staticmethod
+    def _receipts(values):
+        return list({canonical_digest(value): value for value in values}.values())
+
+    @staticmethod
+    def _control_receipt(summary):
+        name = "decision" if "decision" in summary["outputs"] else summary["authoritative_output"]
+        return {"producer": summary["producer"], "result_ref": summary["result_ref"],
+                "output_name": name, "output_ref": summary["outputs"][name]["result_ref"],
+                "control": True}
+
+    def resolve(self, bindings, *, condition=None):
+        inputs, receipts, values = [], [], {}
+        for binding in bindings:
+            source = binding["source"]
+            producer = self.completed.get(source["node_id"])
+            if producer is None or producer.get("state") == "skipped":
+                if binding["required"]:
+                    raise WorkflowInputError("A required producer was intentionally skipped or did not finish.")
+                inputs.append({"name": binding["name"], "status": "unavailable"})
+                values[binding["name"]] = MISSING
+                continue
+            if producer.get("state") not in {"succeeded", "completed", "completed_partial"}:
+                raise WorkflowInputError("The selected producer is failed, invalid or pending, not optional absence.")
+            summary = producer["summary"]
+            try:
+                prompt, receipt = self.load_output(
+                    self.workflow, self.run_id, summary["producer"], summary["result_ref"],
+                    output_name=source["output"], allow_partial=binding["allow_partial"],
+                    reader_user_id=self.actor_user_id, required=binding["required"],
+                )
+            except AnalysisResultUnavailable:
+                from functions_workflow_execution import execution_fingerprint
+
+                self.execution._pause(self.execution.node["id"], execution_fingerprint(summary))
+            if prompt is None:
+                inputs.append({"name": binding["name"], "status": "unavailable"})
+                values[binding["name"]] = MISSING
+                continue
+            payload = json.loads(prompt)
+            if not workflow_output_kind_matches(payload["kind"], binding["expected_kind"]):
+                raise WorkflowInputError("The input does not match its declared output kind.")
+            if condition is not None and binding["name"] in condition:
+                validation = summary.get("workflow_validation") or {}
+                if validation.get("eligible") is not True or not producer.get("structured_validated"):
+                    raise WorkflowInputError("Conditions require structurally validated output fields.")
+            if (summary.get("workflow_validation") or {}).get("status") == "accepted_partial":
+                self.partial = True
+            values[binding["name"]] = payload["value"]
+            inputs.append({"name": binding["name"], "status": "available", "result": payload})
+            receipts.append({**receipt, "input_name": binding["name"]})
+        return {
+            "task_context": json.dumps({"inputs": inputs}, ensure_ascii=False, sort_keys=True) if inputs else "",
+            "consumed_inputs": self._receipts([*receipts, *self.control_receipts]),
+            "bound_inputs": receipts, "values": values,
+        }
+
+    @staticmethod
+    def _predicate_names(predicate):
+        names, pending = set(), [predicate]
+        while pending:
+            value = pending.pop()
+            if isinstance(value, dict):
+                if "input" in value:
+                    names.add(value["input"])
+                pending.extend(value.values())
+            elif isinstance(value, list):
+                pending.extend(value)
+        return names
+
+    def _admit_control(self, node):
+        admitted_by_condition = node["kind"] == "task" and self.execution.store.journal_read(
+            "decision", ["control", self.execution.execution_id()],
+        ) is not None
+        self.execution.store.journal_commit(
+            self.execution.lease.token, "admission", [self.execution.execution_id(), 1],
+            {"execution_id": self.execution.execution_id(), "attempt": 1},
+            admission=not admitted_by_condition, immutable=True,
+            updates={"cursor": {"region_id": self.execution.region_id, "node_id": node["id"]}, "phase": node["id"]},
+        )
+
+    def _control_result(self, node, choice, receipts):
+        identity = workflow_node_identity(
+            self.workflow, self.run_id, node["id"], self.execution.execution_id(), 1,
+            task_id=node.get("task_id"),
+        )
+        envelope = _build_task_result(
+            {"reply": "", "authoritative_result": {"kind": "json", "value": choice}},
+            identity, "workflow-result-v2",
+        )
+        envelope["consumed_inputs"] = receipts
+        envelope["workflow_validation"] = {"version": 1, "status": "valid", "eligible": True, "reason_codes": []}
+        if node["kind"] == "task":
+            envelope["outputs"] = {"decision": envelope["outputs"]["json"]}
+            envelope["authoritative_output"] = None
+            envelope["execution"]["status"] = "skipped" if choice["choice"] == "skip" else "succeeded"
+        manifest, reference = self.persist(
+            envelope, workflow=self.workflow, run_id=self.run_id, task_id=node.get("task_id"), settings=self.settings,
+        )
+        return workflow_result_summary(manifest, reference)
+
+    def _decision(self, node, inputs, choose):
+        from functions_workflow_execution import execution_fingerprint
+
+        digest = execution_fingerprint({"context": inputs["task_context"], "consumed_inputs": inputs["consumed_inputs"]})
+        key = ["control", self.execution.execution_id()]
+        saved = self.execution.store.journal_read("decision", key)
+        if saved:
+            if saved["payload"]["input_digest"] != digest:
+                self.execution._pause(node["id"], digest)
+            choice = saved["payload"]["decision"]
+        else:
+            choice = choose()
+            self.execution.store.journal_commit(
+                self.execution.lease.token, "decision", key, {
+                    "execution_id": self.execution.execution_id(), "node_id": node["id"], "attempt": 1,
+                    "iteration_path": [], "input_digest": digest, "decision": choice,
+                    "consumed_inputs": inputs["consumed_inputs"],
+                }, updates={"cursor": {"region_id": self.execution.region_id, "node_id": node["id"]}},
+                admission=True, immutable=True,
+            )
+        return choice
+
+    def _skip(self, node, region_id, reason):
+        self.execution.set_node(node, region_id)
+        self._admit_control(node)
+        decision = self.execution.store.journal_read("decision", ["control", self.execution.execution_id()])
+        receipts = self._receipts([*((decision or {}).get("payload", {}).get("consumed_inputs") or []), *self.control_receipts])
+        self.execution.finish_node(state="skipped", attempt=0, reason_code=reason, consumed_inputs=receipts)
+        self.completed[node["id"]] = {"state": "skipped"}
+        if node["kind"] == "if":
+            for branch in ("then", "else"):
+                for child in node[branch]["nodes"]:
+                    self._skip(child, node[branch]["id"], reason)
+            join = self.compiled["nodes"][node["join"]["id"]]["node"]
+            self._skip(join, region_id, reason)
+
+    def _join(self, node, region_id, branch, decision_summary):
+        join = self.compiled["nodes"][node["join"]["id"]]["node"]
+        self.execution.set_node(join, region_id)
+        receipts = [{
+            "producer": decision_summary["producer"], "result_ref": decision_summary["result_ref"],
+            "output_name": decision_summary["authoritative_output"],
+            "output_ref": decision_summary["outputs"][decision_summary["authoritative_output"]]["result_ref"],
+        }]
+        exports, structured = {}, True
+        for export in node["join"]["exports"]:
+            source = export[branch]
+            binding = {
+                "name": export["name"], "source": source, "expected_kind": export["expected_kind"],
+                "required": export["required"], "allow_partial": True,
+            }
+            resolved = self.resolve([binding])
+            if not resolved["bound_inputs"]:
+                continue
+            selected = resolved["bound_inputs"][0]
+            receipts.append(selected)
+            producer = self.completed[source["node_id"]]
+            structured = structured and producer.get("structured_validated", False)
+            descriptor = producer["summary"]["outputs"][selected["output_name"]]
+            exports[export["name"]] = {
+                "kind": descriptor["kind"], "result_ref": selected["output_ref"],
+                "selected_producer": selected,
+            }
+        self._admit_control(join)
+        receipts = self._receipts([*receipts, *self.control_receipts])
+        summary = self._control_result(join, {"choice": branch}, receipts)
+        # Export descriptors point to the selected producer, never concatenated/reconstructed values.
+        identity = summary["producer"]
+        from functions_workflow_result_store import load_workflow_node_result, save_workflow_node_result
+        from functions_workflow_node_results import result_selectors
+
+        manifest = load_workflow_node_result(
+            self.workflow, self.run_id, None, summary["result_ref"], **result_selectors(identity),
+        )
+        manifest["outputs"] = exports
+        manifest["authoritative_output"] = next(iter(exports), None)
+        reference = save_workflow_node_result(
+            self.workflow, self.run_id, None, manifest, settings=self.settings, **result_selectors(identity),
+        )
+        summary = workflow_result_summary(manifest, reference)
+        self.completed[join["id"]] = {"state": "completed", "summary": summary, "structured_validated": structured}
+        self.execution.finish_node(state="completed", attempt=1, decision={"choice": branch}, workflow_result=summary,
+                                   consumed_inputs=receipts)
+
+    def _region(self, region):
+        children = region["nodes"]
+        index = 0
+        while index < len(children):
+            node = children[index]
+            self.execution.set_node(node, region["id"])
+            self.execution.check()
+            if node["kind"] == "task":
+                task = deepcopy(self.catalogue[node["task_id"]])
+                if "run_when" in node:
+                    inputs = self.resolve(task["inputs"], condition=self._predicate_names(node["run_when"]))
+                    choice = self._decision(node, inputs, lambda: {
+                        "choice": "run" if evaluate_predicate(node["run_when"], inputs["values"]) else "skip",
+                    })
+                    control_summary = self._control_result(node, choice, inputs["consumed_inputs"])
+                    self.control_receipts.append(self._control_receipt(control_summary))
+                    if choice["choice"] == "skip":
+                        self._skip(node, region["id"], "run_when_false")
+                        index += 1
+                        continue
+                yield task
+                checkpoint = next((item for item in reversed(self.task_results) if item["task"]["id"] == task["id"]), None)
+                if checkpoint is None:
+                    raise WorkflowInputError("A selected task did not save an execution outcome.")
+                result = checkpoint.get("result") or {}
+                summary = result.get("workflow_result")
+                state = checkpoint["status"]
+                if summary:
+                    self.completed[node["id"]] = {
+                        "state": state, "summary": summary,
+                        "structured_validated": bool((task.get("output_contract") or {}).get("schema")),
+                    }
+                    self.execution.finish_node(
+                        state=state, workflow_result=summary, workflow_validation=result.get("workflow_validation"),
+                        consumed_inputs=checkpoint.get("consumed_inputs") or [],
+                    )
+                    self.partial |= (result.get("workflow_validation") or {}).get("status") == "accepted_partial"
+                else:
+                    self.completed[node["id"]] = {"state": "failed"}
+                    self.execution.finish_node(state="failed", reason_code="task_failed")
+                self.failed |= state not in {"succeeded", "completed"}
+            else:
+                inputs = self.resolve(node["inputs"], condition=self._predicate_names(node["condition"]))
+                choice = self._decision(node, inputs, lambda: (
+                    {"choice": "then" if evaluate_predicate(node["condition"], inputs["values"]) else "else"}
+                    if node["kind"] == "if" else
+                    {"target": node["target"] if evaluate_predicate(node["condition"], inputs["values"]) else None}
+                ))
+                summary = self._control_result(node, choice, inputs["consumed_inputs"])
+                self.control_receipts.append(self._control_receipt(summary))
+                self.completed[node["id"]] = {"state": "completed", "summary": summary, "structured_validated": True}
+                self.execution.finish_node(state="completed", attempt=1, decision=choice, workflow_result=summary,
+                                           consumed_inputs=inputs["consumed_inputs"])
+                if node["kind"] == "if":
+                    branch = choice["choice"]
+                    other = "else" if branch == "then" else "then"
+                    for child in node[other]["nodes"]:
+                        self._skip(child, node[other]["id"], "unselected_branch")
+                    yield from self._region(node[branch])
+                    self._join(node, region["id"], branch, summary)
+                elif choice.get("target"):
+                    target = choice["target"]
+                    destination = next(
+                        (position for position, child in enumerate(children) if child["id"] == target.get("node_id")),
+                        len(children),
+                    )
+                    for child in children[index + 1:destination]:
+                        self._skip(child, region["id"], "forward_route")
+                    index = destination
+                    continue
+            index += 1
+
+    def tasks(self):
+        yield from self._region(self.compiled["flow"])
+        self.final_outputs = self.resolve(self.compiled["flow"]["outputs"])["bound_inputs"]
+        self.execution._update(self.execution.check(), {"progress": {
+            "completed": len(self.completed), "total": len(self.compiled["nodes"]),
+        }})
+        self.finished = True
diff --git a/application/single_app/functions_workflow_identity.py b/application/single_app/functions_workflow_identity.py
new file mode 100644
index 000000000..a33d42dd9
--- /dev/null
+++ b/application/single_app/functions_workflow_identity.py
@@ -0,0 +1,60 @@
+# functions_workflow_identity.py
+"""Stable authorized node/execution identity, independent of a mutable attempt."""
+
+import hashlib
+import json
+
+from functions_workflow_definitions import workflow_definition_revision
+
+
+def canonical_digest(value):
+    encoded = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True, allow_nan=False)
+    return hashlib.sha256(encoded.encode("ascii")).hexdigest()
+
+
+def workflow_execution_id(workflow, run_id, node_id, iteration_path=None):
+    path = [] if iteration_path is None else iteration_path
+    if not isinstance(path, list) or path:
+        raise ValueError("M4A executions require an empty iteration path.")
+    if not all(isinstance(value, str) and value for value in (workflow.get("id"), workflow.get("user_id"), run_id, node_id)):
+        raise ValueError("An execution requires its authorized workflow, run and node.")
+    return canonical_digest({
+        "scope_type": "group" if workflow.get("group_id") else "personal",
+        "scope_id": workflow.get("group_id") or workflow["user_id"],
+        "workflow_id": workflow["id"], "run_id": run_id,
+        "definition_revision": workflow_definition_revision(workflow),
+        "node_id": node_id, "iteration_path": path,
+    })
+
+
+def workflow_node_identity(workflow, run_id, node_id, execution_id, attempt, *, task_id=None, iteration_path=None):
+    path = [] if iteration_path is None else iteration_path
+    if execution_id != workflow_execution_id(workflow, run_id, node_id, path) or type(attempt) is not int or attempt < 1:
+        raise ValueError("The execution or attempt does not match its authorized producer.")
+    if workflow.get("definition_version") != 3:
+        raise ValueError("Exact node identities require a structured workflow.")
+    matched = node_id == workflow.get("flow", {}).get("id") and task_id is None
+    pending = list(workflow.get("flow", {}).get("nodes") or [])
+    checked = 0
+    while pending:
+        node = pending.pop()
+        checked += 1
+        if checked > 256:
+            raise ValueError("The saved flow identity is not bounded.")
+        if node.get("id") == node_id:
+            matched = node.get("task_id") == task_id
+        if node.get("kind") == "if":
+            matched |= node.get("join", {}).get("id") == node_id and task_id is None
+            pending.extend(node.get("then", {}).get("nodes") or [])
+            pending.extend(node.get("else", {}).get("nodes") or [])
+    if not matched:
+        raise ValueError("The node and task identity do not match the saved flow.")
+    identity = {
+        "workflow_id": workflow["id"], "run_id": run_id, "node_id": node_id,
+        "execution_id": execution_id, "iteration_path": list(path), "attempt": attempt,
+    }
+    if task_id is not None:
+        if not isinstance(task_id, str) or not task_id:
+            raise ValueError("A task producer requires a real task id.")
+        identity["task_id"] = task_id
+    return identity
diff --git a/application/single_app/functions_workflow_journal.py b/application/single_app/functions_workflow_journal.py
new file mode 100644
index 000000000..741899412
--- /dev/null
+++ b/application/single_app/functions_workflow_journal.py
@@ -0,0 +1,336 @@
+# functions_workflow_journal.py
+"""Paged schema-2 journal records in the existing fenced workflow partition."""
+
+import base64
+import json
+from copy import deepcopy
+
+from azure.cosmos import exceptions as cosmos_exceptions
+
+from functions_workflow_identity import canonical_digest, workflow_execution_id
+
+
+JOURNAL_TYPE = "workflow_runtime_journal"
+JOURNAL_KINDS = frozenset({"execution", "attempt", "unit", "decision", "request", "admission"})
+PUBLIC_EXECUTION_FIELDS = (
+    "execution_id", "node_id", "node_kind", "task_id", "iteration_path", "region_id",
+    "sequence", "state", "attempt", "reason_code", "decision", "workflow_result",
+    "workflow_validation", "consumed_inputs", "started_at", "completed_at",
+)
+PUBLIC_DECISION_FIELDS = (
+    "sequence", "execution_id", "node_id", "iteration_path", "attempt", "gate_id",
+    "gate_kind", "choice", "decision", "actor_user_id", "decided_at", "reason_code", "input_digest",
+)
+
+
+def journal_record_id(kind, key):
+    return f"workflow-journal:v2:{kind}:{canonical_digest(key)}"
+
+
+class WorkflowJournalMixin:
+    """Atomic decision/cursor/admission updates; control does not grow per execution."""
+
+    def journal_read(self, kind, key):
+        self._read_control()
+        if kind not in JOURNAL_KINDS:
+            raise ValueError("Unsupported workflow journal record kind.")
+        try:
+            row = self.container.read_item(
+                item=journal_record_id(kind, key), partition_key=self.identity["run_id"],
+            )
+        except cosmos_exceptions.CosmosResourceNotFoundError:
+            return None
+        if (
+            any(row.get(name) != value for name, value in self.identity.items())
+            or row.get("type") != JOURNAL_TYPE or row.get("record_kind") != kind or row.get("key") != key
+        ):
+            self._journal_conflict("identity_mismatch")
+        return row
+
+    @staticmethod
+    def _journal_conflict(code):
+        # Runtime store imports this mixin; resolve its public error only at use.
+        from functions_workflow_runtime_store import WorkflowRuntimeConflict
+
+        raise WorkflowRuntimeConflict(code)
+
+    def journal_commit(self, token, kind, key, payload, *, updates=None, admission=False, immutable=False):
+        if kind not in JOURNAL_KINDS:
+            raise ValueError("Unsupported workflow journal record kind.")
+        identifier = journal_record_id(kind, key)
+        for _ in range(8):
+            control = self._read_control()
+            self._assert_current_owned(control, token)
+            if control.get("schema_version") != 2:
+                self._journal_conflict("schema_mismatch")
+            previous = self.journal_read(kind, key)
+            if previous is not None and immutable:
+                if previous.get("payload") != payload:
+                    self._journal_conflict("immutable_conflict")
+                return previous
+            replacement = self._base_replacement(control)
+            if admission and previous is None:
+                admitted = int(control.get("admitted_count") or 0)
+                if admitted >= control["max_executions"]:
+                    from functions_workflow_execution import WorkflowSuspended
+
+                    self.pause_execution_limit(token, "execution_budget_exceeded")
+                    raise WorkflowSuspended("paused")
+                replacement["admitted_count"] = admitted + 1
+            if self._now().isoformat() >= control["deadline_at"]:
+                from functions_workflow_execution import WorkflowSuspended
+
+                self.pause_execution_limit(token, "deadline_exceeded")
+                raise WorkflowSuspended("paused")
+            sequence = previous["sequence"] if previous else int(control.get("journal_sequence") or 0) + 1
+            if previous is None:
+                replacement["journal_sequence"] = sequence
+                counts = dict(control.get("journal_counts") or {})
+                counts[kind] = int(counts.get(kind) or 0) + 1
+                replacement["journal_counts"] = counts
+            if kind == "unit":
+                was_completed = bool(previous and previous["payload"].get("state") == "completed")
+                is_completed = payload.get("state") == "completed"
+                replacement["completed_unit_count"] = int(control.get("completed_unit_count") or 0) + int(is_completed) - int(was_completed)
+            if updates:
+                if set(updates) - {"cursor", "progress", "phase", "state", "gate", "lease"}:
+                    self._journal_conflict("invalid_payload")
+                replacement.update(deepcopy(updates))
+            replacement["version"] = control["version"] + 1
+            body = self._runtime_record({
+                "id": identifier, "run_id": self.identity["run_id"], "type": JOURNAL_TYPE,
+                "item_type": JOURNAL_TYPE, "record_kind": kind, "key": key, "sequence": sequence,
+                "execution_id": payload.get("execution_id"), "payload": deepcopy(payload),
+            })
+            operation = (
+                ("replace", (identifier, body), {"if_match_etag": previous["_etag"]})
+                if previous else ("create", (body,))
+            )
+            try:
+                self.container.execute_item_batch(batch_operations=[
+                    ("replace", (control["id"], replacement), {"if_match_etag": control["_etag"]}),
+                    operation,
+                ], partition_key=self.identity["run_id"])
+                return self.journal_read(kind, key)
+            except (cosmos_exceptions.CosmosBatchOperationError, cosmos_exceptions.CosmosHttpResponseError) as exc:
+                if getattr(exc, "status_code", None) in {409, 412}:
+                    continue
+                # A lost acknowledgement is reconciled against the exact immutable key/payload.
+                saved = self.journal_read(kind, key)
+                if saved and saved.get("payload") == payload:
+                    self.assert_owned(token)
+                    return saved
+                raise
+        self._journal_conflict("etag_conflict")
+
+    def journal_page(self, kind, *, cursor=None, limit=50, execution_id=None):
+        control = self._read_control()
+        if kind not in {"execution", "attempt", "decision"} or type(limit) is not int or not 1 <= limit <= 100:
+            raise ValueError("Journal pages require a supported kind and a limit from 1 to 100.")
+        scope = canonical_digest({**self.identity, "kind": kind, "execution_id": execution_id})
+        after = 0
+        through = int(control.get("journal_sequence") or 0)
+        total = int((control.get("journal_counts") or {}).get(kind) or 0)
+        if cursor:
+            try:
+                if not isinstance(cursor, str) or len(cursor) > 1024:
+                    raise ValueError
+                decoded = json.loads(base64.urlsafe_b64decode(cursor.encode("ascii")))
+                if set(decoded) != {"scope", "after", "through", "total"} or decoded["scope"] != scope:
+                    raise ValueError
+                after, bound, count = decoded["after"], decoded["through"], decoded["total"]
+                if not all(type(value) is int for value in (after, bound, count)) or not (
+                    0 <= after <= bound <= through and 0 <= count <= total
+                ):
+                    raise ValueError
+                through, total = bound, count
+            except (ValueError, TypeError, UnicodeError, json.JSONDecodeError) as exc:
+                raise ValueError("Invalid workflow journal cursor.") from exc
+        parameters = [
+            {"name": "@run_id", "value": self.identity["run_id"]},
+            {"name": "@workflow_id", "value": self.identity["workflow_id"]},
+            {"name": "@kind", "value": kind}, {"name": "@after", "value": after},
+            {"name": "@through", "value": through},
+        ]
+        where = (
+            "c.run_id = @run_id AND c.workflow_id = @workflow_id "
+            "AND c.item_type = 'workflow_runtime_journal' AND c.record_kind = @kind "
+            "AND c.sequence > @after AND c.sequence <= @through"
+        )
+        if execution_id is not None:
+            where += " AND c.execution_id = @execution_id"
+            parameters.append({"name": "@execution_id", "value": execution_id})
+        rows = list(self.container.query_items(
+            query=f"SELECT TOP {limit + 1} * FROM c WHERE {where} ORDER BY c.sequence ASC",
+            parameters=parameters, partition_key=self.identity["run_id"],
+        ))
+        for row in rows:
+            if any(row.get(name) != value for name, value in self.identity.items()) or row.get("record_kind") != kind:
+                self._journal_conflict("identity_mismatch")
+        fields = PUBLIC_DECISION_FIELDS if kind == "decision" else PUBLIC_EXECUTION_FIELDS
+        entries = []
+        for row in rows[:limit]:
+            entry = {name: deepcopy(value) for name, value in {**row["payload"], "sequence": row["sequence"]}.items() if name in fields}
+            decision = entry.get("decision")
+            if isinstance(decision, dict):
+                decision = {name: value for name, value in decision.items() if name in {"choice", "target"}}
+                target = decision.get("target")
+                if isinstance(target, dict):
+                    decision["target"] = {name: value for name, value in target.items() if name in {"node_id", "exit_region_id"}}
+                entry["decision"] = decision
+                if kind == "decision":
+                    entry["choice"] = decision.get("choice") or ("route" if target else "continue")
+                    if decision.get("choice") in {"then", "else"}:
+                        entry["selected_branch"] = decision["choice"]
+                    if isinstance(target, dict):
+                        entry["target_node_id"] = target.get("node_id")
+                        entry["exit_region_id"] = target.get("exit_region_id")
+            entries.append(entry)
+        next_cursor = None
+        if len(rows) > limit:
+            next_cursor = base64.urlsafe_b64encode(json.dumps(
+                {"scope": scope, "after": rows[limit - 1]["sequence"], "through": through, "total": total}, separators=(",", ":"),
+            ).encode("ascii")).decode("ascii")
+        return {"items": entries, "next_cursor": next_cursor,
+                "total_count": total}
+
+    def journal_decide(self, *, expected_version, gate_id, choice, actor_user_id, request_id):
+        from functions_workflow_runtime_store import NEXT_STATE_BY_DECISION, _require_id
+
+        if type(expected_version) is not int:
+            self._journal_conflict("stale_version")
+        for name, value in (("gate_id", gate_id), ("choice", choice),
+                            ("actor_user_id", actor_user_id), ("request_id", request_id)):
+            _require_id(value, name)
+        request_key = ["decision", request_id]
+        wanted = {"gate_id": gate_id, "choice": choice, "actor_user_id": actor_user_id}
+        for _ in range(8):
+            control = self._read_control()
+            prior = self.journal_read("request", request_key)
+            if prior:
+                if prior["payload"] != wanted:
+                    self._journal_conflict("request_conflict")
+                return control
+            if control["version"] != expected_version:
+                self._journal_conflict("stale_version")
+            gate = control.get("gate") or {}
+            if gate.get("id") != gate_id:
+                self._journal_conflict("stale_gate")
+            pair = (gate.get("kind"), choice)
+            if pair not in NEXT_STATE_BY_DECISION or choice not in gate.get("choices", []):
+                self._journal_conflict("invalid_choice")
+            if choice in {"approve", "retry", "resume"} and self._now().isoformat() >= control["deadline_at"]:
+                self.expire_deadline()
+                self._journal_conflict("deadline_exceeded")
+            decision = {
+                **wanted, "gate_kind": gate["kind"], "decided_at": self._now().isoformat(),
+                **{key: deepcopy(gate[key]) for key in (
+                    "unit_id", "execution_id", "node_id", "iteration_path", "attempt",
+                    "input_digest", "definition_revision",
+                ) if key in gate},
+            }
+            active = self.journal_read("execution", gate.get("execution_id")) if gate.get("execution_id") else None
+            if active:
+                decision["consumed_inputs"] = deepcopy(active["payload"].get("consumed_inputs") or [])
+                decision["reference_sources"] = deepcopy(active["payload"].get("reference_sources") or [])
+            replacement = self._base_replacement(control)
+            sequence = int(control.get("journal_sequence") or 0)
+            replacement.update(state=NEXT_STATE_BY_DECISION[pair], gate=None, lease=None,
+                               version=control["version"] + 1, journal_sequence=sequence + 2)
+            counts = dict(control.get("journal_counts") or {})
+            operations = [("replace", (control["id"], replacement), {"if_match_etag": control["_etag"]})]
+            for offset, (kind, key, payload) in enumerate((
+                ("decision", ["gate", gate_id], decision), ("request", request_key, wanted),
+            ), start=1):
+                counts[kind] = int(counts.get(kind) or 0) + 1
+                body = self._runtime_record({
+                    "id": journal_record_id(kind, key), "run_id": self.identity["run_id"],
+                    "type": JOURNAL_TYPE, "item_type": JOURNAL_TYPE, "record_kind": kind, "key": key,
+                    "sequence": sequence + offset, "execution_id": decision.get("execution_id"), "payload": payload,
+                })
+                operations.append(("create", (body,)))
+            replacement["journal_counts"] = counts
+            try:
+                self.container.execute_item_batch(batch_operations=operations, partition_key=self.identity["run_id"])
+                return self._read_control()
+            except (cosmos_exceptions.CosmosBatchOperationError, cosmos_exceptions.CosmosHttpResponseError) as exc:
+                if getattr(exc, "status_code", None) in {409, 412}:
+                    continue
+                marker = self.journal_read("request", request_key)
+                if marker and marker["payload"] == wanted:
+                    return self._read_control()
+                raise
+        self._journal_conflict("etag_conflict")
+
+    def journal_request(self, action, *, actor_user_id, request_id, expected_version=None):
+        from functions_workflow_runtime_store import RESUMABLE_STATES, TERMINAL_STATES, _require_id
+
+        _require_id(actor_user_id, "actor_user_id")
+        _require_id(request_id, "request_id")
+        key = [action, request_id]
+        wanted = {"action": action, "actor_user_id": actor_user_id}
+        for _ in range(8):
+            control = self._read_control()
+            marker = self.journal_read("request", key)
+            if marker:
+                if marker["payload"] != wanted:
+                    self._journal_conflict("request_conflict")
+                return control
+            if action == "resume":
+                if type(expected_version) is not int or expected_version != control["version"]:
+                    self._journal_conflict("stale_version")
+                if control["state"] not in RESUMABLE_STATES:
+                    self._journal_conflict("invalid_state")
+                if self._now().isoformat() >= control["deadline_at"]:
+                    self.expire_deadline()
+                    self._journal_conflict("deadline_exceeded")
+                state = "queued"
+            elif action == "cancel":
+                if control["state"] in TERMINAL_STATES:
+                    return control
+                state = "cancelled"
+            else:
+                self._journal_conflict("invalid_payload")
+            replacement = self._base_replacement(control)
+            sequence = int(control.get("journal_sequence") or 0) + 1
+            counts = dict(control.get("journal_counts") or {})
+            counts["request"] = int(counts.get("request") or 0) + 1
+            replacement.update(state=state, gate=None, lease=None, version=control["version"] + 1,
+                               journal_sequence=sequence, journal_counts=counts)
+            body = self._runtime_record({
+                "id": journal_record_id("request", key), "run_id": self.identity["run_id"],
+                "type": JOURNAL_TYPE, "item_type": JOURNAL_TYPE, "record_kind": "request",
+                "key": key, "sequence": sequence, "payload": wanted,
+            })
+            operations = [
+                ("replace", (control["id"], replacement), {"if_match_etag": control["_etag"]}),
+                ("create", (body,)),
+            ]
+            if action == "cancel":
+                node_id = (control.get("cursor") or {}).get("node_id")
+                execution_id = (control.get("gate") or {}).get("execution_id")
+                if not execution_id and node_id:
+                    execution_id = workflow_execution_id(self.workflow, self.identity["run_id"], node_id)
+                active = self.journal_read("execution", execution_id) if execution_id else None
+                if active and active["payload"].get("state") in {"running", "waiting_output", "waiting_approval", "waiting_recovery", "paused"}:
+                    attempt = self.journal_read("attempt", [execution_id, active["payload"]["attempt"]])
+                    for row in (active, attempt):
+                        if row is None or row["payload"].get("state") not in {"running", "waiting_output", "waiting_approval", "waiting_recovery", "paused"}:
+                            continue
+                        cancelled = {key: value for key, value in row.items() if not key.startswith("_")}
+                        cancelled["payload"] = {
+                            **cancelled["payload"], "state": "cancelled", "reason_code": "run_cancelled",
+                            "completed_at": self._now().isoformat(),
+                        }
+                        operations.append(("replace", (row["id"], cancelled), {"if_match_etag": row["_etag"]}))
+            try:
+                self.container.execute_item_batch(batch_operations=operations, partition_key=self.identity["run_id"])
+                return self._read_control()
+            except (cosmos_exceptions.CosmosBatchOperationError, cosmos_exceptions.CosmosHttpResponseError) as exc:
+                if getattr(exc, "status_code", None) in {409, 412}:
+                    continue
+                marker = self.journal_read("request", key)
+                if marker and marker["payload"] == wanted:
+                    return self._read_control()
+                raise
+        self._journal_conflict("etag_conflict")
diff --git a/application/single_app/functions_workflow_node_results.py b/application/single_app/functions_workflow_node_results.py
new file mode 100644
index 000000000..3afcafeac
--- /dev/null
+++ b/application/single_app/functions_workflow_node_results.py
@@ -0,0 +1,177 @@
+# functions_workflow_node_results.py
+"""Exact node result readers, including control provenance and paged lineage."""
+
+import json
+from collections.abc import Mapping
+
+from functions_analysis_access import AnalysisResultUnavailable, analysis_source_snapshot, authorize_analysis_sources
+from functions_workflow_identity import canonical_digest, workflow_node_identity
+from functions_workflow_result_store import load_workflow_node_result
+
+
+def result_selectors(identity):
+    return {key: identity[key] for key in ("node_id", "execution_id", "iteration_path", "attempt")}
+
+
+def load_node_result(workflow, run_id, identity, reference, *, load_result=load_workflow_node_result):
+    expected = workflow_node_identity(
+        workflow, run_id, identity.get("node_id"), identity.get("execution_id"), identity.get("attempt"),
+        task_id=identity.get("task_id"), iteration_path=identity.get("iteration_path"),
+    )
+    if expected != identity:
+        raise AnalysisResultUnavailable("analysis_lineage_invalid")
+    return load_result(workflow, run_id, identity.get("task_id"), reference, **result_selectors(identity))
+
+
+def iter_consumed_inputs(manifest, load_section):
+    from functions_workflow_results import iter_result_records
+
+    if "consumed_inputs_index" not in manifest:
+        values = manifest.get("consumed_inputs") or []
+        if not isinstance(values, list):
+            raise AnalysisResultUnavailable("analysis_lineage_invalid")
+    else:
+        synthetic = {**manifest, "outputs": {"lineage": manifest["consumed_inputs_index"]}}
+        values = iter_result_records(synthetic, "lineage", load_section)
+    for item in values:
+        if not isinstance(item, Mapping):
+            raise AnalysisResultUnavailable("analysis_lineage_invalid")
+        yield item
+
+
+def read_consumed_inputs(manifest, load_section):
+    return list(iter_consumed_inputs(manifest, load_section))
+
+
+def authorize_workflow_node_result_read(
+    workflow, run_id, identity, reference, *, reader_user_id=None, manifest=None,
+    load_result=load_workflow_node_result, source_resolver=None,
+):
+    root = manifest if manifest is not None else load_node_result(workflow, run_id, identity, reference, load_result=load_result)
+    active, visited, sources = set(), set(), {}
+    loaded = {}
+
+    def enter(producer, ref, current):
+        key = (canonical_digest(producer), canonical_digest(ref))
+        if key in active or len(visited) + len(active) > 100000:
+            raise AnalysisResultUnavailable("analysis_lineage_invalid")
+        if key in visited:
+            return None
+        expected = workflow_node_identity(
+            workflow, run_id, producer.get("node_id"), producer.get("execution_id"), producer.get("attempt"),
+            task_id=producer.get("task_id"), iteration_path=producer.get("iteration_path"),
+        )
+        if producer != expected or not isinstance(current, Mapping) or (
+            current.get("contract_version") != "workflow-result-v2" or current.get("identity") != expected
+        ):
+            raise AnalysisResultUnavailable("analysis_lineage_invalid")
+        active.add(key)
+        access = current.get("analysis_access")
+        if access is not None:
+            if not isinstance(access, Mapping) or access.get("version") != "analysis-source-access-v1":
+                raise AnalysisResultUnavailable("analysis_lineage_invalid")
+            direct = analysis_source_snapshot(access.get("sources"))
+            if not direct:
+                raise AnalysisResultUnavailable("analysis_source_manifest_missing")
+            sources.update({canonical_digest(source): source for source in direct})
+        selected = set()
+        for descriptor in (current.get("outputs") or {}).values():
+            if not isinstance(descriptor, Mapping):
+                raise AnalysisResultUnavailable("analysis_lineage_invalid")
+            if descriptor.get("selected_producer"):
+                receipt = descriptor["selected_producer"]
+                if not isinstance(receipt, Mapping) or receipt.get("output_ref") != descriptor.get("result_ref"):
+                    raise AnalysisResultUnavailable("analysis_lineage_invalid")
+                selected.add(canonical_digest(receipt))
+        consumed = iter_consumed_inputs(
+            current, lambda section: load_node_result(workflow, run_id, producer, section, load_result=load_result),
+        )
+        return key, iter(consumed), selected
+
+    pending = [enter(identity, reference, root)]
+    while pending:
+        key, children, selected = pending[-1]
+        item = next(children, None)
+        if item is None:
+            if selected:
+                raise AnalysisResultUnavailable("analysis_lineage_invalid")
+            active.remove(key)
+            visited.add(key)
+            pending.pop()
+            continue
+        selected.discard(canonical_digest(item))
+        parent_identity, parent_ref = item.get("producer"), item.get("result_ref")
+        if not isinstance(parent_identity, dict) or not isinstance(parent_ref, dict):
+            raise AnalysisResultUnavailable("analysis_lineage_invalid")
+        parent_key = (canonical_digest(parent_identity), canonical_digest(parent_ref))
+        parent = loaded.get(parent_key)
+        if parent is None:
+            parent = load_node_result(workflow, run_id, parent_identity, parent_ref, load_result=load_result)
+            loaded[parent_key] = parent
+        output = (parent.get("outputs") or {}).get(item.get("output_name")) or {}
+        if output.get("result_ref") != item.get("output_ref"):
+            raise AnalysisResultUnavailable("analysis_lineage_invalid")
+        child = enter(parent_identity, parent_ref, parent)
+        if child is not None:
+            pending.append(child)
+    snapshots = analysis_source_snapshot(list(sources.values()))
+    access = authorize_analysis_sources(
+        reader_user_id or workflow["user_id"], snapshots, resolver=source_resolver,
+    ) if snapshots else {"source_count": 0, "source_snapshot_changed": False}
+    return root, {**access, "sources": snapshots}
+
+
+def load_workflow_node_input(
+    workflow, run_id, identity, reference, *, output_name="authoritative", allow_partial=False,
+    reader_user_id=None, load_result=load_workflow_node_result, source_resolver=None, required=True,
+):
+    from functions_workflow_results import _require_completed_result, read_result_records
+
+    manifest, access = authorize_workflow_node_result_read(
+        workflow, run_id, identity, reference, reader_user_id=reader_user_id,
+        load_result=load_result, source_resolver=source_resolver,
+    )
+    _require_completed_result(manifest, allow_partial=allow_partial)
+    if access["source_snapshot_changed"]:
+        raise AnalysisResultUnavailable("analysis_source_snapshot_changed")
+    validation = manifest.get("workflow_validation") or {}
+    if validation.get("eligible") is not True:
+        raise ValueError("The producer's output contract is not eligible.")
+    if validation.get("status") == "accepted_partial" and not allow_partial:
+        raise ValueError("This input does not accept partial results.")
+    name = manifest.get("authoritative_output") if output_name == "authoritative" else output_name
+    descriptor = (manifest.get("outputs") or {}).get(name)
+    if not isinstance(descriptor, dict):
+        if required is False:
+            return None, None
+        raise ValueError("The exact selected output is unavailable.")
+    receipt = {"producer": identity, "output_name": name, "result_ref": reference,
+               "output_ref": descriptor["result_ref"]}
+    if access["source_count"]:
+        receipt["analysis_result"] = True
+    loader = lambda ref: load_node_result(workflow, run_id, identity, ref, load_result=load_result)
+    if descriptor.get("selected_producer"):
+        selected = descriptor["selected_producer"]
+        payload, _ = load_workflow_node_input(
+            workflow, run_id, selected["producer"], selected["result_ref"],
+            output_name=selected["output_name"], allow_partial=allow_partial,
+            reader_user_id=reader_user_id, load_result=load_result, source_resolver=source_resolver,
+        )
+        return payload, receipt
+    if descriptor.get("storage_kind") == "record_pages":
+        value, _ = read_result_records(manifest, name, loader)
+        output = {"producer": identity, "contract_version": "workflow-result-v2",
+                  "output_name": name, "kind": descriptor["kind"], "value": value}
+    else:
+        output = loader(descriptor["result_ref"])
+    if (
+        output.get("producer") != identity or output.get("contract_version") != "workflow-result-v2"
+        or output.get("output_name") != name or output.get("kind") != descriptor.get("kind")
+    ):
+        raise ValueError("Saved output section does not match its exact manifest.")
+    return json.dumps({
+        "consumed_result": receipt, "provenance": manifest.get("provenance") or {},
+        "coverage": manifest.get("coverage") or {}, "validation": manifest.get("validation") or {},
+        "kind": output["kind"], "value": output["value"],
+        "source_snapshot_changed": access["source_snapshot_changed"],
+    }, ensure_ascii=False, allow_nan=False, sort_keys=True), receipt
diff --git a/application/single_app/functions_workflow_result_store.py b/application/single_app/functions_workflow_result_store.py
index 24015388d..7436d6507 100644
--- a/application/single_app/functions_workflow_result_store.py
+++ b/application/single_app/functions_workflow_result_store.py
@@ -44,6 +44,7 @@
 from azure.storage.blob import ContentSettings
 
 from functions_workflow_runtime_store import WorkflowRuntimeConflict
+from functions_workflow_identity import workflow_execution_id, workflow_node_identity
 
 STORAGE_SCHEMA_VERSION = 1
 RESULT_RECORD_TYPE = "workflow_result_chunk"
@@ -109,10 +110,24 @@ def _scope(workflow, run_id):
     return {**_workflow_scope(workflow), "run_id": _identifier(run_id)}
 
 
-def _identity(workflow, run_id, task_id):
+def _identity(workflow, run_id, task_id, *, execution_id=None, attempt=None, node_id=None, iteration_path=None):
+    if any(value is not None for value in (execution_id, attempt, node_id, iteration_path)):
+        identity = workflow_node_identity(
+            workflow, run_id, node_id, execution_id, attempt, task_id=task_id, iteration_path=iteration_path,
+        )
+        # Compact transport bindings remain hashable; the manifest retains the verified path.
+        return {**_scope(workflow, run_id), **{key: value for key, value in identity.items() if key != "iteration_path"}}
     return {**_scope(workflow, run_id), "task_id": _identifier(task_id)}
 
 
+def read_workflow_node_result_page(workflow, run_id, task_id, reference, *, node_id, execution_id, attempt,
+                                   iteration_path=None, offset=0, limit=2000):
+    return _configured_store(workflow).read_page(
+        workflow, run_id, task_id, reference, node_id=node_id, execution_id=execution_id,
+        attempt=attempt, iteration_path=[] if iteration_path is None else iteration_path, offset=offset, limit=limit,
+    )
+
+
 def _chat_scope(user_id, conversation_id, message_id=None):
     scope = {
         "scope_type": "chat",
@@ -211,7 +226,8 @@ def _blob_name(identity, reference):
         return f"{_chat_blob_prefix(identity)}{reference['sha256']}.json"
     if identity["scope_type"] == "orchestration":
         return f"{_orchestration_blob_prefix(identity)}{_hash_identifier(identity['step_id'])}/{reference['sha256']}.json"
-    return f"{_run_blob_prefix(identity)}{_hash_identifier(identity['task_id'])}/{reference['sha256']}.json"
+    key = f"{identity['execution_id']}:{identity['attempt']}" if identity.get("execution_id") else identity["task_id"]
+    return f"{_run_blob_prefix(identity)}{_hash_identifier(key)}/{reference['sha256']}.json"
 
 
 def _conversation_blob_scope_metadata(scope):
@@ -248,7 +264,10 @@ def _blob_metadata(identity, reference):
         "scope_hash": _hash_identifier(identity["scope_id"]),
         "workflow_hash": _hash_identifier(identity["workflow_id"]),
         "run_hash": _hash_identifier(identity["run_id"]),
-        "task_hash": _hash_identifier(identity["task_id"]),
+        **({"execution_hash": identity["execution_id"], "attempt": str(identity["attempt"]),
+            "execution_storage_hash": _hash_identifier(f"{identity['execution_id']}:{identity['attempt']}"),
+            "node_hash": _hash_identifier(identity["node_id"])} if identity.get("execution_id")
+           else {"task_hash": _hash_identifier(identity["task_id"])}),
         "sha256": reference["sha256"],
         "size_bytes": str(reference["size_bytes"]),
         "media_type": RESULT_MEDIA_TYPE,
@@ -306,7 +325,10 @@ def _workflow_execution_guard(identity, execution=None):
     execution = execution or _active_workflow_execution()
     if execution is None or "workflow_id" not in identity:
         return None
-    if execution.workflow["id"] != identity["workflow_id"] or execution.run_id != identity["run_id"]:
+    if (
+        execution.workflow["id"] != identity["workflow_id"] or execution.run_id != identity["run_id"]
+        or any(identity.get(key) != value for key, value in _workflow_scope(execution.workflow).items())
+    ):
         raise WorkflowResultIntegrityError("Workflow result write does not match the active execution.")
     execution.check()
     return execution
@@ -406,9 +428,9 @@ def _blob_chunks(self, identity, reference):
             etag=properties.etag, match_condition=MatchConditions.IfNotModified, validate_content=True,
         ).chunks()
 
-    def save(self, workflow, run_id, task_id, result):
+    def save(self, workflow, run_id, task_id, result, **selectors):
         """Persist an envelope without overwriting another immutable result."""
-        return self._save(_identity(workflow, run_id, task_id), result)
+        return self._save(_identity(workflow, run_id, task_id, **selectors), result)
 
     def save_chat(
         self, user_id, conversation_id, message_id, result, *, guard_token=None, require_analysis_guard=False,
@@ -871,7 +893,7 @@ def _analysis_scope_rows(self, scope):
         identity_fields = (
             "c.user_id, c.conversation_id, c.message_id" if scope["scope_type"] == "chat"
             else "c.user_id, c.conversation_id, c.step_id" if scope["scope_type"] == "orchestration"
-            else "c.workflow_id, c.task_id"
+            else "c.workflow_id, c.task_id, c.execution_id, c.node_id, c.attempt"
         )
         return self.container.query_items(
             query=(
@@ -900,6 +922,8 @@ def _analysis_row_identity(self, scope, row):
             )
         else:
             identity = {**scope, "task_id": _identifier(row.get("task_id"))}
+            if row.get("execution_id"):
+                identity.update(execution_id=row["execution_id"], node_id=row["node_id"], attempt=row["attempt"])
         _require_fields(row, identity)
         return identity
 
@@ -947,9 +971,9 @@ def _read_chunk(self, identity, reference, manifest, index):
             raise WorkflowResultIntegrityError("Stored workflow result chunk size or digest does not match.")
         return payload
 
-    def load(self, workflow, run_id, task_id, reference):
+    def load(self, workflow, run_id, task_id, reference, **selectors):
         """Read the full envelope, verifying metadata, reconstructed size, and SHA-256."""
-        return self._load(_identity(workflow, run_id, task_id), reference)
+        return self._load(_identity(workflow, run_id, task_id, **selectors), reference)
 
     def load_chat(self, user_id, conversation_id, message_id, reference):
         """Load and verify the complete result for an authorized chat binding."""
@@ -982,9 +1006,9 @@ def _load(self, identity, reference):
             raise WorkflowResultIntegrityError("Stored workflow result is not a JSON object.")
         return result
 
-    def read_page(self, workflow, run_id, task_id, reference, *, offset=0, limit=DEFAULT_PAGE_BYTES):
+    def read_page(self, workflow, run_id, task_id, reference, *, offset=0, limit=DEFAULT_PAGE_BYTES, **selectors):
         """Read bounded ASCII JSON bytes; complete means EOF, not a complete envelope."""
-        return self._read_page(_identity(workflow, run_id, task_id), reference, offset=offset, limit=limit)
+        return self._read_page(_identity(workflow, run_id, task_id, **selectors), reference, offset=offset, limit=limit)
 
     def read_chat_page(self, user_id, conversation_id, message_id, reference, *, offset=0, limit=DEFAULT_PAGE_BYTES):
         """Read bounded serialized bytes, not semantic records or model-ready content."""
@@ -1096,10 +1120,21 @@ def _delete_scoped_blobs(self, scope):
                     "scope_hash": _hash_identifier(scope["scope_id"]),
                     "workflow_hash": _hash_identifier(scope["workflow_id"]),
                     "run_hash": _hash_identifier(scope["run_id"]),
-                    "task_hash": object_hash,
                     "sha256": digest_filename[:-5],
                     "media_type": RESULT_MEDIA_TYPE,
                 }
+                metadata = properties.metadata or {}
+                if metadata.get("execution_hash"):
+                    execution_hash, attempt = metadata.get("execution_hash"), metadata.get("attempt")
+                    if (
+                        not isinstance(execution_hash, str) or not _DIGEST_PATTERN.fullmatch(execution_hash)
+                        or not isinstance(attempt, str) or not re.fullmatch(r"[1-9][0-9]{0,11}", attempt)
+                        or _hash_identifier(f"{execution_hash}:{attempt}") != object_hash
+                    ):
+                        raise WorkflowResultIntegrityError("The execution Blob identity is invalid.")
+                    expected["execution_storage_hash"] = object_hash
+                else:
+                    expected["task_hash"] = object_hash
             _require_fields(properties.metadata, expected)
             blob = self.blob_client.get_blob_client(container=self.blob_container_name, blob=name)
             try:
@@ -1123,7 +1158,7 @@ def delete_run_results(self, workflow, run_id):
             self._delete_scoped_blobs(scope)
         records = self.container.query_items(
             query=(
-                "SELECT c.id, c.run_id, c.workflow_id, c.scope_type, c.scope_id, c.task_id, "
+                "SELECT c.id, c.run_id, c.workflow_id, c.scope_type, c.scope_id, c.task_id, c.node_id, c.execution_id, c.attempt, "
                 "c.type, c.item_type, c.storage, c.schema_version, c.sha256, c.size_bytes, "
                 "c.chunk_count, c.record_kind, c.chunk_index FROM c "
                 "WHERE c.run_id = @run_id AND c.workflow_id = @workflow_id "
@@ -1139,6 +1174,22 @@ def delete_run_results(self, workflow, run_id):
         )
         self._delete_records(scope, records)
         self._delete_analysis_controls(scope)
+        journal_rows = self.container.query_items(
+            query=(
+                "SELECT c.id, c.workflow_id, c.run_id, c.scope_type, c.scope_id FROM c "
+                "WHERE c.run_id = @run_id AND c.workflow_id = @workflow_id AND c.scope_type = @scope_type "
+                "AND c.scope_id = @scope_id AND c.type = @record_type AND c.item_type = @record_type"
+            ),
+            parameters=[*({"name": f"@{key}", "value": value} for key, value in scope.items()),
+                        {"name": "@record_type", "value": "workflow_runtime_journal"}],
+            partition_key=run_id, max_item_count=100,
+        )
+        for row in journal_rows:
+            _require_fields(row, scope)
+            try:
+                self.container.delete_item(item=row["id"], partition_key=run_id)
+            except CosmosResourceNotFoundError:
+                pass
 
     def delete_chat_results(self, user_id, conversation_id, message_id=None):
         """Delete every private section/revision for a real message or conversation.
@@ -1197,7 +1248,14 @@ def _delete_records(self, scope, records):
                 )
                 _require_fields(record, identity)
             else:
-                identity = {**scope, "task_id": _identifier(record.get("task_id"))}
+                if record.get("execution_id"):
+                    identity = {
+                        **scope, "execution_id": _identifier(record.get("execution_id")),
+                        "node_id": _identifier(record.get("node_id")), "attempt": _positive_integer(record.get("attempt"), "Attempt"),
+                        **({"task_id": _identifier(record["task_id"])} if record.get("task_id") else {}),
+                    }
+                else:
+                    identity = {**scope, "task_id": _identifier(record.get("task_id"))}
             reference = _validate_reference({key: record.get(key) for key in REFERENCE_FIELDS})
             kind = record.get("record_kind")
             if kind == "manifest":
@@ -1259,6 +1317,41 @@ def load_workflow_task_result(workflow, run_id, task_id, reference):
     return _configured_store(workflow).load(workflow, run_id, task_id, reference)
 
 
+def save_workflow_node_result(workflow, run_id, task_id, result, *, node_id, execution_id, attempt,
+                              iteration_path=None, settings=None):
+    return _configured_store(workflow, settings=settings, for_write=True).save(
+        workflow, run_id, task_id, result, node_id=node_id, execution_id=execution_id,
+        attempt=attempt, iteration_path=[] if iteration_path is None else iteration_path,
+    )
+
+
+def load_workflow_node_result(workflow, run_id, task_id, reference, *, node_id, execution_id, attempt,
+                              iteration_path=None):
+    return _configured_store(workflow).load(
+        workflow, run_id, task_id, reference, node_id=node_id, execution_id=execution_id,
+        attempt=attempt, iteration_path=[] if iteration_path is None else iteration_path,
+    )
+
+
+def save_workflow_runtime_result(workflow, run_id, result, *, settings=None):
+    node_id = workflow["flow"]["id"]
+    return save_workflow_node_result(
+        workflow, run_id, None, result, settings=settings, node_id=node_id,
+        execution_id=workflow_execution_id(workflow, run_id, node_id), attempt=1, iteration_path=[],
+    )
+
+
+def load_workflow_runtime_result(workflow, run_id, control, reference):
+    """Load using a verified control's frozen identity, before its definition can be read."""
+    if any(control.get(key) != value for key, value in _scope(workflow, run_id).items()):
+        raise WorkflowResultIntegrityError("The runtime snapshot scope is invalid.")
+    selectors = control.get("snapshot_identity") or {}
+    if set(selectors) != {"node_id", "execution_id", "attempt", "iteration_path"} or selectors["iteration_path"] != []:
+        raise WorkflowResultIntegrityError("The runtime snapshot identity is invalid.")
+    identity = {**_scope(workflow, run_id), **{key: value for key, value in selectors.items() if key != "iteration_path"}}
+    return _configured_store(workflow)._load(identity, reference)
+
+
 def read_workflow_task_result_page(workflow, run_id, task_id, reference, *, offset=0, limit=65536):
     """Read only the bounded serialized byte range of an authorized task result."""
     return _configured_store(workflow).read_page(workflow, run_id, task_id, reference, offset=offset, limit=limit)
diff --git a/application/single_app/functions_workflow_results.py b/application/single_app/functions_workflow_results.py
index 64104cdce..f42e9203c 100644
--- a/application/single_app/functions_workflow_results.py
+++ b/application/single_app/functions_workflow_results.py
@@ -14,6 +14,8 @@
     DEFAULT_MAX_RESULT_SIZE_MB,
     _quota_bytes,
     load_workflow_task_result,
+    load_workflow_node_result,
+    save_workflow_node_result,
     save_workflow_task_result,
 )
 
@@ -159,6 +161,18 @@ def _provenance_references(values):
 
 def build_workflow_task_result(result, *, workflow, run_id, task, attempt_count=1):
     """Capture complete produced data without changing the existing chat reply."""
+    if workflow.get("definition_version") == 3:
+        from functions_workflow_execution import current_workflow_execution
+        from functions_workflow_identity import workflow_node_identity
+
+        execution = current_workflow_execution()
+        if execution is None or execution.node.get("task_id") != task.get("id"):
+            raise ValueError("A v3 task result requires its admitted execution.")
+        selectors = execution.selectors(attempt=attempt_count)
+        return _build_task_result(result, workflow_node_identity(
+            workflow, run_id, selectors["node_id"], selectors["execution_id"], attempt_count,
+            task_id=task["id"], iteration_path=[],
+        ), "workflow-result-v2")
     return _build_task_result(
         result,
         {
@@ -336,9 +350,22 @@ def _build_task_result(result, identity, contract_version):
 
 def authorize_workflow_task_result_read(
     workflow, run_id, task_id, reference, *, reader_user_id=None, manifest=None,
-    load_result=load_workflow_task_result, source_resolver=None,
+    load_result=load_workflow_task_result, source_resolver=None, **selectors,
 ):
     """Recheck contributors of this result and every actually consumed ancestor."""
+    if selectors:
+        from functions_workflow_identity import workflow_node_identity
+        from functions_workflow_node_results import authorize_workflow_node_result_read
+
+        identity = workflow_node_identity(
+            workflow, run_id, selectors.get("node_id"), selectors.get("execution_id"), selectors.get("attempt"),
+            task_id=task_id, iteration_path=selectors.get("iteration_path"),
+        )
+        return authorize_workflow_node_result_read(
+            workflow, run_id, identity, reference, reader_user_id=reader_user_id, manifest=manifest,
+            load_result=load_workflow_node_result if load_result is load_workflow_task_result else load_result,
+            source_resolver=source_resolver,
+        )
     root = manifest if manifest is not None else load_result(workflow, run_id, task_id, reference)
     sources = []
     active = set()
@@ -426,10 +453,24 @@ def visit(current, current_task_id, current_ref):
 def authorize_workflow_run_read(workflow, run_id, *, reader_user_id=None, result_items=None,
                                 load_result=load_workflow_task_result, source_resolver=None):
     """Guard history/activity with every stored task result, without a UI item cap."""
+    structured_run = False
     if result_items is None:
         # These are already scope-authorized workflow/run reads. Query only task
         # metadata directly so a failed store read cannot become an empty list.
         from config import cosmos_group_workflow_run_items_container, cosmos_personal_workflow_run_items_container
+        if workflow.get("definition_version") == 3:
+            from functions_workflow_runtime_store import WorkflowRuntimeConflict, workflow_runtime_store
+
+            store = workflow_runtime_store(workflow, run_id)
+            try:
+                control = store.read()
+            except WorkflowRuntimeConflict as exc:
+                if exc.code != "not_found":
+                    raise
+                control = None
+            if control and control.get("schema_version") == 2:
+                workflow = store.run_definition()
+                structured_run = True
 
         container = (
             cosmos_group_workflow_run_items_container if workflow.get("group_id")
@@ -448,10 +489,11 @@ def authorize_workflow_run_read(workflow, run_id, *, reader_user_id=None, result
         )
     cache = {}
 
-    def cached_load(bound_workflow, bound_run_id, task_id, reference):
-        key = (bound_run_id, task_id, json.dumps(reference, sort_keys=True))
+    def cached_load(bound_workflow, bound_run_id, task_id, reference, **selectors):
+        key = (bound_run_id, task_id, json.dumps(reference, sort_keys=True), json.dumps(selectors, sort_keys=True))
         if key not in cache:
-            cache[key] = load_result(bound_workflow, bound_run_id, task_id, reference)
+            loader = load_workflow_node_result if selectors and load_result is load_workflow_task_result else load_result
+            cache[key] = loader(bound_workflow, bound_run_id, task_id, reference, **selectors)
         return cache[key]
 
     for item in result_items:
@@ -465,11 +507,22 @@ def cached_load(bound_workflow, bound_run_id, task_id, reference):
         authorize_workflow_task_result_read(
             workflow, run_id, item.get("task_id"), reference,
             reader_user_id=reader_user_id, source_resolver=source_resolver, load_result=cached_load,
+            **({key: item['workflow_result']['producer'][key] for key in ('node_id', 'execution_id', 'iteration_path', 'attempt')}
+               if (item.get('workflow_result') or {}).get('contract_version') == 'workflow-result-v2' else {}),
         )
+    if structured_run:
+        from functions_workflow_execution_history import workflow_execution_history
+
+        cursor = None
+        while True:
+            page = workflow_execution_history(workflow, run_id, reader_user_id=reader_user_id, cursor=cursor, limit=100)
+            cursor = page["next_cursor"]
+            if cursor is None:
+                break
 
 
 def _require_completed_result(envelope, *, allow_partial=False):
-    if envelope.get("contract_version") != WORKFLOW_RESULT_CONTRACT_VERSION:
+    if envelope.get("contract_version") not in {WORKFLOW_RESULT_CONTRACT_VERSION, "workflow-result-v2"}:
         raise ValueError("This workflow task result version is not supported.")
     state = (envelope.get("execution") or {}).get("status")
     validation = (envelope.get("validation") or {}).get("status")
@@ -522,14 +575,19 @@ def persist_workflow_task_result(envelope, *, workflow, run_id, task_id, setting
                                  save_result=None):
     """Commit independently readable sections, then their small result manifest."""
     if save_result is None:
-        save_result = save_workflow_task_result
+        save_result = save_workflow_node_result if envelope.get("contract_version") == "workflow-result-v2" else save_workflow_task_result
         if settings is None:
             # Production callers need the actual quota, including paged result sections.
             from functions_settings import get_settings
             settings = get_settings()
+    selectors = {}
+    if envelope.get("contract_version") == "workflow-result-v2":
+        from functions_workflow_node_results import result_selectors
+
+        selectors = result_selectors(envelope["identity"])
     return persist_result_sections(
         envelope,
-        lambda section: save_result(workflow, run_id, task_id, section, settings=settings),
+        lambda section: save_result(workflow, run_id, task_id, section, settings=settings, **selectors),
         max_result_bytes=_quota_bytes(settings or {}),
     )
 
@@ -593,8 +651,15 @@ def persist_result_sections(
     sections["presentation"] = {"kind": "presentation", "value": envelope["presentation"]}
     sections["diagnostics"] = {"kind": "diagnostics", "value": envelope["diagnostics"]}
     manifest["outputs"] = {}
+    if envelope.get("contract_version") == "workflow-result-v2" and len(envelope.get("consumed_inputs") or []) > 100:
+        index = _save_record_pages(envelope, "lineage", envelope["consumed_inputs"], save_section, max_result_bytes)
+        if index:
+            manifest.pop("consumed_inputs", None)
+            manifest["consumed_inputs_index"] = index
     for name, output in sections.items():
-        if output["kind"] in {"records", "evidence"} and envelope.get("analysis_access") and isinstance(output["value"], list):
+        if output["kind"] in {"records", "evidence", "document_results"} and (
+            envelope.get("analysis_access") or envelope.get("contract_version") == "workflow-result-v2"
+        ) and isinstance(output["value"], list):
             paged = _save_record_pages(envelope, name, output["value"], save_section, max_result_bytes, output["kind"])
             if paged is not None:
                 manifest["outputs"][name] = paged
@@ -615,7 +680,7 @@ def persist_result_sections(
 def read_result_records(manifest, name, load_section, *, offset=0, limit=None):
     """Read a complete-record range without loading unrelated record pages."""
     output = (manifest.get("outputs") or {}).get(name)
-    if not isinstance(output, Mapping) or output.get("kind") not in {"records", "evidence"}:
+    if not isinstance(output, Mapping) or output.get("kind") not in {"records", "evidence", "document_results"}:
         raise ValueError("The requested output is not a record collection.")
     if type(offset) is not int or offset < 0 or (limit is not None and (type(limit) is not int or limit < 1)):
         raise ValueError("The record range is invalid.")
@@ -705,7 +770,7 @@ def iter_result_records(manifest, name, load_section):
 def load_workflow_task_input(workflow, run_id, task_id, reference,
                              *, load_result=load_workflow_task_result, reader_user_id=None,
                              source_resolver=None, output_name="authoritative",
-                             allow_partial=False, bounded=False):
+                             allow_partial=False, bounded=False, **selectors):
     """Read one exact final representation and its immutable consumption receipt.
 
     The default selects the producer's authoritative output. Explicit names
@@ -713,6 +778,19 @@ def load_workflow_task_input(workflow, run_id, task_id, reference,
     Partial accepted Analyze findings require an explicit reporting opt-in;
     neither that opt-in nor a named output admits pending or invalid results.
     """
+    if selectors:
+        from functions_workflow_identity import workflow_node_identity
+        from functions_workflow_node_results import load_workflow_node_input
+
+        return load_workflow_node_input(
+            workflow, run_id, workflow_node_identity(
+                workflow, run_id, selectors.get("node_id"), selectors.get("execution_id"), selectors.get("attempt"),
+                task_id=task_id, iteration_path=selectors.get("iteration_path"),
+            ), reference, output_name=output_name, allow_partial=allow_partial,
+            reader_user_id=reader_user_id,
+            load_result=load_workflow_node_result if load_result is load_workflow_task_result else load_result,
+            source_resolver=source_resolver,
+        )
     final_kinds = {"text": "text", "records": "records", "json": "json", "documents": "document_results"}
     if not isinstance(output_name, str) or output_name not in {"authoritative", *final_kinds}:
         raise ValueError("The requested workflow output must be an exact final representation.")
@@ -779,7 +857,7 @@ def load_workflow_task_input(workflow, run_id, task_id, reference,
         )
         output = {
             "contract_version": manifest["contract_version"], "producer": manifest["identity"],
-            "output_name": name, "kind": "records", "value": records,
+            "output_name": name, "kind": output_descriptor["kind"], "value": records,
         }
     else:
         output = load_result(workflow, run_id, task_id, output_ref)
@@ -819,6 +897,10 @@ def workflow_result_summary(envelope, reference):
         "consumed_inputs": _json_copy(envelope.get("consumed_inputs") or []),
         "workflow_validation": _json_copy(envelope.get("workflow_validation") or {}),
     }
+    if envelope.get("contract_version") == "workflow-result-v2":
+        summary["producer"] = _json_copy(envelope["identity"])
+        if envelope.get("consumed_inputs_index"):
+            summary["consumed_input_count"] = envelope["consumed_inputs_index"]["record_count"]
     if envelope.get("analysis_access") or any(
         item.get("analysis_result") for item in envelope.get("consumed_inputs") or []
         if isinstance(item, Mapping)
diff --git a/application/single_app/functions_workflow_runner.py b/application/single_app/functions_workflow_runner.py
index c58ad53b6..c2e7d5122 100644
--- a/application/single_app/functions_workflow_runner.py
+++ b/application/single_app/functions_workflow_runner.py
@@ -9935,7 +9935,9 @@ def _resolve_workflow_task_runner(workflow, task, settings, actor_user_id=None):
     return execution_workflow, runner_audit
 
 
-def _workflow_task_run_item_id(run_id, task_id):
+def _workflow_task_run_item_id(run_id, task_id, execution_id=None):
+    if execution_id is not None:
+        return str(uuid.uuid5(uuid.NAMESPACE_URL, f'workflow-execution:{run_id}:{execution_id}'))
     return str(uuid.uuid5(uuid.NAMESPACE_URL, f'workflow-task:{run_id}:{task_id}'))
 
 
@@ -9983,8 +9985,14 @@ def _save_workflow_task_run_item(
         for field in ('prompt_tokens', 'completion_tokens', 'total_tokens', 'request_count')
         if isinstance(token_usage.get(field), (int, float))
     }
+    execution_identity = {}
+    if workflow.get('definition_version') == 3:
+        execution = current_workflow_execution()
+        if execution is None or execution.node is None or execution.node.get('task_id') != task_id:
+            raise ValueError('A structured task projection requires its exact current execution.')
+        execution_identity = {**execution.selectors(), 'attempt': int(attempt_count or 0)}
     item = {
-        'id': _workflow_task_run_item_id(run_id, task_id),
+        'id': _workflow_task_run_item_id(run_id, task_id, execution_identity.get('execution_id')),
         'type': 'workflow_run_item',
         'item_type': 'task',
         'run_id': run_id,
@@ -9993,6 +10001,7 @@ def _save_workflow_task_run_item(
         'group_id': _get_workflow_group_id(workflow) or None,
         'workflow_name': workflow.get('name'),
         'task_id': task_id,
+        **execution_identity,
         'task_type': str(task.get('type') or 'instructions').strip(),
         'task_order': int(task.get('order') or 0),
         'label': str(task.get('name') or f"Task {task.get('order') or ''}").strip(),
@@ -10138,6 +10147,12 @@ def _merge_workflow_task_execution_results(task_results):
 
     final_source = (successful_results[-1].get('result') or {}) if successful_results else {}
     merged_result = dict(final_source)
+    publications = [
+        item["result"]["publication"] for item in task_results
+        if isinstance(item.get("result"), dict) and isinstance(item["result"].get("publication"), dict)
+    ]
+    if publications:
+        merged_result["publication"] = publications[-1]
     merged_result['reply'] = '\n'.join(reply_sections).strip()
     merged_result['task_results'] = [
         {
@@ -10216,9 +10231,12 @@ def authorize():
     durable = current_workflow_execution()
     options = {}
     if durable is not None:
-        token_record = durable.cache(f'analysis-token:{task_id}', {'token': uuid.uuid4().hex})
+        selectors = durable.selectors() if workflow.get('definition_version') == 3 else {}
+        token_key = f"analysis-token:{task_id}:{selectors['attempt']}" if selectors else f'analysis-token:{task_id}'
+        token_record = durable.cache(token_key, {'token': uuid.uuid4().hex})
         options['attempt_token'] = token_record['token']
         options['recover_running_unit'] = lambda: durable.may_recover_analysis_unit(task_id)
+        options.update(selectors)
     checkpoints = analysis_checkpoints_for_workflow(
         workflow, run_id, task_id, user_id=actor_user_id, authorize=authorize, settings=settings, **options,
     )
@@ -10237,7 +10255,7 @@ def _execute_workflow_task_sequence(
     actor_user_id=None,
 ):
     definition_version = workflow.get('definition_version', 1)
-    if type(definition_version) is not int or definition_version not in {1, 2}:
+    if type(definition_version) is not int or definition_version not in {1, 2, 3}:
         raise ValueError('This workflow definition requires a newer execution engine.')
     tasks = list(workflow.get('tasks') or [])
     error_handling = workflow.get('error_handling') if isinstance(workflow.get('error_handling'), dict) else {}
@@ -10249,8 +10267,18 @@ def _execute_workflow_task_sequence(
     completed_results = {}
     reference_cache = {}
     actor_id = str(actor_user_id or workflow.get('user_id') or '')
-    advanced_definition = workflow.get('definition_version') == 2
+    advanced_definition = workflow.get('definition_version') in {2, 3}
+    structured_definition = definition_version == 3
     durable = current_workflow_execution()
+    flow_runner = None
+    if structured_definition:
+        from functions_workflow_flow_runner import WorkflowFlowRunner
+
+        if durable is None or not hasattr(durable, 'selectors'):
+            raise ValueError('Structured workflows require the durable schema-2 execution engine.')
+        flow_runner = WorkflowFlowRunner(
+            workflow, run_id, durable, task_results, actor_user_id=actor_id, settings=settings,
+        )
     if durable is not None:
         reference_cache = durable.snapshot('shared_references') or {}
         control = durable.check()
@@ -10266,11 +10294,21 @@ def _execute_workflow_task_sequence(
             used_reference_ids.update(all_reference_ids if selected is None else selected)
         for reference in workflow.get('reference_inputs') or []:
             if reference['id'] in used_reference_ids:
-                reference_cache[reference['id']] = load_workflow_reference(
-                    workflow, reference, actor_user_id=actor_id,
-                    snapshot=reference_cache.get(reference['id']),
-                )
-        if durable is not None:
+                if structured_definition:
+                    try:
+                        reference_cache[reference['id']] = durable.freeze_reference(
+                            reference, lambda **snapshot: load_workflow_reference(
+                                workflow, reference, actor_user_id=actor_id, **snapshot,
+                            ),
+                        )
+                    except (AnalysisResultUnavailable, WorkflowInputError):
+                        durable._pause('shared_references', workflow.get('definition_revision') or '')
+                else:
+                    reference_cache[reference['id']] = load_workflow_reference(
+                        workflow, reference, actor_user_id=actor_id,
+                        snapshot=reference_cache.get(reference['id']),
+                    )
+        if durable is not None and not structured_definition:
             durable.cache('shared_references', reference_cache)
 
     def raise_if_cancelled():
@@ -10278,7 +10316,7 @@ def raise_if_cancelled():
         if callable(cancel_check):
             cancel_check(workflow, run_id)
 
-    for task_index, raw_task in enumerate(tasks):
+    for task_index, raw_task in enumerate(flow_runner.tasks() if flow_runner else tasks):
         raise_if_cancelled()
         task = dict(raw_task or {})
         task['order'] = task_index + 1
@@ -10290,9 +10328,17 @@ def raise_if_cancelled():
             if checkpoint is not None:
                 saved_result = checkpoint['result']
                 summary = saved_result['workflow_result']
-                authorize_workflow_task_result_read(
-                    workflow, run_id, task_id, summary['result_ref'], reader_user_id=actor_id,
-                )
+                try:
+                    _, source_access = authorize_workflow_task_result_read(
+                        workflow, run_id, task_id, summary['result_ref'], reader_user_id=actor_id,
+                        **(durable.selectors(attempt=summary['producer']['attempt']) if structured_definition else {}),
+                    )
+                except AnalysisResultUnavailable:
+                    if not structured_definition:
+                        raise
+                    durable._pause(task_unit_key, summary['result_ref']['sha256'])
+                if structured_definition and source_access.get('source_snapshot_changed'):
+                    durable._pause(task_unit_key, summary['result_ref']['sha256'])
                 task_results.append(checkpoint)
                 completed_results[task_id] = {
                     'run_id': run_id, 'result_ref': summary['result_ref'],
@@ -10339,17 +10385,23 @@ def raise_if_cancelled():
             try:
                 if task.get('publication') is not None:
                     task_stage = 'publication'
+                    publication_inputs = flow_runner.resolve(task['inputs']) if flow_runner else None
                     task_result, consumed_inputs = workflow_unit(
                         task_unit_key,
                         lambda: _execute_workflow_analysis_publication(
                             workflow, run_id, task, previous_task_id, previous_result_ref,
                             actor_user_id=actor_user_id,
+                            explicit_inputs=publication_inputs['bound_inputs'] if publication_inputs else None,
                         ),
-                        inputs={'task': task, 'producer_task_id': previous_task_id, 'result_ref': previous_result_ref},
+                        inputs=({'task': task, 'consumed_inputs': publication_inputs['consumed_inputs']}
+                                if publication_inputs is not None else
+                                {'task': task, 'producer_task_id': previous_task_id, 'result_ref': previous_result_ref}),
                         approval=task.get('approval'),
                     )
                     if durable is not None:
-                        attempt_count = durable.check()['units'][task_unit_key]['attempt']
+                        attempt_count = durable.unit(task_unit_key)['attempt']
+                    if flow_runner:
+                        consumed_inputs = flow_runner._receipts([*consumed_inputs, *flow_runner.control_receipts])
                     attempt_workflow = {**workflow, 'consumed_inputs': consumed_inputs}
                     runner_audit = {'requested_mode': 'publication', 'resolved_type': 'publication'}
                     task_error = ''
@@ -10369,15 +10421,22 @@ def raise_if_cancelled():
                 reference_sources = []
                 if advanced_definition:
                     inputs = resolve_workflow_task_inputs(
-                        workflow, task, completed_results, previous_task_id=previous_task_id,
+                        workflow, {**task, 'inputs': []} if structured_definition else task,
+                        completed_results, previous_task_id=previous_task_id,
                         load_output=lambda *args, **kwargs: load_workflow_task_input(
                             *args, reader_user_id=actor_id, **kwargs,
                         ),
                         load_reference=lambda reference, **kwargs: load_workflow_reference(
                             workflow, reference, actor_user_id=actor_id, **kwargs,
+                        ) if not structured_definition else durable.freeze_reference(
+                            reference, lambda **snapshot: load_workflow_reference(
+                                workflow, reference, actor_user_id=actor_id, **snapshot,
+                            ),
                         ),
                         reference_cache=reference_cache,
                     )
+                    if flow_runner:
+                        inputs.update(flow_runner.resolve(task['inputs']))
                     previous_input = inputs['task_context']
                     consumed_inputs = inputs['consumed_inputs']
                     reference_context = inputs['reference_context']
@@ -10395,8 +10454,8 @@ def raise_if_cancelled():
                     resolved_workflow,
                     task,
                     previous_reply='' if isinstance(previous_input, SavedAnalysisInput) else previous_input,
-                    include_document_action=task_index == 0,
-                    include_file_sync_context=task_index == 0,
+                    include_document_action=task_index == 0 and not structured_definition,
+                    include_file_sync_context=task_index == 0 and not structured_definition,
                 )
                 attempt_workflow['consumed_inputs'] = consumed_inputs
                 attempt_workflow['workflow_reference_sources'] = reference_sources
@@ -10426,7 +10485,7 @@ def raise_if_cancelled():
                     'kind': 'workflow', 'workflow_id': workflow['id'],
                     'run_id': run_id, 'task_id': task_id,
                 }
-                if _get_document_action_config(attempt_workflow).get('type') == DOCUMENT_ACTION_TYPE_ANALYZE:
+                if not structured_definition and _get_document_action_config(attempt_workflow).get('type') == DOCUMENT_ACTION_TYPE_ANALYZE:
                     if analysis_checkpoints is None:
                         analysis_checkpoints = _prepare_workflow_analysis_checkpoints(
                             workflow, run_id, task_id, actor_user_id or workflow.get('user_id'), settings,
@@ -10453,20 +10512,33 @@ def raise_if_cancelled():
                     and not attempt_workflow.get('chat_capabilities_enabled')
                     and (attempt_workflow.get('document_action') or {}).get('type') in {None, 'none'}
                 )
+                def dispatch_task():
+                    nonlocal analysis_checkpoints
+                    if structured_definition:
+                        attempt_workflow['_analysis_producer'].update(durable.selectors())
+                        if _get_document_action_config(attempt_workflow).get('type') == DOCUMENT_ACTION_TYPE_ANALYZE:
+                            analysis_checkpoints = _prepare_workflow_analysis_checkpoints(
+                                workflow, run_id, task_id, actor_id, settings,
+                            )
+                            attempt_workflow['_analysis_checkpoints'] = analysis_checkpoints
+                    return _execute_workflow_dispatch(
+                        attempt_workflow, settings, conversation_id, run_id, thought_tracker,
+                        {} if attempt_workflow.get('_saved_analysis_input_only') else url_access_context,
+                        file_sync_result=file_sync_result,
+                    )
+
                 with workflow_context_budget_scope(attempt_workflow):
                     task_result = workflow_unit(
                         task_unit_key,
-                        lambda: _execute_workflow_dispatch(
-                            attempt_workflow, settings, conversation_id, run_id,
-                            thought_tracker, {} if attempt_workflow.get('_saved_analysis_input_only') else url_access_context,
-                            file_sync_result=file_sync_result,
-                        ),
+                        dispatch_task,
                         inputs=operation_inputs, replay_safe=replay_safe,
                         approval=task.get('approval'),
                     )
                 if durable is not None:
-                    saved_unit = (durable.check().get('units') or {}).get(task_unit_key) or {}
+                    saved_unit = durable.unit(task_unit_key)
                     attempt_count = int(saved_unit.get('attempt') or attempt_count)
+                    if structured_definition:
+                        attempt_workflow['_analysis_producer'].update(durable.selectors(attempt=attempt_count))
                 raise_if_workflow_context_blocked(attempt_workflow)
                 task_error = ''
                 runner_audit = dict(runner_audit)
@@ -10482,6 +10554,8 @@ def raise_if_cancelled():
                 task_result = None
                 blocked_audit = ((attempt_workflow or {}).get('context_budget') or {}).get('blocked_request')
                 safe_error = WorkflowContextBudgetError(blocked_audit) if blocked_audit else exc
+                if structured_definition and task_stage == 'input' and isinstance(safe_error, AnalysisResultUnavailable):
+                    durable._pause(task_unit_key, durable.unit(task_unit_key).get('input_digest', ''))
                 log_event(
                     '[WORKFLOW_RUNNER] Task execution failed',
                     extra={'run_id': run_id, 'task_id': task_id, 'attempt': attempt_count,
@@ -10538,6 +10612,9 @@ def raise_if_cancelled():
                     task_result, workflow=workflow, run_id=run_id, task=task,
                     attempt_count=attempt_count,
                 )
+                if structured_definition and _get_document_action_config(attempt_workflow).get('type') == DOCUMENT_ACTION_TYPE_ANALYZE:
+                    if analysis_checkpoints is None:
+                        analysis_checkpoints = _prepare_workflow_analysis_checkpoints(workflow, run_id, task_id, actor_id, settings)
                 if durable is not None and envelope['execution']['status'] == 'pending':
                     try:
                         refreshed = reconcile_workflow_pending_output(
@@ -10563,6 +10640,12 @@ def raise_if_cancelled():
                             result_summary=workflow_result_summary(pending_manifest, pending_ref),
                             consumed_inputs=consumed_inputs, context_budget=context_budget,
                         )
+                        if structured_definition:
+                            pending_summary = workflow_result_summary(pending_manifest, pending_ref)
+                            durable.record_execution(state='waiting_output', attempt=attempt_count,
+                                                     workflow_result=pending_summary, consumed_inputs=consumed_inputs)
+                            durable._attempt(attempt_count, state='waiting_output', workflow_result=pending_summary,
+                                             consumed_inputs=consumed_inputs)
                         durable.wait_for_output(task_unit_key, pending_workflow_output_references(task_result))
                     task_result = refreshed
                     durable.replace_unit_result(task_unit_key, task_result)
@@ -10604,6 +10687,7 @@ def save_analysis_section(bound_workflow, bound_run, bound_task, section, **_kwa
                 result_summary = workflow_result_summary(manifest, result_ref)
                 authorize_workflow_task_result_read(
                     workflow, run_id, task_id, result_ref, manifest=manifest, reader_user_id=actor_id,
+                    **(durable.selectors(attempt=attempt_count) if structured_definition else {}),
                 )
                 task_result['workflow_result'] = result_summary
                 task_result['context_budget'] = context_budget
@@ -10661,6 +10745,11 @@ def save_analysis_section(bound_workflow, bound_run, bound_task, section, **_kwa
                 'runner': runner_audit,
                 'consumed_inputs': consumed_inputs,
             })
+            if structured_definition:
+                durable.finish_node(
+                    state=task_status, attempt=attempt_count, workflow_result=result_summary,
+                    workflow_validation=validation, consumed_inputs=consumed_inputs,
+                )
             if durable is not None and validation['eligible']:
                 durable.cache(f'task-result:{task_id}', task_results[-1])
             if thought_tracker and run_id:
@@ -10734,16 +10823,32 @@ def save_analysis_section(bound_workflow, bound_run, bound_task, section, **_kwa
                 status='failed',
             )
         if error_strategy != 'continue':
+            if structured_definition:
+                durable.finish_node(state='failed', attempt=max(1, attempt_count), reason_code='task_failed',
+                                    consumed_inputs=(attempt_workflow or {}).get('consumed_inputs') or [])
             raise RuntimeError(
                 f"Workflow task '{task.get('name') or task_id}' failed after {attempt_count} attempt(s): {task_error}"
             )
 
-    return _merge_workflow_task_execution_results(task_results)
+    merged = _merge_workflow_task_execution_results(task_results)
+    if flow_runner is not None:
+        for task_result in merged.get('task_results') or []:
+            producer = (task_result.get('workflow_result') or {}).get('producer') or {}
+            task_result.update({key: producer[key] for key in ('execution_id', 'node_id', 'iteration_path', 'attempt') if key in producer})
+        merged['workflow_outputs'] = flow_runner.final_outputs
+        if flow_runner.finished and not flow_runner.failed:
+            merged['workflow_outcome'] = {
+                **merged.get('workflow_outcome', {}),
+                'status': 'completed_partial' if flow_runner.partial else 'completed',
+                'success': True,
+            }
+        durable.set_node(None, workflow['flow']['id'])
+    return merged
 
 
 def _execute_workflow_analysis_publication(
     workflow, run_id, task, previous_task_id, previous_result_ref, *, actor_user_id=None,
-    result_reader=None, publish=None,
+    result_reader=None, publish=None, explicit_inputs=None,
 ):
     """Select only a committed ancestor artifact, before resolving a model or its context."""
     publication = task.get('publication')
@@ -10754,10 +10859,31 @@ def _execute_workflow_analysis_publication(
     from functions_personal_workflows import normalize_workflow_publication
 
     publication = normalize_workflow_publication(publication)
-    if not previous_task_id or not previous_result_ref:
-        raise WorkflowResultNotReadyError('Publication needs an existing saved upstream analysis artifact.')
     reader = result_reader or authorize_workflow_task_result_read
     actor = actor_user_id or workflow.get('user_id')
+    if workflow.get('definition_version') == 3:
+        if not isinstance(explicit_inputs, list) or len(explicit_inputs) != 1:
+            raise WorkflowResultNotReadyError('Publication requires exactly one explicit saved analysis input.')
+        selected = explicit_inputs[0]
+        for _ in range(256):
+            if selected['producer'].get('task_id'):
+                break
+            manifest, _ = reader(
+                workflow, run_id, None, selected['result_ref'], reader_user_id=actor,
+                **{key: selected['producer'][key] for key in ('node_id', 'execution_id', 'iteration_path', 'attempt')},
+            )
+            descriptor = (manifest.get('outputs') or {}).get(selected['output_name']) or {}
+            selected = descriptor.get('selected_producer')
+            if not isinstance(selected, dict):
+                raise WorkflowResultNotReadyError('Select a single native saved analysis output for publication.')
+        else:
+            raise WorkflowResultNotReadyError('The selected join provenance is invalid.')
+        previous_task_id = selected['producer'].get('task_id')
+        previous_result_ref = selected['result_ref']
+        if not previous_task_id:
+            raise WorkflowResultNotReadyError('Select the native saved analysis task explicitly for publication.')
+    if not previous_task_id or not previous_result_ref:
+        raise WorkflowResultNotReadyError('Publication needs an existing saved upstream analysis artifact.')
     pending = [(previous_task_id, previous_result_ref)]
     seen = set()
     while pending:
@@ -10770,6 +10896,8 @@ def _execute_workflow_analysis_publication(
             raise WorkflowResultNotReadyError('The artifact lineage is unavailable.')
         manifest, _ = reader(
             workflow, run_id, producer_task, reference, reader_user_id=actor,
+            **({key: selected['producer'][key] for key in ('node_id', 'execution_id', 'iteration_path', 'attempt')}
+               if workflow.get('definition_version') == 3 else {}),
         )
         matching = [
             artifact for artifact in manifest.get('artifacts') or []
@@ -10792,13 +10920,23 @@ def _execute_workflow_analysis_publication(
             producer = {'kind': 'workflow', **{
                 name: manifest['identity'][name] for name in ('workflow_id', 'run_id', 'task_id')
             }}
+            publication_request_id = f"workflow-publication:{workflow['id']}:{run_id}:{task['id']}"
+            if workflow.get('definition_version') == 3:
+                if manifest.get('analysis_origin') is not True:
+                    raise WorkflowResultNotReadyError('Publication requires a native saved analysis producer.')
+                producer.update({key: manifest['identity'][key] for key in ('node_id', 'execution_id', 'iteration_path', 'attempt')})
+                execution = current_workflow_execution()
+                publication_request_id = (
+                    f"workflow-publication:v3:{execution.execution_id()}:"
+                    f"{producer['execution_id']}:{producer['attempt']}"
+                )
             result = (publish or publish_workflow_analysis_artifact)(
                 actor, publication=publication,
                 artifact_reference={
                     'conversation_id': artifact.get('conversation_id'),
                     'artifact_message_id': artifact.get('artifact_message_id'), 'producer': producer,
                 },
-                request_id=f"workflow-publication:{workflow['id']}:{run_id}:{task['id']}",
+                request_id=publication_request_id,
             )
             state = (result.get('publication') or {}).get('state')
             if state == 'pending_approval':
@@ -10806,11 +10944,17 @@ def _execute_workflow_analysis_publication(
             elif state in {'uncertain', 'approval_failed'}:
                 result['execution_status'] = 'blocked'
             output_name = manifest['authoritative_output']
-            return result, [{
+            native_receipt = {
                 'producer': manifest['identity'], 'output_name': output_name,
                 'result_ref': dict(reference), 'output_ref': manifest['outputs'][output_name]['result_ref'],
                 'analysis_result': True,
-            }]
+            }
+            return result, (
+                [*explicit_inputs, native_receipt] if workflow.get('definition_version') == 3
+                and explicit_inputs[0]['producer'] != native_receipt['producer'] else [native_receipt]
+            )
+        if workflow.get('definition_version') == 3:
+            break
         for consumed in manifest.get('consumed_inputs') or []:
             producer = consumed.get('producer') or {}
             if producer.get('workflow_id') != workflow.get('id') or producer.get('run_id') != run_id:
@@ -10976,11 +11120,17 @@ def _run_personal_workflow_impl(workflow, trigger_source='manual', user_roles=No
     }
     if durable is not None:
         control = durable.check()
-        existing_progress = (
-            durable.load_result(
-                workflow, run_id, 'runtime:run-record', control['run_record_ref'],
-            )['run_record'] if control.get('run_record_ref') else control.get('run_record') or {}
-        )
+        existing_progress = control.get('run_record') or {}
+        if control.get('run_record_ref'):
+            reference = control['run_record_ref']
+            if control.get('schema_version') == 2:
+                existing_progress = durable.load_result(
+                    workflow, run_id, None, reference['result_ref'], **reference['selectors'],
+                )['run_record']
+            else:
+                existing_progress = durable.load_result(
+                    workflow, run_id, 'runtime:run-record', reference,
+                )['run_record']
         if not existing_progress:
             existing_progress = _get_workflow_run_record(workflow, run_id) or {}
         run_record.update(existing_progress)
@@ -11192,6 +11342,8 @@ def _run_personal_workflow_impl(workflow, trigger_source='manual', user_roles=No
             'agent_display_name': execution_result.get('agent_display_name'),
             'analysis_coverage': execution_result.get('analysis_coverage') or {},
             'task_results': execution_result.get('task_results') or [],
+            **({'workflow_outputs': execution_result.get('workflow_outputs') or []}
+               if workflow.get('definition_version') == 3 else {}),
             'task_error_count': int(execution_result.get('task_error_count') or 0),
             'url_access': execution_result.get('url_access') or {},
             'source_review': execution_result.get('source_review') or {},
diff --git a/application/single_app/functions_workflow_runtime.py b/application/single_app/functions_workflow_runtime.py
index 8bbbc4314..452347b25 100644
--- a/application/single_app/functions_workflow_runtime.py
+++ b/application/single_app/functions_workflow_runtime.py
@@ -17,8 +17,11 @@
 from functions_appinsights import log_event
 from functions_workflow_definitions import WORKFLOW_DEFINITION_FIELDS, workflow_definition_revision
 from functions_workflow_execution import DurableWorkflowExecution, WorkflowSuspended, workflow_execution_scope
+from functions_workflow_structured_execution import StructuredWorkflowExecution
+from functions_workflow_flow import compile_workflow_flow
 from functions_workflow_readiness import WorkflowOutputUnavailable, workflow_outputs_ready
 from functions_workflow_result_store import delete_workflow_run_results, load_workflow_task_result, save_workflow_task_result
+from functions_workflow_result_store import load_workflow_runtime_result, save_workflow_runtime_result
 from functions_workflow_runtime_store import (
     WorkflowRuntimeConflict,
     WorkflowRuntimeLease,
@@ -125,6 +128,10 @@ def queue_durable_workflow_run(workflow, *, actor_user_id, trigger_source="manua
     if current.get("durable_execution") is not True:
         raise ValueError("Durable execution is not enabled for this workflow.")
     _authorize_execution(current, actor_user_id, settings)
+    if type(current.get("definition_version", 1)) is not int or current.get("definition_version", 1) not in {1, 2, 3}:
+        raise ValueError("This workflow definition requires a newer execution engine.")
+    if current.get("definition_version") == 3:
+        compile_workflow_flow(current)
     if request_id is not None and not isinstance(request_id, str):
         raise ValueError("A workflow request identifier must be a UUID string.")
     request_id = str(uuid.UUID(request_id)) if request_id is not None else str(uuid.uuid4())
@@ -143,9 +150,13 @@ def queue_durable_workflow_run(workflow, *, actor_user_id, trigger_source="manua
         if existing_control.get("deleted"):
             raise WorkflowRuntimeConflict("tombstoned", "This workflow run was deleted.")
         snapshot_ref = existing_control["snapshot_ref"]
-        snapshot = load_workflow_task_result(current, run_id, "runtime:definition", snapshot_ref)
+        snapshot = store.run_definition() if existing_control.get("schema_version") == 2 else load_workflow_task_result(current, run_id, "runtime:definition", snapshot_ref)
     else:
-        snapshot_ref = save_workflow_task_result(current, run_id, "runtime:definition", snapshot, settings=settings)
+        snapshot_ref = (
+            save_workflow_runtime_result(snapshot, run_id, snapshot, settings=settings)
+            if snapshot.get("definition_version") == 3 else
+            save_workflow_task_result(current, run_id, "runtime:definition", snapshot, settings=settings)
+        )
     control = store.initialize(
         snapshot_ref=snapshot_ref, definition_revision=snapshot["definition_revision"],
         actor_user_id=actor_user_id, request_id=request_id,
@@ -159,6 +170,7 @@ def queue_durable_workflow_run(workflow, *, actor_user_id, trigger_source="manua
         "workspace_type": "group" if current.get("group_id") else "personal",
         "trigger_source": trigger_source, "triggered_by": actor_user_id,
         "durable_execution": True, "status": control["state"], "success": False,
+        "definition_version": snapshot.get("definition_version", 1),
         "started_at": control.get("created_at") or _now(), "completed_at": None,
         "definition_revision": snapshot["definition_revision"],
     }
@@ -189,7 +201,11 @@ def _project_runtime_run(services, workflow, run_id, control, *, result=None, at
     if latest["version"] > control["version"]:
         control, result = latest, None
     if result is None and control.get("completion_ref"):
-        result = load_workflow_task_result(workflow, run_id, "runtime:completion", control["completion_ref"])
+        result = (
+            load_workflow_runtime_result(workflow, run_id, control, control["completion_ref"])
+            if control.get("schema_version") == 2 else
+            load_workflow_task_result(workflow, run_id, "runtime:completion", control["completion_ref"])
+        )
     existing = services["runs"].read_item(item=run_id, partition_key=services["partition"])
     body = {key: value for key, value in existing.items() if not key.startswith("_")}
     if result:
@@ -272,7 +288,9 @@ def decide_workflow_runtime(workflow, run_id, data, *, actor_user_id, resume=Fal
     workflow_runtime_status(workflow, run_id, reader_user_id=actor_user_id)
     store = workflow_runtime_store(workflow, run_id)
     control = store.read()
-    snapshot = load_workflow_task_result(workflow, run_id, "runtime:definition", control["snapshot_ref"])
+    snapshot = store.run_definition() if control.get("schema_version") == 2 else load_workflow_task_result(workflow, run_id, "runtime:definition", control["snapshot_ref"])
+    if snapshot.get("definition_version") == 3:
+        compile_workflow_flow(snapshot)
     current = services["load_workflow"]()
     if not current or workflow_definition_revision(current) != control["definition_revision"]:
         raise WorkflowRuntimeConflict("workflow_definition_changed")
@@ -313,6 +331,7 @@ def continue_durable_workflow_run(workflow, run_id):
     services = _services(workflow)
     store = workflow_runtime_store(workflow, run_id)
     control = store.read()
+    control = store.expire_deadline()
     current = services["load_workflow"]()
     if not current or current.get("active_run_id") != run_id:
         return None
@@ -343,15 +362,18 @@ def continue_durable_workflow_run(workflow, run_id):
                 "choices": ["resume", "cancel"],
             })
             return _project_runtime_run(services, current, run_id, control)
-        snapshot = load_workflow_task_result(current, run_id, "runtime:definition", control["snapshot_ref"])
+        snapshot = store.run_definition() if control.get("schema_version") == 2 else load_workflow_task_result(current, run_id, "runtime:definition", control["snapshot_ref"])
         if workflow_definition_revision(snapshot) != control["definition_revision"]:
             raise WorkflowRuntimeConflict("workflow_definition_changed")
+        if snapshot.get("definition_version") == 3:
+            compile_workflow_flow(snapshot)
         if not snapshot.get("tasks"):
             snapshot["tasks"] = [{
                 "id": "legacy-task", "name": "Workflow task", "type": "instructions",
                 "instructions": snapshot["task_prompt"], "runner": {"type": "inherit"},
             }]
-        execution = DurableWorkflowExecution(store, lease, snapshot, run_id, settings=settings)
+        controller = StructuredWorkflowExecution if snapshot.get("definition_version") == 3 else DurableWorkflowExecution
+        execution = controller(store, lease, snapshot, run_id, settings=settings)
         result = None
         with workflow_execution_scope(execution):
             try:
@@ -361,8 +383,10 @@ def continue_durable_workflow_run(workflow, run_id):
                     actor_user_id=control["actor_user_id"], run_id=run_id,
                 )
                 execution.check()
-                reference = save_workflow_task_result(
-                    snapshot, run_id, "runtime:completion", result, settings=settings,
+                reference = (
+                    save_workflow_runtime_result(snapshot, run_id, result, settings=settings)
+                    if snapshot.get("definition_version") == 3 else
+                    save_workflow_task_result(snapshot, run_id, "runtime:completion", result, settings=settings)
                 )
                 final_state = (result.get("run") or {}).get("status") or "failed"
                 if final_state not in RUNTIME_TERMINAL_STATES:
@@ -394,7 +418,8 @@ def check_durable_workflows_once(limit=20):
             query=(
                 "SELECT TOP @limit * FROM c WHERE c.durable_execution = true "
                 "AND IS_DEFINED(c.active_run_id) AND c.active_run_id != '' "
-                "AND c.status IN ('queued','running','cancelling','waiting_output') ORDER BY c.updated_at ASC"
+                "AND (c.status IN ('queued','running','cancelling','waiting_output') "
+                "OR (c.definition_version = 3 AND c.status IN ('waiting_approval','waiting_recovery'))) ORDER BY c.updated_at ASC"
             ),
             parameters=[{"name": "@limit", "value": limit}],
             enable_cross_partition_query=True,
diff --git a/application/single_app/functions_workflow_runtime_store.py b/application/single_app/functions_workflow_runtime_store.py
index 1c60264ad..14346c747 100644
--- a/application/single_app/functions_workflow_runtime_store.py
+++ b/application/single_app/functions_workflow_runtime_store.py
@@ -1,13 +1,13 @@
 # functions_workflow_runtime_store.py
-"""Durable workflow runtime-control journal for milestone 3.
+"""Durable workflow runtime control and schema-2 paged execution journal.
 
-Version: 0.261.111
+Version: 0.261.116
 Implemented in: 0.261.111
 
-This module owns a single private control row in the existing workflow
-run-items container. It records runtime state, leases, gates, decisions, and
-small safe metadata only; schedulers/runners remain responsible for execution,
-authorization, task replay policy, and large result payload storage.
+The single private control row retains the existing lease/CAS identity.
+Schema 1 keeps legacy unit maps; schema 2 keeps cursor/counters and stores
+execution, attempt, unit and decision records separately in the same partition.
+Schedulers/runners still own execution, authorization and task replay policy.
 """
 
 import json
@@ -19,6 +19,8 @@
 
 from azure.core import MatchConditions
 from azure.cosmos import exceptions as cosmos_exceptions
+from functions_workflow_journal import WorkflowJournalMixin
+from functions_workflow_identity import workflow_execution_id
 
 
 CONTROL_ID = "workflow-runtime:v1"
@@ -55,6 +57,7 @@
 FORBIDDEN_PAYLOAD_KEY_PARTS = ("token", "secret", "password", "connection")
 FORBIDDEN_GATE_KEY_PARTS = FORBIDDEN_PAYLOAD_KEY_PARTS + ("prompt", "result", "payload", "content", "raw")
 GATE_ALLOWED_KEYS = frozenset({
+    "execution_id", "node_id", "iteration_path", "definition_revision",
     "id",
     "kind",
     "unit_id",
@@ -427,6 +430,7 @@ def public_projection(control):
         if isinstance(gate.get("metadata"), dict):
             safe_gate["metadata"] = _safe_ref(gate["metadata"])
     return {
+        "schema_version": control.get("schema_version", 1),
         "version": control.get("version"),
         "state": control.get("state"),
         "control_state": control.get("state"),
@@ -435,11 +439,20 @@ def public_projection(control):
         "snapshot_ref": _safe_ref(control.get("snapshot_ref")),
         "phase": control.get("phase"),
         "progress": control.get("progress"),
+        **({
+            "limits": {
+                "max_executions": control["max_executions"],
+                "admitted_count": int(control.get("admitted_count") or 0),
+                "deadline_at": control["deadline_at"],
+                "deadline_seconds": control["deadline_seconds"],
+                "waits_count": True,
+            },
+        } if control.get("schema_version") == 2 else {}),
         "deleted": bool(control.get("deleted")),
         "gate": safe_gate,
         "memory": {
-            "unit_count": len(units),
-            "completed_unit_count": sum(
+            "unit_count": int((control.get("journal_counts") or {}).get("unit") or 0) if control.get("schema_version") == 2 else len(units),
+            "completed_unit_count": int(control.get("completed_unit_count") or 0) if control.get("schema_version") == 2 else sum(
                 1 for unit in units.values()
                 if isinstance(unit, dict) and (unit.get("state") or unit.get("status")) == "completed"
             ),
@@ -448,6 +461,10 @@ def public_projection(control):
                 for key in sorted(unit_items)
             ],
             "decisions": decisions[-MAX_DECISIONS:],
+            **({
+                "execution_count": int((control.get("journal_counts") or {}).get("execution") or 0),
+                "decision_count": int((control.get("journal_counts") or {}).get("decision") or 0),
+            } if control.get("schema_version") == 2 else {}),
         },
         "can_resume": control.get("state") in RESUMABLE_STATES and not control.get("deleted"),
     }
@@ -456,7 +473,7 @@ def public_projection(control):
 workflow_runtime_projection = public_projection
 
 
-class WorkflowRuntimeStore:
+class WorkflowRuntimeStore(WorkflowJournalMixin):
     """Dependency-injected durable control journal for one authorized workflow run.
 
     ``container`` is the existing personal/group workflow_run_items Cosmos
@@ -475,6 +492,7 @@ def __init__(self, container, workflow, run_id, *, clock=None):
             raise ValueError("A workflow run-items container is required.")
         self.container = container
         self.identity = _identity(workflow, run_id)
+        self.workflow = deepcopy(workflow)
         self.clock = clock or _now
 
     def _now(self):
@@ -487,7 +505,7 @@ def _verify_identity(self, control, *, allow_deleted=False):
             raise RuntimeConflict("identity_mismatch", "Workflow runtime identity does not match this run.")
         if control.get("id") != CONTROL_ID or control.get("type") != CONTROL_TYPE or control.get("item_type") != CONTROL_TYPE:
             raise RuntimeConflict("identity_mismatch", "Workflow runtime control row is invalid.")
-        if control.get("kind") != "run" or control.get("schema_version") != SCHEMA_VERSION:
+        if control.get("kind") != "run" or type(control.get("schema_version")) is not int or control.get("schema_version") not in {1, 2}:
             raise RuntimeConflict("identity_mismatch", "Workflow runtime control row version is invalid.")
         if control.get("deleted") and not allow_deleted:
             raise RuntimeConflict("not_found", "Workflow runtime control was deleted.")
@@ -564,6 +582,57 @@ def read(self, *, allow_deleted=False):
         """Return the internal control row after identity and tombstone checks."""
         return self._read_control(allow_deleted=allow_deleted)
 
+    def expire_deadline(self):
+        def mutator(current):
+            deadline = _parse_timestamp(current.get("deadline_at"))
+            if current.get("schema_version") != 2 or deadline is None or self._now() < deadline or current["state"] in TERMINAL_STATES | {"paused"}:
+                return NO_WRITE
+            return self._limit_pause(current, "deadline_exceeded")
+
+        return self._mutate(mutator)
+
+    def _limit_pause(self, current, code):
+        replacement = self._base_replacement(current)
+        node_id = (current.get("cursor") or {}).get("node_id")
+        replacement.update(state="paused", phase=code, lease=None, version=current["version"] + 1, gate={
+            "id": uuid.uuid4().hex, "kind": "pause", "unit_id": node_id or "run-limits",
+            "input_digest": current["definition_revision"], "choices": ["cancel"],
+            "reason": (
+                "The elapsed workflow deadline was reached, including time spent waiting. Cancel and start a new run."
+                if code == "deadline_exceeded" else
+                "The workflow execution admission limit was reached. Cancel and start a new run with an appropriate limit."
+            ),
+        })
+        return replacement
+
+    def pause_execution_limit(self, token, code):
+        if code not in {"deadline_exceeded", "execution_budget_exceeded"}:
+            raise RuntimeConflict("invalid_limit")
+
+        def mutator(current):
+            self._assert_current_owned(current, token)
+            return self._limit_pause(current, code)
+
+        return self._mutate(mutator)
+
+    def run_definition(self):
+        from functions_workflow_definitions import workflow_definition_revision
+        from functions_workflow_result_store import load_workflow_task_result, load_workflow_runtime_result
+
+        control = self._read_control()
+        snapshot = (
+            load_workflow_runtime_result(self.workflow, self.identity["run_id"], control, control["snapshot_ref"])
+            if control.get("schema_version") == 2 else
+            load_workflow_task_result(self.workflow, self.identity["run_id"], "runtime:definition", control["snapshot_ref"])
+        )
+        if (
+            workflow_definition_revision(snapshot) != control["definition_revision"]
+            or snapshot.get("id") != self.identity["workflow_id"] or snapshot.get("user_id") != self.identity["user_id"]
+            or (snapshot.get("group_id") or None) != self.identity["group_id"]
+        ):
+            raise RuntimeConflict("workflow_definition_changed")
+        return snapshot
+
     def write_record(self, token, record, *, immutable=False):
         """Fence a run-item payload write behind the live runtime-control lease.
 
@@ -625,6 +694,20 @@ def initialize(self, *, snapshot_ref, definition_revision, actor_user_id, reques
             "lease": None,
             "deleted": False,
         }
+        if self.workflow.get("definition_version") == 3:
+            from functions_workflow_flow import compile_workflow_flow
+
+            compiled = compile_workflow_flow(self.workflow)
+            control.update(
+                schema_version=2, cursor={"region_id": compiled["flow"]["id"], "node_id": None},
+                snapshot_identity={"node_id": compiled["flow"]["id"],
+                                   "execution_id": workflow_execution_id(self.workflow, self.identity["run_id"], compiled["flow"]["id"]),
+                                   "attempt": 1, "iteration_path": []},
+                admitted_count=0, journal_sequence=0, journal_counts={},
+                max_executions=compiled["limits"]["max_executions"],
+                deadline_seconds=compiled["limits"]["deadline_seconds"],
+                deadline_at=_iso(self._now() + timedelta(seconds=compiled["limits"]["deadline_seconds"])),
+            )
         _bounded_json_copy(control)
         try:
             saved = self.container.create_item(body=control)
@@ -840,6 +923,11 @@ def mutator(current):
         return self._mutate(mutator)
 
     def decide(self, *, expected_version, gate_id, choice, actor_user_id, request_id):
+        if self._read_control().get("schema_version") == 2:
+            return self.journal_decide(
+                expected_version=expected_version, gate_id=gate_id, choice=choice,
+                actor_user_id=actor_user_id, request_id=request_id,
+            )
         if type(expected_version) is not int:
             raise RuntimeConflict("stale_version", "Workflow runtime version is required.")
         gate_id = _require_id(gate_id, "gate_id")
@@ -894,6 +982,8 @@ def mutator(current):
         return self._mutate(mutator, attempts=MAX_CAS_RETRIES)
 
     def request_cancel(self, *, actor_user_id, request_id):
+        if self._read_control().get("schema_version") == 2:
+            return self.journal_request("cancel", actor_user_id=actor_user_id, request_id=request_id)
         actor_user_id = _require_id(actor_user_id, "actor_user_id")
         request_id = _require_id(request_id, "request_id")
 
@@ -947,6 +1037,8 @@ def mutator(current):
         return self._mutate(mutator, attempts=MAX_CAS_RETRIES)
 
     def resume(self, *, expected_version, actor_user_id, request_id):
+        if self._read_control().get("schema_version") == 2:
+            return self.journal_request("resume", actor_user_id=actor_user_id, request_id=request_id, expected_version=expected_version)
         if type(expected_version) is not int:
             raise RuntimeConflict("stale_version", "Workflow runtime version is required.")
         actor_user_id = _require_id(actor_user_id, "actor_user_id")
diff --git a/application/single_app/functions_workflow_structured_execution.py b/application/single_app/functions_workflow_structured_execution.py
new file mode 100644
index 000000000..988d25b97
--- /dev/null
+++ b/application/single_app/functions_workflow_structured_execution.py
@@ -0,0 +1,289 @@
+# functions_workflow_structured_execution.py
+"""Schema-2 operation boundaries using paged units rather than a growing control map."""
+
+from copy import deepcopy
+
+from functions_workflow_execution import DurableWorkflowExecution, WorkflowSuspended, execution_fingerprint
+from functions_workflow_identity import workflow_execution_id
+from functions_workflow_runtime_store import WorkflowRuntimeConflict
+from functions_workflow_result_store import load_workflow_node_result, save_workflow_node_result
+
+
+class StructuredWorkflowExecution(DurableWorkflowExecution):
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("save_result", save_workflow_node_result)
+        kwargs.setdefault("load_result", load_workflow_node_result)
+        super().__init__(*args, **kwargs)
+        self.node = None
+        self.region_id = self.workflow["flow"]["id"]
+
+    def set_node(self, node, region_id):
+        self.node = node
+        self.region_id = region_id
+
+    def check(self):
+        record = self.lease.check()
+        if self.store._now().isoformat() >= record["deadline_at"]:
+            self.store.pause_execution_limit(self.lease.token, "deadline_exceeded")
+            raise WorkflowSuspended("paused")
+        return record
+
+    def freeze_reference(self, reference, loader):
+        key = ["reference", reference["id"]]
+        row = self.store.journal_read("unit", key)
+        snapshot = None
+        if row:
+            saved = row["payload"]
+            snapshot = self.load_result(
+                self.workflow, self.run_id, None, saved["result_ref"], **saved["selectors"],
+            )
+        value = loader(snapshot=snapshot)
+        if row is None:
+            root = self.workflow["flow"]["id"]
+            selectors = {
+                "node_id": root, "execution_id": workflow_execution_id(self.workflow, self.run_id, root),
+                "iteration_path": [], "attempt": 1,
+            }
+            result_ref = self.save_result(self.workflow, self.run_id, None, value, settings=self.settings, **selectors)
+            self.store.journal_commit(self.lease.token, "unit", key, {
+                "state": "completed", "selectors": selectors, "result_ref": result_ref,
+            }, immutable=True)
+        return value
+
+    def save_runtime_record(self, record):
+        node_id = self.workflow["flow"]["id"]
+        selectors = {
+            "node_id": node_id, "execution_id": workflow_execution_id(self.workflow, self.run_id, node_id),
+            "attempt": 1, "iteration_path": [],
+        }
+        reference = self.save_result(
+            self.workflow, self.run_id, None, {"run_record": record}, settings=self.settings, **selectors,
+        )
+        return {"result_ref": reference, "selectors": selectors}
+
+    def execution_id(self):
+        return workflow_execution_id(
+            self.workflow, self.run_id, self.node["id"] if self.node else self.workflow["flow"]["id"],
+        )
+
+    def _key(self, key):
+        return [self.execution_id(), key]
+
+    def unit(self, key):
+        row = self.store.journal_read("unit", self._key(key))
+        return deepcopy(row["payload"]) if row else {}
+
+    def selectors(self, *, attempt=None):
+        task_id = self.node.get("task_id") if self.node else None
+        unit = self.unit(f"task:{task_id}") if task_id else {}
+        return {
+            "execution_id": self.execution_id(), "node_id": self.node["id"] if self.node else self.workflow["flow"]["id"],
+            "iteration_path": [], "attempt": attempt or unit.get("attempt") or 1,
+        }
+
+    def _save_payload(self, key, payload):
+        task_id = self.node.get("task_id") if self.node else None
+        return self.save_result(
+            self.workflow, self.run_id, task_id, payload, settings=self.settings,
+            **self.selectors(attempt=payload.get("attempt")),
+        )
+
+    def _saved(self, unit, key):
+        task_id = self.node.get("task_id") if self.node else None
+        payload = self.load_result(
+            self.workflow, self.run_id, task_id, unit["result_ref"],
+            **{**unit["selectors"]},
+        )
+        if (
+            payload.get("unit_id") != key or payload.get("input_digest") != unit.get("input_digest")
+            or payload.get("attempt") != unit.get("attempt")
+        ):
+            raise WorkflowRuntimeConflict("workflow_checkpoint_invalid")
+        return payload["value"]
+
+    def _pause(self, key, digest):
+        if self.node:
+            self.record_execution(state="paused", reason_code="inputs_changed")
+        self.store.wait(self.lease.token, state="paused", gate={
+            "id": execution_fingerprint([self.execution_id(), key, digest, "pause"]),
+            "kind": "pause", "unit_id": key, "input_digest": digest, **self.selectors(),
+            "definition_revision": self.workflow.get("definition_revision"),
+            "reason": "Saved inputs changed. Cancel this run and start a new one.", "choices": ["cancel"],
+        })
+        raise WorkflowSuspended("paused")
+
+    def _gate(self, key, digest, attempt, kind, reason, inputs=None):
+        gate_id = execution_fingerprint([self.execution_id(), key, digest, attempt, kind])
+        row = self.store.journal_read("decision", ["gate", gate_id])
+        choice = "approve" if kind == "approval" else "retry"
+        if row and all(row["payload"].get(name) == value for name, value in {
+            "execution_id": self.execution_id(), "attempt": attempt, "input_digest": digest, "choice": choice,
+        }.items()):
+            return
+        state = "waiting_approval" if kind == "approval" else "waiting_recovery"
+        if self.node and self.node["kind"] == "task":
+            self.record_execution(
+                state=state, attempt=attempt,
+                consumed_inputs=(inputs or {}).get("consumed_inputs") or [],
+                reference_sources=(inputs or {}).get("references") or [],
+            )
+            self._attempt(attempt, state=state)
+        self.store.wait(self.lease.token, state=state, gate={
+            "id": gate_id, "kind": kind, "unit_id": key, "input_digest": digest,
+            **self.selectors(attempt=attempt), "reason": reason,
+            "definition_revision": self.workflow.get("definition_revision"),
+            "choices": ["approve", "reject"] if kind == "approval" else ["retry", "cancel"],
+        })
+        raise WorkflowSuspended(state)
+
+    def record_execution(self, **fields):
+        if self.node is None:
+            return None
+        previous = self.store.journal_read("execution", self.execution_id())
+        if previous and previous["payload"].get("state") in {"succeeded", "completed", "skipped", "failed", "invalid", "incomplete"}:
+            prior = previous["payload"]
+            if fields.get("attempt", prior.get("attempt")) == prior.get("attempt") and fields.get("state") == prior.get("state"):
+                if fields.get("workflow_result", prior.get("workflow_result")) != prior.get("workflow_result"):
+                    raise WorkflowRuntimeConflict("immutable_attempt_conflict")
+                return previous
+        payload = previous["payload"] if previous else {
+            "execution_id": self.execution_id(), "node_id": self.node["id"], "node_kind": self.node["kind"],
+            "iteration_path": [], "region_id": self.region_id, "attempt": 0,
+            **({"task_id": self.node["task_id"]} if self.node.get("task_id") else {}),
+        }
+        if previous and fields.get("attempt", payload["attempt"]) != payload["attempt"]:
+            payload = {key: value for key, value in payload.items() if key not in {
+                "workflow_result", "workflow_validation", "consumed_inputs", "completed_at", "started_at", "reason_code",
+            }}
+        return self.store.journal_commit(
+            self.lease.token, "execution", self.execution_id(), {**payload, **fields},
+            updates={"cursor": {"region_id": self.region_id, "node_id": self.node["id"]}},
+        )
+
+    def run_unit(self, key, operation, *, inputs, replay_safe=False, approval=None):
+        self.check()
+        digest = execution_fingerprint(inputs)
+        unit = self.unit(key)
+        if unit and unit.get("input_digest") != digest:
+            self._pause(key, digest)
+        if unit.get("state") == "completed":
+            result = self._saved(unit, key)
+            self.check()
+            return result
+        execution_row = self.store.journal_read("execution", self.execution_id()) if self.node else None
+        if execution_row and execution_row["payload"].get("state") == "paused" and unit.get("state") != "completed":
+            self.record_execution(state="queued", reason_code="")
+        previous_attempt = int(unit.get("attempt") or 0)
+        task_operation = self.node is not None and key == f"task:{self.node.get('task_id')}"
+        if task_operation:
+            self.record_execution(
+                state="queued", attempt=previous_attempt + 1,
+                consumed_inputs=inputs.get("consumed_inputs") or [],
+                reference_sources=inputs.get("references") or [],
+            )
+        if unit and unit.get("state") in {"running", "failed"} and (
+            not unit.get("replay_safe") or previous_attempt >= 3
+        ):
+            self._gate(key, digest, previous_attempt, "recovery",
+                       "Review any external effects before retrying the interrupted task.", inputs)
+        attempt = previous_attempt + 1
+        if approval and approval.get("required") is True:
+            self._gate(key, digest, attempt, "approval",
+                       str(approval.get("message") or "Review this exact task attempt before execution.")[:1000], inputs)
+        selectors = self.selectors(attempt=attempt)
+        unit = {
+            "state": "running", "attempt": attempt, "input_digest": digest,
+            "replay_safe": bool(replay_safe), "selectors": selectors, "execution_id": self.execution_id(),
+        }
+        if task_operation:
+            admitted_by_condition = attempt == 1 and self.store.journal_read(
+                "decision", ["control", self.execution_id()],
+            ) is not None
+            self.store.journal_commit(
+                self.lease.token, "admission", [self.execution_id(), attempt],
+                {"execution_id": self.execution_id(), "attempt": attempt, "input_digest": digest},
+                admission=not admitted_by_condition, immutable=True,
+                updates={"cursor": {"region_id": self.region_id, "node_id": self.node["id"]}, "phase": self.node["id"]},
+            )
+            self.record_execution(state="running", attempt=attempt, started_at=self.store._now().isoformat(),
+                                  consumed_inputs=inputs.get("consumed_inputs") or [])
+            self._attempt(attempt, state="running")
+        self.store.journal_commit(self.lease.token, "unit", self._key(key), unit)
+        try:
+            result = operation()
+        except Exception:
+            self.check()
+            self.store.journal_commit(self.lease.token, "unit", self._key(key), {**unit, "state": "failed"})
+            if task_operation:
+                self.record_execution(state="failed", attempt=attempt)
+                self._attempt(attempt, state="failed")
+            if not replay_safe:
+                self._gate(key, digest, attempt, "recovery", "Review any external effects before retrying this failed attempt.", inputs)
+            raise
+        self.check()
+        reference = self._save_payload(key, {
+            "unit_id": key, "input_digest": digest, "attempt": attempt, "value": result,
+        })
+        self.store.journal_commit(self.lease.token, "unit", self._key(key), {
+            **unit, "state": "completed", "result_ref": reference,
+        })
+        return result
+
+    def _attempt(self, attempt, **fields):
+        row = self.store.journal_read("execution", self.execution_id())
+        payload = {**(row["payload"] if row else {}), "attempt": attempt, **fields}
+        previous = self.store.journal_read("attempt", [self.execution_id(), attempt])
+        if previous and previous["payload"].get("state") not in {"running", "waiting_output", "pending", "waiting_approval", "waiting_recovery"}:
+            if previous["payload"].get("workflow_result") != payload.get("workflow_result"):
+                raise WorkflowRuntimeConflict("immutable_attempt_conflict")
+            if fields.get("state") not in {previous["payload"]["state"], "waiting_recovery"}:
+                raise WorkflowRuntimeConflict("immutable_attempt_conflict")
+            return previous
+        return self.store.journal_commit(
+            self.lease.token, "attempt", [self.execution_id(), attempt], payload,
+        )
+
+    def finish_node(self, **fields):
+        row = self.record_execution(**fields, completed_at=self.store._now().isoformat())
+        if self.node and fields.get("state") != "skipped":
+            self._attempt(row["payload"]["attempt"], **{key: value for key, value in fields.items() if key != "attempt"})
+        return row
+
+    def snapshot(self, key):
+        self.check()
+        unit = self.unit(key)
+        return self._saved(unit, key) if unit.get("state") == "completed" else None
+
+    def invalidate_task(self, key):
+        unit = self.unit(key)
+        if unit:
+            self.store.journal_commit(self.lease.token, "unit", self._key(key), {**unit, "state": "failed"})
+
+    def replace_unit_result(self, key, value):
+        unit = self.unit(key)
+        if unit.get("state") != "completed":
+            raise WorkflowRuntimeConflict("workflow_checkpoint_unavailable")
+        reference = self._save_payload(key, {
+            "unit_id": key, "input_digest": unit["input_digest"], "attempt": unit["attempt"], "value": value,
+        })
+        self.store.journal_commit(self.lease.token, "unit", self._key(key), {**unit, "result_ref": reference})
+
+    def wait_for_output(self, key, references):
+        unit = self.unit(key)
+        self.record_execution(state="waiting_output", attempt=int(unit.get("attempt") or 1))
+        self.store.wait(self.lease.token, state="waiting_output", gate={
+            "id": execution_fingerprint([self.execution_id(), key, unit.get("attempt"), "output"]),
+            "kind": "output", "unit_id": key, "input_digest": unit.get("input_digest", ""),
+            **self.selectors(), "reason": "Waiting for the submitted output to finish.",
+            "choices": [], "references": references,
+        })
+        raise WorkflowSuspended("waiting_output")
+
+    def may_recover_analysis_unit(self, task_id):
+        unit = self.unit(f"task:{task_id}")
+        attempt = int(unit.get("attempt") or 0) - 1
+        gate_id = execution_fingerprint([
+            self.execution_id(), f"task:{task_id}", unit.get("input_digest"), attempt, "recovery",
+        ])
+        row = self.store.journal_read("decision", ["gate", gate_id])
+        return bool(row and row["payload"].get("choice") == "retry")
diff --git a/application/single_app/route_backend_workflows.py b/application/single_app/route_backend_workflows.py
index 1a3e17cb3..483097c93 100644
--- a/application/single_app/route_backend_workflows.py
+++ b/application/single_app/route_backend_workflows.py
@@ -99,6 +99,7 @@
     workflow_runtime_status,
 )
 from functions_workflow_runtime_store import RuntimeUnavailable, WorkflowRuntimeConflict
+from functions_workflow_execution_history import workflow_execution_history, workflow_execution_result_page
 from route_backend_agents import (
     _build_agent_instruction_api_params,
     _create_agent_instruction_client,
@@ -150,6 +151,8 @@ def _workflow_definition_response(workflow, reader_user_id):
 
 
 def _workflow_task_result_page_response(workflow, run_record, task_id, get_item):
+    if (run_record or {}).get('definition_version') == 3 or ((run_record or {}).get('runtime') or {}).get('schema_version') == 2:
+        return jsonify({'error': 'Select an exact execution and attempt for this structured run.'}), 409
     run_id = _normalize_identifier((run_record or {}).get('id'))
     workflow_id = _normalize_identifier((workflow or {}).get('id'))
     if not workflow_id or not run_id or _normalize_identifier(run_record.get('workflow_id')) != workflow_id:
@@ -162,6 +165,8 @@ def _workflow_task_result_page_response(workflow, run_record, task_id, get_item)
     )):
         return jsonify({'error': 'Workflow task result not found.'}), 404
     summary = item.get('workflow_result') or {}
+    if summary.get('contract_version') == 'workflow-result-v2':
+        return jsonify({'error': 'Select an exact execution and attempt for this structured run.'}), 409
     result_ref = summary.get('result_ref')
     if not isinstance(result_ref, dict):
         return jsonify({'error': 'This task has no durable result. Older runs contain previews only.'}), 409
@@ -309,6 +314,48 @@ def _workflow_runtime_response(workflow_id, run_id, *, group=False, action=None)
         return jsonify({'error': 'Workflow progress is temporarily unavailable.'}), 503
 
 
+def _workflow_execution_history_response(workflow_id, run_id, *, group=False, kind='execution',
+                                         execution_id=None, attempt=None):
+    user_id = get_current_user_id()
+    try:
+        if group:
+            group_id, _ = _resolve_group_workflow_request_group(user_id)
+            workflow = get_group_workflow(group_id, workflow_id)
+            run = get_group_workflow_run(group_id, run_id)
+        else:
+            workflow = get_personal_workflow(user_id, workflow_id)
+            run = get_personal_workflow_run(user_id, run_id)
+        if not workflow or not run or run.get('workflow_id') != workflow_id:
+            return jsonify({'error': 'Workflow run not found.'}), 404
+        if attempt is not None:
+            offset, limit = int(request.args.get('offset', '0')), int(request.args.get('limit', '2000'))
+            if offset < 0 or not 1 <= limit <= 65536 or attempt < 1:
+                raise ValueError('Invalid result page.')
+            response = workflow_execution_result_page(
+                workflow, run_id, execution_id, attempt, reader_user_id=user_id,
+                output=request.args.get('output', 'authoritative'), offset=offset, limit=limit,
+            )
+        else:
+            response = workflow_execution_history(
+                workflow, run_id, reader_user_id=user_id, kind=kind, execution_id=execution_id,
+                cursor=request.args.get('cursor'), limit=int(request.args.get('limit', '50')),
+            )
+        return jsonify(response)
+    except WorkflowRuntimeConflict as exc:
+        return jsonify({'error': exc.public_message, 'code': exc.code}), 409
+    except (PermissionError, AnalysisResultUnavailable):
+        return jsonify({'error': 'Current access to this execution or its contributing sources could not be confirmed.'}), 403
+    except (LookupError, CosmosResourceNotFoundError):
+        return jsonify({'error': 'Workflow execution or attempt not found.'}), 404
+    except (ValueError, TypeError):
+        return jsonify({'error': 'Invalid execution, attempt or page request.'}), 400
+    except (AzureError, RuntimeUnavailable, WorkflowResultStorageUnavailableError) as exc:
+        log_event('[WORKFLOW_ROUTES] Execution history read failed',
+                  extra={'workflow_id': workflow_id, 'run_id': run_id, 'error_type': type(exc).__name__},
+                  level=logging.ERROR)
+        return jsonify({'error': 'Workflow execution history is temporarily unavailable.'}), 503
+
+
 def _queue_workflow_response(workflow, user_id):
     data = request.get_json(silent=True)
     if data is None and not request.data:
@@ -903,6 +950,78 @@ def _stream_group_workflow_activity(user_id, group_id, conversation_id='', workf
 
 
 def register_route_backend_workflows(bp):
+    @bp.route('/api/user/workflows/<workflow_id>/runs/<run_id>/executions', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('allow_user_workflows')
+    @workflow_user_required
+    def get_user_workflow_executions(workflow_id, run_id):
+        return _workflow_execution_history_response(workflow_id, run_id)
+
+    @bp.route('/api/group/workflows/<workflow_id>/runs/<run_id>/executions', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('enable_group_workspaces')
+    @enabled_required('allow_group_workflows')
+    def get_group_workflow_executions(workflow_id, run_id):
+        return _workflow_execution_history_response(workflow_id, run_id, group=True)
+
+    @bp.route('/api/user/workflows/<workflow_id>/runs/<run_id>/executions/<execution_id>/attempts', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('allow_user_workflows')
+    @workflow_user_required
+    def get_user_workflow_execution_attempts(workflow_id, run_id, execution_id):
+        return _workflow_execution_history_response(workflow_id, run_id, execution_id=execution_id, kind='attempt')
+
+    @bp.route('/api/group/workflows/<workflow_id>/runs/<run_id>/executions/<execution_id>/attempts', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('enable_group_workspaces')
+    @enabled_required('allow_group_workflows')
+    def get_group_workflow_execution_attempts(workflow_id, run_id, execution_id):
+        return _workflow_execution_history_response(workflow_id, run_id, group=True, execution_id=execution_id, kind='attempt')
+
+    @bp.route('/api/user/workflows/<workflow_id>/runs/<run_id>/executions/<execution_id>/attempts/<int:attempt>/result', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('allow_user_workflows')
+    @workflow_user_required
+    def get_user_workflow_execution_result(workflow_id, run_id, execution_id, attempt):
+        return _workflow_execution_history_response(workflow_id, run_id, execution_id=execution_id, attempt=attempt)
+
+    @bp.route('/api/group/workflows/<workflow_id>/runs/<run_id>/executions/<execution_id>/attempts/<int:attempt>/result', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('enable_group_workspaces')
+    @enabled_required('allow_group_workflows')
+    def get_group_workflow_execution_result(workflow_id, run_id, execution_id, attempt):
+        return _workflow_execution_history_response(workflow_id, run_id, group=True, execution_id=execution_id, attempt=attempt)
+
+    @bp.route('/api/user/workflows/<workflow_id>/runs/<run_id>/runtime/decisions', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('allow_user_workflows')
+    @workflow_user_required
+    def get_user_workflow_decisions(workflow_id, run_id):
+        return _workflow_execution_history_response(workflow_id, run_id, kind='decision')
+
+    @bp.route('/api/group/workflows/<workflow_id>/runs/<run_id>/runtime/decisions', methods=['GET'])
+    @swagger_route(security=get_auth_security())
+    @login_required
+    @user_required
+    @enabled_required('enable_group_workspaces')
+    @enabled_required('allow_group_workflows')
+    def get_group_workflow_decisions(workflow_id, run_id):
+        return _workflow_execution_history_response(workflow_id, run_id, group=True, kind='decision')
+
     @bp.route('/api/user/workflows/<workflow_id>/runs/<run_id>/runtime', methods=['GET'])
     @swagger_route(security=get_auth_security())
     @login_required
diff --git a/application/single_app/static/js/workspace/workspace_workflows.js b/application/single_app/static/js/workspace/workspace_workflows.js
index 6ee5f37d9..e3530fc79 100644
--- a/application/single_app/static/js/workspace/workspace_workflows.js
+++ b/application/single_app/static/js/workspace/workspace_workflows.js
@@ -4028,10 +4028,21 @@ function resetWorkflowForm() {
     showWorkflowStep(0);
 }
 
+function workflowNeedsNativeEditor(workflow) {
+    return Boolean(workflow && (
+        (workflow.definition_version !== undefined && workflow.definition_version !== 1)
+        || workflow.flow !== undefined
+    ));
+}
+
 async function openWorkflowModal(workflow = null) {
     if (!workflowModal) {
         return;
     }
+    if (workflowNeedsNativeEditor(workflow)) {
+        showToast("This workflow uses advanced data flow. Open V2 to edit it without losing its configuration. Run and Cancel remain available here.", "warning");
+        return;
+    }
     if (workflowWorkspaceConfig.scope === "group" && !getWorkflowActiveGroupId()) {
         showToast("Select a group before managing group workflows.", "warning");
         return;
diff --git a/application/v2_ui/src/components/workflows/WorkflowConditionEditor.tsx b/application/v2_ui/src/components/workflows/WorkflowConditionEditor.tsx
new file mode 100644
index 000000000..1479498d8
--- /dev/null
+++ b/application/v2_ui/src/components/workflows/WorkflowConditionEditor.tsx
@@ -0,0 +1,418 @@
+// WorkflowConditionEditor.tsx
+// Typed input and condition controls; predicates are never evaluated in the browser.
+
+import { useState } from 'react';
+import { Plus, Trash2 } from 'lucide-react';
+import { GlassButton } from '../ui/primitives';
+import {
+    analyzeWorkflowFlow,
+    defaultFlowPredicate,
+    flowBinding,
+    flowProducers,
+    FLOW_ALIAS_PATTERN,
+    FLOW_COMPARISONS,
+    FLOW_MAX_PREDICATE_DEPTH,
+    FLOW_OUTPUT_KINDS,
+    predicateSummary,
+    scalarSchemaFields,
+    type FlowProducer,
+    type WorkflowFlowBinding,
+    type WorkflowOperand,
+    type WorkflowPredicate,
+    type WorkflowScalar,
+} from '../../lib/workflowFlow';
+import type { WorkflowDefinition, WorkflowOutputContract, WorkflowOutputKind } from '../../lib/workflowEditor';
+import { isRecord } from '../../lib/workspaceAuthoring';
+
+const inputClass = 'mt-1 w-full min-w-0 rounded-lg border border-edge bg-surface-1 px-3 py-2 text-sm text-text-1 focus:border-accent focus:outline-none';
+
+export function WorkflowFlowInputs({
+    workflow,
+    nodeId,
+    bindings,
+    onChange,
+    label = 'Named inputs',
+    availableIds,
+}: {
+    workflow: WorkflowDefinition;
+    nodeId: string;
+    bindings: WorkflowFlowBinding[];
+    onChange: (bindings: WorkflowFlowBinding[]) => void;
+    label?: string;
+    availableIds?: Set<string>;
+}) {
+    const available = availableIds ?? analyzeWorkflowFlow(workflow).available.get(nodeId) ?? new Set<string>();
+    const producers = flowProducers(workflow).filter((producer) => available.has(producer.id));
+    const update = (index: number, binding: WorkflowFlowBinding) =>
+        onChange(bindings.map((current, position) => position === index ? binding : current));
+    const add = () => {
+        const producer = producers[0];
+        if (!producer) return;
+        let number = 1;
+        while (bindings.some((binding) => binding.name === `input${number}`)) number++;
+        onChange([...bindings, {
+            ...flowBinding(`input${number}`, producer.id, producer.outputs[0]?.name ?? 'authoritative'),
+            expected_kind: producer.outputs[0]?.kind ?? 'any',
+        }]);
+    };
+    return (
+        <fieldset className="min-w-0 space-y-3 rounded-xl border border-edge p-3">
+            <legend className="px-1 text-sm font-medium text-text-1">{label}</legend>
+            <p className="text-xs text-text-3">
+                Only these named final outputs are consumed. A skipped producer never falls back to another task.
+            </p>
+            {bindings.map((binding, index) => {
+                const producer = producers.find((item) => item.id === binding.source.node_id);
+                return (
+                    <div key={index} className="grid min-w-0 gap-3 rounded-lg bg-surface-sunken p-3 sm:grid-cols-2">
+                        <label className="min-w-0 text-xs text-text-2">
+                            Input name
+                            <input className={inputClass} aria-label={`${label} input ${index + 1} name`}
+                                value={binding.name} maxLength={64}
+                                onChange={(event) => update(index, { ...binding, name: event.target.value })} />
+                        </label>
+                        <label className="min-w-0 text-xs text-text-2">
+                            Producer
+                            <select className={inputClass} aria-label={`${label} input ${index + 1} producer`}
+                                value={binding.source.node_id} onChange={(event) => {
+                                    const selected = producers.find((item) => item.id === event.target.value);
+                                    if (selected) update(index, {
+                                        ...binding,
+                                        source: { ...binding.source, node_id: selected.id, output: selected.outputs[0]?.name ?? '' },
+                                        expected_kind: selected.outputs[0]?.kind ?? 'any',
+                                    });
+                                }}>
+                                {!producer ? <option value={binding.source.node_id}>Unavailable: {binding.source.node_id || 'choose a producer'}</option> : null}
+                                {producers.map((item) => <option key={item.id} value={item.id}>{item.label}</option>)}
+                            </select>
+                        </label>
+                        <label className="min-w-0 text-xs text-text-2">
+                            Final output
+                            <select className={inputClass} aria-label={`${label} input ${index + 1} output`}
+                                value={binding.source.output} onChange={(event) => {
+                                    const output = producer?.outputs.find((item) => item.name === event.target.value);
+                                    update(index, {
+                                        ...binding, source: { ...binding.source, output: event.target.value },
+                                        expected_kind: output?.kind ?? binding.expected_kind,
+                                    });
+                                }}>
+                                {!producer?.outputs.some((item) => item.name === binding.source.output) ? (
+                                    <option value={binding.source.output}>Unavailable: {binding.source.output || 'choose an output'}</option>
+                                ) : null}
+                                {producer?.outputs.map((output) => <option key={output.name} value={output.name}>{output.name}</option>)}
+                            </select>
+                        </label>
+                        <label className="text-xs text-text-2">
+                            Expected kind
+                            <select className={inputClass} aria-label={`${label} input ${index + 1} kind`}
+                                value={binding.expected_kind}
+                                onChange={(event) => update(index, { ...binding, expected_kind: event.target.value as WorkflowOutputKind })}>
+                                {FLOW_OUTPUT_KINDS.map((kind) => <option key={kind} value={kind}>{kind.replaceAll('_', ' ')}</option>)}
+                            </select>
+                        </label>
+                        <label className="flex items-center gap-2 text-xs text-text-2">
+                            <input type="checkbox" checked={binding.required}
+                                aria-label={`${label} input ${index + 1} required`}
+                                onChange={(event) => update(index, { ...binding, required: event.target.checked })} />
+                            Required on every reaching path
+                        </label>
+                        <label className="flex items-center gap-2 text-xs text-text-2">
+                            <input type="checkbox" checked={binding.allow_partial}
+                                aria-label={`${label} input ${index + 1} allow partial`}
+                                onChange={(event) => update(index, { ...binding, allow_partial: event.target.checked })} />
+                            Accept eligible completed partial output
+                        </label>
+                        <GlassButton size="sm" variant="danger" aria-label={`${label} remove input ${index + 1}`}
+                            onClick={() => onChange(bindings.filter((_, position) => position !== index))}>
+                            <Trash2 size={14} /> Remove input
+                        </GlassButton>
+                    </div>
+                );
+            })}
+            <GlassButton size="sm" disabled={!producers.length || bindings.length >= 100} onClick={add}
+                aria-label={`Add ${label.toLowerCase()} input`}>
+                <Plus size={14} /> Add input
+            </GlassButton>
+            {!producers.length ? <p className="text-xs text-text-3">Add a reachable producer before this node to bind its output.</p> : null}
+        </fieldset>
+    );
+}
+
+function OperandEditor({
+    value,
+    bindings,
+    producers,
+    onChange,
+    label,
+    inputOnly = false,
+}: {
+    value: WorkflowOperand;
+    bindings: WorkflowFlowBinding[];
+    producers: FlowProducer[];
+    onChange: (value: WorkflowOperand) => void;
+    label: string;
+    inputOnly?: boolean;
+}) {
+    const mode = 'input' in value ? 'input' : 'literal';
+    const binding = 'input' in value ? bindings.find((item) => item.name === value.input) : undefined;
+    const schema = producers.find((item) => item.id === binding?.source.node_id)?.outputs
+        .find((item) => item.name === binding?.source.output)?.schema;
+    const fields = scalarSchemaFields(schema);
+    if (inputOnly && schema && !fields.some((field) => field.path === '')) {
+        fields.unshift({ path: '', type: String(schema.type ?? 'value') });
+    }
+    const firstField = (name: string): WorkflowOperand => {
+        const selected = bindings.find((item) => item.name === name);
+        const output = producers.find((item) => item.id === selected?.source.node_id)?.outputs
+            .find((item) => item.name === selected?.source.output);
+        return { input: name, path: scalarSchemaFields(output?.schema)[0]?.path ?? '' };
+    };
+    const literalType = 'literal' in value ? value.literal === null ? 'null' : typeof value.literal : 'boolean';
+    return (
+        <fieldset className="min-w-0 space-y-2 rounded-lg border border-edge p-3">
+            <legend className="px-1 text-xs text-text-2">{label}</legend>
+            {!inputOnly ? (
+                <label className="block text-xs text-text-2">
+                    Value source
+                    <select className={inputClass} aria-label={`${label} value source`} value={mode}
+                        onChange={(event) => onChange(event.target.value === 'input'
+                            ? firstField(bindings[0]?.name ?? '') : { literal: true })}>
+                        <option value="input">Named input field</option>
+                        <option value="literal">Typed value</option>
+                    </select>
+                </label>
+            ) : null}
+            {'input' in value ? (
+                <>
+                    <label className="block text-xs text-text-2">
+                        Named input
+                        <select className={inputClass} aria-label={`${label} input`} value={value.input}
+                            onChange={(event) => onChange(firstField(event.target.value))}>
+                            {!bindings.some((item) => item.name === value.input) ? <option value={value.input}>Choose input</option> : null}
+                            {bindings.map((item, index) => <option key={index} value={item.name}>{item.name || '(name required)'}</option>)}
+                        </select>
+                    </label>
+                    <label className="block text-xs text-text-2">
+                        Validated field
+                        <select className={inputClass} aria-label={`${label} field`} value={value.path}
+                            onChange={(event) => onChange({ ...value, path: event.target.value })}>
+                            {!fields.some((field) => field.path === value.path) ? (
+                                <option value={value.path}>{value.path ? `Saved field: ${value.path}` : 'Choose field'}</option>
+                            ) : null}
+                            {fields.map((field) => <option key={field.path} value={field.path}>{field.path || '(whole value)'} ({field.type})</option>)}
+                        </select>
+                    </label>
+                    {!fields.length ? (
+                        <p className="text-xs text-warn">Declare typed decision fields in the producer's JSON output contract first.</p>
+                    ) : null}
+                </>
+            ) : (
+                <>
+                    <label className="block text-xs text-text-2">
+                        Value type
+                        <select className={inputClass} aria-label={`${label} type`} value={literalType}
+                            onChange={(event) => {
+                                const defaults: Record<string, WorkflowScalar> = { boolean: true, number: 0, string: '', null: null };
+                                onChange({ literal: defaults[event.target.value] });
+                            }}>
+                            <option value="boolean">Boolean</option>
+                            <option value="number">Number</option>
+                            <option value="string">Text / enum value</option>
+                            <option value="null">Null (present but empty)</option>
+                        </select>
+                    </label>
+                    {typeof value.literal === 'boolean' ? (
+                        <label className="block text-xs text-text-2">
+                            Boolean value
+                            <select className={inputClass} aria-label={`${label} value`} value={String(value.literal)}
+                                onChange={(event) => onChange({ literal: event.target.value === 'true' })}>
+                                <option value="true">true</option><option value="false">false</option>
+                            </select>
+                        </label>
+                    ) : typeof value.literal === 'number' ? (
+                        <label className="block text-xs text-text-2">
+                            Number
+                            <input className={inputClass} type="number" step="any" aria-label={`${label} value`}
+                                value={Number.isFinite(value.literal) ? value.literal : ''}
+                                onChange={(event) => onChange({ literal: event.currentTarget.valueAsNumber })} />
+                        </label>
+                    ) : typeof value.literal === 'string' ? (
+                        <label className="block text-xs text-text-2">
+                            Text value (case-sensitive)
+                            <input className={inputClass} aria-label={`${label} value`} value={value.literal}
+                                onChange={(event) => onChange({ literal: event.target.value })} />
+                        </label>
+                    ) : <p className="text-xs text-text-3">Null is different from a missing field. Use Exists to handle absence.</p>}
+                </>
+            )}
+        </fieldset>
+    );
+}
+
+export function WorkflowConditionEditor({
+    value,
+    bindings,
+    workflow,
+    onChange,
+    label = 'Condition',
+    depth = 1,
+}: {
+    value: WorkflowPredicate;
+    bindings: WorkflowFlowBinding[];
+    workflow: WorkflowDefinition;
+    onChange: (condition: WorkflowPredicate) => void;
+    label?: string;
+    depth?: number;
+}) {
+    const producers = flowProducers(workflow);
+    const operation = (op: string) => {
+        const left: WorkflowOperand = 'left' in value ? value.left : value.op === 'exists'
+            ? value.value : { input: bindings[0]?.name ?? '', path: '' };
+        if (op === 'all' || op === 'any') {
+            onChange({ op, conditions: value.op === 'all' || value.op === 'any' ? value.conditions : [value] });
+        } else if (op === 'not') {
+            onChange({ op, condition: value });
+        } else if (op === 'exists') {
+            onChange({ op, value: 'input' in left ? left : { input: bindings[0]?.name ?? '', path: '' } });
+        } else {
+            const comparison = FLOW_COMPARISONS.find((item) => item === op);
+            if (comparison) onChange({ op: comparison, left, right: 'right' in value ? value.right : { literal: true } });
+        }
+    };
+    return (
+        <div className="min-w-0 space-y-3 rounded-xl border border-edge p-3" aria-label={label}>
+            <label className="block text-sm font-medium text-text-1">
+                {label}
+                <select className={inputClass} aria-label={`${label} operation`} value={value.op}
+                    onChange={(event) => operation(event.target.value)}>
+                    <option value="eq">Equals</option><option value="ne">Does not equal</option>
+                    <option value="lt">Less than</option><option value="lte">Less than or equal</option>
+                    <option value="gt">Greater than</option><option value="gte">Greater than or equal</option>
+                    <option value="exists">Exists</option>
+                    <option value="all" disabled={depth >= FLOW_MAX_PREDICATE_DEPTH}>All conditions (AND)</option>
+                    <option value="any" disabled={depth >= FLOW_MAX_PREDICATE_DEPTH}>Any condition (OR)</option>
+                    <option value="not" disabled={depth >= FLOW_MAX_PREDICATE_DEPTH}>Not</option>
+                </select>
+            </label>
+            {value.op === 'all' || value.op === 'any' ? (
+                <div className="space-y-3 border-l border-edge pl-2 sm:pl-3">
+                    {value.conditions.map((condition, index) => (
+                        <div key={index} className="space-y-2">
+                            <WorkflowConditionEditor value={condition} bindings={bindings} workflow={workflow}
+                                label={`${label} rule ${index + 1}`} depth={depth + 1}
+                                onChange={(next) => onChange({ ...value, conditions: value.conditions.map((item, position) => position === index ? next : item) })} />
+                            <GlassButton size="sm" variant="danger" disabled={value.conditions.length <= 1}
+                                onClick={() => onChange({ ...value, conditions: value.conditions.filter((_, position) => position !== index) })}
+                                aria-label={`Remove ${label} rule ${index + 1}`}><Trash2 size={14} /> Remove rule</GlassButton>
+                        </div>
+                    ))}
+                    <GlassButton size="sm" disabled={depth >= FLOW_MAX_PREDICATE_DEPTH}
+                        onClick={() => onChange({ ...value, conditions: [...value.conditions, defaultFlowPredicate(bindings[0]?.name)] })}
+                        aria-label={`Add ${label} rule`}><Plus size={14} /> Add condition</GlassButton>
+                </div>
+            ) : value.op === 'not' ? (
+                <WorkflowConditionEditor value={value.condition} bindings={bindings} workflow={workflow} depth={depth + 1}
+                    label={`${label} negated`} onChange={(condition) => onChange({ ...value, condition })} />
+            ) : value.op === 'exists' ? (
+                <OperandEditor value={value.value} bindings={bindings} producers={producers} inputOnly
+                    label={`${label} field`} onChange={(field) => onChange({ ...value, value: field })} />
+            ) : 'left' in value ? (
+                <div className="grid min-w-0 gap-3 sm:grid-cols-2">
+                    <OperandEditor value={value.left} bindings={bindings} producers={producers}
+                        label={`${label} left`} onChange={(left) => onChange({ ...value, left })} />
+                    <OperandEditor value={value.right} bindings={bindings} producers={producers}
+                        label={`${label} right`} onChange={(right) => onChange({ ...value, right })} />
+                </div>
+            ) : null}
+            {depth === 1 ? (
+                <>
+                    <p className="break-words text-xs text-text-2">{predicateSummary(value)}</p>
+                    <p className="text-xs text-text-3">
+                        Evaluated by the server from validated data. Missing values need an Exists guard; null, false, and zero are distinct values.
+                    </p>
+                </>
+            ) : null}
+        </div>
+    );
+}
+
+export function WorkflowDecisionFields({
+    contract,
+    onChange,
+}: {
+    contract: WorkflowOutputContract;
+    onChange: (contract: WorkflowOutputContract) => void;
+}) {
+    const [name, setName] = useState('');
+    const [type, setType] = useState('boolean');
+    const [enumText, setEnumText] = useState('');
+    const schema = contract.schema ?? { type: 'object' };
+    if (contract.kind !== 'json' || (schema.type !== undefined && schema.type !== 'object')) return null;
+    const properties = isRecord(schema.properties) ? schema.properties : {};
+    const required = Array.isArray(schema.required) ? schema.required.filter((item): item is string => typeof item === 'string') : [];
+    const enumValues = enumText.split('\n').map((item) => item.trim()).filter(Boolean);
+    const validName = FLOW_ALIAS_PATTERN.test(name) && !Object.hasOwn(properties, name);
+    const validEnum = type !== 'enum' || (enumValues.length > 0 && new Set(enumValues).size === enumValues.length);
+    return (
+        <fieldset className="min-w-0 space-y-3 rounded-xl border border-edge p-3">
+            <legend className="px-1 text-sm font-medium text-text-1">Structured decision fields</legend>
+            <p className="text-xs text-text-3">
+                Declare Boolean, numeric, or enum fields for If/else and Run when. The task must return them inside its final JSON object.
+            </p>
+            {Object.entries(properties).map(([fieldName, field]) => (
+                <div key={fieldName} className="flex flex-wrap items-center gap-3 text-xs text-text-2">
+                    <span className="min-w-0 flex-1 break-all">{fieldName} ({isRecord(field) ? String(field.type ?? 'custom schema') : 'custom schema'})</span>
+                    <label className="flex items-center gap-2">
+                        <input type="checkbox" aria-label={`Require decision field ${fieldName}`} checked={required.includes(fieldName)}
+                            onChange={(event) => onChange({
+                                ...contract, schema: {
+                                    ...schema, required: event.target.checked ? [...required, fieldName] : required.filter((item) => item !== fieldName),
+                                },
+                            })} />
+                        Required
+                    </label>
+                    <GlassButton size="sm" variant="danger" aria-label={`Remove decision field ${fieldName}`} onClick={() => {
+                        const next = { ...properties };
+                        delete next[fieldName];
+                        onChange({ ...contract, schema: { ...schema, properties: next, required: required.filter((item) => item !== fieldName) } });
+                    }}><Trash2 size={14} /></GlassButton>
+                </div>
+            ))}
+            <div className="grid min-w-0 gap-3 sm:grid-cols-2">
+                <label className="text-xs text-text-2">
+                    New field name
+                    <input className={inputClass} aria-label="Decision field name" value={name} maxLength={64}
+                        placeholder="pass" onChange={(event) => setName(event.target.value)} />
+                </label>
+                <label className="text-xs text-text-2">
+                    Field type
+                    <select className={inputClass} aria-label="Decision field type" value={type} onChange={(event) => setType(event.target.value)}>
+                        <option value="boolean">Boolean</option><option value="number">Number</option>
+                        <option value="integer">Integer</option><option value="string">Text</option><option value="enum">Enum (text choices)</option>
+                    </select>
+                </label>
+            </div>
+            {type === 'enum' ? (
+                <label className="block text-xs text-text-2">
+                    Allowed values, one per line
+                    <textarea className={inputClass} aria-label="Decision enum values" value={enumText}
+                        onChange={(event) => setEnumText(event.target.value)} />
+                </label>
+            ) : null}
+            <GlassButton size="sm" disabled={!validName || !validEnum} onClick={() => {
+                onChange({
+                    ...contract,
+                    schema: {
+                        ...schema, type: 'object',
+                        properties: { ...properties, [name]: type === 'enum' ? { type: 'string', enum: enumValues } : { type } },
+                        required: [...required, name],
+                    },
+                });
+                setName('');
+                setEnumText('');
+            }}><Plus size={14} /> Add decision field</GlassButton>
+            {name && !validName ? <p role="status" className="text-xs text-warn">Use a unique field name starting with a letter.</p> : null}
+            {!validEnum ? <p role="status" className="text-xs text-warn">Add at least one unique enum value.</p> : null}
+        </fieldset>
+    );
+}
diff --git a/application/v2_ui/src/components/workflows/WorkflowEditorDialog.tsx b/application/v2_ui/src/components/workflows/WorkflowEditorDialog.tsx
index af3bf347c..6c40686da 100644
--- a/application/v2_ui/src/components/workflows/WorkflowEditorDialog.tsx
+++ b/application/v2_ui/src/components/workflows/WorkflowEditorDialog.tsx
@@ -8,12 +8,23 @@ import { Modal } from '../ui/Modal';
 import { GlassButton, GlassPanel, Toggle } from '../ui/primitives';
 import { Pill } from '../workspace/primitives';
 import { WorkflowDocumentPicker } from './WorkflowDocumentPicker';
+import { WorkflowConditionEditor, WorkflowDecisionFields, WorkflowFlowInputs } from './WorkflowConditionEditor';
+import { WorkflowStructuredList } from './WorkflowStructuredList';
+import {
+    convertToStructuredWorkflow,
+    defaultFlowPredicate,
+    flowUnsupportedReason,
+    isFlowBinding,
+    isLegacyWorkflowBinding,
+    type WorkflowTaskNode,
+} from '../../lib/workflowFlow';
 import {
     createWorkflowTask,
     comparisonActionFromSelection,
     documentActionFromSelection,
     findWorkflowAgent,
     newWorkflowDefinition,
+    normalizeWorkflowDefinition,
     preservedWorkflowFieldLabels,
     safeWorkflowAlias,
     sameWorkflowDefinition,
@@ -41,6 +52,7 @@ import {
     type WorkflowTask,
     type WorkflowTaskRunner,
     type WorkflowReferenceInput,
+    type WorkflowPublication,
 } from '../../lib/workflowEditor';
 
 const inputClass = 'w-full rounded-lg border border-edge bg-surface-1 px-3 py-2 text-sm text-text-1 placeholder:text-text-3 focus:border-accent focus:outline-none';
@@ -105,6 +117,7 @@ function taskValidationErrors(
     const errors: string[] = [];
     const indexes = new Map(tasks.map((item, position) => [item.id, position]));
     for (const input of task.inputs ?? []) {
+        if (workflow.definition_version === 3 || !isLegacyWorkflowBinding(input)) continue;
         const producer = indexes.get(input.task_id);
         if (producer === undefined) {
             errors.push(`${input.name || 'Input'} points to a missing task.`);
@@ -343,7 +356,7 @@ function TaskInputs({
     onChange: (task: WorkflowTask) => void;
 }) {
     const mode = taskInputMode(task);
-    const inputs = task.inputs ?? [];
+    const inputs = (task.inputs ?? []).filter(isLegacyWorkflowBinding);
     const updateInput = (taskId: string, update: Partial<WorkflowInputBinding>) => {
         onChange({
             ...task,
@@ -904,6 +917,8 @@ function TaskCard({
     onSchemaError,
     durableExecution,
     onNeedsDurable,
+    structuredNode,
+    onStructuredNodeChange,
 }: {
     scope: WorkflowScope;
     task: WorkflowTask;
@@ -911,11 +926,13 @@ function TaskCard({
     workflow: WorkflowDefinition;
     options: WorkflowEditorOptions;
     onChange: (task: WorkflowTask) => void;
-    onMove: (direction: -1 | 1) => void;
-    onRemove: () => void;
+    onMove?: (direction: -1 | 1) => void;
+    onRemove?: () => void;
     onSchemaError: (taskId: string, message: string) => void;
     durableExecution: boolean;
     onNeedsDurable: () => void;
+    structuredNode?: WorkflowTaskNode;
+    onStructuredNodeChange?: (node: WorkflowTaskNode) => void;
 }) {
     const previousTasks = workflow.tasks.slice(0, index);
     const errors = taskValidationErrors(task, index, workflow.tasks, workflow);
@@ -939,7 +956,7 @@ function TaskCard({
                         {runnerLabel(task.runner)} · {taskInputMode(task) === 'auto' ? 'automatic input' : `${task.inputs?.length ?? 0} bound inputs`}
                     </p>
                 </div>
-                <div className="flex flex-wrap gap-2">
+                {!structuredNode && onMove && onRemove ? <div className="flex flex-wrap gap-2">
                     <GlassButton size="sm" disabled={index === 0} onClick={() => onMove(-1)} aria-label={`Move ${task.name || `Task ${index + 1}`} up`}>
                         <ArrowUp size={14} /> Up
                     </GlassButton>
@@ -949,7 +966,7 @@ function TaskCard({
                     <GlassButton size="sm" variant="danger" disabled={workflow.tasks.length <= 1} onClick={onRemove} aria-label={`Remove ${task.name || `Task ${index + 1}`}`}>
                         <Trash2 size={14} /> Remove
                     </GlassButton>
-                </div>
+                </div> : null}
             </div>
             {errors.length ? (
                 <div role="alert" className="rounded-xl bg-danger-soft p-3 text-sm text-danger">
@@ -982,18 +999,40 @@ function TaskCard({
                     {task.instructions.length.toLocaleString()} / {WORKFLOW_TASK_INSTRUCTIONS_LIMIT.toLocaleString()} characters
                 </span>
             </label>
+            {structuredNode && onStructuredNodeChange ? (
+                <div className="space-y-3">
+                    <Toggle label="Run when" checked={structuredNode.run_when !== undefined}
+                        description="False intentionally skips this task before approval or execution. A skipped task produces no output."
+                        onChange={(checked) => {
+                            const next = { ...structuredNode };
+                            if (checked) next.run_when = defaultFlowPredicate(task.inputs?.[0]?.name ?? '');
+                            else delete next.run_when;
+                            onStructuredNodeChange(next);
+                        }} />
+                    {structuredNode.run_when ? (
+                        <WorkflowConditionEditor workflow={workflow} bindings={(task.inputs ?? []).filter(isFlowBinding)}
+                            value={structuredNode.run_when} label={`Run when for ${task.name}`}
+                            onChange={(condition) => onStructuredNodeChange({ ...structuredNode, run_when: condition })} />
+                    ) : null}
+                </div>
+            ) : null}
             <details className="rounded-xl border border-edge p-3">
                 <summary className="cursor-pointer text-sm font-medium text-text-1">Runner, inputs, references and outputs</summary>
                 <div className="mt-4 space-y-5">
-                    <TaskRunnerFields runner={task.runner} options={options} onChange={(runner) => onChange({ ...task, runner })} />
+                    {structuredNode ? <TaskPublicationFields task={task} onChange={onChange} /> : null}
+                    {!task.publication ? <TaskRunnerFields runner={task.runner} options={options} onChange={(runner) => onChange({ ...task, runner })} /> : null}
                     <TaskApprovalFields
                         task={task}
                         durableExecution={durableExecution}
                         onNeedsDurable={onNeedsDurable}
                         onChange={onChange}
                     />
-                    <DocumentActionFields scope={scope} task={task} onChange={onChange} />
-                    <TaskInputs task={task} previousTasks={previousTasks} onChange={onChange} />
+                    {!task.publication ? <DocumentActionFields scope={scope} task={task} onChange={onChange} /> : null}
+                    {structuredNode ? (
+                        <WorkflowFlowInputs workflow={workflow} nodeId={structuredNode.id}
+                            bindings={(task.inputs ?? []).filter(isFlowBinding)} label={`${task.name} inputs`}
+                            onChange={(inputs) => onChange({ ...task, inputs })} />
+                    ) : <TaskInputs task={task} previousTasks={previousTasks} onChange={onChange} />}
                     <TaskReferences task={task} workflow={workflow} onChange={onChange} />
                     <label className="text-sm text-text-2">
                         Output contract
@@ -1025,6 +1064,12 @@ function TaskCard({
                         </select>
                     </label>
                     {task.output_contract ? (
+                        <>
+                        {structuredNode ? <WorkflowDecisionFields contract={task.output_contract}
+                            onChange={(contract) => {
+                                setSchemaParseError('');
+                                onChange({ ...task, output_contract: contract });
+                            }} /> : null}
                         <OutputContractFields
                             contract={task.output_contract}
                             onChange={(contract) => {
@@ -1033,6 +1078,7 @@ function TaskCard({
                             errors={{ schema: schemaParseError }}
                             onSchemaError={setSchemaParseError}
                         />
+                        </>
                     ) : (
                         <p className="text-xs text-text-3">
                             No output contract is configured. The backend treats this as any
@@ -1045,6 +1091,72 @@ function TaskCard({
     );
 }
 
+function TaskPublicationFields({ task, onChange }: { task: WorkflowTask; onChange: (task: WorkflowTask) => void }) {
+    const publication = task.publication;
+    const update = (value: WorkflowPublication) => onChange({ ...task, publication: value });
+    return (
+        <div className="space-y-3">
+            <Toggle label="Publish an existing analysis artifact" checked={publication !== undefined}
+                description="Reuse one explicitly bound native Analyze result. No model creates another copy of its content."
+                onChange={(checked) => {
+                    if (checked) onChange({
+                        ...task, publication: { artifact_format: 'md', workspace_scope: 'personal' },
+                        runner: { type: 'inherit' }, document_action: { type: 'none' },
+                        output_contract: { kind: 'json', require_complete_coverage: false, allow_partial: false },
+                    });
+                    else {
+                        const next = { ...task };
+                        delete next.publication;
+                        onChange(next);
+                    }
+                }} />
+            {publication ? (
+                <fieldset className="grid min-w-0 gap-3 rounded-xl border border-edge p-3 sm:grid-cols-2">
+                    <legend className="px-1 text-sm text-text-1">Publication destination</legend>
+                    <label className="text-xs text-text-2">
+                        Existing artifact format
+                        <select className={`${inputClass} mt-1`} aria-label={`Publication format for ${task.name}`}
+                            value={publication.artifact_format} onChange={(event) => update({
+                                ...publication, artifact_format: event.target.value as WorkflowPublication['artifact_format'],
+                            })}>
+                            <option value="md">Markdown</option><option value="csv">CSV</option><option value="json">JSON</option>
+                        </select>
+                    </label>
+                    <label className="text-xs text-text-2">
+                        Destination scope
+                        <select className={`${inputClass} mt-1`} aria-label={`Publication scope for ${task.name}`}
+                            value={publication.workspace_scope} onChange={(event) => {
+                                const scope = event.target.value as WorkflowPublication['workspace_scope'];
+                                update({
+                                    artifact_format: publication.artifact_format, workspace_scope: scope,
+                                    ...(scope === 'group' ? { group_id: '' } : scope === 'public' ? { public_workspace_id: '' } : {}),
+                                });
+                            }}>
+                            <option value="personal">Personal workspace</option><option value="group">Group workspace</option>
+                            <option value="public">Public workspace</option>
+                        </select>
+                    </label>
+                    {publication.workspace_scope !== 'personal' ? (
+                        <label className="text-xs text-text-2 sm:col-span-2">
+                            Destination workspace ID
+                            <input className={`${inputClass} mt-1`} aria-label={`Publication workspace ID for ${task.name}`}
+                                value={publication.workspace_scope === 'group' ? publication.group_id ?? '' : publication.public_workspace_id ?? ''}
+                                onChange={(event) => update({
+                                    ...publication,
+                                    ...(publication.workspace_scope === 'group' ? { group_id: event.target.value } : { public_workspace_id: event.target.value }),
+                                })} />
+                        </label>
+                    ) : null}
+                    <p className="text-xs text-text-3 sm:col-span-2">
+                        Bind exactly one earlier native Analyze output below. The destination is explicit, not your active workspace.
+                        Group/public approval and processing remain separate; queued does not mean indexed and ready.
+                    </p>
+                </fieldset>
+            ) : null}
+        </div>
+    );
+}
+
 export function WorkflowEditorDialog({
     scope,
     workflow,
@@ -1070,8 +1182,10 @@ export function WorkflowEditorDialog({
     const [saving, setSaving] = useState(false);
     const [error, setError] = useState('');
     const [confirmClose, setConfirmClose] = useState(false);
+    const [confirmStructured, setConfirmStructured] = useState(false);
     const [schemaFieldErrors, setSchemaFieldErrors] = useState<Record<string, string>>({});
-    const unsupported = draft.definition_version > 2;
+    const unsupportedFlow = flowUnsupportedReason(draft);
+    const unsupported = !(options.supported_definition_versions ?? [1, 2]).includes(draft.definition_version) || Boolean(unsupportedFlow);
     const readOnly = unsupported || !options.can_manage;
     const dirty = !sameWorkflowDefinition(baseline, draft) ||
         draft.tasks.some((task) => Boolean(schemaFieldErrors[task.id]));
@@ -1132,7 +1246,7 @@ export function WorkflowEditorDialog({
         setError('');
         try {
             const response = await saveWorkflowDefinition(scope, draft, original);
-            const saved = response.workflow ? workflowForSave(response.workflow, null, scope) : workflowForSave(draft, original, scope);
+            const saved = response.workflow ? normalizeWorkflowDefinition(response.workflow, scope) : workflowForSave(draft, original, scope);
             setBaseline(saved);
             setDraft(saved);
             onSaved(saved);
@@ -1215,6 +1329,7 @@ export function WorkflowEditorDialog({
                             <p>
                                 This workflow uses definition version {draft.definition_version}. V2 can read
                                 it but cannot safely save it without downgrading fields from a newer editor.
+                                {unsupportedFlow ? ` ${unsupportedFlow}` : ''}
                             </p>
                         </div>
                     ) : null}
@@ -1393,8 +1508,11 @@ export function WorkflowEditorDialog({
                                 <Toggle
                                     label="Durable execution"
                                     checked={draft.durable_execution === true}
+                                    disabled={draft.definition_version === 3}
                                     onChange={(checked) => setWorkflow((current) => ({ ...current, durable_execution: checked }))}
-                                    description="Save checkpoints so queued and interrupted runs can resume instead of depending on this browser tab."
+                                    description={draft.definition_version === 3
+                                        ? 'Required for structured control flow. Saved decisions and exact execution checkpoints survive waits and restarts.'
+                                        : 'Save checkpoints so queued and interrupted runs can resume instead of depending on this browser tab.'}
                                 />
                                 <Toggle
                                     label="Chat capabilities enabled"
@@ -1418,11 +1536,17 @@ export function WorkflowEditorDialog({
                         <section className="space-y-3 rounded-2xl border border-edge p-4" aria-label="Workflow tasks">
                             <div className="flex flex-wrap items-center justify-between gap-2">
                                 <div>
-                                    <h3 className="text-base font-semibold text-text-1">Tasks</h3>
+                                    <h3 className="text-base font-semibold text-text-1">{draft.definition_version === 3 ? 'Structured List' : 'Tasks'}</h3>
                                     <p className="text-xs text-text-3">
                                         Task IDs stay stable while you edit, so explicit input bindings do not change meaning.
                                     </p>
                                 </div>
+                                {draft.definition_version !== 3 ? <div className="flex flex-wrap gap-2">
+                                {options.supported_definition_versions?.includes(3) && !unsupported ? (
+                                    <GlassButton type="button" size="sm" onClick={() => setConfirmStructured(true)}>
+                                        Enable structured control flow
+                                    </GlassButton>
+                                ) : null}
                                 <GlassButton
                                     type="button"
                                     size="sm"
@@ -1435,11 +1559,23 @@ export function WorkflowEditorDialog({
                                 >
                                     <Plus size={14} /> Add task
                                 </GlassButton>
+                                </div> : <Pill tone="accent">Definition v3</Pill>}
                             </div>
                             {draft.tasks.length >= options.max_tasks ? (
                                 <p role="status" className="text-xs text-warn">Maximum task count reached for this scope.</p>
                             ) : null}
-                            {draft.tasks.map((task, index) => (
+                            {draft.definition_version === 3 ? (
+                                <WorkflowStructuredList workflow={draft} options={options} onChange={(next) => setWorkflow(next)}
+                                    renderTask={(task, node, onNodeChange) => (
+                                        <TaskCard key={task.id} scope={scope} task={task}
+                                            index={draft.tasks.findIndex((item) => item.id === task.id)}
+                                            workflow={draft} options={options}
+                                            onChange={(nextTask) => updateTask(task.id, () => nextTask)}
+                                            onSchemaError={onSchemaError} durableExecution={draft.durable_execution === true}
+                                            onNeedsDurable={() => setWorkflow((current) => ({ ...current, durable_execution: true }))}
+                                            structuredNode={node} onStructuredNodeChange={onNodeChange} />
+                                    )} />
+                            ) : draft.tasks.map((task, index) => (
                                 <TaskCard
                                     key={task.id}
                                     scope={scope}
@@ -1459,6 +1595,21 @@ export function WorkflowEditorDialog({
                     </fieldset>
                 </div>
             </Modal>
+            {confirmStructured ? (
+                <ConfirmDialog title="Enable structured control flow?"
+                    description="This explicitly converts the draft to definition version 3 and requires durable execution. Existing task inputs are made explicit. Classic can still run or cancel it, but advanced editing requires V2. Nothing changes until Save workflow."
+                    confirmLabel="Convert draft" cancelLabel="Keep ordered tasks"
+                    onClose={() => setConfirmStructured(false)}
+                    onConfirm={() => {
+                        try {
+                            setWorkflow(convertToStructuredWorkflow(draft, `root-${createWorkflowTask(0).id}`));
+                            setConfirmStructured(false);
+                        } catch (cause: unknown) {
+                            setConfirmStructured(false);
+                            setError(workflowErrorMessage(cause, 'This workflow cannot be converted safely. Choose explicit inputs first.'));
+                        }
+                    }} />
+            ) : null}
             {confirmClose ? (
                 <ConfirmDialog
                     title="Discard unsaved workflow changes?"
diff --git a/application/v2_ui/src/components/workflows/WorkflowExecutionHistory.tsx b/application/v2_ui/src/components/workflows/WorkflowExecutionHistory.tsx
new file mode 100644
index 000000000..b124e9cb3
--- /dev/null
+++ b/application/v2_ui/src/components/workflows/WorkflowExecutionHistory.tsx
@@ -0,0 +1,642 @@
+// WorkflowExecutionHistory.tsx
+// Structured V3 workflow execution, attempt, decision, and output inspection.
+
+import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react';
+import { ChevronDown, ChevronLeft, ChevronRight, FileJson, Loader2, RefreshCw } from 'lucide-react';
+import { ApiError } from '../../lib/apiClient';
+import {
+    fetchWorkflowExecutionAttemptResult,
+    fetchWorkflowExecutionAttemptsPage,
+    fetchWorkflowExecutionsPage,
+    fetchWorkflowRuntimeDecisionsPage,
+    type WorkflowExecutionAttemptRecord,
+    type WorkflowExecutionDecisionPreview,
+    type WorkflowExecutionPage,
+    type WorkflowExecutionRecord,
+    type WorkflowRuntimeDecisionRecord,
+} from '../../lib/workflowExecutionHistory';
+import {
+    workflowErrorMessage,
+    type WorkflowConsumedInput,
+    type WorkflowIterationFrame,
+    type WorkflowResultReference,
+    type WorkflowRunResultPage,
+    type WorkflowScope,
+    type WorkflowValidationResult,
+} from '../../lib/workflowEditor';
+import { GlassButton, GlassPanel } from '../ui/primitives';
+import { Pill, RowAction } from '../workspace/primitives';
+
+interface PagedState<T> {
+    items: T[];
+    nextCursor: string | null;
+    totalCount?: number;
+    loading: boolean;
+    error: string;
+    cursor: string | null;
+    previousCursors: (string | null)[];
+}
+
+function statusTone(status: unknown): 'ok' | 'warn' | 'danger' | 'neutral' | 'accent' {
+    const value = String(status ?? '').toLowerCase();
+    if (['completed', 'succeeded', 'success', 'finished', 'valid'].includes(value)) {
+        return 'ok';
+    }
+    if (['running', 'queued', 'pending', 'in_progress', 'started', 'waiting_approval', 'waiting_output', 'waiting_recovery', 'paused', 'skipped'].includes(value)) {
+        return 'warn';
+    }
+    if (['failed', 'error', 'cancelled', 'canceled', 'incomplete', 'invalid'].includes(value)) {
+        return 'danger';
+    }
+    return 'neutral';
+}
+
+const VALIDATION_STATUSES = new Set(['valid', 'invalid', 'incomplete', 'accepted_partial', 'not_requested']);
+
+function text(value: unknown): string {
+    return typeof value === 'string' ? value : '';
+}
+
+function formatTimestamp(value: unknown): string {
+    const raw = String(value ?? '');
+    if (!raw) {
+        return '';
+    }
+    const parsed = new Date(raw);
+    return Number.isNaN(parsed.valueOf()) ? raw : parsed.toLocaleString();
+}
+
+function validationSummary(value: WorkflowValidationResult | undefined): string {
+    if (!value || value.version !== 1 || !VALIDATION_STATUSES.has(String(value.status))) {
+        return '';
+    }
+    const reasonCodes = Array.isArray(value.reason_codes)
+        ? value.reason_codes.filter((code): code is string => typeof code === 'string')
+        : [];
+    const counts = value.counts && typeof value.counts === 'object'
+        ? Object.entries(value.counts).map(([key, count]) => `${key}: ${count}`).join(', ')
+        : '';
+    return [String(value.status), ...reasonCodes, counts].filter(Boolean).join(' · ');
+}
+
+function validationTone(value: WorkflowValidationResult | undefined): 'ok' | 'warn' | 'danger' | 'neutral' {
+    if (value?.status === 'valid') {
+        return 'ok';
+    }
+    if (value?.status === 'invalid' || value?.status === 'incomplete') {
+        return 'danger';
+    }
+    if (value?.status === 'accepted_partial') {
+        return 'warn';
+    }
+    return 'neutral';
+}
+
+function formatIterationPath(path: WorkflowIterationFrame[] | undefined): string {
+    if (!Array.isArray(path) || !path.length) {
+        return '';
+    }
+    return path.map((frame, index) => {
+        const loop = text(frame.loop_id) || `region ${index + 1}`;
+        const labels = [
+            text(frame.item_id) ? `item ${text(frame.item_id)}` : '',
+            Number.isFinite(Number(frame.index)) ? `index ${Number(frame.index)}` : '',
+            Number.isFinite(Number(frame.iteration)) ? `iteration ${Number(frame.iteration)}` : '',
+        ].filter(Boolean);
+        return labels.length ? `${loop} (${labels.join(', ')})` : loop;
+    }).join(' / ');
+}
+
+function resultReferenceSummary(reference: WorkflowResultReference | undefined): string {
+    if (!reference) {
+        return '';
+    }
+    const parts = [
+        text(reference.storage),
+        Number.isFinite(Number(reference.size_bytes)) ? `${Number(reference.size_bytes)} bytes` : '',
+        Number.isFinite(Number(reference.chunk_count)) ? `${Number(reference.chunk_count)} chunks` : '',
+        text(reference.sha256) ? `sha256 ${text(reference.sha256)}` : '',
+    ].filter(Boolean);
+    return parts.join(' · ');
+}
+
+function consumedInputSummary(input: WorkflowConsumedInput, index: number): string {
+    const producer = input.producer;
+    const path = formatIterationPath(producer?.iteration_path);
+    const refs = [
+        text(producer?.workflow_id) ? `workflow ${text(producer?.workflow_id)}` : '',
+        text(producer?.run_id) ? `run ${text(producer?.run_id)}` : '',
+        text(producer?.node_id) ? `node ${text(producer?.node_id)}` : '',
+        text(producer?.execution_id) ? `execution ${text(producer?.execution_id)}` : '',
+        text(producer?.task_id) ? `task ${text(producer?.task_id)}` : '',
+        Number.isFinite(Number(producer?.attempt)) ? `attempt ${Number(producer?.attempt)}` : '',
+        path ? `path ${path}` : '',
+    ].filter(Boolean);
+    const inputName = text(input.input_name) || `input ${index + 1}`;
+    const outputName = text(input.output_name) || 'authoritative';
+    return `${inputName} from ${outputName}${refs.length ? ` · ${refs.join(' · ')}` : ''}`;
+}
+
+function decisionSummary(decision: WorkflowExecutionDecisionPreview | WorkflowRuntimeDecisionRecord | undefined): string {
+    if (!decision || typeof decision !== 'object' || Array.isArray(decision)) {
+        return '';
+    }
+    const parts = [
+        text(decision.choice) ? `choice ${text(decision.choice)}` : '',
+        text(decision.selected_branch) ? `branch ${text(decision.selected_branch)}` : '',
+        text(decision.branch_id) ? `branch ${text(decision.branch_id)}` : '',
+        text(decision.target_node_id) ? `target ${text(decision.target_node_id)}` : '',
+        text(decision.route_target) ? `target ${text(decision.route_target)}` : '',
+        text(decision.target?.node_id) ? `target ${text(decision.target?.node_id)}` : '',
+        text(decision.target?.exit_region_id) ? `exit ${text(decision.target?.exit_region_id)}` : '',
+        text(decision.exit_region_id) ? `exit ${text(decision.exit_region_id)}` : '',
+        text(decision.reason_code) ? `reason ${text(decision.reason_code)}` : '',
+    ].filter(Boolean);
+    return parts.join(' · ');
+}
+
+function historyErrorMessage(cause: unknown, fallback: string): string {
+    if (cause instanceof ApiError && cause.status === 403) {
+        return 'You no longer have access to this workflow run. Reload or ask an owner to restore access.';
+    }
+    if (cause instanceof ApiError && cause.status === 404) {
+        return 'This workflow run history is no longer available.';
+    }
+    return workflowErrorMessage(cause, fallback);
+}
+
+function usePagedResource<T>(
+    loadPage: (cursor: string | null, signal: AbortSignal) => Promise<WorkflowExecutionPage<T>>,
+    fallbackError: string,
+) {
+    const [state, setState] = useState<PagedState<T>>({
+        items: [],
+        nextCursor: null,
+        loading: true,
+        error: '',
+        cursor: null,
+        previousCursors: [],
+    });
+    const abortRef = useRef<AbortController | null>(null);
+    const tokenRef = useRef(0);
+
+    const load = useCallback((cursor: string | null, previousCursors: (string | null)[]) => {
+        abortRef.current?.abort();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        tokenRef.current += 1;
+        const token = tokenRef.current;
+        setState({
+            items: [],
+            nextCursor: null,
+            loading: true,
+            error: '',
+            cursor,
+            previousCursors,
+        });
+        void loadPage(cursor, controller.signal)
+            .then((page) => {
+                if (controller.signal.aborted || token !== tokenRef.current) {
+                    return;
+                }
+                setState({
+                    items: page.items,
+                    nextCursor: page.next_cursor,
+                    totalCount: page.total_count,
+                    loading: false,
+                    error: '',
+                    cursor,
+                    previousCursors,
+                });
+            })
+            .catch((cause: unknown) => {
+                if (controller.signal.aborted || token !== tokenRef.current) {
+                    return;
+                }
+                setState((current) => ({
+                    ...current,
+                    items: [],
+                    nextCursor: null,
+                    loading: false,
+                    error: historyErrorMessage(cause, fallbackError),
+                }));
+            });
+    }, [fallbackError, loadPage]);
+
+    useEffect(() => {
+        load(null, []);
+        return () => abortRef.current?.abort();
+    }, [load]);
+
+    const refresh = useCallback(() => {
+        load(null, []);
+    }, [load]);
+
+    const next = useCallback(() => {
+        if (state.nextCursor) {
+            load(state.nextCursor, [...state.previousCursors, state.cursor]);
+        }
+    }, [load, state.cursor, state.nextCursor, state.previousCursors]);
+
+    const previous = useCallback(() => {
+        if (!state.previousCursors.length) {
+            return;
+        }
+        const nextPrevious = state.previousCursors.slice(0, -1);
+        load(state.previousCursors[state.previousCursors.length - 1] ?? null, nextPrevious);
+    }, [load, state.previousCursors]);
+
+    return { ...state, refresh, next, previous };
+}
+
+function PageControls({
+    loading,
+    onRefresh,
+    onPrevious,
+    onNext,
+    hasPrevious,
+    hasNext,
+    nextLabel,
+    totalCount,
+}: {
+    loading: boolean;
+    onRefresh: () => void;
+    onPrevious: () => void;
+    onNext: () => void;
+    hasPrevious: boolean;
+    hasNext: boolean;
+    nextLabel: string;
+    totalCount?: number;
+}) {
+    return (
+        <div className="flex flex-wrap items-center gap-2">
+            <GlassButton size="sm" disabled={loading} onClick={onRefresh}>
+                {loading ? <Loader2 size={14} className="animate-spin" /> : <RefreshCw size={14} />}
+                Refresh
+            </GlassButton>
+            <GlassButton size="sm" disabled={loading || !hasPrevious} onClick={onPrevious}>
+                <ChevronLeft size={14} />
+                Previous page
+            </GlassButton>
+            <GlassButton size="sm" disabled={loading || !hasNext} onClick={onNext}>
+                Next {nextLabel} page
+                <ChevronRight size={14} />
+            </GlassButton>
+            {totalCount !== undefined ? (
+                <span className="text-xs text-text-3">{totalCount} total</span>
+            ) : null}
+        </div>
+    );
+}
+
+function DetailLine({ label, children }: { label: string; children: ReactNode }) {
+    return (
+        <p className="min-w-0 break-words text-xs text-text-3">
+            <span className="font-medium text-text-2">{label}:</span> {children}
+        </p>
+    );
+}
+
+function ConsumedInputs({ inputs }: { inputs?: WorkflowConsumedInput[] }) {
+    if (!inputs?.length) {
+        return null;
+    }
+    return (
+        <div className="space-y-1">
+            <p className="text-xs font-medium text-text-2">Consumed producer refs</p>
+            <ul className="space-y-1" aria-label="Consumed producer references">
+                {inputs.map((input, index) => (
+                    <li key={`${text(input.input_name)}:${index}`} className="min-w-0 break-words rounded-lg bg-surface-sunken p-2 text-xs text-text-3">
+                        {consumedInputSummary(input, index)}
+                        {input.result_ref ? <DetailLine label="Consumed manifest ref">{resultReferenceSummary(input.result_ref)}</DetailLine> : null}
+                        {input.output_ref ? <DetailLine label="Consumed output ref">
+                            {typeof input.output_ref === 'string' ? input.output_ref : resultReferenceSummary(input.output_ref)}
+                        </DetailLine> : null}
+                    </li>
+                ))}
+            </ul>
+        </div>
+    );
+}
+
+function V3ResultExcerpt({
+    scope,
+    workflowId,
+    runId,
+    executionId,
+    attempt,
+}: {
+    scope: WorkflowScope;
+    workflowId: string;
+    runId: string;
+    executionId: string;
+    attempt: number;
+}) {
+    const [page, setPage] = useState<WorkflowRunResultPage | null>(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState('');
+    const [requested, setRequested] = useState(false);
+    const abortRef = useRef<AbortController | null>(null);
+    const tokenRef = useRef(0);
+
+    const load = (nextOffset = 0) => {
+        abortRef.current?.abort();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        tokenRef.current += 1;
+        const token = tokenRef.current;
+        setLoading(true);
+        setPage(null);
+        setError('');
+        setRequested(true);
+        void fetchWorkflowExecutionAttemptResult(
+            scope,
+            workflowId,
+            runId,
+            executionId,
+            attempt,
+            nextOffset,
+            2000,
+            controller.signal,
+        )
+            .then((result) => {
+                if (controller.signal.aborted || token !== tokenRef.current) {
+                    return;
+                }
+                setPage(result);
+            })
+            .catch((cause: unknown) => {
+                if (controller.signal.aborted || token !== tokenRef.current) {
+                    return;
+                }
+                setError(historyErrorMessage(cause, 'Could not load the execution result excerpt.'));
+                setPage(null);
+            })
+            .finally(() => {
+                if (controller.signal.aborted || token !== tokenRef.current) {
+                    return;
+                }
+                setLoading(false);
+            });
+    };
+
+    useEffect(() => () => abortRef.current?.abort(), []);
+
+    return (
+        <div className="space-y-2 rounded-xl border border-edge p-3">
+            <div className="flex flex-wrap items-center gap-2">
+                <GlassButton size="sm" disabled={loading} onClick={() => load()}>
+                    {loading ? <Loader2 size={14} className="animate-spin" /> : <FileJson size={14} />}
+                    {requested ? 'Reload authoritative output excerpt' : 'Load authoritative output excerpt'}
+                </GlassButton>
+                {page?.next_offset !== null && page?.next_offset !== undefined ? (
+                    <GlassButton size="sm" disabled={loading} onClick={() => load(Number(page.next_offset))}>
+                        Next output excerpt page
+                    </GlassButton>
+                ) : null}
+            </div>
+            <p className="text-xs text-text-3">
+                V3 output inspection always reads the exact execution attempt's authoritative output.
+            </p>
+            {error ? <p role="alert" className="text-xs text-danger">{error}</p> : null}
+            {page ? (
+                <pre className="max-h-72 overflow-auto whitespace-pre-wrap break-words rounded-xl bg-surface-sunken p-3 text-xs text-text-2">
+                    {page.content}
+                </pre>
+            ) : null}
+            {page ? (
+                <p className="break-words text-[11px] text-text-3">
+                    Offset {page.offset ?? 0}
+                    {page.total_bytes !== undefined ? ` of ${page.total_bytes} bytes` : ''}
+                    {page.sha256 ? ` · sha256 ${page.sha256}` : ''}
+                </p>
+            ) : null}
+        </div>
+    );
+}
+
+function AttemptHistory({
+    scope,
+    workflowId,
+    runId,
+    execution,
+}: {
+    scope: WorkflowScope;
+    workflowId: string;
+    runId: string;
+    execution: WorkflowExecutionRecord;
+}) {
+    const loadPage = useCallback((cursor: string | null, signal: AbortSignal) =>
+        fetchWorkflowExecutionAttemptsPage(scope, workflowId, runId, execution.execution_id, cursor, 50, signal),
+    [execution.execution_id, runId, scope, workflowId]);
+    const page = usePagedResource<WorkflowExecutionAttemptRecord>(loadPage, 'Could not load execution attempts.');
+
+    return (
+        <div className="space-y-3">
+            <PageControls
+                loading={page.loading}
+                onRefresh={page.refresh}
+                onPrevious={page.previous}
+                onNext={page.next}
+                hasPrevious={page.previousCursors.length > 0}
+                hasNext={Boolean(page.nextCursor)}
+                nextLabel="attempt"
+                totalCount={page.totalCount}
+            />
+            {page.loading ? <p role="status" className="text-xs text-text-3">Loading execution attempts...</p> : null}
+            {page.error ? <p role="alert" className="rounded-xl bg-danger-soft p-3 text-xs text-danger">{page.error}</p> : null}
+            {!page.loading && !page.error && !page.items.length ? <p className="text-xs text-text-3">No attempts were recorded for this execution.</p> : null}
+            <ul className="space-y-2" aria-label={`Attempts for execution ${execution.execution_id}`}>
+                {page.items.map((attempt) => {
+                    const validation = validationSummary(attempt.workflow_validation);
+                    const resultSummary = resultReferenceSummary(attempt.workflow_result?.result_ref);
+                    const inputs = attempt.consumed_inputs ?? attempt.workflow_result?.consumed_inputs;
+                    return (
+                        <li key={`${attempt.execution_id}:${attempt.attempt}`} className="space-y-2 rounded-xl border border-edge p-3">
+                            <div className="flex flex-wrap items-center gap-2">
+                                <Pill tone={statusTone(attempt.state)}>{attempt.state || 'unknown'}</Pill>
+                                <span className="text-sm font-medium text-text-1">Attempt {attempt.attempt}</span>
+                                {attempt.started_at ? <span className="text-xs text-text-3">{formatTimestamp(attempt.started_at)}</span> : null}
+                                {attempt.completed_at ? <span className="text-xs text-text-3">→ {formatTimestamp(attempt.completed_at)}</span> : null}
+                            </div>
+                            {validation ? <DetailLine label="Validation"><Pill tone={validationTone(attempt.workflow_validation)}>{validation}</Pill></DetailLine> : null}
+                            {resultSummary ? <DetailLine label="Result ref">{resultSummary}</DetailLine> : null}
+                            <ConsumedInputs inputs={inputs} />
+                            {attempt.workflow_result?.result_ref ? <V3ResultExcerpt
+                                key={`${workflowId}:${runId}:${attempt.execution_id}:${attempt.attempt}`}
+                                scope={scope}
+                                workflowId={workflowId}
+                                runId={runId}
+                                executionId={attempt.execution_id}
+                                attempt={attempt.attempt}
+                            /> : <p className="text-xs text-text-3">No result was committed for this attempt.</p>}
+                        </li>
+                    );
+                })}
+            </ul>
+        </div>
+    );
+}
+
+function DecisionHistory({
+    scope,
+    workflowId,
+    runId,
+}: {
+    scope: WorkflowScope;
+    workflowId: string;
+    runId: string;
+}) {
+    const loadPage = useCallback((cursor: string | null, signal: AbortSignal) =>
+        fetchWorkflowRuntimeDecisionsPage(scope, workflowId, runId, cursor, 50, signal),
+    [runId, scope, workflowId]);
+    const page = usePagedResource<WorkflowRuntimeDecisionRecord>(loadPage, 'Could not load runtime decisions.');
+
+    return (
+        <details className="rounded-xl border border-edge p-3" open>
+            <summary className="cursor-pointer text-sm font-medium text-text-1">Runtime decision history</summary>
+            <div className="mt-3 space-y-3">
+                <PageControls
+                    loading={page.loading}
+                    onRefresh={page.refresh}
+                    onPrevious={page.previous}
+                    onNext={page.next}
+                    hasPrevious={page.previousCursors.length > 0}
+                    hasNext={Boolean(page.nextCursor)}
+                    nextLabel="decision"
+                    totalCount={page.totalCount}
+                />
+                {page.error ? <p role="alert" className="rounded-xl bg-danger-soft p-3 text-xs text-danger">{page.error}</p> : null}
+                {page.loading && !page.items.length ? <p role="status" className="text-xs text-text-3">Loading runtime decisions…</p> : null}
+                {!page.loading && !page.error && !page.items.length ? (
+                    <p className="text-xs text-text-3">No runtime decisions were recorded for this run.</p>
+                ) : null}
+                {page.items.length ? (
+                    <ul className="space-y-2" aria-label="Runtime decisions">
+                        {page.items.map((decision, index) => {
+                            const summary = decisionSummary(decision) || 'unsupported safe decision schema';
+                            const timestamp = formatTimestamp(decision.timestamp ?? decision.decided_at);
+                            return (
+                                <li key={`${text(decision.execution_id)}:${text(decision.gate_id)}:${index}`} className="space-y-1 rounded-lg bg-surface-sunken p-2 text-xs text-text-3">
+                                    <div className="flex flex-wrap items-center gap-2">
+                                        <Pill tone="accent">{text(decision.choice) || 'decision'}</Pill>
+                                        {timestamp ? <span>{timestamp}</span> : null}
+                                    </div>
+                                    <DetailLine label="Decision">{summary}</DetailLine>
+                                    {text(decision.gate_id) ? <DetailLine label="Gate">{text(decision.gate_id)}</DetailLine> : null}
+                                    {text(decision.execution_id) || text(decision.node_id) || Number.isFinite(Number(decision.attempt)) ? (
+                                        <DetailLine label="Applies to">
+                                            {[
+                                                text(decision.execution_id) ? `execution ${text(decision.execution_id)}` : '',
+                                                text(decision.node_id) ? `node ${text(decision.node_id)}` : '',
+                                                Number.isFinite(Number(decision.attempt)) ? `attempt ${Number(decision.attempt)}` : '',
+                                            ].filter(Boolean).join(' · ')}
+                                        </DetailLine>
+                                    ) : null}
+                                    {text(decision.input_digest) ? <DetailLine label="Input digest">{text(decision.input_digest)}</DetailLine> : null}
+                                </li>
+                            );
+                        })}
+                    </ul>
+                ) : null}
+            </div>
+        </details>
+    );
+}
+
+export function WorkflowExecutionHistory({
+    scope,
+    workflowId,
+    runId,
+}: {
+    scope: WorkflowScope;
+    workflowId: string;
+    runId: string;
+}) {
+    const [expandedExecutionId, setExpandedExecutionId] = useState<string | null>(null);
+    const loadPage = useCallback((cursor: string | null, signal: AbortSignal) =>
+        fetchWorkflowExecutionsPage(scope, workflowId, runId, cursor, 50, signal),
+    [runId, scope, workflowId]);
+    const page = usePagedResource<WorkflowExecutionRecord>(loadPage, 'Could not load workflow executions.');
+
+    return (
+        <div className="space-y-3 px-3 pb-3">
+            <GlassPanel elevation="flat" className="space-y-3 p-3">
+                <div className="flex flex-wrap items-center gap-2">
+                    <Pill tone="accent">definition v3</Pill>
+                    <span className="text-sm font-medium text-text-1">Workflow execution history</span>
+                </div>
+                <p className="text-xs text-text-3">
+                    Structured runs use node, execution, and attempt identities. Output excerpts are loaded per attempt so large results are not rendered automatically.
+                </p>
+                <PageControls
+                    loading={page.loading}
+                    onRefresh={page.refresh}
+                    onPrevious={page.previous}
+                    onNext={page.next}
+                    hasPrevious={page.previousCursors.length > 0}
+                    hasNext={Boolean(page.nextCursor)}
+                    nextLabel="executions"
+                    totalCount={page.totalCount}
+                />
+                {page.loading ? <p role="status" className="text-xs text-text-3">Loading execution history...</p> : null}
+                {page.error ? <p role="alert" className="rounded-xl bg-danger-soft p-3 text-xs text-danger">{page.error}</p> : null}
+                {!page.loading && !page.error && !page.items.length ? (
+                    <p className="text-xs text-text-3">No node executions were recorded for this run.</p>
+                ) : null}
+                {page.items.length ? (
+                    <ul className="space-y-2" aria-label="Workflow node executions">
+                        {page.items.map((execution) => {
+                            const executionId = execution.execution_id;
+                            const expanded = expandedExecutionId === executionId;
+                            const validation = validationSummary(execution.workflow_validation);
+                            const resultSummary = resultReferenceSummary(execution.workflow_result?.result_ref);
+                            const inputs = execution.consumed_inputs ?? execution.workflow_result?.consumed_inputs;
+                            const iterationPath = formatIterationPath(execution.iteration_path);
+                            const decision = decisionSummary(execution.decision);
+                            return (
+                                <li key={executionId}>
+                                    <GlassPanel elevation="flat" className="space-y-3 p-3">
+                                        <div className="flex flex-wrap items-center gap-2">
+                                            <RowAction
+                                                icon={expanded ? <ChevronDown size={15} /> : <ChevronRight size={15} />}
+                                                label={expanded ? `Hide execution attempts for ${executionId}` : `Show execution attempts for ${executionId}`}
+                                                onClick={() => setExpandedExecutionId(expanded ? null : executionId)}
+                                            />
+                                            <Pill tone={statusTone(execution.state)}>{execution.state || 'unknown'}</Pill>
+                                            <span className="min-w-0 break-words text-sm font-medium text-text-1">
+                                                {text(execution.node_id) || 'Unsupported node'} · {text(execution.node_kind) || 'unsupported kind'}
+                                            </span>
+                                        </div>
+                                        <div className="grid gap-1 sm:grid-cols-2">
+                                            <DetailLine label="Execution">{executionId}</DetailLine>
+                                            <DetailLine label="Attempt">{Number.isFinite(Number(execution.attempt)) ? Number(execution.attempt) : 'unknown'}</DetailLine>
+                                            {text(execution.task_id) ? <DetailLine label="Task">{text(execution.task_id)}</DetailLine> : null}
+                                            {Number.isFinite(Number(execution.sequence)) ? <DetailLine label="Sequence">{Number(execution.sequence)}</DetailLine> : null}
+                                            {text(execution.region_id) ? <DetailLine label="Region">{text(execution.region_id)}</DetailLine> : null}
+                                            {iterationPath ? <DetailLine label="Iteration path">{iterationPath}</DetailLine> : null}
+                                            {text(execution.reason_code) ? <DetailLine label="Reason code">{text(execution.reason_code)}</DetailLine> : null}
+                                            {decision ? <DetailLine label="Selected branch or route">{decision}</DetailLine> : null}
+                                            {validation ? <DetailLine label="Validation"><Pill tone={validationTone(execution.workflow_validation)}>{validation}</Pill></DetailLine> : null}
+                                            {resultSummary ? <DetailLine label="Result ref">{resultSummary}</DetailLine> : null}
+                                        </div>
+                                        <ConsumedInputs inputs={inputs} />
+                                        {expanded ? (
+                                            <AttemptHistory
+                                                scope={scope}
+                                                workflowId={workflowId}
+                                                runId={runId}
+                                                execution={execution}
+                                            />
+                                        ) : null}
+                                    </GlassPanel>
+                                </li>
+                            );
+                        })}
+                    </ul>
+                ) : null}
+            </GlassPanel>
+            <DecisionHistory scope={scope} workflowId={workflowId} runId={runId} />
+        </div>
+    );
+}
diff --git a/application/v2_ui/src/components/workflows/WorkflowRunHistory.tsx b/application/v2_ui/src/components/workflows/WorkflowRunHistory.tsx
index 16def411d..1b728edf3 100644
--- a/application/v2_ui/src/components/workflows/WorkflowRunHistory.tsx
+++ b/application/v2_ui/src/components/workflows/WorkflowRunHistory.tsx
@@ -3,6 +3,7 @@
 
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { ChevronDown, ChevronRight, FileJson, Loader2 } from 'lucide-react';
+import { WorkflowExecutionHistory } from './WorkflowExecutionHistory';
 import { WorkflowRuntimePanel } from './WorkflowRuntimePanel';
 import { GlassButton, GlassPanel } from '../ui/primitives';
 import { Pill, RowAction } from '../workspace/primitives';
@@ -11,6 +12,7 @@ import {
     fetchScopedWorkflowRunItems,
     fetchScopedWorkflowRuns,
     fetchWorkflowTaskResult,
+    workflowScopeKey,
     type WorkflowInputOutput,
     type WorkflowRunItem,
     type WorkflowRunResultPage,
@@ -324,7 +326,7 @@ export function WorkflowRunHistory({
         return () => window.clearTimeout(timer);
     }, [refresh, shown]);
 
-    if (loading) {
+    if (loading && !shown.length) {
         return <p role="status" className="px-3 pb-3 text-xs text-text-3">Loading runs…</p>;
     }
     if (error) {
@@ -341,6 +343,9 @@ export function WorkflowRunHistory({
                 const expanded = expandedRunId === runId;
                 const status = String(run.status ?? 'unknown');
                 const validation = validationSummary(run.workflow_validation);
+                const definitionVersion = run.definition_version;
+                const isStructuredRun = definitionVersion === 3;
+                const unsupportedDefinitionVersion = definitionVersion !== undefined && ![1, 2, 3].includes(definitionVersion);
                 return (
                     <li key={runId} className="rounded-xl border border-edge">
                         <div className="flex items-center gap-2 p-2 text-xs text-text-3">
@@ -360,19 +365,30 @@ export function WorkflowRunHistory({
                             <Pill tone={validationTone(run.workflow_validation)}>{validation}</Pill>
                         </p> : null}
                         {expanded ? (
-                            <>
-                                <WorkflowRuntimePanel
-                                    scope={scope}
-                                    workflowId={workflowId}
-                                    runId={runId}
-                                    durable={run.durable_execution === true}
-                                    onRuntimeChanged={() => {
-                                        void refresh();
-                                        onWorkflowRefresh?.();
-                                    }}
-                                />
-                                <RunItems scope={scope} workflowId={workflowId} runId={runId} />
-                            </>
+                            unsupportedDefinitionVersion ? (
+                                <p role="alert" className="px-3 pb-3 text-xs text-warn">
+                                    This run uses workflow definition v{String(definitionVersion)}, which this inspector does not support yet.
+                                </p>
+                            ) : (
+                                <>
+                                    <WorkflowRuntimePanel
+                                        scope={scope}
+                                        workflowId={workflowId}
+                                        runId={runId}
+                                        durable={run.durable_execution === true}
+                                        structuredRun={isStructuredRun}
+                                        onRuntimeChanged={() => {
+                                            void refresh();
+                                            onWorkflowRefresh?.();
+                                        }}
+                                    />
+                                    {isStructuredRun ? (
+                                        <WorkflowExecutionHistory key={`${workflowScopeKey(scope)}:${workflowId}:${runId}`} scope={scope} workflowId={workflowId} runId={runId} />
+                                    ) : (
+                                        <RunItems scope={scope} workflowId={workflowId} runId={runId} />
+                                    )}
+                                </>
+                            )
                         ) : null}
                     </li>
                 );
diff --git a/application/v2_ui/src/components/workflows/WorkflowRuntimePanel.tsx b/application/v2_ui/src/components/workflows/WorkflowRuntimePanel.tsx
index 586040e28..9f6e1b454 100644
--- a/application/v2_ui/src/components/workflows/WorkflowRuntimePanel.tsx
+++ b/application/v2_ui/src/components/workflows/WorkflowRuntimePanel.tsx
@@ -13,6 +13,7 @@ import {
     workflowScopeKey,
     WORKFLOW_RUNTIME_TERMINAL_STATES,
     type WorkflowRuntimeDecisionChoice,
+    type WorkflowRuntimeGate,
     type WorkflowRuntimeMemory,
     type WorkflowRuntimeProjection,
     type WorkflowScope,
@@ -70,10 +71,77 @@ function safeJson(value: unknown): string {
     return JSON.stringify(value, null, 2) ?? 'null';
 }
 
-function RuntimeMemoryDetails({ memory }: { memory?: WorkflowRuntimeMemory }) {
+function formatIterationPath(path: WorkflowRuntimeGate['iteration_path']): string {
+    if (!Array.isArray(path) || !path.length) {
+        return '';
+    }
+    return path.map((frame, index) => {
+        const loop = String(frame.loop_id || `region ${index + 1}`);
+        const labels = [
+            frame.item_id ? `item ${frame.item_id}` : '',
+            frame.index !== undefined ? `index ${frame.index}` : '',
+            frame.iteration !== undefined ? `iteration ${frame.iteration}` : '',
+        ].filter(Boolean);
+        return labels.length ? `${loop} (${labels.join(', ')})` : loop;
+    }).join(' / ');
+}
+
+function gateReference(gate: WorkflowRuntimeGate | undefined): string {
+    if (!gate) {
+        return '';
+    }
+    const path = formatIterationPath(gate.iteration_path);
+    const parts = [
+        gate.execution_id ? `Execution ${gate.execution_id}` : '',
+        gate.node_id ? `Node ${gate.node_id}` : '',
+        gate.attempt !== undefined ? `Attempt ${gate.attempt}` : '',
+        path ? `Path ${path}` : '',
+    ].filter(Boolean);
+    return parts.join(' · ');
+}
+
+function RuntimeMemoryDetails({
+    memory,
+    schemaVersion,
+    structuredRun = false,
+}: {
+    memory?: WorkflowRuntimeMemory;
+    schemaVersion?: number;
+    structuredRun?: boolean;
+}) {
+    if (schemaVersion !== undefined && ![1, 2].includes(schemaVersion)) {
+        return (
+            <p role="alert" className="rounded-xl bg-warn-soft p-3 text-xs text-warn">
+                This runtime memory schema is not supported by this inspector yet.
+            </p>
+        );
+    }
+    if (structuredRun) {
+        const counters = [
+            ['unit_count', 'Checkpoint units'],
+            ['completed_unit_count', 'Completed checkpoint units'],
+            ['execution_count', 'Execution admissions'],
+            ['decision_count', 'Saved decisions'],
+        ].flatMap(([key, label]) => {
+            const value = memory?.[key];
+            return typeof value === 'number' && Number.isFinite(value) ? [{ label, value }] : [];
+        });
+        return (
+            <details className="rounded-xl border border-edge p-3">
+                <summary className="cursor-pointer text-sm font-medium text-text-1">Runtime memory summary</summary>
+                <div className="mt-3 space-y-2 text-xs text-text-3">
+                    <p>Exact execution, attempt, and decision histories use the paged views below. Run memory is not approval authority.</p>
+                    {counters.map((item) => <p key={item.label}>{item.label}: {item.value}</p>)}
+                </div>
+            </details>
+        );
+    }
     const decisions = memory?.decisions ?? [];
     const units = memory?.units ?? [];
-    const otherKeys = Object.keys(memory ?? {}).filter((key) => !['decisions', 'units'].includes(key));
+    const includeOtherKeys = !structuredRun && (schemaVersion === undefined || schemaVersion === 1);
+    const otherKeys = includeOtherKeys
+        ? Object.keys(memory ?? {}).filter((key) => !['decisions', 'units'].includes(key))
+        : [];
 
     if (!memory || (!decisions.length && !units.length && !otherKeys.length)) {
         return <p className="text-xs text-text-3">No run memory has been recorded yet.</p>;
@@ -81,8 +149,15 @@ function RuntimeMemoryDetails({ memory }: { memory?: WorkflowRuntimeMemory }) {
 
     return (
         <details className="rounded-xl border border-edge p-3">
-            <summary className="cursor-pointer text-sm font-medium text-text-1">Run memory</summary>
+            <summary className="cursor-pointer text-sm font-medium text-text-1">
+                {structuredRun ? 'Runtime memory summary' : 'Run memory'}
+            </summary>
             <div className="mt-3 space-y-3">
+                {structuredRun ? (
+                    <p className="text-xs text-text-3">
+                        Detailed V3 execution, attempt, and decision histories load from the paged run-inspection APIs below.
+                    </p>
+                ) : null}
                 <div>
                     <p className="text-xs font-medium text-text-2">Checkpoint units and attempts</p>
                     {units.length ? (
@@ -136,12 +211,14 @@ export function WorkflowRuntimePanel({
     workflowId,
     runId,
     durable,
+    structuredRun = false,
     onRuntimeChanged,
 }: {
     scope: WorkflowScope;
     workflowId: string;
     runId: string;
     durable: boolean;
+    structuredRun?: boolean;
     onRuntimeChanged?: () => void;
 }) {
     const scopeKey = workflowScopeKey(scope);
@@ -152,6 +229,7 @@ export function WorkflowRuntimePanel({
     const [error, setError] = useState('');
     const [action, setAction] = useState<string | null>(null);
     const [confirmRetry, setConfirmRetry] = useState(false);
+    const [retryTarget, setRetryTarget] = useState<{ key: string; gate: WorkflowRuntimeGate } | null>(null);
     const [pollReadToken, setPollReadToken] = useState(0);
     const abortRef = useRef<AbortController | null>(null);
     const requestToken = useRef(0);
@@ -162,6 +240,9 @@ export function WorkflowRuntimePanel({
         setRuntime(null);
         setError('');
         setCanDecide(false);
+        setConfirmRetry(false);
+        setRetryTarget(null);
+        retryRequest.current = null;
     }, [durable, runId, scopeKey, workflowId]);
 
     const loadRuntime = useCallback(async (showSpinner = false) => {
@@ -229,6 +310,12 @@ export function WorkflowRuntimePanel({
         return requestId;
     };
 
+    const recoveryKey = (record: WorkflowRuntimeProjection) => JSON.stringify([
+        scopeKey, workflowId, runId, record.version, record.gate?.id,
+        record.gate?.execution_id, record.gate?.node_id, record.gate?.attempt,
+        record.gate?.input_digest,
+    ]);
+
     const applyRuntimeResponse = (nextRuntime: WorkflowRuntimeProjection, nextCanDecide: boolean) => {
         setRuntime(nextRuntime);
         setCanDecide(nextCanDecide);
@@ -240,16 +327,35 @@ export function WorkflowRuntimePanel({
         retryRequest.current = null;
         setRuntime(null);
         setCanDecide(false);
+        setConfirmRetry(false);
+        setRetryTarget(null);
         setError('You no longer have access to this workflow runtime. Reload or ask an owner to restore access.');
     };
 
     const decide = async (choice: WorkflowRuntimeDecisionChoice) => {
-        if (!runtime?.gate || action) {
+        if (action) return;
+        if (choice === 'retry' && (!runtime?.gate || !retryTarget || retryTarget.key !== recoveryKey(runtime) || runtime.gate.kind !== 'recovery' || !canDecide)) {
+            setConfirmRetry(false);
+            setRetryTarget(null);
+            setError('The recovery gate changed while you were reviewing it. Review the current execution and attempt before retrying.');
+            return;
+        }
+        if (!runtime?.gate) {
+            setError('The gate is no longer available. Reload this run before making another decision.');
             return;
         }
         abortRef.current?.abort();
         const gate = runtime.gate;
-        const requestKey = `decision:${runId}:${runtime.version}:${gate.id}:${choice}`;
+        const requestKey = [
+            'decision',
+            runId,
+            runtime.version,
+            gate.id,
+            gate.execution_id ?? '',
+            gate.node_id ?? '',
+            gate.attempt ?? '',
+            choice,
+        ].join(':');
         const requestId = requestIdFor(requestKey);
         setAction(choice);
         setError('');
@@ -277,6 +383,7 @@ export function WorkflowRuntimePanel({
         } finally {
             setAction(null);
             setConfirmRetry(false);
+            setRetryTarget(null);
         }
     };
 
@@ -332,6 +439,7 @@ export function WorkflowRuntimePanel({
     };
 
     const gate = runtime?.gate;
+    const unsupportedRuntimeSchema = Boolean(runtime && runtime.schema_version !== undefined && ![1, 2].includes(runtime.schema_version));
     const gateAllows = (choice: WorkflowRuntimeDecisionChoice) =>
         Boolean(gate?.choices.includes(choice));
     const progressLabel = useMemo(() => {
@@ -340,7 +448,7 @@ export function WorkflowRuntimePanel({
         }
         return `${runtime.progress.completed} of ${runtime.progress.total} units complete`;
     }, [runtime?.progress]);
-    const canMutate = canDecide && Boolean(runtime) && !loading;
+    const canMutate = canDecide && Boolean(runtime) && !loading && !unsupportedRuntimeSchema;
     const canResume = canMutate && runtime?.can_resume === true &&
         ['failed', 'incomplete', 'invalid'].includes(runtime.state);
     const canCancel = canMutate && runtime && !gateAllows('cancel') ? !runtimeIsTerminal(runtime) : false;
@@ -365,18 +473,30 @@ export function WorkflowRuntimePanel({
                     {loading ? <Loader2 size={14} className="animate-spin text-text-3" /> : null}
                 </div>
                 {progressLabel ? <p className="text-xs text-text-3">{progressLabel}</p> : null}
+                {structuredRun && runtime?.limits ? (
+                    <p className="text-xs text-text-3">
+                        {runtime.limits.admitted_count} of {runtime.limits.max_executions} execution admissions used.
+                        {' '}Deadline: {formatTimestamp(runtime.limits.deadline_at)} (including waits).
+                    </p>
+                ) : null}
                 {error ? <p role="alert" className="rounded-xl bg-danger-soft p-3 text-xs text-danger">{error}</p> : null}
                 {runtime && !canDecide ? (
                     <p className="rounded-xl bg-warn-soft p-3 text-xs text-warn">
                         You can view this runtime, but you do not have permission to approve, reject, retry, resume or cancel it.
                     </p>
                 ) : null}
-                {gate ? (
+                {unsupportedRuntimeSchema ? (
+                    <p role="alert" className="rounded-xl bg-warn-soft p-3 text-xs text-warn">
+                        This runtime schema is not supported by this inspector yet.
+                    </p>
+                ) : null}
+                {gate && !unsupportedRuntimeSchema ? (
                     <div className="space-y-2 rounded-xl border border-edge p-3">
                         <div className="flex flex-wrap items-center gap-2">
                             <Pill tone={gate.kind === 'output' ? 'warn' : 'accent'}>{gate.kind}</Pill>
                             <span className="text-sm font-medium text-text-1">Blocked on {gate.unit_id || 'runtime gate'}</span>
                         </div>
+                        {gateReference(gate) ? <p className="break-words text-xs text-text-3">{gateReference(gate)}</p> : null}
                         {gate.reason ? <p className="text-xs text-text-2">{gate.reason}</p> : null}
                         {gate.input_digest ? <p className="text-xs text-text-3">Input digest: {gate.input_digest}</p> : null}
                         {gate.kind === 'output' ? (
@@ -401,7 +521,12 @@ export function WorkflowRuntimePanel({
                         {canMutate && gate.kind === 'recovery' ? (
                             <div className="flex flex-wrap gap-2">
                                 {gateAllows('retry') ? (
-                                    <GlassButton size="sm" variant="primary" disabled={Boolean(action)} onClick={() => setConfirmRetry(true)}>
+                                    <GlassButton size="sm" variant="primary" disabled={Boolean(action)} onClick={() => {
+                                        if (runtime) {
+                                            setRetryTarget({ key: recoveryKey(runtime), gate: structuredClone(gate) });
+                                            setConfirmRetry(true);
+                                        }
+                                    }}>
                                         {action === 'retry' ? <Loader2 size={14} className="animate-spin" /> : <RotateCcw size={14} />}
                                         Retry task
                                     </GlassButton>
@@ -446,7 +571,11 @@ export function WorkflowRuntimePanel({
                         </GlassButton>
                     ) : null}
                 </div>
-                <RuntimeMemoryDetails memory={runtime?.memory} />
+                <RuntimeMemoryDetails
+                    memory={runtime?.memory}
+                    schemaVersion={runtime?.schema_version}
+                    structuredRun={structuredRun}
+                />
             </GlassPanel>
             {confirmRetry ? (
                 <ConfirmDialog
@@ -457,12 +586,18 @@ export function WorkflowRuntimePanel({
                     cancelLabel="Keep waiting"
                     busy={action === 'retry'}
                     tone="primary"
-                    onClose={() => setConfirmRetry(false)}
+                    onClose={() => {
+                        setConfirmRetry(false);
+                        setRetryTarget(null);
+                    }}
                     onConfirm={() => void decide('retry')}
                 >
                     <p className="text-xs text-text-2">
-                        The runtime will keep the same run id and record this decision against the current recovery gate.
+                        The runtime will keep the same run id and bind this decision to the recovery gate you opened.
                     </p>
+                    {retryTarget && gateReference(retryTarget.gate) ? (
+                        <p className="break-words text-xs text-text-2">{gateReference(retryTarget.gate)}</p>
+                    ) : null}
                 </ConfirmDialog>
             ) : null}
         </div>
diff --git a/application/v2_ui/src/components/workflows/WorkflowStructuredList.tsx b/application/v2_ui/src/components/workflows/WorkflowStructuredList.tsx
new file mode 100644
index 000000000..8dd306246
--- /dev/null
+++ b/application/v2_ui/src/components/workflows/WorkflowStructuredList.tsx
@@ -0,0 +1,295 @@
+// WorkflowStructuredList.tsx
+// List authoring over the canonical structured flow, without a second graph model.
+
+import { useState, type ReactNode } from 'react';
+import { ArrowDown, ArrowUp, GitBranch, Plus, Trash2 } from 'lucide-react';
+import { ConfirmDialog } from '../ui/ConfirmDialog';
+import { GlassButton } from '../ui/primitives';
+import { WorkflowConditionEditor, WorkflowFlowInputs } from './WorkflowConditionEditor';
+import {
+    analyzeWorkflowFlow,
+    DEFAULT_FLOW_LIMITS,
+    defaultFlowPredicate,
+    flowProducers,
+    flowRegions,
+    flowTaskIds,
+    FLOW_MAX_DEPTH,
+    FLOW_OUTPUT_KINDS,
+    isFlowRegion,
+    updateFlowRegion,
+    type FlowProducer,
+    type WorkflowFlowNode,
+    type WorkflowFlowRegion,
+    type WorkflowIfNode,
+    type WorkflowJoinSource,
+    type WorkflowTaskNode,
+} from '../../lib/workflowFlow';
+import { createWorkflowTask, type WorkflowDefinition, type WorkflowEditorOptions, type WorkflowOutputKind, type WorkflowTask } from '../../lib/workflowEditor';
+import { isRecord } from '../../lib/workspaceAuthoring';
+
+const inputClass = 'mt-1 w-full min-w-0 rounded-lg border border-edge bg-surface-1 px-3 py-2 text-sm text-text-1 focus:border-accent focus:outline-none';
+
+function JoinSourcePicker({
+    value, producers, label, onChange,
+}: {
+    value: WorkflowJoinSource;
+    producers: FlowProducer[];
+    label: string;
+    onChange: (source: WorkflowJoinSource) => void;
+}) {
+    const producer = producers.find((item) => item.id === value.node_id);
+    return (
+        <fieldset className="min-w-0 space-y-2 rounded-lg border border-edge p-3">
+            <legend className="px-1 text-xs font-medium text-text-2">{label}</legend>
+            <label className="block text-xs text-text-2">
+                Producer
+                <select className={inputClass} aria-label={`${label} producer`} value={value.node_id}
+                    onChange={(event) => {
+                        const selected = producers.find((item) => item.id === event.target.value);
+                        onChange({ node_id: event.target.value, output: selected?.outputs[0]?.name ?? '' });
+                    }}>
+                    {!producer ? <option value={value.node_id}>{value.node_id ? 'Unavailable producer' : 'Choose producer'}</option> : null}
+                    {producers.map((item) => <option key={item.id} value={item.id}>{item.label}</option>)}
+                </select>
+            </label>
+            <label className="block text-xs text-text-2">
+                Final output
+                <select className={inputClass} aria-label={`${label} output`} value={value.output}
+                    onChange={(event) => onChange({ ...value, output: event.target.value })}>
+                    {!producer?.outputs.some((item) => item.name === value.output) ? <option value={value.output}>Choose output</option> : null}
+                    {producer?.outputs.map((item) => <option key={item.name} value={item.name}>{item.name}</option>)}
+                </select>
+            </label>
+        </fieldset>
+    );
+}
+
+function JoinEditor({
+    node, workflow, onChange,
+}: {
+    node: WorkflowIfNode;
+    workflow: WorkflowDefinition;
+    onChange: (node: WorkflowIfNode) => void;
+}) {
+    const analysis = analyzeWorkflowFlow(workflow);
+    const producers = flowProducers(workflow);
+    const thenSources = producers.filter((item) => analysis.branchEnds.get(node.then.id)?.has(item.id));
+    const elseSources = producers.filter((item) => analysis.branchEnds.get(node.else.id)?.has(item.id));
+    const update = (index: number, patch: Partial<WorkflowIfNode['join']['exports'][number]>) =>
+        onChange({ ...node, join: { ...node.join, exports: node.join.exports.map((item, position) => position === index ? { ...item, ...patch } : item) } });
+    return (
+        <fieldset className="min-w-0 space-y-3 rounded-xl border border-edge p-3">
+            <legend className="px-1 text-sm font-semibold text-text-1">Join outputs</legend>
+            <p className="text-xs text-text-3">
+                Both paths rejoin here. Select each path's exact output to give later tasks one named input.
+                Unselected paths do not produce data.
+            </p>
+            {node.join.exports.map((item, index) => (
+                <div key={index} className="min-w-0 space-y-3 rounded-xl bg-surface-sunken p-3">
+                    <div className="grid min-w-0 gap-3 sm:grid-cols-2">
+                        <label className="text-xs text-text-2">
+                            Joined output name
+                            <input className={inputClass} aria-label={`Join output ${index + 1} name`} value={item.name} maxLength={64}
+                                onChange={(event) => update(index, { name: event.target.value })} />
+                        </label>
+                        <label className="text-xs text-text-2">
+                            Expected kind
+                            <select className={inputClass} aria-label={`Join output ${index + 1} kind`} value={item.expected_kind}
+                                onChange={(event) => update(index, { expected_kind: event.target.value as WorkflowOutputKind })}>
+                                {FLOW_OUTPUT_KINDS.map((kind) => <option key={kind} value={kind}>{kind.replaceAll('_', ' ')}</option>)}
+                            </select>
+                        </label>
+                        <JoinSourcePicker value={item.then} producers={thenSources} label={`Join output ${index + 1} Then`}
+                            onChange={(source) => update(index, { then: source })} />
+                        <JoinSourcePicker value={item.else} producers={elseSources} label={`Join output ${index + 1} Else`}
+                            onChange={(source) => update(index, { else: source })} />
+                    </div>
+                    <label className="flex items-center gap-2 text-xs text-text-2">
+                        <input type="checkbox" checked={item.required} aria-label={`Join output ${index + 1} required`}
+                            onChange={(event) => update(index, { required: event.target.checked })} />
+                        Require this output on either selected path
+                    </label>
+                    <GlassButton size="sm" variant="danger" aria-label={`Remove join output ${index + 1}`}
+                        onClick={() => onChange({ ...node, join: { ...node.join, exports: node.join.exports.filter((_, position) => position !== index) } })}>
+                        <Trash2 size={14} /> Remove output
+                    </GlassButton>
+                </div>
+            ))}
+            <GlassButton size="sm" disabled={node.join.exports.length >= 100} onClick={() => {
+                let name = 'report';
+                let number = 2;
+                while (node.join.exports.some((item) => item.name === name)) name = `report${number++}`;
+                onChange({ ...node, join: { ...node.join, exports: [...node.join.exports, {
+                    name, expected_kind: 'any', required: true,
+                    then: { node_id: '', output: '' }, else: { node_id: '', output: '' },
+                }] } });
+            }}><Plus size={14} /> Add joined output</GlassButton>
+        </fieldset>
+    );
+}
+
+export function WorkflowStructuredList({
+    workflow, options, onChange, renderTask,
+}: {
+    workflow: WorkflowDefinition;
+    options: WorkflowEditorOptions;
+    onChange: (workflow: WorkflowDefinition) => void;
+    renderTask: (task: WorkflowTask, node: WorkflowTaskNode, onNodeChange: (node: WorkflowTaskNode) => void) => ReactNode;
+}) {
+    const [removing, setRemoving] = useState<{ regionId: string; node: WorkflowFlowNode } | null>(null);
+    if (!isFlowRegion(workflow.flow)) {
+        return <p role="alert" className="text-sm text-danger">This flow cannot be edited by this version of the List editor.</p>;
+    }
+    const flow = workflow.flow;
+    const regions = flowRegions(flow);
+    const limits = isRecord(workflow.limits) ? workflow.limits : DEFAULT_FLOW_LIMITS;
+    const setFlow = (next: WorkflowFlowRegion, tasks = workflow.tasks) => onChange({ ...workflow, flow: next, tasks });
+    const setNode = (regionId: string, next: WorkflowFlowNode) =>
+        setFlow(updateFlowRegion(flow, regionId, (region) => ({
+            ...region, nodes: region.nodes.map((node) => node.id === next.id ? next : node),
+        })));
+    const add = (regionId: string, kind: WorkflowFlowNode['kind']) => {
+        const task = { ...createWorkflowTask(workflow.tasks.length), inputs: [], reference_ids: workflow.reference_inputs.map((reference) => reference.id) };
+        const id = kind === 'task' ? task.id : `${kind}-${task.id}`;
+        let node: WorkflowFlowNode;
+        if (kind === 'task') node = { id, kind, task_id: task.id };
+        else if (kind === 'route') node = { id, kind, inputs: [], condition: defaultFlowPredicate(), target: { node_id: '' } };
+        else node = {
+            id, kind, inputs: [], condition: defaultFlowPredicate(),
+            then: { id: `then-${task.id}`, nodes: [] }, else: { id: `else-${task.id}`, nodes: [] },
+            join: { id: `join-${task.id}`, exports: [] },
+        };
+        setFlow(updateFlowRegion(flow, regionId, (region) => ({ ...region, nodes: [...region.nodes, node] })),
+            kind === 'task' ? [...workflow.tasks, task] : workflow.tasks);
+    };
+    const move = (regionId: string, nodeId: string, direction: -1 | 1) =>
+        setFlow(updateFlowRegion(flow, regionId, (region) => {
+            const index = region.nodes.findIndex((node) => node.id === nodeId);
+            const nodes = [...region.nodes];
+            [nodes[index], nodes[index + direction]] = [nodes[index + direction], nodes[index]];
+            return { ...region, nodes };
+        }));
+    const moveToRegion = (regionId: string, targetId: string, node: WorkflowFlowNode) => {
+        const removed = updateFlowRegion(flow, regionId, (region) => ({ ...region, nodes: region.nodes.filter((item) => item.id !== node.id) }));
+        setFlow(updateFlowRegion(removed, targetId, (region) => ({ ...region, nodes: [...region.nodes, node] })));
+    };
+    const renderRegion = (region: WorkflowFlowRegion, label: string, depth: number): ReactNode => (
+        <fieldset className={`min-w-0 space-y-3 ${depth ? 'rounded-xl border-l-2 border-edge p-2 sm:p-3' : ''}`} key={region.id} aria-label={`${label} region`}>
+            <legend className="px-1 text-sm font-semibold text-text-1">{label}</legend>
+            {region.nodes.map((node, index) => {
+                const descendants = node.kind === 'if' ? new Set([
+                    ...flowRegions(node.then).map((item) => item.id), ...flowRegions(node.else).map((item) => item.id),
+                ]) : new Set<string>();
+                const destinations = regions.filter((item) => item.id !== region.id && !descendants.has(item.id));
+                const task = node.kind === 'task' ? workflow.tasks.find((item) => item.id === node.task_id) : undefined;
+                const title = node.kind === 'task' ? task?.name || 'Task' : node.kind === 'if' ? 'If / else' : 'Forward route';
+                const routeTargetId = node.kind === 'route' && 'node_id' in node.target ? node.target.node_id : undefined;
+                return (
+                    <section key={node.id} className="min-w-0 space-y-3 rounded-xl border border-edge bg-surface-1 p-3" aria-label={`${title} block`}>
+                        <div className="flex min-w-0 flex-wrap items-center justify-between gap-2">
+                            <div className="min-w-0">
+                                <p className="text-sm font-semibold text-text-1">{index + 1}. {title}</p>
+                                <p className="max-w-full break-all text-[10px] text-text-3">Node: {node.id}</p>
+                            </div>
+                            <div className="flex flex-wrap gap-1">
+                                <GlassButton size="sm" disabled={index === 0} aria-label={`Move ${title} up`} onClick={() => move(region.id, node.id, -1)}><ArrowUp size={14} /> Up</GlassButton>
+                                <GlassButton size="sm" disabled={index === region.nodes.length - 1} aria-label={`Move ${title} down`} onClick={() => move(region.id, node.id, 1)}><ArrowDown size={14} /> Down</GlassButton>
+                                <GlassButton size="sm" variant="danger" disabled={workflow.tasks.length - flowTaskIds(node).length < 1}
+                                    aria-label={`Remove ${title} block`} onClick={() => setRemoving({ regionId: region.id, node })}><Trash2 size={14} /> Remove</GlassButton>
+                            </div>
+                        </div>
+                        {destinations.length ? (
+                            <label className="block text-xs text-text-2">
+                                Move block to a region
+                                <select className={inputClass} value="" aria-label={`Move ${title} to region`}
+                                    onChange={(event) => moveToRegion(region.id, event.target.value, node)}>
+                                    <option value="" disabled>Choose destination</option>
+                                    {destinations.map((item) => <option key={item.id} value={item.id}>{item.label}</option>)}
+                                </select>
+                            </label>
+                        ) : null}
+                        {node.kind === 'task' ? (
+                            task ? renderTask(task, node, (next) => setNode(region.id, next)) : <p role="alert" className="text-xs text-danger">The referenced task is missing.</p>
+                        ) : (
+                            <>
+                                <WorkflowFlowInputs workflow={workflow} nodeId={node.id} bindings={node.inputs} label={`${title} inputs`}
+                                    onChange={(inputs) => setNode(region.id, { ...node, inputs })} />
+                                <WorkflowConditionEditor workflow={workflow} bindings={node.inputs} value={node.condition} label={`${title} condition`}
+                                    onChange={(condition) => setNode(region.id, { ...node, condition })} />
+                                {node.kind === 'if' ? (
+                                    <>
+                                        <p className="text-xs text-text-3">True selects Then; false selects Else. The choice is saved before either path starts.</p>
+                                        {renderRegion(node.then, 'Then', depth + 1)}
+                                        {renderRegion(node.else, 'Else', depth + 1)}
+                                        <JoinEditor node={node} workflow={workflow} onChange={(next) => setNode(region.id, next)} />
+                                    </>
+                                ) : (
+                                    <label className="block text-xs text-text-2">
+                                        Route when true
+                                        <select className={inputClass} aria-label="Forward route target"
+                                            value={'node_id' in node.target ? `node:${node.target.node_id}` : `exit:${node.target.exit_region_id}`}
+                                            onChange={(event) => {
+                                                const value = event.target.value;
+                                                setNode(region.id, { ...node, target: value.startsWith('exit:')
+                                                    ? { exit_region_id: value.slice(5) } : { node_id: value.slice(5) } });
+                                            }}>
+                                            <option value={routeTargetId !== undefined && !region.nodes.slice(index + 1).some((item) => item.id === routeTargetId) ? `node:${routeTargetId}` : ''} disabled>Choose a later sibling or branch exit</option>
+                                            {region.nodes.slice(index + 1).map((item) => <option key={item.id} value={`node:${item.id}`}>
+                                                {item.kind === 'task' ? workflow.tasks.find((task) => task.id === item.task_id)?.name || item.id : `${item.kind} (${item.id})`}
+                                            </option>)}
+                                            {depth > 0 ? <option value={`exit:${region.id}`}>Exit this branch to its join</option> : null}
+                                        </select>
+                                        <span className="mt-1 block text-xs text-text-3">False continues to the next node. Routing cannot bypass required inputs.</span>
+                                    </label>
+                                )}
+                            </>
+                        )}
+                    </section>
+                );
+            })}
+            {!region.nodes.length ? <p className="text-xs text-text-3">This path is empty and rejoins without producing an output.</p> : null}
+            <div className="flex flex-wrap gap-2">
+                <GlassButton size="sm" disabled={workflow.tasks.length >= options.max_tasks} onClick={() => add(region.id, 'task')}
+                    aria-label={`Add task to ${label}`}><Plus size={14} /> Add task</GlassButton>
+                <GlassButton size="sm" disabled={depth + 1 >= FLOW_MAX_DEPTH} onClick={() => add(region.id, 'if')}
+                    aria-label={`Add If/else to ${label}`}><GitBranch size={14} /> Add If/else</GlassButton>
+                <GlassButton size="sm" onClick={() => add(region.id, 'route')}
+                    aria-label={`Add forward route to ${label}`}><Plus size={14} /> Add forward route</GlassButton>
+            </div>
+        </fieldset>
+    );
+    return (
+        <div className="min-w-0 space-y-4">
+            <p className="text-xs text-text-3">List order inside each region is the executable flow. Reordering never retargets a saved input.</p>
+            <div className="grid gap-3 sm:grid-cols-2">
+                <label className="text-xs text-text-2">
+                    Maximum execution admissions
+                    <input className={inputClass} type="number" min={1} max={DEFAULT_FLOW_LIMITS.max_executions}
+                        aria-label="Maximum execution admissions" value={Number.isFinite(Number(limits.max_executions)) ? Number(limits.max_executions) : ''}
+                        onChange={(event) => onChange({ ...workflow, limits: { ...limits, max_executions: event.currentTarget.valueAsNumber } })} />
+                </label>
+                <label className="text-xs text-text-2">
+                    Elapsed deadline (seconds, including waits)
+                    <input className={inputClass} type="number" min={1} max={DEFAULT_FLOW_LIMITS.deadline_seconds}
+                        aria-label="Workflow elapsed deadline" value={Number.isFinite(Number(limits.deadline_seconds)) ? Number(limits.deadline_seconds) : ''}
+                        onChange={(event) => onChange({ ...workflow, limits: { ...limits, deadline_seconds: event.currentTarget.valueAsNumber } })} />
+                </label>
+            </div>
+            {renderRegion(flow, 'Main', 0)}
+            <WorkflowFlowInputs workflow={workflow} nodeId={flow.id} bindings={flow.outputs ?? []} label="Final outputs"
+                onChange={(outputs) => setFlow({ ...flow, outputs })} />
+            <p className="text-xs text-text-3">Required final outputs must exist on every selected path. Leave this list empty only when the workflow does not promise a final deliverable.</p>
+            {removing ? (
+                <ConfirmDialog title="Remove this flow block?" description="Tasks inside the block will be removed. Existing consumers keep their bindings and will show any resulting dependency errors."
+                    confirmLabel="Remove block" cancelLabel="Keep block" onClose={() => setRemoving(null)}
+                    onConfirm={() => {
+                        const taskIds = new Set(flowTaskIds(removing.node));
+                        setFlow(updateFlowRegion(flow, removing.regionId, (region) => ({
+                            ...region, nodes: region.nodes.filter((node) => node.id !== removing.node.id),
+                        })), workflow.tasks.filter((task) => !taskIds.has(task.id)));
+                        setRemoving(null);
+                    }} />
+            ) : null}
+        </div>
+    );
+}
diff --git a/application/v2_ui/src/lib/workflowEditor.ts b/application/v2_ui/src/lib/workflowEditor.ts
index 4f4e74131..063f634c1 100644
--- a/application/v2_ui/src/lib/workflowEditor.ts
+++ b/application/v2_ui/src/lib/workflowEditor.ts
@@ -8,6 +8,13 @@ import {
 } from './documentExplorer';
 import type { DocumentListResponse, DocumentQuery, WorkspaceDocument } from './types';
 import { isRecord, sameEditorValue } from './workspaceAuthoring';
+import {
+    analyzeWorkflowFlow,
+    FLOW_ALIAS_PATTERN,
+    isFlowBinding,
+    isLegacyWorkflowBinding,
+    type WorkflowFlowBinding,
+} from './workflowFlow';
 
 export type WorkflowScope = { type: 'personal' } | { type: 'group'; groupId: string };
 export type WorkflowRunnerType = 'model' | 'agent';
@@ -44,6 +51,16 @@ export interface WorkflowModelOption {
 
 export interface WorkflowEditorOptions {
     definition_version: 2;
+    supported_definition_versions?: number[];
+    supported_node_kinds?: string[];
+    flow_limits?: {
+        max_nodes: number;
+        max_depth: number;
+        max_predicate_nodes: number;
+        max_predicate_depth: number;
+        max_executions: number;
+        deadline_seconds: number;
+    };
     can_manage: boolean;
     max_tasks: number;
     agents: WorkflowAgentOption[];
@@ -89,6 +106,13 @@ export interface WorkflowTaskApproval {
     message?: string;
 }
 
+export interface WorkflowPublication {
+    artifact_format: 'md' | 'csv' | 'json';
+    workspace_scope: 'personal' | 'group' | 'public';
+    group_id?: string;
+    public_workspace_id?: string;
+}
+
 export interface WorkflowTask {
     id: string;
     type: 'instructions';
@@ -97,10 +121,11 @@ export interface WorkflowTask {
     order: number;
     runner: WorkflowTaskRunner;
     document_action?: WorkflowDocumentAction;
-    inputs?: WorkflowInputBinding[];
+    inputs?: (WorkflowInputBinding | WorkflowFlowBinding)[];
     reference_ids?: string[];
     output_contract?: WorkflowOutputContract;
     approval?: WorkflowTaskApproval;
+    publication?: WorkflowPublication;
     [key: string]: unknown;
 }
 
@@ -146,6 +171,7 @@ export interface WorkflowDefinition {
     tasks: WorkflowTask[];
     reference_inputs: WorkflowReferenceInput[];
     durable_execution?: boolean;
+    editor_readonly_reason?: string;
     [key: string]: unknown;
 }
 
@@ -156,6 +182,17 @@ export interface WorkflowRuntimeGate {
     input_digest?: string;
     reason?: string;
     choices: string[];
+    execution_id?: string;
+    node_id?: string;
+    attempt?: number;
+    iteration_path?: WorkflowIterationFrame[];
+}
+
+export interface WorkflowIterationFrame {
+    loop_id: string;
+    item_id?: string;
+    index?: number;
+    iteration?: number;
 }
 
 export interface WorkflowRuntimeDecision {
@@ -165,6 +202,9 @@ export interface WorkflowRuntimeDecision {
     decided_at?: string;
     input_digest?: string;
     attempt?: number;
+    execution_id?: string;
+    node_id?: string;
+    iteration_path?: WorkflowIterationFrame[];
 }
 
 export interface WorkflowRuntimeUnitMemory {
@@ -182,6 +222,7 @@ export interface WorkflowRuntimeMemory {
 }
 
 export interface WorkflowRuntimeProjection {
+    schema_version?: number;
     version: number;
     state: WorkflowRuntimeState;
     phase?: string;
@@ -192,6 +233,13 @@ export interface WorkflowRuntimeProjection {
     gate?: WorkflowRuntimeGate;
     memory?: WorkflowRuntimeMemory;
     can_resume?: boolean;
+    limits?: {
+        max_executions: number;
+        admitted_count: number;
+        deadline_at: string;
+        deadline_seconds: number;
+        waits_count: boolean;
+    };
 }
 
 export interface WorkflowRuntimeResponse {
@@ -215,6 +263,7 @@ export interface WorkflowRunSummary {
     id?: string;
     run_id?: string;
     workflow_id?: string;
+    definition_version?: number;
     status?: string;
     durable_execution?: boolean;
     started_at?: string;
@@ -265,13 +314,17 @@ export interface WorkflowResultReference {
 
 export interface WorkflowConsumedInput {
     producer?: {
+        workflow_id?: string;
+        node_id?: string;
+        execution_id?: string;
+        iteration_path?: WorkflowIterationFrame[];
         task_id?: string;
         run_id?: string;
         attempt?: number;
     };
     output_name?: string;
     result_ref?: WorkflowResultReference;
-    output_ref?: string;
+    output_ref?: WorkflowResultReference | string;
     input_name?: string;
 }
 
@@ -301,7 +354,7 @@ export interface WorkflowRunResultPage {
 
 export const WORKFLOW_TASK_INSTRUCTIONS_LIMIT = 12000;
 export const WORKFLOW_SCHEMA_LIMIT = 32768;
-export const WORKFLOW_ALIAS_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+export const WORKFLOW_ALIAS_PATTERN = FLOW_ALIAS_PATTERN;
 export const WORKFLOW_SCHEMA_ALLOWED_KEYS = new Set([
     'type',
     'properties',
@@ -372,9 +425,9 @@ function withScopeQuery(path: string, scope: WorkflowScope, extra?: URLSearchPar
     return query ? `${path}?${query}` : path;
 }
 
-function workflowUrl(scope: WorkflowScope, workflowId?: string, suffix = ''): string {
+export function workflowUrl(scope: WorkflowScope, workflowId?: string, suffix = '', extra?: URLSearchParams): string {
     const path = `${workflowRoot(scope)}${workflowId ? `/${encodeURIComponent(workflowId)}` : ''}${suffix}`;
-    return withScopeQuery(path, scope);
+    return withScopeQuery(path, scope, extra);
 }
 
 function asArray<T>(value: unknown, key?: string): T[] {
@@ -504,7 +557,7 @@ export function newWorkflowDefinition(scope: WorkflowScope): WorkflowDefinition
     };
 }
 
-function normalizeRunner(value: unknown): WorkflowTaskRunner {
+function normalizeRunner(value: unknown, structured = false): WorkflowTaskRunner {
     if (!isRecord(value)) {
         return { type: 'inherit' };
     }
@@ -512,6 +565,7 @@ function normalizeRunner(value: unknown): WorkflowTaskRunner {
         ? value.type as WorkflowTaskRunnerType
         : 'inherit';
     return {
+        ...(structured ? value : {}),
         type,
         selected_agent: agentReference(value.selected_agent),
         model_endpoint_id: text(value.model_endpoint_id),
@@ -538,7 +592,14 @@ function normalizeOutputContract(value: unknown): WorkflowOutputContract | undef
     };
 }
 
-function normalizeInputs(value: unknown): WorkflowInputBinding[] | undefined {
+function normalizeInputs(value: unknown, structured = false): (WorkflowInputBinding | WorkflowFlowBinding)[] | undefined {
+    if (structured) {
+        if (value === undefined) return [];
+        if (!Array.isArray(value) || !value.every(isFlowBinding)) {
+            throw new Error('This structured workflow contains unsupported input bindings. Its saved definition was not changed.');
+        }
+        return structuredClone(value);
+    }
     if (value === null || value === undefined) {
         return undefined;
     }
@@ -567,10 +628,12 @@ function normalizeApproval(value: unknown): WorkflowTaskApproval | undefined {
     };
 }
 
-function normalizeTask(value: unknown, index: number): WorkflowTask {
+function normalizeTask(value: unknown, index: number, structured = false): WorkflowTask {
     const record = isRecord(value) ? value : {};
-    const inputs = Object.hasOwn(record, 'inputs') && record.inputs !== null
-        ? normalizeInputs(record.inputs) ?? []
+    const unsupportedInputs = structured && record.inputs !== undefined &&
+        (!Array.isArray(record.inputs) || !record.inputs.every(isFlowBinding));
+    const inputs = structured || (Object.hasOwn(record, 'inputs') && record.inputs !== null)
+        ? unsupportedInputs ? [] : normalizeInputs(record.inputs, structured) ?? []
         : undefined;
     const referenceIds = Array.isArray(record.reference_ids)
         ? record.reference_ids.filter((item): item is string => typeof item === 'string')
@@ -584,7 +647,8 @@ function normalizeTask(value: unknown, index: number): WorkflowTask {
         name: text(record.name) || `Task ${index + 1}`,
         instructions: text(record.instructions),
         order: index + 1,
-        runner: normalizeRunner(record.runner),
+        runner: normalizeRunner(record.runner, structured),
+        ...(unsupportedInputs ? { unrecognized_inputs: structuredClone(record.inputs) } : {}),
         document_action: isRecord(record.document_action) ? record.document_action as WorkflowDocumentAction : undefined,
         ...(inputs !== undefined ? { inputs } : {}),
         ...(referenceIds !== undefined ? { reference_ids: referenceIds } : {}),
@@ -684,7 +748,7 @@ export function normalizeWorkflowDefinition(
         : 'manual';
     const normalizedTasks = Array.isArray(record.tasks) ? record.tasks : [];
     const tasks = normalizedTasks
-        .map(normalizeTask)
+        .map((task, index) => normalizeTask(task, index, record.definition_version === 3))
         .sort((left, right) => left.order - right.order)
         .map((task, index) => ({ ...task, order: index + 1 }));
     const references = (Array.isArray(record.reference_inputs) ? record.reference_inputs : [])
@@ -725,6 +789,9 @@ export function normalizeWorkflowDefinition(
         },
         tasks: tasks.length ? tasks : [legacyWorkflowTask(record) ?? createWorkflowTask(0)],
         reference_inputs: references,
+        ...(record.definition_version === 3 && tasks.some((task) => Object.hasOwn(task, 'unrecognized_inputs')) ? {
+            editor_readonly_reason: 'This workflow contains input bindings from an unsupported schema. Its original inputs have been retained and editing is disabled.',
+        } : {}),
         ...(Object.hasOwn(record, 'durable_execution') ? { durable_execution: record.durable_execution === true } : {}),
         ...(scope.type === 'group' ? { group_id: scope.groupId } : {}),
     };
@@ -735,13 +802,19 @@ export function workflowForSave(
     original: WorkflowDefinition | null,
     scope: WorkflowScope,
 ): WorkflowDefinition {
+    if (draft.editor_readonly_reason) {
+        throw new Error('This workflow contains unsupported executable fields and cannot be saved by this editor.');
+    }
+    if (original && original.definition_version >= 3 && draft.definition_version < original.definition_version) {
+        throw new Error('This workflow cannot be downgraded without losing executable fields.');
+    }
     const base = original ? structuredClone(original) : newWorkflowDefinition(scope);
     const originalHasDurable = original ? Object.hasOwn(original, 'durable_execution') : false;
     const includeDurable = !original || originalHasDurable || draft.durable_execution === true;
     const next = {
         ...base,
         id: original?.id ?? draft.id,
-        definition_version: 2,
+        definition_version: draft.definition_version === 3 ? 3 : 2,
         definition_revision: original?.definition_revision,
         name: draft.name.trim(),
         description: draft.description.trim(),
@@ -757,6 +830,7 @@ export function workflowForSave(
         tasks: draft.tasks.map((task, index) => ({ ...task, order: index + 1 })),
         task_prompt: draft.tasks[0]?.instructions.trim() || '',
         reference_inputs: draft.reference_inputs,
+        ...(draft.definition_version === 3 ? { flow: structuredClone(draft.flow), limits: structuredClone(draft.limits) } : {}),
         ...(includeDurable ? { durable_execution: draft.durable_execution === true } : {}),
         ...(scope.type === 'group' ? { group_id: scope.groupId } : {}),
     };
@@ -789,6 +863,8 @@ export function preservedWorkflowFieldLabels(original: WorkflowDefinition | null
         'task_prompt',
         'reference_inputs',
         'durable_execution',
+        'flow',
+        'limits',
         'group_id',
     ]);
     const labels: Record<string, string> = {
@@ -817,9 +893,12 @@ export function workflowValidationErrors(
     if (!options.can_manage) {
         errors.push('You do not have permission to save workflows in this scope.');
     }
-    if (draft.definition_version > 2) {
+    if (!(options.supported_definition_versions ?? [1, 2]).includes(draft.definition_version)) {
         errors.push('This workflow was created by a newer editor and is read-only here.');
     }
+    if (draft.definition_version === 3) {
+        errors.push(...analyzeWorkflowFlow(draft).errors);
+    }
     if (draft.trigger_type === 'interval' && draft.schedule.value < 1) {
         errors.push('Interval workflows need a positive schedule value.');
     }
@@ -906,6 +985,11 @@ export function workflowValidationErrors(
             errors.push(`${task.name || `Task ${index + 1}`} must choose an explicit model because the app default model is not valid for this workflow scope.`);
         }
         for (const input of task.inputs ?? []) {
+            if (draft.definition_version === 3) continue;
+            if (!isLegacyWorkflowBinding(input)) {
+                errors.push('Structured input bindings require definition version 3.');
+                continue;
+            }
             if (!WORKFLOW_ALIAS_PATTERN.test(input.name)) {
                 errors.push(`${task.name || `Task ${index + 1}`} has an input alias that must start with a letter and use only letters, numbers, underscores, or dashes, up to 64 characters.`);
             }
diff --git a/application/v2_ui/src/lib/workflowExecutionHistory.ts b/application/v2_ui/src/lib/workflowExecutionHistory.ts
new file mode 100644
index 000000000..379de8d05
--- /dev/null
+++ b/application/v2_ui/src/lib/workflowExecutionHistory.ts
@@ -0,0 +1,270 @@
+// workflowExecutionHistory.ts
+// Paged V3 workflow execution-history API contracts and client helpers.
+
+import { api } from './apiClient';
+import { isRecord } from './workspaceAuthoring';
+import {
+    workflowUrl,
+    type WorkflowConsumedInput,
+    type WorkflowIterationFrame,
+    type WorkflowResultReference,
+    type WorkflowRunResultPage,
+    type WorkflowScope,
+    type WorkflowValidationResult,
+} from './workflowEditor';
+
+export interface WorkflowExecutionDecisionPreview {
+    choice?: string;
+    selected_branch?: string;
+    branch_id?: string;
+    target_node_id?: string;
+    route_target?: string;
+    target?: { node_id?: string; exit_region_id?: string } | null;
+    exit_region_id?: string;
+    gate_id?: string;
+    input_digest?: string;
+    reason_code?: string;
+    timestamp?: string;
+    decided_at?: string;
+    [key: string]: unknown;
+}
+
+export interface WorkflowExecutionRecord {
+    execution_id: string;
+    node_id: string;
+    node_kind: string;
+    task_id?: string;
+    iteration_path?: WorkflowIterationFrame[];
+    region_id?: string;
+    sequence?: number;
+    state: string;
+    attempt: number;
+    reason_code?: string;
+    decision?: WorkflowExecutionDecisionPreview;
+    workflow_result?: {
+        result_ref?: WorkflowResultReference;
+        outputs?: Record<string, unknown>;
+        authoritative_output?: string;
+        consumed_inputs?: WorkflowConsumedInput[];
+    };
+    workflow_validation?: WorkflowValidationResult;
+    consumed_inputs?: WorkflowConsumedInput[];
+    started_at?: string;
+    completed_at?: string;
+    [key: string]: unknown;
+}
+
+export interface WorkflowExecutionAttemptRecord {
+    execution_id: string;
+    node_id: string;
+    task_id?: string;
+    attempt: number;
+    state: string;
+    started_at?: string;
+    completed_at?: string;
+    workflow_result?: {
+        result_ref?: WorkflowResultReference;
+        outputs?: Record<string, unknown>;
+        authoritative_output?: string;
+        consumed_inputs?: WorkflowConsumedInput[];
+    };
+    workflow_validation?: WorkflowValidationResult;
+    consumed_inputs?: WorkflowConsumedInput[];
+    [key: string]: unknown;
+}
+
+export interface WorkflowRuntimeDecisionRecord {
+    execution_id?: string;
+    node_id?: string;
+    attempt?: number;
+    gate_id?: string;
+    input_digest?: string;
+    choice?: string;
+    selected_branch?: string;
+    branch_id?: string;
+    target_node_id?: string;
+    route_target?: string;
+    target?: { node_id?: string; exit_region_id?: string } | null;
+    exit_region_id?: string;
+    decision?: WorkflowExecutionDecisionPreview;
+    reason_code?: string;
+    iteration_path?: WorkflowIterationFrame[];
+    timestamp?: string;
+    decided_at?: string;
+    [key: string]: unknown;
+}
+
+export interface WorkflowExecutionPage<T> {
+    items: T[];
+    next_cursor: string | null;
+    total_count?: number;
+}
+
+function boundedLimit(limit: number, maximum = 100): number {
+    if (!Number.isInteger(limit) || limit < 1 || limit > maximum) {
+        throw new Error('The requested workflow history page size is invalid.');
+    }
+    return limit;
+}
+
+function validIdentity(value: unknown): value is string {
+    return typeof value === 'string' && Boolean(value.trim()) && value.length <= 256;
+}
+
+function validPath(value: unknown): value is WorkflowIterationFrame[] | undefined {
+    return value === undefined || Array.isArray(value) && value.every((frame) =>
+        isRecord(frame) && validIdentity(frame.loop_id) &&
+        (frame.item_id === undefined || validIdentity(frame.item_id)) &&
+        (frame.index === undefined || typeof frame.index === 'number' && Number.isInteger(frame.index) && frame.index >= 0) &&
+        (frame.iteration === undefined || typeof frame.iteration === 'number' && Number.isInteger(frame.iteration) && frame.iteration >= 1));
+}
+
+function validInputs(value: unknown): boolean {
+    return value === undefined || Array.isArray(value) && value.every((input) =>
+        isRecord(input) && (input.producer === undefined || isRecord(input.producer) && validPath(input.producer.iteration_path)));
+}
+
+function validResultMetadata(value: Record<string, unknown>): boolean {
+    return validInputs(value.consumed_inputs) &&
+        (value.workflow_result === undefined || isRecord(value.workflow_result) && validInputs(value.workflow_result.consumed_inputs)) &&
+        (value.workflow_validation === undefined || isRecord(value.workflow_validation));
+}
+
+function isExecution(value: unknown): value is WorkflowExecutionRecord {
+    return isRecord(value) && validIdentity(value.execution_id) && validIdentity(value.node_id) &&
+        validIdentity(value.node_kind) && validIdentity(value.state) &&
+        typeof value.attempt === 'number' && Number.isInteger(value.attempt) && value.attempt >= 0 &&
+        validPath(value.iteration_path) && validResultMetadata(value);
+}
+
+function isAttempt(value: unknown): value is WorkflowExecutionAttemptRecord {
+    return isRecord(value) && validIdentity(value.execution_id) && validIdentity(value.node_id) &&
+        validIdentity(value.state) && typeof value.attempt === 'number' &&
+        Number.isInteger(value.attempt) && value.attempt >= 1 && validResultMetadata(value);
+}
+
+function isDecision(value: unknown): value is WorkflowRuntimeDecisionRecord {
+    return isRecord(value) && validPath(value.iteration_path) &&
+        (value.execution_id === undefined || validIdentity(value.execution_id)) &&
+        (value.node_id === undefined || validIdentity(value.node_id)) &&
+        (value.attempt === undefined || typeof value.attempt === 'number' && Number.isInteger(value.attempt) && value.attempt >= 0);
+}
+
+function pageParams(cursor: string | null, limit: number): URLSearchParams {
+    const params = new URLSearchParams({ limit: String(boundedLimit(limit)) });
+    if (cursor) {
+        params.set('cursor', cursor);
+    }
+    return params;
+}
+
+function pageFromResponse<T>(
+    response: unknown,
+    key: 'executions' | 'attempts' | 'decisions',
+    isItem: (value: unknown) => value is T,
+    identity?: (value: T) => string,
+): WorkflowExecutionPage<T> {
+    if (!isRecord(response)) {
+        throw new Error('The workflow execution history returned an unsupported response.');
+    }
+    const items = response[key];
+    if (!Array.isArray(items) || !items.every(isItem) ||
+        !(response.next_cursor === null || typeof response.next_cursor === 'string' && response.next_cursor.length > 0)) {
+        throw new Error('The workflow execution history returned an unsupported response.');
+    }
+    if (identity && new Set(items.map(identity)).size !== items.length) {
+        throw new Error('The workflow execution history contains conflicting identities.');
+    }
+    const total = response.total_count;
+    if (total !== undefined && (typeof total !== 'number' || !Number.isInteger(total) || total < 0)) {
+        throw new Error('The workflow execution history returned an invalid count.');
+    }
+    return {
+        items,
+        next_cursor: response.next_cursor,
+        ...(typeof total === 'number' ? { total_count: total } : {}),
+    };
+}
+
+export async function fetchWorkflowExecutionsPage(
+    scope: WorkflowScope,
+    workflowId: string,
+    runId: string,
+    cursor: string | null,
+    limit = 50,
+    signal?: AbortSignal,
+): Promise<WorkflowExecutionPage<WorkflowExecutionRecord>> {
+    const response = await api.get<unknown>(
+        workflowUrl(scope, workflowId, `/runs/${encodeURIComponent(runId)}/executions`, pageParams(cursor, limit)),
+        signal,
+    );
+    return pageFromResponse(response, 'executions', isExecution, (item) => item.execution_id);
+}
+
+export async function fetchWorkflowExecutionAttemptsPage(
+    scope: WorkflowScope,
+    workflowId: string,
+    runId: string,
+    executionId: string,
+    cursor: string | null,
+    limit = 50,
+    signal?: AbortSignal,
+): Promise<WorkflowExecutionPage<WorkflowExecutionAttemptRecord>> {
+    const response = await api.get<unknown>(
+        workflowUrl(
+            scope,
+            workflowId,
+            `/runs/${encodeURIComponent(runId)}/executions/${encodeURIComponent(executionId)}/attempts`,
+            pageParams(cursor, limit),
+        ),
+        signal,
+    );
+    return pageFromResponse(response, 'attempts',
+        (value): value is WorkflowExecutionAttemptRecord => isAttempt(value) && value.execution_id === executionId,
+        (item) => `${item.execution_id}:${item.attempt}`);
+}
+
+export async function fetchWorkflowExecutionAttemptResult(
+    scope: WorkflowScope,
+    workflowId: string,
+    runId: string,
+    executionId: string,
+    attempt: number,
+    offset: number,
+    limit = 2000,
+    signal?: AbortSignal,
+): Promise<WorkflowRunResultPage> {
+    const resultLimit = boundedLimit(limit, 2000);
+    if (!validIdentity(executionId) || !Number.isInteger(attempt) || attempt < 1 || !Number.isInteger(offset) || offset < 0) {
+        throw new Error('The requested execution attempt or result range is invalid.');
+    }
+    const params = new URLSearchParams({
+        output: 'authoritative',
+        offset: String(offset),
+        limit: String(resultLimit),
+    });
+    return api.get<WorkflowRunResultPage>(
+        workflowUrl(
+            scope,
+            workflowId,
+            `/runs/${encodeURIComponent(runId)}/executions/${encodeURIComponent(executionId)}/attempts/${attempt}/result`,
+            params,
+        ),
+        signal,
+    );
+}
+
+export async function fetchWorkflowRuntimeDecisionsPage(
+    scope: WorkflowScope,
+    workflowId: string,
+    runId: string,
+    cursor: string | null,
+    limit = 50,
+    signal?: AbortSignal,
+): Promise<WorkflowExecutionPage<WorkflowRuntimeDecisionRecord>> {
+    const response = await api.get<unknown>(
+        workflowUrl(scope, workflowId, `/runs/${encodeURIComponent(runId)}/runtime/decisions`, pageParams(cursor, limit)),
+        signal,
+    );
+    return pageFromResponse(response, 'decisions', isDecision);
+}
diff --git a/application/v2_ui/src/lib/workflowFlow.ts b/application/v2_ui/src/lib/workflowFlow.ts
new file mode 100644
index 000000000..dfb1b45a7
--- /dev/null
+++ b/application/v2_ui/src/lib/workflowFlow.ts
@@ -0,0 +1,656 @@
+// workflowFlow.ts
+// Structured workflow definitions and side-effect-free List editing helpers.
+
+import type {
+    WorkflowDefinition,
+    WorkflowInputBinding,
+    WorkflowOutputKind,
+    WorkflowDocumentAction,
+} from './workflowEditor';
+import { isRecord, sameEditorValue } from './workspaceAuthoring';
+
+export type WorkflowScalar = string | number | boolean | null;
+export type WorkflowComparison = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte';
+export type WorkflowOperand = { input: string; path: string } | { literal: WorkflowScalar };
+export type WorkflowPredicate =
+    | { op: WorkflowComparison; left: WorkflowOperand; right: WorkflowOperand }
+    | { op: 'exists'; value: WorkflowOperand }
+    | { op: 'all' | 'any'; conditions: WorkflowPredicate[] }
+    | { op: 'not'; condition: WorkflowPredicate };
+
+export interface WorkflowFlowSource {
+    kind: 'node_output';
+    node_id: string;
+    output: string;
+    scope: 'current';
+}
+
+export interface WorkflowFlowBinding {
+    name: string;
+    source: WorkflowFlowSource;
+    required: boolean;
+    expected_kind: WorkflowOutputKind;
+    allow_partial: boolean;
+}
+
+export interface WorkflowJoinSource {
+    node_id: string;
+    output: string;
+}
+
+export interface WorkflowJoinExport {
+    name: string;
+    expected_kind: WorkflowOutputKind;
+    required: boolean;
+    then: WorkflowJoinSource;
+    else: WorkflowJoinSource;
+}
+
+export interface WorkflowTaskNode {
+    id: string;
+    kind: 'task';
+    task_id: string;
+    run_when?: WorkflowPredicate;
+}
+
+export interface WorkflowIfNode {
+    id: string;
+    kind: 'if';
+    inputs: WorkflowFlowBinding[];
+    condition: WorkflowPredicate;
+    then: WorkflowFlowRegion;
+    else: WorkflowFlowRegion;
+    join: { id: string; exports: WorkflowJoinExport[] };
+}
+
+export interface WorkflowRouteNode {
+    id: string;
+    kind: 'route';
+    inputs: WorkflowFlowBinding[];
+    condition: WorkflowPredicate;
+    target: { node_id: string } | { exit_region_id: string };
+}
+
+export type WorkflowFlowNode = WorkflowTaskNode | WorkflowIfNode | WorkflowRouteNode;
+
+export interface WorkflowFlowRegion {
+    id: string;
+    nodes: WorkflowFlowNode[];
+    outputs?: WorkflowFlowBinding[];
+}
+
+export interface WorkflowFlowLimits {
+    max_executions: number;
+    deadline_seconds: number;
+}
+
+export const DEFAULT_FLOW_LIMITS: WorkflowFlowLimits = {
+    max_executions: 5000,
+    deadline_seconds: 86400,
+};
+export const FLOW_MAX_NODES = 256;
+export const FLOW_MAX_DEPTH = 4;
+export const FLOW_MAX_PREDICATE_DEPTH = 8;
+export const FLOW_MAX_PREDICATE_NODES = 100;
+export const FLOW_ALIAS_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+export const FLOW_OUTPUT_KINDS: WorkflowOutputKind[] = ['any', 'text', 'records', 'json', 'document_results'];
+export const FLOW_FINAL_OUTPUTS = ['authoritative', 'text', 'records', 'json', 'documents'] as const;
+export const FLOW_COMPARISONS: WorkflowComparison[] = ['eq', 'ne', 'lt', 'lte', 'gt', 'gte'];
+
+export function isFlowBinding(value: unknown): value is WorkflowFlowBinding {
+    return isRecord(value) && typeof value.name === 'string' && isRecord(value.source) &&
+        value.source.kind === 'node_output' && value.source.scope === 'current' &&
+        typeof value.source.node_id === 'string' && typeof value.source.output === 'string' &&
+        typeof value.required === 'boolean' && typeof value.allow_partial === 'boolean' &&
+        FLOW_OUTPUT_KINDS.some((kind) => kind === value.expected_kind);
+}
+
+export function isLegacyWorkflowBinding(
+    value: WorkflowInputBinding | WorkflowFlowBinding,
+): value is WorkflowInputBinding {
+    return 'task_id' in value;
+}
+
+function isOperand(value: unknown): value is WorkflowOperand {
+    if (!isRecord(value)) return false;
+    if ('literal' in value) {
+        return value.literal === null || ['string', 'number', 'boolean'].includes(typeof value.literal);
+    }
+    return typeof value.input === 'string' && typeof value.path === 'string';
+}
+
+export function isFlowPredicate(value: unknown, depth = 0): value is WorkflowPredicate {
+    if (!isRecord(value) || depth > 32) return false;
+    if (value.op === 'exists') return isOperand(value.value);
+    if (value.op === 'not') return isFlowPredicate(value.condition, depth + 1);
+    if (value.op === 'all' || value.op === 'any') {
+        return Array.isArray(value.conditions) && value.conditions.every((item) => isFlowPredicate(item, depth + 1));
+    }
+    return FLOW_COMPARISONS.some((op) => op === value.op) && isOperand(value.left) && isOperand(value.right);
+}
+
+function isJoinSource(value: unknown): value is WorkflowJoinSource {
+    return isRecord(value) && typeof value.node_id === 'string' && typeof value.output === 'string';
+}
+
+function isJoinExport(value: unknown): value is WorkflowJoinExport {
+    return isRecord(value) && typeof value.name === 'string' && typeof value.required === 'boolean' &&
+        FLOW_OUTPUT_KINDS.some((kind) => kind === value.expected_kind) &&
+        isJoinSource(value.then) && isJoinSource(value.else);
+}
+
+export function isFlowRegion(value: unknown, depth = 0): value is WorkflowFlowRegion {
+    if (!isRecord(value) || typeof value.id !== 'string' || !Array.isArray(value.nodes) ||
+        value.nodes.length > FLOW_MAX_NODES || depth > 16) return false;
+    if (value.outputs !== undefined && (!Array.isArray(value.outputs) || !value.outputs.every(isFlowBinding))) return false;
+    return value.nodes.every((node) => {
+        if (!isRecord(node) || typeof node.id !== 'string') return false;
+        if (node.kind === 'task') {
+            return typeof node.task_id === 'string' && (node.run_when === undefined || isFlowPredicate(node.run_when));
+        }
+        if (!Array.isArray(node.inputs) || !node.inputs.every(isFlowBinding) || !isFlowPredicate(node.condition)) return false;
+        if (node.kind === 'route') {
+            return isRecord(node.target) &&
+                (typeof node.target.node_id === 'string' || typeof node.target.exit_region_id === 'string');
+        }
+        return node.kind === 'if' && isFlowRegion(node.then, depth + 1) && isFlowRegion(node.else, depth + 1) &&
+            isRecord(node.join) && typeof node.join.id === 'string' &&
+            Array.isArray(node.join.exports) && node.join.exports.every(isJoinExport);
+    });
+}
+
+export function defaultFlowPredicate(input = ''): WorkflowPredicate {
+    return { op: 'eq', left: { input, path: '' }, right: { literal: true } };
+}
+
+export function flowBinding(name: string, nodeId: string, output = 'authoritative'): WorkflowFlowBinding {
+    return {
+        name,
+        source: { kind: 'node_output', node_id: nodeId, output, scope: 'current' },
+        required: true,
+        expected_kind: 'any',
+        allow_partial: false,
+    };
+}
+
+export interface FlowProducer {
+    id: string;
+    label: string;
+    outputs: { name: string; kind: WorkflowOutputKind; required: boolean; schema?: Record<string, unknown> }[];
+}
+
+export function flowProducers(workflow: WorkflowDefinition): FlowProducer[] {
+    if (!isFlowRegion(workflow.flow)) return [];
+    const tasks = new Map(workflow.tasks.map((task) => [task.id, task]));
+    const result: FlowProducer[] = [];
+    const walk = (region: WorkflowFlowRegion) => region.nodes.forEach((node) => {
+        if (node.kind === 'task') {
+            const task = tasks.get(node.task_id);
+            if (!task) return;
+            const kind = task.output_contract?.kind ?? 'any';
+            const outputs: FlowProducer['outputs'] = [{
+                name: 'authoritative', kind, required: node.run_when === undefined,
+                schema: task.output_contract?.schema,
+            }, {
+                name: 'text', kind: 'text', required: node.run_when === undefined,
+                schema: kind === 'text' ? task.output_contract?.schema : undefined,
+            }];
+            if (kind === 'json' || kind === 'records' || kind === 'document_results') {
+                outputs.push({
+                    name: kind === 'document_results' ? 'documents' : kind, kind,
+                    required: node.run_when === undefined, schema: task.output_contract?.schema,
+                });
+            }
+            result.push({ id: node.id, label: task.name || node.id, outputs });
+        } else if (node.kind === 'if') {
+            walk(node.then);
+            walk(node.else);
+            result.push({
+                id: node.join.id,
+                label: `Join ${node.id}`,
+                outputs: node.join.exports.map((item) => {
+                    const thenSchema = result.find((producer) => producer.id === item.then.node_id)?.outputs
+                        .find((output) => output.name === item.then.output)?.schema;
+                    const elseSchema = result.find((producer) => producer.id === item.else.node_id)?.outputs
+                        .find((output) => output.name === item.else.output)?.schema;
+                    return {
+                        name: item.name, kind: item.expected_kind, required: item.required,
+                        ...(thenSchema && sameEditorValue(thenSchema, elseSchema) ? { schema: thenSchema } : {}),
+                    };
+                }),
+            });
+        }
+    });
+    walk(workflow.flow);
+    return result;
+}
+
+export function flowRegions(flow: WorkflowFlowRegion): { id: string; label: string; depth: number }[] {
+    const regions: { id: string; label: string; depth: number }[] = [];
+    const walk = (region: WorkflowFlowRegion, label: string, depth: number) => {
+        regions.push({ id: region.id, label, depth });
+        region.nodes.forEach((node) => {
+            if (node.kind === 'if') {
+                walk(node.then, `${label} / ${node.id} / Then`, depth + 1);
+                walk(node.else, `${label} / ${node.id} / Else`, depth + 1);
+            }
+        });
+    };
+    walk(flow, 'Main', 0);
+    return regions;
+}
+
+export function updateFlowRegion(
+    flow: WorkflowFlowRegion,
+    regionId: string,
+    update: (region: WorkflowFlowRegion) => WorkflowFlowRegion,
+): WorkflowFlowRegion {
+    if (flow.id === regionId) return update(flow);
+    return {
+        ...flow,
+        nodes: flow.nodes.map((node) => node.kind === 'if' ? {
+            ...node,
+            then: updateFlowRegion(node.then, regionId, update),
+            else: updateFlowRegion(node.else, regionId, update),
+        } : node),
+    };
+}
+
+export function flowTaskIds(node: WorkflowFlowNode): string[] {
+    if (node.kind === 'task') return [node.task_id];
+    if (node.kind === 'route') return [];
+    return [...node.then.nodes, ...node.else.nodes].flatMap(flowTaskIds);
+}
+
+export function convertToStructuredWorkflow(workflow: WorkflowDefinition, rootId: string): WorkflowDefinition {
+    if (workflow.definition_version > 2) throw new Error('Only legacy workflow definitions can be converted.');
+    if (workflow.error_handling.strategy === 'continue' && workflow.tasks.some((task, index) => index > 0 && task.inputs == null)) {
+        throw new Error('Choose explicit task inputs before converting a continue-on-error workflow. Automatic previous-successful bindings cannot be converted without changing their meaning.');
+    }
+    const converted = structuredClone(workflow);
+    let inheritedAction: WorkflowDocumentAction | undefined;
+    if (isRecord(converted.document_action)) {
+        const type = converted.document_action.type;
+        if (type !== 'none' && type !== 'search' && type !== 'analyze' && type !== 'comparison') {
+            throw new Error('Choose an explicit supported document action before converting this workflow.');
+        }
+        inheritedAction = { ...structuredClone(converted.document_action), type };
+    }
+    converted.tasks = converted.tasks.map((task, index) => {
+        const previous = converted.tasks[index - 1];
+        const bindings = task.inputs ?? (previous ? [{
+            name: 'previous', task_id: previous.id, output: 'authoritative' as const,
+            required: true, expected_kind: 'any' as const,
+        }] : []);
+        return {
+            ...task,
+            inputs: bindings.map((binding) => isFlowBinding(binding) ? binding : {
+                ...flowBinding(binding.name, binding.task_id, binding.output),
+                required: binding.required,
+                expected_kind: binding.expected_kind,
+                allow_partial: converted.tasks.find((producer) => producer.id === binding.task_id)?.output_contract?.allow_partial === true,
+            }),
+            reference_ids: task.reference_ids ?? converted.reference_inputs.map((reference) => reference.id),
+            document_action: task.document_action ?? (index === 0 ? inheritedAction : undefined) ?? { type: 'none' },
+        };
+    });
+    converted.definition_version = 3;
+    converted.durable_execution = true;
+    converted.limits = { ...DEFAULT_FLOW_LIMITS };
+    converted.flow = {
+        id: rootId,
+        nodes: converted.tasks.map((task) => ({ id: task.id, kind: 'task', task_id: task.id })),
+        outputs: [],
+    };
+    return converted;
+}
+
+function onlyFields(value: object, fields: string[], errors: string[], label: string) {
+    if (Object.keys(value).some((field) => !fields.includes(field))) errors.push(`${label} contains unsupported executable fields.`);
+}
+
+export function flowUnsupportedReason(workflow: WorkflowDefinition): string {
+    if (workflow.editor_readonly_reason) return workflow.editor_readonly_reason;
+    if (workflow.definition_version !== 3) return '';
+    if (!isFlowRegion(workflow.flow)) return 'This structured definition contains an unsupported or malformed region, node, binding, or condition.';
+    const errors: string[] = [];
+    const operand = (value: WorkflowOperand) =>
+        onlyFields(value, 'literal' in value ? ['literal'] : ['input', 'path'], errors, 'Condition operand');
+    const predicate = (value: WorkflowPredicate) => {
+        if (value.op === 'all' || value.op === 'any') {
+            onlyFields(value, ['op', 'conditions'], errors, 'Condition');
+            value.conditions.forEach(predicate);
+        } else if (value.op === 'not') {
+            onlyFields(value, ['op', 'condition'], errors, 'Condition');
+            predicate(value.condition);
+        } else if (value.op === 'exists') {
+            onlyFields(value, ['op', 'value'], errors, 'Condition');
+            operand(value.value);
+        } else if ('left' in value) {
+            onlyFields(value, ['op', 'left', 'right'], errors, 'Condition');
+            operand(value.left);
+            operand(value.right);
+        }
+    };
+    const bindings = (values: (WorkflowFlowBinding | WorkflowInputBinding)[]) => values.forEach((binding) => {
+        if (!isFlowBinding(binding)) {
+            errors.push('Structured task inputs require explicit node-output bindings.');
+            return;
+        }
+        onlyFields(binding, ['name', 'source', 'required', 'expected_kind', 'allow_partial'], errors, 'Input');
+        onlyFields(binding.source, ['kind', 'node_id', 'output', 'scope'], errors, 'Input source');
+    });
+    const walk = (region: WorkflowFlowRegion, root = false) => {
+        onlyFields(region, root ? ['id', 'nodes', 'outputs'] : ['id', 'nodes'], errors, 'Region');
+        bindings(region.outputs ?? []);
+        region.nodes.forEach((node) => {
+            if (node.kind === 'task') {
+                onlyFields(node, ['id', 'kind', 'task_id', 'run_when'], errors, 'Task node');
+                if (node.run_when) predicate(node.run_when);
+            } else {
+                bindings(node.inputs);
+                predicate(node.condition);
+                if (node.kind === 'route') {
+                    onlyFields(node, ['id', 'kind', 'inputs', 'condition', 'target'], errors, 'Route');
+                    onlyFields(node.target, 'node_id' in node.target ? ['node_id'] : ['exit_region_id'], errors, 'Route target');
+                } else {
+                    onlyFields(node, ['id', 'kind', 'inputs', 'condition', 'then', 'else', 'join'], errors, 'If/else');
+                    onlyFields(node.join, ['id', 'exports'], errors, 'Join');
+                    node.join.exports.forEach((item) => {
+                        onlyFields(item, ['name', 'expected_kind', 'required', 'then', 'else'], errors, 'Join output');
+                        onlyFields(item.then, ['node_id', 'output'], errors, 'Join source');
+                        onlyFields(item.else, ['node_id', 'output'], errors, 'Join source');
+                    });
+                    walk(node.then);
+                    walk(node.else);
+                }
+            }
+        });
+    };
+    walk(workflow.flow, true);
+    workflow.tasks.forEach((task) => {
+        onlyFields(task, [
+            'id', 'type', 'name', 'instructions', 'order', 'runner', 'document_action', 'inputs',
+            'reference_ids', 'output_contract', 'approval', 'publication',
+        ], errors, 'Task configuration');
+        onlyFields(task.runner, ['type', 'selected_agent', 'model_endpoint_id', 'model_id', 'model_provider', 'model_binding_summary'], errors, 'Task runner');
+        bindings(task.inputs ?? []);
+    });
+    if (isRecord(workflow.limits)) onlyFields(workflow.limits, ['max_executions', 'deadline_seconds'], errors, 'Run limits');
+    return errors[0] ?? '';
+}
+
+interface Availability {
+    possible: Set<string>;
+    definite: Set<string>;
+}
+
+function combineAvailability(paths: Availability[]): Availability {
+    const possible = new Set(paths.flatMap((path) => [...path.possible]));
+    const definite = new Set(paths[0]?.definite ?? []);
+    paths.forEach((path) => definite.forEach((id) => { if (!path.definite.has(id)) definite.delete(id); }));
+    return { possible, definite };
+}
+
+function withProducer(available: Availability, id: string, definite: boolean): Availability {
+    return {
+        possible: new Set([...available.possible, id]),
+        definite: new Set([...available.definite, ...(definite ? [id] : [])]),
+    };
+}
+
+export interface WorkflowFlowAnalysis {
+    errors: string[];
+    available: Map<string, Set<string>>;
+    branchEnds: Map<string, Set<string>>;
+}
+
+export function analyzeWorkflowFlow(workflow: WorkflowDefinition): WorkflowFlowAnalysis {
+    const errors: string[] = [];
+    const available = new Map<string, Set<string>>();
+    const branchEnds = new Map<string, Set<string>>();
+    const result = { errors, available, branchEnds };
+    if (workflow.definition_version !== 3) return result;
+    const unsupported = flowUnsupportedReason(workflow);
+    if (unsupported || !isFlowRegion(workflow.flow)) {
+        errors.push(unsupported || 'Structured control flow is required.');
+        return result;
+    }
+    if (workflow.durable_execution !== true) errors.push('Structured control flow requires durable execution.');
+    const producers = new Map(flowProducers(workflow).map((producer) => [producer.id, producer]));
+    const tasks = new Map(workflow.tasks.map((task) => [task.id, task]));
+    const usedTasks = new Set<string>();
+    const ids = new Set<string>();
+    const root = workflow.flow;
+    const register = (id: string) => {
+        if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(id)) errors.push('Flow IDs must use letters, digits, dots, colons, underscores or hyphens, up to 128 characters.');
+        if (ids.has(id)) errors.push(`Flow ID ${id} is duplicated.`);
+        ids.add(id);
+    };
+    const shape = (region: WorkflowFlowRegion, depth: number) => {
+        register(region.id);
+        if (depth > FLOW_MAX_DEPTH) errors.push(`Structured flow supports at most ${FLOW_MAX_DEPTH} nested regions.`);
+        region.nodes.forEach((node) => {
+            register(node.id);
+            if (node.kind === 'task') {
+                if (!tasks.has(node.task_id)) errors.push(`Node ${node.id} references a missing task.`);
+                if (usedTasks.has(node.task_id)) errors.push('Each task configuration must appear exactly once in the flow.');
+                usedTasks.add(node.task_id);
+            } else if (node.kind === 'if') {
+                register(node.join.id);
+                shape(node.then, depth + 1);
+                shape(node.else, depth + 1);
+            }
+        });
+    };
+    shape(root, 1);
+    if (ids.size > FLOW_MAX_NODES) errors.push(`Structured flow supports at most ${FLOW_MAX_NODES} IDs.`);
+    if (workflow.tasks.some((task) => !usedTasks.has(task.id))) errors.push('Every task configuration must be placed in the flow.');
+    const checkSource = (source: WorkflowJoinSource, required: boolean, state: Availability, label: string, expected: WorkflowOutputKind) => {
+        const producer = producers.get(source.node_id);
+        const output = producer?.outputs.find((item) => item.name === source.output);
+        if (!producer || !output) {
+            errors.push(`${label} selects a missing producer or undeclared output.`);
+            return;
+        }
+        if (!state.possible.has(source.node_id)) errors.push(`${label} must select an earlier, reachable producer in this scope.`);
+        if (required && (!state.definite.has(source.node_id) || !output.required)) {
+            errors.push(`${label} requires an output that can be skipped. Use an optional input or a required branch-join output.`);
+        }
+        if (expected !== 'any' && output.kind !== 'any' && output.kind !== expected &&
+            !(expected === 'json' && ['records', 'document_results'].includes(output.kind))) {
+            errors.push(`${label} has an expected kind that disagrees with its producer.`);
+        }
+    };
+    const checkBindings = (bindings: WorkflowFlowBinding[], state: Availability, label: string) => {
+        const names = new Set<string>();
+        bindings.forEach((binding) => {
+            if (!FLOW_ALIAS_PATTERN.test(binding.name)) errors.push(`${label} needs valid input aliases (letter first, up to 64 letters, digits, underscores or dashes).`);
+            if (names.has(binding.name)) errors.push(`${label} has duplicate input aliases.`);
+            names.add(binding.name);
+            checkSource(binding.source, binding.required, state, `${label}: ${binding.name || 'input'}`, binding.expected_kind);
+        });
+    };
+    const checkPredicate = (condition: WorkflowPredicate, bindings: WorkflowFlowBinding[], label: string) => {
+        let count = 0;
+        const operand = (value: WorkflowOperand, scalar = true): string[] => {
+            if ('literal' in value) {
+                if (typeof value.literal === 'number' && !Number.isFinite(value.literal)) errors.push(`${label} requires finite numeric values.`);
+                return [value.literal === null ? 'null' : typeof value.literal];
+            }
+            const binding = bindings.find((input) => input.name === value.input);
+            if (!binding) errors.push(`${label} references an input that has not been bound.`);
+            if (value.path !== '' && (!value.path.startsWith('/') || /~(?:[^01]|$)/.test(value.path))) {
+                errors.push(`${label} needs a valid JSON pointer for its field.`);
+            }
+            if (binding) {
+                const output = producers.get(binding.source.node_id)?.outputs.find((item) => item.name === binding.source.output);
+                if (!output?.schema) errors.push(`${label} must select a schema-validated producer field.`);
+                else {
+                    const field = workflowSchemaAtPointer(output.schema, value.path);
+                    if (!field) errors.push(`${label} references a field that is not declared in its producer's schema.`);
+                    const types = field && (Array.isArray(field.type) ? field.type : [field.type]);
+                    if (types?.every((type): type is string => typeof type === 'string')) {
+                        if (scalar && types.some((type) => !['string', 'number', 'integer', 'boolean', 'null'].includes(type))) {
+                            errors.push(`${label} must compare scalar fields, not whole objects or collections.`);
+                        }
+                        return types;
+                    }
+                }
+            }
+            return [];
+        };
+        const walk = (predicate: WorkflowPredicate, depth: number) => {
+            count++;
+            if (depth > FLOW_MAX_PREDICATE_DEPTH) {
+                errors.push(`${label} exceeds the condition nesting limit.`);
+                return;
+            }
+            if (predicate.op === 'all' || predicate.op === 'any') {
+                if (!predicate.conditions.length) errors.push(`${label} needs at least one condition.`);
+                predicate.conditions.forEach((child) => walk(child, depth + 1));
+            } else if (predicate.op === 'not') {
+                walk(predicate.condition, depth + 1);
+            } else if (predicate.op === 'exists') {
+                count++;
+                if (!('input' in predicate.value)) errors.push(`${label} existence checks require an input field.`);
+                operand(predicate.value, false);
+            } else if ('left' in predicate) {
+                count += 2;
+                const leftTypes = operand(predicate.left);
+                const rightTypes = operand(predicate.right);
+                if (['lt', 'lte', 'gt', 'gte'].includes(predicate.op) &&
+                    [leftTypes, rightTypes].some((types) => types.length && !types.some((type) => type === 'number' || type === 'integer'))) {
+                    errors.push(`${label} numeric comparisons require numeric fields and values.`);
+                }
+            }
+        };
+        walk(condition, 1);
+        if (count > FLOW_MAX_PREDICATE_NODES || JSON.stringify(condition).length > 16384) errors.push(`${label} exceeds the condition size limit.`);
+    };
+    const walk = (region: WorkflowFlowRegion, incoming: Availability): Availability => {
+        const inputs = new Map<number, Availability[]>();
+        const exits: Availability[] = [];
+        let current = incoming;
+        region.nodes.forEach((node, index) => {
+            current = combineAvailability([current, ...(inputs.get(index) ?? [])]);
+            available.set(node.id, new Set(current.possible));
+            if (node.kind === 'task') {
+                const task = tasks.get(node.task_id);
+                if (!task) return;
+                const bindings = (task.inputs ?? []).filter(isFlowBinding);
+                checkBindings(bindings, current, task.name || node.id);
+                if (task.publication) {
+                    if (bindings.length !== 1) errors.push(`${task.name} publication requires exactly one explicit native Analyze input.`);
+                    if (!['md', 'csv', 'json'].includes(task.publication.artifact_format) ||
+                        !['personal', 'group', 'public'].includes(task.publication.workspace_scope)) {
+                        errors.push(`${task.name} publication needs a supported format and explicit destination.`);
+                    }
+                    if (task.publication.workspace_scope === 'group' && !task.publication.group_id?.trim() ||
+                        task.publication.workspace_scope === 'public' && !task.publication.public_workspace_id?.trim()) {
+                        errors.push(`${task.name} publication needs the destination workspace ID.`);
+                    }
+                    if (task.runner.type !== 'inherit' || task.document_action && task.document_action.type !== 'none') {
+                        errors.push(`${task.name} publication cannot invoke a model, agent, or document action.`);
+                    }
+                }
+                if (node.run_when) checkPredicate(node.run_when, bindings, `Run when for ${task.name || node.id}`);
+                current = withProducer(current, node.id, node.run_when === undefined);
+            } else {
+                checkBindings(node.inputs, current, node.id);
+                checkPredicate(node.condition, node.inputs, `Condition for ${node.id}`);
+                if (node.kind === 'route') {
+                    if ('exit_region_id' in node.target) {
+                        if (region.id === root.id || node.target.exit_region_id !== region.id) {
+                            errors.push(`Route ${node.id} can exit only its current branch region.`);
+                        } else exits.push(current);
+                    } else {
+                        const targetId = node.target.node_id;
+                        const target = region.nodes.findIndex((item) => item.id === targetId);
+                        if (target <= index) errors.push(`Route ${node.id} must target a later sibling; branch entry and backward routes are not allowed.`);
+                        else inputs.set(target, [...(inputs.get(target) ?? []), current]);
+                    }
+                } else {
+                    const thenEnd = walk(node.then, current);
+                    const elseEnd = walk(node.else, current);
+                    const names = new Set<string>();
+                    node.join.exports.forEach((item) => {
+                        if (!FLOW_ALIAS_PATTERN.test(item.name) || names.has(item.name)) errors.push(`Join ${node.join.id} needs unique, valid output names.`);
+                        names.add(item.name);
+                        checkSource(item.then, item.required, thenEnd, `Then output ${item.name}`, item.expected_kind);
+                        checkSource(item.else, item.required, elseEnd, `Else output ${item.name}`, item.expected_kind);
+                    });
+                    current = withProducer(current, node.join.id, true);
+                }
+            }
+        });
+        const end = combineAvailability([current, ...exits]);
+        branchEnds.set(region.id, end.possible);
+        return end;
+    };
+    const end = walk(root, { possible: new Set(), definite: new Set() });
+    available.set(root.id, end.possible);
+    checkBindings(root.outputs ?? [], end, 'Final outputs');
+    const limits = workflow.limits;
+    if (!isRecord(limits) || !Number.isInteger(limits.max_executions) ||
+        Number(limits.max_executions) < 1 || Number(limits.max_executions) > DEFAULT_FLOW_LIMITS.max_executions) {
+        errors.push('Execution limit must be a whole number from 1 to 5,000.');
+    }
+    if (!isRecord(limits) || !Number.isInteger(limits.deadline_seconds) ||
+        Number(limits.deadline_seconds) < 1 || Number(limits.deadline_seconds) > DEFAULT_FLOW_LIMITS.deadline_seconds) {
+        errors.push('Elapsed deadline must be a whole number from 1 to 86,400 seconds, including waits.');
+    }
+    result.errors = [...new Set(errors)];
+    return result;
+}
+
+export function predicateSummary(condition: WorkflowPredicate): string {
+    const operand = (value: WorkflowOperand) =>
+        'literal' in value ? JSON.stringify(value.literal) : `${value.input || 'Choose input'}${value.path.replaceAll('/', '.')}`;
+    if (condition.op === 'all' || condition.op === 'any') {
+        return condition.conditions.map(predicateSummary).join(condition.op === 'all' ? ' AND ' : ' OR ');
+    }
+    if (condition.op === 'not') return `NOT (${predicateSummary(condition.condition)})`;
+    if (condition.op === 'exists') return `${operand(condition.value)} exists`;
+    if ('left' in condition) {
+        const labels: Record<WorkflowComparison, string> = { eq: 'equals', ne: 'does not equal', lt: '<', lte: '<=', gt: '>', gte: '>=' };
+        return `${operand(condition.left)} ${labels[condition.op]} ${operand(condition.right)}`;
+    }
+    return '';
+}
+
+export function scalarSchemaFields(schema?: Record<string, unknown>): { path: string; type: string; values?: WorkflowScalar[] }[] {
+    const fields: { path: string; type: string; values?: WorkflowScalar[] }[] = [];
+    const walk = (value: Record<string, unknown>, path: string, depth: number) => {
+        if (depth > 12) return;
+        const types = Array.isArray(value.type) ? value.type : [value.type];
+        if (types.length && types.every((type) => ['boolean', 'number', 'integer', 'string', 'null'].includes(String(type)))) {
+            fields.push({
+                path, type: types.join(' | '),
+                ...(Array.isArray(value.enum) ? {
+                    values: value.enum.filter((item): item is WorkflowScalar =>
+                        item === null || typeof item === 'string' || typeof item === 'boolean' ||
+                        (typeof item === 'number' && Number.isFinite(item))),
+                } : {}),
+            });
+        }
+        if (isRecord(value.properties)) Object.entries(value.properties).forEach(([name, child]) => {
+            if (isRecord(child)) walk(child, `${path}/${name.replaceAll('~', '~0').replaceAll('/', '~1')}`, depth + 1);
+        });
+    };
+    if (schema) walk(schema, '', 0);
+    return fields;
+}
+
+function workflowSchemaAtPointer(schema: Record<string, unknown>, pointer: string): Record<string, unknown> | undefined {
+    if (pointer === '') return schema;
+    if (!pointer.startsWith('/') || /~(?:[^01]|$)/.test(pointer)) return undefined;
+    let current = schema;
+    for (const part of pointer.slice(1).split('/').map((value) => value.replaceAll('~1', '/').replaceAll('~0', '~'))) {
+        const next = current.type === 'array' && /^(0|[1-9]\d*)$/.test(part)
+            ? current.items : isRecord(current.properties) ? current.properties[part] : undefined;
+        if (!isRecord(next)) return undefined;
+        current = next;
+    }
+    return current;
+}
diff --git a/docs/admin/workflow.md b/docs/admin/workflow.md
index e75b44e59..306f8e5e6 100644
--- a/docs/admin/workflow.md
+++ b/docs/admin/workflow.md
@@ -80,6 +80,26 @@ Cosmos container is required.
 See [Trigger a workflow]({{ '/guides/trigger-a-workflow/' | relative_url }}) for
 the operator's approval, continuation, and cancellation workflow.
 
+### Structured control-flow budgets
+
+Version **0.261.116** adds an explicit definition-version-3 option in the V2
+List editor. It uses the existing personal/group permissions and requires
+durable execution; it does not introduce another global capability toggle.
+Existing ordered definitions retain their previous behavior.
+
+The existing **Workflow Task Limit** still caps authored tasks, not runtime
+admissions. A structured definition additionally stores a finite admission
+limit (default/maximum 5,000) and elapsed deadline (default/maximum 86,400
+seconds). Time spent waiting for approval or output counts toward that
+deadline. These limits survive restart and Resume. Exhaustion pauses the run
+without releasing it for overlapping scheduled runs; cancellation is required
+before starting a replacement.
+
+Conditions and joins are deterministic engine operations. Model input limits
+still come from the selected catalog/deployment, not the admission limit.
+See [Structured workflow control flow](../explanation/features/WORKFLOW_STRUCTURED_CONTROL_FLOW.md)
+for the supported If/else, Run when, and forward-routing scope.
+
 ## Common tasks
 
 1. **Pilot group workflows with one team.** Enable Group Workflows, turn on
diff --git a/docs/explanation/features/WORKFLOW_DURABLE_EXECUTION.md b/docs/explanation/features/WORKFLOW_DURABLE_EXECUTION.md
index 6655837a9..cb64d8c6c 100644
--- a/docs/explanation/features/WORKFLOW_DURABLE_EXECUTION.md
+++ b/docs/explanation/features/WORKFLOW_DURABLE_EXECUTION.md
@@ -4,6 +4,11 @@ Implemented in version: **0.261.111**
 
 Application version tracking: `application/single_app/config.py`.
 
+Structured control-flow integration in **0.261.116** adds an opt-in version-3
+definition and execution-scoped, paged journal records. The ordered version-2
+behavior described below remains supported. See
+[Structured workflow control flow](WORKFLOW_STRUCTURED_CONTROL_FLOW.md).
+
 ## Purpose
 
 Durable execution separates a workflow run from the browser request that
@@ -192,6 +197,7 @@ claim races, checkpoint integrity, pending outputs, and private-record
 visibility. Native V2 tests cover queued responses, run-memory/approval recovery
 after reload, and explicit decision permissions.
 
-No new Cosmos container, external workflow service, graph editor, or loop
-execution feature is required. General For each, Repeat until, branching and
-visual Flow authoring remain separate milestones.
+No new Cosmos container or external workflow service is required. Structured
+If/else, Run when, and restricted forward routing are available through the
+version-3 List editor. General For each, Repeat until, exact Collect, and visual
+Flow authoring remain later milestones.
diff --git a/docs/explanation/features/WORKFLOW_EXPLICIT_DATA_FLOW.md b/docs/explanation/features/WORKFLOW_EXPLICIT_DATA_FLOW.md
index 8a6e3cca6..c992a8e8e 100644
--- a/docs/explanation/features/WORKFLOW_EXPLICIT_DATA_FLOW.md
+++ b/docs/explanation/features/WORKFLOW_EXPLICIT_DATA_FLOW.md
@@ -4,6 +4,11 @@ Implemented in version: **0.261.108**
 
 The application version is tracked in `application/single_app/config.py`.
 
+Version-3 structured control flow was added in **0.261.116**. This page describes
+the retained ordered version-2 contract; v3 uses explicit node bindings and
+selected-path joins instead of an implicit previous-successful-task input.
+See [Structured workflow control flow](WORKFLOW_STRUCTURED_CONTROL_FLOW.md).
+
 ## Overview
 
 An ordered workflow can select the final output of a specific earlier task instead
diff --git a/docs/explanation/features/WORKFLOW_STRUCTURED_CONTROL_FLOW.md b/docs/explanation/features/WORKFLOW_STRUCTURED_CONTROL_FLOW.md
new file mode 100644
index 000000000..c47119b9b
--- /dev/null
+++ b/docs/explanation/features/WORKFLOW_STRUCTURED_CONTROL_FLOW.md
@@ -0,0 +1,267 @@
+# Structured workflow control flow
+
+Implemented in version: **0.261.116**
+
+Application version tracking: `application/single_app/config.py`.
+
+## Purpose and scope
+
+Structured workflows choose a path from validated data instead of relying on a
+model to describe what should happen next. Milestone 4A adds **If/else**, task
+**Run when**, explicit branch joins, and restricted forward routing to the
+personal and group V2 List editor.
+
+This is useful when an assessment should produce either an explanation or a
+review, when an optional task should run only for particular findings, or when
+a known later step can safely replace optional intermediate work.
+
+For each, Repeat until, exact Collect, generic aggregate publication, and the
+visual Flow editor are not part of this slice. The execution identity and
+paged journal are prepared for repeated execution; M4A does not admit loops.
+
+## Dependencies and compatibility
+
+Structured control flow uses the existing workflow runner, durable execution
+lease, private result store, source-authorized readers, native Analyze adapter,
+and artifact publication service. No second scheduler, Cosmos container, or
+external browser library is introduced.
+
+Definition version **3** is an explicit opt-in and requires durable execution.
+Existing version-1 and version-2 definitions keep their previous behavior.
+Opening or editing an ordered workflow does not automatically convert it.
+Classic can still run and cancel durable workflows; advanced editing requires
+V2, and Classic refuses to open an advanced definition in its reduced editor.
+
+## Author a structured workflow
+
+1. Open `/v2/workspace/workflows`, or select the owning group under `/v2/groups`.
+2. Create a workflow or open an existing draft. Choose **Enable structured
+   control flow**, then **Convert draft**. Nothing is persisted until **Save
+   workflow**.
+3. On the decision-producing task, choose a JSON output contract. Under
+   **Structured decision fields**, add a Boolean such as `pass`, a number, or
+   an enum. The task's instructions should request those fields in its final
+   JSON object.
+4. Add **If/else** after that producer. Bind its saved JSON output under a
+   named input, then choose the field, comparison, and typed value.
+5. Add tasks inside **Then** and **Else**. Under **Join outputs**, name the
+   result that later tasks need and select the exact producer/output for each
+   path.
+6. Bind later tasks to the named join output. Declare any promised deliverable
+   under **Final outputs** so the run cannot complete without it.
+
+For example, an evaluation can return `{"pass": true, "add_note": false}`.
+An If/else condition reads `decision.pass`, selects an explanation or review,
+and exports the selected text as `report`. A later task consumes that report,
+not the last message that happened to be written.
+
+Conversion makes legacy automatic inputs explicit. A continue-on-error
+workflow with automatic previous-successful inputs must choose explicit inputs
+before conversion: selecting one fixed predecessor would otherwise change its
+failure behavior. Shared references and the first task's legacy document action
+are retained explicitly.
+
+### Skip an optional task
+
+Enable **Run when** on the task and select a condition using its named inputs.
+A false condition records an intentional skip before approval, Analyze
+preparation, or model/tool invocation. A skipped task produces no result.
+
+If a later task consumes that output, mark the binding optional or supply a
+required branch-join output instead. Required bindings cannot silently consume
+a different reply. Removing or moving a producer retains existing bindings and
+shows dependency errors rather than retargeting them.
+
+### Route forward
+
+Add **Forward route**, bind its condition inputs, and choose a later sibling
+under **Route when true**. Within a branch, the route can instead exit that
+branch to its join. False continues to the next node.
+
+Backward routes, entry into another branch, unmatched region crossings, and
+bypasses that remove a required input are rejected. Routing is not a substitute
+for a loop, and a model cannot supply a destination ID.
+
+## Definition contract
+
+The version-3 `tasks` array is a catalogue of existing authorized task
+configurations. `flow` is the only executable ordering and nesting structure.
+Each task configuration appears in exactly one logical task node. Derived
+indexes are not a second stored graph.
+
+| Structure | Authored fields |
+| --- | --- |
+| Root region | `id`, ordered `nodes`, and final `outputs` bindings |
+| Branch region | `id` and ordered `nodes` |
+| Task node | `id`, `kind: "task"`, `task_id`, optional `run_when` |
+| If/else node | `id`, `kind: "if"`, `inputs`, `condition`, `then`, `else`, `join` |
+| Join | Stable `id` and named `exports`, each selecting a Then and Else producer/output |
+| Forward route | `id`, `kind: "route"`, `inputs`, `condition`, `target` |
+| Route target | A later sibling `node_id`, or the current branch's `exit_region_id` |
+
+A version-3 binding is explicit:
+
+```json
+{
+  "name": "decision",
+  "source": {
+    "kind": "node_output",
+    "node_id": "evaluate",
+    "output": "json",
+    "scope": "current"
+  },
+  "required": true,
+  "expected_kind": "json",
+  "allow_partial": false
+}
+```
+
+Missing inputs normalize to an empty list; `null` is not a version-3 automatic
+input mode. Version-1 and version-2 omitted/null predecessor behavior remains
+unchanged. Definitions cannot supply result-store references or choose another
+run's execution.
+
+The server validates versions, executable fields, node kinds, unique IDs,
+region depth, routing, and producer availability. Advanced saves retain the
+existing definition-revision and active-run protections.
+
+## Condition semantics
+
+The bounded language supports `exists`, `eq`, `ne`, `lt`, `lte`, `gt`, `gte`,
+`all`, `any`, and `not`. Operands select a named input field using a JSON
+pointer or declare a finite scalar literal. Normal authoring uses controls,
+not an expression or JSON editor.
+
+Equality does not coerce strings, numbers, or booleans. Numeric ordering
+requires numbers. Missing is different from null: `exists` is true for a
+present null value. An unguarded missing field is an error; use an existence
+guard when absence is allowed. `all` and `any` evaluate in authored order and
+short-circuit.
+
+Authorization and output eligibility precede predicate evaluation. Revoked
+source access, invalid results, and pending producers cannot become optional
+absence. Partial data needs explicit acceptance and retains its limitations.
+Human approval cannot make invalid or unfinished output eligible.
+
+Output schema validity is not factual correctness. Analyze producer validation
+and workflow output requirements remain separate. Ordinary model prose such
+as "PASS" or "complete" is never an engine command.
+
+## Durable execution and results
+
+A saved branch/skip/routing decision includes its input digest and exact
+consumption references before the next task begins. Resume reauthorizes saved
+inputs and follows that decision. Changed sources cannot silently change the
+selected path.
+
+New structured results use `workflow-result-v2`. Their identity contains the
+workflow, run, logical node, server-derived `execution_id`, `iteration_path`,
+and attempt. Real task results also retain `task_id`; engine results do not
+invent task IDs. M4A iteration paths are empty.
+
+Retries retain the execution ID and advance the attempt. Approval and recovery
+decisions bind the exact execution, attempt, gate, definition, and input
+digest. Receipts retain the actual producer and representation. Branch-control
+provenance remains part of the access boundary.
+
+The versioned runtime control row keeps bounded state, while execution,
+attempt, and decision records are paged in the existing run partition.
+Writes use the existing lease and conditional-write fence. Native Analyze
+also retains its producer/work-unit fence. Private rows are not ordinary
+history items, and deletion preserves lifecycle tombstones.
+
+## Limits and inspection
+
+| Limit | M4A policy |
+| --- | --- |
+| Authored tasks | Existing administrator setting: default 50, supported range 1-100 |
+| Structural IDs | At most 256 |
+| Nested flow depth | At most 4 |
+| Predicate size | At most 100 nodes, depth 8, and 16 KiB |
+| Execution admissions | Default/maximum 5,000; includes retries, not result-chunk writes |
+| Elapsed deadline | Default/maximum 86,400 seconds, including waits |
+| Model input | Existing effective catalog/deployment budget; complete required input is never clipped |
+
+Run history distinguishes selected paths, intentionally skipped nodes, output
+validation, attempts, and exact consumed-result receipts. Large execution and
+decision histories are paginated. Full result content is requested separately;
+a byte-range excerpt is a display transport, not a complete-record iterator.
+
+Completion checks selected-path obligations and required final outputs, not
+whether every authored branch ran. Accepted partial work remains
+`completed_partial`. Exhausted limits and missing required results do not
+become Completed.
+
+## Publication boundary
+
+Existing publication tasks use the existing artifact publication service and
+destination ledger. In a structured workflow, publication selects its exact
+upstream producer explicitly instead of searching whichever task happened to
+finish most recently. Source and destination permissions are checked again.
+
+An acknowledgment retry reuses the publication identity. It must not create a
+second document or duplicate approval notifications. Existing `queued`,
+`pending_approval`, `approved`, `approval_failed`, and `uncertain` states retain
+their meanings; none is a new promise that indexing has completed.
+
+New processing/index-readiness policies and publication adapters for generic
+aggregates belong to later milestone-4 slices.
+
+## Regression coverage and boundaries
+
+The existing isolated workflow definition, runtime, result, Analyze, and
+publication suites provide the backend regression boundaries. Browser coverage
+uses the real locally built V2 SPA and closed API fixtures, including production
+definition validation.
+
+`ui_tests/test_v2_workflow_control_flow.py` covers normal control authoring,
+joins, skipped dependencies, retained conflict drafts, unsupported definitions,
+explicit conversion, group scope, and keyboard/mobile editing.
+`ui_tests/test_workflow_classic_advanced_guard.py` exercises the actual Classic
+edit guard without loading runners or changing drafts.
+
+`functional_tests/test_workflow_structured_flow.py` covers persisted path
+decisions, exact identities, selected joins, skip/routing behavior, more than
+1,000 paged journal records, cancellation/deletion fences, and complete
+consumption lineage beyond 256 ancestors.
+`functional_tests/test_workflow_structured_edges.py` covers real save
+round-trips, limits, missing/null predicates, frozen shared references, gate
+source checks, invalid-output inspection, and complete paged per-document
+outputs retaining their `document_results` type in legacy and structured reads.
+`functional_tests/test_workflow_structured_publication.py` passes genuine native
+Analyze records through a saved join and the existing publication service,
+including restart without duplicate publication and later source revocation.
+
+Local regression fixtures do not deploy the application, run private production
+workflows, or publish documents. Live acceptance requires a separately
+authorized deployment matching the integrated code.
+
+## API and implementation
+
+Existing save, run, cancellation, and gate-decision endpoints remain in use.
+Editor options advertise supported definition versions and node kinds. Saves
+retain `definition_revision` concurrency protection; runtime `version` remains
+the mutable gate-decision revision, separate from runtime `schema_version`.
+
+Structured run inspection adds these authorized read paths:
+
+```text
+GET /api/user/workflows/<workflow_id>/runs/<run_id>/executions
+GET /api/user/workflows/<workflow_id>/runs/<run_id>/executions/<execution_id>/attempts
+GET /api/user/workflows/<workflow_id>/runs/<run_id>/executions/<execution_id>/attempts/<attempt>/result
+GET /api/user/workflows/<workflow_id>/runs/<run_id>/runtime/decisions
+```
+
+Group paths replace `user` with `group` and use the existing explicit `group_id`
+query parameter. History pages accept `cursor` and a bounded `limit`; they
+return the named collection and `next_cursor`. Result pages retain byte offsets,
+digests, and complete/partial transport indicators. No endpoint accepts a
+caller-provided result-store locator.
+
+`functions_workflow_flow.py` validates the canonical structure and typed
+predicates. `functions_workflow_flow_runner.py` traverses it around the existing
+task dispatcher. `functions_workflow_identity.py`, `functions_workflow_journal.py`,
+and `functions_workflow_structured_execution.py` provide exact identities and
+fenced checkpoints. `functions_workflow_node_results.py` and
+`functions_workflow_execution_history.py` share source-authorized result and
+inspection boundaries.
diff --git a/docs/guides/create-a-workflow.md b/docs/guides/create-a-workflow.md
index 94e519e83..d1b774f56 100644
--- a/docs/guides/create-a-workflow.md
+++ b/docs/guides/create-a-workflow.md
@@ -51,6 +51,33 @@ draft instead of overwriting another editor's changes.
 See [Explicit workflow data flow](../explanation/features/WORKFLOW_EXPLICIT_DATA_FLOW.md)
 for binding semantics, shared references, and validation outcomes.
 
+## Choose branches and optional work
+
+In **0.261.116**, **Enable structured control flow** explicitly converts a V2
+draft to definition version 3. Existing workflows stay ordered unless you
+choose this conversion; nothing is persisted until **Save workflow**.
+
+Use a JSON output contract with **Structured decision fields** when a task
+must supply a Boolean, number, or enum for a decision. Add **If/else**, bind
+that saved output by name, and choose the field and comparison. Put the
+appropriate tasks in **Then** and **Else**, then configure **Join outputs**
+to give later tasks one explicit result from the selected path.
+
+**Run when** skips a task when its condition is false. A skipped task produces
+no output, so downstream consumers need an optional binding or a required join
+output. **Forward route** may bypass optional work only by selecting a later
+sibling or exiting the current branch to its join. Invalid dependencies are
+shown before saving; moving a block never silently changes its input source.
+
+Declare promised deliverables under **Final outputs**. This prevents a run from
+reporting completion when a selected path did not produce the required result.
+Structured definitions require durable execution and preserve their choices
+across waits and restarts. For each, Repeat until, Collect, and the visual Flow
+editor are not included in this slice.
+
+See [Structured workflow control flow](../explanation/features/WORKFLOW_STRUCTURED_CONTROL_FLOW.md)
+for condition semantics, execution identity, limits, and compatibility.
+
 ## Durable execution and task approval
 
 Starting in **0.261.111**, new V2 workflows enable **Durable execution**.
diff --git a/docs/guides/trigger-a-workflow.md b/docs/guides/trigger-a-workflow.md
index e8a6b66d3..3c716c84e 100644
--- a/docs/guides/trigger-a-workflow.md
+++ b/docs/guides/trigger-a-workflow.md
@@ -72,6 +72,24 @@ Classic workflows remain synchronous unless opted in. Classic can run and cancel
 durable definitions, but V2 provides their approval, checkpoint-resume, and
 memory controls. See [Durable workflow execution](../explanation/features/WORKFLOW_DURABLE_EXECUTION.md).
 
+## Inspect a structured path
+
+For definition-version-3 workflows introduced in **0.261.116**, inspect the
+selected If/else path and each task's skip reason before interpreting a missing
+output as a failure. A false **Run when**, an unselected branch, and a validated
+forward route are intentional skips; they do not create empty successful
+results.
+
+Execution and attempt identities distinguish the exact result and approval
+being inspected. Use the paged execution/decision views rather than treating
+the task name or the latest reply as the producer identity. Result excerpts
+load separately and remain subject to current source permissions.
+
+Required final outputs and selected-path work determine completion. A budget
+or deadline limit cannot be cleared by a normal Resume, and changing source
+data cannot silently choose a different branch. See
+[Structured workflow control flow](../explanation/features/WORKFLOW_STRUCTURED_CONTROL_FLOW.md).
+
 ## Troubleshooting
 
 | Symptom | Likely cause | Fix |
diff --git a/functional_tests/route_tests/test_workflow_execution_journal_policy.py b/functional_tests/route_tests/test_workflow_execution_journal_policy.py
new file mode 100644
index 000000000..8444e7873
--- /dev/null
+++ b/functional_tests/route_tests/test_workflow_execution_journal_policy.py
@@ -0,0 +1,120 @@
+# test_workflow_execution_journal_policy.py
+"""
+Structured workflow execution API policy and exact result regression coverage.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+Production route helpers and journal readers execute with isolated Flask request
+contexts and the shared transactional workflow fake, never a live application.
+"""
+
+import ast
+import logging
+import sys
+from pathlib import Path
+
+import pytest
+from azure.core.exceptions import AzureError
+from azure.cosmos.exceptions import CosmosResourceNotFoundError
+from flask import Flask, jsonify, request
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT / "application" / "single_app"))
+sys.path.insert(0, str(ROOT / "functional_tests"))
+
+# Production and shared fixtures follow the worktree import setup.
+from functions_analysis_access import AnalysisResultUnavailable
+from functions_workflow_execution_history import workflow_execution_history, workflow_execution_result_page
+from functions_workflow_result_store import WorkflowResultStorageUnavailableError
+from functions_workflow_runtime_store import RuntimeUnavailable, WorkflowRuntimeConflict
+from test_workflow_structured_flow import runtime, run_flow
+
+
+ROUTES = ROOT / "application" / "single_app" / "route_backend_workflows.py"
+
+
+def test_all_eight_execution_routes_retain_blueprint_and_swagger_security():
+    tree = ast.parse(ROUTES.read_text(encoding="utf-8"))
+    registrar = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "register_route_backend_workflows")
+    routes = []
+    for node in registrar.body:
+        if not isinstance(node, ast.FunctionDef) or not node.decorator_list:
+            continue
+        route = node.decorator_list[0]
+        path = route.args[0].value
+        if "/executions" not in path and not path.endswith("/runtime/decisions"):
+            continue
+        routes.append(path)
+        assert isinstance(route.func, ast.Attribute) and route.func.value.id == "bp"
+        assert ast.unparse(node.decorator_list[1]) == "swagger_route(security=get_auth_security())"
+        decorators = [ast.unparse(value) for value in node.decorator_list]
+        assert "login_required" in decorators and "user_required" in decorators
+        assert any("enabled_required" in value for value in decorators)
+        if "/user/" in path:
+            assert "workflow_user_required" in decorators
+    assert len(routes) == 8
+
+
+@pytest.fixture
+def api(runtime, monkeypatch):
+    workflow, store, _, _ = runtime
+    flow, _ = run_flow(workflow, store)
+    monkeypatch.setattr("functions_workflow_execution_history.workflow_runtime_store", lambda *args: store)
+    access = {"group": True, "owner": True}
+
+    def group_scope(user):
+        if not access["group"]:
+            raise PermissionError
+        return "group", {}
+
+    namespace = {
+        "get_current_user_id": lambda: "owner", "jsonify": jsonify, "request": request, "logging": logging,
+        "get_personal_workflow": lambda user, key: workflow if access["owner"] and key == workflow["id"] else None,
+        "get_group_workflow": lambda group, key: workflow if key == workflow["id"] else None,
+        "get_personal_workflow_run": lambda user, run: {"id": run, "workflow_id": workflow["id"]} if run == "run" else None,
+        "get_group_workflow_run": lambda group, run: {"id": run, "workflow_id": workflow["id"]} if run == "run" else None,
+        "_resolve_group_workflow_request_group": group_scope,
+        "workflow_execution_history": workflow_execution_history,
+        "workflow_execution_result_page": workflow_execution_result_page,
+        "WorkflowRuntimeConflict": WorkflowRuntimeConflict, "RuntimeUnavailable": RuntimeUnavailable,
+        "AnalysisResultUnavailable": AnalysisResultUnavailable,
+        "WorkflowResultStorageUnavailableError": WorkflowResultStorageUnavailableError,
+        "AzureError": AzureError, "CosmosResourceNotFoundError": CosmosResourceNotFoundError,
+        "log_event": lambda *args, **kwargs: None,
+    }
+    function = next(node for node in ast.parse(ROUTES.read_text(encoding="utf-8")).body
+                    if isinstance(node, ast.FunctionDef) and node.name == "_workflow_execution_history_response")
+    exec(compile(ast.Module(body=[function], type_ignores=[]), str(ROUTES), "exec"), namespace)
+    app = Flask("structured-history")
+    app.add_url_rule("/<scope>/<workflow_id>/<run_id>/<kind>", endpoint="history", view_func=lambda scope, workflow_id, run_id, kind:
+                     namespace["_workflow_execution_history_response"](workflow_id, run_id, group=scope == "group", kind=kind))
+    app.add_url_rule("/result/<execution_id>/<int:attempt>", endpoint="result", view_func=lambda execution_id, attempt:
+                     namespace["_workflow_execution_history_response"]("workflow", "run", execution_id=execution_id, attempt=attempt))
+    return app.test_client(), access, flow
+
+
+def test_safe_paging_and_exact_attempt_result_routes(api):
+    client, access, flow = api
+    page = client.get("/user/workflow/run/execution?limit=2")
+    assert page.status_code == 200 and len(page.json["executions"]) == 2
+    assert page.json["total_count"] == 6 and page.json["next_cursor"]
+    assert "token" not in page.get_data(as_text=True)
+    identity = flow.final_outputs[0]["producer"]
+    response = client.get(f"/result/{identity['execution_id']}/1?limit=2000")
+    assert response.status_code == 200 and response.json["output_name"] == "text"
+    assert client.get(f"/result/{identity['execution_id']}/2").status_code == 404
+    assert client.get("/result/" + "f" * 64 + "/1").status_code == 404
+    join = flow.completed["joined"]["summary"]["producer"]
+    join_page = client.get(f"/result/{join['execution_id']}/1?output=answer")
+    assert join_page.status_code == 200 and join_page.json["output_name"] == "answer"
+
+
+def test_cursors_ranges_and_current_object_authorization_fail_closed(api):
+    client, access, _ = api
+    assert client.get("/user/workflow/run/execution?limit=101").status_code == 400
+    assert client.get("/user/workflow/run/execution?cursor=forged").status_code == 400
+    assert client.get("/user/workflow/other-run/execution").status_code == 404
+    access["owner"] = False
+    assert client.get("/user/workflow/run/execution").status_code == 404
+    access["group"] = False
+    assert client.get("/group/workflow/run/execution").status_code == 403
diff --git a/functional_tests/test_analyze_workflow_publication_integration.py b/functional_tests/test_analyze_workflow_publication_integration.py
index 957d8b76b..222fb1938 100644
--- a/functional_tests/test_analyze_workflow_publication_integration.py
+++ b/functional_tests/test_analyze_workflow_publication_integration.py
@@ -1,7 +1,7 @@
 # test_analyze_workflow_publication_integration.py
 """
 Analyze -> save -> reload -> explain -> optional publish in one workflow run.
-Version: 0.261.109
+Version: 0.261.116
 Implemented in: 0.261.109
 
 The native adapter, section contract, task sequence, model consumer, artifact
@@ -203,7 +203,7 @@ def test_unknown_publication_acknowledgement_is_explicit_and_not_recreated(seque
 
 def test_native_source_revocation_blocks_saved_report_and_publication(sequence):
     sequence.native.state["allowed"] = False
-    with pytest.raises(RuntimeError, match="input could not be resolved"):
+    with pytest.raises(RuntimeError, match="source access could not be confirmed"):
         execute(sequence)
     assert sequence.model_calls == []
     assert all(not values for values in sequence.publishing.calls.values())
diff --git a/functional_tests/test_workflow_definition_data_flow.py b/functional_tests/test_workflow_definition_data_flow.py
index 941523953..bd10ebdfc 100644
--- a/functional_tests/test_workflow_definition_data_flow.py
+++ b/functional_tests/test_workflow_definition_data_flow.py
@@ -1,7 +1,7 @@
 # test_workflow_definition_data_flow.py
 """
 Functional tests for versioned workflow authoring and stable data-flow bindings.
-Version: 0.261.108
+Version: 0.261.116
 Implemented in: 0.261.108
 
 These tests cover stale saves, V1 protection, task ordering, scoped reference
@@ -174,7 +174,7 @@ def test_native_update_does_not_change_an_active_run_definition():
         normalize(payload, existing)
 
 
-@pytest.mark.parametrize("version", [True, 0, 3, "2", None])
+@pytest.mark.parametrize("version", [True, 0, 4, "2", None])
 def test_unsupported_version_never_downgrades(version):
     payload = definition()
     payload["definition_version"] = version
diff --git a/functional_tests/test_workflow_runtime_integration.py b/functional_tests/test_workflow_runtime_integration.py
index 09340517b..e1407595a 100644
--- a/functional_tests/test_workflow_runtime_integration.py
+++ b/functional_tests/test_workflow_runtime_integration.py
@@ -1,7 +1,7 @@
 # test_workflow_runtime_integration.py
 """
 Functional tests for durable submission and the actual workflow runner.
-Version: 0.261.111
+Version: 0.261.116
 Implemented in: 0.261.111
 
 Queue, recreated worker, task checkpoint, approval, and projections run through
@@ -176,6 +176,40 @@ def test_background_runner_completes_and_clears_the_active_pointer(integration):
     assert len(requests) == 2
 
 
+def test_structured_submission_and_real_runner_use_genuine_runtime_and_task_identities(integration, monkeypatch):
+    workflow, runner, services, make_store, clock, requests = integration
+    workflow.update(definition_version=3, flow={
+        "id": "root", "nodes": [
+            {"id": "extract-node", "kind": "task", "task_id": "extract"},
+            {"id": "consume-node", "kind": "task", "task_id": "consume"},
+        ], "outputs": [{"name": "answer", "source": {"kind": "node_output", "node_id": "consume-node"}}],
+    })
+    workflow["tasks"][0].update(inputs=[], output_contract={"kind": "records"})
+    workflow["tasks"][1]["inputs"] = [{
+        "name": "inventory", "source": {"kind": "node_output", "node_id": "extract-node", "output": "records"},
+    }]
+    container = make_store(workflow, "unused").container
+    services["definitions"].upsert_item(workflow)
+    monkeypatch.setattr("functions_workflow_result_store._configured_store", lambda *args, **kwargs: WorkflowResultStore(container))
+    runner.update({
+        "persist_workflow_task_result": lambda envelope, **kwargs: persist_workflow_task_result(envelope, **kwargs),
+        "authorize_workflow_task_result_read": authorize_workflow_task_result_read,
+    })
+    queued = runtime.queue_durable_workflow_run(workflow, actor_user_id="owner")
+    run_id = queued["run"]["id"]
+    assert queued["runtime"]["schema_version"] == 2
+    runtime.continue_durable_workflow_run(workflow, run_id)
+    record = services["runs"].read_item(item=run_id, partition_key="owner")
+    assert record["status"] == "completed" and len(requests) == 2
+    assert record["workflow_outputs"][0]["producer"]["node_id"] == "consume-node"
+    control = make_store(workflow, run_id).read()
+    assert control["units"] == {} and control["memory"] == {}
+    private_results = [item for item in container.items.values() if item.get("item_type") == "workflow_result_chunk"]
+    assert all(item.get("execution_id") and item.get("node_id") for item in private_results)
+    assert all(not str(item.get("task_id") or "").startswith("runtime:") for item in private_results)
+    assert services["load_workflow"]()["active_run_id"] == ""
+
+
 def test_submission_replay_after_completion_retains_the_original_snapshot(integration):
     workflow, runner, services, make_store, clock, requests = integration
     request_id = "442f2e0b-63ad-4347-8e73-1be93b4e6b61"
diff --git a/functional_tests/test_workflow_structured_edges.py b/functional_tests/test_workflow_structured_edges.py
new file mode 100644
index 000000000..d7355442f
--- /dev/null
+++ b/functional_tests/test_workflow_structured_edges.py
@@ -0,0 +1,258 @@
+# test_workflow_structured_edges.py
+"""
+Regression coverage for M4A schema, limits, source snapshots and exact gates.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+Exercises production code through isolated existing storage and dispatcher
+fixtures. No workflow, document, model or publication service is invoked live.
+"""
+
+import sys
+import json
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "application" / "single_app"))
+
+# Production helpers follow the worktree path setup.
+from functions_analysis_access import AnalysisResultUnavailable
+from functions_workflow_bindings import WorkflowInputError, load_workflow_reference
+from functions_workflow_definitions import WorkflowDefinitionError
+from functions_workflow_execution import WorkflowSuspended, workflow_execution_scope
+from functions_workflow_execution_history import workflow_execution_history
+from functions_workflow_flow import compile_workflow_flow, evaluate_predicate, normalize_predicate
+from functions_workflow_runtime_store import WorkflowRuntimeConflict, WorkflowRuntimeLease
+from functions_workflow_structured_execution import StructuredWorkflowExecution
+from test_workflow_definition_store_integration import load_group_store, load_personal_store
+from test_workflow_structured_flow import definition, runtime, run_flow  # noqa: F401
+from test_workflow_task_result_handoff import build_inventory_run
+from functions_workflow_results import authorize_workflow_task_result_read, persist_workflow_task_result
+from functions_workflow_results import (
+    _build_task_result, load_workflow_task_input, read_result_records,
+)
+from functions_workflow_identity import workflow_execution_id, workflow_node_identity
+from functions_workflow_node_results import load_workflow_node_input
+from functions_workflow_result_store import load_workflow_node_result
+from test_workflow_result_contract import SerializedSections
+
+
+@pytest.mark.parametrize("scope", ["personal", "group"])
+def test_v3_save_roundtrips_nested_limits_and_server_metadata(scope):
+    helpers, container, _ = load_group_store() if scope == "group" else load_personal_store()
+    payload = {
+        **definition(), "name": "Structured audit", "trigger_type": "manual",
+        "limits": {"max_executions": 17, "deadline_seconds": 900},
+    }
+    save = helpers["save_group_workflow"] if scope == "group" else helpers["save_personal_workflow"]
+    scope_id = "group-one" if scope == "group" else "owner"
+    saved = save(scope_id, payload, "owner")
+    key = (scope_id, saved["id"])
+    container.items[key]["metadata"] = {"retained": "existing non-executable settings"}
+    loaded = helpers["get_group_workflow" if scope == "group" else "get_personal_workflow"](scope_id, saved["id"])
+    updated = save(scope_id, {**loaded, "description": "Edited safely"}, "owner")
+    assert updated["limits"] == payload["limits"]
+    assert "max_executions" not in updated and "deadline_seconds" not in updated
+    assert updated["flow"] == saved["flow"] and updated["tasks"] == saved["tasks"]
+    assert updated["metadata"] == loaded["metadata"]
+    assert updated["created_at"] == saved["created_at"]
+    assert updated["definition_revision"] != saved["definition_revision"]
+    with pytest.raises(WorkflowDefinitionError):
+        save(scope_id, {**updated, "future_executable": {"jump": "unknown"}}, "owner")
+
+
+@pytest.mark.parametrize("change", [
+    {"limits": None}, {"limits": {"max_executions": False}},
+    {"limits": {"max_executions": 5001}}, {"limits": {"deadline_seconds": 0}},
+    {"limits": {"deadline_seconds": 1.5}}, {"limits": {"future_budget": 3}},
+    {"max_executions": 3}, {"deadline_seconds": 3},
+])
+def test_only_canonical_bounded_limits_are_accepted(change):
+    with pytest.raises(WorkflowDefinitionError):
+        compile_workflow_flow({**definition(), **change})
+
+
+def test_conditions_reject_undeclared_or_nonscalar_fields_and_wrong_numeric_types():
+    for field in ("/not_declared", ""):
+        workflow = definition()
+        workflow["flow"]["nodes"][1]["condition"]["left"]["path"] = field
+        with pytest.raises(WorkflowDefinitionError):
+            compile_workflow_flow(workflow)
+    workflow = definition()
+    workflow["flow"]["nodes"][1]["condition"]["op"] = "gt"
+    workflow["flow"]["nodes"][1]["condition"]["right"] = {"literal": 1}
+    with pytest.raises(WorkflowDefinitionError, match="numeric"):
+        compile_workflow_flow(workflow)
+
+
+@pytest.mark.parametrize("value,expected", [(None, False), (0, False), (4, True)])
+def test_null_guard_remains_distinct_from_missing_and_numeric_values(value, expected):
+    condition = normalize_predicate({
+        "op": "all", "conditions": [
+            {"op": "exists", "value": {"input": "data", "path": "/quantity"}},
+            {"op": "ne", "left": {"input": "data", "path": "/quantity"}, "right": {"literal": None}},
+            {"op": "gt", "left": {"input": "data", "path": "/quantity"}, "right": {"literal": 0}},
+        ],
+    }, [{"name": "data"}])
+    assert evaluate_predicate(condition, {"data": {"quantity": value}}) is expected
+    assert evaluate_predicate(condition, {"data": {}}) is False
+
+
+def test_shared_reference_snapshot_is_run_scoped_and_reauthorized_after_restart(runtime):
+    workflow, store, _, clock = runtime
+    reference = {"id": "criteria", "name": "criteria", "document_id": "source", "scope_type": "personal", "scope_id": "owner"}
+    state = {"version": "v1", "allowed": True, "reads": 0}
+
+    def resolve(**kwargs):
+        assert kwargs["document_id"] == "source" and kwargs["user_id"] == "owner"
+        if not state["allowed"]:
+            raise AnalysisResultUnavailable()
+        return {"scope": "personal", "document": {"id": "source", "user_id": "owner", "_etag": state["version"]}}
+
+    def chunks(**kwargs):
+        state["reads"] += 1
+        return {
+            "scope": "personal", "scope_id": "owner", "returned_chunk_count": 1, "chunk_count": 1,
+            "chunks": [{"chunk_text": f"Frozen criteria {state['version']}"}],
+        }
+
+    def read(**kwargs):
+        return load_workflow_reference(workflow, reference, actor_user_id="owner", resolve_document=resolve, load_chunks=chunks, **kwargs)
+
+    with WorkflowRuntimeLease(store, owner_id="first") as lease:
+        controller = StructuredWorkflowExecution(store, lease, workflow, "run")
+        controller.set_node(workflow["flow"]["nodes"][0], "root")
+        with workflow_execution_scope(controller):
+            original = controller.freeze_reference(reference, read)
+    clock.advance()
+    with WorkflowRuntimeLease(store, owner_id="second") as lease:
+        controller = StructuredWorkflowExecution(store, lease, workflow, "run")
+        controller.set_node(workflow["flow"]["nodes"][-1], "root")
+        with workflow_execution_scope(controller):
+            assert controller.freeze_reference(reference, read) == original
+            assert state["reads"] == 1
+            state["version"] = "v2"
+            with pytest.raises(WorkflowInputError, match="changed"):
+                controller.freeze_reference(reference, read)
+            state["version"], state["allowed"] = "v1", False
+            with pytest.raises(AnalysisResultUnavailable):
+                controller.freeze_reference(reference, read)
+
+
+def test_approval_history_rechecks_predicate_and_shared_reference_sources(runtime, monkeypatch):
+    workflow, store, _, _ = runtime
+    with pytest.raises(SystemExit):
+        run_flow(workflow, store, crash_after_choice=True)
+    producer = next(item for item in store.journal_page("execution")["items"] if item["node_id"] == "classify-node")["workflow_result"]
+    receipt = {
+        "producer": producer["producer"], "result_ref": producer["result_ref"],
+        "output_name": "json", "output_ref": producer["outputs"]["json"]["result_ref"],
+    }
+    node = workflow["flow"]["nodes"][-1]
+    with WorkflowRuntimeLease(store, owner_id="gate-owner") as lease:
+        controller = StructuredWorkflowExecution(store, lease, workflow, "run")
+        controller.set_node(node, "root")
+        with workflow_execution_scope(controller), pytest.raises(WorkflowSuspended):
+            controller.run_unit(
+                "task:report", lambda: pytest.fail("Approval must precede effects."),
+                inputs={"consumed_inputs": [receipt], "references": [{
+                    "document_id": "criteria", "scope_type": "personal", "scope_id": "owner", "source_version": 1,
+                }]}, approval={"required": True},
+            )
+    gate = store.read()["gate"]
+    execution = store.journal_read("execution", gate["execution_id"])["payload"]
+    assert execution["consumed_inputs"] == [receipt]
+    assert execution["reference_sources"][0]["document_id"] == "criteria"
+    monkeypatch.setattr("functions_workflow_execution_history.workflow_runtime_store", lambda *_: store)
+    monkeypatch.setattr("functions_workflow_execution_history.authorize_analysis_sources", lambda *args, **kwargs: (_ for _ in ()).throw(AnalysisResultUnavailable()))
+    with pytest.raises(AnalysisResultUnavailable):
+        workflow_execution_history(workflow, "run", reader_user_id="owner")
+
+
+def test_invalid_selected_output_is_visible_in_exact_attempt_history(runtime):
+    workflow, store, _, _ = runtime
+    runner, _, _, _, _, _ = build_inventory_run()
+    runner.update({
+        "_execute_workflow_dispatch": lambda *args, **kwargs: {"reply": "Not the required JSON object."},
+        "persist_workflow_task_result": persist_workflow_task_result,
+        "authorize_workflow_task_result_read": authorize_workflow_task_result_read,
+    })
+    with WorkflowRuntimeLease(store, owner_id="invalid-task") as lease:
+        controller = StructuredWorkflowExecution(store, lease, workflow, "run")
+        with workflow_execution_scope(controller):
+            result = runner["_execute_workflow_task_sequence"](workflow, {}, "conversation", "run", None, {})
+    assert result["workflow_outcome"] == {"status": "invalid", "success": False}
+    execution = store.journal_page("execution")["items"][0]
+    assert execution["state"] == "invalid"
+    attempts = store.journal_page("attempt", execution_id=execution["execution_id"])["items"]
+    assert attempts[0]["workflow_validation"]["status"] == "invalid"
+    assert attempts[0]["workflow_result"]["producer"]["attempt"] == 1
+
+
+def test_deadline_expiration_is_idempotent_and_cannot_resume(runtime):
+    _, store, _, clock = runtime
+    with WorkflowRuntimeLease(store, owner_id="waiting") as lease:
+        store.wait(lease.token, state="waiting_approval", gate={"id": "gate", "kind": "approval", "choices": ["approve", "reject"]})
+    clock.now = clock.now.replace(year=clock.now.year + 1)
+    expired = store.expire_deadline()
+    again = store.expire_deadline()
+    assert expired == again and expired["state"] == "paused"
+    assert expired["gate"]["choices"] == ["cancel"]
+    with pytest.raises(WorkflowRuntimeConflict):
+        store.resume(expected_version=expired["version"], actor_user_id="owner", request_id="reset")
+    assert store.read()["deadline_at"] == expired["deadline_at"]
+
+
+def test_restart_after_completed_skip_does_not_create_task_attempts(runtime):
+    workflow, store, _, clock = runtime
+    run_flow(workflow, store)
+    skipped = next(item for item in store.journal_page("execution")["items"] if item["state"] == "skipped")
+    assert skipped["attempt"] == 0
+    assert store.journal_page("attempt", execution_id=skipped["execution_id"])["items"] == []
+    admitted = store.read()["admitted_count"]
+    clock.advance()
+    _, calls = run_flow(workflow, store)
+    assert not calls and store.read()["admitted_count"] == admitted
+    assert store.journal_page("attempt", execution_id=skipped["execution_id"])["items"] == []
+
+
+@pytest.mark.parametrize("version", [1, 3])
+def test_paged_per_document_outputs_retain_their_kind_and_full_values(runtime, version):
+    workflow, _, _, _ = runtime
+    documents = [{
+        "document_id": f"source-{index}",
+        "full_result": {"text": "x" * 140000 + f"END-OF-DOCUMENT-{index}"},
+    } for index in range(2)]
+    identity = (
+        workflow_node_identity(workflow, "run", "yes-node", workflow_execution_id(workflow, "run", "yes-node"), 1, task_id="yes")
+        if version == 3 else {"workflow_id": workflow["id"], "run_id": "run", "task_id": "yes", "attempt": 1}
+    )
+    envelope = _build_task_result(
+        {"reply": "Short preview", "analysis_result": {"per_document": True, "document_results": documents}},
+        identity, "workflow-result-v2" if version == 3 else "workflow-result-v1",
+    )
+    envelope["workflow_validation"] = {"version": 1, "status": "valid", "eligible": True, "reason_codes": []}
+    if version == 3:
+        manifest, reference = persist_workflow_task_result(envelope, workflow=workflow, run_id="run", task_id="yes", settings={})
+        loader = lambda ref: load_workflow_node_result(
+            workflow, "run", "yes", ref, node_id="yes-node", execution_id=identity["execution_id"], attempt=1, iteration_path=[],
+        )
+        prompt, receipt = load_workflow_node_input(workflow, "run", identity, reference, output_name="documents")
+    else:
+        store = SerializedSections()
+        source = {"document_id": "source", "scope": "personal", "scope_id": "owner", "source_version": 1}
+        envelope["analysis_access"] = {"version": "analysis-source-access-v1", "sources": [source]}
+        manifest, reference = persist_workflow_task_result(envelope, workflow=workflow, run_id="run", task_id="yes", settings={}, save_result=store.save)
+        loader = lambda ref: store.load(workflow, "run", "yes", ref)
+        prompt, receipt = load_workflow_task_input(
+            workflow, "run", "yes", reference, output_name="documents", load_result=store.load,
+            source_resolver=lambda ids, **kwargs: [{**source, "authorization_status": "authorized"}],
+        )
+    assert manifest["outputs"]["documents"]["storage_kind"] == "record_pages"
+    second, total = read_result_records(manifest, "documents", loader, offset=1, limit=1)
+    assert total == 2 and second[0]["value"].endswith("END-OF-DOCUMENT-1")
+    value = json.loads(prompt)
+    assert value["kind"] == "document_results" and len(value["value"]) == 2
+    assert all(item["value"].endswith(f"END-OF-DOCUMENT-{index}") for index, item in enumerate(value["value"]))
+    assert receipt["output_name"] == "documents"
diff --git a/functional_tests/test_workflow_structured_flow.py b/functional_tests/test_workflow_structured_flow.py
new file mode 100644
index 000000000..14d9e47fd
--- /dev/null
+++ b/functional_tests/test_workflow_structured_flow.py
@@ -0,0 +1,653 @@
+# test_workflow_structured_flow.py
+"""
+Isolated regression coverage for the structured v3 compiler, exact results and journal.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+Uses production compiler, controller, flow traversal, result transport and readers
+with JSON-copying transactional Cosmos fakes. No model, Azure or workflow is invoked.
+"""
+
+import copy
+import ast
+import json
+import re
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+from azure.cosmos.exceptions import CosmosHttpResponseError, CosmosResourceNotFoundError
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "application" / "single_app"))
+
+# Production imports follow the worktree path setup.
+from functions_workflow_definitions import WorkflowDefinitionError, workflow_definition_revision
+from functions_analysis_access import AnalysisResultUnavailable
+from functions_workflow_execution import WorkflowSuspended, workflow_execution_scope
+from functions_workflow_execution import current_workflow_execution
+from functions_workflow_results import WorkflowResultNotReadyError
+from functions_workflow_flow import MISSING, compile_workflow_flow, evaluate_predicate, normalize_predicate
+from functions_workflow_flow_runner import WorkflowFlowRunner
+from functions_workflow_identity import workflow_execution_id, workflow_node_identity
+from functions_workflow_node_results import authorize_workflow_node_result_read, load_workflow_node_input
+from functions_workflow_result_store import WorkflowResultStore
+from functions_workflow_results import build_workflow_task_result, persist_workflow_task_result, workflow_result_summary
+from functions_workflow_results import authorize_workflow_task_result_read
+from functions_workflow_results import _build_task_result
+from functions_document_analysis_checkpoints import analysis_checkpoints_for_workflow
+from functions_workflow_runtime_store import WorkflowRuntimeConflict, WorkflowRuntimeLease, WorkflowRuntimeStore
+from functions_workflow_structured_execution import StructuredWorkflowExecution
+from functions_workflow_validation import validate_workflow_task_output
+from test_workflow_durable_execution import Clock, RuntimeContainer
+
+
+def binding(node_id, name="input", output="authoritative", required=True):
+    return {"name": name, "source": {"kind": "node_output", "node_id": node_id, "output": output},
+            "required": required}
+
+
+def task(identifier, *, inputs=None, contract=None):
+    return {
+        "id": identifier, "type": "instructions", "name": identifier, "instructions": "Use only declared inputs.",
+        "runner": {"type": "inherit"}, "document_action": {"type": "none"},
+        "inputs": [] if inputs is None else inputs, "output_contract": contract or {"kind": "text"},
+    }
+
+
+def condition(name="flag"):
+    return {"op": "eq", "left": {"input": name, "path": "/pass"}, "right": {"literal": True}}
+
+
+def definition():
+    return {
+        "id": "workflow", "user_id": "owner", "definition_version": 3, "durable_execution": True,
+        "runner_type": "model", "chat_capabilities_enabled": False,
+        "tasks": [
+            task("report", inputs=[binding("joined", output="answer")]),
+            task("no"), task("yes"),
+            task("classify", contract={"kind": "json", "schema": {
+                "type": "object", "required": ["pass"], "properties": {"pass": {"type": "boolean"}},
+            }}),
+        ],
+        "flow": {"id": "root", "nodes": [
+            {"id": "classify-node", "kind": "task", "task_id": "classify"},
+            {"id": "choice", "kind": "if", "inputs": [binding("classify-node", "flag")],
+             "condition": condition(),
+             "then": {"id": "positive", "nodes": [{"id": "yes-node", "kind": "task", "task_id": "yes"}]},
+             "else": {"id": "negative", "nodes": [{"id": "no-node", "kind": "task", "task_id": "no"}]},
+             "join": {"id": "joined", "exports": [{
+                 "name": "answer", "expected_kind": "text", "required": True,
+                 "then": {"node_id": "yes-node"}, "else": {"node_id": "no-node"},
+             }]}},
+            {"id": "report-node", "kind": "task", "task_id": "report"},
+        ], "outputs": [binding("report-node", "report")]},
+    }
+
+
+class JournalContainer(RuntimeContainer):
+    def query_items(self, *, query, parameters, partition_key=None, max_item_count=None, **kwargs):
+        values = {item["name"][1:]: item["value"] for item in parameters}
+        rows = [copy.deepcopy(row) for (partition, _), row in self.items.items()
+                if partition_key is None or partition == partition_key]
+        for field in ("run_id", "workflow_id", "scope_type", "scope_id", "execution_id"):
+            if field in values:
+                rows = [row for row in rows if row.get(field) == values[field]]
+        if "record_type" in values:
+            rows = [row for row in rows if row.get("type") == values["record_type"]]
+        if "kind" in values:
+            rows = [row for row in rows if row.get("record_kind") == values["kind"]]
+        if "after" in values:
+            rows = [row for row in rows if row.get("sequence", 0) > values["after"]]
+            rows.sort(key=lambda row: row["sequence"])
+        if "through" in values:
+            rows = [row for row in rows if row.get("sequence", 0) <= values["through"]]
+        top = re.search(r"SELECT TOP (\d+)", query)
+        return rows[:int(top[1])] if top else rows
+
+    def delete_item(self, item, partition_key):
+        del self.items[(partition_key, item)]
+
+
+@pytest.fixture
+def runtime(monkeypatch):
+    return create_structured_runtime(definition(), monkeypatch)
+
+
+def create_structured_runtime(workflow, monkeypatch):
+    compiled = compile_workflow_flow(workflow)
+    workflow.update({key: compiled[key] for key in ("flow", "tasks", "limits")})
+    workflow["definition_revision"] = workflow_definition_revision(workflow)
+    container, clock = JournalContainer(), Clock()
+    store = WorkflowRuntimeStore(container, workflow, "run", clock=clock)
+    results = WorkflowResultStore(container)
+    snapshot = results.save(
+        workflow, "run", None, workflow, node_id="root",
+        execution_id=workflow_execution_id(workflow, "run", "root"), attempt=1, iteration_path=[],
+    )
+    store.initialize(snapshot_ref=snapshot, definition_revision=workflow["definition_revision"],
+                     actor_user_id="owner", request_id="request")
+
+    def configured(*args, **kwargs):
+        return WorkflowResultStore(container)
+
+    monkeypatch.setattr("functions_workflow_result_store._configured_store", configured)
+    monkeypatch.setattr("functions_workflow_result_store._configured_result_store", configured)
+    return workflow, store, container, clock
+
+
+def test_catalogue_order_is_not_executable_and_defaults_are_explicit():
+    compiled = compile_workflow_flow(definition())
+    assert compiled["flow"]["nodes"][0]["task_id"] == "classify"
+    assert compiled["tasks"][0]["id"] == "report"
+    source = compiled["tasks"][0]["inputs"][0]
+    assert source["allow_partial"] is False and source["source"]["scope"] == "current"
+    assert compiled["limits"] == {"max_executions": 5000, "deadline_seconds": 86400}
+
+
+@pytest.mark.parametrize("mutation", [
+    lambda wf: wf["flow"]["nodes"][1]["then"]["nodes"].append({"id": "other", "kind": "repeat"}),
+    lambda wf: wf["tasks"][0].update(inputs=None),
+    lambda wf: wf["flow"]["nodes"][1]["join"]["exports"][0]["then"].update(node_id="missing"),
+    lambda wf: wf["flow"]["nodes"][1]["then"]["nodes"][0].update(run_when={"op": "eq", "left": {"literal": 1}, "right": {"literal": 1}}),
+    lambda wf: wf["flow"]["nodes"][1]["else"].update(id="positive"),
+    lambda wf: wf["tasks"].append(copy.deepcopy(wf["tasks"][0])),
+    lambda wf: wf.update(limits={"max_executions": True}),
+    lambda wf: wf["flow"].pop("outputs"),
+    lambda wf: wf["flow"]["nodes"][1].update(target={"node_id": "report-node"}),
+])
+def test_compiler_rejects_invalid_or_lossy_shapes(mutation):
+    workflow = definition()
+    mutation(workflow)
+    with pytest.raises(WorkflowDefinitionError):
+        compile_workflow_flow(workflow)
+
+
+def test_branch_outputs_cannot_escape_without_a_join():
+    workflow = definition()
+    workflow["tasks"][0]["inputs"] = [binding("yes-node")]
+    with pytest.raises(WorkflowDefinitionError, match="region"):
+        compile_workflow_flow(workflow)
+
+
+def test_forward_route_checks_every_reachable_required_dependency():
+    workflow = definition()
+    workflow["flow"]["nodes"].insert(0, {
+        "id": "route", "kind": "route", "inputs": [], "condition": {
+            "op": "eq", "left": {"literal": 1}, "right": {"literal": 2},
+        }, "target": {"node_id": "choice"},
+    })
+    with pytest.raises(WorkflowDefinitionError, match="required producer"):
+        compile_workflow_flow(workflow)
+    workflow["flow"]["nodes"][0]["target"] = {"node_id": "route"}
+    with pytest.raises(WorkflowDefinitionError, match="later sibling"):
+        compile_workflow_flow(workflow)
+
+
+def test_predicate_missing_null_boolean_numeric_and_short_circuit_rules():
+    bindings = [{"name": "input"}]
+    exists = normalize_predicate({"op": "exists", "value": {"input": "input", "path": "/x"}}, bindings)
+    assert evaluate_predicate(exists, {"input": {"x": None}}) is True
+    assert evaluate_predicate(exists, {"input": {}}) is False
+    comparison = normalize_predicate({
+        "op": "eq", "left": {"input": "input", "path": "/x"}, "right": {"literal": None},
+    }, bindings)
+    with pytest.raises(WorkflowDefinitionError, match="missing"):
+        evaluate_predicate(comparison, {"input": {}})
+    guarded = normalize_predicate({"op": "all", "conditions": [exists, comparison]}, bindings)
+    assert evaluate_predicate(guarded, {"input": {}}) is False
+    for operator in ("eq", "ne", "lt"):
+        expr = normalize_predicate({"op": operator, "left": {"literal": True}, "right": {"literal": 1}}, [])
+        if operator == "lt":
+            with pytest.raises(WorkflowDefinitionError):
+                evaluate_predicate(expr, {})
+        else:
+            assert evaluate_predicate(expr, {}) is (operator == "ne")
+    assert evaluate_predicate(normalize_predicate({
+        "op": "eq", "left": {"literal": 1}, "right": {"literal": 1.0},
+    }, []), {})
+    with pytest.raises(WorkflowDefinitionError):
+        normalize_predicate({"op": "exists", "value": {"input": "input", "path": "/bad~2path"}}, bindings)
+
+
+def run_flow(workflow, store, *, yes=True, crash_after_choice=False):
+    calls, outcomes = [], []
+    with WorkflowRuntimeLease(store, owner_id="worker") as lease:
+        execution = StructuredWorkflowExecution(store, lease, workflow, "run")
+        with workflow_execution_scope(execution):
+            flow = WorkflowFlowRunner(workflow, "run", execution, outcomes, actor_user_id="owner")
+            for current in flow.tasks():
+                if crash_after_choice and current["id"] in {"yes", "no"}:
+                    raise SystemExit("Restart after durable branch decision.")
+                resolved = flow.resolve(current["inputs"])
+                raw = execution.run_unit(
+                    f"task:{current['id']}",
+                    lambda: calls.append(current["id"]) or (
+                        {"reply": json.dumps({"pass": yes}), "authoritative_result": {"kind": "json", "value": {"pass": yes}}}
+                        if current["id"] == "classify" else {"reply": current["id"] + "x" * 13000 + "FINAL-SENTINEL"}
+                    ), inputs={"task": current, "receipts": resolved["consumed_inputs"]}, replay_safe=True,
+                )
+                envelope = build_workflow_task_result(raw, workflow=workflow, run_id="run", task=current)
+                envelope["consumed_inputs"] = resolved["consumed_inputs"]
+                envelope["workflow_validation"] = validate_workflow_task_output(envelope, current["output_contract"])
+                manifest, reference = persist_workflow_task_result(
+                    envelope, workflow=workflow, run_id="run", task_id=current["id"], settings={"max_file_size_mb": 10},
+                )
+                outcomes.append({
+                    "task": current, "status": "succeeded",
+                    "consumed_inputs": resolved["consumed_inputs"],
+                    "result": {**raw, "workflow_result": workflow_result_summary(manifest, reference),
+                               "workflow_validation": envelope["workflow_validation"]},
+                })
+            return flow, calls
+
+
+@pytest.mark.parametrize("yes", [True, False])
+def test_exact_selected_join_and_long_final_output_survive_reload(runtime, yes):
+    workflow, store, container, _ = runtime
+    flow, calls = run_flow(workflow, store, yes=yes)
+    assert calls == ["classify", "yes" if yes else "no", "report"]
+    assert flow.finished and not flow.failed
+    receipt = flow.final_outputs[0]
+    prompt, _ = load_workflow_node_input(workflow, "run", receipt["producer"], receipt["result_ref"])
+    assert json.loads(prompt)["value"].endswith("FINAL-SENTINEL")
+    report = flow.completed["report-node"]["summary"]
+    join_receipt = report["consumed_inputs"][0]
+    assert join_receipt["producer"]["node_id"] == "joined"
+    assert "task_id" not in join_receipt["producer"]
+    join, _ = authorize_workflow_node_result_read(
+        workflow, "run", join_receipt["producer"], join_receipt["result_ref"],
+    )
+    assert {item["producer"]["node_id"] for item in join["consumed_inputs"]} == {"choice", "yes-node" if yes else "no-node"}
+    assert join["outputs"]["answer"]["selected_producer"]["producer"]["node_id"] == ("yes-node" if yes else "no-node")
+    assert store.read()["units"] == {} and store.read()["memory"] == {}
+
+
+def test_restart_follows_persisted_choice_and_does_not_reinvoke_classifier(runtime):
+    workflow, store, _, _ = runtime
+    with pytest.raises(SystemExit):
+        run_flow(workflow, store, crash_after_choice=True)
+    flow, calls = run_flow(workflow, store, yes=False)
+    assert calls == ["yes", "report"]
+    assert flow.completed["no-node"]["state"] == "skipped"
+
+
+def test_exact_identity_rejects_forged_attempt_execution_task_and_scope(runtime):
+    workflow, store, _, _ = runtime
+    flow, _ = run_flow(workflow, store)
+    receipt = flow.final_outputs[0]
+    for changed in (
+        {"attempt": 2}, {"execution_id": "f" * 64}, {"task_id": "classify"}, {"node_id": "classify-node"},
+    ):
+        with pytest.raises((ValueError, CosmosResourceNotFoundError)):
+            load_workflow_node_input(workflow, "run", {**receipt["producer"], **changed}, receipt["result_ref"])
+    with pytest.raises(ValueError):
+        workflow_node_identity({**workflow, "user_id": "stranger"}, "run", "report-node",
+                               receipt["producer"]["execution_id"], 1, task_id="report")
+
+
+def test_schema2_pages_more_than_1000_records_without_growing_control(runtime):
+    workflow, store, container, _ = runtime
+    with WorkflowRuntimeLease(store, owner_id="seed-worker") as lease:
+        for index in range(1010):
+            store.journal_commit(lease.token, "execution", f"seed-{index}", {
+                "execution_id": f"seed-{index}", "node_id": "node", "node_kind": "task",
+                "iteration_path": [], "state": "completed", "attempt": 1,
+            })
+    cursor, items = None, []
+    while True:
+        page = store.journal_page("execution", cursor=cursor, limit=73)
+        items.extend(page["items"])
+        cursor = page["next_cursor"]
+        if cursor is None:
+            break
+    assert len(items) == 1010 and len({item["sequence"] for item in items}) == 1010
+    control = store.read()
+    assert len(json.dumps(control)) < 5000 and control["units"] == {} and control["memory"] == {}
+    assert control["admitted_count"] == 0
+    with pytest.raises(ValueError):
+        store.journal_page("attempt", cursor=store.journal_page("execution", limit=1)["next_cursor"])
+
+
+def test_approval_is_bound_to_exact_attempt_and_old_gate_cannot_approve_retry(runtime):
+    workflow, store, _, _ = runtime
+    node = workflow["flow"]["nodes"][0]
+    def execute():
+        with WorkflowRuntimeLease(store, owner_id="worker") as lease:
+            controller = StructuredWorkflowExecution(store, lease, workflow, "run")
+            controller.set_node(node, "root")
+            with workflow_execution_scope(controller):
+                return controller.run_unit("task:classify", lambda: {"reply": "saved"},
+                                           inputs={"request": 1}, approval={"required": True}, replay_safe=True)
+    with pytest.raises(WorkflowSuspended):
+        execute()
+    waiting = store.read()
+    first_gate = waiting["gate"]
+    assert first_gate["node_id"] == node["id"] and first_gate["attempt"] == 1
+    store.decide(expected_version=waiting["version"], gate_id=first_gate["id"], choice="approve",
+                 actor_user_id="owner", request_id="approve-1")
+    execute()
+    with WorkflowRuntimeLease(store, owner_id="invalidate") as lease:
+        controller = StructuredWorkflowExecution(store, lease, workflow, "run")
+        controller.set_node(node, "root")
+        controller.invalidate_task("task:classify")
+    with pytest.raises(WorkflowSuspended):
+        execute()
+    second = store.read()
+    assert second["gate"]["attempt"] == 2 and second["gate"]["id"] != first_gate["id"]
+    with pytest.raises(WorkflowRuntimeConflict):
+        store.decide(expected_version=second["version"], gate_id=first_gate["id"], choice="approve",
+                     actor_user_id="owner", request_id="stale-approval")
+
+
+def test_production_task_sequence_reuses_dispatcher_and_exact_results(runtime):
+    from test_workflow_task_result_handoff import build_inventory_run
+
+    workflow, store, _, _ = runtime
+    runner, _, _, _, _, items = build_inventory_run(1)
+    requests = []
+
+    def completion(**kwargs):
+        requests.append(kwargs)
+        response = '{"pass": true}' if len(requests) == 1 else "x" * 13000 + "DISPATCH-SENTINEL"
+        return SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content=response))], usage=None)
+
+    client = SimpleNamespace(chat=SimpleNamespace(completions=SimpleNamespace(create=completion)))
+    runner.update({
+        "get_workflow_alert_signals": lambda: [],
+        "_resolve_model_workflow_client": lambda *args, **kwargs: (
+            runner["WorkflowModelClient"](client, "gpt-4.1", "aoai"), "gpt-4.1", "aoai",
+        ),
+        "persist_workflow_task_result": lambda envelope, **kwargs: persist_workflow_task_result(
+            envelope, **{**kwargs, "settings": {"max_file_size_mb": 10}},
+        ),
+        "authorize_workflow_task_result_read": authorize_workflow_task_result_read,
+    })
+    with WorkflowRuntimeLease(store, owner_id="dispatcher-worker") as lease:
+        execution = StructuredWorkflowExecution(store, lease, workflow, "run")
+        with workflow_execution_scope(execution):
+            result = runner["_execute_workflow_task_sequence"](
+                workflow, {}, "conversation", "run", None, {}, actor_user_id="owner",
+            )
+    assert len(requests) == 3
+    assert result["workflow_outcome"] == {"status": "completed", "success": True}
+    assert result["reply"].endswith("DISPATCH-SENTINEL")
+    assert [entry["task_id"] for entry in result["task_results"]] == ["classify", "yes", "report"]
+    assert result["workflow_outputs"][0]["producer"]["node_id"] == "report-node"
+
+
+def test_run_when_false_precedes_approval_and_produces_only_skip_evidence(runtime):
+    workflow, store, _, _ = runtime
+    workflow["flow"]["nodes"][0]["run_when"] = {
+        "op": "eq", "left": {"literal": 1}, "right": {"literal": 2},
+    }
+    workflow["tasks"] = [task("classify")]
+    workflow["tasks"][0]["approval"] = {"required": True}
+    workflow["flow"]["nodes"] = [workflow["flow"]["nodes"][0]]
+    workflow["flow"]["outputs"] = []
+    with WorkflowRuntimeLease(store, owner_id="skip-worker") as lease:
+        execution = StructuredWorkflowExecution(store, lease, workflow, "run")
+        flow = WorkflowFlowRunner(workflow, "run", execution, [], actor_user_id="owner")
+        assert list(flow.tasks()) == []
+    row = store.journal_page("execution")["items"][0]
+    assert row["state"] == "skipped" and row["reason_code"] == "run_when_false"
+    assert "workflow_result" not in row and store.read()["gate"] is None
+    assert store.read()["admitted_count"] == 1
+
+
+def test_control_budget_and_deadline_include_waits_without_counting_payload_writes(runtime):
+    workflow, store, container, clock = runtime
+    control = store.read()
+    control["max_executions"] = 1
+    container._store(("run", control["id"]), control)
+    with WorkflowRuntimeLease(store, owner_id="budget-worker") as lease:
+        store.journal_commit(lease.token, "decision", "first", {"choice": "then"}, admission=True)
+        for index in range(3):
+            store.journal_commit(lease.token, "unit", f"checkpoint-{index}", {"state": "completed"})
+        store.wait(lease.token, state="waiting_approval", gate={"id": "gate", "kind": "approval", "choices": ["approve", "reject"]})
+    waiting = store.read()
+    store.decide(expected_version=waiting["version"], gate_id="gate", choice="approve", actor_user_id="owner", request_id="allow")
+    with WorkflowRuntimeLease(store, owner_id="limit-worker") as lease:
+        with pytest.raises(WorkflowSuspended, match="paused"):
+            store.journal_commit(lease.token, "decision", "second", {"choice": "else"}, admission=True)
+    limited = store.read()
+    assert limited["admitted_count"] == 1 and limited["gate"]["choices"] == ["cancel"]
+    with pytest.raises(WorkflowRuntimeConflict):
+        store.resume(expected_version=limited["version"], actor_user_id="owner", request_id="reset-budget")
+    # Independently exercise expiration while a run is genuinely waiting.
+    limited.update(state="waiting_approval", phase="", gate={"id": "later-gate", "kind": "approval", "choices": ["approve", "reject"]})
+    container._store(("run", limited["id"]), limited)
+    clock.now = clock.now.replace(year=clock.now.year + 1)
+    assert store.expire_deadline()["state"] == "paused"
+    assert store.read()["phase"] == "deadline_exceeded"
+
+
+@pytest.mark.parametrize("race", ["before_guard", "checkpoint", "cancelled_worker"])
+def test_v3_analyze_writes_retain_workflow_and_native_guard_fences(runtime, monkeypatch, race):
+    workflow, store, container, _ = runtime
+    node = workflow["flow"]["nodes"][0]
+    with WorkflowRuntimeLease(store, owner_id="analyze-worker") as lease:
+        execution = StructuredWorkflowExecution(store, lease, workflow, "run")
+        execution.set_node(node, "root")
+        with workflow_execution_scope(execution):
+            checkpoints = analysis_checkpoints_for_workflow(
+                workflow, "run", "classify", user_id="owner", authorize=lambda: execution.check(),
+                source_authorizer=lambda *args, **kwargs: True, store=WorkflowResultStore(container), **execution.selectors(),
+            )
+            assert all(not isinstance(value, list) for value in checkpoints.binding.values())
+            if race != "before_guard":
+                checkpoints.prepare()
+                checkpoints.initialize({"instructions": "Extract"}, [
+                    {"document_id": "source", "scope": "personal", "scope_id": "owner", "source_version": 1},
+                ])
+            operation = checkpoints.prepare if race == "before_guard" else lambda: checkpoints.store.write_analysis_checkpoint(
+                checkpoints.binding, "source", "source", {"source": "verified"}, token=checkpoints.token,
+            )
+            if race == "cancelled_worker":
+                store.request_cancel(actor_user_id="owner", request_id="cancel")
+                before = copy.deepcopy(container.items)
+            else:
+                original = container.execute_item_batch
+                before = []
+
+                def race_write(batch_operations, partition_key):
+                    if not before:
+                        store.tombstone()
+                        before.append(copy.deepcopy(container.items))
+                    return original(batch_operations, partition_key)
+
+                monkeypatch.setattr(container, "execute_item_batch", race_write)
+            with pytest.raises(WorkflowRuntimeConflict):
+                operation()
+            assert container.items == (before if race == "cancelled_worker" else before[0])
+
+
+def test_paged_consumption_lineage_is_not_limited_to_256_ancestors(runtime):
+    workflow, store, _, _ = runtime
+    receipts = []
+    source_execution = workflow_execution_id(workflow, "run", "yes-node")
+    for attempt in range(1, 302):
+        identity = workflow_node_identity(workflow, "run", "yes-node", source_execution, attempt, task_id="yes")
+        envelope = _build_task_result({"reply": f"result {attempt}"}, identity, "workflow-result-v2")
+        envelope["workflow_validation"] = {"version": 1, "status": "valid", "eligible": True}
+        manifest, reference = persist_workflow_task_result(envelope, workflow=workflow, run_id="run", task_id="yes", settings={})
+        receipts.append({"producer": identity, "result_ref": reference, "output_name": "text",
+                         "output_ref": manifest["outputs"]["text"]["result_ref"]})
+    identity = workflow_node_identity(workflow, "run", "report-node", workflow_execution_id(workflow, "run", "report-node"), 1, task_id="report")
+    aggregate = _build_task_result({"reply": "Complete lineage"}, identity, "workflow-result-v2")
+    aggregate["workflow_validation"] = {"version": 1, "status": "valid", "eligible": True}
+    aggregate["consumed_inputs"] = receipts
+    manifest, reference = persist_workflow_task_result(aggregate, workflow=workflow, run_id="run", task_id="report", settings={})
+    assert "consumed_inputs" not in manifest
+    assert manifest["consumed_inputs_index"]["record_count"] == 301
+    loaded, _ = authorize_workflow_node_result_read(workflow, "run", identity, reference)
+    assert loaded["consumed_inputs_index"]["record_count"] == 301
+
+
+def test_publication_uses_explicit_producer_and_stable_execution_receipt_across_retry(runtime, monkeypatch):
+    from test_analyze_backend_saved_integration import load_functions
+
+    workflow, store, _, _ = runtime
+    identity = workflow_node_identity(workflow, "run", "yes-node", workflow_execution_id(workflow, "run", "yes-node"), 2, task_id="yes")
+    envelope = _build_task_result({"reply": "Native saved analysis"}, identity, "workflow-result-v2")
+    envelope.update(analysis_origin=True, validation={"status": "valid"}, workflow_validation={
+        "version": 1, "status": "valid", "eligible": True,
+    }, artifacts=[{"output_format": "md", "artifact_message_id": "artifact", "conversation_id": "conversation", "capability": "analyze"}])
+    manifest, reference = persist_workflow_task_result(envelope, workflow=workflow, run_id="run", task_id="yes", settings={})
+    receipt = {"producer": identity, "result_ref": reference, "output_name": "text", "output_ref": manifest["outputs"]["text"]["result_ref"]}
+    published, requests = {}, []
+
+    def publish(actor, *, request_id, publication, artifact_reference):
+        requests.append((request_id, artifact_reference["producer"]))
+        published.setdefault(request_id, {"publication": {"state": "queued", "document_id": "one-document"}})
+        return copy.deepcopy(published[request_id])
+
+    monkeypatch.setitem(sys.modules, "functions_artifact_publication", SimpleNamespace(publish_workflow_analysis_artifact=publish))
+    monkeypatch.setitem(sys.modules, "functions_personal_workflows", SimpleNamespace(normalize_workflow_publication=lambda value: value))
+    namespace = {"WorkflowResultNotReadyError": WorkflowResultNotReadyError,
+                 "authorize_workflow_task_result_read": authorize_workflow_task_result_read,
+                 "current_workflow_execution": current_workflow_execution}
+    load_functions("functions_workflow_runner.py", {"_execute_workflow_analysis_publication"}, namespace)
+    task_config = {**workflow["tasks"][0], "publication": {"artifact_format": "md", "workspace_scope": "personal"}}
+    with WorkflowRuntimeLease(store, owner_id="publication") as lease:
+        execution = StructuredWorkflowExecution(store, lease, workflow, "run")
+        execution.set_node(workflow["flow"]["nodes"][-1], "root")
+        with workflow_execution_scope(execution):
+            for attempt in (1, 2):
+                store.journal_commit(lease.token, "unit", execution._key("task:report"), {"state": "running", "attempt": attempt})
+                result, consumed = namespace["_execute_workflow_analysis_publication"](
+                    workflow, "run", task_config, "wrong-predecessor", {"sha256": "wrong"},
+                    explicit_inputs=[receipt], actor_user_id="owner", publish=publish,
+                )
+                assert result["publication"]["state"] == "queued"
+                assert consumed[0]["producer"] == identity
+    assert len(requests) == 2 and requests[0] == requests[1] and len(published) == 1
+    assert requests[0][1]["attempt"] == 2
+
+
+def test_branch_exit_route_skips_remaining_children_and_reaches_only_its_join(runtime):
+    workflow, store, _, _ = runtime
+    branch = workflow["flow"]["nodes"][1]["then"]
+    workflow["tasks"].append(task("never"))
+    branch["nodes"].extend([
+        {"id": "exit", "kind": "route", "inputs": [], "condition": {
+            "op": "eq", "left": {"literal": 1}, "right": {"literal": 1},
+        }, "target": {"exit_region_id": branch["id"]}},
+        {"id": "never-node", "kind": "task", "task_id": "never"},
+    ])
+    flow, calls = run_flow(workflow, store)
+    assert "never" not in calls and flow.completed["never-node"]["state"] == "skipped"
+    assert flow.completed["joined"]["state"] == "completed" and flow.finished
+
+
+def test_lost_decision_acknowledgement_does_not_double_admit_or_change_choice(runtime, monkeypatch):
+    workflow, store, container, _ = runtime
+    original = container.execute_item_batch
+    lost = []
+
+    def commit_then_disconnect(batch_operations, partition_key):
+        value = original(batch_operations, partition_key)
+        if not lost:
+            lost.append(True)
+            raise CosmosHttpResponseError(status_code=503)
+        return value
+
+    with WorkflowRuntimeLease(store, owner_id="worker") as lease:
+        monkeypatch.setattr(container, "execute_item_batch", commit_then_disconnect)
+        row = store.journal_commit(lease.token, "decision", "decision", {"decision": {"choice": "then"}},
+                                   admission=True, immutable=True, updates={"cursor": {"node_id": "choice"}})
+        version = store.read()["version"]
+        repeated = store.journal_commit(lease.token, "decision", "decision", {"decision": {"choice": "then"}},
+                                        admission=True, immutable=True)
+        assert repeated == row and store.read()["admitted_count"] == 1 and store.read()["version"] == version
+
+
+def test_deletion_sweeps_v3_journal_and_genuine_node_sections_but_keeps_tombstone(runtime):
+    workflow, store, container, _ = runtime
+    run_flow(workflow, store)
+    store.tombstone()
+    WorkflowResultStore(container).delete_run_results(workflow, "run")
+    remaining = list(container.items.values())
+    assert len(remaining) == 1 and remaining[0]["type"] == "workflow_runtime_control"
+    assert remaining[0]["deleted"] is True
+
+
+def test_private_journal_records_never_enter_ordinary_run_items():
+    path = Path(__file__).resolve().parents[1] / "application" / "single_app" / "functions_personal_workflows.py"
+    function = next(node for node in ast.parse(path.read_text(encoding="utf-8")).body
+                    if isinstance(node, ast.FunctionDef) and node.name == "is_public_workflow_run_item")
+    namespace = {}
+    exec(compile(ast.Module(body=[function], type_ignores=[]), str(path), "exec"), namespace)
+    for field in ("type", "item_type"):
+        assert namespace["is_public_workflow_run_item"]({field: "workflow_runtime_journal"}) is False
+    assert namespace["is_public_workflow_run_item"]({"item_type": "task"}) is True
+
+
+def test_blob_transport_keeps_attempt_namespaces_distinct_and_cleans_genuine_node_results(runtime):
+    from test_workflow_result_store import FakeBlobService
+
+    workflow, store, container, _ = runtime
+    blobs = FakeBlobService()
+    results = WorkflowResultStore(container, blobs, "private-results")
+    execution_id = workflow_execution_id(workflow, "run", "yes-node")
+    references = []
+    for attempt in (1, 2):
+        reference = results.save(
+            workflow, "run", "yes", {"complete": "same payload"},
+            node_id="yes-node", execution_id=execution_id, attempt=attempt, iteration_path=[],
+        )
+        references.append(reference)
+        assert results.load(workflow, "run", "yes", reference, node_id="yes-node",
+                            execution_id=execution_id, attempt=attempt, iteration_path=[]) == {"complete": "same payload"}
+    assert len(blobs.records) == 2 and references[0] == references[1]
+    store.tombstone()
+    results.delete_run_results(workflow, "run")
+    assert blobs.records == {}
+    assert len(container.items) == 1
+
+
+def test_control_provenance_cannot_bypass_source_authorization_or_claim_analyze_origin(runtime):
+    workflow, _, _, _ = runtime
+    source = {"document_id": "source", "scope": "personal", "scope_id": "owner", "source_version": 1}
+    receipts = []
+    for node_id, task_id in (("classify-node", "classify"), ("choice", None), ("report-node", "report")):
+        identity = workflow_node_identity(workflow, "run", node_id, workflow_execution_id(workflow, "run", node_id), 1, task_id=task_id)
+        envelope = _build_task_result({"reply": "Selected result"}, identity, "workflow-result-v2")
+        envelope["workflow_validation"] = {"version": 1, "status": "valid", "eligible": True}
+        envelope["consumed_inputs"] = receipts[-1:]
+        if not receipts:
+            envelope["analysis_access"] = {"version": "analysis-source-access-v1", "sources": [source]}
+        manifest, reference = persist_workflow_task_result(envelope, workflow=workflow, run_id="run", task_id=task_id, settings={})
+        receipts.append({"producer": identity, "result_ref": reference, "output_name": "text",
+                         "output_ref": manifest["outputs"]["text"]["result_ref"], "control": task_id is None})
+    authorized = True
+
+    def resolver(ids, **kwargs):
+        return [{**source, "authorization_status": "authorized" if authorized else "unresolved"}]
+
+    root, access = authorize_workflow_node_result_read(workflow, "run", identity, reference, source_resolver=resolver)
+    assert access["source_count"] == 1 and root.get("analysis_origin") is not True
+    authorized = False
+    with pytest.raises(AnalysisResultUnavailable):
+        authorize_workflow_node_result_read(workflow, "run", identity, reference, source_resolver=resolver)
+
+
+def test_history_sanitizer_preserves_exact_task_and_control_result_bindings(runtime):
+    from functions_saved_analysis import sanitize_workflow_analysis_history
+
+    workflow, store, _, _ = runtime
+    flow, _ = run_flow(workflow, store)
+    record = {"id": "run", "task_results": [{
+        "task_id": item["task"]["id"], "workflow_result": item["result"]["workflow_result"],
+        "consumed_inputs": item["consumed_inputs"], "response_preview": "Saved output",
+    } for item in flow.task_results]}
+    reads = []
+
+    def reader(*args, **kwargs):
+        reads.append((args[2], kwargs))
+        return authorize_workflow_task_result_read(*args, **kwargs)
+
+    safe, _, available = sanitize_workflow_analysis_history(workflow, record, "owner", result_reader=reader)
+    assert available and safe == record
+    assert reads and all(item[1]["execution_id"] for item in reads)
+    assert any(task_id is None for task_id, _ in reads)
diff --git a/functional_tests/test_workflow_structured_publication.py b/functional_tests/test_workflow_structured_publication.py
new file mode 100644
index 000000000..e910dedb2
--- /dev/null
+++ b/functional_tests/test_workflow_structured_publication.py
@@ -0,0 +1,141 @@
+# test_workflow_structured_publication.py
+"""
+Native Analyze and publication service integration for structured workflows.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+Actual final-checkpoint adaptation, result persistence, source-authorized joins,
+task dispatch and publication receipts operate over fictional service doubles.
+No Analyze origin flags are fabricated and no live document is published.
+"""
+
+import copy
+import hashlib
+import sys
+from types import SimpleNamespace
+
+import pytest
+
+from test_analysis_artifact_publication import publication  # noqa: F401
+from test_analyze_native_saved_integration import native, native_run  # noqa: F401
+from test_analyze_backend_saved_integration import saved
+from test_workflow_structured_flow import create_structured_runtime, definition
+from test_workflow_task_result_handoff import build_inventory_run
+from functions_analysis_access import AnalysisResultUnavailable
+from functions_workflow_execution import workflow_execution_scope
+from functions_workflow_runtime_store import WorkflowRuntimeLease
+from functions_workflow_structured_execution import StructuredWorkflowExecution
+from functions_workflow_results import authorize_workflow_task_result_read, persist_workflow_task_result
+
+
+def test_actual_native_result_publishes_once_through_an_explicit_join(native_run, publication, monkeypatch):
+    workflow = definition()
+    workflow["tasks"][1]["output_contract"] = {"kind": "records"}
+    workflow["tasks"][2].update(
+        output_contract={"kind": "records"},
+        document_action={"type": "analyze", "document_ids": ["native-source"]},
+    )
+    workflow["tasks"][0].update(
+        publication={"artifact_format": "md", "workspace_scope": "personal"},
+        output_contract={"kind": "json"},
+    )
+    workflow["flow"]["nodes"][1]["join"]["exports"][0]["expected_kind"] = "records"
+    workflow, store, container, _ = create_structured_runtime(workflow, monkeypatch)
+    native_run.source["scope_id"] = "owner"
+    native_run.run["user_id"] = "owner"
+    monkeypatch.setitem(sys.modules, "functions_saved_analysis", saved)
+    runner, _, _, _, _, _ = build_inventory_run()
+    calls = []
+
+    def source_resolver(ids, **kwargs):
+        assert kwargs["user_id"] == "owner"
+        return native_run.resolve(ids, **kwargs)
+
+    def authorize(*args, **kwargs):
+        return authorize_workflow_task_result_read(*args, source_resolver=source_resolver, **kwargs)
+
+    def dispatch(execution_workflow, *args, **kwargs):
+        calls.append(execution_workflow["active_task"]["id"])
+        if calls[-1] == "classify":
+            return {"reply": '{"pass":true}'}
+        assert calls[-1] == "yes", "Publication must never invoke a model or run the unselected task."
+        producer = execution_workflow["_analysis_producer"]
+        analysis = native.adapt_native_analysis_result(
+            user_id="owner", conversation_id="conversation-1", source=native_run.source,
+            generated_outputs=[{"run_id": "native-run", "status": "completed"}],
+            source_resolver=source_resolver, analysis_producer=producer,
+        )
+        assert len(analysis["authoritative_result"]["value"]) == 150
+        artifact = copy.deepcopy(publication.artifact)
+        artifact["metadata"].update(saved.analysis_artifact_metadata(producer))
+        publication.state["content"] = analysis["analysis_reply"].encode("utf-8")
+        artifact["metadata"]["generated_artifact_content_sha256"] = hashlib.sha256(publication.state["content"]).hexdigest()
+        publication.messages.put(artifact)
+        return {
+            "reply": analysis["reply"], "analysis_result": analysis,
+            "generated_analysis_artifacts": [{
+                "artifact_message_id": artifact["id"], "conversation_id": "conversation-1",
+                "output_format": "md", "capability": "analyze",
+            }],
+        }
+
+    publication.conversations.put({"id": "conversation-1", "user_id": "owner"})
+    publication.state["parents"] = []
+    monkeypatch.setitem(sys.modules, "functions_artifact_publication", publication.module)
+    monkeypatch.setitem(sys.modules, "functions_workflow_runner", SimpleNamespace(
+        _workflow_task_run_item_id=runner["_workflow_task_run_item_id"],
+    ))
+    personal = sys.modules["functions_personal_workflows"]
+    monkeypatch.setattr(personal, "get_personal_workflow", lambda user, key: copy.deepcopy(workflow) if user == "owner" and key == workflow["id"] else None, raising=False)
+    monkeypatch.setattr(personal, "get_personal_workflow_run", lambda user, key: {
+        "id": "run", "workflow_id": workflow["id"], "conversation_id": "conversation-1",
+    } if user == "owner" and key == "run" else None, raising=False)
+    monkeypatch.setattr(personal, "get_personal_workflow_run_item", lambda run_id, key: copy.deepcopy(container.items.get((run_id, key))), raising=False)
+    monkeypatch.setitem(sys.modules, "functions_group_workflows", SimpleNamespace(
+        get_group_workflow=lambda *args: None, get_group_workflow_run=lambda *args: None,
+        get_group_workflow_run_item=lambda *args: None,
+    ))
+    monkeypatch.setattr("functions_workflow_runtime_store.workflow_runtime_store", lambda *args: store)
+    monkeypatch.setattr(saved, "authorize_workflow_task_result_read", authorize)
+    monkeypatch.setattr(publication.module, "authorize_analysis_artifact", saved.authorize_analysis_artifact)
+    monkeypatch.setattr("functions_workflow_node_results.authorize_analysis_sources", lambda user, sources, **kwargs: (
+        saved.authorize_analysis_sources(user, sources, resolver=source_resolver)
+    ))
+    runner.update(
+        _execute_workflow_dispatch=dispatch,
+        authorize_workflow_task_result_read=authorize,
+        persist_workflow_task_result=persist_workflow_task_result,
+    )
+
+    def execute():
+        with WorkflowRuntimeLease(store, owner_id="worker") as lease:
+            controller = StructuredWorkflowExecution(store, lease, workflow, "run")
+            with workflow_execution_scope(controller):
+                return runner["_execute_workflow_task_sequence"](workflow, {}, "conversation-1", "run", None, {}, actor_user_id="owner")
+
+    result = execute()
+    assert result["workflow_outcome"] == {"status": "completed", "success": True}
+    assert result["publication"]["state"] == "queued"
+    assert calls == ["classify", "yes"]
+    assert native_run.reads == ["batch-1", "batch-2", "batch-3"]
+    assert len(publication.calls["create"]) == len(publication.calls["queue"]) == 1
+    assert publication.calls["queue"][0]["file_content_bytes"] == publication.state["content"]
+    producer = result["task_results"][1]["workflow_result"]["producer"]
+    assert producer["node_id"] == "yes-node" and producer["attempt"] == 1
+    assert result["task_results"][1]["workflow_result"]["analysis_origin"] is True
+    assert publication.messages.records["artifact-1"]["metadata"]["analysis_producer"]["execution_id"] == producer["execution_id"]
+    replay = execute()
+    assert replay["publication"] == result["publication"]
+    assert calls == ["classify", "yes"] and len(publication.calls["create"]) == 1
+
+    native_run.state["allowed"] = False
+    before = copy.deepcopy(publication.calls)
+    with pytest.raises(AnalysisResultUnavailable):
+        publication.module.publish_workflow_analysis_artifact(
+            "owner", publication=workflow["tasks"][0]["publication"],
+            artifact_reference={
+                "conversation_id": "conversation-1", "artifact_message_id": "artifact-1",
+                "producer": {"kind": "workflow", **producer},
+            }, request_id="forbidden-new-copy",
+        )
+    assert publication.calls == before
diff --git a/functional_tests/test_workflow_task_result_handoff.py b/functional_tests/test_workflow_task_result_handoff.py
index 23d9bb41d..99688df79 100644
--- a/functional_tests/test_workflow_task_result_handoff.py
+++ b/functional_tests/test_workflow_task_result_handoff.py
@@ -1,7 +1,7 @@
 # test_workflow_task_result_handoff.py
 """
 Functional regression for workflow result production, persistence, and handoff.
-Version: 0.261.109
+Version: 0.261.116
 Implemented in: 0.261.106
 
 Fictional inventory records pass through the production document analysis,
@@ -16,8 +16,10 @@
 import time
 import uuid
 from datetime import datetime, timezone
+from functools import partial, wraps
 from pathlib import Path
 from types import SimpleNamespace
+from unittest.mock import patch
 
 import pytest
 from azure.core.exceptions import ServiceRequestError
@@ -32,6 +34,8 @@
     persist_workflow_task_result,
     authorize_workflow_task_result_read,
 )
+from content_screening import access as screening_access
+from content_screening.contracts import ScreeningError
 
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -134,12 +138,31 @@ def upload_artifact(**kwargs):
     def unexpected_workspace_write(*args, **kwargs):
         raise AssertionError("Result consumption must not upload or re-index a workspace document.")
 
+    def screening_metadata(document_id, user_id, group_id=None, public_workspace_id=None, **kwargs):
+        if document_id != "inventory-source" or user_id != "owner" or group_id or public_workspace_id:
+            raise PermissionError("Only the fictional inventory source is authorized.")
+        return {"id": document_id, "user_id": "owner", "file_name": "fictional-inventory.txt"}
+
+    def screened_model(invoke, evidence, user_id=None):
+        guarded = screening_access.guard_model_callable(invoke, evidence, user_id)
+
+        @wraps(invoke)
+        def call(*args, **kwargs):
+            with patch.object(screening_access, "_read_authorized_document", screening_metadata):
+                return guarded(*args, **kwargs)
+
+        return call
+
     analysis = _load_production_functions(ANALYSIS, {
         "time": time,
         "log_event": lambda *args, **kwargs: None,
         "debug_print": lambda *args, **kwargs: None,
         "normalize_search_id_list": lambda values: list(values or []),
         "normalize_search_scope": lambda value: value or "personal",
+        "PROVENANCE_FIELD": screening_access.PROVENANCE_FIELD,
+        "ScreeningError": ScreeningError,
+        "guard_model_callable": screened_model,
+        "assert_evidence_available": partial(screening_access.assert_evidence_available, metadata_reader=screening_metadata),
     })
     analysis["_get_mixed_source_orchestration_helpers"] = lambda: (
         type("AnalysisCancelled", (BaseException,), {}),
diff --git a/ui_tests/fixtures/workflow_control_definitions.py b/ui_tests/fixtures/workflow_control_definitions.py
new file mode 100644
index 000000000..e4c51bb0e
--- /dev/null
+++ b/ui_tests/fixtures/workflow_control_definitions.py
@@ -0,0 +1,90 @@
+# workflow_control_definitions.py
+"""
+Shared valid M4A definitions for closed V2 authoring and inspection fixtures.
+Version: 0.261.116
+Implemented in: 0.261.116
+"""
+
+from ui_tests.fixtures.workflow_editor import workflow_record
+
+
+STRUCTURED_ID = "structured-review"
+
+
+def flow_binding(name, node_id, output="json", *, required=True, kind="json"):
+    return {
+        "name": name,
+        "source": {"kind": "node_output", "node_id": node_id, "output": output, "scope": "current"},
+        "required": required,
+        "expected_kind": kind,
+        "allow_partial": False,
+    }
+
+
+def flow_condition(field):
+    return {
+        "op": "eq",
+        "left": {"input": "decision", "path": f"/{field}"},
+        "right": {"literal": True},
+    }
+
+
+def structured_workflow_record(identifier=STRUCTURED_ID, name="Structured review", **overrides):
+    tasks = [
+        {
+            "id": task_id, "type": "instructions", "name": task_name,
+            "instructions": f"Produce the {task_name.lower()} result.",
+            "order": index + 1, "runner": {"type": "inherit"}, "inputs": [],
+            "reference_ids": [], "document_action": {"type": "none"},
+            "output_contract": {"kind": "text", "allow_partial": False, "require_complete_coverage": False},
+        }
+        for index, (task_id, task_name) in enumerate([
+            ("evaluate", "Evaluate"), ("accept", "Accept"), ("review", "Review"),
+            ("note", "Optional note"), ("finish", "Finish"),
+        ])
+    ]
+    tasks[0]["output_contract"] = {
+        "kind": "json", "allow_partial": False, "require_complete_coverage": False,
+        "schema": {
+            "type": "object",
+            "properties": {"pass": {"type": "boolean"}, "add_note": {"type": "boolean"}},
+            "required": ["pass", "add_note"],
+        },
+    }
+    tasks[3]["inputs"] = [flow_binding("decision", "evaluate")]
+    tasks[4]["inputs"] = [
+        flow_binding("report", "decision-join", "report", kind="text"),
+        flow_binding("note", "note", "text", required=False, kind="text"),
+    ]
+    flow = {
+        "id": "root",
+        "nodes": [
+            {"id": "evaluate", "kind": "task", "task_id": "evaluate"},
+            {
+                "id": "choose", "kind": "if", "inputs": [flow_binding("decision", "evaluate")],
+                "condition": flow_condition("pass"),
+                "then": {"id": "accepted-path", "nodes": [{"id": "accept", "kind": "task", "task_id": "accept"}]},
+                "else": {"id": "review-path", "nodes": [{"id": "review", "kind": "task", "task_id": "review"}]},
+                "join": {
+                    "id": "decision-join",
+                    "exports": [{
+                        "name": "report", "expected_kind": "text", "required": True,
+                        "then": {"node_id": "accept", "output": "text"},
+                        "else": {"node_id": "review", "output": "text"},
+                    }],
+                },
+            },
+            {
+                "id": "bypass-note", "kind": "route", "inputs": [flow_binding("decision", "evaluate")],
+                "condition": flow_condition("pass"), "target": {"node_id": "finish"},
+            },
+            {"id": "note", "kind": "task", "task_id": "note", "run_when": flow_condition("add_note")},
+            {"id": "finish", "kind": "task", "task_id": "finish"},
+        ],
+        "outputs": [flow_binding("report", "finish", "text", kind="text")],
+    }
+    return workflow_record(
+        identifier, name=name, definition_version=3, durable_execution=True,
+        tasks=tasks, flow=flow, limits={"max_executions": 5000, "deadline_seconds": 86400},
+        **overrides,
+    )
diff --git a/ui_tests/fixtures/workflow_control_runtime.py b/ui_tests/fixtures/workflow_control_runtime.py
new file mode 100644
index 000000000..0b6009254
--- /dev/null
+++ b/ui_tests/fixtures/workflow_control_runtime.py
@@ -0,0 +1,274 @@
+# workflow_control_runtime.py
+"""
+Closed API fixtures for actual M4A control-flow inspection contracts.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+Definitions share the authoring fixture's valid If/else, Run when and route
+tree. M4A paths are empty: no invented loops, control-node approvals, or
+completed runs containing pending work. Payload pages contain real serialized
+JSON bytes and immutable content digests; no live service is contacted.
+"""
+
+import copy
+import hashlib
+import json
+import re
+
+import pytest
+
+from ui_tests.fixtures.workflow_control_definitions import structured_workflow_record
+from ui_tests.fixtures.workflow_editor import (
+    GROUP_ID,
+    WorkflowEditorFixture,
+    connect_options,  # noqa: F401
+)
+
+
+V3_WORKFLOW_ID = "structured-branch-workflow"
+V3_RUN_ID = "structured-run-1"
+GROUP_V3_WORKFLOW_ID = "group-structured-branch-workflow"
+GROUP_V3_RUN_ID = "group-structured-run-1"
+
+
+def _digest(value):
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def execution_id(workflow_id, run_id, node_id):
+    """Opaque fixture IDs have the production digest shape, never list positions."""
+    return _digest(f"{workflow_id}:{run_id}:{node_id}")
+
+
+def _identity(workflow_id, run_id, node_id, attempt):
+    identity = {
+        "workflow_id": workflow_id, "run_id": run_id, "node_id": node_id,
+        "execution_id": execution_id(workflow_id, run_id, node_id),
+        "iteration_path": [], "attempt": attempt,
+    }
+    if node_id in {"evaluate", "accept", "review", "note", "finish"}:
+        identity["task_id"] = node_id
+    return identity
+
+
+def _encoded(value):
+    return json.dumps(value, ensure_ascii=True, allow_nan=False, sort_keys=True, separators=(",", ":"))
+
+
+def _reference(content):
+    return {
+        "storage": "cosmos", "schema_version": 1, "sha256": _digest(content),
+        "size_bytes": len(content.encode("ascii")), "chunk_count": 1,
+    }
+
+
+def _output(workflow_id, run_id, node_id, attempt, *, group=False):
+    identity = _identity(workflow_id, run_id, node_id, attempt)
+    kind = "json" if node_id == "evaluate" else "text"
+    message = f"Authoritative output excerpt from execution {identity['execution_id']} attempt {attempt}"
+    value = {"pass": not group, "add_note": False, "details": f"{message}. " + "record " * 340} if kind == "json" else message
+    return _encoded({
+        "contract_version": "workflow-result-v2", "producer": identity,
+        "output_name": kind, "kind": kind, "value": value,
+    })
+
+
+def _result(workflow_id, run_id, node_id, attempt, *, group=False):
+    content = _output(workflow_id, run_id, node_id, attempt, group=group)
+    output_name = "json" if node_id == "evaluate" else "text"
+    manifest = {
+        "contract_version": "workflow-result-v2", "identity": _identity(workflow_id, run_id, node_id, attempt),
+        "authoritative_output": output_name,
+        "outputs": {output_name: {"kind": output_name, "result_ref": _reference(content)}},
+    }
+    return {**manifest, "result_ref": _reference(_encoded(manifest))}
+
+
+def _receipt(workflow_id, run_id, *, group=False):
+    result = _result(workflow_id, run_id, "evaluate", 2, group=group)
+    return {
+        "input_name": "decision", "output_name": "json", "producer": result["identity"],
+        "result_ref": result["result_ref"], "output_ref": result["outputs"]["json"]["result_ref"],
+    }
+
+
+def _pages(records, first_size):
+    return {
+        "": {"items": records[:first_size], "next_cursor": "page-2" if len(records) > first_size else None},
+        **({"page-2": {"items": records[first_size:], "next_cursor": None}} if len(records) > first_size else {}),
+    }
+
+
+class WorkflowControlRuntimeFixture(WorkflowEditorFixture):
+    """Small server pages exercise cursor navigation independently of UI page size."""
+
+    def __init__(self, page):
+        super().__init__(page)
+        self.execution_pages = {}
+        self.attempt_pages = {}
+        self.decision_pages = {}
+        self.execution_nodes = {}
+        for scope, workflow_id, run_id in (
+            ("user", V3_WORKFLOW_ID, V3_RUN_ID),
+            ("group", GROUP_V3_WORKFLOW_ID, GROUP_V3_RUN_ID),
+        ):
+            group = scope == "group"
+            record = structured_workflow_record(
+                workflow_id, name="Group structured branch workflow" if group else "Structured branch workflow",
+                **({"group_id": GROUP_ID} if group else {}),
+            )
+            record["tasks"][2]["approval"] = {"required": True, "message": "Review this selected task before execution."}
+            workflows = self.group_workflows[GROUP_ID] if group else self.personal_workflows
+            workflows[workflow_id] = record
+            status = "waiting_approval" if group else "completed"
+            self.workflow_runs[workflow_id] = [{
+                "id": run_id, "workflow_id": workflow_id, "definition_version": 3,
+                "status": status, "durable_execution": True,
+                "started_at": "2026-09-17T14:00:00Z",
+                "completed_at": None if group else "2026-09-17T14:05:00Z",
+            }]
+            key = (scope, workflow_id, run_id)
+            runtime = {
+                "schema_version": 2, "version": 12, "state": status,
+                "phase": "Review approval" if group else "Completed selected path",
+                "memory": {"units": [], "decisions": []},
+            }
+            if group:
+                runtime["gate"] = {
+                    "id": "review-approval-gate", "kind": "approval", "unit_id": "task:review",
+                    "execution_id": execution_id(workflow_id, run_id, "review"), "node_id": "review",
+                    "attempt": 1, "iteration_path": [], "input_digest": _digest("review-input"),
+                    "reason": "Approval is required before the selected Review task.",
+                    "choices": ["approve", "reject"],
+                }
+            self.workflow_runtimes[key] = runtime
+            self.runtime_can_decide[key] = True
+            rows = [
+                ("evaluate", "task", "completed", 2, None, None),
+                ("choose", "if", "completed", 1, None, {"choice": "else" if group else "then", "selected_branch": "else" if group else "then"}),
+                ("accept" if group else "review", "task", "skipped", 0, "branch_not_selected", None),
+                ("review" if group else "accept", "task", "waiting_approval" if group else "completed", 1, None, None),
+            ]
+            if not group:
+                rows.extend([
+                    ("decision-join", "join", "completed", 1, None, None),
+                    ("bypass-note", "route", "completed", 1, None, {"choice": "route", "target_node_id": "finish"}),
+                    ("note", "task", "skipped", 0, "forward_route", None),
+                    ("finish", "task", "completed", 1, None, None),
+                ])
+            executions = []
+            for index, (node_id, kind, state, attempt, reason, decision) in enumerate(rows):
+                eid = execution_id(workflow_id, run_id, node_id)
+                execution = {
+                    "execution_id": eid, "node_id": node_id, "node_kind": kind,
+                    "iteration_path": [], "region_id": "review-path" if node_id == "review" else "accepted-path" if node_id == "accept" else "root",
+                    "sequence": index + 1, "state": state, "attempt": attempt,
+                }
+                if kind == "task":
+                    execution["task_id"] = node_id
+                if reason:
+                    execution["reason_code"] = reason
+                if decision:
+                    execution["decision"] = decision
+                    execution["consumed_inputs"] = [_receipt(workflow_id, run_id, group=group)]
+                attempts = []
+                if node_id == "evaluate":
+                    attempts.append({
+                        "execution_id": eid, "node_id": node_id, "task_id": node_id,
+                        "attempt": 1, "state": "failed",
+                    })
+                if attempt and kind == "task":
+                    item = {
+                        "execution_id": eid, "node_id": node_id, "task_id": node_id,
+                        "attempt": attempt, "state": state,
+                    }
+                    if state == "completed":
+                        item["workflow_result"] = _result(workflow_id, run_id, node_id, attempt, group=group)
+                        item["workflow_validation"] = {"version": 1, "status": "valid", "eligible": True, "reason_codes": [], "counts": {}}
+                        execution.update(workflow_result=item["workflow_result"], workflow_validation=item["workflow_validation"])
+                    attempts.append(item)
+                self.attempt_pages[(*key, eid)] = _pages(attempts, 50)
+                self.execution_nodes[(*key, eid)] = node_id
+                executions.append(execution)
+            self.execution_pages[key] = _pages(executions, 3 if group else 4)
+            decisions = [{
+                "execution_id": execution_id(workflow_id, run_id, "evaluate"), "node_id": "evaluate",
+                "attempt": 1, "gate_id": "evaluate-recovery-gate", "choice": "retry",
+                "input_digest": _digest("evaluate-input"), "decided_at": "2026-09-17T14:01:00Z",
+            }, {
+                "execution_id": execution_id(workflow_id, run_id, "choose"), "node_id": "choose",
+                "attempt": 1, "choice": "else" if group else "then", "selected_branch": "else" if group else "then",
+                "input_digest": _digest("decision-input"), "decided_at": "2026-09-17T14:03:00Z",
+            }]
+            if not group:
+                decisions.append({
+                    "execution_id": execution_id(workflow_id, run_id, "bypass-note"), "node_id": "bypass-note",
+                    "attempt": 1, "choice": "route", "target_node_id": "finish",
+                    "input_digest": _digest("route-input"), "decided_at": "2026-09-17T14:04:00Z",
+                })
+            self.decision_pages[key] = _pages(decisions, 1)
+
+    def _dispatch(self, route, entry):
+        if re.fullmatch(r"/api/(user|group)/workflows/[^/]+/runs/[^/]+/executions(?:/[^/]+/attempts(?:/\d+/result)?)?", entry.path):
+            self._execution_resource(route, entry)
+        elif re.fullmatch(r"/api/(user|group)/workflows/[^/]+/runs/[^/]+/runtime/decisions", entry.path):
+            self._read_page(route, entry, self.decision_pages, "decisions")
+        else:
+            super()._dispatch(route, entry)
+
+    def _key(self, entry):
+        parts = entry.path.split("/")
+        scope, workflow_id, run_id = parts[2], parts[4], parts[6]
+        assert entry.method == "GET", entry
+        assert entry.query.get("group_id") == ([GROUP_ID] if scope == "group" else None), entry
+        return scope, workflow_id, run_id
+
+    def _read_page(self, route, entry, collection, name, execution=None):
+        key = self._key(entry)
+        if execution is not None:
+            key = (*key, execution)
+        assert key in collection, f"Unexpected {name} lookup: {entry}"
+        assert 1 <= int(entry.query.get("limit", ["50"])[0]) <= 100, entry
+        pages = collection[key]
+        cursor = entry.query.get("cursor", [""])[0]
+        assert cursor in pages, f"Unexpected cursor: {entry}"
+        page = copy.deepcopy(pages[cursor])
+        self._json(route, {
+            name: page["items"], "next_cursor": page["next_cursor"],
+            "total_count": sum(len(item["items"]) for item in pages.values()),
+        })
+
+    def _execution_resource(self, route, entry):
+        parts = entry.path.split("/")
+        key = self._key(entry)
+        if len(parts) == 8:
+            self._read_page(route, entry, self.execution_pages, "executions")
+        elif len(parts) == 10:
+            self._read_page(route, entry, self.attempt_pages, "attempts", parts[8])
+        elif len(parts) == 12 and parts[11] == "result":
+            eid, attempt = parts[8], int(parts[10])
+            assert (*key, eid) in self.execution_nodes, entry
+            attempts = self.attempt_pages[(*key, eid)][""]["items"]
+            selected = next((item for item in attempts if item["attempt"] == attempt), None)
+            assert selected and selected.get("workflow_result"), f"No committed output for {entry}"
+            assert entry.query.get("output") == ["authoritative"], entry
+            offset = int(entry.query.get("offset", ["0"])[0])
+            limit = int(entry.query.get("limit", ["2000"])[0])
+            assert 0 <= offset and 1 <= limit <= 2000, entry
+            content = _output(key[1], key[2], self.execution_nodes[(*key, eid)], attempt, group=key[0] == "group")
+            assert offset < len(content), entry
+            end = min(len(content), offset + limit)
+            self._json(route, {
+                "content": content[offset:end], "output_name": selected["workflow_result"]["authoritative_output"],
+                "offset": offset, "next_offset": end if end < len(content) else None,
+                "total_bytes": len(content), "complete": end == len(content), "sha256": _digest(content),
+            })
+        else:
+            raise AssertionError(f"Unexpected execution route: {entry}")
+
+
+@pytest.fixture
+def workflow_control_ui(page):
+    fixture = WorkflowControlRuntimeFixture(page)
+    yield fixture
+    fixture.assert_clean()
diff --git a/ui_tests/fixtures/workflow_editor.py b/ui_tests/fixtures/workflow_editor.py
index 1572cde1b..0a246fd70 100644
--- a/ui_tests/fixtures/workflow_editor.py
+++ b/ui_tests/fixtures/workflow_editor.py
@@ -1,7 +1,7 @@
 # workflow_editor.py
 """
 Closed API fixtures for the native V2 workflow editor.
-Version: 0.261.111
+Version: 0.261.116
 Implemented in: 0.261.108
 """
 
@@ -99,6 +99,13 @@ def workflow_record(identifier=WORKFLOW_ID, **overrides):
 def editor_options(scope_type="personal", scope_id=None):
     return {
         "definition_version": 2,
+        "supported_definition_versions": [1, 2, 3],
+        "supported_node_kinds": ["task", "if", "route"],
+        "flow_limits": {
+            "max_nodes": 256, "max_depth": 4,
+            "max_predicate_nodes": 100, "max_predicate_depth": 8,
+            "max_executions": 5000, "deadline_seconds": 86400,
+        },
         "can_manage": True,
         "max_tasks": 6,
         "agents": [
@@ -203,7 +210,7 @@ def __init__(self, page: Page):
             ),
             UNSUPPORTED_WORKFLOW_ID: workflow_record(
                 UNSUPPORTED_WORKFLOW_ID,
-                definition_version=3,
+                definition_version=4,
                 name="Future workflow",
             ),
         }
@@ -434,7 +441,7 @@ def _workflow_collection(self, route, entry, workflows, scope_type, group_id=Non
             self._json(route, {"workflows": list(workflows.values())})
             return
         assert isinstance(entry.body, dict), entry
-        assert entry.body.get("definition_version") == 2, entry
+        assert entry.body.get("definition_version") in {2, 3}, entry
         if entry.body.get("runner_type") == "agent":
             assert isinstance(entry.body.get("selected_agent"), dict), entry.body
         for task in entry.body.get("tasks", []):
@@ -452,18 +459,15 @@ def _workflow_collection(self, route, entry, workflows, scope_type, group_id=Non
             # Human-readable fixture revisions are checked above. The structural
             # contract uses the production authored-content revision algorithm.
             validation_payload["definition_revision"] = workflow_definition_revision(existing)
-        validation_payload.pop("durable_execution", None)
-        for task in validation_payload.get("tasks", []):
-            task.pop("approval", None)
         try:
-            normalize_workflow_definition(
+            definition = normalize_workflow_definition(
                 validation_payload, existing, validation_payload["tasks"],
                 user_id=OWNER_ID, group_id=group_id or "",
             )
         except WorkflowDefinitionError as exc:
             self._json(route, {"error": str(exc)}, 400)
             return
-        saved = copy.deepcopy(entry.body)
+        saved = {**copy.deepcopy(entry.body), **definition}
         saved["id"] = identifier
         saved["definition_revision"] = f"revision:{identifier}:{len(self.workflow_writes) + 2}"
         workflows[identifier] = saved
diff --git a/ui_tests/test_v2_workflow_control_flow.py b/ui_tests/test_v2_workflow_control_flow.py
new file mode 100644
index 000000000..bd7595655
--- /dev/null
+++ b/ui_tests/test_v2_workflow_control_flow.py
@@ -0,0 +1,262 @@
+# test_v2_workflow_control_flow.py
+"""
+UI regressions for structured If/else, Run when and forward routing.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+The real local SPA uses the existing closed API fixture and production definition
+validation. No model, source service, publication or live workspace is invoked.
+"""
+
+import copy
+import re
+import sys
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / "ui_tests"))
+sys.path.insert(0, str(ROOT / "ui_tests" / "fixtures"))
+
+# Shared fixture imports follow its local module-path setup.
+from ui_tests.fixtures.workflow_editor import (
+    GROUP_ID,
+    WORKFLOW_ID,
+    connect_options,  # noqa: F401
+    workflow_ui,  # noqa: F401
+)
+from ui_tests.fixtures.workflow_control_definitions import (
+    STRUCTURED_ID,
+    flow_condition as condition,
+    structured_workflow_record as structured_record,
+)
+
+
+pytestmark = pytest.mark.ui
+
+
+def task_block(page, name):
+    return page.get_by_role("region", name=f"{name} block", exact=True)
+
+
+def add_task(page, region, region_name, name):
+    region.get_by_role("button", name=f"Add task to {region_name}", exact=True).click()
+    region.get_by_label("Task name", exact=True).last.fill(name)
+    block = task_block(page, name)
+    block.get_by_label("Instructions", exact=True).fill(f"Produce {name.lower()}.")
+    return block
+
+
+def open_details(block):
+    block.get_by_text("Runner, inputs, references and outputs", exact=True).click()
+
+
+def add_input(block, label, producer, alias, index=1, output=None):
+    block.get_by_role("button", name=f"Add {label.lower()} input", exact=True).click()
+    block.get_by_label(f"{label} input {index} name", exact=True).fill(alias)
+    block.get_by_label(f"{label} input {index} producer", exact=True).select_option(label=producer)
+    if output:
+        block.get_by_label(f"{label} input {index} output", exact=True).select_option(output)
+
+
+def select_condition(block, label, field):
+    block.get_by_label(f"{label} left input", exact=True).select_option("decision")
+    block.get_by_label(f"{label} left field", exact=True).select_option(field)
+
+
+def test_create_branches_skip_route_and_join_without_raw_json(workflow_ui):
+    ui, page = workflow_ui, workflow_ui.page
+    ui.open("/workspace/workflows")
+    page.get_by_role("button", name="Create workflow", exact=True).click()
+    page.get_by_label("Workflow name", exact=True).fill("Authored structured flow")
+    page.get_by_label("Model", exact=True).select_option(label="Workspace GPT \u00b7 aoai")
+    page.get_by_role("button", name="Enable structured control flow", exact=True).click()
+    page.get_by_role("button", name="Convert draft", exact=True).click()
+    main = page.get_by_role("group", name="Main region", exact=True)
+    main.get_by_label("Task name", exact=True).fill("Evaluate")
+    evaluate = task_block(page, "Evaluate")
+    evaluate.get_by_label("Instructions", exact=True).fill("Return a JSON object with Boolean pass and add_note fields.")
+    open_details(evaluate)
+    evaluate.get_by_label("Output contract for Evaluate", exact=True).select_option("json")
+    for field in ("pass", "add_note"):
+        evaluate.get_by_label("Decision field name", exact=True).fill(field)
+        evaluate.get_by_role("button", name="Add decision field", exact=True).click()
+    main.get_by_role("button", name="Add If/else to Main", exact=True).click()
+    branch = page.get_by_role("region", name="If / else block", exact=True)
+    add_input(branch, "If / else inputs", "Evaluate", "decision")
+    select_condition(branch, "If / else condition", "/pass")
+    add_task(page, page.get_by_role("group", name="Then region", exact=True), "Then", "Accept")
+    add_task(page, page.get_by_role("group", name="Else region", exact=True), "Else", "Review")
+    branch.get_by_role("button", name="Add joined output", exact=True).click()
+    branch.get_by_label("Join output 1 Then producer", exact=True).select_option(label="Accept")
+    branch.get_by_label("Join output 1 Then output", exact=True).select_option("text")
+    branch.get_by_label("Join output 1 Else producer", exact=True).select_option(label="Review")
+    branch.get_by_label("Join output 1 Else output", exact=True).select_option("text")
+    branch.get_by_label("Join output 1 kind", exact=True).select_option("text")
+
+    main.get_by_role("button", name="Add forward route to Main", exact=True).click()
+    route = page.get_by_role("region", name="Forward route block", exact=True)
+    add_input(route, "Forward route inputs", "Evaluate", "decision")
+    select_condition(route, "Forward route condition", "/pass")
+    note = add_task(page, main, "Main", "Optional note")
+    open_details(note)
+    add_input(note, "Optional note inputs", "Evaluate", "decision")
+    note.get_by_text("Run when", exact=True).click()
+    expect(note.get_by_role("checkbox", name=re.compile("^Run when"))).to_be_checked()
+    select_condition(note, "Run when for Optional note", "/add_note")
+    finish = add_task(page, main, "Main", "Finish")
+    open_details(finish)
+    finish.get_by_role("button", name="Add finish inputs input", exact=True).click()
+    producer = finish.get_by_label("Finish inputs input 1 producer", exact=True)
+    join_id = producer.locator("option").filter(has_text=re.compile("^Join ")).get_attribute("value")
+    assert join_id
+    producer.select_option(join_id)
+    finish.get_by_label("Finish inputs input 1 name", exact=True).fill("report")
+    finish.get_by_label("Finish inputs input 1 output", exact=True).select_option("report")
+    add_input(finish, "Finish inputs", "Optional note", "note", index=2, output="text")
+    finish.get_by_label("Finish inputs input 2 required", exact=True).uncheck()
+    route.get_by_label("Forward route target", exact=True).select_option(label="Finish")
+    final_outputs = page.get_by_role("group", name="Final outputs", exact=True)
+    add_input(final_outputs, "Final outputs", "Finish", "report", output="text")
+    ui.assert_no_overflow()
+    page.get_by_role("button", name="Save workflow", exact=True).click()
+    expect(page.get_by_role("dialog", name="Create workflow", exact=True)).to_have_count(0)
+
+    assert len(ui.workflow_writes) == 1
+    body = ui.workflow_writes[0].body
+    assert body["definition_version"] == 3
+    assert body["durable_execution"] is True
+    assert all(isinstance(task["inputs"], list) for task in body["tasks"])
+    nodes = body["flow"]["nodes"]
+    assert [node["kind"] for node in nodes] == ["task", "if", "route", "task", "task"]
+    assert nodes[1]["condition"]["left"] == {"input": "decision", "path": "/pass"}
+    assert nodes[1]["join"]["exports"][0]["name"] == "report"
+    assert nodes[2]["target"]["node_id"] == nodes[4]["id"]
+    assert nodes[3]["run_when"]["left"]["path"] == "/add_note"
+    assert body["tasks"][0]["output_contract"]["schema"]["properties"]["pass"] == {"type": "boolean"}
+    assert body["flow"]["outputs"][0]["source"]["node_id"] == nodes[4]["id"]
+    assert not any("/run" in request.path or "publication" in request.path for request in ui.writes)
+
+
+def test_skip_dependency_is_rejected_and_stale_save_retains_flow(workflow_ui):
+    ui, page = workflow_ui, workflow_ui.page
+    record = structured_record()
+    ui.personal_workflows[STRUCTURED_ID] = record
+    ui.open(f"/workspace/workflows?workflow_id={STRUCTURED_ID}")
+    finish = task_block(page, "Finish")
+    open_details(finish)
+    finish.get_by_label("Finish inputs input 2 required", exact=True).check()
+    page.get_by_role("button", name="Save workflow", exact=True).click()
+    expect(page.get_by_role("alert").filter(has_text="can be skipped")).to_be_visible()
+    assert not ui.workflow_writes
+    finish.get_by_label("Finish inputs input 2 required", exact=True).uncheck()
+    page.get_by_label("Workflow name", exact=True).fill("Retained structured draft")
+    ui.mutate_revision(STRUCTURED_ID)
+    page.get_by_role("button", name="Save workflow", exact=True).click()
+    expect(page.get_by_role("alert").filter(has_text="draft has been retained")).to_be_visible()
+    expect(page.get_by_label("Workflow name", exact=True)).to_have_value("Retained structured draft")
+    expect(page.get_by_label("Forward route target", exact=True)).to_have_value("node:finish")
+    expect(page.get_by_role("group", name="Then region", exact=True)).to_be_visible()
+    assert not ui.workflow_writes
+    assert record["flow"]["nodes"][3]["run_when"] == condition("add_note")
+
+
+@pytest.mark.parametrize("unsupported", ["node_kind", "executable_field", "input_kind", "runner_field"])
+def test_unknown_structured_semantics_are_read_only(workflow_ui, unsupported):
+    ui, page = workflow_ui, workflow_ui.page
+    record = structured_record()
+    if unsupported == "node_kind":
+        record["flow"]["nodes"][1]["kind"] = "for_each"
+    elif unsupported == "executable_field":
+        record["flow"]["nodes"][1]["condition"]["expression"] = "unrecognized executable field"
+    elif unsupported == "input_kind":
+        record["tasks"][3]["inputs"][0]["source"]["kind"] = "future_item"
+    else:
+        record["tasks"][3]["runner"]["future_tool_policy"] = "new executor semantics"
+    original = copy.deepcopy(record)
+    ui.personal_workflows[STRUCTURED_ID] = record
+    ui.open(f"/workspace/workflows?workflow_id={STRUCTURED_ID}")
+    expect(page.get_by_role("alert").filter(has_text="cannot safely save")).to_be_visible()
+    expect(page.get_by_role("button", name="Save workflow", exact=True)).to_have_count(0)
+    assert not ui.workflow_writes
+    assert ui.personal_workflows[STRUCTURED_ID] == original
+
+
+def test_structured_mobile_keyboard_edit_preserves_identity(workflow_ui):
+    ui, page = workflow_ui, workflow_ui.page
+    record = structured_record()
+    ui.personal_workflows[STRUCTURED_ID] = record
+    ui.open(f"/workspace/workflows?workflow_id={STRUCTURED_ID}", theme="dark", width=390, height=844)
+    ui.assert_no_overflow()
+    limit = page.get_by_label("Maximum execution admissions", exact=True)
+    limit.focus()
+    limit.press("ArrowDown")
+    expect(limit).to_have_value("4999")
+    save = page.get_by_role("button", name="Save workflow", exact=True)
+    save.focus()
+    save.press("Enter")
+    expect(page.get_by_role("dialog", name="Edit workflow", exact=True)).to_have_count(0)
+    assert ui.workflow_writes[-1].body["limits"]["max_executions"] == 4999
+    assert ui.workflow_writes[-1].body["flow"] == record["flow"]
+    assert [task["id"] for task in ui.workflow_writes[-1].body["tasks"]] == [task["id"] for task in record["tasks"]]
+    ui.assert_no_overflow()
+
+
+def test_group_structured_save_keeps_explicit_group_scope(workflow_ui):
+    ui, page = workflow_ui, workflow_ui.page
+    record = structured_record(group_id=GROUP_ID)
+    ui.group_workflows[GROUP_ID] = {STRUCTURED_ID: record}
+    ui.open("/groups")
+    page.get_by_label("Group workspace", exact=True).select_option(GROUP_ID)
+    expect(page.get_by_role("heading", name="Workflows", exact=True)).to_be_visible()
+    page.get_by_role("button", name=re.compile("Edit Structured review")).click()
+    page.get_by_label("Workflow name", exact=True).fill("Group structured review")
+    page.get_by_role("button", name="Save workflow", exact=True).click()
+    expect(page.get_by_role("dialog", name="Edit workflow", exact=True)).to_have_count(0)
+    write = ui.workflow_writes[-1]
+    assert write.path == "/api/group/workflows"
+    assert write.query["group_id"] == [GROUP_ID]
+    assert write.body["group_id"] == GROUP_ID
+    assert write.body["flow"] == record["flow"]
+    assert not any(request.path == "/api/user/settings" and request.method != "GET" for request in ui.requests)
+
+
+def test_conversion_never_silently_changes_continue_on_error_inputs(workflow_ui):
+    ui, page = workflow_ui, workflow_ui.page
+    ui.personal_workflows[WORKFLOW_ID]["error_handling"]["strategy"] = "continue"
+    ui.open(f"/workspace/workflows?workflow_id={WORKFLOW_ID}")
+    page.get_by_role("button", name="Enable structured control flow", exact=True).click()
+    page.get_by_role("button", name="Convert draft", exact=True).click()
+    expect(page.get_by_role("alert").filter(has_text="explicit task inputs")).to_be_visible()
+    expect(page.get_by_role("button", name="Enable structured control flow", exact=True)).to_be_visible()
+    assert ui.personal_workflows[WORKFLOW_ID]["definition_version"] == 2
+    assert not ui.workflow_writes
+
+
+def test_structured_publication_uses_one_explicit_input_and_destination(workflow_ui):
+    ui, page = workflow_ui, workflow_ui.page
+    record = structured_record()
+    record["tasks"][1]["document_action"] = {"type": "analyze", "document_ids": ["personal-brief"]}
+    ui.personal_workflows[STRUCTURED_ID] = record
+    ui.open(f"/workspace/workflows?workflow_id={STRUCTURED_ID}")
+    finish = task_block(page, "Finish")
+    open_details(finish)
+    finish.get_by_text("Publish an existing analysis artifact", exact=True).click()
+    finish.get_by_label("Publication scope for Finish", exact=True).select_option("group")
+    finish.get_by_label("Publication workspace ID for Finish", exact=True).fill("explicit-destination")
+    page.get_by_role("button", name="Save workflow", exact=True).click()
+    expect(page.get_by_role("alert").filter(has_text="exactly one explicit native Analyze input")).to_be_visible()
+    assert not ui.workflow_writes
+    finish.get_by_role("button", name="Finish inputs remove input 2", exact=True).click()
+    page.get_by_role("button", name="Save workflow", exact=True).click()
+    expect(page.get_by_role("dialog", name="Edit workflow", exact=True)).to_have_count(0)
+    task = ui.workflow_writes[-1].body["tasks"][-1]
+    assert task["publication"] == {
+        "artifact_format": "md", "workspace_scope": "group", "group_id": "explicit-destination",
+    }
+    assert len(task["inputs"]) == 1 and task["inputs"][0]["source"]["node_id"] == "decision-join"
+    assert task["runner"]["type"] == "inherit" and task["document_action"]["type"] == "none"
+    assert not any(request.path.endswith("/run") or request.path.endswith("/promote") for request in ui.writes)
diff --git a/ui_tests/test_v2_workflow_control_runtime.py b/ui_tests/test_v2_workflow_control_runtime.py
new file mode 100644
index 000000000..bdebb843d
--- /dev/null
+++ b/ui_tests/test_v2_workflow_control_runtime.py
@@ -0,0 +1,227 @@
+# test_v2_workflow_control_runtime.py
+"""
+UI tests for V2 workflow control-runtime run inspection.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+These tests use the real V2 SPA bundle with a closed API fixture. They cover
+definition v3 execution inspection, scoped runtime decisions, authoritative
+attempt output excerpts, and preservation of legacy v1/v2 task-result
+inspection.
+"""
+
+import re
+import sys
+import copy
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / "ui_tests"))
+sys.path.insert(0, str(ROOT / "ui_tests" / "fixtures"))
+
+from ui_tests.fixtures.workflow_control_runtime import (  # noqa: E402
+    GROUP_ID,
+    GROUP_V3_RUN_ID,
+    GROUP_V3_WORKFLOW_ID,
+    V3_RUN_ID,
+    V3_WORKFLOW_ID,
+    execution_id,
+    connect_options,  # noqa: F401
+    workflow_control_ui,  # noqa: F401
+)
+from ui_tests.fixtures.workflow_editor import WORKFLOW_ID  # noqa: E402
+
+
+pytestmark = pytest.mark.ui
+
+
+def expand_run_history(page, workflow_name):
+    row = page.get_by_role("listitem").filter(has_text=workflow_name).first
+    row.get_by_role("button", name="Show run history", exact=True).click()
+    row.get_by_role("button", name="Show run task results", exact=True).click()
+    return row
+
+
+def result_requests(ui):
+    return [request for request in ui.requests if request.path.endswith("/result")]
+
+
+def test_v3_execution_history_uses_exact_attempt_result_endpoint(workflow_control_ui):
+    ui, page = workflow_control_ui, workflow_control_ui.page
+    key = ("user", V3_WORKFLOW_ID, V3_RUN_ID)
+    # Deliberately unexpected provider fields must never become a debug dump.
+    ui.execution_pages[key][""]["items"][1]["decision"]["operands"] = {"private": "raw-secret-token"}
+    ui.workflow_runtimes[key]["memory"]["private_journal"] = "private-journal"
+    producer_id = execution_id(V3_WORKFLOW_ID, V3_RUN_ID, "evaluate")
+    ui.open("/workspace/workflows")
+    expand_run_history(page, "Structured branch workflow")
+
+    expect(page.get_by_text("Workflow execution history", exact=True)).to_be_visible()
+    expect(page.get_by_text(f"Execution: {producer_id}", exact=True)).to_be_visible()
+    expect(page.get_by_text("Reason code: branch_not_selected", exact=True)).to_be_visible()
+    expect(page.get_by_text("Selected branch or route: choice then \u00b7 branch then", exact=True)).to_be_visible()
+    receipts = page.get_by_role("list", name="Consumed producer references", exact=True)
+    expect(receipts).to_contain_text(f"execution {producer_id}")
+    expect(receipts).to_contain_text("decision from json")
+    expect(receipts).to_contain_text("attempt 2")
+    expect(receipts).to_contain_text("Consumed output ref")
+    expect(page.get_by_text("raw-secret-token", exact=True)).to_have_count(0)
+    expect(page.get_by_text("private-journal", exact=True)).to_have_count(0)
+
+    page.get_by_role("button", name=f"Show execution attempts for {producer_id}", exact=True).click()
+    attempts = page.get_by_role("list", name=f"Attempts for execution {producer_id}", exact=True)
+    attempt = attempts.get_by_role("listitem").filter(has_text="Attempt 2")
+    attempt.get_by_role("button", name="Load authoritative output excerpt", exact=True).click()
+    expect(page.get_by_text(f"Authoritative output excerpt from execution {producer_id} attempt 2", exact=False)).to_be_visible()
+    expect(attempts.get_by_text("No result was committed for this attempt.", exact=True)).to_be_visible()
+
+    exact_result_path = (
+        f"/api/user/workflows/{V3_WORKFLOW_ID}/runs/{V3_RUN_ID}"
+        f"/executions/{producer_id}/attempts/2/result"
+    )
+    assert any(
+        request.path == exact_result_path and request.query.get("output") == ["authoritative"]
+        for request in result_requests(ui)
+    )
+    assert not any(
+        request.path.startswith(f"/api/user/workflows/{V3_WORKFLOW_ID}/runs/{V3_RUN_ID}/tasks/")
+        for request in result_requests(ui)
+    )
+
+
+def test_v3_group_runtime_decisions_keep_scope_and_replace_pages(workflow_control_ui):
+    ui, page = workflow_control_ui, workflow_control_ui.page
+    review_id = execution_id(GROUP_V3_WORKFLOW_ID, GROUP_V3_RUN_ID, "review")
+    producer_id = execution_id(GROUP_V3_WORKFLOW_ID, GROUP_V3_RUN_ID, "evaluate")
+    ui.open("/groups")
+    page.get_by_label("Group workspace", exact=True).select_option(GROUP_ID)
+    expect(page.get_by_role("heading", name="Workflows", exact=True)).to_be_visible()
+    expand_run_history(page, "Group structured branch workflow")
+
+    expect(page.get_by_text(f"Execution {review_id} \u00b7 Node review \u00b7 Attempt 1", exact=True)).to_be_visible()
+    decisions = page.get_by_role("list", name="Runtime decisions", exact=True)
+    expect(decisions).to_contain_text("evaluate-recovery-gate")
+    expect(page.get_by_text("raw-secret-token", exact=True)).to_have_count(0)
+
+    page.get_by_role("button", name="Next executions page", exact=True).click()
+    expect(page.get_by_text(f"Execution: {review_id}", exact=True)).to_be_visible()
+    expect(page.get_by_text(f"Execution: {producer_id}", exact=True)).to_have_count(0)
+
+    page.get_by_role("button", name="Next decision page", exact=True).click()
+    expect(decisions).to_contain_text("choice else")
+    expect(decisions).not_to_contain_text("evaluate-recovery-gate")
+
+    scoped_requests = [
+        request for request in ui.requests
+        if request.path.startswith(f"/api/group/workflows/{GROUP_V3_WORKFLOW_ID}/runs/{GROUP_V3_RUN_ID}")
+    ]
+    assert scoped_requests
+    assert all(request.query.get("group_id") == [GROUP_ID] for request in scoped_requests)
+    assert not any(request.path == "/api/user/settings" and request.method != "GET" for request in ui.requests)
+
+
+def test_v2_runs_keep_legacy_task_result_inspection(workflow_control_ui):
+    ui, page = workflow_control_ui, workflow_control_ui.page
+    ui.open("/workspace/workflows")
+    expand_run_history(page, "Quarterly review workflow")
+
+    expect(page.get_by_text("Workflow execution history", exact=True)).to_have_count(0)
+    expect(page.get_by_text("Collect evidence", exact=True)).to_be_visible()
+    page.get_by_role("button", name="Load result excerpt", exact=True).first.click()
+    expect(page.get_by_text("First transport excerpt page for the authoritative output.", exact=True)).to_be_visible()
+
+    assert any(
+        request.path == f"/api/user/workflows/{WORKFLOW_ID}/runs/run-1/tasks/task-a/result"
+        for request in result_requests(ui)
+    )
+    assert not any(
+        request.path.startswith(f"/api/user/workflows/{WORKFLOW_ID}/runs/run-1/executions")
+        for request in ui.requests
+    )
+
+
+def test_failed_refresh_clears_cached_execution_receipts(workflow_control_ui):
+    ui, page = workflow_control_ui, workflow_control_ui.page
+    ui.open("/workspace/workflows")
+    expand_run_history(page, "Structured branch workflow")
+    expect(page.get_by_role("list", name="Consumed producer references", exact=True)).to_be_visible()
+    path = f"/api/user/workflows/{V3_WORKFLOW_ID}/runs/{V3_RUN_ID}/executions"
+    ui.failures.append(("GET", path, 403, {"error": "Source access could not be confirmed."}))
+    page.get_by_role("button", name="Refresh", exact=True).first.click()
+    expect(page.get_by_role("alert").filter(has_text="no longer have access")).to_be_visible()
+    expect(page.get_by_role("list", name="Workflow node executions", exact=True)).to_have_count(0)
+    expect(page.get_by_role("list", name="Consumed producer references", exact=True)).to_have_count(0)
+
+
+@pytest.mark.parametrize("malformed", ["null_record", "invalid_cursor", "duplicate_identity"])
+def test_malformed_execution_pages_fail_explicitly(workflow_control_ui, malformed):
+    ui, page = workflow_control_ui, workflow_control_ui.page
+    first = ui.execution_pages[("user", V3_WORKFLOW_ID, V3_RUN_ID)][""]
+    if malformed == "null_record":
+        first["items"][0] = None
+    elif malformed == "invalid_cursor":
+        first["next_cursor"] = 123
+    else:
+        first["items"].append(copy.deepcopy(first["items"][0]))
+    ui.open("/workspace/workflows")
+    expand_run_history(page, "Structured branch workflow")
+    expect(page.get_by_role("alert").filter(has_text=re.compile("unsupported response|conflicting identities"))).to_be_visible()
+    expect(page.get_by_role("list", name="Workflow node executions", exact=True)).to_have_count(0)
+    assert not result_requests(ui)
+
+
+def test_attempt_response_cannot_retarget_the_selected_execution(workflow_control_ui):
+    ui, page = workflow_control_ui, workflow_control_ui.page
+    eid = execution_id(V3_WORKFLOW_ID, V3_RUN_ID, "evaluate")
+    attempts = ui.attempt_pages[("user", V3_WORKFLOW_ID, V3_RUN_ID, eid)][""]["items"]
+    attempts[-1]["execution_id"] = execution_id(V3_WORKFLOW_ID, V3_RUN_ID, "review")
+    ui.open("/workspace/workflows")
+    expand_run_history(page, "Structured branch workflow")
+    page.get_by_role("button", name=f"Show execution attempts for {eid}", exact=True).click()
+    expect(page.get_by_role("alert").filter(has_text="unsupported response")).to_be_visible()
+    expect(page.get_by_role("button", name="Load authoritative output excerpt", exact=True)).to_have_count(0)
+    assert not result_requests(ui)
+
+
+def test_recovery_confirmation_does_not_transfer_to_a_new_attempt(workflow_control_ui):
+    ui, page = workflow_control_ui, workflow_control_ui.page
+    key = ("group", GROUP_V3_WORKFLOW_ID, GROUP_V3_RUN_ID)
+    eid = execution_id(GROUP_V3_WORKFLOW_ID, GROUP_V3_RUN_ID, "review")
+    runtime = ui.workflow_runtimes[key]
+    runtime["state"] = "waiting_recovery"
+    runtime["gate"].update(
+        id="review-recovery-1", kind="recovery", choices=["retry", "cancel"],
+        reason="The selected Review task failed after it started.",
+    )
+    ui.workflow_runs[GROUP_V3_WORKFLOW_ID][0]["status"] = "waiting_recovery"
+    execution = ui.execution_pages[key]["page-2"]["items"][0]
+    execution["state"] = "waiting_recovery"
+    attempts = ui.attempt_pages[(*key, eid)][""]["items"]
+    attempts[0]["state"] = "failed"
+    ui.open("/groups")
+    page.get_by_label("Group workspace", exact=True).select_option(GROUP_ID)
+    expand_run_history(page, "Group structured branch workflow")
+    page.get_by_role("button", name="Retry task", exact=True).click()
+    confirmation = page.get_by_role("dialog", name="Retry task?", exact=True)
+    expect(confirmation).to_contain_text(f"Execution {eid}")
+    expect(confirmation).to_contain_text("Attempt 1")
+
+    # Another reviewer retries the task; that second attempt fails and gets its
+    # own recovery gate while this browser still holds the first confirmation.
+    runtime["version"] += 5
+    runtime["gate"].update(id="review-recovery-2", attempt=2)
+    execution["attempt"] = 2
+    attempts.append({**copy.deepcopy(attempts[0]), "attempt": 2})
+    ui.decision_pages[key]["page-2"]["items"].extend([
+        {"execution_id": eid, "node_id": "review", "attempt": 1, "choice": "retry", "gate_id": "review-recovery-1"},
+        {"execution_id": eid, "node_id": "review", "attempt": 2, "choice": "approve", "gate_id": "review-approval-2"},
+    ])
+    expect(page.get_by_text(f"Execution {eid} \u00b7 Node review \u00b7 Attempt 2", exact=True)).to_be_visible()
+    confirmation.get_by_role("button", name="Retry task", exact=True).click()
+    expect(confirmation).to_have_count(0)
+    expect(page.get_by_role("alert").filter(has_text="recovery gate changed")).to_be_visible()
+    assert not any(request.path.endswith("/runtime/decision") and request.method == "POST" for request in ui.requests)
diff --git a/ui_tests/test_v2_workflow_editor.py b/ui_tests/test_v2_workflow_editor.py
index 488090e57..1ac8d66d0 100644
--- a/ui_tests/test_v2_workflow_editor.py
+++ b/ui_tests/test_v2_workflow_editor.py
@@ -1,7 +1,7 @@
 # test_v2_workflow_editor.py
 """
 UI tests for the native V2 LIST workflow editor.
-Version: 0.261.108
+Version: 0.261.116
 Implemented in: 0.261.108
 
 These tests use the real V2 SPA bundle with a closed API fixture. They cover
@@ -205,7 +205,7 @@ def test_unsupported_version_is_read_only_and_409_retains_draft(workflow_ui):
     ui.open("/workspace/workflows")
 
     page.get_by_role("button", name=re.compile(r"Edit Future workflow")).click()
-    expect(page.get_by_role("alert").filter(has_text="definition version 3")).to_be_visible()
+    expect(page.get_by_role("alert").filter(has_text="definition version 4")).to_be_visible()
     expect(page.get_by_role("button", name="Save workflow", exact=True)).to_have_count(0)
     page.get_by_role("dialog", name="Edit workflow", exact=True).get_by_role(
         "button", name="Close", exact=True
diff --git a/ui_tests/test_workflow_classic_advanced_guard.py b/ui_tests/test_workflow_classic_advanced_guard.py
new file mode 100644
index 000000000..0a33ded2e
--- /dev/null
+++ b/ui_tests/test_workflow_classic_advanced_guard.py
@@ -0,0 +1,86 @@
+# test_workflow_classic_advanced_guard.py
+"""
+Source-backed browser coverage for the Classic advanced-workflow edit guard.
+Version: 0.261.116
+Implemented in: 0.261.116
+
+The actual local edit function must stop before loading runners or resetting a
+draft for advanced definitions. Legacy eligibility and Run/Cancel are unchanged.
+"""
+
+import re
+from pathlib import Path
+
+import pytest
+from playwright.sync_api import expect
+
+from ui_tests.fixtures.playwright_connection import connect_options  # noqa: F401
+
+
+SOURCE = Path(__file__).resolve().parents[1] / "application" / "single_app" / "static" / "js" / "workspace" / "workspace_workflows.js"
+ORIGIN = "http://workflow-guard.test"
+pytestmark = pytest.mark.ui
+
+
+def _function(source, name):
+    start = re.search(rf"(?m)^(?:async )?function {name}\(", source)
+    assert start, f"Missing production function {name}."
+    following = re.search(r"(?m)^(?:async )?function ", source[start.end():])
+    assert following, f"Missing end boundary for production function {name}."
+    return source[start.start():start.end() + following.start()]
+
+
+@pytest.mark.parametrize("scope", ["personal", "group"])
+@pytest.mark.parametrize("version", [2, 3, 4, "3"])
+def test_classic_advanced_edit_stops_before_preparation(page, scope, version):
+    source = SOURCE.read_text(encoding="utf-8")
+    functions = "\n".join(_function(source, name) for name in ("workflowNeedsNativeEditor", "openWorkflowModal"))
+    script = """
+window.preparationCalls = 0;
+const workflowModal = {show() { window.preparationCalls++; }};
+const workflowWorkspaceConfig = {scope: 'personal'};
+function getWorkflowActiveGroupId() { return 'group-1'; }
+async function loadAgentOptions() { window.preparationCalls++; throw new Error('Unexpected runner loading'); }
+async function loadFileSyncSourceOptions() { window.preparationCalls++; throw new Error('Unexpected source loading'); }
+function resetWorkflowForm() { window.preparationCalls++; }
+function showToast(message, tone) {
+    const notice = document.createElement('div');
+    notice.classList.add('alert', `alert-${tone}`);
+    notice.setAttribute('role', 'alert');
+    notice.textContent = message;
+    document.body.appendChild(notice);
+}
+""" + functions + """
+document.getElementById('edit').addEventListener('click', () => openWorkflowModal(window.testWorkflow));
+window.configureScope = scope => { workflowWorkspaceConfig.scope = scope; };
+"""
+    unexpected = []
+    errors = []
+    page.on("pageerror", lambda error: errors.append(str(error)))
+
+    def route(request):
+        if request.request.url == f"{ORIGIN}/":
+            request.fulfill(
+                content_type="text/html",
+                body='<html lang="en"><body><button id="edit" type="button">Edit workflow</button><script src="/guard.js"></script></body></html>',
+            )
+        elif request.request.url == f"{ORIGIN}/guard.js":
+            request.fulfill(content_type="application/javascript", body=script)
+        else:
+            unexpected.append(request.request.url)
+            request.abort()
+
+    page.route("**/*", route)
+    page.goto(f"{ORIGIN}/")
+    page.evaluate("(scope) => window.configureScope(scope)", scope)
+    page.evaluate("(version) => { window.testWorkflow = {id: 'workflow', definition_version: version}; }", version)
+    page.get_by_role("button", name="Edit workflow", exact=True).click()
+    expect(page.get_by_role("alert")).to_contain_text("Open V2 to edit")
+    expect(page.get_by_role("alert")).to_contain_text("Run and Cancel remain available")
+    assert page.evaluate("window.preparationCalls") == 0
+    assert page.evaluate("workflowNeedsNativeEditor(null)") is False
+    assert page.evaluate("workflowNeedsNativeEditor({id: 'legacy'})") is False
+    assert page.evaluate("workflowNeedsNativeEditor({definition_version: 1})") is False
+    assert page.evaluate("workflowNeedsNativeEditor({definition_version: 1, flow: {}})") is True
+    assert not unexpected
+    assert not errors