deeploop 0.1.2__tar.gz → 0.1.4__tar.gz

{deeploop-0.1.2/src/deeploop.egg-info → deeploop-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deeploop
-Version: 0.1.2
+Version: 0.1.4
 Summary: DeepLoop autonomous research autopilot control plane.
 Author: DeepLoop maintainers
 License-Expression: MIT
@@ -93,26 +93,35 @@ DeepLoop **owns behavior** and orchestration; substrate repos own reusable domai
      cp -R examples/translation-budget-ladder PROJECT_FOLDER
      ```
 
-   - fastest path:
+    - fastest path:
 
      ```text
      deeploop run --project-root examples/translation-budget-ladder --until-complete
      ```
 
-     > **Note:** If `<project-folder>/.deeploop/missions/*.yaml` files exist, `deeploop run`
-     > automatically uses the first one instead of bootstrapping a blank mission.
-     > For a plain folder with no existing config, it bootstraps from the folder's facts.
-     > To target a specific explicit config directly, use
-     > `deeploop init --config <mission-config.yaml>` followed by
-     > `deeploop start --mission-state <mission-state.json>`.
+      > **Note:** If `<project-folder>/.deeploop/missions/*.yaml` files exist, `deeploop run`
+      > automatically uses the first one instead of bootstrapping a blank mission.
+      > For a plain folder with no existing config, it bootstraps from the folder's facts.
+      > If the folder is rough but still recognizable, DeepLoop can initialize with
+      > disclosed clarifications/defaults and keep the project folder unchanged. To
+      > target a specific explicit config directly, use `deeploop init --config
+      > <mission-config.yaml>` followed by `deeploop start --mission-state
+      > <mission-state.json>`.
 
-   - explicit operator path:
+    - discovery / operator path:
 
-     ```text
-     deeploop init --project-root examples/translation-budget-ladder --force
-     ```
+      ```text
+      deeploop init --project-root PROJECT_FOLDER --force
+      deeploop init --discover --project-root PROJECT_FOLDER --force
+      ```
+
+      Use plain `deeploop init --project-root ...` when the folder is rough but
+      already recognizable. Add `--discover` when you want DeepLoop to ask
+      clarifying questions before kickoff.
 
-   On a copied folder, substitute `PROJECT_FOLDER` in the commands above.
+    On a copied folder, substitute `PROJECT_FOLDER` in the commands above. If
+    DeepLoop cannot safely bootstrap the folder yet, it stops with bounded
+    bootstrap-repair guidance instead of mutating the project.
 
 5. **Use the operator CLI when a run pauses**
 
@@ -124,6 +133,13 @@ DeepLoop **owns behavior** and orchestration; substrate repos own reusable domai
 
 The `deeploop` CLI is the single entry point — `run`, `init`, `status`, `inbox`, `resume`, and more are all subcommands.
 
+## Readiness at a glance
+
+- **Fastest supported path:** Linux, Python 3.11+, `pip install deeploop`, `make setup`, `make public-bootstrap-check`, then `deeploop run --project-root <project-folder> --until-complete`
+- **Messy starts are supported:** rough plain-folder projects can initialize with disclosed clarifications/defaults, or you can use `deeploop init --discover ...` for a guided kickoff
+- **Repair stays bounded:** if the folder is missing the plain-folder bootstrap contract, DeepLoop exits with bootstrap-repair guidance and suggested starter inputs instead of silently rewriting project files
+- **Current release gate:** `make public-bootstrap-check`, `make docker-release-validate`, and `make docs-build`, with PyPI publish only from a published GitHub Release whose tag matches `project.version`
+
 ## Best fit today
 
 DeepLoop is best when you already have:

{deeploop-0.1.2 → deeploop-0.1.4}/README.md

@@ -54,26 +54,35 @@ DeepLoop **owns behavior** and orchestration; substrate repos own reusable domai
      cp -R examples/translation-budget-ladder PROJECT_FOLDER
      ```
 
-   - fastest path:
+    - fastest path:
 
      ```text
      deeploop run --project-root examples/translation-budget-ladder --until-complete
      ```
 
-     > **Note:** If `<project-folder>/.deeploop/missions/*.yaml` files exist, `deeploop run`
-     > automatically uses the first one instead of bootstrapping a blank mission.
-     > For a plain folder with no existing config, it bootstraps from the folder's facts.
-     > To target a specific explicit config directly, use
-     > `deeploop init --config <mission-config.yaml>` followed by
-     > `deeploop start --mission-state <mission-state.json>`.
+      > **Note:** If `<project-folder>/.deeploop/missions/*.yaml` files exist, `deeploop run`
+      > automatically uses the first one instead of bootstrapping a blank mission.
+      > For a plain folder with no existing config, it bootstraps from the folder's facts.
+      > If the folder is rough but still recognizable, DeepLoop can initialize with
+      > disclosed clarifications/defaults and keep the project folder unchanged. To
+      > target a specific explicit config directly, use `deeploop init --config
+      > <mission-config.yaml>` followed by `deeploop start --mission-state
+      > <mission-state.json>`.
 
-   - explicit operator path:
+    - discovery / operator path:
 
-     ```text
-     deeploop init --project-root examples/translation-budget-ladder --force
-     ```
+      ```text
+      deeploop init --project-root PROJECT_FOLDER --force
+      deeploop init --discover --project-root PROJECT_FOLDER --force
+      ```
+
+      Use plain `deeploop init --project-root ...` when the folder is rough but
+      already recognizable. Add `--discover` when you want DeepLoop to ask
+      clarifying questions before kickoff.
 
-   On a copied folder, substitute `PROJECT_FOLDER` in the commands above.
+    On a copied folder, substitute `PROJECT_FOLDER` in the commands above. If
+    DeepLoop cannot safely bootstrap the folder yet, it stops with bounded
+    bootstrap-repair guidance instead of mutating the project.
 
 5. **Use the operator CLI when a run pauses**
 
@@ -85,6 +94,13 @@ DeepLoop **owns behavior** and orchestration; substrate repos own reusable domai
 
 The `deeploop` CLI is the single entry point — `run`, `init`, `status`, `inbox`, `resume`, and more are all subcommands.
 
+## Readiness at a glance
+
+- **Fastest supported path:** Linux, Python 3.11+, `pip install deeploop`, `make setup`, `make public-bootstrap-check`, then `deeploop run --project-root <project-folder> --until-complete`
+- **Messy starts are supported:** rough plain-folder projects can initialize with disclosed clarifications/defaults, or you can use `deeploop init --discover ...` for a guided kickoff
+- **Repair stays bounded:** if the folder is missing the plain-folder bootstrap contract, DeepLoop exits with bootstrap-repair guidance and suggested starter inputs instead of silently rewriting project files
+- **Current release gate:** `make public-bootstrap-check`, `make docker-release-validate`, and `make docs-build`, with PyPI publish only from a published GitHub Release whose tag matches `project.version`
+
 ## Best fit today
 
 DeepLoop is best when you already have:

{deeploop-0.1.2 → deeploop-0.1.4}/configs/runtime/provider-selection-registry.yaml

@@ -112,7 +112,7 @@ selection_profiles:
         - vllm
         - local-transformers
   openai-compatible-api-control-plane:
-    status: reserved-runtime-adapter
+    status: implemented
     provider_family: openai-compatible-api
     backend: openai-compatible-api
     model_selection:
@@ -125,6 +125,9 @@ selection_profiles:
       provider_family_switch: explicit-only
       backend_switch: provider-native
       model_fallback: explicit-model-ladder-only
+    notes:
+      - runtime support currently covers prompt/result control-plane flows that return structured JSON
+      - recursive-agent tool execution remains on the copilot-cli path
   anthropic-api-control-plane:
     status: reserved-runtime-adapter
     provider_family: anthropic-api

{deeploop-0.1.2 → deeploop-0.1.4}/configs/runtime/provider-setup-registry.yaml

@@ -50,7 +50,7 @@ provider_families:
   openai-compatible-api:
     display_name: OpenAI-compatible API providers
     public_contract_tier: first-class
-    runtime_integration: deferred
+    runtime_integration: implemented
     required_tools:
       - command: python
         purpose: control-plane entrypoint
@@ -71,7 +71,7 @@ provider_families:
           expectation: set in the operator shell or runner environment
       manual:
         - if OPENAI_BASE_URL is set, confirm the endpoint is reachable over HTTPS
-        - DeepLoop does not yet ship a public request adapter or mission/runtime selector for this family
+        - the public adapter currently covers prompt/result control-plane flows; it does not add Copilot-style tool execution
   anthropic-api:
     display_name: Anthropic API providers
     public_contract_tier: first-class

{deeploop-0.1.2 → deeploop-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deeploop"
-version = "0.1.2"
+version = "0.1.4"
 description = "DeepLoop autonomous research autopilot control plane."
 readme = "README.md"
 requires-python = ">=3.11"

{deeploop-0.1.2 → deeploop-0.1.4}/scripts/runtime/invoke_provider_prompt.py

@@ -1,13 +1,36 @@
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 from pathlib import Path
 
-REPO_ROOT = Path(__file__).resolve().parents[2]
-SRC_ROOT = REPO_ROOT / "src"
-if str(SRC_ROOT) not in sys.path:
-    sys.path.insert(0, str(SRC_ROOT))
+SCRIPT_PATH = Path(__file__).resolve()
+REPO_ROOT = SCRIPT_PATH.parents[2]
+
+
+def _bootstrap_import_path() -> None:
+    candidates: list[Path] = []
+
+    cache_src = os.environ.get("DEEPLOOP_RUNTIME_CACHE_SRC", "").strip()
+    if cache_src:
+        candidates.append(Path(cache_src).expanduser().resolve())
+
+    repo_src = REPO_ROOT / "src"
+    if repo_src.is_dir():
+        candidates.append(repo_src)
+
+    package_root = SCRIPT_PATH.parents[3]
+    if package_root.name == "deeploop" and (package_root / "__init__.py").is_file():
+        candidates.append(package_root.parent)
+
+    for candidate in candidates:
+        candidate_text = str(candidate)
+        if candidate.is_dir() and candidate_text not in sys.path:
+            sys.path.insert(0, candidate_text)
+
+
+_bootstrap_import_path()
 
 from deeploop.runtime.provider_launcher import run_provider_prompt
 

deeploop-0.1.4/src/deeploop/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.4"

{deeploop-0.1.2 → deeploop-0.1.4}/src/deeploop/artifacts/artifact_packager.py

@@ -850,6 +850,39 @@ def _artifact_bullets(artifacts: list[dict[str, Any]], artifact_ids: list[str],
     return bullets
 
 
+def _mission_runtime_handoff_bullets(mission_state: dict[str, Any], *, ledger_entries: int) -> list[str]:
+    mission_runtime = mission_state.get("mission_runtime") if isinstance(mission_state.get("mission_runtime"), dict) else {}
+    if not mission_runtime:
+        return [f"Ledger entries captured: {ledger_entries}."]
+    bullets = [
+        "Mission runtime: "
+        f"{mission_runtime.get('status', 'unknown')} after "
+        f"{int(mission_runtime.get('iterations_completed', 0) or 0)} bounded iteration(s)."
+    ]
+    telemetry = (
+        mission_runtime.get("autonomy_gap_telemetry")
+        if isinstance(mission_runtime.get("autonomy_gap_telemetry"), dict)
+        else {}
+    )
+    counts = telemetry.get("counts") if isinstance(telemetry.get("counts"), dict) else {}
+    if counts:
+        bullets.append(
+            "Recovery telemetry: "
+            f"soft_gates={int(counts.get('soft_gates_total', 0) or 0)}, "
+            f"bounded_recoveries={int(counts.get('bounded_recovery_outcomes', 0) or 0)}, "
+            f"operator_requests={int(counts.get('operator_requests_total', 0) or 0)}."
+        )
+        auto_recovered = int(counts.get("temporary_gap_auto_recovered", 0) or 0)
+        escalated = int(counts.get("temporary_gap_escalated", 0) or 0)
+        if auto_recovered or escalated:
+            bullets.append(
+                "Temporary gaps: "
+                f"auto_recovered={auto_recovered}, escalated={escalated}."
+            )
+    bullets.append(f"Ledger entries captured: {ledger_entries}.")
+    return bullets
+
+
 def _data_artifact_reference_only(metadata: dict[str, Any]) -> bool:
     return metadata.get("package") is False or str(
         metadata.get("packaging_policy") or metadata.get("package_policy") or ""
@@ -1155,9 +1188,11 @@ def package_mission_artifacts(
         register_artifact(report_path, category=category, metadata=metadata)
 
     ledger_path = mission_root / "ledger.jsonl"
+    ledger_entries: list[dict[str, Any]] = []
     if ledger_path.exists():
         ledger_artifact_id = register_artifact(ledger_path, category="ledgers")
-        for entry in _load_jsonl(ledger_path):
+        ledger_entries = _load_jsonl(ledger_path)
+        for entry in ledger_entries:
             related_paths = entry.get("related_paths", [])
             for raw_path in related_paths:
                 if not isinstance(raw_path, str):
@@ -1382,6 +1417,7 @@ def package_mission_artifacts(
         f"Current phase: {mission_state.get('current_phase')} ({mission_state.get('status')})",
         f"Packaged {len(artifacts)} artifacts across {len(run_bundles)} manifest bundles.",
     ]
+    operator_bullets.extend(_mission_runtime_handoff_bullets(mission_state, ledger_entries=len(ledger_entries)))
     if missing_required_artifacts_summary:
         operator_bullets.append(missing_required_artifacts_summary)
     next_actions = mission_state.get("next_actions", {})

{deeploop-0.1.2 → deeploop-0.1.4}/src/deeploop/cli/init_mission.py

@@ -8,7 +8,11 @@ from deeploop.core.paths import SCRATCH_DIR, WORKSPACE_ROOT, WORKSPACE_ROOT_ENV_
 from deeploop.core.structured_io import write_text, write_yaml_mapping
 from deeploop.mission.mission_discovery import run_interactive_discovery
 from deeploop.mission.orchestrator import initialize_mission
-from deeploop.mission.project_bootstrap import build_mission_config_from_project_root
+from deeploop.mission.project_bootstrap import (
+    build_mission_config_from_project_root,
+    render_bootstrap_repair_lines,
+    render_mission_contract_summary_lines,
+)
 
 
 def _add_init_args(parser: argparse.ArgumentParser) -> None:
@@ -31,6 +35,14 @@ def _add_init_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--force", action="store_true", help="Replace any existing mission root with the same mission id.")
 
 
+def _print_readiness_summary(config: dict[str, object]) -> None:
+    mission_contract = config.get("mission_contract") if isinstance(config.get("mission_contract"), dict) else {}
+    if not mission_contract:
+        return
+    for line in render_mission_contract_summary_lines(mission_contract, format="plain"):
+        print(f"mission-init: {line}" if line else "mission-init:")
+
+
 def _init_mission(args: argparse.Namespace) -> int:
     has_config = bool(getattr(args, "config", None))
     has_project_root = bool(getattr(args, "project_root", None))
@@ -75,9 +87,18 @@ def _init_mission(args: argparse.Namespace) -> int:
         write_text(persisted_config_path, Path(discovery["config_path"]).read_text(encoding="utf-8"))
         print(f"mission-init: used confirmed discovery config {discovery['config_path']}")
         print(f"mission-init: wrote generated config to {persisted_config_path}")
+        _print_readiness_summary(discovery["config"])
     elif has_project_root:
         project_root = Path(args.project_root).expanduser().resolve()
         generated_config = build_mission_config_from_project_root(project_root, mission_id=getattr(args, "mission_id", None))
+        bootstrap_repair = (
+            generated_config.get("bootstrap_repair") if isinstance(generated_config.get("bootstrap_repair"), dict) else None
+        )
+        if isinstance(bootstrap_repair, dict) and str(bootstrap_repair.get("status") or "").strip().lower() == "required":
+            print(f"mission-init: project-root bootstrap needs repair for {project_root}", file=sys.stderr)
+            for line in render_bootstrap_repair_lines(bootstrap_repair, format="plain"):
+                print(f"mission-init: {line}" if line else "mission-init:", file=sys.stderr)
+            return 2
         generated_config_dir = SCRATCH_DIR / "mission_bootstrap_configs"
         generated_config_dir.mkdir(parents=True, exist_ok=True)
         generated_config_path = generated_config_dir / f"{generated_config['mission']['id']}.yaml"
@@ -87,6 +108,7 @@ def _init_mission(args: argparse.Namespace) -> int:
         write_text(persisted_config_path, generated_config_path.read_text(encoding="utf-8"))
         print(f"mission-init: bootstrapped mission config from project folder {project_root}")
         print(f"mission-init: wrote generated config to {persisted_config_path}")
+        _print_readiness_summary(generated_config)
     else:
         result = initialize_mission(Path(args.config).expanduser().resolve(), force=getattr(args, "force", False))
 

deeploop-0.1.4/src/deeploop/cli/run_project.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from deeploop.mission.project_bootstrap import render_bootstrap_repair_lines
+from deeploop.mission.project_runner import _jsonify, run_project_until_complete
+
+
+def _add_run_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--project-root",
+        required=True,
+        help="Path to the plain researcher project folder. `deeploop run` bootstraps or reuses the mission state for you.",
+    )
+    parser.add_argument("--mission-id", help="Optional override for the generated mission id.")
+    parser.add_argument("--force", action="store_true", help="Replace any existing mission root with the same mission id.")
+    parser.add_argument(
+        "--until-complete",
+        action="store_true",
+        required=True,
+        help=(
+            "Keep extending bounded runtime passes until the mission completes or hits a true operator handoff. "
+            "Use `deeploop init` plus `deeploop start`/`deeploop resume` instead when you want manual control."
+        ),
+    )
+    parser.add_argument(
+        "--chunk-iterations",
+        type=int,
+        default=8,
+        help="How many additional bounded mission-runtime iterations to grant per pass.",
+    )
+    parser.add_argument(
+        "--max-total-iterations",
+        type=int,
+        default=256,
+        help="Absolute mission-runtime iteration budget across the full `--until-complete` run.",
+    )
+
+
+def _first_next_command(snapshot: dict[str, Any] | None) -> str | None:
+    if not isinstance(snapshot, dict):
+        return None
+    operator_console = snapshot.get("operator_console")
+    if not isinstance(operator_console, dict):
+        return None
+    next_commands = operator_console.get("next_commands")
+    if not isinstance(next_commands, list):
+        return None
+    for entry in next_commands:
+        if isinstance(entry, dict):
+            command = str(entry.get("command") or "").strip()
+            if command:
+                return command
+    return None
+
+
+def _resume_summary_line(result: dict[str, Any]) -> str | None:
+    resume_summary = result.get("resume_summary")
+    if not isinstance(resume_summary, dict):
+        return None
+    parts: list[str] = []
+    if resume_summary.get("resumed_existing_mission"):
+        initial_iterations = int(resume_summary.get("initial_iterations_completed", 0) or 0)
+        initial_status = str(resume_summary.get("initial_runtime_status") or "unknown")
+        parts.append(f"reused prior mission state ({initial_iterations} recorded iteration(s), status `{initial_status}`)")
+    bounded_resume_passes = int(resume_summary.get("bounded_resume_passes", 0) or 0)
+    if bounded_resume_passes > 0:
+        parts.append(f"auto-resumed {bounded_resume_passes} bounded pass(es)")
+    soft_recovery_resume_passes = int(resume_summary.get("soft_recovery_resume_passes", 0) or 0)
+    if soft_recovery_resume_passes > 0:
+        parts.append(f"{soft_recovery_resume_passes} via soft-gate recovery")
+    if not parts:
+        return None
+    return "; ".join(parts)
+
+
+def _noncompleted_summary_lines(result: dict[str, Any]) -> list[str]:
+    status = str(result.get("status") or "stopped")
+    bootstrap_repair = result.get("bootstrap_repair") if isinstance(result.get("bootstrap_repair"), dict) else None
+    if status == "bootstrap-repair-required" and isinstance(bootstrap_repair, dict):
+        return [
+            "DeepLoop could not bootstrap this project root yet.",
+            f"- outcome: `{status}`",
+            *render_bootstrap_repair_lines(bootstrap_repair, format="plain"),
+        ]
+    snapshot = result.get("snapshot") if isinstance(result.get("snapshot"), dict) else None
+    operator_console = snapshot.get("operator_console") if isinstance(snapshot, dict) else None
+    headline = (
+        str(operator_console.get("headline") or "").strip()
+        if isinstance(operator_console, dict)
+        else ""
+    )
+    summary = (
+        str(operator_console.get("summary") or "").strip()
+        if isinstance(operator_console, dict)
+        else ""
+    )
+    recommendation = (
+        str(operator_console.get("recommendation") or "").strip()
+        if isinstance(operator_console, dict)
+        else ""
+    )
+    mission_state_path = result.get("mission_state_path")
+    next_command = _first_next_command(snapshot)
+    lines = [
+        "DeepLoop did not complete this run.",
+        f"- outcome: `{status}`",
+    ]
+    if headline:
+        lines.append(f"- handoff: {headline}")
+    if summary:
+        lines.append(f"- summary: {summary}")
+    elif status == "max-total-iterations":
+        lines.append("- summary: Reached the total `--max-total-iterations` budget before completion.")
+    if recommendation:
+        lines.append(f"- recommendation: {recommendation}")
+    resume_line = _resume_summary_line(result)
+    if resume_line:
+        lines.append(f"- resume: {resume_line}")
+    if next_command:
+        lines.append(f"- next_command: `{next_command}`")
+    elif mission_state_path:
+        lines.append(f"- next_command: `deeploop status --mission-state {mission_state_path}`")
+    return lines
+
+
+def _run_project(args: argparse.Namespace) -> int:
+    if not args.until_complete:
+        print(
+            "error: `deeploop run` requires `--until-complete`; use `deeploop init` plus "
+            "`deeploop start`/`deeploop resume` for manual step-by-step control.",
+            flush=True,
+        )
+        return 2
+    result = run_project_until_complete(
+        Path(args.project_root),
+        mission_id=getattr(args, "mission_id", None),
+        force=getattr(args, "force", False),
+        chunk_iterations=getattr(args, "chunk_iterations", 8),
+        max_total_iterations=getattr(args, "max_total_iterations", 256),
+    )
+    if result["status"] != "completed":
+        print("\n".join(_noncompleted_summary_lines(result)), file=sys.stderr, flush=True)
+    print(json.dumps(_jsonify(result), indent=2))
+    return 0 if result["status"] == "completed" else 1
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Run a plain researcher project folder through DeepLoop until completion or a true operator boundary. "
+            "This command handles init + bounded start/resume loops for you."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    _add_run_args(parser)
+    args = parser.parse_args()
+    return _run_project(args)
+
+
+__all__ = ["main", "_add_run_args", "_run_project"]

{deeploop-0.1.2 → deeploop-0.1.4}/src/deeploop/mission/_operator_surface.py

@@ -7,7 +7,7 @@ from typing import Any, Mapping
 def management_commands(mission_state_path: Path) -> dict[str, str]:
     mission_state_arg = str(mission_state_path)
     return {
-        name: f"python scripts/mission/manage_mission.py {name} --mission-state {mission_state_arg}"
+        name: f"deeploop {name} --mission-state {mission_state_arg}"
         for name in ("status", "logs", "decisions", "inbox", "resume", "retry", "reroute", "triage", "stop")
     }
 
@@ -130,8 +130,8 @@ def operator_console_snapshot(
 
     headline = "STOPPED — DeepLoop is not currently running."
     summary = "No operator-facing mission summary is available yet."
-    recommendation = "Run status and logs to inspect the current mission state."
-    continue_summary = "Start or resume the mission once the desired next step is clear."
+    recommendation = "Run `deeploop status` or `deeploop logs` to inspect the current mission state."
+    continue_summary = "Start or resume once the next step is clear."
     gate_class = "none"
     gate_detail = None
     stop_reason = None
@@ -184,15 +184,15 @@ def operator_console_snapshot(
         ] or alternatives
         gate_class = str(blocker.get("kind") or blocker.get("gate") or "operator-review")
         gate_detail = str(blocker.get("risk_class") or blocker.get("label") or gate_class)
-        headline = "BLOCKED — operator action is required before DeepLoop can continue."
+        headline = "BLOCKED — review the request, then resume when ready."
         summary = str(current_request.get("summary") or blocker.get("reason") or "DeepLoop opened the operator inbox.")
         recommendation = str(
             recommendation_payload.get("summary")
-            or "Review the request, make the smallest safe change, then resume autopilot."
+            or "Review the request, make the smallest safe change, then resume."
         )
         stop_reason = str(blocker.get("reason") or failures.get("completion_reason") or summary)
         requires_action = True
-        continue_summary = "Review the inbox, make the requested change, optionally record retry/reroute feedback, then resume."
+        continue_summary = "Open the inbox, fix or reroute the blocked step, optionally record feedback, then resume."
         next_commands = [
             *(
                 [
@@ -234,7 +234,7 @@ def operator_console_snapshot(
         if isinstance(current_response, Mapping):
             action = str(current_response.get("action") or "operator-action")
             continue_summary = (
-                f"Operator feedback `{action}` is already recorded. Finish the requested change, then resume autopilot."
+                f"Operator feedback `{action}` is already recorded. Finish the change, then resume."
             )
             next_commands = [
                 {
@@ -390,7 +390,7 @@ def operator_console_snapshot(
             or failures.get("last_blocker")
             or "The detached mission process exited or has not started yet."
         )
-        recommendation = "Inspect status, logs, and decisions, address the blocker honestly, then resume if more work is needed."
+        recommendation = "Inspect status, logs, and decisions, then resume only after the blocker is understood."
         continue_summary = "Resume only after the blocker is understood and the next step is safe."
         requires_action = mission_status in {"blocked", "failed"}
         next_commands = [