lean-runtime 2.0.8__tar.gz → 2.1.0__tar.gz

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/CHANGELOG.md

@@ -1,6 +1,50 @@
 # Changelog
 
-## Unreleased
+## 2.1.0 - 2026-08-11
+
+- Add `lean-runtime toolchain-slim` and
+  `ToolchainManager.materialize_slim()`: a verified check-profile toolchain
+  copy that drops editor indexes, static libraries, bundled LLVM/clang, and
+  sources (about 2.6 GB → 2.1 GB for v4.32.2 once `--prune-original` removes
+  the full Elan copy). Materialization hardlinks files, verification runs a
+  capability corpus with the slim copy's own `lean`, and checking transparently
+  routes through the slim copy when the full toolchain is absent. Lean v4.32
+  requires all `.olean` facets and per-module IR for ordinary elaboration, so
+  those remain; source builds of new environments still need the full
+  toolchain.
+
+- Exempt environment acquisition (downloads, toolchain installs, source
+  builds) from the discovery search budget: a slow first-time download can no
+  longer expire an otherwise healthy search. Acquisition is bounded separately
+  by `DiscoveryPolicy.acquisition_timeout_seconds` and `lean-run
+  --acquire-timeout`; `--search-timeout` and `--check-timeout` name the
+  remaining budgets, with `--discovery-timeout` and `--timeout` kept as
+  deprecated aliases.
+- Split the candidate probe into `acquire` and `check` phases and announce
+  first-time toolchain installation through a `toolchain.install_started`
+  event and a `lean-run` progress line. `CandidateProbe` implementers must now
+  provide both methods; `acquire` returns the newly exported
+  `AcquiredCandidate`, and its acquisition budget is forwarded to
+  `open_exact(build_timeout=...)` so `--acquire-timeout` governs source
+  builds.
+- Add `ExecutionResult.errors`, `.warnings`, and `.first_error` severity views,
+  a `Diagnostic.location` property, and compact `repr` output for both types.
+  `to_dict()` payloads are unchanged.
+- Report structured diagnostics against the caller's logical input names
+  (for example `Main.lean`) instead of staged sandbox paths, and rewrite the
+  staged entrypoint path back to the user's file in `lean-run` text output.
+  Raw `stdout`/`stderr` remain authoritative and unmodified in results.
+- Add `lean.setup(toolchain="v4.32.2")` and `Runtime.open_toolchain()` for
+  reusable core-only environments; the empty-`deps` error now teaches the
+  toolchain form.
+- Accept an exact lock path anywhere `lean-runtime profile` previously
+  required an environment name (`Runtime.subject_environment`); a path that
+  exists on disk always wins over an environment name.
+
+## 2.0.9 - 2026-08-10
+
+- Allow callers and `build-and-publish --timeout` to raise the per-step limit
+  for artifact hydration and environment builds on slower platforms.
 
 ## 2.0.8 - 2026-08-10
 

{lean_runtime-2.0.8/lean_runtime.egg-info → lean_runtime-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-runtime
-Version: 2.0.8
+Version: 2.1.0
 Summary: Run Lean 4 proofs from Python or standalone files
 Author: Alejandro Radisic
 License-Expression: Apache-2.0
@@ -131,6 +131,24 @@ result = env.check(
 result.raise_for_error()
 ```
 
+Rejected proofs carry parsed diagnostics:
+
+```python
+result = env.check(broken_proof)
+
+for error in result.errors:
+    print(error.file, error.line, error.message)
+
+result.raise_for_error()  # raises LeanCheckError with the same detail
+```
+
+Core-only work does not need a dependency:
+
+```python
+core = lean.setup(toolchain="v4.32.2")
+core.check("example : 2 + 2 = 4 := rfl").raise_for_error()
+```
+
 Batch and asyncio APIs reuse that prepared environment:
 
 ```python

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/README.md

@@ -96,6 +96,24 @@ result = env.check(
 result.raise_for_error()
 ```
 
+Rejected proofs carry parsed diagnostics:
+
+```python
+result = env.check(broken_proof)
+
+for error in result.errors:
+    print(error.file, error.line, error.message)
+
+result.raise_for_error()  # raises LeanCheckError with the same detail
+```
+
+Core-only work does not need a dependency:
+
+```python
+core = lean.setup(toolchain="v4.32.2")
+core.check("example : 2 + 2 = 4 := rfl").raise_for_error()
+```
+
 Batch and asyncio APIs reuse that prepared environment:
 
 ```python

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/docs/cli.md

@@ -18,9 +18,14 @@ lean-run Main.lean --offline
 
 Without explicit context or a pinned Lake project, `lean-run` automatically
 searches its bundled exact-environment catalog. Use `--lock-out` to retain the
-successful lock, `--no-discover` to require explicit context,
-`--catalog PATH` to override the catalog, and `--max-candidates` plus
-`--discovery-timeout` to bound search. See
+successful lock, `--no-discover` to require explicit context, and
+`--catalog PATH` to override the catalog. Three budgets bound the work:
+`--search-timeout` covers ranking and compiler probes, `--check-timeout`
+covers each Lean invocation, and `--acquire-timeout` independently bounds
+downloading, installing, or building one candidate environment, so a slow
+first-time download cannot expire the search. `--discovery-timeout` and
+`--timeout` remain as deprecated aliases of `--search-timeout` and
+`--check-timeout`. See
 [Standalone Lean files](standalone-files.md) for routing and policy details.
 
 ## `lean-runtime`
@@ -79,6 +84,34 @@ identity, package Git trees, computer compatibility, and Lean probe before
 making the environment available. See [Portable copies and environment
 libraries](portable-copies.md) for its trust boundary.
 
+## Slim toolchains
+
+The official Lean toolchain is roughly 2.6 GB installed. Proof checking does
+not need all of it: editor indexes, static libraries, the bundled LLVM/clang,
+and toolchain sources are only used by editors and native compilation.
+
+```bash
+lean-runtime toolchain-slim v4.32.2
+lean-runtime toolchain-slim v4.32.2 --prune-original
+```
+
+`toolchain-slim` materializes a separate check-profile copy by hardlinking the
+kept files (near-zero extra disk), then verifies it against a capability
+corpus — elaboration, core tactics, `decide`, `#eval`, metaprogramming, and
+`Std` imports — using the slim copy's own `lean`. A copy that fails any probe
+is removed and reported.
+
+`--prune-original` uninstalls the full Elan toolchain after verification,
+reducing the v4.32.2 footprint from about 2.6 GB to about 2.1 GB. All checking
+continues through the slim copy. Lean v4.32 loads every `.olean` facet and
+per-module IR during ordinary elaboration, so those artifact classes must
+stay; larger reductions require upstream facet-loading changes.
+
+After pruning, source builds of *new* environments and native compilation
+need the full toolchain again; reinstall it with `lean-runtime install`.
+Downloads are unaffected: first-time installation still transfers the full
+official release before a slim copy can be derived from it.
+
 ## Replay
 
 ```bash

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/docs/getting-started.md

@@ -75,17 +75,27 @@ result.raise_for_error()
 `setup()` resolves and ensures the environment once. Further checks reuse that
 handle, including batch and asynchronous calls.
 
-The same entry point opens local projects, exact locks, and previously named
-environments:
+The same entry point opens local projects, exact locks, previously named
+environments, and core-only toolchains:
 
 ```python
 project = lean.setup(project="./my-project")
 locked = lean.setup(lock="environment.lock.json")
 existing = lean.setup(environment="research-stack")
+core = lean.setup(toolchain="v4.32.2")
 ```
 
 Exactly one context must be supplied.
 
+Rejected checks expose parsed diagnostics directly, with `file` naming your
+logical input:
+
+```python
+result = environment.check(broken_proof)
+for error in result.errors:
+    print(error.file, error.line, error.message)
+```
+
 ## Lock for CI
 
 Resolve a friendly dependency declaration and retain its exact graph:

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/docs/python-api.md

@@ -12,9 +12,13 @@ environment = lean.setup(["mathlib@v4.32.2"])
 project = lean.setup(project="./my-project")
 locked = lean.setup(lock="environment.lock.json")
 existing = lean.setup(environment="research-stack")
+core = lean.setup(toolchain="v4.32.2")
 ```
 
-Exactly one of `deps`, `project`, `lock`, or `environment` is required. The
+Exactly one of `deps`, `project`, `lock`, `environment`, or a bare
+`toolchain` is required. A bare `toolchain` prepares the core-only
+environment for that Lean release; combined with `deps` or `project` it
+remains an override. The
 default `Runtime` is created lazily on the first operation; importing
 `lean_runtime` has no filesystem or network side effects. Supply
 `runtime=Runtime(...)` to any façade function for explicit configuration.
@@ -53,7 +57,24 @@ runs. Planning metadata narrows candidates but never asserts compatibility.
 
 ## Results
 
-Results remain inspectable values. Scripts that prefer exceptions can use:
+Results remain inspectable values. Failed checks expose their parsed
+diagnostics directly:
+
+```python
+result = environment.check(source)
+
+for error in result.errors:
+    print(error.file, error.line, error.message)
+
+if result.first_error is not None:
+    print(result.first_error.location)
+```
+
+`errors` and `warnings` are severity-filtered views of `diagnostics`;
+`first_error` returns the first error or `None`. Diagnostic `file` values name
+the caller's logical input (for example `Main.lean`); raw compiler output
+remains authoritative on `stdout`/`stderr` and may contain physical sandbox
+paths. Scripts that prefer exceptions can use:
 
 ```python
 result.raise_for_error()

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/docs/standalone-files.md

@@ -15,9 +15,21 @@ environment is compatible. Runtime materializes each bounded candidate and
 Lean authoritatively checks the source before discovery can succeed.
 
 The bundled bootstrap catalog contains core Lean v4.32.2 plus exact Mathlib
-v4.32.2, v4.31.0, and v4.30.0 locks. `--catalog PATH` selects another validated catalog,
-`--max-candidates` and `--discovery-timeout` bound the search, and
-`--no-discover` restores strict explicit-context behavior.
+v4.32.2, v4.31.0, and v4.30.0 locks. `--catalog PATH` selects another validated
+catalog and `--no-discover` restores strict explicit-context behavior.
+
+Three budgets bound the work independently:
+
+- `--max-candidates` and `--search-timeout` bound the search itself: ranking
+  plus compiler probes.
+- `--check-timeout` bounds each Lean invocation.
+- `--acquire-timeout` bounds downloading, installing, or building one
+  candidate environment, including its source build. Acquisition never
+  consumes the search budget, so a slow first-time toolchain download cannot
+  expire an otherwise healthy search.
+
+`--discovery-timeout` and `--timeout` remain as deprecated aliases of
+`--search-timeout` and `--check-timeout`.
 
 ## Frontmatter format
 
@@ -53,12 +65,21 @@ environments only.
 
 ## Output
 
-Human output is concise:
+Human output is concise, and error locations name the file you passed rather
+than an internal staging path:
 
 ```text
 ✓ Main.lean accepted in 0.42s
 ```
 
+```text
+proofs/Bad.lean:1:23: error: Type mismatch
+✗ proofs/Bad.lean rejected in 0.35s
+```
+
+Only the checked file's own path is rewritten; dependency paths in compiler
+output are shown as Lean printed them.
+
 Cold operations report meaningful dependency, cache, and build phases on
 stderr. `--quiet` suppresses progress and `--json` emits the complete structured
 `ExecutionResult` without progress messages.

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/docs/trust-and-limitations.md

@@ -2,7 +2,7 @@
 
 ## Trusted local execution
 
-Lean Runtime 0.5 orchestrates trusted code. It is not a sandbox.
+Lean Runtime orchestrates trusted code. It is not a sandbox.
 
 Lake configurations are executable, dependencies may contain native code and
 custom build targets, and explicit artifact commands run subprocesses. Lockfile

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/lean_runtime/cli.py

@@ -142,6 +142,12 @@ def parser() -> argparse.ArgumentParser:
     push.add_argument("--publish-to", required=True)
     push.add_argument("--tag", action="append", default=[])
     push.add_argument("--name")
+    push.add_argument(
+        "--timeout",
+        type=float,
+        default=1800,
+        help="maximum seconds for each artifact hydration and the environment build",
+    )
     push.add_argument(
         "--platform-only",
         action="store_true",
@@ -265,8 +271,21 @@ def parser() -> argparse.ArgumentParser:
     diff.add_argument("right")
     diff.add_argument("--json", action="store_true")
 
+    toolchain_slim = commands.add_parser(
+        "toolchain-slim",
+        help="materialize a verified slim check-profile copy of a toolchain",
+    )
+    toolchain_slim.add_argument("toolchain", help="Lean toolchain, e.g. v4.32.2")
+    toolchain_slim.add_argument(
+        "--prune-original",
+        action="store_true",
+        help="uninstall the full Elan toolchain after verification; checking keeps "
+        "working through the slim copy, but source builds of new environments and "
+        "native compilation need the full toolchain again",
+    )
+
     profile = commands.add_parser("profile", help="measure repeated checks in one environment")
-    profile.add_argument("environment")
+    profile.add_argument("environment", help="environment name or exact lock path")
     profile.add_argument("file", type=Path)
     profile.add_argument("--warmup", type=int, default=1)
     profile.add_argument("--repeat", type=int, default=5)
@@ -368,7 +387,11 @@ def main(argv: list[str] | None = None) -> int:
             _json(environment.inspect().to_dict())
             return 0
         if args.command == "build-and-publish":
-            environment = runtime.open_exact(EnvironmentLock.load(args.lock), name=args.name)
+            environment = runtime.open_exact(
+                EnvironmentLock.load(args.lock),
+                name=args.name,
+                build_timeout=args.timeout,
+            )
             _json(
                 runtime.publish_environment(
                     environment.id,
@@ -509,6 +532,18 @@ def main(argv: list[str] | None = None) -> int:
         if args.command == "storage":
             _json(runtime.store_status().to_dict())
             return 0
+        if args.command == "toolchain-slim":
+            manifest = runtime.toolchains.materialize_slim(args.toolchain)
+            if args.prune_original:
+                runtime.toolchains.prune_original(args.toolchain)
+            _json(
+                {
+                    **manifest.to_dict(),
+                    "path": str(runtime.toolchains.slim_path(args.toolchain)),
+                    "pruned_original": args.prune_original,
+                }
+            )
+            return 0
         if args.command == "doctor":
             doctor_report = runtime.doctor()
             _json(doctor_report.to_dict())

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/lean_runtime/diagnostics.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Mapping
+from dataclasses import replace
 
 from .models import Diagnostic, Severity
 
@@ -46,6 +48,26 @@ def parse_diagnostics(output: str) -> tuple[Diagnostic, ...]:
     return tuple(diagnostics)
 
 
+def map_diagnostic_paths(
+    diagnostics: tuple[Diagnostic, ...],
+    path_map: Mapping[str, str] | None,
+) -> tuple[Diagnostic, ...]:
+    """Rewrite staged physical paths to the caller's logical input names.
+
+    Only exact staged-file matches are rewritten; package files may
+    legitimately share basenames, and raw compiler output remains authoritative
+    on the execution result.
+    """
+    if not path_map:
+        return diagnostics
+    return tuple(
+        replace(item, file=path_map[item.file])
+        if item.file is not None and item.file in path_map
+        else item
+        for item in diagnostics
+    )
+
+
 def error_diagnostic(message: str) -> Diagnostic:
     """Create an infrastructure diagnostic."""
     severity: Severity = "error"

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/lean_runtime/discovery/__init__.py

@@ -21,7 +21,7 @@ from .defaults import DEFAULT_CATALOG_PATH, default_catalog
 from .errors import CatalogError, DiscoveryError, PolicyError
 from .planner import Planner
 from .policy import DiscoveryPolicy
-from .probe import CandidateProbe, LeanRuntimeProbe, ProbeOutcome
+from .probe import AcquiredCandidate, CandidateProbe, LeanRuntimeProbe, ProbeOutcome
 from .result import (
     RESULT_SCHEMA,
     CandidateAttempt,
@@ -39,6 +39,7 @@ __all__ = [
     "AvailabilityObservation",
     "Candidate",
     "CandidateAttempt",
+    "AcquiredCandidate",
     "CandidateProbe",
     "CandidateReason",
     "Catalog",

{lean_runtime-2.0.8 → lean_runtime-2.1.0}/lean_runtime/discovery/engine.py

@@ -68,6 +68,61 @@ def _diagnostic(code: str, detail: str) -> tuple[ResultDiagnostic, ...]:
     return (ResultDiagnostic(code=code, detail=detail),)
 
 
+def _failed_attempt(
+    exc: Exception,
+    *,
+    candidate_id: str,
+    lock_id: str,
+    attempt_started: float,
+    cancelled_externally: bool,
+    timed_out: bool,
+) -> tuple[CandidateAttempt, str]:
+    """Map one probe exception to an attempt and an action: continue, failed, or cancelled."""
+    duration = time.monotonic() - attempt_started
+    if isinstance(exc, ProbeIntegrityFailure):
+        status: AttemptStatus = "environment_integrity_failure"
+        code = CANDIDATE_INTEGRITY_FAILURE
+        action = "failed"
+    elif isinstance(exc, ProbeUnavailable):
+        if cancelled_externally:
+            status = "cancelled"
+            code = CANDIDATE_CANCELLED
+            action = "cancelled"
+        elif timed_out:
+            status = "timeout"
+            code = CANDIDATE_TIMEOUT
+            action = "continue"
+        else:
+            status = "environment_unavailable"
+            code = CANDIDATE_UNAVAILABLE
+            action = "continue"
+    elif isinstance(exc, LeanRuntimeError):
+        if cancelled_externally:
+            status = "cancelled"
+            code = CANDIDATE_CANCELLED
+            action = "cancelled"
+        elif timed_out:
+            status = "timeout"
+            code = CANDIDATE_TIMEOUT
+            action = "continue"
+        else:
+            status = "runtime_error"
+            code = CANDIDATE_RUNTIME_ERROR
+            action = "failed"
+    else:  # defensive adapter boundary
+        status = "runtime_error"
+        code = CANDIDATE_RUNTIME_ERROR
+        action = "generic_failed"
+    attempt = CandidateAttempt(
+        candidate_id=candidate_id,
+        lock_id=lock_id,
+        status=status,
+        duration_seconds=duration,
+        diagnostics=_diagnostic(code, str(exc)),
+    )
+    return attempt, action
+
+
 def _rejection_detail(stderr: str, stdout: str) -> str:
     return stderr.strip() or stdout.strip() or "Lean rejected the source"
 
@@ -130,114 +185,77 @@ def discover(
                 duration_seconds=time.monotonic() - started,
                 diagnostics=_diagnostic(DISCOVERY_TIME_LIMIT, "total search budget expired"),
             )
-        timeout = min(
-            remaining,
-            plan.policy.candidate_timeout_seconds or remaining,
-        )
         attempt_started = time.monotonic()
-        with _AttemptCancellation(timeout, cancel) as attempt_cancel:
+        acquisition_timeout = plan.policy.acquisition_timeout_seconds
+        with _AttemptCancellation(acquisition_timeout, cancel) as acquisition_cancel:
             try:
-                outcome = probe.check(
-                    candidate,
-                    source,
-                    timeout_seconds=timeout,
-                    cancel=attempt_cancel.cancel,
-                )
-            except ProbeIntegrityFailure as exc:
-                attempt = CandidateAttempt(
-                    candidate_id=candidate.entry.id,
-                    lock_id=candidate.entry.lock.lock_id,
-                    status="environment_integrity_failure",
-                    duration_seconds=time.monotonic() - attempt_started,
-                    diagnostics=_diagnostic(CANDIDATE_INTEGRITY_FAILURE, str(exc)),
-                )
-                attempts.append(attempt)
-                return DiscoveryResult(
-                    status="failed",
-                    confidence="exhausted",
-                    plan=plan,
-                    attempts=tuple(attempts),
-                    duration_seconds=time.monotonic() - started,
-                    diagnostics=attempt.diagnostics,
-                )
-            except ProbeUnavailable as exc:
-                if cancel is not None and cancel.is_set():
-                    attempt = CandidateAttempt(
-                        candidate_id=candidate.entry.id,
-                        lock_id=candidate.entry.lock.lock_id,
-                        status="cancelled",
-                        duration_seconds=time.monotonic() - attempt_started,
-                        diagnostics=_diagnostic(CANDIDATE_CANCELLED, str(exc)),
-                    )
-                    attempts.append(attempt)
-                    return DiscoveryResult(
-                        status="cancelled",
-                        confidence="exhausted",
-                        plan=plan,
-                        attempts=tuple(attempts),
-                        duration_seconds=time.monotonic() - started,
-                        diagnostics=attempt.diagnostics,
+                # Acquisition (downloads, toolchain installs, builds) is
+                # budgeted separately; every acquisition outcome, including
+                # failures, credits its elapsed time back to the search budget.
+                try:
+                    acquired = probe.acquire(
+                        candidate,
+                        timeout_seconds=acquisition_timeout,
+                        cancel=acquisition_cancel.cancel,
                     )
-                unavailable_status: AttemptStatus = (
-                    "timeout" if attempt_cancel.timed_out.is_set() else "environment_unavailable"
-                )
-                code = (
-                    CANDIDATE_TIMEOUT if unavailable_status == "timeout" else CANDIDATE_UNAVAILABLE
-                )
-                attempts.append(
-                    CandidateAttempt(
-                        candidate_id=candidate.entry.id,
-                        lock_id=candidate.entry.lock.lock_id,
-                        status=unavailable_status,
-                        duration_seconds=time.monotonic() - attempt_started,
-                        diagnostics=_diagnostic(code, str(exc)),
-                    )
-                )
-                continue
-            except LeanRuntimeError as exc:
-                if cancel is not None and cancel.is_set():
-                    error_status: AttemptStatus = "cancelled"
-                    code = CANDIDATE_CANCELLED
-                elif attempt_cancel.timed_out.is_set():
-                    error_status = "timeout"
-                    code = CANDIDATE_TIMEOUT
-                else:
-                    error_status = "runtime_error"
-                    code = CANDIDATE_RUNTIME_ERROR
-                attempt = CandidateAttempt(
+                finally:
+                    deadline += time.monotonic() - attempt_started
+            except Exception as exc:  # defensive adapter boundary
+                attempt, action = _failed_attempt(
+                    exc,
                     candidate_id=candidate.entry.id,
                     lock_id=candidate.entry.lock.lock_id,
-                    status=error_status,
-                    duration_seconds=time.monotonic() - attempt_started,
-                    diagnostics=_diagnostic(code, str(exc)),
+                    attempt_started=attempt_started,
+                    cancelled_externally=cancel is not None and cancel.is_set(),
+                    timed_out=acquisition_cancel.timed_out.is_set(),
                 )
                 attempts.append(attempt)
-                if error_status == "timeout":
+                if action == "continue":
                     continue
                 return DiscoveryResult(
-                    status="cancelled" if error_status == "cancelled" else "failed",
+                    status="cancelled" if action == "cancelled" else "failed",
                     confidence="exhausted",
                     plan=plan,
                     attempts=tuple(attempts),
                     duration_seconds=time.monotonic() - started,
-                    diagnostics=attempt.diagnostics,
+                    diagnostics=_diagnostic(DISCOVERY_RUNTIME_ERROR, str(exc))
+                    if action == "generic_failed"
+                    else attempt.diagnostics,
+                )
+        remaining = deadline - time.monotonic()
+        timeout = min(
+            remaining,
+            plan.policy.candidate_timeout_seconds or remaining,
+        )
+        with _AttemptCancellation(timeout, cancel) as attempt_cancel:
+            try:
+                outcome = probe.check(
+                    acquired,
+                    source,
+                    timeout_seconds=timeout,
+                    cancel=attempt_cancel.cancel,
                 )
             except Exception as exc:  # defensive adapter boundary
-                attempt = CandidateAttempt(
+                attempt, action = _failed_attempt(
+                    exc,
                     candidate_id=candidate.entry.id,
                     lock_id=candidate.entry.lock.lock_id,
-                    status="runtime_error",
-                    duration_seconds=time.monotonic() - attempt_started,
-                    diagnostics=_diagnostic(CANDIDATE_RUNTIME_ERROR, str(exc)),
+                    attempt_started=attempt_started,
+                    cancelled_externally=cancel is not None and cancel.is_set(),
+                    timed_out=attempt_cancel.timed_out.is_set(),
                 )
                 attempts.append(attempt)
+                if action == "continue":
+                    continue
                 return DiscoveryResult(
-                    status="failed",
+                    status="cancelled" if action == "cancelled" else "failed",
                     confidence="exhausted",
                     plan=plan,
                     attempts=tuple(attempts),
                     duration_seconds=time.monotonic() - started,
-                    diagnostics=_diagnostic(DISCOVERY_RUNTIME_ERROR, str(exc)),
+                    diagnostics=_diagnostic(DISCOVERY_RUNTIME_ERROR, str(exc))
+                    if action == "generic_failed"
+                    else attempt.diagnostics,
                 )
 
         result = outcome.execution_result