claude-dev-env 8.11.1 → 8.12.0

package/.agents/skills/e-code-review/reference/loop.md

@@ -1,261 +0,0 @@
-# Loop until clean
-
-## Preflight-proposal mode
-
-When the hub selects `preflight-proposal`, continue the review loop with the established proposal context. Proposal mode ends with proposal evidence. Normal mode keeps its GitHub disclosure and Ready actions.
-
-## Act
-
-`loop` on the hub command authorizes the full cycle. After the effort level procedure returns findings, run the gate sequence below immediately.
-
-Do not ask whether to fix, which nits to keep, whether to commit or push, or whether to re-review. Do not open a plan fork. Do not end the turn on a recommendation.
-
-Report progress while you work. Stop for the user only on a terminal outcome below.
-
-## Where fixes come from
-
-A round always applies fixes. Gate 2 below is the only place a round applies a
-fix. `--fix` chooses the mechanics. With the flag, Gate 2 loads
-`reference\fix.md` (relative to this skill's folder) for which agent applies
-each fix, agent resume, the code-rules gate, skip logging, and outcome
-reporting. Without the flag, this session applies each fix itself.
-
-The gate sequence still decides whether a round fixes, commits, pushes, and
-re-reviews.
-
-## Scope stays narrow
-
-Auto-fix only verified findings on the review target. Leave deferred PR-body follow-ups and unrelated refactors alone.
-
-## How to class each finding
-
-Every retained finding carries a verified `severity` and a verification
-`verdict` (`CONFIRMED` or `PLAUSIBLE`). The frozen severity set is exactly
-`blocker`, `high`, `medium`, `low`, `nit`.
-
-A finding is a `nit` only when that severity is `nit`. Runtime-correctness,
-security, data-loss, compatibility, and every other non-nit finding is a
-`bug`.
-
-A finding that lacks severity is **unclassified**. Consult the assigned
-advisor to classify it before Gate 2. When that advisor is unreachable,
-terminate with `advisor_blocked` and preserve draft state.
-
-A finding this document has already classed keeps that class at every level. An
-on-target shape-reader break is `bug` under *A shape change names its readers*;
-no advisor call reopens that.
-
-## Required checks
-
-"Run required checks" means: run
-`python ~/.claude/_shared/pr-loop/scripts/code_rules_gate.py --repo-root <repo root>`
-with no file paths and no `--only-under` prefix. The `python` prefix is
-required. On Windows a bare `.py` path opens the file in Cursor, which then
-crashes on the gate flags. On a violation on lines this
-round already owns, fix it and re-run the exact same command until clean. A
-violation outside the review target is reported or skipped, not force-fixed into
-unrelated files, and the skip is logged with path and reason.
-
-That bare call gates the git diff since the merge-base (and any staged added
-lines the gate already includes). Working-tree lines that are neither staged
-nor committed sit outside that scope until they are staged or committed. Gate 2
-leaves its edits uncommitted, so the round tail stages those edits before
-required checks when this round produced edits.
-
-Two failure scenarios keep the call bare. A file path named on the command line
-puts the gate in whole-file scope on that file: a CODE_RULES violation on a line
-this round never touched fails the round and churns the loop. An `--only-under`
-prefix that matches nothing in the diff leaves the gate zero files to inspect and
-exits clean, so a run that inspected nothing reads as a pass.
-
-## Each round reviews new code
-
-A repair diff is new code. From the second round on, the round runs the level
-file end to end at the new head. End to end means that file's review phases, up
-to and including its findings report; the round stops there and brings those
-findings back to the gate sequence below. It does not run the level file's
-*Looping* section. That section hands control to this document, and the round
-is already inside it. The round's scope is the level's own review
-target, the diff or path the level gathers up front, called Phase 0 in
-`medium.md` and `xhigh.md`, taken against that target's base. A repair edit
-landing outside that target widens the next round's scope to cover it: the next
-round's review target is the original target **plus** that path, and the round
-reviews both. A later widening adds to that target the same way.
-
-The widened target is what the round hands the level file. When a round runs the
-level file end to end, it passes the current review target (the original target
-plus every path a widening has since added) as that run's target argument, in
-place of the argument the first round was given. When the first round was given
-no target argument, the original target is the item `default-range`, the level
-file's own default gather, so the widened target is `default-range` plus every
-added path, and the range the first round reviewed stays in scope. The level
-file gathers what the round hands it, so a widened path is gathered and reviewed
-like any other part of the target.
-
-## Dangerous diffs take two full rounds
-
-A diff is dangerous when it touches deletion paths, locks or other concurrency
-control, or shared mutable state. A deletion path is a runtime path that removes
-data or files; a dead-code cleanup is not one. Each round names whether the diff
-it reviewed is dangerous. A dangerous diff holds the loop open until two full
-rounds have reviewed it. A repair that rewrites the dangerous surface restarts
-the two-round count at the first round that reviews the rewritten surface.
-
-The round's progress report is where both facts are recorded: the dangerous
-classification, and the dangerous-round count written as `N of M`.
-
-## A shape change names its readers
-
-When a repair changes a key, an identifier format, or a data shape, list every
-reader of the shape it changed and state how each one reads the new shape. The
-list goes in the round's progress report.
-
-The round that follows a posted list checks each reader on that list against the
-new shape and names each reader with its result in that round's progress report.
-
-Discharge then turns on where the reader sits.
-
-- An **off-target** reader discharges once it is named with a result. This
-  branch cannot repair it.
-- An **on-target** reader that reads the new shape correctly discharges on that
-  result.
-- An **on-target** reader that reads the new shape wrong is a bug-severity
-  finding of the round that checked it. It joins that round's findings, and it
-  discharges on exactly one of three results, each of them an outcome gate 2
-  already produces: it is repaired, it is recorded as a skipped finding, or the
-  advisor refutes it. Naming the break discharges nothing on its own, and
-  neither does a further round merely happening.
-
-The list discharges once every reader on it has discharged.
-
-A broken reader outside the review target does not block the loop and does not
-widen scope. Hand it off as a reported finding. Two separate things are owed for
-that hand-off, and they land at different times:
-
-- **The round-scoped record.** What a round produces. Check the reader, record
-  its result, and name it in that round's progress report. All three are done
-  inside the round that checks the reader, and nothing outside that round is
-  needed to complete them. This is the record gate 2 reads.
-- **The termination-time disclosure.** What terminating requires. The
-  ready-for-review message names every broken off-target reader and every
-  skipped finding that still exists, and the pull request body carries the same
-  names when the target is a pull request. A target with no pull request owes
-  the ready message alone. Gate 3 enforces this at the moment the loop
-  terminates; no earlier round owes it.
-
-## Terminal outcomes
-
-The loop emits exactly one of these terminals when it stops:
-
-| Terminal | When |
-|---|---|
-| `clean` | Zero retained findings on the current head, and required checks pass |
-| `nits_fixed` | Every retained finding is a nit with severity and a retained verdict, every nit is fixed, and required checks pass |
-| `advisor_blocked` | Classification needs the assigned advisor and that advisor is unreachable |
-
-Every round does this round's own work first, then runs the three gates below,
-in order: gate 1, then gate 2, then gate 3.
-
-**This round's work, before the gates.** Record this round's dangerous
-classification and the dangerous-round count as `N of M`; and when a shape-change
-list is open, check each reader on that list and name each reader with its
-result, adding any on-target reader that reads the new shape wrong to this
-round's findings as *A shape change names its readers* directs. Then run the
-gates.
-
-**Gate 1, obligations.** Gate 1 is evaluated first in the sequence, and its
-answer turns on the round's open obligations alone. The findings are in hand by
-now, and no content they carry changes it. Ask only: does any obligation remain
-open? Two kinds exist.
-
-- A dangerous diff that has had fewer than two full rounds.
-- A posted shape-change list that no round has discharged.
-
-Gate 1 states its answer and stops there: an obligation remains open, or none
-does. It states no re-entry, no continuation, and no routing. Gate 3 is the sole
-router. Every path out of a round passes through it.
-
-**Gate 2, findings.** When `--fix` is set, load `reference\fix.md` here and
-follow it for the mechanics of every fix this gate applies: the fix agent,
-agent resume, the code-rules gate, skip logging, and outcome reporting. When `--fix` is
-absent, apply each fix in this session yourself, and log each skip in this
-round's progress report. Then take the one case that matches the round's
-findings.
-
-- Any bug-severity finding: validate each bug with an advisor before touching
-  code. Confirm the bug exists and confirm the intended fix, then fix every
-  validated bug and every nit on the review target. A refuted bug removes only
-  itself from the round's work; the nits are fixed either way.
-- Nits only, with at least one nit present: fix all of them on the review
-  target.
-- No findings at all: make no edits.
-
-Gate 2 then ends by stating one of exactly two outcomes: unresolved findings
-remain, or none remain. A refuted bug is resolved. A fixed nit is resolved. A
-fixed validated bug is resolved. A handed-off off-target finding is resolved once
-this round has made its round-scoped record as *A shape change names its readers*
-defines that record (checked, result recorded, named in this round's progress
-report), whether or not the problem behind it is solved. Gate 2 reads the record
-and nothing else; the termination-time disclosure belongs to gate 3.
-
-A skipped finding, a finding deliberately not applied because fixing it would
-change intended behavior, would reach beyond the review target, or the finding
-itself is judged a false positive, is resolved once its skip is logged in this
-round's progress report, naming the finding and the reason it was skipped. That
-report is the sink every run has, with or without `--fix`. When `--fix` is set,
-the skip handling `fix.md` carries runs inside this gate and adds to this log
-rather than replacing it.
-
-Gate 3 reads that stated outcome, never a case label.
-
-**Gate 3, exit test.** Resolve the terminal from the table above, then stop or
-continue:
-
-- zero retained findings and required checks pass → `clean`;
-- nits only (each with severity and a retained verdict), all fixed, required checks pass → `nits_fixed`;
-- advisor needed for classification and unreachable → `advisor_blocked`;
-- otherwise continue.
-
-Also require, for `clean` and `nits_fixed`:
-
-- gate 1 shows no open obligation;
-- gate 2 states no unresolved findings remain;
-- this round produced no edits after the gates settled.
-
-Any other combination runs the round tail and re-enters the loop.
-
-Terminating with `clean` or `nits_fixed` carries one further condition, the
-termination-time disclosure: the ready-for-review message names every broken
-off-target reader and every skipped finding that still exists. When the target
-is a pull request, the pull request body carries the same names; a target with
-no pull request owes the ready message alone. Every surface this condition
-names is written at termination, the ready message always, the pull request
-body too when the target is a pull request, so each one is available to the
-terminating round. A round that cannot name them does not terminate; it runs
-the round tail and re-enters the loop, the same as any other non-terminating
-round. With that condition met, post the proof-of-work PR comment when the
-target is a PR, then run `gh pr ready` for a draft PR, or state ready
-otherwise.
-
-`advisor_blocked` keeps the pull request draft. It does
-not run `gh pr ready`. It reports every surviving structured finding.
-
-Gate 3 points at gate 1 for the obligation answer. It does not restate the
-two-round rule or the shape-reader rule; each of those keeps its one home in its
-own section above.
-
-**The round tail.** Every round runs required checks here, in the one form
-*Required checks* gives: the bare command, no file paths. When this round
-produced edits, stage those edits first so they enter the bare gate's scope,
-then run the checks. When this round produced no edits, run the same checks.
-Should those checks produce repairs, this round has produced edits. Stage
-them and re-run the checks.
-
-**Commit and push are lead-owned.** Gate 2 and the round tail leave every fix
-unstaged-or-staged in the working tree for the lead that owns the branch. A
-fix agent, patch worker, or resumed finding agent never creates the commit and
-never pushes. The lead stages, commits once per review round, and pushes after
-the gates pass. Start the next round under *Each round reviews new code* only
-after that lead commit lands a new head.
-
-Do not drop findings to force ready. Without `loop`, run one review at the selected level, fix, and return every validated finding.

package/.agents/skills/e-code-review/reference/mode-contract.test.mjs

@@ -1,67 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import test from 'node:test'
-
-const proposalSource = readFileSync(new URL('./preflight-proposal.md', import.meta.url), 'utf8')
-const fixSource = readFileSync(new URL('./fix.md', import.meta.url), 'utf8')
-const loopSource = readFileSync(new URL('./loop.md', import.meta.url), 'utf8')
-
-function sourceBetweenHeadings(source, fromHeading, toHeading) {
-  const fromOffset = source.indexOf(fromHeading)
-  const toOffset = source.indexOf(toHeading, fromOffset)
-
-  assert.ok(fromOffset >= 0)
-  assert.ok(toOffset > fromOffset)
-
-  return source.slice(fromOffset, toOffset)
-}
-
-function assertReviewLevelExtension() {
-  assert.match(proposalSource, /<review_level> --fix loop/)
-  const allReviewLevelMappings = [
-    ['Omitted override', 'low'],
-    ['`low`', 'low'],
-    ['`medium`', 'medium'],
-    ['`xhigh`', 'xhigh'],
-  ]
-
-  for (const [eachCallerSelection, eachLevel] of allReviewLevelMappings) {
-    const expectedRow = `| ${eachCallerSelection} | \`${eachLevel}\` |`
-    assert.match(proposalSource, new RegExp(expectedRow.replaceAll('|', '\\|')))
-  }
-  assert.match(proposalSource, /`review_level` evidence mirrors the resolved `--level` value/)
-}
-
-function assertProposalHandoffs() {
-  assert.match(proposalSource, /This file owns the proposal contract for `e-code-review`/)
-  assert.match(proposalSource, /exact `base_sha\.\.\.head_sha` range/)
-  const fixModeSource = sourceBetweenHeadings(
-    fixSource,
-    '## Preflight-proposal mode',
-    '## Resume the finding agent',
-  )
-  assert.match(fixModeSource, /consume the established proposal context/)
-  assert.doesNotMatch(fixModeSource, /follow \[preflight-proposal.md\]/)
-  const proposalModeSource = sourceBetweenHeadings(
-    loopSource,
-    '## Preflight-proposal mode',
-    '## Act',
-  )
-  assert.match(proposalModeSource, /continue the review loop with the established proposal context/)
-  assert.doesNotMatch(proposalModeSource, /follow \[preflight-proposal.md\]/)
-  assert.match(proposalModeSource, /Proposal mode ends with proposal evidence/)
-  assert.doesNotMatch(proposalModeSource, /proof-of-work PR comment|gh pr ready/)
-  assert.doesNotMatch(proposalSource, /proof-of-work PR comment|gh pr ready/)
-}
-
-function assertNormalTerminationContract() {
-  const normalTerminalSource = loopSource.slice(loopSource.indexOf('## Terminal outcomes'))
-  assert.match(normalTerminalSource, /proof-of-work PR comment/)
-  assert.match(normalTerminalSource, /gh pr ready/)
-}
-
-test('preflight proposal mode isolates review loops and preserves normal termination behavior', () => {
-  assertReviewLevelExtension()
-  assertProposalHandoffs()
-  assertNormalTerminationContract()
-})

package/.agents/skills/e-code-review/reference/preflight-proposal.md

@@ -1,75 +0,0 @@
-# Review preflight proposal mode
-
-This file owns the proposal contract for `e-code-review`.
-
-Use this review mode when the caller selects `preflight-proposal`:
-
-```text
-/e-code-review preflight-proposal <pr_number> --level low --base-sha <base_sha> --head-sha <head_sha> --worktree <isolated_worktree>
-```
-
-## Required inputs
-
-| Input | Contract |
-|---|---|
-| `pr_number` | Resolved open pull-request number |
-| `--level` | Resolved review level: `low`, `medium`, or `xhigh` |
-| `--base-sha` | Full immutable base commit SHA |
-| `--head-sha` | Full immutable head commit SHA |
-| `--worktree` | Caller-supplied isolated worktree path |
-
-## Proposal contract
-
-1. Validate every required input before the first review command.
-2. Run `git rev-parse HEAD` in the supplied worktree and require exact equality with the head SHA.
-3. Gather changed paths and review scope from the exact `base_sha...head_sha` range. Use the resolved pull-request number for pull-request metadata.
-4. Run the complete selected review and findings against the immutable range and worktree.
-5. Keep every review edit and test inside the caller-supplied isolated worktree.
-6. Create an immutable proposal identity. Use the existing commit SHA for committed proposals. For working-tree edits, use a deterministic diff hash over the baseline `HEAD` SHA, base SHA, head SHA, sorted normalized changed paths, status records, and file bytes.
-7. Record every changed path, including tracked, untracked, renamed, and deleted paths.
-8. Record exact tests and outcomes: each test command, exit code, and outcome.
-9. Return selected-candidate-ready proposal evidence with the proposal ID, isolated worktree path, changed paths, findings, tests, and outcomes.
-10. Keep commit, push, pull-request body, pull-request comment, pull-request review, pull-request update, merge, rebase, and Ready-state mutations disabled.
-11. Return the proposal for downstream disposition. The downstream owner adds the proposal ID to its selected or dispositioned proposal collection. Reapplication uses exactly the selected records and their changed paths. Give each later finding a new proposal ID and evidence record.
-
-## Review extension
-
-The caller resolves the review level before invocation and always passes `--level`. Use this mapping:
-
-| Caller selection | Resolved `--level` |
-|---|---|
-| Omitted override | `low` |
-| `low` | `low` |
-| `medium` | `medium` |
-| `xhigh` | `xhigh` |
-
-The `review_level` evidence mirrors the resolved `--level` value.
-
-Run the selected level as `<review_level> --fix loop`. The selected level owns its normal finding and fix rules. Require `HEAD` to equal the supplied head SHA before each round.
-
-Keep Gate 1, Gate 2, the bare code-rules gate, and exact required tests.
-
-## Evidence record
-
-```yaml
-mode: preflight-proposal
-pr_number: <resolved PR number>
-review_level: low | medium | xhigh
-base_sha: <immutable base SHA>
-head_sha: <immutable head SHA>
-proposal_id:
-  kind: commit-sha | diff-sha256
-  value: <immutable identity>
-isolated_worktree: <caller-supplied path>
-changed_paths:
-  - <normalized path>
-findings:
-  - severity: blocker | high | medium | low | nit
-    verdict: CONFIRMED | PLAUSIBLE
-    outcome: fixed | no_change_needed | skipped
-tests:
-  - command: <exact command>
-    exit_code: <integer>
-    outcome: <exact outcome>
-downstream_selection: required
-```

package/.agents/skills/e-code-review/reference/runner-selection.md

@@ -1,40 +0,0 @@
-# Runner selection (medium review)
-
-How `/e-code-review medium` (and loop) picks a harness runner for finder and
-verify work. `SKILL.md` points here.
-
-## What lives here
-
-| Topic | Content |
-|---|---|
-| Goal | One skill surface, many runners (Grok, Codex, Claude headless, and others) |
-| Today | `scripts/grok_code_review.py` is the Grok medium orchestration module |
-| Target | A thin selector chooses a runner by availability and task flags |
-| Out of scope | Reimplementing every harness inside this skill |
-
-## Today
-
-- Medium procedure: `reference/medium.md` (angles, verify, output fields).
-- Grok orchestration API: `scripts/grok_code_review.py` (discovery, dedupe,
-  retain, head-drift).
-- Constants: `scripts/e_code_review_scripts_constants/`.
-
-## Target shape (tracked separately)
-
-1. **Runner protocol.** Shared inputs (diff base, head, angles) and outputs
-   (candidates, verdicts, severities).
-2. **Detection.** Which runners are installed or configured (PATH, skills,
-   account chain).
-3. **Selection.** Pick one runner. Keep vendor choice out of `SKILL.md`
-   process steps.
-4. **Adapters.** Thin wrappers: Grok (current module), Codex, Claude, and
-   others.
-
-Keep implementation pull requests small: one concern each. Link this file from
-the tracking issue.
-
-## Related always-on docs
-
-- Skill hub: `../SKILL.md` (levels, fix, loop).
-- Preflight proposal: `preflight-proposal.md` (immutable range, local runner, proposal evidence).
-- Medium procedure: `medium.md`.

package/.agents/skills/e-code-review/scripts/config/e_code_review_effort_constants/__init__.py

@@ -1,41 +0,0 @@
-"""Constants for the e-code-review effort evaluation harness."""
-
-from e_code_review_effort_constants.effort_constants import (
-    ALL_EFFORT_LEVELS,
-    ALL_EFFORT_RANK_BY_NAME,
-    ALL_FIXTURE_BANDS,
-    ALL_REQUIRED_ROW_KEYS,
-    ALL_SCORE_ROW_KEYS,
-    ALL_SKILL_EFFORT_FOR_EVALUATION_EFFORT,
-    ALL_SKILL_EFFORT_LEVELS,
-    COST_LATENCY_LEVER,
-    EVALUATION_EVIDENCE_FILENAME,
-    EVALUATION_SCHEMA_VERSION,
-    FIXTURES_DIRECTORY_NAME,
-    JSON_SUFFIX,
-    LATENCY_MS_ROW_KEY,
-    MINIMUM_QUALITY_HOLD_SCORE,
-    THINKING_ENABLED_DEFAULT,
-    VISIBLE_TOKENS_ROW_KEY,
-    WORKFLOW_FAMILY_E_CODE_REVIEW,
-)
-
-__all__ = [
-    "ALL_EFFORT_LEVELS",
-    "ALL_EFFORT_RANK_BY_NAME",
-    "ALL_FIXTURE_BANDS",
-    "ALL_REQUIRED_ROW_KEYS",
-    "ALL_SCORE_ROW_KEYS",
-    "ALL_SKILL_EFFORT_FOR_EVALUATION_EFFORT",
-    "ALL_SKILL_EFFORT_LEVELS",
-    "COST_LATENCY_LEVER",
-    "EVALUATION_EVIDENCE_FILENAME",
-    "EVALUATION_SCHEMA_VERSION",
-    "FIXTURES_DIRECTORY_NAME",
-    "JSON_SUFFIX",
-    "LATENCY_MS_ROW_KEY",
-    "MINIMUM_QUALITY_HOLD_SCORE",
-    "THINKING_ENABLED_DEFAULT",
-    "VISIBLE_TOKENS_ROW_KEY",
-    "WORKFLOW_FAMILY_E_CODE_REVIEW",
-]

package/.agents/skills/e-code-review/scripts/config/e_code_review_effort_constants/effort_constants.py

@@ -1,40 +0,0 @@
-"""Named values for the Opus effort evaluation sweep."""
-
-EVALUATION_SCHEMA_VERSION: str = "1"
-THINKING_ENABLED_DEFAULT: bool = True
-MINIMUM_QUALITY_HOLD_SCORE: float = 0.8
-COST_LATENCY_LEVER: str = "effort"
-ALL_EFFORT_LEVELS: tuple[str, ...] = ("low", "medium", "high", "xhigh", "max")
-ALL_FIXTURE_BANDS: tuple[str, ...] = ("easy", "medium", "demanding")
-ALL_SCORE_ROW_KEYS: tuple[str, ...] = (
-    "quality_score",
-    "finding_recall",
-    "finding_precision",
-)
-FIXTURES_DIRECTORY_NAME: str = "fixtures"
-JSON_SUFFIX: str = ".json"
-VISIBLE_TOKENS_ROW_KEY: str = "visible_tokens"
-LATENCY_MS_ROW_KEY: str = "latency_ms"
-ALL_REQUIRED_ROW_KEYS: tuple[str, ...] = (
-    "fixture_id",
-    "fixture_band",
-    "effort",
-    *ALL_SCORE_ROW_KEYS,
-    VISIBLE_TOKENS_ROW_KEY,
-    LATENCY_MS_ROW_KEY,
-    "thinking_enabled",
-)
-ALL_EFFORT_RANK_BY_NAME: dict[str, int] = {
-    each_effort: each_index
-    for each_index, each_effort in enumerate(ALL_EFFORT_LEVELS)
-}
-ALL_SKILL_EFFORT_LEVELS: tuple[str, ...] = ("low", "medium", "xhigh")
-EVALUATION_EVIDENCE_FILENAME: str = "effort_defaults_evidence.json"
-WORKFLOW_FAMILY_E_CODE_REVIEW: str = "e-code-review"
-ALL_SKILL_EFFORT_FOR_EVALUATION_EFFORT: dict[str, str] = {
-    "low": "low",
-    "medium": "medium",
-    "high": "xhigh",
-    "xhigh": "xhigh",
-    "max": "xhigh",
-}

package/.agents/skills/e-code-review/scripts/e_code_review_scripts_constants/__init__.py

@@ -1 +0,0 @@
-"""Constants package for e-code-review scripts."""

package/.agents/skills/e-code-review/scripts/e_code_review_scripts_constants/finding_pipeline_constants.py

@@ -1,49 +0,0 @@
-"""Named constants for the collect-then-filter finding pipeline.
-
-::
-
-    collect_findings([...low-severity finding...])
-        ok: collection keeps every seeded severity including low and nit
-    filter_findings_by_severity(collection, minimum_severity="medium")
-        ok: consumer stage drops lower severities; collection record is unchanged
-"""
-
-from __future__ import annotations
-
-COLLECTION_STAGE_NAME: str = "collection"
-"""Stage that retains every real finding with its evidence fields."""
-
-FILTER_STAGE_NAME: str = "severity_filter"
-"""Later consumer stage that may drop findings by severity for action."""
-
-FINDING_FIELD_FILE: str = "file"
-FINDING_FIELD_LINE: str = "line"
-FINDING_FIELD_SEVERITY: str = "severity"
-FINDING_FIELD_CATEGORY: str = "category"
-FINDING_FIELD_EVIDENCE: str = "evidence"
-
-SEVERITY_BLOCKER: str = "blocker"
-SEVERITY_HIGH: str = "high"
-SEVERITY_MEDIUM: str = "medium"
-SEVERITY_LOW: str = "low"
-SEVERITY_NIT: str = "nit"
-
-ALL_SEVERITY_RANK_BY_TOKEN: dict[str, int] = {
-    SEVERITY_BLOCKER: 5,
-    SEVERITY_HIGH: 4,
-    SEVERITY_MEDIUM: 3,
-    SEVERITY_LOW: 2,
-    SEVERITY_NIT: 1,
-}
-"""Higher rank is more severe; used only by the filter stage."""
-
-ALL_COLLECTION_SEVERITIES: tuple[str, ...] = tuple(ALL_SEVERITY_RANK_BY_TOKEN)
-"""Severity tokens collection accepts; derived from the rank map keys."""
-
-REPORT_EVERY_FINDING_INSTRUCTION: str = (
-    "Report every real finding. Collection retains all severities "
-    f"({', '.join(ALL_COLLECTION_SEVERITIES)}). Do not drop findings "
-    "by severity during collection; severity or action filtering is a "
-    "separate consumer stage after the collection record is complete."
-)
-"""Reviewer-prompt instruction that separates collection from filtering."""

package/.agents/skills/e-code-review/scripts/e_code_review_scripts_constants/grok_code_review_constants.py

@@ -1,55 +0,0 @@
-"""Named constants for Grok medium-review discovery and verification."""
-
-from __future__ import annotations
-
-MEDIUM_REVIEW_SCHEMA_VERSION: str = "1.0.0"
-"""Schema version for medium-review run documents."""
-
-MEDIUM_REVIEW_FINDER_COUNT: int = 8
-"""Exactly eight finder angles execute per medium review head."""
-
-ALL_MEDIUM_FINDER_ANGLES: tuple[str, ...] = (
-    "correctness",
-    "security",
-    "code_rules",
-    "tests",
-    "docs",
-    "concurrency",
-    "api_contracts",
-    "regressions",
-)
-"""Named finder angles for one medium-review discovery batch."""
-
-VERDICT_CONFIRMED: str = "CONFIRMED"
-"""Verification retained a concrete failure scenario."""
-
-VERDICT_PLAUSIBLE: str = "PLAUSIBLE"
-"""Verification could not refute the finding."""
-
-VERDICT_REFUTED: str = "REFUTED"
-"""Verification rejected the finding."""
-
-ALL_VERIFICATION_VERDICTS: frozenset[str] = frozenset(
-    {VERDICT_CONFIRMED, VERDICT_PLAUSIBLE, VERDICT_REFUTED}
-)
-"""Legal verification verdict tokens."""
-
-SEVERITY_BLOCKER: str = "blocker"
-SEVERITY_HIGH: str = "high"
-SEVERITY_MEDIUM: str = "medium"
-SEVERITY_LOW: str = "low"
-SEVERITY_NIT: str = "nit"
-
-ALL_SEVERITIES: frozenset[str] = frozenset(
-    {
-        SEVERITY_BLOCKER,
-        SEVERITY_HIGH,
-        SEVERITY_MEDIUM,
-        SEVERITY_LOW,
-        SEVERITY_NIT,
-    }
-)
-"""Legal severity tokens on retained findings."""
-
-UTF8_ENCODING: str = "utf-8"
-"""Text encoding for review artifacts."""