devagent-physical-engine 0.11.3__tar.gz → 0.11.4__tar.gz

{devagent_physical_engine-0.11.3/src/devagent_physical_engine.egg-info → devagent_physical_engine-0.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devagent-physical-engine
-Version: 0.11.3
+Version: 0.11.4
 Summary: Verification-first agentic planning runtime for robotic and industrial automation.
 Author: Tom Ha
 License: All Rights Reserved
@@ -49,11 +49,11 @@ DevAgent Smart Physical Engine adds AI-assisted engineering to existing automati
 
 ## Current version
 
-**v0.11.3 — Beta software / evidence-gated physical runtime**
+**v0.11.4 — Beta software / evidence-gated physical runtime**
 
 The Python software stack is regression-tested on Python 3.11, 3.12, and 3.13 with separate static/coverage, package-install, and runtime dependency security gates. The UR5e Gazebo/MoveIt path now contains production-candidate continuous-clearance, tool-collision, and workpiece-lifecycle capabilities, but those physical-simulation scopes remain **EXPERIMENTAL until the executable target-workstation v0.11 campaign passes**.
 
-v0.11.3 also normalizes provider-neutral agent schemas at the OpenAI transport boundary so strict Structured Outputs can represent DevAgent optional fields without changing Anthropic/Gemini or deterministic core semantics.
+v0.11.3 normalized provider-neutral agent schemas at the OpenAI transport boundary so strict Structured Outputs can represent DevAgent optional fields without changing Anthropic/Gemini or deterministic core semantics. v0.11.4 adds live terminal progress tracing for AI request, engineering, and provider-qualification workflows. Progress is written to `stderr`; final machine-readable JSON remains isolated on `stdout`.
 
 Real robot execution remains locked. Functional-safety certification and site qualification are not claimed.
 
@@ -65,6 +65,7 @@ Real robot execution remains locked. Functional-safety certification and site qu
 | OpenAI / Anthropic / Gemini structured adapters | Implemented |
 | Planner / Critic / Recovery | Implemented |
 | Natural-language engineering request front door | Implemented |
+| Live terminal stage tracing (`stderr`) | Implemented; `--quiet` supported |
 | Deterministic compiler / semantic / verification gates | Implemented |
 | Multi-vendor robot profile registry | Implemented |
 | UR5e / FANUC CRX / KUKA KR / ABB IRB abstraction | Implemented; physical qualification is vendor-specific |
@@ -210,6 +211,25 @@ devagent-physical-ai engineer \
   --provider openai --model <model-id>
 ```
 
+Live commands now show stage-by-stage progress while they are running, for example:
+
+```text
+[DevAgent +   0.00s] START        provider=openai model=<model-id>
+[DevAgent +   0.00s] INTERPRETER  understanding engineering request
+[DevAgent +   6.84s] INTERPRETER  validated request_id=REQ-...
+[DevAgent +   6.84s] REASONING    risk_score=1 max_revisions=1 critic_threshold=0.70
+[DevAgent +   6.84s] PLANNER      revision=0 generating high-level task graph
+[DevAgent +  12.21s] PLANNER      revision=0 proposal compiled and deterministically verified
+[DevAgent +  12.21s] CRITIC       revision=0 reviewing verified plan
+[DevAgent +  15.77s] CRITIC       revision=0 decision=accept score=0.91
+[DevAgent +  15.77s] PLANNING     verified plan accepted after revision=0
+[DevAgent +  15.77s] SIMULATION   running deterministic model execution
+[DevAgent +  15.78s] SIMULATION   deterministic model execution completed
+[DevAgent +  15.78s] COMPLETE     ready_for_twin_simulation=true
+```
+
+Progress logs are emitted to `stderr`, so piping `stdout` still produces clean JSON. For CI or scripts that do not want terminal progress, add `--quiet`.
+
 Equivalent routing supports Anthropic and Gemini. Live AI qualification does not unlock real robot execution.
 
 ## Software production gates

{devagent_physical_engine-0.11.3 → devagent_physical_engine-0.11.4}/README.md

@@ -8,11 +8,11 @@ DevAgent Smart Physical Engine adds AI-assisted engineering to existing automati
 
 ## Current version
 
-**v0.11.3 — Beta software / evidence-gated physical runtime**
+**v0.11.4 — Beta software / evidence-gated physical runtime**
 
 The Python software stack is regression-tested on Python 3.11, 3.12, and 3.13 with separate static/coverage, package-install, and runtime dependency security gates. The UR5e Gazebo/MoveIt path now contains production-candidate continuous-clearance, tool-collision, and workpiece-lifecycle capabilities, but those physical-simulation scopes remain **EXPERIMENTAL until the executable target-workstation v0.11 campaign passes**.
 
-v0.11.3 also normalizes provider-neutral agent schemas at the OpenAI transport boundary so strict Structured Outputs can represent DevAgent optional fields without changing Anthropic/Gemini or deterministic core semantics.
+v0.11.3 normalized provider-neutral agent schemas at the OpenAI transport boundary so strict Structured Outputs can represent DevAgent optional fields without changing Anthropic/Gemini or deterministic core semantics. v0.11.4 adds live terminal progress tracing for AI request, engineering, and provider-qualification workflows. Progress is written to `stderr`; final machine-readable JSON remains isolated on `stdout`.
 
 Real robot execution remains locked. Functional-safety certification and site qualification are not claimed.
 
@@ -24,6 +24,7 @@ Real robot execution remains locked. Functional-safety certification and site qu
 | OpenAI / Anthropic / Gemini structured adapters | Implemented |
 | Planner / Critic / Recovery | Implemented |
 | Natural-language engineering request front door | Implemented |
+| Live terminal stage tracing (`stderr`) | Implemented; `--quiet` supported |
 | Deterministic compiler / semantic / verification gates | Implemented |
 | Multi-vendor robot profile registry | Implemented |
 | UR5e / FANUC CRX / KUKA KR / ABB IRB abstraction | Implemented; physical qualification is vendor-specific |
@@ -169,6 +170,25 @@ devagent-physical-ai engineer \
   --provider openai --model <model-id>
 ```
 
+Live commands now show stage-by-stage progress while they are running, for example:
+
+```text
+[DevAgent +   0.00s] START        provider=openai model=<model-id>
+[DevAgent +   0.00s] INTERPRETER  understanding engineering request
+[DevAgent +   6.84s] INTERPRETER  validated request_id=REQ-...
+[DevAgent +   6.84s] REASONING    risk_score=1 max_revisions=1 critic_threshold=0.70
+[DevAgent +   6.84s] PLANNER      revision=0 generating high-level task graph
+[DevAgent +  12.21s] PLANNER      revision=0 proposal compiled and deterministically verified
+[DevAgent +  12.21s] CRITIC       revision=0 reviewing verified plan
+[DevAgent +  15.77s] CRITIC       revision=0 decision=accept score=0.91
+[DevAgent +  15.77s] PLANNING     verified plan accepted after revision=0
+[DevAgent +  15.77s] SIMULATION   running deterministic model execution
+[DevAgent +  15.78s] SIMULATION   deterministic model execution completed
+[DevAgent +  15.78s] COMPLETE     ready_for_twin_simulation=true
+```
+
+Progress logs are emitted to `stderr`, so piping `stdout` still produces clean JSON. For CI or scripts that do not want terminal progress, add `--quiet`.
+
 Equivalent routing supports Anthropic and Gemini. Live AI qualification does not unlock real robot execution.
 
 ## Software production gates
@@ -294,4 +314,4 @@ DevAgent Smart Physical Engine
 Copyright © 2026 Tom Ha  
 Original creator: Tom Ha  
 Original project: https://github.com/tomha85/devagent-physical-engine  
-All rights reserved.
+All rights reserved.

{devagent_physical_engine-0.11.3 → devagent_physical_engine-0.11.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devagent-physical-engine"
-version = "0.11.3"
+version = "0.11.4"
 description = "Verification-first agentic planning runtime for robotic and industrial automation."
 readme = "README.md"
 requires-python = ">=3.11"

{devagent_physical_engine-0.11.3 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/__init__.py

@@ -41,4 +41,4 @@ __all__ = [
     "TwinValidator",
 ]
 
-__version__ = "0.11.3"
+__version__ = "0.11.4"

{devagent_physical_engine-0.11.3 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/agent/coordinator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Mapping
+from typing import Any, Callable, Mapping
 
 from .contracts import AgentEvidence, CriticDecision, RoutingPolicy
 from .critic import CriticAgent
@@ -9,6 +9,8 @@ from .evidence import task_graph_hash
 from .planner import PlannerAgent
 from ..models import Goal, Resource, TaskGraph, WorldState
 
+ProgressCallback = Callable[[str, str], None]
+
 
 class PlanningCoordinationError(RuntimeError):
     pass
@@ -52,12 +54,18 @@ class PlanningCoordinator:
         critic_policy: RoutingPolicy,
         *,
         engineering_context: Mapping[str, Any] | None = None,
+        progress: ProgressCallback | None = None,
     ) -> VerifiedPlanArtifact:
         feedback: tuple[str, ...] = ()
         planner_evidence: list[AgentEvidence] = []
         critic_evidence: list[AgentEvidence] = []
 
         for revision in range(self.max_revision_rounds + 1):
+            if progress is not None:
+                progress(
+                    "PLANNER",
+                    f"revision={revision} generating high-level task graph",
+                )
             planned = self.planner.plan(
                 goal,
                 resources,
@@ -67,6 +75,15 @@ class PlanningCoordinator:
                 engineering_context=engineering_context,
             )
             planner_evidence.append(planned.evidence)
+            if progress is not None:
+                progress(
+                    "PLANNER",
+                    f"revision={revision} proposal compiled and deterministically verified",
+                )
+                progress(
+                    "CRITIC",
+                    f"revision={revision} reviewing verified plan",
+                )
 
             reviewed = self.critic.review(
                 goal,
@@ -77,11 +94,24 @@ class PlanningCoordinator:
                 engineering_context=engineering_context,
             )
             critic_evidence.append(reviewed.evidence)
+            if progress is not None:
+                progress(
+                    "CRITIC",
+                    (
+                        f"revision={revision} decision={reviewed.critique.decision.value} "
+                        f"score={reviewed.critique.score:.2f}"
+                    ),
+                )
 
             if (
                 reviewed.critique.decision is CriticDecision.ACCEPT
                 and reviewed.critique.score >= self.min_accept_score
             ):
+                if progress is not None:
+                    progress(
+                        "PLANNING",
+                        f"verified plan accepted after revision={revision}",
+                    )
                 return VerifiedPlanArtifact(
                     graph=planned.graph,
                     graph_hash=task_graph_hash(planned.graph),
@@ -91,6 +121,8 @@ class PlanningCoordinator:
                 )
 
             if reviewed.critique.decision is CriticDecision.REJECT:
+                if progress is not None:
+                    progress("PLANNING", f"critic rejected revision={revision}")
                 raise PlanningCoordinationError(
                     "critic_rejected_plan:"
                     + ";".join(reviewed.critique.issues)
@@ -104,5 +136,12 @@ class PlanningCoordinator:
                 feedback = reviewed.critique.issues or (
                     "critic_requested_revision",
                 )
+            if progress is not None:
+                progress(
+                    "PLANNING",
+                    f"revision={revision} requires another planning round",
+                )
 
+        if progress is not None:
+            progress("PLANNING", "revision budget exhausted")
         raise PlanningCoordinationError("revision_budget_exhausted")

{devagent_physical_engine-0.11.3 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/ai_cli.py

@@ -4,6 +4,9 @@ import argparse
 import importlib.util
 import json
 import os
+import sys
+import time
+from collections.abc import Callable
 
 from .agent import (
     AgentRuntime,
@@ -20,6 +23,8 @@ from .provider_adapters import PROVIDER_NAMES, create_provider
 from .provider_qualification import qualify_live_provider
 from .providers import ModelRegistry, ModelSpec, QualificationStatus
 
+ProgressCallback = Callable[[str, str], None]
+
 
 def _add_live_request_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("text", help="Natural-language engineering request")
@@ -33,6 +38,11 @@ def _add_live_request_args(parser: argparse.ArgumentParser) -> None:
     )
     parser.add_argument("--timeout", type=float, default=30.0)
     parser.add_argument("--max-attempts", type=int, default=2)
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress terminal progress logs; final JSON remains on stdout",
+    )
 
 
 def _parser() -> argparse.ArgumentParser:
@@ -54,6 +64,11 @@ def _parser() -> argparse.ArgumentParser:
     qualify.add_argument("--timeout", type=float, default=30.0)
     qualify.add_argument("--max-attempts", type=int, default=2)
     qualify.add_argument("--max-revisions", type=int, default=2)
+    qualify.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress terminal progress logs; final JSON remains on stdout",
+    )
 
     request = sub.add_parser(
         "request",
@@ -93,6 +108,28 @@ def provider_doctor(provider: str) -> dict:
     }
 
 
+def _terminal_progress(enabled: bool) -> ProgressCallback | None:
+    if not enabled:
+        return None
+    started = time.monotonic()
+
+    def emit(stage: str, message: str) -> None:
+        elapsed = time.monotonic() - started
+        label = stage.strip().upper()[:12]
+        print(
+            f"[DevAgent +{elapsed:7.2f}s] {label:<12} {message}",
+            file=sys.stderr,
+            flush=True,
+        )
+
+    return emit
+
+
+def _emit(progress: ProgressCallback | None, stage: str, message: str) -> None:
+    if progress is not None:
+        progress(stage, message)
+
+
 def _live_runtime(provider_name: str, model: str, *, timeout: float, max_attempts: int):
     provider = create_provider(provider_name)
     registry = ModelRegistry()
@@ -123,30 +160,51 @@ def _live_runtime(provider_name: str, model: str, *, timeout: float, max_attempt
     return provider, runtime, policy
 
 
-def _request(args: argparse.Namespace) -> int:
+def _request(args: argparse.Namespace, progress: ProgressCallback | None = None) -> int:
+    _emit(progress, "START", f"provider={args.provider} model={args.model}")
     _, runtime, policy = _live_runtime(
         args.provider,
         args.model,
         timeout=args.timeout,
         max_attempts=args.max_attempts,
     )
+    _emit(progress, "INTERPRETER", "understanding engineering request")
     interpreted = RequirementInterpreterAgent(runtime).interpret(
         args.text,
         policy,
         follow_ups=args.follow_up,
     )
+    if interpreted.validated is not None:
+        _emit(
+            progress,
+            "INTERPRETER",
+            f"validated request_id={interpreted.validated.request_id}",
+        )
+    elif interpreted.rejection_code:
+        _emit(
+            progress,
+            "INTERPRETER",
+            f"request rejected code={interpreted.rejection_code}",
+        )
+    else:
+        _emit(progress, "INTERPRETER", "more engineering information required")
+
     payload = interpreted.to_dict()
     payload["provider_mode"] = "simulation_only_ephemeral_route"
     payload["real_execution_allowed"] = False
     print(json.dumps(payload, indent=2))
     if interpreted.validated is not None:
+        _emit(progress, "COMPLETE", "request validation passed")
         return 0
     if interpreted.rejection_code:
+        _emit(progress, "COMPLETE", "request validation rejected")
         return 4
+    _emit(progress, "COMPLETE", "request requires follow-up information")
     return 3
 
 
-def _engineer(args: argparse.Namespace) -> int:
+def _engineer(args: argparse.Namespace, progress: ProgressCallback | None = None) -> int:
+    _emit(progress, "START", f"provider={args.provider} model={args.model}")
     _, runtime, policy = _live_runtime(
         args.provider,
         args.model,
@@ -164,6 +222,7 @@ def _engineer(args: argparse.Namespace) -> int:
         planner_policy=policy,
         critic_policy=policy,
         follow_ups=args.follow_up,
+        progress=progress,
     )
     payload = result.to_dict()
     payload["provider_mode"] = "simulation_only_ephemeral_route"
@@ -171,12 +230,25 @@ def _engineer(args: argparse.Namespace) -> int:
     print(json.dumps(payload, indent=2))
     if result.ready_for_twin_simulation:
         return 0
+    _emit(
+        progress,
+        "COMPLETE",
+        (
+            "ready_for_twin_simulation=false "
+            f"failure_code={result.failure_code or 'more_information_required'}"
+        ),
+    )
     if result.interpretation.validated is None and not result.interpretation.rejection_code:
         return 3
     return 4
 
 
-def _natural_language_failure(exc: BaseException) -> int:
+def _natural_language_failure(
+    exc: BaseException,
+    *,
+    progress: ProgressCallback | None = None,
+) -> int:
+    _emit(progress, "FAILED", f"pipeline stopped type={type(exc).__name__}")
     print(
         json.dumps(
             {
@@ -198,18 +270,21 @@ def main(argv: list[str] | None = None) -> int:
         print(json.dumps(result, indent=2))
         return 0 if result["ready_for_live_qualification"] else 1
 
+    progress = _terminal_progress(not getattr(args, "quiet", False))
+
     if args.command == "request":
         try:
-            return _request(args)
+            return _request(args, progress)
         except Exception as exc:
-            return _natural_language_failure(exc)
+            return _natural_language_failure(exc, progress=progress)
 
     if args.command == "engineer":
         try:
-            return _engineer(args)
+            return _engineer(args, progress)
         except Exception as exc:
-            return _natural_language_failure(exc)
+            return _natural_language_failure(exc, progress=progress)
 
+    _emit(progress, "START", f"provider={args.provider} model={args.model}")
     provider = create_provider(args.provider)
     report = qualify_live_provider(
         provider,
@@ -217,6 +292,12 @@ def main(argv: list[str] | None = None) -> int:
         timeout_s=args.timeout,
         max_attempts=args.max_attempts,
         max_revision_rounds=args.max_revisions,
+        progress=progress,
+    )
+    _emit(
+        progress,
+        "RESULT",
+        f"passed={str(report.passed).lower()} failure_code={report.failure_code or 'none'}",
     )
     print(json.dumps(report.to_dict(), indent=2))
     return 0 if report.passed else 2

{devagent_physical_engine-0.11.3 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/engineering_agent.py

@@ -4,7 +4,12 @@ from dataclasses import asdict, dataclass
 from typing import Any, Sequence
 
 from .agent.contracts import AgentEvidence, RoutingPolicy
-from .agent.coordinator import PlanningCoordinationError, PlanningCoordinator, VerifiedPlanArtifact
+from .agent.coordinator import (
+    PlanningCoordinationError,
+    PlanningCoordinator,
+    ProgressCallback,
+    VerifiedPlanArtifact,
+)
 from .agent.critic import CriticAgent
 from .agent.evidence import task_graph_to_dict
 from .agent.interpreter import InterpretedEngineeringRequest, RequirementInterpreterAgent
@@ -153,7 +158,10 @@ class SmartEngineeringAgent:
         planner_policy: RoutingPolicy,
         critic_policy: RoutingPolicy,
         follow_ups: Sequence[str] = (),
+        progress: ProgressCallback | None = None,
     ) -> SmartEngineeringResult:
+        if progress is not None:
+            progress("INTERPRETER", "understanding engineering request")
         interpreted = self.interpreter.interpret(
             text,
             interpreter_policy,
@@ -161,12 +169,32 @@ class SmartEngineeringAgent:
         )
         request = interpreted.validated
         if request is None:
+            if progress is not None:
+                if interpreted.rejection_code:
+                    progress(
+                        "INTERPRETER",
+                        f"request rejected code={interpreted.rejection_code}",
+                    )
+                else:
+                    progress("INTERPRETER", "more engineering information required")
             return SmartEngineeringResult(
                 interpretation=interpreted,
                 failure_code=interpreted.rejection_code,
             )
 
+        if progress is not None:
+            progress("INTERPRETER", f"validated request_id={request.request_id}")
+
         strategy = self.reasoning_policy.select(request)
+        if progress is not None:
+            progress(
+                "REASONING",
+                (
+                    f"risk_score={strategy.risk_score} "
+                    f"max_revisions={strategy.max_revision_rounds} "
+                    f"critic_threshold={strategy.min_critic_score:.2f}"
+                ),
+            )
         goal = request.goal()
         resources = [request.resource()]
         # Explicit nominal model state, never represented as observed site state.
@@ -191,14 +219,19 @@ class SmartEngineeringAgent:
                 planner_policy,
                 critic_policy,
                 engineering_context=request.to_dict(),
+                progress=progress,
             )
         except PlanningCoordinationError as exc:
+            if progress is not None:
+                progress("PLANNING", "planning coordination failed")
             return SmartEngineeringResult(
                 interpretation=interpreted,
                 reasoning_strategy=strategy,
                 failure_code=f"planning_failed:{str(exc).split(':', 1)[0]}",
             )
         except Exception as exc:
+            if progress is not None:
+                progress("PLANNING", f"planning failed type={type(exc).__name__}")
             # Never expose provider/internal exception text as customer evidence.
             return SmartEngineeringResult(
                 interpretation=interpreted,
@@ -206,6 +239,8 @@ class SmartEngineeringAgent:
                 failure_code=f"planning_failed:{type(exc).__name__}",
             )
 
+        if progress is not None:
+            progress("SIMULATION", "running deterministic model execution")
         simulation_world = WorldState(facts=set(world.facts), values=dict(world.values))
         simulation = ExecutionSupervisor().execute(
             plan.graph,
@@ -216,6 +251,11 @@ class SmartEngineeringAgent:
         )
         if not simulation.completed:
             issue_codes = sorted({issue.code for issue in simulation.issues})
+            if progress is not None:
+                progress(
+                    "SIMULATION",
+                    "blocked by deterministic constraints",
+                )
             return SmartEngineeringResult(
                 interpretation=interpreted,
                 reasoning_strategy=strategy,
@@ -227,6 +267,9 @@ class SmartEngineeringAgent:
                 ),
             )
 
+        if progress is not None:
+            progress("SIMULATION", "deterministic model execution completed")
+            progress("COMPLETE", "ready_for_twin_simulation=true")
         return SmartEngineeringResult(
             interpretation=interpreted,
             reasoning_strategy=strategy,

{devagent_physical_engine-0.11.3 → devagent_physical_engine-0.11.4}/src/devagent_physical_engine/provider_qualification.py

@@ -15,6 +15,7 @@ from .agent import (
     RoutingPolicy,
     RoutingStrategy,
 )
+from .agent.coordinator import ProgressCallback
 from .agent.runtime import AgentRuntimeError
 from .execution import ExecutionMode, ExecutionSupervisor
 from .models import WorldState
@@ -97,6 +98,7 @@ def qualify_live_provider(
     timeout_s: float = 30.0,
     max_attempts: int = 2,
     max_revision_rounds: int = 2,
+    progress: ProgressCallback | None = None,
 ) -> LiveProviderQualificationReport:
     """Run Interpreter -> Planner -> Critic -> verify/simulate -> Recovery.
 
@@ -140,12 +142,16 @@ def qualify_live_provider(
     request_validated = False
 
     try:
+        if progress is not None:
+            progress("INTERPRETER", "running qualification request interpretation")
         interpreted = RequirementInterpreterAgent(runtime).interpret(
             "Use the UR5e to load P17 from conveyor_a into cnc_04. Simulate the operation using an engineering test preset.",
             policy,
         )
         evidence.append(interpreted.evidence)
         if interpreted.validated is None:
+            if progress is not None:
+                progress("INTERPRETER", "qualification request was not validated")
             request_ids = _request_ids(evidence)
             input_tokens, output_tokens, total_tokens = _usage(provider, request_ids)
             return LiveProviderQualificationReport(
@@ -169,6 +175,8 @@ def qualify_live_provider(
 
         request_validated = True
         request = interpreted.validated
+        if progress is not None:
+            progress("INTERPRETER", f"validated request_id={request.request_id}")
         goal = request.goal()
         robot = request.resource()
 
@@ -189,10 +197,13 @@ def qualify_live_provider(
             policy,
             policy,
             engineering_context=request.to_dict(),
+            progress=progress,
         )
         evidence.extend(artifact.planner_evidence)
         evidence.extend(artifact.critic_evidence)
 
+        if progress is not None:
+            progress("SIMULATION", "running deterministic qualification simulation")
         simulation_world = WorldState(facts=set(world.facts), values=dict(world.values))
         simulation = ExecutionSupervisor().execute(
             artifact.graph,
@@ -202,6 +213,8 @@ def qualify_live_provider(
             ExecutionMode.SIMULATION,
         )
         if not simulation.completed:
+            if progress is not None:
+                progress("SIMULATION", "deterministic qualification simulation failed")
             request_ids = _request_ids(evidence)
             input_tokens, output_tokens, total_tokens = _usage(provider, request_ids)
             return LiveProviderQualificationReport(
@@ -220,6 +233,9 @@ def qualify_live_provider(
                 total_tokens=total_tokens,
                 failure_code="deterministic_simulation_failed",
             )
+        if progress is not None:
+            progress("SIMULATION", "deterministic qualification simulation completed")
+            progress("RECOVERY", "checking bounded recovery advice")
 
         recovered = recovery.advise(
             task_id="T2",
@@ -228,6 +244,12 @@ def qualify_live_provider(
             policy=policy,
         )
         evidence.append(recovered.evidence)
+        if progress is not None:
+            progress(
+                "RECOVERY",
+                f"decision={recovered.advice.decision.value}",
+            )
+            progress("COMPLETE", "live provider qualification passed")
         request_ids = _request_ids(evidence)
         input_tokens, output_tokens, total_tokens = _usage(provider, request_ids)
         return LiveProviderQualificationReport(
@@ -247,6 +269,8 @@ def qualify_live_provider(
             failure_code=None,
         )
     except Exception as exc:
+        if progress is not None:
+            progress("FAILED", f"qualification stopped type={type(exc).__name__}")
         _append_exception_evidence(evidence, exc)
         request_ids = _request_ids(evidence)
         input_tokens, output_tokens, total_tokens = _usage(provider, request_ids)