From b2261a535e8a3008c145b88999b56436989db3fa Mon Sep 17 00:00:00 2001 From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com> Date: Wed, 18 Nov 2026 01:46:12 +0800 Subject: [PATCH] feat(control-plane): assess scope budget proportionality without blocking large features Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com> --- loopx/capabilities/change_quality/receipt.py | 16 ++ loopx/capabilities/change_quality/result.py | 30 ++- loopx/capabilities/change_quality/scope.py | 89 +++++++++ loopx/capabilities/pr_review_queue/core.py | 10 +- .../pr_review_queue/review_contract.py | 11 +- .../pr_review_queue/scope_budget.py | 143 +++++++++++++++ .../capabilities/change_quality_validation.ts | 11 +- .../capabilities/change_scope_budget.ts | 142 ++++++++++++++ .../control_plane/effect_runtime_handlers.ts | 1 + loopx/pr_review.py | 43 ++++- skills/loopx-change-quality/SKILL.md | 13 ++ skills/loopx-pr-review/SKILL.md | 2 +- tests/capabilities/test_change_quality.py | 155 ++++++++++++++++ .../test_pr_review_agent_order.py | 67 +++++++ .../test_pr_review_result_check.py | 57 ++++++ .../change_quality_validation.test.ts | 35 ++++ .../change_scope_budget.test.ts | 173 ++++++++++++++++++ tsconfig.control-plane.json | 1 + 18 files changed, 987 insertions(+), 12 deletions(-) create mode 100644 loopx/capabilities/pr_review_queue/scope_budget.py create mode 100644 loopx/control_plane/capabilities/change_scope_budget.ts create mode 100644 tests/control_plane_ts/change_scope_budget.test.ts diff --git a/loopx/capabilities/change_quality/receipt.py b/loopx/capabilities/change_quality/receipt.py index 7b112abe6a..c833d3a7da 100644 --- a/loopx/capabilities/change_quality/receipt.py +++ b/loopx/capabilities/change_quality/receipt.py @@ -190,6 +190,10 @@ def build_change_quality_prepare_packet( status = "no_changes" else: status = "review_required" + raw_scope_budget = scope.get("scope_budget") + scope_budget = raw_scope_budget if isinstance(raw_scope_budget, dict) else {} + is_large_scope = scope_budget.get("status") == "large_scope" + resolved_base_ref = str(scope.get("base_ref") or base_ref) return { "ok": True, "schema_version": CHANGE_QUALITY_PREPARE_SCHEMA_VERSION, @@ -211,6 +215,18 @@ def build_change_quality_prepare_packet( ], "guardrail_status_owner": "loopx_derived", "instructions": [ + *( + [ + ( + f"Scope budget is large_scope against {resolved_base_ref}: cohesive large features " + f"(including multi-commit, multi-round, or mainline-merged branches) are allowed " + f"when proportionate to the goal; verify in reuse and simplification that no " + f"accidental shims, duplicate code paths, or unrelated scope drift inflated the diff." + ) + ] + if is_large_scope + else [] + ), "Review only the exact changed scope and resolve the projected repository instruction and ownership references.", "Write one grounded reuse conclusion and one grounded simplification conclusion.", "Prefer deletion, reuse, direct control flow, and established language idioms over redundant state, parameters, branches, wrappers, or speculative abstraction.", diff --git a/loopx/capabilities/change_quality/result.py b/loopx/capabilities/change_quality/result.py index 9f3f8b3f01..b106bd5e92 100644 --- a/loopx/capabilities/change_quality/result.py +++ b/loopx/capabilities/change_quality/result.py @@ -483,6 +483,12 @@ def normalize_change_quality_result( } +_GUARDRAIL_QUALIFICATION_PREFIXES = { + "test_validation": "validator:", + "efficiency": "scope_budget:", +} + + def derive_change_quality_guardrails( result: dict[str, Any], *, expected_scope: dict[str, Any] | None = None, ) -> dict[str, Any]: @@ -498,11 +504,25 @@ def derive_change_quality_guardrails( for item in category_risks if item["severity"] == "blocker" and item["resolved"] is not True ] - validation_blockers: list[str] = [] - validation_risks: list[str] = [] - if guardrail_id == "test_validation": - validation_blockers = qualification["blocking_codes"] - validation_risks = qualification["risk_codes"] + prefix = _GUARDRAIL_QUALIFICATION_PREFIXES.get(guardrail_id) + validation_blockers = ( + [ + code + for code in qualification["blocking_codes"] + if isinstance(code, str) and code.startswith(prefix) + ] + if prefix + else [] + ) + validation_risks = ( + [ + code + for code in qualification["risk_codes"] + if isinstance(code, str) and code.startswith(prefix) + ] + if prefix + else [] + ) current_blockers = [*unresolved_blockers, *validation_blockers] blocking_codes.extend(current_blockers) unresolved_risks = [ diff --git a/loopx/capabilities/change_quality/scope.py b/loopx/capabilities/change_quality/scope.py index be963cdb0a..3811196818 100644 --- a/loopx/capabilities/change_quality/scope.py +++ b/loopx/capabilities/change_quality/scope.py @@ -6,6 +6,7 @@ from pathlib import Path from typing import Any +from ...control_plane.effect_runtime import effect_runtime_result from ...extensions.process_runtime import retire_owned_process CHANGE_QUALITY_SCOPE_SCHEMA_VERSION = "change_quality_scope_v0" @@ -183,6 +184,60 @@ def _hash_untracked_file(digest: Any, repo_root: Path, relative_path: str) -> No digest.update(b"\0") +def _numstat_totals(repo_root: Path, *args: str) -> tuple[int, int]: + """Sum line additions and deletions from ``git diff --numstat -z`` output.""" + + result = _git(repo_root, *args) + if result.returncode != 0: + detail = bytes(result.stderr or b"").decode("utf-8", errors="replace").strip() + raise ValueError(f"git {' '.join(args)} failed: {detail}") + tokens = bytes(result.stdout or b"").split(b"\0") + additions = 0 + deletions = 0 + index = 0 + while index < len(tokens): + token = tokens[index] + index += 1 + if not token: + continue + parts = token.split(b"\t", 2) + if len(parts) < 3: + continue + added, deleted, path = parts + if path == b"": + # A rename/copy entry in ``--numstat -z`` emits two path tokens next. + index += 2 + if added.isdigit(): + additions += int(added) + if deleted.isdigit(): + deletions += int(deleted) + return additions, deletions + + +def _untracked_line_count(repo_root: Path, relative_path: str) -> int: + path = repo_root / relative_path + if path.is_symlink(): + return 1 + if not path.is_file(): + return 0 + with path.open("rb") as handle: + head = handle.read(8192) + if b"\0" in head: + return 0 + lines = head.count(b"\n") + last_byte = head[-1:] if head else b"" + while chunk := handle.read(1024 * 1024): + lines += chunk.count(b"\n") + last_byte = chunk[-1:] + if last_byte and last_byte != b"\n": + lines += 1 + return lines + + +def _rev_list_count(repo_root: Path, *args: str) -> int: + return int(_required_git_text(repo_root, "rev-list", *args)) + + def build_change_quality_scope( *, repo_path: Path, @@ -244,6 +299,39 @@ def build_change_quality_scope( for relative_path in sorted(untracked): _hash_untracked_file(digest, repo_root, relative_path) + committed_add, committed_del = _numstat_totals( + repo_root, "diff", "--numstat", "-z", committed_range, "--" + ) + staged_add, staged_del = _numstat_totals( + repo_root, "diff", "--numstat", "-z", "--cached" + ) + unstaged_add, unstaged_del = _numstat_totals( + repo_root, "diff", "--numstat", "-z" + ) + untracked_add = sum( + _untracked_line_count(repo_root, relative_path) + for relative_path in untracked + ) + additions = committed_add + staged_add + unstaged_add + untracked_add + deletions = committed_del + staged_del + unstaged_del + commit_count = _rev_list_count( + repo_root, "--count", f"{base_commit}..{head_commit}" + ) + merge_commit_count = _rev_list_count( + repo_root, "--merges", "--count", f"{base_commit}..{head_commit}" + ) + scope_budget = effect_runtime_result( + "capabilities.change_scope_budget.assess", + { + "changed_files": len(changed_files), + "additions": additions, + "deletions": deletions, + "commit_count": commit_count, + "merge_commit_count": merge_commit_count, + "request_changes_rounds": None, + }, + ) + return { "schema_version": CHANGE_QUALITY_SCOPE_SCHEMA_VERSION, "base_ref": normalized_base_ref, @@ -252,6 +340,7 @@ def build_change_quality_scope( "scope_fingerprint": digest.hexdigest(), "changed_files": changed_files, "changed_file_count": len(changed_files), + "scope_budget": scope_budget, "sources": { "committed": committed, "staged": staged, diff --git a/loopx/capabilities/pr_review_queue/core.py b/loopx/capabilities/pr_review_queue/core.py index f296196c79..743a056749 100644 --- a/loopx/capabilities/pr_review_queue/core.py +++ b/loopx/capabilities/pr_review_queue/core.py @@ -119,7 +119,15 @@ def _pr_snapshot( for key, value in snapshot.items() if key != "review_ready_age_hours" } - return snapshot | {"fingerprint": _fingerprint(fingerprint_snapshot)} + scope_budget = item.get("scope_budget") + return snapshot | { + "fingerprint": _fingerprint(fingerprint_snapshot), + **( + {"scope_budget": scope_budget} + if isinstance(scope_budget, Mapping) + else {} + ), + } def _previous_observation(value: Any) -> Mapping[str, Any]: diff --git a/loopx/capabilities/pr_review_queue/review_contract.py b/loopx/capabilities/pr_review_queue/review_contract.py index 5cdd820a52..7af54f852e 100644 --- a/loopx/capabilities/pr_review_queue/review_contract.py +++ b/loopx/capabilities/pr_review_queue/review_contract.py @@ -13,6 +13,7 @@ ) from .approval_closeout import approval_closeout_contract from .architecture_assessment import ARCHITECTURE_ASSESSMENT +from .scope_budget import is_large_scope from .visual_assessment import VISUAL_ASSESSMENT # Increment when review requirements change without changing the packet shape. @@ -1157,7 +1158,14 @@ def build_review_execution_contract(*, wait_for_ci: bool = True) -> dict[str, An "approval." " The nested architecture assessment binds mechanism placement, default " "strategy and the useful current-PR boundary to this same verdict, " - "rather than allowing them to remain disconnected commentary." + "rather than allowing them to remain disconnected commentary. " + "When scope_budget.status is large_scope, cohesive large features " + "(including high-addition, multi-commit, multi-review-round, or " + "mainline-merged branches) remain eligible for verdict=proportionate " + "and APPROVE when their scale matches the goal; choose " + "verdict=disproportionate or architecture_assessment.decision=simplify_now " + "only when the diff accumulated accidental shims, duplicate paths, " + "unrelated scope drift, or nit-loop churn." ), }, { @@ -1524,6 +1532,7 @@ def build_review_plan(item: Mapping[str, Any]) -> dict[str, Any]: }, "applicability": { "areas": sorted(areas), + "large_scope": is_large_scope(item), "code_change": code_change, "behavioral_policy_change": behavioral_policy_change, "behavior_bearing_change": behavior_bearing_change, diff --git a/loopx/capabilities/pr_review_queue/scope_budget.py b/loopx/capabilities/pr_review_queue/scope_budget.py new file mode 100644 index 0000000000..bf85c2e862 --- /dev/null +++ b/loopx/capabilities/pr_review_queue/scope_budget.py @@ -0,0 +1,143 @@ +"""Pull-request scope-budget adapter over the single-owner TypeScript contract.""" + +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from typing import cast + +from ...control_plane.effect_runtime import effect_runtime_result +from .review_body import AUTHOR_OWNED_REQUEST_CHANGES_FALLBACK_TITLE + + +def _is_merge_commit(commit: Mapping[str, object]) -> bool: + nested = commit.get("commit") + nested_map = nested if isinstance(nested, Mapping) else None + parents = commit.get("parents") + if parents is None and nested_map is not None: + parents = nested_map.get("parents") + if isinstance(parents, Mapping): + total = parents.get("totalCount") + if type(total) is int: + return total > 1 + elif isinstance(parents, Sequence) and not isinstance(parents, (str, bytes)): + if len(parents) > 0: + return len(parents) > 1 + headline = str( + commit.get("messageHeadline") + or (nested_map.get("messageHeadline") if nested_map is not None else "") + or "" + ) + return headline.startswith("Merge ") + + +def _extract_commit_counts(pr: Mapping[str, object]) -> tuple[int | None, int | None]: + raw_commits = pr.get("commits") + if raw_commits is None: + return None, None + if isinstance(raw_commits, Mapping): + total = raw_commits.get("totalCount") + nodes = raw_commits.get("nodes") + if isinstance(nodes, Sequence) and not isinstance(nodes, (str, bytes)): + commit_nodes = [item for item in nodes if isinstance(item, Mapping)] + commit_count = ( + int(total) + if type(total) is int and total >= len(commit_nodes) + else len(commit_nodes) + ) + merge_count = sum(1 for item in commit_nodes if _is_merge_commit(item)) + return commit_count, merge_count + if type(total) is int and total >= 0: + return total, None + return None, None + if isinstance(raw_commits, Sequence) and not isinstance(raw_commits, (str, bytes)): + commit_count = len(raw_commits) + merge_count = sum( + 1 + for item in raw_commits + if isinstance(item, Mapping) and _is_merge_commit(item) + ) + return commit_count, merge_count + return None, None + + +def _extract_request_changes_rounds(pr: Mapping[str, object]) -> int | None: + raw_reviews = pr.get("reviews") + if raw_reviews is None: + return None + if isinstance(raw_reviews, Mapping): + nodes = raw_reviews.get("nodes") + if isinstance(nodes, Sequence) and not isinstance(nodes, (str, bytes)): + reviews = nodes + else: + return None + elif isinstance(raw_reviews, Sequence) and not isinstance( + raw_reviews, (str, bytes) + ): + reviews = raw_reviews + else: + return None + rounds = 0 + for review in reviews: + if not isinstance(review, Mapping): + continue + state = str(review.get("state") or "").strip().upper() + body = str(review.get("body") or "") + if ( + state == "CHANGES_REQUESTED" + or AUTHOR_OWNED_REQUEST_CHANGES_FALLBACK_TITLE in body + ): + rounds += 1 + return rounds + + +def assess_pr_scope_budget( + pr: Mapping[str, object], + *, + changed_files: int, + additions: int, + deletions: int, +) -> dict[str, object]: + """Classify PR scale, commit churn, merges, and review rounds via TS owner.""" + + commit_count, merge_commit_count = _extract_commit_counts(pr) + request_changes_rounds = _extract_request_changes_rounds(pr) + payload = effect_runtime_result( + "capabilities.change_scope_budget.assess", + { + "changed_files": max(0, int(changed_files)), + "additions": max(0, int(additions)), + "deletions": max(0, int(deletions)), + "commit_count": commit_count, + "merge_commit_count": merge_commit_count, + "request_changes_rounds": request_changes_rounds, + }, + ) + return cast(dict[str, object], payload) + + +def is_large_scope(item: Mapping[str, object]) -> bool: + scope_budget = item.get("scope_budget") + return isinstance(scope_budget, Mapping) and scope_budget.get("status") == "large_scope" + + +def pr_scope_budget_risk_note( + scope_budget: Mapping[str, object] | None, +) -> str | None: + if not ( + isinstance(scope_budget, Mapping) + and scope_budget.get("status") == "large_scope" + ): + return None + signals = scope_budget.get("triggered_signals") + signal_text = ( + f" ({', '.join(str(item) for item in signals)})" + if isinstance(signals, Sequence) + and not isinstance(signals, (str, bytes)) + and signals + else "" + ) + return ( + f"Large scope / high churn{signal_text}: cohesive large features are allowed " + "when proportionate to the goal; verify change_proportionality distinguishes " + "legitimate feature breadth from accidental shims, duplicate paths, or unrelated scope drift." + ) diff --git a/loopx/control_plane/capabilities/change_quality_validation.ts b/loopx/control_plane/capabilities/change_quality_validation.ts index 28e82090e2..077e867e58 100644 --- a/loopx/control_plane/capabilities/change_quality_validation.ts +++ b/loopx/control_plane/capabilities/change_quality_validation.ts @@ -5,7 +5,7 @@ import type {JsonObject} from "../effect_program.ts"; import {ENVELOPED_SHA256_PATTERN} from "../content_digest.ts"; import {EffectRuntimeRequestError} from "../effect_runtime_errors.ts"; -import {requireBoolean, requireInteger, requireJsonObject, requireNonEmptyString, +import {jsonObject, requireBoolean, requireInteger, requireJsonObject, requireNonEmptyString, requireStringArray, requireStringLiteral} from "../runtime_decode.ts"; export type ChangeQualityValidationStatus = "passed" | "failed" | "skipped"; @@ -110,5 +110,14 @@ export function qualifyChangeQualityValidation(input: JsonObject): JsonObject { blocking.push(ref); } else if (row.status !== "passed") risks.push(ref); } + const scope = jsonObject(input.scope); + const scopeBudget = scope ? jsonObject(scope.scope_budget) : null; + if (scopeBudget) { + if (scopeBudget.status === "large_scope") { + risks.push("scope_budget:large_scope"); + } else if (scopeBudget.status === "elevated_scope") { + risks.push("scope_budget:elevated_scope"); + } + } return {validation: rows, blocking_codes: blocking, risk_codes: risks}; } diff --git a/loopx/control_plane/capabilities/change_scope_budget.ts b/loopx/control_plane/capabilities/change_scope_budget.ts new file mode 100644 index 0000000000..892a7bb3a3 --- /dev/null +++ b/loopx/control_plane/capabilities/change_scope_budget.ts @@ -0,0 +1,142 @@ +/** Single-owner scope-budget and large-feature diagnostic for dev and PR review. + * + * Pure TypeScript control-plane decision owner with zero host or Git IO. + * Surfaces non-blocking proportionality diagnostics on large additions, + * high commit/merge churn, or multi-round review loops while exempting + * net-subtraction cleanups and allowing cohesive large features. + */ +import type {JsonObject} from "../effect_program.ts"; +import {EffectRuntimeRequestError} from "../effect_runtime_errors.ts"; +import {requireInteger, requireJsonObject} from "../runtime_decode.ts"; + +export const CHANGE_SCOPE_BUDGET_SCHEMA_VERSION = + "change_scope_budget_assessment_v0"; + +export const CHANGE_SCOPE_BUDGET_STATUSES = [ + "within_budget", + "net_subtraction", + "elevated_scope", + "large_scope", +] as const; +export type ChangeScopeBudgetStatus = + (typeof CHANGE_SCOPE_BUDGET_STATUSES)[number]; + +const ALLOWED_INPUT_FIELDS = new Set([ + "changed_files", + "additions", + "deletions", + "commit_count", + "merge_commit_count", + "request_changes_rounds", +]); + +function nonNegativeInteger(value: unknown, label: string): number { + const parsed = requireInteger(value, label); + if (!Number.isSafeInteger(parsed) || parsed < 0) { + throw new EffectRuntimeRequestError( + `${label} must be a non-negative integer`, + ); + } + return parsed; +} + +function optionalNullableNonNegativeInteger( + value: unknown, + label: string, +): number | null { + if (value === undefined || value === null) return null; + return nonNegativeInteger(value, label); +} + +export function assessChangeScopeBudget(input: JsonObject): JsonObject { + const raw = requireJsonObject(input, "change scope budget input"); + for (const key of Object.keys(raw)) { + if (!ALLOWED_INPUT_FIELDS.has(key)) { + throw new EffectRuntimeRequestError( + `change scope budget input.${key} is unsupported`, + ); + } + } + const changedFiles = nonNegativeInteger(raw.changed_files, "changed_files"); + const additions = nonNegativeInteger(raw.additions, "additions"); + const deletions = nonNegativeInteger(raw.deletions, "deletions"); + const commitCount = optionalNullableNonNegativeInteger( + raw.commit_count, + "commit_count", + ); + const mergeCommitCount = optionalNullableNonNegativeInteger( + raw.merge_commit_count, + "merge_commit_count", + ); + const requestChangesRounds = optionalNullableNonNegativeInteger( + raw.request_changes_rounds, + "request_changes_rounds", + ); + + const triggeredSignals: string[] = []; + let status: ChangeScopeBudgetStatus; + + if (deletions > additions && additions <= 1500) { + status = "net_subtraction"; + } else { + const rounds = requestChangesRounds ?? 0; + const commits = commitCount ?? 0; + const merges = mergeCommitCount ?? 0; + + if (additions >= 2500 && additions > deletions && changedFiles >= 35) { + triggeredSignals.push("excessive_addition_surface"); + } + if (rounds >= 5 && additions >= 1200 && additions >= deletions) { + triggeredSignals.push("review_ping_pong_spiral"); + } + if (commits >= 40 && additions >= 1200 && additions >= deletions) { + triggeredSignals.push("excessive_commit_churn"); + } + if (merges >= 3 && additions >= 800) { + triggeredSignals.push("repeated_mainline_merge_commits"); + } + + if (triggeredSignals.length > 0) { + status = "large_scope"; + } else { + if ( + (additions >= 1000 && additions > deletions) || + (changedFiles >= 20 && additions >= deletions && additions >= 400) + ) { + triggeredSignals.push("elevated_addition_surface"); + } + if (rounds >= 3 && additions >= 400) { + triggeredSignals.push("elevated_review_rounds"); + } + if (commits >= 20 && additions >= 400) { + triggeredSignals.push("elevated_commit_count"); + } + if (merges >= 2) { + triggeredSignals.push("repeated_mainline_merge_commits"); + } + status = + triggeredSignals.length > 0 ? "elevated_scope" : "within_budget"; + } + } + + const remediation = + status === "large_scope" + ? "verify_goal_proportionality" + : status === "elevated_scope" + ? "prefer_smaller_slice" + : "none"; + + return { + schema_version: CHANGE_SCOPE_BUDGET_SCHEMA_VERSION, + status, + changed_files: changedFiles, + additions, + deletions, + net_additions: additions - deletions, + commit_count: commitCount, + merge_commit_count: mergeCommitCount, + request_changes_rounds: requestChangesRounds, + triggered_signals: triggeredSignals, + remediation, + }; +} diff --git a/loopx/control_plane/effect_runtime_handlers.ts b/loopx/control_plane/effect_runtime_handlers.ts index 648fb9bbd8..6827b62088 100644 --- a/loopx/control_plane/effect_runtime_handlers.ts +++ b/loopx/control_plane/effect_runtime_handlers.ts @@ -493,6 +493,7 @@ export function createEffectRuntimeHandlers( ["scheduler.monitor_batch.replay", lazyHandler(() => import("./scheduler/monitor_batch.ts"), ({replayLegacyMonitorBatch}) => replayLegacyMonitorBatch)], ["scheduler.monitor_target.select", lazyHandler(() => import("./scheduler/monitor_successor.ts"), ({selectMonitorTodoRequest}) => selectMonitorTodoRequest)], ["capabilities.issue_fix.monitor_reconciliation.plan", lazyHandler(() => import("./capabilities/issue_fix_monitor_reconciliation.ts"), ({planIssueFixMonitorReconciliation}) => planIssueFixMonitorReconciliation)], + ["capabilities.change_scope_budget.assess", lazyHandler(() => import("./capabilities/change_scope_budget.ts"), ({assessChangeScopeBudget}) => assessChangeScopeBudget)], ["capabilities.change_quality.validation_gate", lazyHandler(() => import("./capabilities/change_quality_validation.ts"), ({qualifyChangeQualityValidation}) => qualifyChangeQualityValidation)], ["capabilities.pr_review.approval_closeout.plan", lazyHandler(() => import("./capabilities/pr_review_approval_closeout.ts"), ({planPrReviewApprovalCloseout}) => planPrReviewApprovalCloseout)], ["capabilities.pr_review.conclusion.select", lazyHandler(() => import("./capabilities/pr_review_approval_closeout.ts"), ({selectPrReviewConclusion}) => selectPrReviewConclusion)], diff --git a/loopx/pr_review.py b/loopx/pr_review.py index 2238eacf4b..64b57dfaf2 100644 --- a/loopx/pr_review.py +++ b/loopx/pr_review.py @@ -42,6 +42,10 @@ CODE_AREAS as CODE_AREAS, BEHAVIORAL_POLICY_AREAS as BEHAVIORAL_POLICY_AREAS, ) +from .capabilities.pr_review_queue.scope_budget import ( + assess_pr_scope_budget, + pr_scope_budget_risk_note, +) from .control_plane.runtime.time import now_utc_iso from .presentation.markdown import as_dict as _as_dict from .presentation.markdown import as_list as _as_list @@ -712,7 +716,13 @@ def _checks(pr: dict[str, Any]) -> dict[str, Any]: } -def _risk_notes(pr: dict[str, Any], files: list[dict[str, Any]], *, wait_for_ci: bool = True) -> list[str]: +def _risk_notes( + pr: dict[str, Any], + files: list[dict[str, Any]], + *, + wait_for_ci: bool = True, + scope_budget: Mapping[str, object] | None = None, +) -> list[str]: notes: list[str] = [] state = str(pr.get("state") or "").upper() if state == "MERGED" or pr.get("mergedAt") or pr.get("merged_at"): @@ -733,6 +743,9 @@ def _risk_notes(pr: dict[str, Any], files: list[dict[str, Any]], *, wait_for_ci: checks = _checks(pr) if wait_for_ci and checks.get("failures"): notes.append("Failing status checks block a clean merge decision.") + hold_note = pr_scope_budget_risk_note(scope_budget) + if hold_note: + notes.append(hold_note) return notes @@ -939,6 +952,27 @@ def _normalize_pr( conclusion = _review_conclusion(pr, reviewer_login=reviewer_login, behavior_bearing=bool({item["area"] for item in files} & (CODE_AREAS | BEHAVIORAL_POLICY_AREAS))) independent = conclusion.pop("independent_review", None) + changed_file_count = max(0, int(pr.get("changedFiles") or len(files) or 0)) + raw_additions = pr.get("additions") + raw_deletions = pr.get("deletions") + addition_count = max( + 0, + int(raw_additions) + if raw_additions is not None + else sum(int(f["additions"]) for f in files if isinstance(f.get("additions"), int)), + ) + deletion_count = max( + 0, + int(raw_deletions) + if raw_deletions is not None + else sum(int(f["deletions"]) for f in files if isinstance(f.get("deletions"), int)), + ) + scope_budget = assess_pr_scope_budget( + pr, + changed_files=changed_file_count, + additions=addition_count, + deletions=deletion_count, + ) item: dict[str, Any] = { "number": number, "title": _redact_text(pr.get("title"), limit=180), @@ -976,17 +1010,20 @@ def _normalize_pr( "mergeability": str(pr.get("mergeable") or "UNKNOWN").upper(), "motivation": _motivation(pr), "scale": { - "changed_files": int(pr.get("changedFiles") or len(files) or 0), + "changed_files": changed_file_count, "additions": int(pr.get("additions") or 0), "deletions": int(pr.get("deletions") or 0), }, + "scope_budget": scope_budget, "areas": _area_counts(files), "key_files": files[:10], "commit_headlines": _commit_headlines(pr), "checks": checks, "wait_for_ci": wait_for_ci, "review_depth": _review_depth(files), - "risk_notes": _risk_notes(pr, files, wait_for_ci=wait_for_ci), + "risk_notes": _risk_notes( + pr, files, wait_for_ci=wait_for_ci, scope_budget=scope_budget + ), "metadata_risk_hint": _metadata_risk_hint(pr, files, checks, wait_for_ci=wait_for_ci), "main_regression_analysis": _main_regression_analysis(pr, files, wait_for_ci=wait_for_ci), } diff --git a/skills/loopx-change-quality/SKILL.md b/skills/loopx-change-quality/SKILL.md index bf57acd296..6024c4074a 100644 --- a/skills/loopx-change-quality/SKILL.md +++ b/skills/loopx-change-quality/SKILL.md @@ -41,6 +41,19 @@ Stop when the packet says `disabled` or `no_changes`. When it says `review_required`, review only the files and exact fingerprint in the packet. Read repository-local instructions before judging the change. +Each `prepare` packet also assesses `scope.scope_budget` +(`change_scope_budget_assessment_v0`): + +- `net_subtraction` (`deletions > additions` with `additions <= 1500`) is exempt + from file-count, commit-churn, and merge-commit accretion penalties; +- `elevated_scope` (`prefer_smaller_slice`) marks the `efficiency` guardrail as + diagnostic `risk` without failing the receipt; +- `large_scope` (`verify_goal_proportionality`) allows cohesive large features + (including high-addition, multi-commit, multi-review-round, or mainline-merged + branches): it adds a goal-proportionality review instruction in `prepare` and + marks `efficiency` as diagnostic `risk` (`scope_budget:large_scope`) without + blocking `record`/`verify` (`canary premerge`). + Run `loopx project-skill status --project . --skill loopx-change-quality` when the host depends on skill discovery. If the managed copy is absent or stale, preview an explicit project install; do not fall back to a global copy. diff --git a/skills/loopx-pr-review/SKILL.md b/skills/loopx-pr-review/SKILL.md index a520a27588..033e8674f8 100644 --- a/skills/loopx-pr-review/SKILL.md +++ b/skills/loopx-pr-review/SKILL.md @@ -104,7 +104,7 @@ An explicitly authorized fresh audit uses the same exact-head override above. with the remote readback and rerun `--check-result`; matching does not certify reasoning. 5. Re-read the remote head immediately before verdict and publication; restart evidence if it changed. -Each PR needs independent evidence and a standalone card; a queue table is a preface only. +Each PR needs independent evidence and a standalone card; a queue table is a preface only. Each PR carries `scope_budget` (`change_scope_budget_assessment_v0`): `net_subtraction` (`deletions > additions`, `additions <= 1500`) is exempt from file-count and churn warnings; `elevated_scope` (`prefer_smaller_slice`) and `large_scope` (`verify_goal_proportionality` on high additions, `>=5` review rounds, `>=40` commits, or `>=3` mainline merges) are non-blocking diagnostics—cohesive large features remain eligible for normal queue ordering, `verdict="proportionate"`, and `APPROVE`, while accidental bloat or unrelated scope drift should still receive `disproportionate` / `simplify_now`. For managed review, pass `--goal-id GOAL` and execute the packet's current `validation_matrix`: its `wait_for_ci`, `validation_source` and diff --git a/tests/capabilities/test_change_quality.py b/tests/capabilities/test_change_quality.py index 620523e79f..76cf445ed6 100644 --- a/tests/capabilities/test_change_quality.py +++ b/tests/capabilities/test_change_quality.py @@ -986,3 +986,158 @@ def test_quality_skill_uses_managed_project_delivery(tmp_path: Path) -> None: ) assert readback["status"] == "current" assert readback["managed"] is True + + +def test_scope_budget_allows_large_scope_as_diagnostic_risk_and_exempts_net_subtraction( + tmp_path: Path, +) -> None: + repo, registry, runtime_root = _fixture(tmp_path) + _enable(registry) + base = _git(repo, "rev-parse", "HEAD") + + (repo / "blob.bin").write_bytes(b"\x00\x01\x02\xff") + _git(repo, "add", "blob.bin") + (repo / "elevated.py").write_text( + "\n".join(f"line_{i} = {i}" for i in range(1050)) + "\n", + encoding="utf-8", + ) + elevated_prepare = build_change_quality_prepare_packet( + registry_path=registry, + goal_id=GOAL_ID, + repo_path=repo, + base_ref=base, + ) + assert elevated_prepare["scope"]["scope_budget"]["status"] == "elevated_scope" + assert "split_required" not in elevated_prepare["scope"]["scope_budget"] + elevated_result = _result( + tmp_path / "elevated-result.json", + elevated_prepare["scope"]["scope_fingerprint"], + reuse={ + "outcome": "retained", + "summary": "Direct assignments only.", + "evidence_refs": ["path:elevated.py"], + }, + simplification={ + "outcome": "retained", + "summary": "Direct assignments only.", + "evidence_refs": ["path:elevated.py"], + "safe_fix_applied": False, + }, + ) + elevated_recorded = record_change_quality_receipt( + registry_path=registry, + runtime_root=runtime_root, + goal_id=GOAL_ID, + repo_path=repo, + result_path=elevated_result, + base_ref=base, + execute=False, + ) + assert elevated_recorded["decision"] == "pass" + efficiency_state = next( + item + for item in elevated_recorded["receipt"]["guardrails"]["states"] + if item["guardrail_id"] == "efficiency" + ) + assert efficiency_state["status"] == "risk" + + for index in range(35): + (repo / f"module_{index}.py").write_text( + "\n".join(f"x_{j} = {j}" for j in range(50)) + "\n", + encoding="utf-8", + ) + large_prepare = build_change_quality_prepare_packet( + registry_path=registry, + goal_id=GOAL_ID, + repo_path=repo, + base_ref=base, + ) + assert large_prepare["scope"]["scope_budget"]["status"] == "large_scope" + assert large_prepare["scope"]["scope_budget"]["remediation"] == "verify_goal_proportionality" + assert "split_required" not in large_prepare["scope"]["scope_budget"] + assert any( + "large_scope" in line and "cohesive large features" in line and base in line + for line in large_prepare["agent_contract"]["instructions"] + ) + large_result = _result( + tmp_path / "large-result.json", + large_prepare["scope"]["scope_fingerprint"], + reuse={ + "outcome": "retained", + "summary": "Cohesive feature modules.", + "evidence_refs": ["path:elevated.py"], + }, + simplification={ + "outcome": "retained", + "summary": "Checked feature breadth against goal.", + "evidence_refs": ["path:elevated.py"], + "safe_fix_applied": False, + }, + ) + large_recorded = record_change_quality_receipt( + registry_path=registry, + runtime_root=runtime_root, + goal_id=GOAL_ID, + repo_path=repo, + result_path=large_result, + base_ref=base, + execute=False, + ) + assert large_recorded["ok"] is True + assert large_recorded["decision"] == "pass" + assert large_recorded["unresolved_blockers"] == [] + large_efficiency = next( + item + for item in large_recorded["receipt"]["guardrails"]["states"] + if item["guardrail_id"] == "efficiency" + ) + assert large_efficiency["status"] == "risk" + assert large_efficiency["blocking_codes"] == [] + + # Net subtraction across >= 35 files stays exempt when additions <= 1500. + _git(repo, "reset", "--hard", base) + _git(repo, "clean", "-fd") + for index in range(40): + (repo / f"cleanup_{index}.py").write_text( + "\n".join(f"old_{j} = {j}" for j in range(60)) + "\n", + encoding="utf-8", + ) + _git(repo, "add", ".") + _git(repo, "commit", "-qm", "legacy surface") + deletion_base = _git(repo, "rev-parse", "HEAD") + for index in range(40): + (repo / f"cleanup_{index}.py").unlink() + (repo / "compact.py").write_text("compact = True\n", encoding="utf-8") + sub_prepare = build_change_quality_prepare_packet( + registry_path=registry, + goal_id=GOAL_ID, + repo_path=repo, + base_ref=deletion_base, + ) + assert sub_prepare["scope"]["scope_budget"]["status"] == "net_subtraction" + assert "split_required" not in sub_prepare["scope"]["scope_budget"] + sub_result = _result( + tmp_path / "sub-result.json", + sub_prepare["scope"]["scope_fingerprint"], + reuse={ + "outcome": "reused", + "summary": "Replaced duplicated files.", + "evidence_refs": ["path:compact.py"], + }, + simplification={ + "outcome": "retained", + "summary": "Net deletion cleanup.", + "evidence_refs": ["path:compact.py"], + "safe_fix_applied": False, + }, + ) + sub_recorded = record_change_quality_receipt( + registry_path=registry, + runtime_root=runtime_root, + goal_id=GOAL_ID, + repo_path=repo, + result_path=sub_result, + base_ref=deletion_base, + execute=False, + ) + assert sub_recorded["decision"] == "pass" diff --git a/tests/capabilities/test_pr_review_agent_order.py b/tests/capabilities/test_pr_review_agent_order.py index da8512492e..f6904d8f8e 100644 --- a/tests/capabilities/test_pr_review_agent_order.py +++ b/tests/capabilities/test_pr_review_agent_order.py @@ -295,3 +295,70 @@ def test_public_cli_owner_save_restart_cross_goal_and_clear(tmp_path, capsys, mo saved = json.loads(registry.read_text())["goals"][0]["control_plane"]["pull_request_review"] assert saved["owner_logins"] == [] assert saved["agent_orders"] == {"a": "forward", "b": "reverse"} + + +def test_large_scope_feature_pr_preserves_fair_queue_order_and_surfaces_diagnostics(): + make = runpy.run_path( + str(Path(__file__).parents[1] / "test_pr_review_github_scan.py") + )["_queue_pr"] + prs = [ + make(1, author="other", ready_at="2026-09-01T00:00:00Z", updated_at="2026-09-01T00:00:00Z"), + make(2, author="other", ready_at="2026-09-02T00:00:00Z", updated_at="2026-09-02T00:00:00Z"), + make(3, author="reviewer", ready_at="2026-09-01T00:00:00Z", updated_at="2026-09-01T00:00:00Z"), + make(4, author="reviewer", ready_at="2026-09-02T00:00:00Z", updated_at="2026-09-02T00:00:00Z"), + make(5, author="reviewer", ready_at="2026-09-03T00:00:00Z", updated_at="2026-09-03T00:00:00Z"), + make(6, author="other", ready_at="2026-09-03T00:00:00Z", updated_at="2026-09-03T00:00:00Z"), + ] + # PR #5 is a cohesive large feature (latest owner push) with multiple review rounds. + prs[4].update( + changedFiles=42, + additions=3200, + deletions=120, + reviews=[ + { + "state": "COMMENTED", + "body": "Request changes conclusion (author-owned PR; GitHub blocks formal self-review)", + } + for _ in range(5) + ], + ) + # PR #6 is a net-subtraction cleanup across 45 files, so it stays exempt. + prs[5].update(changedFiles=45, additions=200, deletions=3000) + + forward = build_pr_review_packet( + pull_requests=prs, + repository="owner/repo", + reviewer_login="reviewer", + source="fixture", + review_order="forward", + limit=100, + ) + reverse = build_pr_review_packet( + pull_requests=prs, + repository="owner/repo", + reviewer_login="reviewer", + source="fixture", + review_order="reverse", + limit=100, + ) + + assert _sequence(forward) == [1, 2, 6, 3, 4, 5] + assert _sequence(reverse) == [5, 4, 3, 6, 2, 1] + assert all("accretion_hold" not in entry for entry in reverse["review_sequence"]) + + mega = next(row for row in reverse["pull_requests"] if row["number"] == 5) + cleanup = next(row for row in reverse["pull_requests"] if row["number"] == 6) + assert mega["scope_budget"]["status"] == "large_scope" + assert "split_required" not in mega["scope_budget"] + assert mega["review_plan"]["applicability"]["large_scope"] is True + assert any("Large scope / high churn" in note for note in mega["risk_notes"]) + assert cleanup["scope_budget"]["status"] == "net_subtraction" + assert cleanup["review_plan"]["applicability"]["large_scope"] is False + + observed = build_pull_request_review_queue_observation( + repository="owner/repo", + pull_requests=reverse["pull_requests"], + result_completeness={"complete": True}, + review_order="reverse", + ) + assert observed["candidate"]["number"] == 5 diff --git a/tests/capabilities/test_pr_review_result_check.py b/tests/capabilities/test_pr_review_result_check.py index b8e8472ffa..f9cb5d8c0f 100644 --- a/tests/capabilities/test_pr_review_result_check.py +++ b/tests/capabilities/test_pr_review_result_check.py @@ -1702,3 +1702,60 @@ def test_a_published_mapping_must_carry_its_immutable_revision(): # Publishing the same mapping with its revision closes the gap. result["review_body"] += "Spec revision: " + revision + "\n" assert check_review_result(packet, result)["ok"] + + +def test_large_scope_allows_proportionate_approve_and_supports_disproportionate_request_changes(): + packet, result = _review() + packet["pull_requests"][0]["scope_budget"] = { + "schema_version": "change_scope_budget_assessment_v0", + "status": "large_scope", + "triggered_signals": ["excessive_addition_surface"], + "remediation": "verify_goal_proportionality", + } + plan = build_review_plan(packet["pull_requests"][0]) + assert plan["applicability"]["large_scope"] is True + contract = build_review_execution_contract() + prop_req = next( + row + for row in contract["evidence_requirements"] + if row["evidence_id"] == "change_proportionality" + ) + assert "large_scope" in prop_req["rule"] + + # Approving a cohesive large feature as proportionate is allowed cleanly. + checked_approve = check_review_result(packet, result) + assert checked_approve["ok"] is True + assert checked_approve["approval_consistent"] is True + assert checked_approve["approval_blockers"] == [] + + # Reviewers can still flag genuine bloat via REQUEST_CHANGES with disproportionate/simplify_now. + result["verdict"] = "REQUEST_CHANGES" + result["review_body"] = result["review_body"].replace( + "English verdict: APPROVE", "English verdict: REQUEST_CHANGES" + ) + disproportionate_result = copy.deepcopy(result) + disproportionate_result["evidence"]["change_proportionality"]["verdict"] = "disproportionate" + assert check_review_result(packet, disproportionate_result)["ok"] + + simplify_result = copy.deepcopy(result) + simplify_result["evidence"]["change_proportionality"]["architecture_assessment"] = { + "decision": "simplify_now", + "reason": "Diff accumulated accidental shims beyond the goal.", + "current_pr_boundary": "Keep only the primary feature slice.", + "validation_evidence": "Synthetic consistency fixture.", + "mechanisms": [ + { + "mechanism": "scope_split", + "responsibility": "policy", + "owning_boundary": "Author branch cleanup.", + "activation_and_default": "Diagnostic guidance for disproportionate bloat.", + "failure_and_recovery": "Remove accidental shims.", + "placement_basis": "Scope budget proportionality review.", + } + ], + } + simplify_result["review_body"] = simplify_result["review_body"].replace( + "## 改动思路\n", + "## 改动思路\n\nDiff accumulated accidental shims beyond the goal.\n\nKeep only the primary feature slice.\n", + ) + assert check_review_result(packet, simplify_result)["ok"] diff --git a/tests/control_plane_ts/change_quality_validation.test.ts b/tests/control_plane_ts/change_quality_validation.test.ts index b3409d556a..2b2ecd2e92 100644 --- a/tests/control_plane_ts/change_quality_validation.test.ts +++ b/tests/control_plane_ts/change_quality_validation.test.ts @@ -65,3 +65,38 @@ for (const mutation of ["dirty", "missing_scope", "same_run", "zero_exit", "sign assert.throws(() => qualifyChangeQualityValidation(input)); }); } + +test("scope_budget large_scope and elevated_scope stay non-blocking diagnostic risks", () => { + const large = qualifyChangeQualityValidation({ + scope: { + scope_budget: { + status: "large_scope", + }, + }, + validation: [{validator: "check", status: "passed", required: true}], + }); + assert.deepEqual(large.blocking_codes, []); + assert.deepEqual(large.risk_codes, ["scope_budget:large_scope"]); + + const elevated = qualifyChangeQualityValidation({ + scope: { + scope_budget: { + status: "elevated_scope", + }, + }, + validation: [{validator: "check", status: "passed", required: true}], + }); + assert.deepEqual(elevated.blocking_codes, []); + assert.deepEqual(elevated.risk_codes, ["scope_budget:elevated_scope"]); + + const subtraction = qualifyChangeQualityValidation({ + scope: { + scope_budget: { + status: "net_subtraction", + }, + }, + validation: [{validator: "check", status: "passed", required: true}], + }); + assert.deepEqual(subtraction.blocking_codes, []); + assert.deepEqual(subtraction.risk_codes, []); +}); diff --git a/tests/control_plane_ts/change_scope_budget.test.ts b/tests/control_plane_ts/change_scope_budget.test.ts new file mode 100644 index 0000000000..70c57d2066 --- /dev/null +++ b/tests/control_plane_ts/change_scope_budget.test.ts @@ -0,0 +1,173 @@ +import assert from "node:assert/strict"; +import test from "node:test"; +import { + assessChangeScopeBudget, + CHANGE_SCOPE_BUDGET_SCHEMA_VERSION, + CHANGE_SCOPE_BUDGET_STATUSES, +} from "../../loopx/control_plane/capabilities/change_scope_budget.ts"; + +test("status vocabulary stays explicit and bounded", () => { + assert.deepEqual(CHANGE_SCOPE_BUDGET_STATUSES, [ + "within_budget", + "net_subtraction", + "elevated_scope", + "large_scope", + ]); +}); + +test("bounded diff is within_budget with no remediation", () => { + const result = assessChangeScopeBudget({ + changed_files: 6, + additions: 180, + deletions: 40, + commit_count: 3, + merge_commit_count: 0, + request_changes_rounds: 1, + }); + assert.equal(result.schema_version, CHANGE_SCOPE_BUDGET_SCHEMA_VERSION); + assert.equal(result.status, "within_budget"); + assert.equal("split_required" in result, false); + assert.equal(result.net_additions, 140); + assert.deepEqual(result.triggered_signals, []); + assert.equal(result.remediation, "none"); +}); + +test("net_subtraction exempts large cleanups up to 1500 additions", () => { + const result = assessChangeScopeBudget({ + changed_files: 80, + additions: 1500, + deletions: 4200, + commit_count: 45, + merge_commit_count: 4, + request_changes_rounds: 6, + }); + assert.equal(result.status, "net_subtraction"); + assert.equal("split_required" in result, false); + assert.equal(result.net_additions, -2700); + assert.deepEqual(result.triggered_signals, []); + assert.equal(result.remediation, "none"); +}); + +test("net_subtraction exemption stops above 1500 additions", () => { + const result = assessChangeScopeBudget({ + changed_files: 20, + additions: 1501, + deletions: 3000, + merge_commit_count: 3, + }); + assert.equal(result.status, "large_scope"); + assert.equal("split_required" in result, false); + assert.deepEqual(result.triggered_signals, ["repeated_mainline_merge_commits"]); + assert.equal(result.remediation, "verify_goal_proportionality"); +}); + +test("large_scope marks high-addition, multi-commit, merge, and ping-pong signals without mandatory split", () => { + const surface = assessChangeScopeBudget({ + changed_files: 35, + additions: 2500, + deletions: 2499, + }); + assert.equal(surface.status, "large_scope"); + assert.equal("split_required" in surface, false); + assert.deepEqual(surface.triggered_signals, ["excessive_addition_surface"]); + assert.equal(surface.remediation, "verify_goal_proportionality"); + + const spiral = assessChangeScopeBudget({ + changed_files: 8, + additions: 1200, + deletions: 1200, + request_changes_rounds: 5, + }); + assert.equal(spiral.status, "large_scope"); + assert.deepEqual(spiral.triggered_signals, ["review_ping_pong_spiral"]); + assert.equal(spiral.remediation, "verify_goal_proportionality"); + + const churn = assessChangeScopeBudget({ + changed_files: 8, + additions: 1200, + deletions: 800, + commit_count: 40, + }); + assert.equal(churn.status, "large_scope"); + assert.deepEqual(churn.triggered_signals, ["excessive_commit_churn"]); + + const mergesExempt = assessChangeScopeBudget({ + changed_files: 5, + additions: 800, + deletions: 900, + merge_commit_count: 3, + }); + assert.equal(mergesExempt.status, "net_subtraction"); + + const merges = assessChangeScopeBudget({ + changed_files: 5, + additions: 800, + deletions: 800, + merge_commit_count: 3, + }); + assert.equal(merges.status, "large_scope"); + assert.deepEqual(merges.triggered_signals, ["repeated_mainline_merge_commits"]); + + const mergesAboveCeiling = assessChangeScopeBudget({ + changed_files: 5, + additions: 1600, + deletions: 1700, + merge_commit_count: 3, + }); + assert.equal(mergesAboveCeiling.status, "large_scope"); + assert.deepEqual(mergesAboveCeiling.triggered_signals, [ + "repeated_mainline_merge_commits", + ]); +}); + +test("elevated_scope reports non-blocking diagnostic warnings", () => { + const largeSlice = assessChangeScopeBudget({ + changed_files: 10, + additions: 1000, + deletions: 200, + commit_count: 20, + merge_commit_count: 2, + request_changes_rounds: 3, + }); + assert.equal(largeSlice.status, "elevated_scope"); + assert.equal(largeSlice.remediation, "prefer_smaller_slice"); + assert.deepEqual(largeSlice.triggered_signals, [ + "elevated_addition_surface", + "elevated_review_rounds", + "elevated_commit_count", + "repeated_mainline_merge_commits", + ]); + + const wideEqualSlice = assessChangeScopeBudget({ + changed_files: 20, + additions: 400, + deletions: 400, + }); + assert.equal(wideEqualSlice.status, "elevated_scope"); + assert.deepEqual(wideEqualSlice.triggered_signals, ["elevated_addition_surface"]); +}); + +test("rejects negative, non-integer, and unsupported fields", () => { + assert.throws(() => + assessChangeScopeBudget({changed_files: -1, additions: 1, deletions: 0}), + ); + assert.throws(() => + assessChangeScopeBudget({changed_files: 1, additions: 1.5, deletions: 0}), + ); + assert.throws(() => + assessChangeScopeBudget({ + changed_files: 1, + additions: 1, + deletions: 0, + commit_count: -2, + }), + ); + assert.throws(() => + assessChangeScopeBudget({ + changed_files: 1, + additions: 1, + deletions: 0, + extra: 1, + }), + ); +}); diff --git a/tsconfig.control-plane.json b/tsconfig.control-plane.json index abe6435c8e..3f2a34bef6 100644 --- a/tsconfig.control-plane.json +++ b/tsconfig.control-plane.json @@ -128,6 +128,7 @@ "tests/control_plane_ts/test_python_runtime.test.ts", "tests/control_plane_ts/direction_authority.test.ts", "tests/control_plane_ts/direction_baseline.test.ts", + "tests/control_plane_ts/change_scope_budget.test.ts", "tests/control_plane_ts/material_wave_ranking.test.ts", "tests/control_plane_ts/zcode*.test.ts" ]