Applies fixes from a prior review-llm-artifacts run, with safe/risky classification. Respects verify-llm-artifacts output when present to skip false positives.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Applies fixes from a prior review-llm-artifacts run, with safe/risky classification. Respects verify-llm-artifacts output when present to skip false positives.
disable-model-invocation
true
Fix LLM Artifacts
Apply fixes from a previous review-llm-artifacts run with automatic safe/risky classification. If .beagle/llm-artifacts-verification.json exists, skip findings marked false_positive and treat inconclusive like risky fixes (prompt or skip per user).
Usage
Invoke the fix-llm-artifacts skill, optionally passing these flags:
--dry-run - Show what would be fixed without changing files
--all - Fix entire codebase (runs review-llm-artifacts --all first if no review JSON)
--category <name> - Only fix specific category: tests|dead-code|abstraction|style
Instructions
Hard gates
Sequence matters. Do not apply fixes until each pass condition is satisfied (these steps are not “internal verification”).
Working tree — git status --porcelain is empty or a stash was created with message and shows it. If the user refuses stash/backup, or document explicit acceptance of risk in the report before edits.
beagle-core: pre-fix-llm-artifacts backup
git stash list
stop
Review artifact on disk — .beagle/llm-artifacts-review.json exists, or--all completed a review-llm-artifacts run that wrote that file. Otherwise stop (no fixes from memory or guesses).
2a. Echo + ID lock (anti-confabulation) — After loading the review (Section 3), echo the finding table (id | category | file:line | description) from the parsed JSON and record the exact id set as the locked id set. You fix only findings in this set; never fix a finding inferred from the branch name, directory, or memory. Every fix you apply or skip maps 1:1 to a locked id. See the review-verification-protocol skill → Anti-confabulation (gate 0).
2b. Per-fix existence precondition — Before editing for any finding, confirm (i) its id is in the locked set, and (ii) the cited file exists and the cited code is actually present at file:line (read it now). If the file or code is absent, do not edit — the finding is stale or confabulated; mark it skipped with a reason and move on. Never create or rewrite a file to match a finding.
Stale review — If jq -r '.git_head' .beagle/llm-artifacts-review.json ≠ git rev-parse HEAD, prompt to re-run review. y → re-run review, then continue. n → abort the fix pass (do not apply fixes against stale findings).
Verification overlay — If .beagle/llm-artifacts-verification.json exists, it must parse; build exclude/inconclusive sets before partitioning (Section 4). On parse failure, stop and report the error.
Risky fixes — No code_removal, logic_change, mock_boundary, abstraction_change, or test_refactor work without the interactive choice in Section 6 (or s to skip all remaining risky items).
Post-edit: Sections 7–8 pass only when invoked tools exit successfully (non-zero = failure; keep JSON artifacts per Cleanup).
1. Parse Arguments
Extract flags from $ARGUMENTS:
--dry-run - Preview mode only
--all - Full codebase scan
--category <name> - Filter to specific category
2. Pre-flight Safety Checks
# Check for uncommitted changes
git status --porcelain
If working directory is dirty, warn:
Warning: You have uncommitted changes. Creating a git stash before proceeding.
Run `git stash pop` to restore if needed.
If --all flag: Run review-llm-artifacts --all first to produce a full-project review
Otherwise: Fail with: "No review results found. Run the review-llm-artifacts skill first."
Echo + lock ids (gate 2a): Once the file is present, print every finding from the parsed JSON and lock the id set before partitioning:
python3 - <<'PY'
import json
r = json.load(open('.beagle/llm-artifacts-review.json'))
f = r['findings']
if not isinstance(f, list) or not f:
raise SystemExit("No findings to lock; aborting.")
ids = [x.get('id') for x in f]
if any(not isinstance(i, int) for i in ids):
raise SystemExit("All finding ids must be integers; aborting.")
if len(set(ids)) != len(ids):
raise SystemExit("Duplicate finding ids detected; aborting.")
print("| id | category | file:line | description |")
print("|----|----------|-----------|-------------|")
for x in f:
desc = (x.get('description') or '').replace('|', '\\|')[:80]
print(f"| {x['id']} | {x.get('category')} | {x.get('file')}:{x.get('line')} | {desc} |")
print("Locked ids: {" + ", ".join(str(i) for i in sorted(set(ids))) + "}")
PY
Adjudicate and fix only the ids above. If your sense of what to fix differs from this table, the table wins.
Optional verification overlay — if .beagle/llm-artifacts-verification.json exists:
Build a set of finding ids with status: false_positive → exclude these from all fix lists.
Finding ids with status: inconclusive → always follow risky-fix handling (Section 6), even if fix_safety was Safe in the review.
Finding ids with status: confirmed_issue → use review JSON fix_safety / risk as usual.
If verification is missing, warn when applying deletes or dead-code fixes: "For fewer false positives, run the verify-llm-artifacts skill first."
If file exists, validate freshness:
# Get stored git HEAD, scope, and target from JSON
stored_head=$(jq -r '.git_head' .beagle/llm-artifacts-review.json)
stored_scope=$(jq -r '.scope // "all"' .beagle/llm-artifacts-review.json)
stored_target=$(jq -r '.target // "."' .beagle/llm-artifacts-review.json)
current_head=$(git rev-parse HEAD)
if [ "$stored_head" != "$current_head" ]; thenecho"Warning: Review was run at commit $stored_head, but HEAD is now $current_head"fi
If stale, prompt: "Review results are stale. Re-run review? (y/n)".
y → re-run review-llm-artifacts with the original scope and target read from the stale JSON, then reload. This preserves the user's original intent; do not silently widen or narrow the scope, which would apply fixes unrelated to the user's diff (or miss files they cared about). Concretely:
If scope or target is missing from the JSON (pre-schema review), do not abort. Assume scope = "all" and target = ".", then warn:
"Review JSON predates the scope/target schema; re-running as a full-project scan (--all). If you meant a narrower scope (the default changed-files diff, or a subdirectory), cancel now and re-run the review-llm-artifacts skill explicitly."
Proceed only if the user does not cancel.
n → abort (do not apply fixes; stale findings are not trustworthy).
4. Partition Findings by Safety
Parse findings from JSON and classify by fix_safety field (after applying verification overlay from step 3):
Otherwise, apply the safe fixes per category. If the agent supports subagents, dispatch one per category in parallel; otherwise work through the categories sequentially yourself, applying the identical per-finding contract below and producing the same per-fix report.
Apply safe fixes for category "{category}"
Files: [list of files with findings in this category]
Instructions: For EACH finding, first confirm it is in the locked id set and that the
cited code exists at file:line (read it). If the file or code is absent, skip the finding
with a reason — do NOT create or rewrite a file to match the finding. Then apply each
confirmed fix, preserving surrounding code. Report success/failure/skip per fix by id.
Categories (parallelized across subagents when supported, otherwise handled sequentially):
style - Comments, formatting
dead-code - Imports, unreachable code
tests - Test-related safe fixes
abstraction - Safe refactors
6. Handle Risky Fixes
For each risky fix, prompt interactively:
[src/services/auth.py:156] Remove seemingly unused authenticate_legacy() method?
This method has no callers in the codebase but may be used externally.
(y)es / (n)o / (s)kip all risky:
Track user choices:
y - Apply this fix
n - Skip this fix
s - Skip all remaining risky fixes
7. Post-Fix Verification
Detect project type and run appropriate linters:
Python:
# Check if ruff config existsif [ -f "pyproject.toml" ] || [ -f "ruff.toml" ]; then
ruff check --fix .
ruff format .
fi# Check if mypy config existsif [ -f "pyproject.toml" ] || [ -f "mypy.ini" ]; then
mypy .
fi
TypeScript/JavaScript:
# Check for eslintif [ -f "eslint.config.js" ] || [ -f ".eslintrc.json" ]; then
npx eslint --fix .
fi# Check for TypeScriptif [ -f "tsconfig.json" ]; then
npx tsc --noEmit
fi
Go:
if [ -f "go.mod" ]; then
go vet ./...
go build ./...
fi
8. Run Tests
# Pythonif [ -f "pyproject.toml" ] || [ -f "pytest.ini" ]; then
pytest
fi# JavaScript/TypeScriptif [ -f "package.json" ]; then
npm test 2>/dev/null || yarn test 2>/dev/null || truefi# Goif [ -f "go.mod" ]; then
go test ./...
fi
