Przejdź do treści
Biblioteka skilli
Programowanie · Przegląd i audyt

pre-commit-review

/pre-commit-review

Wykonuje wymagany przegląd zmian przed każdym commitem: uproszczenie, skan sekretów i cztery niezależne przeglądy tylko do odczytu.

Repozytorium
SC_AI ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

98/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena13 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Wykonuje wymagany przegląd zmian przed każdym commitem: uproszczenie, skan sekretów i cztery niezależne przeglądy tylko do odczytu.

Oryginalny opis (EN)

Run the required staged-diff review (a simplification pass, a secret scan, then four read-only review lanes) before every git commit, and record the approved staged-tree state for the shared Git hook. Use when an agent is about to commit, runs /pre-commit-review, reviews staged commit scope, or decides whether a commit may proceed after code, workflow, documentation, test, configuration or infrastructure edits.

Jak działa

  1. The ten steps
  2. Ponytail dependency
  3. Models and runtimes
  4. Step 1: Setup check
  5. Step 2: Stage only the intended change
  6. Step 3: Pass 1, simplification
  7. Step 4: Capture the reviewed tree
  8. Step 5: Secret scan
  9. Step 6: Run the required checks once
  10. Step 7: Brief and run the four review lanes
Sekcje z nagłówków SKILL.md, w oryginale · 287 linii, 4 046 słów
Podgląd SKILL.md
---
name: pre-commit-review
description: Run the required staged-diff review (a simplification pass, a secret scan, then four read-only review lanes) before every git commit, and record the approved staged-tree state for the shared Git hook. Use when an agent is about to commit, runs /pre-commit-review, reviews staged commit scope, or decides whether a commit may proceed after code, workflow, documentation, test, configuration or infrastructure edits.
---

# Pre-Commit Review

These skills ship with the SCG router, which delivers and refreshes them; see
[automatic updates](../../references/updates.md). There is no per-plugin updater
to configure. Respect explicit read-only scope.

This skill is the gate before every commit. You, the main agent, prepare the staged change, run a simplification pass, scan for secrets, run the required checks once, have four read-only reviewer subagents inspect the exact staged tree, decide on their findings, and record one approval for that tree. The shared Git hook refuses a commit without that approval. If this process does not run, the task is incomplete and you must not commit.

**Materiality over coverage.** The gate catches realistic failures that this change causes. Report, fix and block only on failures with a plausible path in normal or demonstrably reachable use, never on speculative edge cases. A proportionate review that finishes is success; an exhaustive review that never converges is a failed review.

## The ten steps

Do them in this order. Each section below says exactly what to run.

| Step | Do | Stop with `❌ Block` when |
|---|---|---|
| 1 | Setup and Ponytail dependency check | the check fails or Ponytail cannot be read |
| 2 | Stage only the intended change and check its size | unrelated work is staged, or it is oversized without a reason |
| 3 | Pass 1: simplification, then stage its edits | no permitted model can complete Pass 1 |
| 4 | Capture the reviewed tree | |
| 5 | Secret scan | the scan exits non-zero |
| 6 | Run the required checks once | a required check fails |
| 7 | Brief and run the four review lanes | a lane cannot complete |
| 8 | Adjudicate the findings and fix blockers | an accepted blocker needs owner input |
| 9 | Re-review if the staged tree changed | |
| 10 | Record the approval and commit | |

## Ponytail dependency

Before Pass 1, resolve `scg-ponytail:ponytail` from the active client's skill
catalogue or installed-plugin inventory (`/scg-ponytail:ponytail` in Claude
Code), and read its `SKILL.md` in full. Supply that same resolved absolute
path to the simplifier and every review lane; each pass reads it before
inspection and confirms its path. Resolve the current installation, never a
hard-coded cache version or the former standalone or SCG Review copy.

If the plugin is missing, disabled or unreadable, report `❌ Block` before
dispatching any pass. Install and enable `scg-ponytail@scg-agent-plugins` in
the active client, then retry the setup check. Never omit this dependency or
fall back to older Ponytail guidance.

## Models and runtimes

Read the bundled [reviewer routing policy](../../references/reviews.md) before every review. It defines model-agnostic selection, bounded availability fallbacks and escalation. It is an unchanged copy of the canonical optimal-subagents policy. Exact user or project model/effort requirements take precedence over it.

- **Codex:** use the machine owner's configured reviewer choices under the bundled policy. Use the bundled [code-simplifier](../code-simplifier/SKILL.md) for Pass 1 and the active subagent tools for the four lanes. Security also reads the bundled [security-review](../security-review/SKILL.md) skill.
- **Claude Code:** use the installed adapter agents `code-simplifier`, `review-correctness`, `review-quality` and `review-adversarial`, plus the bundled `scg-review:review-security` agent. The parent selects the owner's configured model and effort for every pass using the active tool schema. Without a per-invocation effort field, use a verified matching inherited session effort; otherwise report the selection blocker. Never label a client selection limit as unsupported model effort. This plugin supplies the security agent with no model or effort; it does not install or change the other local agents. Skip a model when the active client has no eligible route to it; a configured identifier does not establish access.
- **Other runtimes:** use only a verified installed adapter that implements this procedure.

When the selected model is unavailable, use an eligible fallback and record the substitution. Fallbacks are enabled unless the current user forbids substitution or an applicable instruction requires an exact model, provider or effort. Follow the policy's two-fallback dispatch limit and shared-failure rules. A required pass is `❌ Block` when no permitted model can complete it. Never switch runtimes, accounts or data constraints, or weaken a gate, to get around a requirement. Confirm access through actual review calls: an accepted dispatch is not a completed review. See [provider access and identity rules](../../references/reviewer-models.md).

Record each pass's requested and returned model and effort in your notes. Missing served identity is `unverified`; a known mismatch invalidates that pass. Fallbacks never remove staged-tree coverage, lane independence or the need for a genuine review.
For Codex, keep the exact child/parent IDs and assignment window, then read
[child evidence](../../references/reviewer-models.md#exact-codex-child-evidence)
after completion. Use upstream-reported fields separately from requested
effort; incomplete evidence keeps the existing unverified fallback.

Use the **elevated-risk profile** when the staged change, or a directly relevant context file, touches auth, security, money, destructive data, migrations, concurrency or deployment. You decide the profile in step 2 and state it in every brief. It deepens inspection and the evidence required for the whole review; it does not by itself require a more expensive model.

### Codex: select the model and handoff

Use the active tool schema. With `multi_agent_v1`, pass `fork_context=false`,
the selected model, supported effort and the brief in `message`; there is no
`task_name` or `fork_turns`. Keep the returned `agent_id`.

With V2, call `spawn_agent` with a task name, the selected model, supported
`reasoning_effort`, `fork_turns="none"` and the complete brief in `message`.
Omit effort only when the selected model does not support it and no exact
effort requirement applies. Record
`unavailable`. Pass 1 receives the code-simplifier assignment; the lanes receive
Step 7's brief. A model label in the message does not select the model. Resolve
the configured reviewer before dispatch rather than relying on implicit defaults.

If `collaboration_plaintext` handoff tools are offered, use them for every
subagent assignment, message and follow-up, whatever the recipient. Otherwise
use the `collaboration` tools. Pass the selected model and supported effort
explicitly; external children need `fork_turns="none"`.

A handoff refusal is a delivery failure, not model or provider unavailability.
Report the exact delivery blocker as `❌ Block` and preserve the work.

## Step 1: Setup check

Find the repo root and branch, and read the root and nested `AGENTS.md` files that govern the staged files. Then run this with the installed plugin root, which is two folders above this skill's folder:

```bash
python3 <plugin-root>/scripts/setup.py check --repo <absolute-repo-path>
~/.config/scg-agent-git-hooks/bin/scg-review-state models --client codex
```

Use `--client claude-code` in Claude Code; other adapters use their own profile.
Read the returned ordered preferences for simplification and each lane. Missing
or invalid preferences are `❌ Block` before model dispatch; the shared skill
supplies no model defaults. The [setup guide](../../references/setup.md#reviewer-preferences)
describes the owner's local configuration. Do not rewrite it during review.

On native Windows, use Git Bash for this guide's Bash commands. In PowerShell,
run setup with an absolute interpreter, for example the router's runtime:

```powershell
& "$env:USERPROFILE\.codex\mixed-model-router\runtime\python\python.exe" "<plugin-root>\scripts\setup.py" check --repo "<absolute-repo-path>"
```

A failure is `❌ Block`. Use [review-setup](../review-setup/SKILL.md) to diagnose it. Installing never counts as a review or an approval.

## Step 2: Stage only the intended change

Run `git status --short`. Stage only this commit's scope, and move unrelated staged work out first. Apply the host or project size rule. Otherwise keep a commit within 800 meaningful changed lines (additions plus deletions), not counting generated, vendored and mechanical files. An unavoidable oversized but coherent change needs a short written justification before review; unjustified oversize is `❌ Block`. Then decide the risk profile: normal, or elevated (see Models and runtimes) with the reason.

## Step 3: Pass 1, simplification

Run the simplification pass before the lanes, then stage its edits. A no-op is valid and is recorded as one. Use your runtime's entry under Models and runtimes and the installed code-simplifier skill. Pause your own edits while the simplifier has write ownership. It edits staged files only, reads ponytail first, follows project instructions and reports its changes or a no-op. If it edits outside the staged scope, undo only its own out-of-scope edits and keep any pre-existing work. Verify its result, then stage it; the staged scope must still be the intended commit. The hook receipt lists the four review lanes, not the simplifier.

Pass 1 is often the slowest phase. The simplifier may read the staged scope, instructions, callers and tests for a long time before it edits or reports, so a quiet child is not a stalled child: do not cancel, interrupt, respawn, or launch a duplicate simplifier because it is quiet. Check on it through the runtime's bounded wait or status mechanism. Treat Pass 1 as stalled only when the runtime reports a failure, the child asks for attention, or an established runtime/transport timeout occurs. Then inspect the worktree and index before one focused retry with a fresh brief.

## Step 4: Capture the reviewed tree

```bash
git diff --cached --name-only
git diff --cached --stat
git diff --cached
git write-tree
git rev-parse --verify HEAD
```

The `git write-tree` output is the reviewed tree id. Record HEAD as the base
commit; if HEAD does not exist, record an initial repository explicitly. Every
later step refers to this pair. A changed base invalidates introduction evidence.

## Step 5: Secret scan

Run this before any reviewer call:

```bash
~/.config/scg-agent-git-hooks/bin/scg-review-state scan
```

On native Windows, run this Bash command in Git Bash. Git for Windows also runs
the installed hook shims through Bash; the helper uses the interpreter recorded
in `config.json` (the router's runtime by default).

The scan checks the pinned Gitleaks binary (absolute path, version and SHA-256 in `~/.config/scg-agent-git-hooks/config.json`). A failed checksum stops before executing the binary. It refuses repository or environment scanner overrides and scans the staged diff with redacted output. This does not establish that every unchanged file is secret-free. Any non-zero exit (a missing, changed, timed-out or failed scanner, or any leak) means zero reviewer calls and `❌ Block`. Never print or paste a secret: report the credential type and `file:line`, and recommend rotation. Changing the pin or allowing a repository config is an owner change to the hook adapter, never a session workaround. A different target must supply and prove its own adapter before this skill is usable there.

## Step 6: Run the required checks once

Run the required checks yourself, once, on the frozen tree. This comes after Pass 1 because Pass 1 edits the tree; an earlier run would describe a tree that no longer exists.

- **Required:** documented pre-commit checks, targeted tests for changed behaviour, new or changed tests, and the typecheck, lint, build, contract and snapshot checks that normally gate the repo. Expect exit code 0 unless the repo documents stricter output.
- **Optional:** broad, slow, destructive, production-impacting or unrelated commands. Never run destructive or production-impacting commands without explicit approval.
- If no required command exists, record a verification gap.

Record the exact commands, their results and the reviewed tree id. Every lane receives this record and does not repeat the checks. A failed required check is `❌ Block`: fix the cause, re-freeze the tree, repeat the secret scan and rerun the affected checks.

Right before spawning reviewers, confirm `git write-tree` still prints the reviewed tree id. If it does not, isolate the change, recapture the scope, rescan and rerun the affected checks.

## Step 7: Brief and run the four review lanes

Run correctness, quality, adversarial and security after Pass 1 is finished and staged. Use independent contexts and the same frozen tree. Respect available child slots: run at most three reviewers at once, then the remaining lane. Scheduling does not make a lane optional. Each lane owns one failure class in the [lane guide](../../references/lanes.md).

List the context files reviewers need beyond the staged files: direct callers or importers of changed exports; adjacent tests and fixtures; schemas, contracts, builders, snapshots, workflow definitions or config that define the changed behaviour; and docs or runbooks when behaviour or deployment changes. If a lane cannot inspect required context, its review is incomplete.

Send every lane this brief, changing only the lane name and model line. Do not write per-model prompts.

```text
<requested model> <effort>: pre-commit review, <lane> lane, for <task or branch>.
Worktree: <absolute worktree path>
Reviewed tree: <tree id>
Base commit: <HEAD commit id, or initial repository with no HEAD>
Staged files: <list>
Context files: <absolute paths>
Risk profile: <normal, or elevated because ...>
Verification already run: <commands and results>
First read in full: <resolved absolute path of scg-ponytail's ponytail SKILL.md>, then <absolute path of references/lanes.md>, applying its <lane> section. Security also reads <absolute security-review SKILL.md> with role discover and uses its safer Git object-read commands for all target material.
Inspect the staged change with these commands, run in the worktree, and read the listed context files; inspect nothing else:
  git write-tree            must print the reviewed tree id; on a mismatch, report it and stop
  git diff --cached --stat
  git diff --cached
  git show :path            for every staged file, in full
You are read-only: do not edit, stage, commit, push, delegate or change any system. Other lanes may run one narrow, non-destructive check to prove or disprove a finding; report what you ran and what it showed. Security performs source reads only: no target code, tests, imports, filters, network, credentials or live tools. It reads tracked context from the reviewed tree, compares base blobs and checks tree/base stability again before reporting.
Reply in the lane report format from the lane guide, then stop.
```

`git show :path` covers only the listed staged files, and context is a named path list. Do not reconstruct trees, extract the repository to `/tmp`, inspect unlisted files, or continue after the Markdown report. A failed report is not unavailability: do not rerun the same model with the same brief. Make one focused correction, then use an eligible fallback within the policy's dispatch limit.

If delivery goes wrong:

- A child that misses the brief or starts unrelated work is stopped, not sent the full review again. As a fallback, write the same brief to a non-secret temporary Markdown file and deliver its absolute path through the same handoff tool; a file path cannot repair a brief that arrived encrypted. If only task labels arrive, put the file name in the label too. This changes the transport only, never the models, pass order or approval rules. Never replace a lane with a top-level task or a self-written review.
- A short acknowledgement, a task name or an accepted spawn is not review evidence. A report must cover the full staged diff and every staged file in full, including an index or README file beyond its changed hunk. When a report conflicts with what the child actually did, verify the missing inspection before accepting it. Do not add delivery probes or extra approval questions to ordinary successful reviews.
- Use a distinct brief for each pass and each changed tree. Reject a result that repeats an old tree's review; start a fresh subagent with the new brief.
- If file handoff also fails, report the exact error, apply the policy's bounded fallbacks where eligible, and preserve the work if no permitted pass can run. Do not repeat unbounded review calls.

## Verdicts

Every lane report, every interim update while other lanes are still running, and the final recap use only these labels, emoji included:

- `✅ All Clear`
- `📝 Proceed With Notes`
- `❌ Block`

These three labels are the whole verdict vocabulary. A verdict keeps its label and its emoji wherever it is relayed, from the first mention, not only in the recap. It is never paraphrased into prose (`All Clear`, `blocks`, `passed`), stripped of its emoji, or replaced by another symbol such as `🟡` or `🔴`. Snake_case appears only in the hook's `--decision` values.

## Step 8: Adjudicate the findings and fix blockers

1. Confirm all four lanes inspected the full staged diff and every staged file, and read ponytail first. A lane missing either confirmation is incomplete and blocks the commit. Security's explicit exception for irrelevant binary asset contents requires honest coverage reporting, not a full-file claim. Confirm security used the captured tree/base and source-only contract.
2. Merge duplicate findings by root cause; the lane that owns the failure class keeps it.
3. Decide each item: Accept, Downgrade or Reject, against the staged evidence and the reportability and severity rules in the [lane guide](../../references/lanes.md). Security candidates first undergo the independent verification below; the parent may merge duplicates but cannot discard a reported security candidate on its merits before verification. Accept only when the change caused or worsened it, the failure path is executable or deterministic, the impact is material, the confidence is justified and the smallest fix is in scope. A downgrade must fit the severity scale: a finding that breaks a contract, a safety boundary, data integrity or required operability is at least `HIGH`, never `MEDIUM`. Write a short reason for any decision that is not obvious. A rejected `❌ Block` triggers no edits and no further review after any required security verification.

Send every reported security candidate, after merging duplicates, to one fresh
security verifier that did not discover them. Use the same configured security
selection, full staged scope, named context and source-only brief, with role
`verify`. Do not supply the parent's preferred verdict. Require an independent
source trace and disposition for every candidate. No candidates means no extra
call. Record the verifier's requested and returned model/effort, exact tree/base,
disposition for each root cause and any missing identity fields as unverified.
A material replacement claim requires fresh verification before acceptance;
unresolved material candidates or incomplete verification remain `❌ Block`.
4. Act on what you accepted:

| Accepted item | Action |
|---|---|
| `CRITICAL` or `HIGH` finding, or a `HIGH` or `CRITICAL` missing test | Fix it before committing. If the fix needs owner or product input, stop and ask |
| `MEDIUM` finding | Do not auto-fix. Accept the residual risk with a reason (`📝 Proceed With Notes`) or ask the owner to widen the scope |
| `LOW`, speculative, style-only, pre-existing or optional hardening | Not reportable: no edits, and no follow-up work unless the owner asks or the evidence shows a separate material risk |

5. Rerun the required checks that a fix affects, or all of them when unsure. A failed required check blocks. If one cannot run because of an environment or dependency problem, record the blocker, the residual risk and the next check before allowing `📝 Proceed With Notes`.
6. Record in the repo's task notes, when it has them (`tasks/todo.md`, `tasks/lessons.md` or similar): staged scope, simplification outcome, reviewed tree id, requested and returned model and effort per lane, verdicts, fixed findings, final staged delta, accepted residual risks, and verification results.
7. Write a short recap for the person: the combined verdict, then one bullet per lane with its verdict, requested model/effort and upstream-reported model/effort (or `unverified`). Label provider reports and retained-record coverage as described in [child evidence](../../references/reviewer-models.md#exact-codex-child-evidence); never turn the requested effort into a served claim. For `📝 Proceed With Notes` or `❌ Block`, add a flat list of the accepted notes: lane, one-line point, and why it was accepted or why it blocks.

The combined decision:

- `✅ All Clear`: every lane passed, no unresolved material risk remains, and every required check ran and passed.
- `📝 Proceed With Notes`: only accepted `MEDIUM` findings or unavoidable verification or runtime risks remain, each with a recorded reason. Notes create no automatic follow-up work.
- `❌ Block`: any unresolved `CRITICAL` or `HIGH` finding, an incomplete lane, a required pass that no permitted model could complete, staged scope that is not isolated, a failed required check, or an unresolved high-severity missing test. Speculative concerns never block on their own; reject them at adjudication so the gate converges.

## Step 9: Re-review if the staged tree changed

Compare the final staged tree with the reviewed tree id. If they match, no re-review is needed. If not, inspect `git diff <reviewed-tree-id> --cached` and classify the delta:

| Delta | Examples | What to do |
|---|---|---|
| Mechanical | typos, behaviour-neutral formatting, adding exactly the regression test a reviewer asked for without changing test strategy, narrowing a change exactly as asked without altering behaviour, prose-only corrections | No lane reruns. Self-verify, run targeted checks, rescan, and record why the original review still covers the final tree |
| Material | any change to behaviour or public contracts; auth, security, permissions or secrets handling; payments, sends, deletes, record writes or other side effects; migrations, deployment, rollback or infrastructure; concurrency, idempotency, retry or state; test strategy or coverage boundaries; agent instructions, approval rules, executable runbooks, specs, schemas or workflow JSON when a contract or required behaviour changes; any simplification pass run after the lanes | Rerun the owning lane on the final tree, plus correctness when another lane owned the finding or behaviour changed. Security also reruns when its inspected boundary or evidence changed. Rerun all four only when one fix spans several lanes, adds a new risk area, or cannot be bounded from the delta |

A delta that touches anything in the Material row is material, even when part of it also looks mechanical.

An unaffected lane's result carries over only after you inspect the exact reviewed-to-final delta and record why its conclusion still holds. Record the original tree, the final tree, the rerun lanes, the carried-over lanes and your reasons before approving. Fix and re-review cycles are not capped: keep going until the combined decision is `✅ All Clear` or `📝 Proceed With Notes`, and stop only when an accepted blocker needs owner input. A rephrased version of the same root cause is not a new finding.

## Step 10: Record the approval and commit

Check that the effective `core.hooksPath` is `~/.config/scg-agent-git-hooks/`.
Confirm the staged tree and HEAD still match the final reviewed pair before
recording approval. A changed base needs a new scope assessment and review;
never stamp the new base onto an old review.

The commit, automatic-merge and commit-message hooks require an approved
receipt for this repository, branch, exact tree and base, required lanes and
maximum age. They check scope again after chained repository hooks. A hook
that stages changes blocks the commit until those changes are reviewed.
The hooks do not run the review or scan. Rescan after every staged-tree change,
including mechanical deltas.

To prepare a merge commit for review, use `git merge --no-commit --no-ff <branch>`.
Review and approve the staged result, then run `git commit`. Automatic merges
also need matching approval. Version 3 receipts retain the base explicitly,
including an unborn repository. Older receipts remain saved but cannot pass
the refreshed gate; follow the [adapter refresh guide](../../references/setup.md#refresh-an-existing-installation).

Then record the approval under `~/.cache/scg-agent-git-hooks/reviews/`:

```bash
~/.config/scg-agent-git-hooks/bin/scg-review-state approve --decision ALL_CLEAR --pass correctness=<requested-model>@<requested-variant>::<returned-model>@<returned-variant> --pass quality=<requested-model>@<requested-variant>::<returned-model>@<returned-variant> --pass adversarial=<requested-model>@<requested-variant>::<returned-model>@<returned-variant> --pass security=<requested-model>@<requested-variant>::<returned-model>@<returned-variant>
```

- `✅ All Clear` maps to `--decision ALL_CLEAR` and `📝 Proceed With Notes` maps to `--decision PROCEED_WITH_NOTES`. Never record approval for `❌ Block`.
- Each `--pass` value is `<requested-model>@<requested-variant-or-unavailable>::<returned-model-or-unverified>@<returned-variant-or-unverified-or-unavailable>`. Use the actual callable identifier and supported effort, or `unavailable` when effort is unsupported. When the runtime does not echo its serving identity, record `unverified@unverified` on the returned side; that absence never blocks approval.
- Never invent a value, and never record approval without a genuine four-lane review having run. Self-attesting the review is a bypass of the gate, not a review.

Commit with `<type>: <short summary>`, where type is `feat`, `fix`, `refactor`, `test`, `chore` or `docs`, matching the shared commit-msg hook.

## Rules that apply throughout

- Run this process once for the intended staged commit scope.
- Reviewers are read-only. They inspect the staged diff and the full staged files from the git index, never snippets or working-tree content, and the main agent's single verification run stands for all four lanes.
- Every pass reads the installed `scg-ponytail:ponytail` skill in full before inspecting anything; give each pass its resolved absolute path under [Ponytail dependency](#ponytail-dependency). Ponytail informs judgement about the smallest correct change. It never makes style-only, `LOW`, speculative or out-of-lane findings reportable, and never justifies editing for rejected items.
- The parent owns orchestration. A reviewer must not run the whole gate or spawn its own reviewers. Use the runtime's actual subagent tools and schemas, and the current policy rather than model names remembered from an earlier turn.
Pliki w paczce (2)
  • SKILL.md 27 KB
  • agents/openai.yaml 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · software-combined/SC_AI98Apache-2.0
openshift-eng/ai-helpers100Apache-2.0
KjellKod/quest100Unlicense

Migawka bazy z 13.11.2026 · wersja paczki 7024d799b8b6 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100pre-commit-quality-review
    Wykonuje przegląd strukturalnej jakości kodu przed commitem, poprawieniem lub scaleniem commitów.
  • 100commit-staged
    Tworzy commit ze staged plików i pisze komunikat zmian, gdy prosisz o zacommitowanie, przygotowanie wiadomości lub wywołujesz commit-staged.
  • 100setup-pre-commit
    Konfiguruje hooki Husky pre-commit z lint-staged i Prettier, a także sprawdzanie typów i testy przed każdym commitem.
  • 100pre-commit
    Przeprowadza pełną bramkę walidacji przed commitem: kontrole jakości, testy, pokrycie, skan bezpieczeństwa, changelog i przegląd towarzyszący.
  • 100git-commit
    Zatwierdza przygotowane zmiany commitem z komunikatem w formacie conventional commit.
  • 100git-commit
    Zatwierdza przygotowane zmiany commitem z komunikatem w formacie conventional commit.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.