diff --git a/loopx/capabilities/native_chat/steward_monitor.py b/loopx/capabilities/native_chat/steward_monitor.py index fa65660e6c..ddfe008552 100644 --- a/loopx/capabilities/native_chat/steward_monitor.py +++ b/loopx/capabilities/native_chat/steward_monitor.py @@ -33,6 +33,7 @@ TARGET = "steward-portfolio-watch" FOLLOWUP_TARGET_PREFIX = "steward-monitor-followup:" ADVANCEMENT_PRECOMMIT_RETRY_COOLDOWN_SECONDS = 60 +ADVANCEMENT_ADMISSION_RETRY_SUFFIX = ".admission-retry" ADVANCEMENT_PRECOMMIT_RETRY_SUFFIX = ".precommit-retry" _LOG = logging.getLogger(__name__) @@ -71,23 +72,43 @@ def advancement_turn_id(todo: dict[str, Any]) -> str: [todo["todo_id"], stamp], sort_keys=True).encode()).hexdigest()[:40] -def _is_precommit_retryable_advancement_turn( +def _zero_write_advancement_response( turn: Mapping[str, Any], *, now: float | None = None, -) -> bool: - """Allow one delayed retry only when zero kernel/Steward writes occurred.""" +) -> Mapping[str, Any] | None: + """Return native_loopx payload only when a completed Turn wrote zero Steward outputs and passed cooldown.""" from .steward_turn import _iso_timestamp_seconds if turn.get("status") != "completed": - return False + return None resp = turn.get("response") if not isinstance(resp, Mapping): - return False + return None + if (resp.get("steward_owner_report_queued") + or resp.get("context_handoff") + or resp.get("steward_user_action_receipts")): + return None nl = resp.get("native_loopx") - if not isinstance(nl, Mapping): - return False - if nl.get("ok") is not False or nl.get("status") != "failed": + if not isinstance(nl, Mapping) or nl.get("ok") is not False: + return None + completed_ts = _iso_timestamp_seconds(turn.get("completed_at")) + if completed_ts is None: + return None + current_ts = time.time() if now is None else now + if current_ts - completed_ts < ADVANCEMENT_PRECOMMIT_RETRY_COOLDOWN_SECONDS: + return None + return nl + + +def _is_precommit_retryable_advancement_turn( + turn: Mapping[str, Any], + *, + now: float | None = None, +) -> bool: + """Allow one delayed retry only when zero kernel/Steward writes occurred.""" + nl = _zero_write_advancement_response(turn, now=now) + if nl is None or nl.get("status") != "failed": return False if nl.get("result_kind") not in {"validation_failed", "host_failure"}: return False @@ -98,19 +119,32 @@ def _is_precommit_retryable_advancement_turn( return False if not (commit_eligibility.get("writeback") is False or effects.get("state_written") is False): return False - if (effects.get("state_written") is True - or effects.get("quota_spent") is True - or effects.get("scheduler_acknowledged") is True): + return not ( + effects.get("state_written") is True + or effects.get("quota_spent") is True + or effects.get("scheduler_acknowledged") is True + ) + + +def _is_zero_effect_selection_deferred_advancement_turn( + turn: Mapping[str, Any], + *, + now: float | None = None, +) -> bool: + """Allow bounded retry only for zero-effect pre-host selection deferrals.""" + nl = _zero_write_advancement_response(turn, now=now) + if nl is None or nl.get("error_code") != "turn_todo_selection_deferred": return False - if (resp.get("steward_owner_report_queued") - or resp.get("context_handoff") - or resp.get("steward_user_action_receipts")): + refusal = nl.get("selection_rejection") + if not isinstance(refusal, Mapping) or refusal.get("state") != "deferred": return False - completed_ts = _iso_timestamp_seconds(turn.get("completed_at")) - if completed_ts is None: + effects = nl.get("effects") + if not isinstance(effects, Mapping): return False - current_ts = time.time() if now is None else now - return current_ts - completed_ts >= ADVANCEMENT_PRECOMMIT_RETRY_COOLDOWN_SECONDS + return not any( + effects.get(key) is not False + for key in ("host_invoked", "state_written", "quota_spent", "scheduler_acknowledged") + ) def resolve_advancement_turn_id( @@ -120,7 +154,7 @@ def resolve_advancement_turn_id( *, now: float | None = None, ) -> str | None: - """Resolve the active attempt id or at most one post-cooldown pre-commit retry.""" + """Resolve the active attempt id or bounded post-cooldown deferral/pre-commit retries.""" from .steward_turn import native_steward_client_id base = advancement_turn_id(todo) @@ -130,15 +164,32 @@ def resolve_advancement_turn_id( ) if existing is None: return base + primary_token = base + if _is_zero_effect_selection_deferred_advancement_turn(existing, now=now): + primary_token = base + ADVANCEMENT_ADMISSION_RETRY_SUFFIX + existing = store.turn_for_client( + actor["session_id"], + native_steward_client_id(actor, primary_token), + ) + if existing is None: + return primary_token if not _is_precommit_retryable_advancement_turn(existing, now=now): return None - retry_token = base + ADVANCEMENT_PRECOMMIT_RETRY_SUFFIX - if store.turn_for_client( + retry_token = primary_token + ADVANCEMENT_PRECOMMIT_RETRY_SUFFIX + retry_existing = store.turn_for_client( actor["session_id"], native_steward_client_id(actor, retry_token), - ) is not None: - return None - return retry_token + ) + if retry_existing is None: + return retry_token + if _is_zero_effect_selection_deferred_advancement_turn(retry_existing, now=now): + retry_admission_token = retry_token + ADVANCEMENT_ADMISSION_RETRY_SUFFIX + if store.turn_for_client( + actor["session_id"], + native_steward_client_id(actor, retry_admission_token), + ) is None: + return retry_admission_token + return None def _github_repo_slug(task_repository: Any) -> str | None: diff --git a/loopx/capabilities/native_chat/steward_turn.py b/loopx/capabilities/native_chat/steward_turn.py index be81f00d06..7530e72126 100644 --- a/loopx/capabilities/native_chat/steward_turn.py +++ b/loopx/capabilities/native_chat/steward_turn.py @@ -14,9 +14,11 @@ import json from pathlib import Path import re +import shlex import time from typing import Any +from ...control_plane.effect_runtime import EffectRuntimeRejected from ...control_plane.goals.activation import goal_is_stopped from ...control_plane.goals.first_party_host_admission import FirstPartyHostRuntimeRejected from ...file_lock import exclusive_file_lock @@ -198,6 +200,24 @@ def _normalize_steward_advancement_kernel_candidate(candidate: Mapping[str, Any] return normalized +def _is_zero_effect_replan_selection_deferral(result: Mapping[str, Any]) -> bool: + """Identify a zero-effect pre-host autonomous_replan selection refusal.""" + if result.get("ok") is not False or result.get("error_code") != "turn_todo_selection_deferred": + return False + refusal = result.get("selection_rejection") + if (not isinstance(refusal, Mapping) or refusal.get("state") != "deferred" + or refusal.get("reason_code") != "autonomous_replan" + or refusal.get("recovery_action") != "reenter_guard_without_selection"): + return False + effects = result.get("effects") + if not isinstance(effects, Mapping): + return False + return all( + effects.get(key) is False + for key in ("host_invoked", "state_written", "quota_spent", "scheduler_acknowledged") + ) + + class StewardTurnHost: def __init__(self, controller: Any) -> None: self.controller = controller @@ -1231,6 +1251,85 @@ def _steward_followup_context(self, actor: Mapping[str, Any], session_id: str, payload["prior_handoff_receipts"] = prior[:40] return payload + def _governance_replan_context(self, actor: Mapping[str, Any], authority: Mapping[str, Any]) -> dict[str, Any]: + """Project public-safe review/writeback/vision context for text-only Steward replanning.""" + from ...cli import build_parser + from ...cli_commands.quota_native_context import read_replan_view + from ...control_plane.goals.goal_frontier import latest_agent_vision_from_status_payload + from ...control_plane.todos.list_readback import list_goal_todos + from .steward_commands import NativeStewardCommandError, native_command + + model_input = authority.get("_model_input") + detail_ref = model_input.get("detail_ref") if isinstance(model_input, Mapping) else None + packet = authority.get("replan_action_packet") or ( + detail_ref.get("replan_action_packet") if isinstance(detail_ref, Mapping) else None + ) + + def _read_stage(cmd_str: Any) -> dict[str, Any] | None: + if not isinstance(cmd_str, str) or not cmd_str.strip(): + return None + try: + tokens = shlex.split(cmd_str) + q_idx = tokens.index("quota") + parsed = build_parser().parse_args(tokens[q_idx:]) + view = read_replan_view(parsed) + if isinstance(view, Mapping) and view.get("ok") is True: + return dict(view) + except (OSError, ValueError, KeyError, TypeError, RuntimeError, EffectRuntimeRejected, SystemExit): + return None + return None + + payload: dict[str, Any] = {} + if isinstance(packet, Mapping): + review_view = _read_stage(packet.get("review")) + if review_view is not None: + core_goal = review_view.get("core_goal") + payload["review"] = { + "obligation_id": review_view.get("obligation_id"), + "context_id": review_view.get("context_id"), + "objective": core_goal.get("objective") if isinstance(core_goal, Mapping) else None, + "triggers": review_view.get("triggers"), + "recent_evidence": list(review_view.get("evidence") or [])[:12], + "decision_followthrough": review_view.get("decision_followthrough"), + } + writeback_view = _read_stage(packet.get("writeback")) + if writeback_view is not None: + payload["writeback"] = { + "obligation_id": writeback_view.get("obligation_id"), + "context_id": writeback_view.get("context_id"), + "required_outcome": writeback_view.get("required_outcome"), + "writeback_contract": writeback_view.get("writeback_contract"), + "stride_control": writeback_view.get("stride_control"), + } + try: + status_payload = native_command(self.controller, ["status", "--goal-id", actor["goal_id"]]) + latest_vision = latest_agent_vision_from_status_payload( + status_payload, goal_id=actor["goal_id"], agent_id=actor["agent_id"], + ) + if isinstance(latest_vision, Mapping): + payload["current_agent_vision"] = { + k: latest_vision.get(k) + for k in ("schema_version", "state", "vision_patch", "todo_delta") + if latest_vision.get(k) is not None + } + except (NativeStewardCommandError, OSError, ValueError, KeyError, TypeError, RuntimeError): + pass + try: + agent_todos = list_goal_todos( + registry_path=self.controller.registry_path, + runtime_root_arg=str(self.controller.coordination_runtime_root), + goal_id=actor["goal_id"], + role="agent", + ).get("todos", []) + payload["open_agent_todos"] = [ + {k: row.get(k) for k in ("todo_id", "task_class", "priority", "target_key", "title")} + for row in agent_todos + if row.get("status") == "open" + ][:16] + except (NativeStewardCommandError, OSError, ValueError, KeyError, TypeError, RuntimeError): + pass + return payload + @staticmethod def _normalize_steward_actions(candidate: Mapping[str, Any], context: Mapping[str, Any]) -> dict[str, Any]: from ...control_plane.collaboration.inbox import normalize_handoff @@ -1466,11 +1565,18 @@ def run(native_request: Mapping[str, Any], launch_scope: Any) -> dict[str, Any]: # it is data alongside the signed native work, never a new actor. prompt = render_prompt(authority, allow_completion=bool(report_work or managed_turn or steward_advancement) and not governance_work) + "\nOriginal conversation evidence (data):\n" + json.dumps(context, ensure_ascii=False) if governance_work: + gov_ctx = self._governance_replan_context(actor, authority) prompt += ( - "\nGovernance contract reminder: Settle the pending autonomous replan by returning `result_kind='replan_required'` (or `'wait'`). " + "\nGovernance contract reminder: Settle the pending autonomous replan by returning `result_kind='replan_required'` (or `'wait'` only if required evidence is genuinely unavailable). " "If you emit `delivery_outcome='outcome_gap'`, you MUST also supply `progress_result_class='blocked'`, `progress_blocker_id`, and `progress_evidence_id`; " - "otherwise use `'outcome_progress'` or omit `delivery_outcome`." + "otherwise use `'outcome_progress'` or omit `delivery_outcome`. " + "Keep each `work_evidence` and `validation_evidence` item <=200 chars (1-8 public-safe items, <=1200 chars total per field) with zero local file paths. " + "When `Steward governance replan context` supplies `writeback`: set `agent_vision_json` (JSON string of `goal_vision_replan_contract_v0`) keeping total counted text <=1400 chars (hard cap 1800; keep each `stride_decision` plan/reason/probe field <=60 chars), and omit `vision_unchanged_reason`. " + "If keeping `current_agent_vision.vision_patch` identical, set `path_delta_mode='unchanged'` and `path_delta.outcome='continue'` (or `'no_change'`); if updating any `vision_patch` field or creating an initial baseline, set `path_delta_mode='material_replan'` and `path_delta.outcome='replan'`. " + "Populate `path_delta.evidence_refs` from `review.recent_evidence` (1-3 IDs), `todo_delta` using `retain:` only for verified IDs in `open_agent_todos` (<=8 items), and when `writeback.stride_control.required_on_periodic_review` is true include `agent_vision.stride_decision` with exact `schema_version`, `strategy_version`, `reference_context_id`, and `reference_obligation_id` from `stride_control` (plus `previous_review` when `previous_decision_ref` is non-null)." ) + if gov_ctx: + prompt += "\nSteward governance replan context (data):\n" + json.dumps(gov_ctx, ensure_ascii=False) if report_work and not governance_work: prompt += report_context if steward_advancement and not governance_work: @@ -1547,6 +1653,11 @@ def launch(): kernel_candidate.pop("steward_user_actions", None) kernel_candidate.pop("steward_owner_report", None) kernel_candidate = _normalize_steward_advancement_kernel_candidate(kernel_candidate) + elif governance_work and kernel_candidate is not None: + kernel_candidate.pop("context_handoff", None) + kernel_candidate.pop("steward_user_actions", None) + kernel_candidate.pop("steward_owner_report", None) + kernel_candidate = _normalize_steward_advancement_kernel_candidate(kernel_candidate) if governance_work and kernel_candidate and kernel_candidate.get("result_kind") not in {"replan_required", "wait", "user_action_required", "iteration_failed"}: kernel_candidate = {"result_kind": "wait", "classification": "report_replan_not_settled", "next_action": "Retain the original report until its native semantic replan is settled."} @@ -1652,18 +1763,55 @@ def steward_validator(_plan: Mapping[str, Any], candidate_result: Mapping[str, A return {"status": "passed", "validator_kind": "callback", "summary": "steward advancement non-completion result recorded"} - handle_turn_command(args, registry_path=self.controller.registry_path, - runtime_root_arg=str(self.controller.coordination_runtime_root), - output_format=lambda *_a, **_kw: "json", - print_payload=lambda value, *_a: result.update(value), - native_host_runner=run, native_session_binding_resolver=session_binding, - native_execution_preparer=prepare_native_task if not report_work else None, - **({"native_completion_lease_resolver": report_lease_proof, - "native_task_validator": self._report_validator(request)} if report_work else - {"native_task_validator": managed_turn.validator(request, turn_id=turn_id), - "native_completion_lease_resolver": lambda: self._task_lease_proof(managed_lease_request, managed_lease)} if managed_turn else - {"native_task_validator": steward_validator, - "native_completion_lease_resolver": lambda: self._task_lease_proof(managed_lease_request, managed_lease)} if steward_advancement else {})) + def run_primary_turn() -> None: + result.clear() + handle_turn_command(args, registry_path=self.controller.registry_path, + runtime_root_arg=str(self.controller.coordination_runtime_root), + output_format=lambda *_a, **_kw: "json", + print_payload=lambda value, *_a: result.update(value), + native_host_runner=run, native_session_binding_resolver=session_binding, + native_execution_preparer=prepare_native_task if not report_work else None, + **({"native_completion_lease_resolver": report_lease_proof, + "native_task_validator": self._report_validator(request)} if report_work else + {"native_task_validator": managed_turn.validator(request, turn_id=turn_id), + "native_completion_lease_resolver": lambda: self._task_lease_proof(managed_lease_request, managed_lease)} if managed_turn else + {"native_task_validator": steward_validator, + "native_completion_lease_resolver": lambda: self._task_lease_proof(managed_lease_request, managed_lease)} if steward_advancement else {})) + + run_primary_turn() + if (steward_advancement and request.get("todo_id") and not request.get("resume_turn_key") + and _is_zero_effect_replan_selection_deferral(result)): + governance_args = type(args)(**vars(args)) + governance_args.todo_id, governance_args.validation_command_json = None, None + governance_args.turn_instance_id = request["turn_instance_id"] + ".replan" + governance: dict[str, Any] = {} + governance_work = True + try: + handle_turn_command(governance_args, registry_path=self.controller.registry_path, + runtime_root_arg=str(self.controller.coordination_runtime_root), + output_format=lambda *_a, **_kw: "json", + print_payload=lambda value, *_a: governance.update(value), + native_host_runner=run, native_session_binding_resolver=session_binding) + finally: + governance_work = False + self.store.append_event(session_id, turn_id, kind="native_loopx.replan_result", payload=governance) + replan_cleared = ( + governance.get("status") == "committed" + and governance.get("result_kind") == "replan_required" + ) or ( + governance.get("status") == "stopped" + and isinstance(governance.get("host_result"), Mapping) + and governance["host_result"].get("classification") == "report_replan_not_admitted" + and self._cleared_replan_guard(actor) is not None + ) + if replan_cleared: + run_primary_turn() + elif isinstance(governance.get("effects"), Mapping): + merged_effects = dict(result.get("effects") or {}) + for key in ("host_invoked", "state_written", "quota_spent", "scheduler_acknowledged"): + if governance["effects"].get(key) is True: + merged_effects[key] = True + result["effects"] = merged_effects if preparation_status is not None: # Validation stopped preparation before the claim or model call. result["status"] = preparation_status diff --git a/tests/test_steward_generic_monitor_todo.py b/tests/test_steward_generic_monitor_todo.py index 4418bec159..2db398c92b 100644 --- a/tests/test_steward_generic_monitor_todo.py +++ b/tests/test_steward_generic_monitor_todo.py @@ -800,3 +800,351 @@ def test_scoped_signal_monitor_overlong_work_evidence_commits_and_precommit_retr # No third retry is ever dispatched even if open. runtime._steward_monitor_next_check.clear() assert pump_steward_monitors(runtime) == [] + + +def test_resolve_advancement_turn_id_handles_selection_deferral_and_precommit_retries(tmp_path) -> None: + from loopx.capabilities.native_chat.steward_monitor import ( + ADVANCEMENT_ADMISSION_RETRY_SUFFIX, + ADVANCEMENT_PRECOMMIT_RETRY_SUFFIX, + advancement_turn_id, + resolve_advancement_turn_id, + ) + from loopx.capabilities.native_chat.steward_turn import native_steward_client_id + + actor = {"goal_id": "goal-steward-test", "agent_id": "steward", "session_id": "sess-1"} + todo = {"todo_id": "todo_adv123", "updated_at": "2026-11-21T08:00:00Z"} + base = advancement_turn_id(todo) + base_cid = native_steward_client_id(actor, base) + adm_tok = base + ADVANCEMENT_ADMISSION_RETRY_SUFFIX + adm_cid = native_steward_client_id(actor, adm_tok) + pre_tok = base + ADVANCEMENT_PRECOMMIT_RETRY_SUFFIX + pre_cid = native_steward_client_id(actor, pre_tok) + pre_adm_tok = pre_tok + ADVANCEMENT_ADMISSION_RETRY_SUFFIX + pre_adm_cid = native_steward_client_id(actor, pre_adm_tok) + old_completed = "2026-11-21T08:00:00Z" + now_after_cooldown = datetime(2026, 11, 21, 8, 5, 0, tzinfo=timezone.utc).timestamp() + now_in_cooldown = datetime(2026, 11, 21, 8, 0, 20, tzinfo=timezone.utc).timestamp() + + class _FakeStore: + def __init__(self, mapping: dict[str, dict]) -> None: + self.mapping = mapping + + def turn_for_client(self, session_id: str, cid: str): + return self.mapping.get(cid) if session_id == "sess-1" else None + + deferred_turn = { + "status": "completed", + "completed_at": old_completed, + "response": { + "native_loopx": { + "ok": False, + "error_code": "turn_todo_selection_deferred", + "selection_rejection": {"state": "deferred", "reason_code": "autonomous_replan"}, + "effects": { + "host_invoked": False, + "state_written": False, + "quota_spent": False, + "scheduler_acknowledged": False, + }, + }, + }, + } + precommit_turn = { + "status": "completed", + "completed_at": old_completed, + "response": { + "native_loopx": { + "ok": False, + "status": "failed", + "result_kind": "validation_failed", + "receipt": {"commit_eligibility": {"writeback": False}}, + "effects": { + "host_invoked": True, + "state_written": False, + "quota_spent": False, + "scheduler_acknowledged": False, + }, + }, + }, + } + + assert resolve_advancement_turn_id(_FakeStore({base_cid: deferred_turn}), actor, todo, now=now_in_cooldown) is None + assert resolve_advancement_turn_id(_FakeStore({base_cid: deferred_turn}), actor, todo, now=now_after_cooldown) == adm_tok + assert resolve_advancement_turn_id( + _FakeStore({base_cid: deferred_turn, adm_cid: precommit_turn}), actor, todo, now=now_after_cooldown + ) == (adm_tok + ADVANCEMENT_PRECOMMIT_RETRY_SUFFIX) + + host_invoked_deferred = { + **deferred_turn, + "response": { + "native_loopx": { + **deferred_turn["response"]["native_loopx"], + "effects": {**deferred_turn["response"]["native_loopx"]["effects"], "host_invoked": True}, + }, + }, + } + assert resolve_advancement_turn_id(_FakeStore({base_cid: host_invoked_deferred}), actor, todo, now=now_after_cooldown) is None + + # Pre-commit failure on base followed by zero-effect deferral on .precommit-retry unlocks .precommit-retry.admission-retry once. + store_after_precommit_deferred = _FakeStore({base_cid: precommit_turn, pre_cid: deferred_turn}) + assert resolve_advancement_turn_id(store_after_precommit_deferred, actor, todo, now=now_after_cooldown) == pre_adm_tok + store_after_exhausted = _FakeStore({base_cid: precommit_turn, pre_cid: deferred_turn, pre_adm_cid: deferred_turn}) + assert resolve_advancement_turn_id(store_after_exhausted, actor, todo, now=now_after_cooldown) is None + + +def test_scoped_signal_monitor_settles_autonomous_replan_inline_and_commits_followup( + steward, tmp_path, monkeypatch, +) -> None: + isolate_sqlite_runtime(tmp_path, monkeypatch) + store, runtime, _, transport, binding, _, _ = steward + sid, managed = original(steward) + storage(runtime, "sqlite") + plan = managed.prepare(binding["binding_id"], session_id=sid)["plan"] + actor = managed.prepare( + binding["binding_id"], + session_id=sid, + expected_plan_id=plan["plan_id"], + execute=True, + )["actor"] + store.load_session(sid) + + from loopx.configure_goal import configure_goal + assert configure_goal( + registry_path=runtime.registry_path, + goal_id=actor["goal_id"], + execution_replan_after_turns=1, + execute=True, + )["ok"] + + monitor = StewardMonitor(runtime) + enable_plan = monitor.configure(binding["binding_id"], operation="enable")["plan"] + monitor.configure( + binding["binding_id"], + operation="enable", + execute=True, + expected_plan_id=enable_plan["plan_id"], + ) + default_watch = monitor.current(actor) + edit_local_watch( + runtime, + actor, + default_watch["todo_id"], + "--next-due-at", + (datetime.now(timezone.utc) + timedelta(hours=2)).isoformat(), + ) + + actions = transport.core.actions + preview = actions.preview({ + "action_kind": "monitor.create", + "summary": "Track mergeable approved PRs on acme/widgets and send one aggregated report", + "normalized_parameters": { + "goal_id": actor["goal_id"], + "agent_id": actor["agent_id"], + "target": "Track mergeable approved PRs on acme/widgets and emit one aggregated report.", + "target_key": "steward-gpt-mergeable-pr-monitor", + "task_repository": "acme/widgets", + "cadence": "every_2_hours", + "timezone": "Asia/Shanghai", + "stop_condition": "watch_only", + "signal_scope": { + "schema_version": "steward_signal_monitor_scope_v0", + "include_portfolio": False, + "include_inbox": False, + "pr_filter": { + "exclude_drafts": True, + "exclude_conflicting": True, + "effective_verdicts": ["APPROVE"], + "required_approver_declarations": ["GPT", "OpenAI"], + }, + }, + }, + "context": {"kind": "goal", "goal_id": actor["goal_id"]}, + "idempotency_key": "create-gpt-mergeable-pr-monitor-inline-replan", + }) + assert preview["status"] == "preview_ready" + created_todo_id = actions.apply(preview["proposal_id"])["proposal"]["receipt"]["resource_ids"]["todo_id"] + + import loopx.capabilities.native_chat.steward_monitor as monitor_mod + + def _pr_item(number: int) -> dict: + return { + "number": number, + "title": f"Mergeable PR #{number}", + "url": f"https://github.com/acme/widgets/pull/{number}", + "headRefOid": f"head{number}", + "isDraft": False, + "mergeable": "MERGEABLE", + "updatedAt": "2026-11-20T09:00:00Z", + "author": {"login": "alice"}, + "checks_summary": {"state": "SUCCESS", "total": 1, "passing": 1, "failing": 0, "pending": 0}, + "bypassed_gates": [], + "review_summary": { + "effective_verdict": "APPROVE", + "has_review_conflict": False, + "stale_review_count": 0, + "exact_head_reviews": [{ + "author_login": "bob", + "reviewer_declaration": "GPT-5.4", + "verdict": "APPROVE", + "valid_verdict_review": True, + "state": "APPROVED", + }], + }, + } + + # Route governance replan vs advancement responses in fake_codex via a clean helper module. + prompt_log = tmp_path / "captured_gov_prompt.txt" + router_file = tmp_path / "codex_router.py" + router_file.write_text( + f"""import json +from pathlib import Path + +def route(params): + txt = "\\n".join(r.get("text", "") for r in (params or {{}}).get("input", []) if isinstance(r, dict)) + marker = "Steward governance replan context (data):" + if marker in txt: + Path({str(prompt_log)!r}).write_text(txt, encoding="utf-8") + ctx = json.loads(txt.split(marker, 1)[1].lstrip().splitlines()[0]) + recent = (ctx.get("review") or {{}}).get("recent_evidence") or [{{}}] + ev_ref = recent[0].get("evidence_ref", "replan-evidence-inline") + todo_delta = [ + "retain:" + r["todo_id"] + for r in (ctx.get("open_agent_todos") or [])[:4] + if isinstance(r, dict) and r.get("todo_id") + ] + sc = (ctx.get("writeback") or {{}}).get("stride_control") + vision = {{ + "schema_version": "goal_vision_replan_contract_v0", + "state": "active", + "vision_patch": {{ + "vision_summary": "Maintain private steward PR monitoring and reports.", + "acceptance_summary": "Aggregate matching PR signals cleanly without notification spam.", + }}, + "todo_delta": todo_delta, + "path_delta": {{ + "schema_version": "goal_path_delta_v0", + "outcome": "replan", + "prior_assumption": "Steward monitor followups execute continuously without inline replan.", + "observed_reality": "Periodic review became due after first settled turn and cleared inline.", + "retained": ["All scoped monitor subscriptions"], + "changed": ["Recorded evidence-linked baseline for steward followups"], + "evidence_refs": [ev_ref], + }}, + }} + if isinstance(sc, dict) and sc.get("reference_context_id"): + vision["stride_decision"] = {{ + "schema_version": sc["schema_version"], + "strategy_version": sc["strategy_version"], + "reference_context_id": sc["reference_context_id"], + "reference_obligation_id": sc["reference_obligation_id"], + "basis": "supported_progress", + "action": "verify", + "axes": {{ + "work_slice": {{"plan": "Complete inline replan and queued report.", "reason": "Clear review gate cleanly."}}, + "route_distance": {{"plan": "Keep scoped monitor pipeline unchanged.", "reason": "Existing filter matches goal."}}, + "validation_scope": {{"plan": "Verify replan writeback and queued delivery.", "reason": "Confirm single-turn recovery."}}, + }}, + "next_probe": {{ + "scope": "Run blocked monitor followup triage.", + "prediction": "Advancement commits after inline replan.", + "adoption_criterion": "Followup todo closes with queued report.", + "cost_bound": "One inline governance turn plus followup.", + "minimum_evidence": "Committed replan event and delivery json.", + }}, + }} + return json.dumps({{ + "result_kind": "replan_required", + "classification": "steward_periodic_review_settled", + "summary": "Settled steward autonomous periodic review inline.", + "next_action": "Continue scoped PR monitor advancement.", + "delivery_batch_scale": "implementation", + "delivery_outcome": "outcome_progress", + "work_evidence": ["Reviewed recent settled turns and retained active monitor scope"], + "validation_evidence": ["Checked replan writeback contract and open monitor todos"], + "path_delta_mode": "material_replan", + "agent_vision_json": json.dumps(vision), + }}) + return json.dumps({{ + "result_kind": "validated_completion", + "classification": "steward_scoped_pr_report", + "summary": "Prepared aggregated mergeable PR report.", + "next_action": "Await next monitor cadence.", + "delivery_batch_scale": "implementation", + "delivery_outcome": "outcome_progress", + "work_evidence": ["Synthesized aggregated report for matching PR"], + "validation_evidence": ["steward_monitor_snapshot_v0 scoped cleanly"], + "path_delta_mode": "unchanged", + "vision_unchanged_reason": "Scoped steward monitor report.", + "steward_owner_report": "## 可直接合并 PR\\n- #9102 Mergeable PR (GPT-5.4 APPROVE)", + }}) +""", + encoding="utf-8", + ) + fake = Path(runtime.codex_bin) + source = fake.read_text(encoding="utf-8") + target = '"message": "Runtime response."' + assert target in source + route_expr = ( + f'__import__("importlib.util").util.spec_from_file_location("codex_router", {str(router_file)!r})' + ) + dynamic_msg = ( + f'(lambda p: (lambda m: (m.loader.exec_module(m_mod := __import__("importlib.util").util.module_from_spec(m)), ' + f'm_mod.route(p))[1])({route_expr}))(request.get("params"))' + ) + fake.write_text(source.replace(target, f'"message": {dynamic_msg}'), encoding="utf-8") + if sid in runtime.adapters: + runtime.adapters.pop(sid).close_session() + + # Turn 1: settle first advancement so periodic_review_due threshold=1 is reached. + edit_local_watch( + runtime, + actor, + created_todo_id, + "--next-due-at", + (datetime.now(timezone.utc) - timedelta(seconds=5)).isoformat(), + ) + monkeypatch.setattr(monitor_mod, "_observe_github_repository_prs", lambda repo: { + "status": "ok", "repository": repo, "items": [_pr_item(9101)], + }) + assert finish(runtime, pump_steward_monitors(runtime)[0])["status"] == "completed" + runtime._steward_monitor_next_check.clear() + first_adv_done = finish(runtime, pump_steward_monitors(runtime)[0]) + assert first_adv_done["response"]["native_loopx"]["status"] == "committed" + + # Turn 2: new material change creates a second advancement Todo while periodic_review_due is active. + edit_local_watch( + runtime, + actor, + created_todo_id, + "--next-due-at", + (datetime.now(timezone.utc) - timedelta(seconds=5)).isoformat(), + ) + monkeypatch.setattr(monitor_mod, "_observe_github_repository_prs", lambda repo: { + "status": "ok", "repository": repo, "items": [_pr_item(9102)], + }) + assert finish(runtime, pump_steward_monitors(runtime)[0])["status"] == "completed" + + runtime._steward_monitor_next_check.clear() + second_adv_turns = pump_steward_monitors(runtime) + assert len(second_adv_turns) == 1 + second_done = finish(runtime, second_adv_turns[0]) + assert second_done["status"] == "completed", second_done + assert second_done["response"]["native_loopx"]["status"] == "committed", second_done + assert second_done["response"]["steward_owner_report_queued"] is True + + replan_events = [ + row["payload"] for row in store.events_after(sid, second_done["turn_id"], None) + if row.get("kind") == "native_loopx.replan_result" + ] + assert len(replan_events) == 1 + assert replan_events[0]["status"] == "committed" + assert replan_events[0]["result_kind"] == "replan_required" + + captured_prompt = prompt_log.read_text(encoding="utf-8") + assert "Steward governance replan context (data):" in captured_prompt + gov_json = json.loads( + captured_prompt.split("Steward governance replan context (data):", 1)[1].lstrip().splitlines()[0] + ) + assert "read_action" not in json.dumps(gov_json) + assert "next_cli_actions" not in json.dumps(gov_json) + assert str(tmp_path) not in json.dumps(gov_json)