diff --git a/loopx/capabilities/native_chat/steward_monitor.py b/loopx/capabilities/native_chat/steward_monitor.py index 4788daeb3b..48497262c5 100644 --- a/loopx/capabilities/native_chat/steward_monitor.py +++ b/loopx/capabilities/native_chat/steward_monitor.py @@ -12,12 +12,14 @@ import json import logging from pathlib import Path +import re import subprocess import time -from typing import Any +from typing import Any, Mapping from ...agent_registry import load_goal_from_registry from ...chat_store import _atomic_write_json +from ...control_plane.effect_runtime import effect_runtime_result from ...control_plane.scheduler.monitor_todo import monitor_todo_is_due from ...control_plane.todos.list_readback import list_goal_todos from ...control_plane.runtime.time import now_utc @@ -82,10 +84,64 @@ def _observe_github_repository_prs(repo_slug: str) -> dict[str, Any]: return observe_github_repository_prs(repo_slug, runner=subprocess.run) +_MONITOR_TARGET_KEY_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$") + + def steward_monitor_snapshot_path(runtime_root: Path, goal_id: str, todo_id: str) -> Path: return Path(runtime_root).expanduser().resolve() / "steward-monitors" / goal_id / f"{todo_id}.latest.json" +def steward_monitor_scope_path(runtime_root: Path, goal_id: str, target_key: str) -> Path: + safe_goal = str(goal_id or "").strip() + safe_key = str(target_key or "").strip() + if not safe_goal or "/" in safe_goal or "\\" in safe_goal or ".." in safe_goal: + raise ValueError("invalid monitor scope goal_id") + if not _MONITOR_TARGET_KEY_RE.fullmatch(safe_key): + raise ValueError("invalid monitor scope target_key") + return Path(runtime_root).expanduser().resolve() / "steward-monitors" / safe_goal / "scopes" / f"{safe_key}.json" + + +def steward_monitor_delivery_dir(runtime_root: Path, goal_id: str) -> Path: + safe_goal = str(goal_id or "").strip() + if not safe_goal or "/" in safe_goal or "\\" in safe_goal or ".." in safe_goal: + raise ValueError("invalid monitor delivery goal_id") + return Path(runtime_root).expanduser().resolve() / "steward-monitors" / safe_goal / "deliveries" + + +def normalize_steward_monitor_scope(signal_scope: Mapping[str, Any] | None) -> dict[str, Any] | None: + if signal_scope is None: + return None + normalized = effect_runtime_result( + "collaboration.steward.monitor.signal_scope.normalize", + {"signal_scope": dict(signal_scope)}, + ).get("signal_scope") + return dict(normalized) if isinstance(normalized, Mapping) else None + + +def write_steward_monitor_scope( + runtime_root: Path, goal_id: str, target_key: str, signal_scope: Mapping[str, Any], +) -> dict[str, Any]: + normalized = normalize_steward_monitor_scope(signal_scope) + if normalized is None: + raise ValueError("signal_scope cannot be empty") + path = steward_monitor_scope_path(runtime_root, goal_id, target_key) + path.parent.mkdir(parents=True, exist_ok=True) + _atomic_write_json(path, normalized) + return normalized + + +def read_steward_monitor_scope(runtime_root: Path, goal_id: str, target_key: str) -> dict[str, Any] | None: + if not target_key or not _MONITOR_TARGET_KEY_RE.fullmatch(str(target_key)): + return None + path = steward_monitor_scope_path(runtime_root, goal_id, target_key) + if not path.is_file(): + return None + raw = json.loads(path.read_text(encoding="utf-8")) + if not isinstance(raw, Mapping): + raise ValueError("invalid persisted steward monitor scope") + return normalize_steward_monitor_scope(raw) + + class StewardMonitor: def __init__(self, controller: Any) -> None: self.controller = controller @@ -298,27 +354,47 @@ def configure(self, binding_id: str, *, operation: str, cadence_minutes: int = 3 "monitor": self.current(actor), "model_invoked": False} def _collect_signal_monitor(self, actor: dict[str, Any], context: dict[str, Any], todo: dict[str, Any]) -> tuple[dict[str, Any], list[str]]: - portfolio = self.bindings._core("collaboration.steward.monitor.observation", { - "context": context, "goal_ids": self.bindings.steward_scope(self.controller.store.load_session(actor["session_id"])), - "actor_goal_id": actor["goal_id"], "previous_hash": None}) + target_key = str(todo.get("target_key") or "") + signal_scope = read_steward_monitor_scope( + self.controller.coordination_runtime_root, actor["goal_id"], target_key, + ) + include_portfolio = True if signal_scope is None else signal_scope.get("include_portfolio", True) is True + include_inbox = True if signal_scope is None else signal_scope.get("include_inbox", True) is True + portfolio = ( + self.bindings._core("collaboration.steward.monitor.observation", { + "context": context, "goal_ids": self.bindings.steward_scope(self.controller.store.load_session(actor["session_id"])), + "actor_goal_id": actor["goal_id"], "previous_hash": None}) + if include_portfolio else None + ) from ...control_plane.collaboration.inbox import pending as inbox_pending - try: - inbox_raw = inbox_pending(self.controller.coordination_runtime_root, - goal_id=actor["goal_id"], agent_id=actor["agent_id"]) - inbox_items = [{"request_id": row["request_id"], "source_id": row.get("source_id")} - for row in inbox_raw if isinstance(row, dict) and row.get("request_id")] - except (OSError, ValueError): + if include_inbox: + try: + inbox_raw = inbox_pending(self.controller.coordination_runtime_root, + goal_id=actor["goal_id"], agent_id=actor["agent_id"]) + inbox_items = [{"request_id": row["request_id"], "source_id": row.get("source_id")} + for row in inbox_raw if isinstance(row, dict) and row.get("request_id")] + except (OSError, ValueError): + inbox_items = [] + else: inbox_items = [] repo_slug = _github_repo_slug(todo.get("task_repository")) repo_snapshot = _observe_github_repository_prs(repo_slug) if repo_slug else None - observation = self.bindings._core("collaboration.steward.monitor.signal_observation", { + observed_at = now_utc().isoformat() + signal_request: dict[str, Any] = { "portfolio_observation": portfolio, "inbox_items": inbox_items, "repository_snapshot": repo_snapshot, "previous_hash": todo.get("result_hash"), - }) + } + if signal_scope is not None: + signal_request["signal_scope"] = signal_scope + signal_request["observed_at"] = observed_at + observation = self.bindings._core("collaboration.steward.monitor.signal_observation", signal_request) if observation.get("observation_incomplete") is True: raise RuntimeError("steward monitor external signal source temporarily unavailable") + persisted_repo_snapshot = repo_snapshot + if isinstance(repo_snapshot, Mapping) and "scoped_repository_items" in observation: + persisted_repo_snapshot = {**repo_snapshot, "items": list(observation["scoped_repository_items"])} snapshot_path = steward_monitor_snapshot_path( self.controller.coordination_runtime_root, actor["goal_id"], todo["todo_id"]) snapshot_path.parent.mkdir(parents=True, exist_ok=True) @@ -329,10 +405,11 @@ def _collect_signal_monitor(self, actor: dict[str, Any], context: dict[str, Any] "target_key": todo.get("target_key"), "monitor_text": todo.get("text"), "task_repository": todo.get("task_repository"), + **({"signal_scope": signal_scope} if signal_scope is not None else {}), "result_hash": observation["result_hash"], "material_change": observation["material_change"], - "observed_at": now_utc().isoformat(), - "repository_snapshot": repo_snapshot, + "observed_at": observed_at, + "repository_snapshot": persisted_repo_snapshot, "inbox_items": inbox_items, }) followup_key = f"{FOLLOWUP_TARGET_PREFIX}{todo['todo_id']}" diff --git a/loopx/capabilities/native_chat/steward_turn.py b/loopx/capabilities/native_chat/steward_turn.py index 51fbffbed1..b9d17e6838 100644 --- a/loopx/capabilities/native_chat/steward_turn.py +++ b/loopx/capabilities/native_chat/steward_turn.py @@ -1130,7 +1130,7 @@ def _steward_followup_context(self, actor: Mapping[str, Any], session_id: str, @staticmethod def _normalize_steward_actions(candidate: Mapping[str, Any], context: Mapping[str, Any]) -> dict[str, Any]: from ...control_plane.collaboration.inbox import normalize_handoff - state: dict[str, Any] = {"context_handoff": None, "user_actions": [], "validation_error": None} + state: dict[str, Any] = {"context_handoff": None, "user_actions": [], "owner_report": None, "validation_error": None} allowed_targets = { (row["goal_id"], row["agent_id"]) for row in ((context.get("context_delegation") or {}).get("targets") or []) @@ -1171,6 +1171,17 @@ def _normalize_steward_actions(candidate: Mapping[str, Any], context: Mapping[st seen_keys.add(key) cleaned.append({"dedupe_key": key, "priority": prio, "text": text}) state["user_actions"] = cleaned + raw_report = candidate.get("steward_owner_report") + if raw_report is not None: + markdown = raw_report.get("markdown") if isinstance(raw_report, Mapping) else raw_report + if not isinstance(markdown, str): + state["validation_error"] = "steward_owner_report must be a markdown string or {markdown}" + return state + normalized_report = markdown.strip() + if not normalized_report or len(normalized_report) > 24000: + state["validation_error"] = "steward_owner_report markdown must be 1..24000 characters" + return state + state["owner_report"] = normalized_report return state def _apply_steward_user_actions(self, actor: Mapping[str, Any], actions: Sequence[Mapping[str, str]], @@ -1269,7 +1280,7 @@ def execute(self, *, session_id: str, turn_id: str, adapter: Any, managed_answer = "" managed_lease, managed_lease_request = None, None preparation_status = None - steward_actions_state: dict[str, Any] = {"context_handoff": None, "user_actions": [], "validation_error": None} + steward_actions_state: dict[str, Any] = {"context_handoff": None, "user_actions": [], "owner_report": None, "validation_error": None} def report_lease_proof(): return self._task_lease_proof(request, report_lease) @@ -1370,7 +1381,8 @@ def run(native_request: Mapping[str, Any], launch_scope: Any) -> dict[str, Any]: "When `signal_snapshot.repository_snapshot.items` is present, each PR carries `mergeable`, `checks_summary`, `bypassed_gates`, and `review_summary` (`effective_verdict`, `has_review_conflict`, `stale_review_count`, `exact_head_reviews` with `reviewer_declaration`, `valid_verdict_review`, `author_owned_fallback`). Keep triage read-only; never execute merges here. " "You may include optional top-level JSON fields alongside the normal kernel fields: " "`context_handoff` (single object or array <=32 of {goal_id, agent_id, brief} with `schema_version='collaboration_brief_v0'` and `inputs=[]` when referencing URLs/PRs, restricted to `context_delegation.targets`), " - "and `steward_user_actions` (array <=16 of {dedupe_key, priority:'P0'|'P1'|'P2', text}). Set `result_kind='validated_completion'` when triage/handoff/user-action preparation is complete.\n" + "`steward_owner_report` (optional non-empty Markdown string <=24000 chars or `{markdown}` delivered once directly to the bound Steward App and Feishu conversation; omit or set `null` when silent/no report should be sent), " + "and `steward_user_actions` (array <=16 of {dedupe_key, priority:'P0'|'P1'|'P2', text}; do NOT emit per-PR `steward_user_actions` when the monitor prompt asks for an aggregated report). Set `result_kind='validated_completion'` when triage/handoff/report/user-action preparation is complete.\n" "Steward monitor & dedupe context (data):\n" + json.dumps(followup_ctx, ensure_ascii=False) ) if request.get("work_kind") == "scheduled_task": @@ -1429,6 +1441,7 @@ def launch(): steward_actions_state.update(self._normalize_steward_actions(kernel_candidate, context)) kernel_candidate.pop("context_handoff", None) kernel_candidate.pop("steward_user_actions", None) + kernel_candidate.pop("steward_owner_report", None) 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."} @@ -1587,13 +1600,33 @@ def steward_validator(_plan: Mapping[str, Any], candidate_result: Mapping[str, A observed=observed, selection_recovery=selection_recovery) user_action_receipts = self._apply_steward_user_actions( actor, steward_actions_state["user_actions"], request["turn_instance_id"]) + owner_report = (steward_actions_state["owner_report"] + if steward_advancement and result.get("status") == "committed" else None) + if owner_report: + from ...registry import atomic_write_json + from .steward_monitor import steward_monitor_delivery_dir + delivery_path = steward_monitor_delivery_dir(self.controller.coordination_runtime_root, actor["goal_id"]) / f"{turn_id}.json" + atomic_write_json(delivery_path, { + "schema_version": "steward_monitor_report_delivery_v0", + "goal_id": actor["goal_id"], + "agent_id": actor["agent_id"], + "session_id": actor["session_id"], + "turn_id": turn_id, + "turn_instance_id": request["turn_instance_id"], + "todo_id": (managed_lease_request or request).get("todo_id"), + "markdown": owner_report, + "created_at": datetime.now(timezone.utc).isoformat(), + "delivery_status": "pending", + "deliveries": {}, + }) committed_handoff = (steward_actions_state["context_handoff"] if steward_advancement and result.get("status") == "committed" else None) return {"schema_version": "loopx_chat_agent_response_v0", "message": "当前没有可执行且已配置独立验收的原生任务,尚未启动模型;请检查原任务的验收配置。" if managed_turn and managed_turn.validation_unavailable else - (managed_answer or "本轮任务已完成结果回写。") if result.get("status") == "committed" else + (owner_report or managed_answer or "本轮任务已完成结果回写。") if result.get("status") == "committed" else "本轮等待后续执行条件。" if result.get("status") == "stopped" and result.get("result_kind") == "wait" else "本轮任务尚未完成;执行状态已保留。", "proposals": [], "gate": None, "native_loopx": result, **({"context_handoff": committed_handoff} if committed_handoff else {}), + **({"steward_owner_report_queued": True} if owner_report else {}), **({"steward_user_action_receipts": user_action_receipts} if user_action_receipts else {})} diff --git a/loopx/chat/monitor_actions.py b/loopx/chat/monitor_actions.py index 92cbb9b872..c43950b58f 100644 --- a/loopx/chat/monitor_actions.py +++ b/loopx/chat/monitor_actions.py @@ -116,6 +116,14 @@ def _run_monitor_update( monitor_metadata=base_metadata, ) result = update_goal_todo(**kwargs) + if not dry_run and parameters.get("signal_scope") is not None: + from ..capabilities.native_chat.steward_monitor import write_steward_monitor_scope + target_key = str( + parameters.get("target_key") or (result.get("todo") or {}).get("target_key") or "" + ).strip() + if not target_key: + raise ValueError("signal_scope update requires target_key") + write_steward_monitor_scope(source.runtime_root, goal_id, target_key, parameters["signal_scope"]) return result def _apply_monitor_update( diff --git a/loopx/chat_action_normalization.py b/loopx/chat_action_normalization.py index 8746b34478..2a2c6c8620 100644 --- a/loopx/chat_action_normalization.py +++ b/loopx/chat_action_normalization.py @@ -761,6 +761,7 @@ def _normalize( ), } if action_kind == "monitor.create": + from .capabilities.native_chat.steward_monitor import normalize_steward_monitor_scope values = self._allowed_parameters( parameters, allowed={ @@ -773,6 +774,7 @@ def _normalize( "timezone", "stop_condition", "notification_rule", + "signal_scope", }, ) goal_id = _opaque(values.get("goal_id"), field="goal_id") @@ -785,6 +787,10 @@ def _normalize( "cadence": _normalize_cadence(values.get("cadence")), "timezone": _text(values.get("timezone"), field="timezone", limit=80), } + if values.get("signal_scope") is not None: + if not isinstance(values["signal_scope"], Mapping): + raise ValueError("signal_scope must be an object") + result["signal_scope"] = normalize_steward_monitor_scope(values["signal_scope"]) if values.get("task_repository"): raw_repo = _text(values["task_repository"], field="task_repository", limit=200) if _REPO_PATTERN.fullmatch(raw_repo): @@ -805,6 +811,7 @@ def _normalize( ) return result if action_kind == "monitor.update": + from .capabilities.native_chat.steward_monitor import normalize_steward_monitor_scope values = self._allowed_parameters( parameters, allowed={ @@ -819,6 +826,7 @@ def _normalize( "stop_condition", "session_id", "endpoint_id", + "signal_scope", }, ) goal_id = _opaque(values.get("goal_id"), field="goal_id") @@ -834,6 +842,10 @@ def _normalize( "agent_id": _opaque(values.get("agent_id"), field="agent_id"), "operation": operation, } + if values.get("signal_scope") is not None: + if not isinstance(values["signal_scope"], Mapping): + raise ValueError("signal_scope must be an object") + result["signal_scope"] = normalize_steward_monitor_scope(values["signal_scope"]) if values.get("endpoint_id"): endpoint_id = _opaque(values["endpoint_id"], field="endpoint_id") result["endpoint_id"] = endpoint_id @@ -863,7 +875,7 @@ def _normalize( result["session_id"] = _opaque(values["session_id"], field="session_id") if operation == "edit" and len(result) == 4: raise ValueError( - "monitor edit requires target, target_key, cadence, or stop_condition" + "monitor edit requires target, target_key, cadence, stop_condition, or signal_scope" ) return result if action_kind == "pr.merge": diff --git a/loopx/chat_actions.py b/loopx/chat_actions.py index 907f758cff..8508e58900 100644 --- a/loopx/chat_actions.py +++ b/loopx/chat_actions.py @@ -1265,6 +1265,12 @@ def _apply_monitor_create( }), receipt={}) return {"proposal": stale, "turn": None} todo_id = _opaque(result.get("todo_id"), field="todo_id") + if parameters.get("signal_scope") is not None: + from .capabilities.native_chat.steward_monitor import write_steward_monitor_scope + target_key = str(parameters.get("target_key") or "").strip() + if not target_key: + raise ValueError("signal_scope requires target_key") + write_steward_monitor_scope(source.runtime_root, goal_id, target_key, parameters["signal_scope"]) receipt = { "receipt_id": _digest( {"proposal_id": proposal_id, "goal_id": goal_id, "todo_id": todo_id} diff --git a/loopx/control_plane/collaboration/steward_managed_mode.ts b/loopx/control_plane/collaboration/steward_managed_mode.ts index db7b409348..fe40887e83 100644 --- a/loopx/control_plane/collaboration/steward_managed_mode.ts +++ b/loopx/control_plane/collaboration/steward_managed_mode.ts @@ -853,6 +853,198 @@ function monitorObservation(facts: unknown, previousHash: unknown): JsonObject { return {result_hash: resultHash, material_change: previousHash != null && previousHash !== resultHash}; } +const PR_SIGNAL_VERDICTS = new Set(["APPROVE", "REQUEST_CHANGES", "NONE"]); +const PR_AUTHOR_MODES = new Set(["include", "exclude"]); +const SIGNAL_SCOPE_SCHEMA = "steward_signal_monitor_scope_v0"; + +export function normalizeStewardSignalMonitorScope(value: unknown): JsonObject | null { + if (value === undefined || value === null) return null; + const scope = requireJsonObject(value, "steward monitor signal scope"); + const allowedKeys = new Set(["schema_version", "include_portfolio", "include_inbox", "pr_filter"]); + for (const key of Object.keys(scope)) { + if (!allowedKeys.has(key)) { + throw new EffectRuntimeRequestError(`unsupported signal_scope field: ${key}`); + } + } + if (scope.schema_version !== SIGNAL_SCOPE_SCHEMA) { + throw new EffectRuntimeRequestError(`signal_scope requires schema_version=${SIGNAL_SCOPE_SCHEMA}`); + } + const includePortfolio = scope.include_portfolio === undefined ? true : scope.include_portfolio; + const includeInbox = scope.include_inbox === undefined ? true : scope.include_inbox; + if (typeof includePortfolio !== "boolean" || typeof includeInbox !== "boolean") { + throw new EffectRuntimeRequestError("signal_scope include_portfolio and include_inbox must be booleans"); + } + let normalizedFilter: JsonObject | null = null; + if (scope.pr_filter !== undefined && scope.pr_filter !== null) { + const rawFilter = requireJsonObject(scope.pr_filter, "PR signal filter"); + const allowedFilterKeys = new Set([ + "exclude_drafts", + "exclude_conflicting", + "effective_verdicts", + "required_approver_declarations", + "author_mode", + "authors", + "min_stalled_hours", + ]); + for (const key of Object.keys(rawFilter)) { + if (!allowedFilterKeys.has(key)) { + throw new EffectRuntimeRequestError(`unsupported pr_filter field: ${key}`); + } + } + const nextFilter: JsonObject = {}; + for (const boolKey of ["exclude_drafts", "exclude_conflicting"] as const) { + if (rawFilter[boolKey] !== undefined) { + if (typeof rawFilter[boolKey] !== "boolean") { + throw new EffectRuntimeRequestError(`pr_filter.${boolKey} must be a boolean`); + } + nextFilter[boolKey] = rawFilter[boolKey]; + } + } + if (rawFilter.required_approver_declarations !== undefined) { + if (!Array.isArray(rawFilter.required_approver_declarations) || rawFilter.required_approver_declarations.length === 0) { + throw new EffectRuntimeRequestError("pr_filter.required_approver_declarations must be a non-empty array"); + } + const tokens = rawFilter.required_approver_declarations.map((entry) => + requireNonEmptyString(entry, "pr_filter.required_approver_declarations[]").toLowerCase(), + ); + nextFilter.required_approver_declarations = [...new Set(tokens)].sort(); + } + if (rawFilter.effective_verdicts !== undefined) { + if (!Array.isArray(rawFilter.effective_verdicts) || rawFilter.effective_verdicts.length === 0) { + throw new EffectRuntimeRequestError("pr_filter.effective_verdicts must be a non-empty array"); + } + const verdicts = rawFilter.effective_verdicts.map((item) => { + if (typeof item !== "string" || !PR_SIGNAL_VERDICTS.has(item)) { + throw new EffectRuntimeRequestError(`invalid pr_filter.effective_verdicts entry: ${String(item)}`); + } + return item; + }); + nextFilter.effective_verdicts = [...new Set(verdicts)]; + } + if (rawFilter.author_mode !== undefined || rawFilter.authors !== undefined) { + if (typeof rawFilter.author_mode !== "string" || !PR_AUTHOR_MODES.has(rawFilter.author_mode)) { + throw new EffectRuntimeRequestError("pr_filter.author_mode must be include or exclude"); + } + if (!Array.isArray(rawFilter.authors) || rawFilter.authors.length === 0) { + throw new EffectRuntimeRequestError("pr_filter.authors must be a non-empty array when author_mode is set"); + } + const authors = rawFilter.authors.map((entry) => requireNonEmptyString(entry, "pr_filter.authors[]").toLowerCase()); + nextFilter.author_mode = rawFilter.author_mode; + nextFilter.authors = [...new Set(authors)].sort(); + } + if (rawFilter.min_stalled_hours !== undefined) { + if ( + typeof rawFilter.min_stalled_hours !== "number" + || !Number.isFinite(rawFilter.min_stalled_hours) + || rawFilter.min_stalled_hours <= 0 + ) { + throw new EffectRuntimeRequestError("pr_filter.min_stalled_hours must be a positive finite number"); + } + nextFilter.min_stalled_hours = rawFilter.min_stalled_hours; + } + normalizedFilter = nextFilter; + } + return { + schema_version: SIGNAL_SCOPE_SCHEMA, + include_portfolio: includePortfolio, + include_inbox: includeInbox, + ...(normalizedFilter !== null ? { pr_filter: normalizedFilter } : {}), + }; +} + +function prAuthorLogin(item: JsonObject): string { + const authorObj = jsonObject(item.author); + const raw = authorObj ? authorObj.login : item.author; + return typeof raw === "string" ? raw.trim().toLowerCase() : ""; +} + +function hasMatchingApprovedReviewerDeclaration(item: JsonObject, requiredTokens: string[]): boolean { + const reviewSummary = jsonObject(item.review_summary); + if (!reviewSummary || reviewSummary.effective_verdict !== "APPROVE" || reviewSummary.has_review_conflict === true) { + return false; + } + const exactReviews = Array.isArray(reviewSummary.exact_head_reviews) ? reviewSummary.exact_head_reviews : []; + const latestByActor = new Map(); + for (const entry of exactReviews) { + const review = jsonObject(entry); + if (!review) continue; + const actorKey = `${String(review.author_login ?? "").trim().toLowerCase()}\0${String(review.reviewer_declaration ?? "").trim().toLowerCase()}`; + if (review.state === "DISMISSED") { + latestByActor.delete(actorKey); + } else if ( + review.valid_verdict_review === true + && (review.verdict === "APPROVE" || review.verdict === "REQUEST_CHANGES") + ) { + latestByActor.set(actorKey, { + verdict: review.verdict, + declaration: String(review.reviewer_declaration ?? "").toLowerCase(), + }); + } + } + return Array.from(latestByActor.values()).some( + (entry) => entry.verdict === "APPROVE" && requiredTokens.some((tok) => entry.declaration.includes(tok)), + ); +} + +function filterScopedRepositoryItems( + rawItems: unknown[], + filter: JsonObject | null, + observedAtValue: unknown, +): JsonObject[] { + const minStalledHours = typeof filter?.min_stalled_hours === "number" ? filter.min_stalled_hours : null; + let observedAtMs = NaN; + if (minStalledHours !== null) { + observedAtMs = typeof observedAtValue === "string" ? Date.parse(observedAtValue) : NaN; + if (!Number.isFinite(observedAtMs)) { + throw new EffectRuntimeRequestError("scoped monitor min_stalled_hours requires a valid observed_at timestamp"); + } + } + const effectiveVerdicts = Array.isArray(filter?.effective_verdicts) + ? new Set(filter.effective_verdicts.map(String)) + : null; + const requiredApprovers = Array.isArray(filter?.required_approver_declarations) + ? filter.required_approver_declarations.map(String) + : null; + const authorMode = typeof filter?.author_mode === "string" ? filter.author_mode : null; + const authors = Array.isArray(filter?.authors) ? new Set(filter.authors.map(String)) : null; + + const matched: JsonObject[] = []; + for (const rawItem of rawItems) { + const item = jsonObject(rawItem); + if (!item) continue; + if (filter?.exclude_drafts === true && item.isDraft === true) continue; + const reviewSummary = jsonObject(item.review_summary); + if ( + filter?.exclude_conflicting === true + && (String(item.mergeable ?? "").toUpperCase() === "CONFLICTING" || reviewSummary?.has_review_conflict === true) + ) { + continue; + } + if (effectiveVerdicts !== null) { + const verdict = String(reviewSummary?.effective_verdict ?? "NONE"); + if (!effectiveVerdicts.has(verdict)) continue; + } + if (requiredApprovers !== null && !hasMatchingApprovedReviewerDeclaration(item, requiredApprovers)) { + continue; + } + if (authorMode !== null && authors !== null) { + const login = prAuthorLogin(item); + if (authorMode === "include" && (!login || !authors.has(login))) continue; + if (authorMode === "exclude" && login && authors.has(login)) continue; + } + if (minStalledHours !== null) { + const updatedMs = typeof item.updatedAt === "string" ? Date.parse(item.updatedAt) : NaN; + if (!Number.isFinite(updatedMs) || observedAtMs - updatedMs < minStalledHours * 3_600_000) { + continue; + } + matched.push({ ...item, stalled_threshold_met: true }); + } else { + matched.push(item); + } + } + return matched; +} + /** Combine authorized local portfolio, inbox and optional repository signal * snapshots into one deterministic change gate for custom Steward monitors. * Unavailable external signal reads fail closed so transient provider errors @@ -860,6 +1052,7 @@ function monitorObservation(facts: unknown, previousHash: unknown): JsonObject { export function observeStewardSignalMonitor(params: JsonObject): JsonObject { const previousHash = typeof params.previous_hash === "string" && params.previous_hash ? params.previous_hash : null; + const signalScope = normalizeStewardSignalMonitorScope(params.signal_scope); const repo = params.repository_snapshot == null ? null : requireJsonObject(params.repository_snapshot, "repository signal"); if (repo !== null && repo.status === "unavailable") { return { @@ -872,11 +1065,28 @@ export function observeStewardSignalMonitor(params: JsonObject): JsonObject { const portfolio = params.portfolio_observation == null ? null : requireJsonObject(params.portfolio_observation, "portfolio observation"); const inboxItems = Array.isArray(params.inbox_items) ? params.inbox_items : []; - const facts = { - portfolio_hash: portfolio?.result_hash ?? null, - inbox_items: inboxItems, - repository_items: repo === null ? null : (Array.isArray(repo.items) ? repo.items : []), - }; + const rawRepoItems = repo === null ? null : (Array.isArray(repo.items) ? repo.items : []); + const scopedRepoItems = signalScope !== null && rawRepoItems !== null + ? filterScopedRepositoryItems( + rawRepoItems, + signalScope.pr_filter === undefined ? null : jsonObject(signalScope.pr_filter), + params.observed_at ?? repo?.observed_at, + ) + : null; + const includePortfolio = signalScope === null ? true : signalScope.include_portfolio === true; + const includeInbox = signalScope === null ? true : signalScope.include_inbox === true; + const facts = signalScope === null + ? { + portfolio_hash: portfolio?.result_hash ?? null, + inbox_items: inboxItems, + repository_items: rawRepoItems, + } + : { + signal_scope: signalScope, + portfolio_hash: includePortfolio ? (portfolio?.result_hash ?? null) : null, + inbox_items: includeInbox ? inboxItems : [], + repository_items: scopedRepoItems, + }; const clocks = new Set(["snapshot_id", "portfolio_snapshot_id", "collected_at", "collection_completed_at", "generated_at", "evaluated_at", "age_seconds", "observed_at"]); function canonical(value: unknown): unknown { @@ -892,6 +1102,7 @@ export function observeStewardSignalMonitor(params: JsonObject): JsonObject { material_change: previousHash !== resultHash, observation_incomplete: false, own_monitor_bookkeeping_excluded: true, + ...(scopedRepoItems !== null ? { scoped_repository_items: scopedRepoItems } : {}), }; } diff --git a/loopx/control_plane/effect_runtime_handlers.ts b/loopx/control_plane/effect_runtime_handlers.ts index 6fbe7ec4ab..6eb7d42482 100644 --- a/loopx/control_plane/effect_runtime_handlers.ts +++ b/loopx/control_plane/effect_runtime_handlers.ts @@ -644,6 +644,7 @@ export function createEffectRuntimeHandlers( ["collaboration.steward.report.plan", lazyHandler(() => import("./collaboration/steward_reports.ts"), ({planStewardReport}) => planStewardReport)], ["collaboration.steward.monitor.observation", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({observeStewardPortfolio}) => observeStewardPortfolio)], ["collaboration.steward.monitor.signal_observation", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({observeStewardSignalMonitor}) => observeStewardSignalMonitor)], + ["collaboration.steward.monitor.signal_scope.normalize", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({normalizeStewardSignalMonitorScope}) => (params) => ({signal_scope: normalizeStewardSignalMonitorScope(params?.signal_scope)}))], ["collaboration.session.monitor.observation", lazyHandler(() => import("./collaboration/steward_managed_mode.ts"), ({observeManagedWork}) => observeManagedWork)], ["collaboration.conversation.binding", lazyHandler(() => import("./collaboration/conversation_binding.ts"), ({planConversationBinding}) => planConversationBinding)], ["collaboration.conversation.bound_context", lazyHandler(() => import("./collaboration/conversation_binding.ts"), ({resolveBoundConversation}) => resolveBoundConversation)], diff --git a/loopx/extensions/lark/private_conversations.py b/loopx/extensions/lark/private_conversations.py index 15f8945434..7b7d4a90cc 100644 --- a/loopx/extensions/lark/private_conversations.py +++ b/loopx/extensions/lark/private_conversations.py @@ -1144,7 +1144,7 @@ def image_authorized() -> bool: **({"image_keys": image_keys} if image_keys else {}), **({"reply_placement": reply_placement} if reply_placement is not None else {}), **({"delivery_id": delivery_id} if delivery_id is not None else {}), - finalize_reactions=finalize_source and not edit_only and kind not in {"admission", "progress", "periodic_report"} and not (kind == "terminal" and record.get("commission_resources")), + finalize_reactions=finalize_source and not edit_only and kind not in {"admission", "progress", "periodic_report", "steward_monitor_report"} and not (kind == "terminal" and record.get("commission_resources")), source_authority_verifier=lambda profile, chat, message: ( source_authority(profile, chat, message) if authorization_check is None or authorization_check() else (None, False))) diff --git a/loopx/extensions/lark/steward_reports.py b/loopx/extensions/lark/steward_reports.py index 13576f7977..41218b9504 100644 --- a/loopx/extensions/lark/steward_reports.py +++ b/loopx/extensions/lark/steward_reports.py @@ -9,12 +9,14 @@ from datetime import datetime, timezone import hashlib import json +from pathlib import Path from typing import Any from ...chat_store import _read_json from ...file_lock import try_exclusive_file_lock from ...file_lock import exclusive_file_lock from ...registry import atomic_write_json +from ...capabilities.native_chat.steward_monitor import steward_monitor_delivery_dir from ...capabilities.native_chat.steward_reports import StewardReports from ...capabilities.native_chat.steward_turn import report_turn from ...capabilities.periodic_report.cadence_journal import read_cadence_journal @@ -43,9 +45,40 @@ def route_proof(self, binding: dict[str, Any], actor: dict[str, Any]) -> dict[st "session_id": actor["session_id"], "provider_ref": binding["provider_ref"], "operator_ref": binding["operator_ref"]} + def _pending_monitor_report_paths(self, actor: dict[str, Any]) -> list[Path]: + goal_id = str(actor.get("goal_id") or "").strip() + if not goal_id: + return [] + try: + delivery_dir = steward_monitor_delivery_dir(self.reports.root, goal_id) + except ValueError: + return [] + if not delivery_dir.is_dir(): + return [] + pending: list[Path] = [] + for path in sorted(delivery_dir.glob("*.json")): + try: + item = _read_json(path) + except (OSError, ValueError): + continue + if (isinstance(item, dict) + and item.get("schema_version") == "steward_monitor_report_delivery_v0" + and item.get("goal_id") == goal_id + and item.get("agent_id") == actor.get("agent_id") + and item.get("session_id") == actor.get("session_id") + and item.get("delivery_status") in {"pending", "unconfirmed"} + and str(item.get("markdown") or "").strip()): + pending.append(path) + return pending + def pending(self) -> bool: - return any(row.get("managed_actor") and self.reports.health(row["binding_id"]).get("enabled") - for row in self.transport.bindings.read()["bindings"]) + return any( + row.get("managed_actor") and ( + self.reports.health(row["binding_id"]).get("enabled") + or self._pending_monitor_report_paths(row["managed_actor"]) + ) + for row in self.transport.bindings.read()["bindings"] + ) def _committed_turn(self, actor: dict[str, Any], window: dict[str, Any]) -> dict[str, Any] | None: # Same stable client identity as the original native host. Reading a @@ -69,12 +102,93 @@ def _committed_turn(self, actor: dict[str, Any], window: dict[str, Any]) -> dict return turn return None + def _reconcile_monitor_reports(self, binding: dict[str, Any], actor: dict[str, Any]) -> int: + verified = 0 + for path in self._pending_monitor_report_paths(actor): + try: + with try_exclusive_file_lock(path.with_suffix(".lock"), operation="return_steward_monitor_report") as acquired: + if not acquired or not path.exists(): + continue + item = _read_json(path) + if (not isinstance(item, dict) + or item.get("delivery_status") not in {"pending", "unconfirmed"} + or item.get("goal_id") != actor.get("goal_id") + or item.get("agent_id") != actor.get("agent_id") + or item.get("session_id") != actor.get("session_id") + or not str(item.get("markdown") or "").strip()): + continue + turn_id = str(item.get("turn_id") or "").strip() + if not turn_id: + continue + turn = self.controller.store.load_turn(actor["session_id"], turn_id) + if not turn: + continue + req = turn.get("loopx_request") or {} + if (turn.get("origin") != "native_loopx" + or turn.get("loopx_execution") is not True + or req.get("actor") != actor): + raise ValueError("the monitor report Turn changed identity") + native = (turn.get("response") or {}).get("native_loopx") or {} + committed = native.get("status") == "committed" or any( + row.get("kind") == "native_loopx.result" + and isinstance(row.get("payload"), dict) + and row["payload"].get("status") == "committed" + for row in self.controller.store.events_after(actor["session_id"], turn_id, None) + ) + if not committed: + continue + def current() -> bool: + try: + selected = self.reports.selected(binding["binding_id"]) + except (OSError, ValueError, KeyError, TypeError): + return False + return bool(selected["binding"].get("enabled") is True and selected["actor"] == actor) + if not current(): + continue + saved_route = item.get("original_route") + route = self._original_route(binding, actor, saved_route) + if saved_route is not None and saved_route != route: + raise ValueError("the frozen monitor report changed its original audience") + if "source" not in item or "event" not in item or "original_route" not in item: + original = _read_json(self.transport.root / (route["request_ref"] + ".json")) + base = {k: deepcopy(v) for k, v in original.items() + if k not in {"deliveries", "stream", "recovery_streams", "context_recovery"}} + record = {**base, **item} + record["deliveries"] = dict(item.get("deliveries") or {}) + record["original_route"] = route + atomic_write_json(path, record) + else: + record = item + phase = f"steward_monitor_report.{turn_id}" + delivered = self.transport._deliver( + path, + record, + phase, + str(record["markdown"]), + inbox=lambda r=record: self.transport._inbox(r), + authorization_check=current, + reply_placement="chat_root", + finalize_source=False, + ) + record["delivery_status"] = "delivered" if delivered else "unconfirmed" + atomic_write_json(path, record) + if not delivered or not current(): + continue + proof = (record.get("deliveries") or {}).get(phase) or {} + if proof.get("verified") is not True: + raise ValueError("the monitor report reply has no verified provider receipt") + verified += 1 + except (OSError, ValueError, KeyError, TypeError, RuntimeError): + continue + return verified + def reconcile(self) -> int: verified = 0 for binding in self.transport.bindings.read()["bindings"]: actor = binding.get("managed_actor") if not actor: continue + verified += self._reconcile_monitor_reports(binding, actor) try: subscription = self.reports.subscription(binding["binding_id"]) if subscription is None: diff --git a/tests/control_plane_ts/steward_managed_mode.test.ts b/tests/control_plane_ts/steward_managed_mode.test.ts index 20ef5b8c32..538ec92d2b 100644 --- a/tests/control_plane_ts/steward_managed_mode.test.ts +++ b/tests/control_plane_ts/steward_managed_mode.test.ts @@ -474,3 +474,200 @@ test("chained post-context transient watch carriers recover only after cooldown assert.throws(() => admitStewardManagedTurn({...input, monitor_restart_basis: {...basis, ...badBasis}})); } }); + +test("observeStewardSignalMonitor preserves feature-off parity and isolates scoped PR monitor hashes", () => { + const sampleRepo = { + status: "ok", + repository: "acme/widgets", + items: [ + { + number: 101, + title: "Mergeable GPT-approved PR", + isDraft: false, + mergeable: "MERGEABLE", + author: {login: "alice"}, + updatedAt: "2026-11-20T09:00:00Z", + review_summary: { + effective_verdict: "APPROVE", + has_review_conflict: false, + exact_head_reviews: [ + {author_login: "bob", reviewer_declaration: "GPT-5.4", verdict: "APPROVE", valid_verdict_review: true, state: "APPROVED"}, + ], + }, + }, + { + number: 102, + title: "Dismissed GPT review then author-owned fallback only", + isDraft: false, + mergeable: "MERGEABLE", + author: {login: "alice"}, + updatedAt: "2026-11-18T00:00:00Z", + review_summary: { + effective_verdict: "APPROVE", + has_review_conflict: false, + exact_head_reviews: [ + {author_login: "bob", reviewer_declaration: "GPT-5.4", verdict: "APPROVE", valid_verdict_review: true, state: "APPROVED"}, + {author_login: "bob", reviewer_declaration: "GPT-5.4", verdict: null, valid_verdict_review: false, state: "DISMISSED"}, + {author_login: "alice", reviewer_declaration: "Codex Author Fallback", verdict: "APPROVE", valid_verdict_review: true, state: "COMMENTED", author_owned_fallback: true}, + ], + }, + }, + { + number: 103, + title: "External stalled PR", + isDraft: false, + mergeable: "CONFLICTING", + author: {login: "ext-contributor"}, + updatedAt: "2026-11-19T08:00:00Z", + review_summary: {effective_verdict: "CHANGES_REQUESTED", has_review_conflict: false, exact_head_reviews: []}, + }, + { + number: 104, + title: "Draft PR excluded", + isDraft: true, + mergeable: "MERGEABLE", + author: {login: "alice"}, + updatedAt: "2026-11-18T00:00:00Z", + review_summary: {effective_verdict: "APPROVE", has_review_conflict: false, exact_head_reviews: []}, + }, + ], + }; + + // Feature-off parity: null and undefined signal_scope behave identically and omit scoped_repository_items. + const legacyUndef = observeStewardSignalMonitor({ + portfolio_observation: {result_hash: "p1"}, + inbox_items: [{request_id: "r1"}], + repository_snapshot: sampleRepo, + observed_at: "2026-11-21T08:00:00Z", + }); + const legacyNull = observeStewardSignalMonitor({ + signal_scope: null, + portfolio_observation: {result_hash: "p1"}, + inbox_items: [{request_id: "r1"}], + repository_snapshot: sampleRepo, + observed_at: "2026-11-21T08:00:00Z", + }); + assert.equal(legacyUndef.result_hash, legacyNull.result_hash); + assert.equal("scoped_repository_items" in legacyUndef, false); + + const mergeableScope = { + 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"], + }, + }; + const internalStalledScope = { + schema_version: "steward_signal_monitor_scope_v0", + include_portfolio: false, + include_inbox: false, + pr_filter: { + exclude_drafts: true, + author_mode: "include", + authors: ["Alice"], + min_stalled_hours: 24, + }, + }; + const externalStalledScope = { + schema_version: "steward_signal_monitor_scope_v0", + include_portfolio: false, + include_inbox: false, + pr_filter: { + exclude_drafts: true, + author_mode: "exclude", + authors: ["alice"], + min_stalled_hours: 24, + }, + }; + + // Mergeable monitor matches only PR #101 (PR #102's GPT review was DISMISSED). + const mergeableObs = observeStewardSignalMonitor({ + signal_scope: mergeableScope, + portfolio_observation: {result_hash: "p1"}, + inbox_items: [{request_id: "r1"}], + repository_snapshot: sampleRepo, + observed_at: "2026-11-21T08:00:00Z", + }); + assert.deepEqual(mergeableObs.scoped_repository_items.map((row: {number: number}) => row.number), [101]); + + // Changing portfolio_observation and inbox_items is ignored when include_portfolio/include_inbox are false. + const mergeableObsPortfolioMutated = observeStewardSignalMonitor({ + signal_scope: mergeableScope, + previous_hash: mergeableObs.result_hash, + portfolio_observation: {result_hash: "p2-changed"}, + inbox_items: [{request_id: "r1"}, {request_id: "r2"}], + repository_snapshot: { + ...sampleRepo, + items: [ + sampleRepo.items[0], + sampleRepo.items[1], + {...sampleRepo.items[2], title: "Unrelated external update"}, + sampleRepo.items[3], + ], + }, + observed_at: "2026-11-21T08:00:00Z", + }); + assert.equal(mergeableObsPortfolioMutated.result_hash, mergeableObs.result_hash); + assert.equal(mergeableObsPortfolioMutated.material_change, false); + + // Stalled threshold flips once at >= 24h and stays stable at 25h / 48h. + // PR #101 updatedAt is 2026-11-20T09:00:00Z; #102 is 2026-11-18T00:00:00Z. + const at23h = observeStewardSignalMonitor({ + signal_scope: internalStalledScope, + repository_snapshot: sampleRepo, + observed_at: "2026-11-21T08:00:00Z", // #101 is 23h old -> only #102 matches + }); + assert.deepEqual(at23h.scoped_repository_items.map((row: {number: number}) => row.number), [102]); + assert.equal(at23h.scoped_repository_items[0].stalled_threshold_met, true); + + const at24h = observeStewardSignalMonitor({ + signal_scope: internalStalledScope, + previous_hash: at23h.result_hash, + repository_snapshot: sampleRepo, + observed_at: "2026-11-21T09:00:00Z", // #101 reaches 24h -> flips once + }); + assert.deepEqual(at24h.scoped_repository_items.map((row: {number: number}) => row.number), [101, 102]); + assert.equal(at24h.material_change, true); + + const at25h = observeStewardSignalMonitor({ + signal_scope: internalStalledScope, + previous_hash: at24h.result_hash, + repository_snapshot: sampleRepo, + observed_at: "2026-11-21T10:00:00Z", // 25h -> stable hash, no re-wake + }); + assert.equal(at25h.result_hash, at24h.result_hash); + assert.equal(at25h.material_change, false); + + const externalObs = observeStewardSignalMonitor({ + signal_scope: externalStalledScope, + repository_snapshot: sampleRepo, + observed_at: "2026-11-21T08:00:00Z", + }); + assert.deepEqual(externalObs.scoped_repository_items.map((row: {number: number}) => row.number), [103]); + assert.notEqual(mergeableObs.result_hash, at24h.result_hash); + assert.notEqual(at24h.result_hash, externalObs.result_hash); + + // Domain-neutral filter rejects legacy vendor-specific field and empty declaration lists. + assert.throws(() => observeStewardSignalMonitor({ + signal_scope: { + schema_version: "steward_signal_monitor_scope_v0", + pr_filter: {require_independent_gpt_approve: true}, + }, + repository_snapshot: sampleRepo, + })); + assert.throws(() => observeStewardSignalMonitor({ + signal_scope: { + schema_version: "steward_signal_monitor_scope_v0", + pr_filter: {required_approver_declarations: []}, + }, + repository_snapshot: sampleRepo, + })); + assert.throws(() => observeStewardSignalMonitor({ + signal_scope: internalStalledScope, + repository_snapshot: sampleRepo, + })); +}); diff --git a/tests/test_lark_steward_reports.py b/tests/test_lark_steward_reports.py index f3b44663bc..fae773c5a4 100644 --- a/tests/test_lark_steward_reports.py +++ b/tests/test_lark_steward_reports.py @@ -383,3 +383,135 @@ def test_schedule_change_cannot_strand_a_frozen_original_report(steward, tmp_pat result = reports.configure(binding["binding_id"], operation="enable", schedule=changed, execute=True, expected_plan_id=preview["plan_id"]) assert result["applied"] and result["report"]["schedule"] == changed + + +def test_monitor_report_reconciles_to_chat_root_without_periodic_subscription(steward, tmp_path, monkeypatch): + from datetime import datetime, timedelta, timezone + import loopx.capabilities.native_chat.steward_monitor as monitor_mod + from loopx.capabilities.native_chat.steward_monitor import StewardMonitor, steward_monitor_delivery_dir + from loopx.capabilities.native_chat.steward_reports import StewardReports + from loopx.extensions.lark.conversation_identity import identity_ref + from test_native_steward_managed_mode import storage + from test_native_steward_monitor import edit_local_watch + from test_steward_generic_monitor_todo import _configure_codex_response + from tests.control_plane.canonical_authority_fixture import isolate_sqlite_runtime + + isolate_sqlite_runtime(tmp_path, monkeypatch) + _, runtime, provider, transport, binding, _, _ = steward + storage(runtime, "sqlite") + + parent = provider.event("steward-app", "earlier-thread-parent", "Earlier threaded question") + event = provider.event("steward-app", "threaded-origin", "Keep steward monitor reports on chat root") + thread = dict(root_id=parent["message_id"], parent_id=parent["message_id"], thread_id="omt_steward") + event.update(thread) + provider.messages[event["message_id"]].update(thread) + transport.admit("steward-app", event) + row = transport.core.read_request(identity_ref(binding["provider_ref"], event["message_id"])) + assert finish(runtime, row)["status"] == "completed" + sid = row["session_id"] + + plan = transport.managed_steward.prepare(binding["binding_id"], session_id=sid)["plan"] + actor = transport.managed_steward.prepare( + binding["binding_id"], + session_id=sid, + execute=True, + expected_plan_id=plan["plan_id"], + )["actor"] + transport.reconcile() + assert StewardReports(runtime).subscription(binding["binding_id"]) is None + assert not transport.steward_reports.pending() + + 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": "Scoped PR monitor for chat_root delivery", + "normalized_parameters": { + "goal_id": actor["goal_id"], + "agent_id": actor["agent_id"], + "target": "Report matching PRs directly to chat_root.", + "target_key": "steward-chat-root-pr-monitor", + "task_repository": "acme/widgets", + "cadence": "every_hour", + "timezone": "UTC", + "stop_condition": "watch_only", + "signal_scope": { + "schema_version": "steward_signal_monitor_scope_v0", + "include_portfolio": False, + "include_inbox": False, + "pr_filter": {"exclude_drafts": True}, + }, + }, + "context": {"kind": "goal", "goal_id": actor["goal_id"]}, + "idempotency_key": "create-chat-root-pr-monitor", + }) + created_todo_id = actions.apply(preview["proposal_id"])["proposal"]["receipt"]["resource_ids"]["todo_id"] + 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": [{"number": 42, "title": "Ready PR", "isDraft": False, "updatedAt": "2026-11-20T00:00:00Z"}], + }) + poll_turns = pump_steward_monitors(runtime) + assert len(poll_turns) == 1 + assert finish(runtime, poll_turns[0])["status"] == "completed" + + report_md = "## 合并候选\n- PR #42 Ready PR" + _configure_codex_response(runtime, sid, { + "result_kind": "validated_completion", + "classification": "steward_scoped_pr_report", + "summary": "Delivered aggregated report.", + "next_action": "Wait for next poll.", + "evidence": ["PR #42 ready"], + "delivery_batch_scale": "implementation", + "delivery_outcome": "outcome_progress", + "work_evidence": ["Aggregated PR #42"], + "validation_evidence": ["Scoped snapshot confirmed"], + "path_delta_mode": "unchanged", + "vision_unchanged_reason": "Monitor report delivery.", + "steward_owner_report": report_md, + }) + + runtime._steward_monitor_next_check.clear() + adv_turns = pump_steward_monitors(runtime) + assert len(adv_turns) == 1 + adv_done = finish(runtime, adv_turns[0]) + assert adv_done["status"] == "completed", adv_done + assert adv_done["response"]["steward_owner_report_queued"] is True + + assert transport.steward_reports.pending() is True + before_writes = len(provider.writes) + before_topic = len(provider.topic_writes) + assert transport.steward_reports.reconcile() == 1 + assert len(provider.writes) == before_writes + 1 + assert len(provider.topic_writes) == before_topic + sent_message = provider.messages[f"om_out_{before_writes}"] + assert sent_message["chat_id"] == "oc_steward_app" + assert not sent_message.get("parent_id") + assert report_md in json.loads(sent_message["body"]["content"])["zh_cn"]["content"][0][0]["text"] + + delivery_path = steward_monitor_delivery_dir(runtime.coordination_runtime_root, actor["goal_id"]) / f"{adv_turns[0]['turn_id']}.json" + record = json.loads(delivery_path.read_text(encoding="utf-8")) + assert record["delivery_status"] == "delivered" + assert transport.steward_reports.pending() is False + writes_snapshot = list(provider.writes) + assert LarkStewardReports(transport).reconcile() == 0 + assert provider.writes == writes_snapshot diff --git a/tests/test_steward_generic_monitor_todo.py b/tests/test_steward_generic_monitor_todo.py index f3e57adc83..7f25f75ebe 100644 --- a/tests/test_steward_generic_monitor_todo.py +++ b/tests/test_steward_generic_monitor_todo.py @@ -8,6 +8,8 @@ from loopx.capabilities.native_chat.steward_monitor import ( StewardMonitor, pump_steward_monitors, + steward_monitor_delivery_dir, + steward_monitor_scope_path, steward_monitor_snapshot_path, ) from loopx.control_plane.collaboration.inbox import pending as inbox_pending @@ -325,3 +327,204 @@ def test_generic_signal_monitor_triggers_handoff_and_deduped_user_actions( assert poll3_done["status"] == "failed" assert capture.read_bytes() == calls_before_poll3 assert local_watch_row(runtime, actor, created_todo_id)["result_hash"] == first_hash + + +def test_scoped_signal_monitor_queues_aggregated_owner_report_without_user_todos( + steward, tmp_path, monkeypatch, +) -> None: + isolate_sqlite_runtime(tmp_path, monkeypatch) + store, runtime, _, transport, binding, capture, _ = 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) + + 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 + scope_spec = { + "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"], + }, + } + 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 without creating per-PR user todos.", + "target_key": "steward-gpt-mergeable-pr-monitor", + "task_repository": "acme/widgets", + "cadence": "every_2_hours", + "timezone": "Asia/Shanghai", + "stop_condition": "watch_only", + "signal_scope": scope_spec, + }, + "context": {"kind": "goal", "goal_id": actor["goal_id"]}, + "idempotency_key": "create-gpt-mergeable-pr-monitor", + }) + assert preview["status"] == "preview_ready" + assert preview["normalized_parameters"]["signal_scope"]["pr_filter"]["required_approver_declarations"] == ["gpt", "openai"] + applied = actions.apply(preview["proposal_id"]) + created_todo_id = applied["proposal"]["receipt"]["resource_ids"]["todo_id"] + scope_file = steward_monitor_scope_path(runtime.coordination_runtime_root, actor["goal_id"], "steward-gpt-mergeable-pr-monitor") + assert scope_file.is_file() + persisted_scope = json.loads(scope_file.read_text(encoding="utf-8")) + assert persisted_scope == preview["normalized_parameters"]["signal_scope"] + + edit_local_watch( + runtime, + actor, + created_todo_id, + "--next-due-at", + (datetime.now(timezone.utc) - timedelta(seconds=5)).isoformat(), + ) + + import loopx.capabilities.native_chat.steward_monitor as monitor_mod + from loopx.capabilities.native_chat.steward_turn import StewardTurnHost + + host = StewardTurnHost(runtime) + assert host._normalize_steward_actions({"steward_owner_report": " "}, {"context_delegation": {"targets": []}})["validation_error"] + assert host._normalize_steward_actions({"steward_owner_report": {"markdown": "x" * 24001}}, {"context_delegation": {"targets": []}})["validation_error"] + assert host._normalize_steward_actions({"steward_owner_report": {}}, {"context_delegation": {"targets": []}})["validation_error"] + + repo_payload = { + "status": "ok", + "repository": "acme/widgets", + "items": [ + { + "number": 9101, + "title": "Mergeable PR", + "url": "https://github.com/acme/widgets/pull/9101", + "headRefOid": "head9101", + "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"}, + ], + }, + }, + { + "number": 9102, + "title": "Conflicting PR excluded", + "url": "https://github.com/acme/widgets/pull/9102", + "headRefOid": "head9102", + "isDraft": False, + "mergeable": "CONFLICTING", + "updatedAt": "2026-11-20T09:00:00Z", + "author": {"login": "alice"}, + "review_summary": {"effective_verdict": "APPROVE", "has_review_conflict": False, "exact_head_reviews": []}, + }, + { + "number": 9103, + "title": "Dismissed GPT review excluded", + "url": "https://github.com/acme/widgets/pull/9103", + "headRefOid": "head9103", + "isDraft": False, + "mergeable": "MERGEABLE", + "updatedAt": "2026-11-20T09:00:00Z", + "author": {"login": "alice"}, + "review_summary": { + "effective_verdict": "APPROVE", + "has_review_conflict": False, + "exact_head_reviews": [ + {"author_login": "bob", "reviewer_declaration": "GPT-5.4", "verdict": "APPROVE", "valid_verdict_review": True, "state": "APPROVED"}, + {"author_login": "bob", "reviewer_declaration": "GPT-5.4", "verdict": None, "valid_verdict_review": False, "state": "DISMISSED"}, + {"author_login": "alice", "reviewer_declaration": "Author Fallback", "verdict": "APPROVE", "valid_verdict_review": True, "state": "COMMENTED", "author_owned_fallback": True}, + ], + }, + }, + ], + } + monkeypatch.setattr(monitor_mod, "_observe_github_repository_prs", lambda repo: repo_payload) + + calls_before_poll = capture.read_bytes() + poll_turns = pump_steward_monitors(runtime) + assert len(poll_turns) == 1 + poll_done = finish(runtime, poll_turns[0]) + assert poll_done["status"] == "completed" + assert poll_done["response"]["native_loopx"]["monitor"]["material_change"] is True + assert capture.read_bytes() == calls_before_poll + + snapshot_file = steward_monitor_snapshot_path(runtime.coordination_runtime_root, actor["goal_id"], created_todo_id) + snapshot_data = json.loads(snapshot_file.read_text(encoding="utf-8")) + assert [row["number"] for row in snapshot_data["repository_snapshot"]["items"]] == [9101] + assert snapshot_data["inbox_items"] == [] + assert snapshot_data["signal_scope"] == persisted_scope + + aggregated_md = "## 可直接合并 PR\n- #9101 Mergeable PR (author: alice, GPT-5.4 APPROVE)" + _configure_codex_response(runtime, sid, { + "result_kind": "validated_completion", + "classification": "steward_scoped_pr_report", + "summary": "Prepared aggregated mergeable PR report.", + "next_action": "Await next monitor cadence.", + "evidence": ["PR #9101 matched scoped GPT-approved filter"], + "delivery_batch_scale": "implementation", + "delivery_outcome": "outcome_progress", + "work_evidence": ["Synthesized 1 aggregated report instead of per-PR user todos"], + "validation_evidence": ["steward_monitor_snapshot_v0 scoped to 1 matching PR"], + "path_delta_mode": "unchanged", + "vision_unchanged_reason": "Scoped steward monitor report.", + "steward_owner_report": {"markdown": f" {aggregated_md} "}, + }) + + runtime._steward_monitor_next_check.clear() + adv_turns = pump_steward_monitors(runtime) + assert len(adv_turns) == 1 + adv_done = finish(runtime, adv_turns[0]) + assert adv_done["status"] == "completed", adv_done + assert adv_done["response"]["native_loopx"]["status"] == "committed" + assert adv_done["response"]["message"] == aggregated_md + assert adv_done["response"]["steward_owner_report_queued"] is True + + delivery_file = steward_monitor_delivery_dir(runtime.coordination_runtime_root, actor["goal_id"]) / f"{adv_turns[0]['turn_id']}.json" + assert delivery_file.is_file() + delivery = json.loads(delivery_file.read_text(encoding="utf-8")) + assert delivery["schema_version"] == "steward_monitor_report_delivery_v0" + assert delivery["delivery_status"] == "pending" + assert delivery["markdown"] == aggregated_md + assert delivery["turn_id"] == adv_turns[0]["turn_id"] + + user_todos = list_goal_todos( + registry_path=runtime.registry_path, + runtime_root_arg=str(runtime.coordination_runtime_root), + goal_id=actor["goal_id"], + role="user", + )["todos"] + assert user_todos == []