/oss:release audit splits dependency CVEs by release scope. run_audit_checks.py diffs the range's dependency manifests and lock files and passes the touched package names to parse_audit_json.py --introduced, which reports new and pre-existing vulnerable packages. A CVE new in the range is a critical finding (red flag, verdict BLOCKED); a pre-existing one stays a medium warning and never blocks alone.
/oss:release audit counts dependency CVEs only for packages the built distribution ships: [project].dependencies, non-dev optional groups and their transitive runtime requirements. Test, docs and other dev-only packages are listed as not shipped and never become findings; an unreadable or dynamic dependency set falls back to scanning everything and says so.
Sync write-guard.js: a protected file git already tracks no longer asks before a write, since the write is diffable and revertible; untracked, new and gitignored protected files still ask, and .claude/settings*.json and .pre-commit-config.yaml always ask.
Sync the adversarial-loop rule: reviewer briefs that run adversarial shell cases require case files written with a file-editing tool and fake gh/git binaries.
Keep review coverage and confidence gaps as factual limitations; require a specific user decision for additional review and omit declined requests from findings and final actions.
Write report-path test sentinels with LF on every platform so Git Bash reads valid paths on Windows.
/oss:resolve no longer hard-blocks a review report that fails intake. It runs find_review_report.py --assess, prints every gap graded critical (a lost, unbacked, duplicated or stale finding, a confirmed row resolve's merge would refuse, an ambiguous verdict, an unreadable sidecar, or a blocked/missing QA review under a claimed-complete report) or degraded (a wrong readiness or aggregate-outcome label, another reviewer's coverage gap, open-concern bookkeeping, a legacy report), and asks: proceed with the valid parts (offered only with no critical gap and no REJECT_ gate), rerun review for selected gaps, rerun in full, or abort. The review's report, sidecars and findings are never edited. Proceeding passes merge_action_items.py --accept-degraded for that report only; the verdict re-check stays strict, and the final report records the degraded intake and its gaps.
New /oss:review <N> --fill-gaps <report> --roles "…" --candidates "…": re-runs only the named reviewer roles and candidate checks against an unchanged PR head, carries every other record of the prior run into a new run, and publishes a confirmed candidate's missing finding row without re-validating it. fill_gaps_scope.py validates the selection, plans the run and verifies the carried records.
find_review_report.py --assess prints the graded gaps as one JSON line; exit 2 on any critical gap, exit 1 when the report path cannot be published, else 0 with the report path published. The line carries head_moved (true/false, or null when the run recorded no commit id or the PR head cannot be fetched); a moved head drops the targeted rerun from resolve's triage and recommends a full rerun.
--assess never under-grades a report the strict gate refuses: a completed reviewer without coverage, rationale or evidence is assessment-unbacked, a non-string candidate id candidate-invalid, any record rule no label correction satisfies ungraded-rule (all critical), and a refused report always shows at least one gap. A malformed sidecar grades sidecar-malformed instead of crashing, a legacy gate line other than PASS, BLOCK or REJECT_<GROUND> grades legacy-gate-ambiguous (critical), and the QA reviewer is recognised by one shared pattern (qa, security, test) in both grading and the fill-gaps unit map.
--fill-gaps refuses before any spawn unless the run it would publish can pass the publication gate. It checks the carried projection, which is the prior run minus the re-run roles and re-validated candidates, plus the rows to publish, with every other record verbatim. The check uses the gate's own record rules and varies only what the new consolidator may write. A refusal names the carried records to add to --roles/--candidates, or says that no addition can help. A sidecar, contract or open-concern gap that no rerun can repair is refused outright. The prior head-sha.txt must hold a 7–40 hex commit id. A named CONFIRMED candidate only gains its missing row when its record passes every rule and has no open concern; otherwise it is re-validated. Carried findings rows must also pass the producer row rules (merge-ready fields, unique ids): a failing row names its candidate as an addition, and a row naming no recorded candidate needs a full review.
New fill_gaps_scope.py triage --report=<report> | --assessment=<--assess JSON> prints whether resolve may offer a targeted rerun, plus the required and optional subjects, using the planner's own checks. It covers the recorded commit id, a moved head, a terminal REJECT, and whether the carried records can pass. Resolve's triage offers Rerun review for selected gaps only when the verdict is admissible and always includes the required subjects, so it never suggests a request the planner refuses. The one exception is a PR head that could not be checked: the rerun is still offered but not marked recommended, and the planner re-checks the head before any spawn. Triage also offers every rerun the planner would accept, adding any carried record the run needs to the required subjects; when the gaps lie outside every record (a header-only or aggregate-label defect), every recorded subject that plans alone is offered as optional. A QA or security role named by a gap is always required, and the rerun is not offered when that role cannot be named in --roles. Every refusal ends with a pointer to a full review. The verdict carries the resolved pr. When one optional subject sits beside required ones, or when more than 16 optional subjects are all of one kind, the user is asked instead of having it taken for them.
The fill-gaps projection lets the aggregate outcome follow its projected assessments, so a rerun can correct a mislabelled aggregate without re-running a healthy reviewer. Allocation refuses a --fill-gaps run that has no plan instead of falling back to a plain run. A null aggregate outcome beside a missing reviewer is now valid with Readiness: incomplete, because a missing reviewer outranks blocked; the strict gate and --assess apply the same rule.
--assess adds recorded_rejection, the report's Gate: REJECT_… line, even when critical gaps blank gate, and resolve's triage shows it. Deeply nested or malformed sidecars grade as gaps instead of raising RecursionError. fill_gaps_scope.py verify reports malformed plans and sidecars as problem lines, never a traceback.
mint_finding_ids.py --carry-from <prior findings.jsonl> keeps every carried row's id verbatim in a fill-gaps run, and a new row never takes a carried row's id. The consolidator passes it with the plan's prior_findings.
The strict gate requires an assessment role to be a non-empty string. merge_action_items.py blocks a findings row or link whose fields have the wrong type, instead of crashing.
The carry check and the publication gate share one consolidator re-spawn per run. Before that re-spawn the refused report is parked as review-report.refused.md, and a final refusal empties the report-dir sentinel, so the delivery hook never demands a refused report. A consolidator that publishes a REJECT_ gate itself fails the gate: only Stage 1's terminal publisher may publish a rejection.
Resolve's report-mode lookup no longer aborts under zsh when a report lineage holds no file; the printed fill-gaps command quotes the report path, and the subject follow-up question stays within 4 questions of 2–4 options each.
/oss:review now checks its own publication before printing it as finished: after the consolidator returns, it runs find_review_report.py --report --producer, which applies the same intake check /oss:resolve uses plus producer checks: the header must carry Review contract: 1, and every findings.jsonl row must carry the fields resolve's merge requires (id, section, severity, title, change, author), with a known severity word and no id shared by two rows. A consolidator-published REJECT_ keeps its own reject route and skips these row checks. A failing report gets one consolidator re-spawn with the failure reason; a second failure stops with ! BLOCKED instead of delivering a report that resolve would reject (for example Readiness: complete with open UNVERIFIED concerns, a blocked reviewer, or a CONFIRMED candidate without a findings.jsonl row). The gate and resolve's merge share one row rule, and merge_action_items.py --recheck-verdicts now blocks on a publication row it cannot use instead of crashing.
find_review_report.py names the broken rule on rejection: incomplete-review-report is followed by a [gate] reason: line (for example open candidate 'V13' (UNVERIFIED) under readiness=complete). gate_line() is unchanged; the new gate_verdict() returns the gate line and the reason.
Sync the cross-validation protocol and consolidator prompt: aggregate readiness: complete requires every assessment complete and no open concerns.
When /oss:resolve sends a review item to Codex to fix, hand it the CodeQL alert the item links: fetch_alert_context.py reads it in the calling session (the child has no network) and appends it to the brief as delimited untrusted data, only for alerts in the PR's own repository and the item's own file. The helper now also writes the item line, with the reviewer's comment fenced as untrusted, and always ends with one line, outside and after every block, naming the caller-fetched block tokens (none when nothing was fetched), so a comment cannot pass a forged section off as fetched data. An item whose path holds a line break, a control character or </>, or whose line is not a line number, is refused and takes the ordinary path; a path with spaces is written as a quoted JSON string. A failed fetch, an unresolved repository, an alert elsewhere, a foreign-repository link, a link past the cap or a code-scanning link on another host, in another form or with its number in other digits each append a notice so the child returns UNCERTAIN instead of guessing. Links with http://, www. or a different host case are fetched too. Inside a fence, marker-shaped spellings get a word joiner inserted, never consumed, so identifiers and paths that merely mention them stay verbatim. The spellings, and alert links, are found on a folded view (format characters and invisible marks dropped, dashes unified, NFKC), so in-word zero-width, fullwidth and dash look-alike spellings cannot slip through; the comment itself reaches the child unchanged apart from the inserted joiners.
Require full_comment_text to keep the comment body verbatim, links included.
Drop the Suggestion column from the resolve report's Challenge Log; Resolution is the outcome, and suggestion_why stays in challenge-log.txt.
Sync the quality-gates rule: after each validated adversarial-loop round, print the progress table exactly, with all rows kept and each cell as old + new.
Stop the resolve picker from restating items the printed table and item options already show: the bulk question carries counts, notices and the saved table path, and the group-preview question carries the group count and path.
Make enforce-resolve-table.js require the saved table file (every pending and closed id as its own cell) instead of item lines in the question text.
Fix review validation publication: the reviewer instructions now require string-array assessment evidence and limits, open concerns only for UNVERIFIED or pending candidates, and no complete readiness beside an open candidate; the report intake gate accepts a single string for evidence and limits.
Show reviewer names and finding authors as roles only, using square-bracketed scores (Software engineer [3]); keep execution provenance in evidence and limits, omit skipped roles, and render a null score as [no source judgment].
Add owner-stamped atomic compaction contracts and boundary metadata; call Foundry's compaction gate when present and continue with an explicit fallback when absent.
Route medium- and high-effort single-file code, test, documentation, style, configuration and CI items to bridge:implement; keep architecture, performance, refactor and extra-high-effort work with specialists.
Ask follow-up questions with plain report path, title and outcome text within 1,500 characters; print the complete header in the final reply and remove duplicated option previews.
List pending resolve items in question text, using top items, exact type counts and the saved complete inventory when the budget is exceeded; print the full table once before selection.
Read pinned PR-head source in early challenges even after a clean merge, keeping freshness verification and source reads on the same revision.
Validate every review candidate at every severity before publication; write a version-one validation envelope separating source judgment, readiness, reviewer coverage and open concerns.
Keep missing reviewers and undecidable judgments distinct from rejection, retain all confirmed findings, and require compatible validation intake before resolve merges them.
Preserve VALID, affirmative REJECT, UNVERIFIED and ALREADY_FIXED evidence states through resolution; unverified items remain pending with an owner and next check, while already-fixed history needs revision-bound proof.
Recheck carried verifier and parent evidence against the source revision actually consumed by each resolve wave and preserve independent provenance across Git Bash paths on Windows.
Remove broad GitHub API allow and write-deny entries that conflict with Foundry's guarded read and approval lanes; use explicit GET for ecosystem search requests.
Include the optional GitHub-read lane in Bash audit verification.
Ask separately about target drift and then obtain a single-use push approval for the concrete scope; retain explicit skip and manual-push recovery outcomes.
Keep finding collection and selection in one stream with no conflict agent running beside the picker.
Start conflict resolution and read-only early challenge together after selection; early challenge reads pinned PR-head source, while implementation waits for conflict completion.
Preserve pending items and release the mutex on an unanswered group gate instead of choosing a silent default.
Assemble vitality datasets and compute rubric metrics in Python so large JSONL lines cannot disappear through truncated source reads.
Distinguish failed fetches, valid empty datasets, permission-limited alerts and pending contributor statistics; preserve missing-data confidence caps and compare unrounded metrics.
Fetch repository community and workflow evidence through bounded helper calls and carry extractor-applied bands, scores and confidence deductions into scorer output.
Keep every low finding as its own action item and table row, while bounding resolve challenge and implementation work by group rather than total selection size.
Process every selected resolve item in the same pass instead of imposing an item cap; bound challenge chunks to twelve items and implementation groups to five.
Persist predictable selection, grouping, dispatch and push decisions before unattended implementation and retain exact selected IDs in report mode.
Recheck target-branch freshness before QA and again before push, remerge and revalidate when the target advances, and report unverifiable freshness explicitly.
Keep non-fast-forward push recovery manual instead of repeating merge or push operations unattended.
Build grouped resolve subjects as valid Conventional Commits, preserving a single item's typed subject and deriving shared type/scope for multiple items.
Show the action inventory once immediately before selection and account for transcript flush delay before denying a report-table gate.
Enforce report-header delivery at Stop as well as follow-up questions so skipping the picker does not omit the report.
Keep reviewer ratings, legend, aggregate summary and findings overview in the delivered review, and report explicit confidence deductions in resolve handoffs.
Bootstrap Python without requiring Python to start the launcher: provide POSIX and native Windows entry points, probe supported runtimes, execute the workload once and preserve its exit status.
Run adversarial ledger checks through the packaged portable launcher.
Publish stable finding IDs and structured review handoffs, merging them into GitHub action items without losing unmatched findings or contributor attribution.
Persist resolution and release provenance as append-only ledgers with separate mutable headers.
Gate resolve selection on visible action-table delivery and choose lighter review only when changed symbols and transitive callers stay in tests or leaf modules.
Ground release truth checks in exact baseline and HEAD source coordinates, distinguishing a candidate binding from public-export proof and keeping uncertain absence qualified.
Reconcile typed breaking-change counts with individual evidence ledger entries before classification approval.
Capture the caller branch before resolve checkout and keep release append merges staged at stable user-visible artifact paths.
Warn when a running session uses an older plugin root than the active install.
Refold appended release summaries into a short hook, real user wins and an upgrade call; revalidate the final merged draft against current source and migration documentation.
Recognize conventional revert subjects as well as Git's default format and require evidence links for added changelog entries.
Retry a colliding worktree name once with a disambiguator and inspect stale worktrees only when the remaining failure actually names a candidate.
Overlap PR intelligence with checkout and trial merge, then overlap conflict resolution with item selection when their inputs are independent.
Replace Fine dispatch with Per specialist and Custom choices; per-specialist dispatch removes the five-item split while retaining ownership and coupling rules. Document each skill's actual fan-out and gate structure.
Let resolve users choose automatic, sequential, finer or previewed specialist dispatch, changing wave width while preserving file ownership and routing.
Enforce model-tier wave ceilings and show real formed groups only on the requested preview path.
Deliver one quality-rule variant per plugin, using OSS deltas when the Foundry shared rule is present.
Accept approved review outcome tokens with their optional leading verdict symbol during resolve intake, preserving rejection and incomplete-report checks.
Require a complete current report-header table before analyse or review follow-up, preserving diagnostic questions when delivery fails.
Block resolve intake on incomplete reports or failed report-path publication and keep implementation tasks open until every child reaches an explained state.
Load structural gates from the active registry-selected codemap-py installation, skipping orphaned cache versions and removing the local contract copy.
Remove the semantic companion --semble path and keep structural context or source reads as the supported review routes.
Resolve and gate a saved review report once before remediation, distinguish rejected or incompatible lineage, and reuse it instead of starting another review.
Group resolve commits by domain, file or specialist according to the selected strategy.
Store PR reviews under .reports/review/pr-<N>/run-<NNN>/ and allocate increasing run directories; resolve finds the newest report for the requested PR.
Fetch review bodies and inline comments independently, including collapsed findings, and refresh them even when the primary PR thread cache is reused.
Build release contributors from Git authors, coauthors and verified in-range PR authors, including bots when requested; use paginated commit-to-PR associations instead of merge dates as range proof.
Preserve historical changelog entries and remove only exact confirmed stale Unreleased claims for unshipped reverts or pivots.
Require independent review and targeted fixes in a bounded weighted convergence loop; never present a final local fix as independently verified before a later review.
Resume background agents from completion notifications instead of polling, and preserve partial or timed-out results explicitly.
Choose host-valid private temporary directories for commit authorization and preflight, avoiding POSIX paths interpreted as native Windows locations.
Remove location duplication from resolve inventory columns and label discussion rows pending · thread (no GH resolve) so they are not mistaken for resolvable inline threads.
Enforce strict scope exits for unrelated content and use concrete severity criteria in thread analysis.
Run a second quality pass only for a named actionable evidence or coverage gap; preserve caller-visible fixes that should not disappear into same-release feature deduplication.
Fetch one PR snapshot and reuse its metadata, checks and diff throughout review, including helper signal analysis.
Batch disjoint-file Bridge candidates while retaining per-item commits, and combine item and commit choices into one question call when the inventory fits.
Cap independent verifier agents and group compatible critical findings for verification.
Replace legacy Codex plugin calls with bridge:review and bridge:implement, checking installed, disabled and absent states before use.
Keep complex resolve work explicitly skipped when Bridge is unavailable, allow an explicit implementation-agent override, and retain independent vitality and release auditing through Bridge.
Standardize shared contract and Markdown formatting, including skill compaction state and review output instructions.
Add a cheap PR acceptance gate before full review: terminal rejection needs affirmative evidence for a defined ground, while blocking concerns continue to source review.
Record the acceptance decision and reviewed SHA in report metadata so resolve can detect a changed PR before acting on a rejection.
Stop treating cherry-pick or stable-branch release history as unexplained scope drift; inspect merge ancestry and distinguish raw branch merges from reviewed PR merges.
Verify release classification against actual changes instead of trusting fix: or feat: labels.
Extract shared flag parsing and changed-symbol extraction to reduce repeated shell and prompt work.
Require reviewers to consult existing structural answers first, limit extra queries and stop repeated lookup when the provider reports a complete answer.
Preserve all resolve commit choices and enforce actual report-table delivery before marking header printing complete.
Add /oss:setup to deliver plugin-owned rules as namespaced symlinks, validating sources before mutation and refusing to overwrite unowned destinations.
Validate commit IDs and structural module paths before they reach Git commands or cache paths; make report-path handling portable across Windows and POSIX.
Preserve low and cosmetic report findings during resolve extraction rather than silently dropping items already present in the source report.
Keep CI reruns, tag pushes and release creation human-owned and remove subagent-local task tracking that the parent cannot observe.
Add release --append: rerun the pipeline for newly landed commits and merge evidence-backed additions into existing artifacts.
Track processed commits, invalidate markers that are no longer reachable or have been superseded by a release tag, and reconcile earlier entries when later changes revert or replace them.
Guard whole-file summary and migration merges against accidental content collapse and reuse resolved contributor identities.
Use No.N for local item ordinals and full issue or PR URLs for cross-repository references, avoiding accidental GitHub links and reviewer pings in attribution.
Verify factual claims about names, versions, identifiers and counts before a resolve challenger marks them valid; reserve a source lookup when the referenced code cannot settle the claim.
Add opt-in --worktree isolation for PR review and resolution, keeping checkout and implementation off the invoking worktree and reporting the isolated path on exit.
Normalize pass, warning and failure symbols across analysis, release and review reports.
Add change-set diff-impact context and fix module iteration under zsh; stop issuing function queries with module-only names and use module reverse dependencies for importer context.
Scope temporary workflow state by session ID across analyse, release, review and resolve so concurrent sessions do not overwrite each other's flags, timestamps or paths.
Move reusable preflight state under .temp/state/preflight/.
Move the plugin source directory from plugins/oss to plugins/cc_oss and update helper, shared-document and skill fallback paths while retaining the oss plugin identity.
Dispatch independent resolve changes to specialist worktrees, retaining sequential Codex-first work and deterministic merge ordering by structural centrality.
Guard a resolve run with a branch mutex and HEAD fingerprint so concurrent runs or external branch changes cannot silently corrupt integration.
Map report sections to implementation categories and gate selections larger than twenty items before dispatch.
Bind reproduction dispatch to the selected role: QA for test examples, software engineering for other or ambiguous examples, and general-purpose only when Foundry is absent.
Add optional structural signals to thread triage and vitality, including candidate-symbol lookup, overlapping PR files, coupled modules and repository constraints.
Cache review structural queries by index state and classify release breaking changes with caller-package evidence.
Load only the assigned vitality scoring-group rubric instead of sending every scorer the complete thirteen-axis reference; label unassigned axes explicitly.
Batch compatible resolve work and clarify CI, documentation and release-agent scope to reduce unnecessary delegation.
Build a session-scoped agent index and route missing roles through local semantic matches, using OpenAI embeddings when configured or an Anthropic selection fallback before general-purpose dispatch.
Require shepherd's inline-suggestion table whenever findings identify file and line locations; verify the reply file and retry missing required content.
Block consolidation when the Agent tool is unavailable, preserve all readiness rows in release preparation, and use short PR references in draft notes.
Pass structural context to every applicable review dimension, including function blast radius and affected tests, rather than only the software reviewer.
Label discussion action items as lacking a GitHub resolve button in the selection UI.
Correct release mode detection, handle unknown flags explicitly and ask before using the initial commit when no stable tag exists.
Extract release truth checking and review scope, reviewer and consolidator prompts into dedicated files; run independent changelog audit and contributor extraction together after their prerequisites.
Separate resolve bulk item selection from commit-mode selection and use compact selection for large inventories.
Split PR and report intelligence and batch execution into resolve modes, requiring a result for every selected item and keeping user questions and task ownership with the parent.
Repeat lint and QA after fixes and block publication when blocking findings remain after three iterations.
Route documentation PRs to the documentation reviewer and preserve dedicated CI routing; override small-diff classification when refactor or performance intent demands deeper review.
Enforce sequential release phases, net-state classification, contributing-PR accumulation and explicit failure handling before downstream artifacts are produced.
Enable resolve structural context when an index is available, with --no-codemap to disable it and strict --codemap preflight when explicitly requested.
Compare documentation coverage of a significant release feature with similar existing features, including headings, explanation and examples.
Require concrete diff locations for review findings and primary evidence or independently corroborated experiments for external-standard claims.
Mark capped GitHub responses partial, distinguish null fields from missing fields, and keep real CI results separate from workflow or badge presence in vitality scoring.
Resolve review resources from the installed plugin before falling back to the checkout.
Preserve permission-denied and pending GitHub datasets as explicit partial evidence; guard zero-sample responsiveness and use one analysis timestamp for age calculations.
Fail immediately when shared initialization is invalid, derive the release trunk from repository metadata, and retain human ownership of public GitHub changes.
Expand vitality scoring to thirteen axes and recalibrate weights and response thresholds; detect stale-bot inflation instead of treating every closure as maintainer responsiveness.
Distinguish resolvable inline review threads from discussion comments and report findings; mark discussion items done only with evidence of a subsequent answer or fix.
Persist analyse drift and scraper time-window values across shell calls.
Check for existing helpers before accepting new abstractions, flag oversized review scope, and retain praise and learning notes after defect findings in contributor replies.
Persist authoritative action-item details in the implementation handoff and scan caller blast radius once before dispatch.
Preserve PR motivation and labels in resolve context, default ambiguous comment work to software engineering, and recompute authorization paths before cleanup.
Preserve resolve's selected commit mode across the full item loop without re-asking; make bulk and lint commits manage their scoped authorization cleanup.
Add change-category and severity fields to resolve action items for implementation routing.
Run PR checkout and conflict resolution even when no action items are selected; route available fallback implementation by change category while explicitly skipping unsupported complex work.
Extract vitality score assembly and variable loading into Python helpers, renormalizing unavailable axes and loading all report variables in one JSON pass.
Extract release setup, audit, GitHub fetching and resolve commit/staging operations into packaged helpers.
Keep partial GitHub datasets explicit and validate Action SHA lookups before using them.
Harden resolve parser output before sourcing it, refuse default-branch PR checkouts, and require a target-specific push confirmation.
Restore pre-item stashes on exit paths and centralize staging in a dedicated helper.
Route mixed documentation and CI PRs to the relevant two reviewers.
Parse resolve findings by contained section names, including numbered review headings.
Refresh the review health checkpoint when output advances so active reviewers are not marked stalled; expose GitHub rate-limit evidence to the scraper.
Recognize security-intent commit bodies during release classification and link public advisories without exposing vulnerability identifiers in public notes.
Explicitly support documentation and CI configuration PRs alongside Python review, while rejecting unsupported source-only languages.
Require explicit confirmation for a detected unannounced breaking change, stating the former behavior, new break and reason; prior deprecation followed by removal remains a separate classification.
Remove the separate Comment column from resolve inventories.
Launch linked-issue agents and Codex review in one batch; keep vitality report formatting and adversarial review with the orchestrator.
Expand literal values in delegated prompts, verify shepherd output exists, and print only the corrected release classification table after self-review.
Restore stashed changes before resolve commits so conflict markers cannot enter a committed result.
Use all CI runs as the pass-rate denominator, classify test and CI dependency alerts separately from runtime exposure, and compute active CODEOWNERS from commit evidence.
Require silence rate in responsiveness scoring and keep independent vitality review grounded in raw data.
Calibrate resolve effort per item and skip QA only when every selected change is limited to lint, typing, documentation or formatting.
Split vitality into a GitHub data scraper and three parallel axis scorers, with raw JSONL, partial scores, a shared rubric and a structured report template.
Keep shepherd communication draft-only and separate public reply drafting from direct GitHub publication.
Scope analyse caches by repository and extract review parsing and release templates into reusable files.
Replace repository health mode with vitality analysis, using timestamped GitHub evidence and weighted axes for maintenance, community, quality and security.
Reject unsupported review and release flags with the supported syntax; make skill triggers and scope redirects explicit.
Classify removal after a prior deprecation as Removed; reserve Breaking Changes for an immediate unannounced public break, and include migration examples for deprecations and removals.
Seed reviewer prompts with a bounded Codex finding list and expand output-path variables before dispatch.
Make structural and semantic review context opt-in through --codemap and --semble; fail preflight with setup guidance when an explicitly requested provider is unavailable.
Detect stable release branches from their first-parent tag and annotate cherry-picked changes in release classification.
Read resolved PR review-thread status when gathering action items, and allow simple resolution items to use a software-engineer fallback when Codex is unavailable.
Make skill boundaries explicit: analyse gathers evidence, resolve implements PR feedback, and review rejects unsupported source-language PRs.
Add adversarial PR review with an optional --no-challenge flag, task tracking, and a fallback challenger role when Foundry is absent.
Ask for confirmation when a report path is supplied to analyse without --reply; render resolve action inventories as Markdown tables with explicit status and notes.
Check documented behavior changes against deprecation requirements and keep narrowly scoped reviews focused on the requested surface.
Share one shepherd reply protocol between analyse and review; analyse replies now use the same summary and inline-suggestion format as PR review replies.
Introduce OSS thread, repository-health and ecosystem analysis; GitHub PR review; review-action resolution and conflict handling; and release notes, changelog, migration and readiness workflows.
Ship shepherd and CI specialist agents, with plugin-prefixed cross-plugin dispatch and general-purpose fallback roles when companion plugins are unavailable.
Restrict /oss:review to GitHub PRs; route local file and diff reviews to /develop:review, and check issue/discussion reproductions before reporting.
Track resolve action items and merge conflicts as tasks; add optional structural context for reviewers and keep public releases behind a human handoff.