loopx 1.0.1__tar.gz → 1.0.2__tar.gz

{loopx-1.0.1/loopx.egg-info → loopx-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loopx
-Version: 1.0.1
+Version: 1.0.2
 Summary: A lightweight Loop Engineering control plane for long-running agent goals.
 Author: LoopX contributors
 License-Expression: Apache-2.0
@@ -250,6 +250,18 @@ These are the three strongest current cases, not the full inventory. Browse the
 [complete Showcase catalog](docs/showcases/README.md) for contributor cases,
 creator dogfooding, reproducible demos, and explicit evidence-strength labels.
 
+### Exploratory Benchmark Studies
+
+- **[SWE-Marathon](https://huangruiteng.github.io/loopx/benchmarks/swe-marathon/):**
+  Five execution modes on 15 matched tasks compare self-verification, scores,
+  and cost. More self-verification did not consistently yield higher scores.
+- **[DeepSWE behavior analysis](https://huangruiteng.github.io/loopx/benchmarks/deepswe/behavior-discovery/)** (Chinese):
+  Selected cases examine how domain hints relate to requirement retention and
+  verification choices, offering mechanism hypotheses for further testing.
+
+SWE-Marathon has one trial per task and mode; DeepSWE uses selected cases and
+post-hoc analysis. Neither establishes a general performance gain.
+
 More inspectable surfaces:
 
 - the [public homepage](https://huangruiteng.github.io/loopx/) for the product

{loopx-1.0.1 → loopx-1.0.2}/README.md

@@ -220,6 +220,18 @@ These are the three strongest current cases, not the full inventory. Browse the
 [complete Showcase catalog](docs/showcases/README.md) for contributor cases,
 creator dogfooding, reproducible demos, and explicit evidence-strength labels.
 
+### Exploratory Benchmark Studies
+
+- **[SWE-Marathon](https://huangruiteng.github.io/loopx/benchmarks/swe-marathon/):**
+  Five execution modes on 15 matched tasks compare self-verification, scores,
+  and cost. More self-verification did not consistently yield higher scores.
+- **[DeepSWE behavior analysis](https://huangruiteng.github.io/loopx/benchmarks/deepswe/behavior-discovery/)** (Chinese):
+  Selected cases examine how domain hints relate to requirement retention and
+  verification choices, offering mechanism hypotheses for further testing.
+
+SWE-Marathon has one trial per task and mode; DeepSWE uses selected cases and
+post-hoc analysis. Neither establishes a general performance gain.
+
 More inspectable surfaces:
 
 - the [public homepage](https://huangruiteng.github.io/loopx/) for the product

{loopx-1.0.1 → loopx-1.0.2}/loopx/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"

{loopx-1.0.1 → loopx-1.0.2}/loopx/authority.py

@@ -10,24 +10,19 @@ from typing import Any
 from urllib.parse import urlparse
 
 from .control_plane.runtime.time import now_local_iso
+from .public_safe_text import (
+    PRIVATE_TEXT_PATTERNS as SHARED_PRIVATE_TEXT_PATTERNS,
+    find_private_text_match,
+)
 
 
 AUTHORITY_SOURCE_REGISTRATION_VERSION = "authority_source_registration_v0"
 DOC_REGISTRY_AUTHORITY_IMPORT_VERSION = "doc_registry_authority_import_v0"
 AUTHORITY_SOURCE_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]{0,79}$")
 AUTHORITY_SOURCE_BOUNDARIES = {"public", "local_private", "private_redacted"}
-PRIVATE_TEXT_PATTERNS = (
-    re.compile(r"/" + r"Users/"),
-    re.compile(r"/" + r"ext_data/"),
-    re.compile("la" + "rk" + "office", re.I),
-    re.compile("docs" + r"\." + "internal", re.I),
-    re.compile(r"\bt-20\d{12}-[a-z0-9]+\b"),
-    re.compile(r"\b" + "Bear" + r"er\b", re.I),
-    re.compile(r"\b" + "Author" + r"ization\b", re.I),
-    re.compile(r"\b" + "tok" + r"en\s*=", re.I),
-    re.compile(r"\b" + "pass" + r"word\b", re.I),
-    re.compile(r"\b" + "sec" + r"ret\b", re.I),
-)
+# Owned by loopx.public_safe_text so every real validator owner shares one
+# contract; re-exported here because callers already import this name.
+PRIVATE_TEXT_PATTERNS = SHARED_PRIVATE_TEXT_PATTERNS
 
 AUTHORITY_REGISTRY_SUMMARY_FIELDS = (
     "declared",
@@ -115,11 +110,8 @@ def public_safe_optional(label: str, value: str | None) -> str | None:
 
 
 def validate_public_safe_text(label: str, value: str | None) -> None:
-    if not value:
-        return
-    for pattern in PRIVATE_TEXT_PATTERNS:
-        if pattern.search(value):
-            raise ValueError(f"{label} contains a private-looking value; keep raw evidence in private payloads")
+    if find_private_text_match(value) is not None:
+        raise ValueError(f"{label} contains a private-looking value; keep raw evidence in private payloads")
 
 
 def find_goal_index(registry: dict[str, Any], goal_id: str) -> int:

{loopx-1.0.1 → loopx-1.0.2}/loopx/boundary_authority.py

@@ -1,28 +1,22 @@
 from __future__ import annotations
 
-import re
 from datetime import datetime, timezone
 from typing import Any
 
 from .control_plane.runtime.time import parse_timestamp as _parse_timestamp
 from .control_plane.todos.contract import normalize_required_write_scopes
+from .public_safe_text import (
+    PRIVATE_TEXT_PATTERNS as SHARED_PRIVATE_TEXT_PATTERNS,
+    find_private_text_match,
+)
 
 
 CHECKPOINTED_BOUNDARY_AUTHORITY_SCHEMA_VERSION = "checkpointed_boundary_authority_v0"
 ACTIVE_BOUNDARY_AUTHORITY_STATUSES = {"active", "approved"}
 BOUNDARY_AUTHORITY_DECISIONS = {"approve", "reject", "defer"}
-PRIVATE_TEXT_PATTERNS = (
-    re.compile(r"/" + r"Users/"),
-    re.compile(r"/" + r"ext_data/"),
-    re.compile("la" + "rk" + "office", re.I),
-    re.compile("docs" + r"\." + "internal", re.I),
-    re.compile(r"\bt-20\d{12}-[a-z0-9]+\b"),
-    re.compile(r"\b" + "Bear" + r"er\b", re.I),
-    re.compile(r"\b" + "Author" + r"ization\b", re.I),
-    re.compile(r"\b" + "tok" + r"en\s*=", re.I),
-    re.compile(r"\b" + "pass" + r"word\b", re.I),
-    re.compile(r"\b" + "sec" + r"ret\b", re.I),
-)
+# Owned by loopx.public_safe_text so every real validator owner shares one
+# contract; re-exported here because callers already import this name.
+PRIVATE_TEXT_PATTERNS = SHARED_PRIVATE_TEXT_PATTERNS
 
 
 def _now() -> datetime:
@@ -30,11 +24,8 @@ def _now() -> datetime:
 
 
 def _validate_public_safe_text(label: str, value: str | None) -> None:
-    if not value:
-        return
-    for pattern in PRIVATE_TEXT_PATTERNS:
-        if pattern.search(value):
-            raise ValueError(f"{label} contains a private-looking value; keep raw evidence in private payloads")
+    if find_private_text_match(value) is not None:
+        raise ValueError(f"{label} contains a private-looking value; keep raw evidence in private payloads")
 
 
 def _clean_text(value: Any, *, limit: int = 180) -> str | None:

{loopx-1.0.1 → loopx-1.0.2}/loopx/capabilities/benchmark_toolkit/README.md

@@ -1049,6 +1049,49 @@ solver-trajectory slice, even when no case became terminal. This readback is for
 campaign supervision and insight discovery only; it must not expose hidden
 evaluator evidence to the solving arm.
 
+When that readback produces a useful case-level runtime finding before terminal
+scoring, preserve it as a private provisional observation rather than waiting for
+the final grader or overstating it as a scored insight:
+
+```json
+{
+  "schema_version": "benchmark_case_observation_v0",
+  "case": {
+    "benchmark_id": "<public-id>",
+    "case_id": "<public-id>",
+    "arm": "<baseline-or-treatment>"
+  },
+  "run_status": "running",
+  "runtime_outcome": "<ok-error-in_progress-or-unknown>",
+  "duration_ms": null,
+  "evidence_refs": [
+    {
+      "kind": "trace",
+      "trace_id": "<opaque-id-or-null>",
+      "span_id": "<opaque-id-or-null>",
+      "env": "<environment-token-or-null>",
+      "artifact_ref": "<private-pointer-or-null>"
+    }
+  ],
+  "hypothesis": "<provisional-causal-explanation>",
+  "confidence": "medium",
+  "promotion_state": "pending_terminal_score_review"
+}
+```
+
+`trace_id`, `span_id`, and `env` are provider-neutral optional traceability fields.
+Provider-specific session identifiers belong in private provider extensions, not in
+this common contract. Raw evidence references can still disclose sensitive runtime
+topology, so the artifact stays in private benchmark storage. The public experiment
+board records only a compact classification or private artifact handle; it never
+copies trace IDs, spans, URLs, paths, or provider-specific session identifiers.
+
+The provisional observation must not invent a score or treat request success,
+progress, or runtime status as case quality. Once the run is terminal and scoring
+is complete, the analyst re-reads the complete authorized evidence and writes a
+separate `benchmark_case_insight_v0`; it does not relabel the provisional artifact
+as final.
+
 This is a provider obligation, not an effect performed by the reducer: the
 runtime-observation command only returns a typed classification and recommended
 transition. The provider remains responsible for the monitor cycle, trajectory
@@ -1093,6 +1136,15 @@ Record the result in this compact shape:
     "grader_or_verifier",
     "failure_and_score_details"
   ],
+  "evidence_refs": [
+    {
+      "kind": "<trace-log-artifact-report-or-other>",
+      "trace_id": "<opaque-id-or-null>",
+      "span_id": "<opaque-id-or-null>",
+      "env": "<environment-token-or-null>",
+      "artifact_ref": "<private-pointer-or-null>"
+    }
+  ],
   "insight": {
     "approach_summary": "<what-the-solver-tried>",
     "decisive_evidence": ["<specific-observation>"],

{loopx-1.0.1 → loopx-1.0.2}/loopx/capabilities/benchmark_toolkit/catalog_entry.py

@@ -746,6 +746,51 @@ BENCHMARK_TOOLKIT_CATALOG_ENTRY: dict[str, Any] = {
                 "raw_log_error_count_alone",
             ],
         },
+        "active_case_observation": {
+            "status": "provisional_only",
+            "purpose": (
+                "Preserve traceable runtime evidence while a case or campaign is "
+                "still active without presenting it as an official scored insight."
+            ),
+            "artifact_template": {
+                "schema_version": "benchmark_case_observation_v0",
+                "case": {
+                    "benchmark_id": "<public-id>",
+                    "case_id": "<public-id>",
+                    "arm": "<baseline-or-treatment>",
+                },
+                "run_status": "<planned-running-or-terminal>",
+                "runtime_outcome": "<ok-error-in_progress-or-unknown>",
+                "duration_ms": "<non-negative-integer-or-null>",
+                "evidence_refs": [
+                    {
+                        "kind": "<trace-log-artifact-report-or-other>",
+                        "trace_id": "<opaque-id-or-null>",
+                        "span_id": "<opaque-id-or-null>",
+                        "env": "<environment-token-or-null>",
+                        "artifact_ref": "<private-pointer-or-null>",
+                    }
+                ],
+                "hypothesis": "<provisional-causal-explanation>",
+                "confidence": "<high-medium-or-low>",
+                "promotion_state": "pending_terminal_score_review",
+            },
+            "score_boundary": (
+                "A provisional observation must not invent an official score or "
+                "treat request success, progress, or runtime status as case quality."
+            ),
+            "promotion_rule": (
+                "After terminal scoring, re-read the complete authorized evidence "
+                "and write a separate benchmark_case_insight_v0; do not relabel the "
+                "provisional artifact as final."
+            ),
+            "privacy_boundary": (
+                "Keep raw evidence references in private benchmark storage. The "
+                "public experiment board may expose only a compact classification "
+                "or private artifact handle, never trace IDs, spans, URLs, paths, "
+                "or provider-specific session identifiers."
+            ),
+        },
         "hint": (
             "After the solver has stopped and scoring is complete, read the task, "
             "real trajectory, final patch or workspace, hidden tests, grader or "
@@ -815,6 +860,15 @@ BENCHMARK_TOOLKIT_CATALOG_ENTRY: dict[str, Any] = {
                 "grader_or_verifier",
                 "failure_and_score_details",
             ],
+            "evidence_refs": [
+                {
+                    "kind": "<trace-log-artifact-report-or-other>",
+                    "trace_id": "<opaque-id-or-null>",
+                    "span_id": "<opaque-id-or-null>",
+                    "env": "<environment-token-or-null>",
+                    "artifact_ref": "<private-pointer-or-null>",
+                }
+            ],
             "insight": {
                 "approach_summary": "<what-the-solver-tried>",
                 "decisive_evidence": ["<specific-observation>"],
@@ -940,6 +994,11 @@ BENCHMARK_TOOLKIT_CATALOG_ENTRY: dict[str, Any] = {
             "module": "loopx.capabilities.benchmark_toolkit.run_permissions",
             "doc": "loopx/capabilities/benchmark_toolkit/README.md",
         },
+        {
+            "schema_version": "benchmark_case_observation_v0",
+            "module": "loopx.capabilities.benchmark_toolkit.catalog_entry",
+            "doc": "loopx/capabilities/benchmark_toolkit/README.md",
+        },
         {
             "schema_version": "benchmark_case_insight_v0",
             "module": "loopx.capabilities.benchmark_toolkit.catalog_entry",

{loopx-1.0.1 → loopx-1.0.2}/loopx/capabilities/benchmark_toolkit/native_codex_profile.py

@@ -463,11 +463,32 @@ def inspect_native_codex_profile(
     if resolved_release not in resolved_cli.parents:
         raise NativeCodexProfileError("profile_cli_not_release_snapshot")
 
+    env = _formal_install_environment(
+        paths=paths,
+        python_executable=_resolved_executable(None),
+        release_id=release_id,
+        base_env=base_env,
+    )
+    # The profile's CLI owns the loaded skills; the inspecting supervisor may
+    # run a different LoopX version.
+    try:
+        version_readback = subprocess.run(
+            [str(cli_bin), "--version"],
+            cwd=paths["root"], env=env, check=False, capture_output=True,
+            text=True, timeout=30,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise NativeCodexProfileError("profile_cli_version_unavailable") from exc
+    version_parts = version_readback.stdout.split()
+    if version_readback.returncode or len(version_parts) != 2 or version_parts[0] != "loopx":
+        raise NativeCodexProfileError("profile_cli_version_invalid")
+
     expected_source = Path(source_root).expanduser().resolve() if source_root else None
     skill_readback = inspect_skill_install_readback(
         skills_dir=paths["skills_dir"],
         required_skill_ids=required,
         source_root=expected_source,
+        expected_loopx_version_override=version_parts[1],
     )
     if skill_readback.get("ready") is not True:
         status = re.sub(r"[^A-Za-z0-9_.:-]", "_", str(skill_readback.get("status")))
@@ -484,12 +505,6 @@ def inspect_native_codex_profile(
     if not isinstance(skills_digest, str) or not isinstance(source_revision, str):
         raise NativeCodexProfileError("profile_identity_missing")
 
-    env = _formal_install_environment(
-        paths=paths,
-        python_executable=_resolved_executable(None),
-        release_id=release_id,
-        base_env=base_env,
-    )
     doctor = _doctor_payload(cli_bin=cli_bin, paths=paths, env=env)
     release_manifest = (doctor.get("release_manifest") or {}).get("manifest") or {}
     release_source = release_manifest.get("source") or {}

{loopx-1.0.1 → loopx-1.0.2}/loopx/capabilities/pr_review_queue/README.md

@@ -543,7 +543,23 @@ blocking findings. A successful check is **not** proof of factual evidence, revi
 quality, current remote head, or merge permission. Re-read the head and publish the
 human-readable evidence separately. Existing queue/monitor behavior is unchanged;
 omit these two flags to use normal queue discovery. An older saved packet may need
-fresh review evidence when the installed contract has advanced.
+fresh review evidence when the installed contract has advanced. The execution
+contract now carries `policy_revision`, distinct from its stable wire schema;
+results bind `review_policy_revision`. Missing or mismatched policy revisions
+cannot certify approval. Regenerate the packet and perform the current plan,
+not merely relabel old evidence. The skill rejects approval from incompatible
+packets produced by expired development-runtime overrides. It may still publish
+a conservative `REQUEST_CHANGES` only when that verdict explicitly identifies
+the incompatible-policy evidence gap; a later approval requires regeneration.
+
+For retained or parallel implementations, `repository_reuse.rule_ownership`
+maps business rules across both reachable paths, including unchanged files.
+Keeping a legacy storage writer does not justify keeping its independent
+eligibility, retention, ordering or successor rules. Name actual retired rules
+and justified compatibility/effect code, not a net-deletion quota. A positive
+twin with shared decisions and necessary extra adapter code must remain
+approvable. Verified evidence rows must fill their declared fields; the checker
+validates this completeness only, never the truth of their contents.
 
 Behavioral qualification lives in `tests/capabilities/test_pr_review_behavior.py`:
 paired synthetic cases include valid designs as well as counterexamples. The optional

{loopx-1.0.1 → loopx-1.0.2}/loopx/capabilities/pr_review_queue/result_check.py

@@ -31,6 +31,9 @@ def check_review_result(
     }
     blockers: list[str] = []
     errors: list[str] = []
+    revision = result.get("review_policy_revision")
+    if type(revision) is not int or revision != contract["policy_revision"]:
+        blockers.append("review_policy_revision:stale_or_missing")
     if result.get("schema_version") != "pull_request_review_result_v1":
         errors.append("unsupported_result_schema")
     evidence = result.get("evidence")
@@ -50,6 +53,10 @@ def check_review_result(
         detail = {k: v for k, v in row.items() if k not in {"status", "verdict"}}
         if not any(v not in (None, "", [], {}) for v in detail.values()):
             blockers.append(f"{key}:missing_evidence_detail")
+        if status == "verified":
+            for field in requirements[key].get("fields", []):
+                if row.get(field) in (None, "", [], {}):
+                    blockers.append(f"{key}:missing_field:{field}")
         allowed = requirements[key].get("verdict_values")
         if allowed and row.get("verdict") not in allowed:
             blockers.append(f"{key}:missing_or_invalid_verdict")

{loopx-1.0.1 → loopx-1.0.2}/loopx/capabilities/pr_review_queue/review_contract.py

@@ -3,6 +3,9 @@ from __future__ import annotations
 from collections.abc import Mapping, Sequence
 from typing import Any
 
+# Increment when review requirements change without changing the packet shape.
+REVIEW_POLICY_REVISION = 1
+
 REQUIRED_FINAL_SECTIONS = [
     "动机",
     "改动思路",
@@ -105,6 +108,7 @@ def build_review_template(item: Mapping[str, Any]) -> dict[str, Any]:
 def build_review_execution_contract() -> dict[str, Any]:
     return {
         "schema_version": "pull_request_review_execution_contract_v2",
+        "policy_revision": REVIEW_POLICY_REVISION,
         "purpose": (
             "Define the evidence that must exist before a detailed review verdict; "
             "host skills route this contract but must not reimplement it."
@@ -188,13 +192,36 @@ def build_review_execution_contract() -> dict[str, Any]:
                 "fields": [
                     "searched_revisions", "queries_and_paths", "existing_candidates",
                     "semantic_comparison", "reuse_or_separation_reason",
-                    "state_model_assessment", "validation_evidence", "verdict",
+                    "state_model_assessment", "rule_ownership", "validation_evidence", "verdict",
                 ],
                 "comparison_dimensions": [
                     "resource_and_caller", "data_scope_and_filters",
                     "ordering_and_pagination", "authority_and_sanitization",
                     "state_retry_and_failure_owner",
                 ],
+                "rule_ownership": {
+                    "required_when": "retained_or_parallel_implementations",
+                    "row_fields": [
+                        "business_rule", "baseline_owner", "head_owner",
+                        "retained_path_and_caller", "retention_reason",
+                        "deleted_rule_or_exit_condition", "validation",
+                    ],
+                    "rule": (
+                        "For migrations, fallback paths, dual providers or old/new entrypoints, "
+                        "map each touched business rule across BOTH reachable paths, including "
+                        "unchanged files. Separate storage parsing/writing and host effects from "
+                        "eligibility, ordering, retention and successor derivation. A required "
+                        "legacy writer does not justify a second decision owner. Ask where the "
+                        "next policy change must be edited: tests comparing two new providers "
+                        "do not prove the old path shares their rule. Name a bounded shared "
+                        "owner and actual deletion where appropriate; justify deliberate "
+                        "independent semantics instead of forcing abstraction. Record no "
+                        "parallel path with caller-search evidence when not applicable. "
+                        "Moved lines are not retired knowledge, and net-negative LOC is not "
+                        "an acceptance quota. Missing analysis is not_yet_proven; an unjustified "
+                        "duplicate rule is unjustified_duplication under repository_reuse."
+                    ),
+                },
                 "state_model_assessment": {
                     "required_when": "introduced_or_newly_enforced_state",
                     "classification_values": [
@@ -896,6 +923,7 @@ def build_review_plan(item: Mapping[str, Any]) -> dict[str, Any]:
         "required_evidence_ids": required_evidence,
         "result_template": {
             "schema_version": "pull_request_review_result_v1",
+            "review_policy_revision": REVIEW_POLICY_REVISION,
             "target_exact_head": target_key,
             "evidence": {
                 evidence_id: {"status": "unverified"}

{loopx-1.0.1 → loopx-1.0.2}/loopx/chat_server.py

@@ -1477,10 +1477,10 @@ def serve_chat(
     )
     server.action_service = ChatActionService(
         store=server.action_store,
-        registry_path=registry_path,
+        registry_path=resolved_registry_path,
         chat_store=server.chat_store,
         runtime_controller=server.runtime_controller,
-        workspace_roots=scan_roots,
+        workspace_roots=resolved_scan_roots,
     )
     server.lark_goal_topic_runtime = LarkGoalTopicRuntimeService(
         snapshot_provider=lambda: build_lark_goal_topic_runtime_snapshot(

{loopx-1.0.1 → loopx-1.0.2}/loopx/chat_store.py

@@ -489,9 +489,10 @@ class ChatSessionStore:
             "created_at": utc_now(),
         }
         with exclusive_file_lock(path, agent_id="loopx-chat", operation="append_chat_message"):
-            for existing in _read_jsonl(path):
-                if existing.get("message_id") == payload["message_id"]:
-                    return existing
+            if message_id:
+                for existing in _read_jsonl(path):
+                    if existing.get("message_id") == payload["message_id"]:
+                        return existing
             _append_jsonl(path, payload)
         return payload
 

{loopx-1.0.1 → loopx-1.0.2}/loopx/cli_commands/quota.py

@@ -42,6 +42,9 @@ from ..control_plane.quota.settlement_cli import (
     render_existing_heartbeat_receipt_payload,
 )
 from ..control_plane.quota.turn_envelope import build_turn_envelope
+from ..control_plane.coordination.legacy_writer_fence import (
+    LegacyCoordinationWriterFenced,
+)
 from ..control_plane.effect_runtime import EffectRuntimeRejected
 from ..control_plane.scheduler.execution_context import (
     GUIDED_START_TURN_RUNTIME_PROFILES,
@@ -238,6 +241,14 @@ def _quota_failure_payload(
         )
         if error.agent_id is not None:
             payload["agent_id"] = error.agent_id
+    elif isinstance(error, LegacyCoordinationWriterFenced):
+        payload.update(
+            {
+                "error_code": error.code,
+                "reason": str(error),
+                **error.payload,
+            }
+        )
     if lock_timeout_fields:
         payload["recommended_action"] = "inspect the lock holder before retrying"
     if command == "monitor-poll":

{loopx-1.0.1 → loopx-1.0.2}/loopx/cli_commands/quota_context.py

@@ -5,6 +5,9 @@ from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from pathlib import Path
 
+from ..control_plane.coordination.legacy_writer_fence import (
+    require_legacy_coordination_write_allowed,
+)
 from ..control_plane.quota.error_codes import QuotaCommandValidationError
 from ..control_plane.runtime.status_projection_cache import (
     load_status_projection_cache,
@@ -175,7 +178,8 @@ def validate_quota_command_context_request(
         if profile not in GUIDED_START_TURN_RUNTIME_PROFILES:
             raise QuotaCommandValidationError(
                 "--begin-turn requires runtime-profile codex_app_heartbeat "
-                "or codex_app_ssh_goal"
+                "or codex_app_ssh_goal; every other host starts its turn by "
+                "passing its own --turn-instance-id"
             )
     if (
         (heartbeat_turn_id or begin_turn)
@@ -220,6 +224,13 @@ def prepare_quota_command_context(
         registry_path=registry_path,
         runtime_root_override=runtime_root_arg,
     )
+    if command == "monitor-poll" and args.execute and (args.todo_id or args.target_key):
+        # This command still uses the legacy Todo writer. Preserve its typed
+        # rejection before collecting a promoted read model (which may itself
+        # be unavailable). The writer repeats the check under its mutation lock.
+        require_legacy_coordination_write_allowed(
+            runtime_root=runtime_root, goal_id=args.goal_id,
+        )
     status_goal_id = args.goal_id if command not in {"status", "plan"} else None
     projection_cache_ttl_seconds = int(
         getattr(args, "projection_cache_ttl_seconds", 120)

{loopx-1.0.1 → loopx-1.0.2}/loopx/cli_commands/todo_event.py

@@ -37,7 +37,7 @@ def todo_error_payload(args: argparse.Namespace, exc: Exception) -> dict[str, ob
         "dry_run": True
         if args.todo_command == "suggest"
         else not bool(args.execute)
-        if args.todo_command == "archive-completed"
+        if args.todo_command in {"archive-completed", "project-markdown"}
         else bool(args.dry_run),
         "added": False,
         "already_exists": False,

{loopx-1.0.1 → loopx-1.0.2}/loopx/cli_commands/turn.py

@@ -481,6 +481,7 @@ def handle_turn_command(
                     todo_id=todo_id,
                     registry_path=registry_path,
                     goal_id=args.goal_id,
+                    runtime_root=runtime_root,
                 )
                 return project_durable_completion_intent(
                     todo=durable_todo,
@@ -531,6 +532,7 @@ def handle_turn_command(
                         todo_id=todo_id,
                         registry_path=registry_path,
                         goal_id=args.goal_id,
+                        runtime_root=runtime_root,
                     )
                     completion_outcome = project_durable_completion_outcome(
                         todo=durable_todo,
@@ -675,6 +677,7 @@ def handle_turn_command(
                         todo_id=todo_id,
                         registry_path=registry_path,
                         goal_id=args.goal_id,
+                        runtime_root=runtime_root,
                     )
                     return project_durable_completion_outcome(
                         todo=durable_todo,
@@ -703,6 +706,7 @@ def handle_turn_command(
                     todo_id=todo_id,
                     registry_path=registry_path,
                     goal_id=args.goal_id,
+                    runtime_root=runtime_root,
                 )
                 readback = project_durable_terminal_completion_readback(
                     todo=durable_todo,