Skip to content

hashgraph-online/awesome-codex-plugins / plugins/beastlabai/multi-llm-plugin/skills/multi-llm

multi-llm

Flagged

Orchestrate plan reviews, task generation, implementation and code reviews across several LLM CLIs in parallel, or ask every model one free-text question about a plan. Use when the user says: review my plan, multi-llm, run a code review, generate tasks from a plan, implement this plan, ask the models about my plan.

FileKindSize
SKILL.mdskill md4.0 KB
apply_code_fixes_orchestrator.pyscript56.6 KB
apply_commit_fixes_orchestrator.pyscript2.3 KB
apply_suggestions_orchestrator.pyscript4.5 KB
apply_task_suggestions_orchestrator.pyscript19.1 KB
ask_orchestrator.pyscript162.5 KB
assets/icons/Anthropic.svgother584 B
assets/icons/Codex.svgother1.3 KB
assets/icons/Copilot.svgother1.5 KB
assets/icons/Cursor.svgother793 B
assets/icons/GoogleGemini.svgother623 B
assets/icons/Goose.svgother3.2 KB
assets/icons/Kilocode.svgother531 B
assets/icons/MiniMax.pngbinary1.5 KB
assets/icons/Mistral.svgother717 B
assets/icons/MoonshotAI.svgother957 B
assets/icons/Nvidia.svgother2.4 KB
assets/icons/OhMyPi.svgother434 B
assets/icons/OpenAI.svgother1.7 KB
assets/icons/Opencode.svgother325 B
assets/icons/Pi.svgother440 B
assets/icons/Qwen.svgother1.7 KB
assets/icons/Zhipu.pngbinary442 B
assets/icons/xAI.svgother343 B
assets/omp/overlay.ymlconfig2.4 KB
check_workflow_prerequisites.pyscript74.5 KB
code_review_orchestrator.pyscript324.0 KB
display_decisions.pyscript9.8 KB
finalize_tracking.pyscript1.3 KB
full_workflow_orchestrator.pyscript58.8 KB
generate_tasks_orchestrator.pyscript44.2 KB
hosts/capabilities.yamlconfig49.9 KB
hosts/codex/plugin-skill.md.tmplother2.8 KB
hosts/codex/shim.md.tmplother7.3 KB
hosts/opencode/plugin-command.md.tmplother2.2 KB
hosts/opencode/shim.md.tmplother6.8 KB
hosts/render_capabilities.pyscript48.4 KB
hosts/snippets/poll-loop.mdmarkdown4.4 KB
hosts/snippets/uv-preflight.mdmarkdown2.2 KB
hosts/uv-missing.txtmarkdown1.5 KB
implement_orchestrator.pyscript156.0 KB
improve_code_orchestrator.pyscript1.6 KB
improve_commits_orchestrator.pyscript2.5 KB
improve_plan_orchestrator.pyscript1.6 KB
init_config.pyscript57.6 KB
instructions/apply-code-fixes.mdmarkdown52.0 KB
instructions/apply-commit-fixes.mdmarkdown10.3 KB
instructions/apply-suggestions.mdmarkdown48.2 KB
instructions/apply-task-suggestions.mdmarkdown53.9 KB
instructions/ask.mdmarkdown27.6 KB
instructions/full-workflow.mdmarkdown24.6 KB
instructions/generate-tasks.mdmarkdown18.1 KB
instructions/implement.mdmarkdown54.0 KB
instructions/improve-code.mdmarkdown25.0 KB
instructions/improve-commits.mdmarkdown24.8 KB
instructions/improve-plan.mdmarkdown26.2 KB
instructions/init-config.mdmarkdown6.6 KB
instructions/review-code.mdmarkdown43.5 KB
instructions/review-commits.mdmarkdown11.4 KB
instructions/review-plan.mdmarkdown38.4 KB
instructions/review-tasks.mdmarkdown37.8 KB
modes.pyscript58.8 KB
multi_llm.pyscript101.1 KB
prompts/ask.txtmarkdown948 B
prompts/code_review.txtmarkdown4.5 KB
prompts/commit_review.txtmarkdown6.2 KB
prompts/consolidate_suggestions.txtmarkdown3.1 KB
prompts/implementation_task.txtmarkdown1.4 KB
prompts/plan_review.txtmarkdown8.0 KB
prompts/task_review.txtmarkdown8.3 KB
providers.yamlconfig19.6 KB
pyproject.tomlmanifest6.8 KB
references/apply-write-executor.mdmarkdown3.0 KB
references/consolidation.mdmarkdown5.6 KB
references/host-capabilities.mdmarkdown13.5 KB
references/human-decision-batch.mdmarkdown17.2 KB
references/implement-prerequisites.mdmarkdown6.0 KB
references/implement-write-executor.mdmarkdown4.9 KB
references/interrupted-run-recovery.mdmarkdown3.1 KB
references/own-check.mdmarkdown4.3 KB
references/resume-detection.mdmarkdown8.5 KB
references/revalidation.mdmarkdown6.9 KB
references/review-code-apply-fixes.mdmarkdown4.3 KB
references/salvage-handling.mdmarkdown12.5 KB
references/summary-format.mdmarkdown10.0 KB
references/uv-check.mdmarkdown5.7 KB
references/wave-batching.mdmarkdown5.2 KB
review_commits_orchestrator.pyscript2.3 KB
review_plan_orchestrator.pyexecutablescript22.3 KB
review_tasks_orchestrator.pyscript10.7 KB
schemas/cascade_record.schema.jsonconfig6.6 KB
schemas/code_review_issues.schema.jsonconfig2.0 KB
schemas/consolidated.schema.jsonconfig6.8 KB
schemas/consolidation_batch.schema.jsonconfig3.7 KB
schemas/generated_tasks.schema.jsonconfig3.1 KB
schemas/host_capabilities.schema.jsonconfig38.3 KB
schemas/human_decision_verdicts.schema.jsonconfig2.6 KB
schemas/result_line.schema.jsonconfig10.1 KB
schemas/review_suggestions.schema.jsonconfig2.4 KB
schemas/state_file.schema.jsonconfig21.5 KB
schemas/status_file.schema.jsonconfig24.9 KB
schemas/status_json.schema.jsonconfig10.8 KB
schemas/subagent_tasks.schema.jsonconfig20.5 KB
schemas/task_decomposition.schema.jsonconfig1.2 KB
schemas/write_batch_result.schema.jsonconfig8.8 KB
templates/config/providers.override.yamlconfig17.2 KB
templates/consolidated_report_template.htmlother44.1 KB
templates/pr_report_template.htmlother181.2 KB
templates/report_template.htmlother67.5 KB
templates/shared/report_core.cssother4.1 KB
templates/shared/report_core.jsscript25.5 KB
update_plan_tasks.pyscript20.9 KB
utils/__init__.pyscript284 B
utils/advisory.pyscript4.8 KB
utils/apply_orchestrator_base.pyscript220.6 KB
utils/apply_output_helpers.pyscript10.9 KB
utils/apply_path_helpers.pyscript683 B
utils/apply_report.pyscript51.2 KB
utils/apply_selection_helpers.pyscript6.8 KB
utils/apply_suggestion_phase.pyscript11.7 KB
utils/atomic_io.pyscript12.9 KB
utils/attempt_classifier.pyscript31.4 KB
utils/backup.pyscript2.0 KB
utils/batch_done.pyscript79.2 KB
utils/batch_ledger.pyscript27.4 KB
utils/batch_prompt.pyscript29.3 KB
utils/batch_prompt_builder.pyscript12.2 KB
utils/batch_reply.pyscript32.9 KB
utils/cascade_archive.pyscript50.6 KB
utils/cascade_ledger.pyscript39.3 KB
utils/cascade_provenance.pyscript22.0 KB
utils/check_records.pyscript59.3 KB
utils/check_reply.pyscript9.5 KB
utils/check_tree.pyscript1.2 KB
utils/cli_common.pyscript91.2 KB
utils/cli_version_cache.pyscript14.0 KB
utils/clock.pyscript3.5 KB
utils/code_fix_batcher.pyscript30.6 KB
utils/codex_trust.pyscript12.9 KB
utils/commit_apply.pyscript73.3 KB
utils/commit_attribution.pyscript21.2 KB
utils/commit_brief.pyscript32.2 KB
utils/commit_front_door.pyscript81.6 KB
utils/commit_paths.pyscript18.0 KB
utils/commit_range.pyscript61.2 KB
utils/commit_report.pyscript19.9 KB
utils/commit_review.pyscript413 B
utils/commit_spelling.pyscript7.9 KB
utils/commit_write_guard.pyscript9.9 KB
utils/concurrency.pyscript11.6 KB
utils/consolidation.pyscript87.3 KB
utils/detach.pyscript186.8 KB
utils/dispatch_spawn.pyscript56.3 KB
utils/doctor.pyscript76.7 KB
utils/env_vars.pyscript20.5 KB
utils/failure_capture.pyscript10.1 KB
utils/file_discovery.pyscript11.0 KB
utils/filtering.pyscript19.9 KB
utils/git_diff.pyscript23.6 KB
utils/git_utils.pyscript86.6 KB
utils/held_folder.pyscript21.3 KB
utils/host_capabilities.pyscript48.0 KB
utils/host_install.pyscript77.6 KB
utils/host_paths.pyscript12.0 KB
utils/host_routes/__init__.pyscript5.7 KB
utils/host_routes/codex.pyscript18.3 KB
utils/host_routes/npm.pyscript12.2 KB
utils/host_shim.pyscript14.7 KB
utils/html_report_generator.pyscript118.9 KB
utils/human_decisions.pyscript38.3 KB
utils/human_task_plan.pyscript30.2 KB
utils/importance.pyscript6.2 KB
utils/improve_cascade.pyscript63.7 KB
utils/improve_cascade_next.pyscript22.2 KB
utils/improve_steps.pyscript32.4 KB
utils/improve_workflow.pyscript114.4 KB
utils/interactive.pyscript31.6 KB
utils/json_extractor.pyscript61.5 KB
utils/judge_vocab.pyscript5.3 KB
utils/known_checks.pyscript37.5 KB
utils/landlock_dispatch.pyscript103.8 KB
utils/landlock_exec.pyscript21.4 KB
utils/launch_limiter.pyscript13.5 KB
utils/llm_client.pyscript126.9 KB
utils/manual_tasks.pyscript14.9 KB
utils/metrics.pyscript68.1 KB
utils/next_phase.pyscript96.1 KB
utils/next_phase_words.pyscript6.4 KB
utils/output_handler.pyscript23.2 KB
utils/phase_walk.pyscript6.4 KB
utils/plan_updater.pyscript17.9 KB
utils/positionals.pyscript5.8 KB
utils/prior_changes.pyscript28.7 KB
utils/probe_state.pyscript17.9 KB
utils/process_capture.pyscript37.6 KB
utils/process_control.pyscript228.7 KB
utils/process_state.pyscript6.6 KB
utils/progress_tracker.pyscript92.2 KB
utils/prompt_channels.pyscript34.1 KB
utils/prompt_files.pyscript24.5 KB

utils/filtering.py

View on GitHub
"""Shared filtering logic for suggestions and code fixes."""

import copy
import re
import sys
from typing import Any, Dict, List, Optional, Set, Tuple

from .human_decisions import is_judge_source
from .judge_vocab import JUDGE_DECIDE, JUDGE_DECIDE_ITEM_IDS, upgrade_legacy
from . import importance as _importance
from .importance import get_highest_importance

from .validation import ERROR_TYPE_AMBIGUOUS


def resolve_bulk_option_conflicts(
    skip_all_human: bool = False,
    approve_all_human: bool = False,
    approve_all_low: bool = False,
    approve_importance_levels: Optional[List[str]] = None,
    approve_validation_failed: bool = False
) -> Tuple[Dict[str, Any], List[str]]:
    """
    Resolve conflicts between bulk approval options.

    Priority order (highest to lowest):
    1. skip_all_human (highest priority - safety first)
    2. approve_all_human (explicit full approval overrides selective)
    3. approve_importance_levels (explicit importance levels)
    4. approve_all_low (convenience shorthand)
    5. approve_validation_failed (lowest priority - only affects validation failures)

    Returns:
        Tuple of (effective_settings, warnings)
    """
    warnings = []
    effective = {
        "skip_all": False,
        "approve_all": False,
        "approve_importance_levels": [],
        "approve_validation_failed": False
    }

    # Priority 1: skip_all_human overrides everything
    if skip_all_human:
        effective["skip_all"] = True
        if approve_all_human or approve_all_low or approve_importance_levels:
            warnings.append(
                "WARNING: --skip-all-human overrides all approval options. "
                "All needs-human-decision items will be SKIPPED, not approved."
            )
        return effective, warnings

    # Priority 2: approve_all_human overrides selective options
    if approve_all_human:
        effective["approve_all"] = True
        if approve_all_low or approve_importance_levels:
            warnings.append(
                "WARNING: --approve-all overrides --approve-all-low and "
                "--approve-importance. ALL needs-human-decision items will be approved."
            )
        return effective, warnings

    # Priority 3: approve_importance_levels (explicit levels)
    if approve_importance_levels:
        effective["approve_importance_levels"] = [
            level.upper() for level in approve_importance_levels
        ]
        if approve_all_low and "LOW" not in effective["approve_importance_levels"]:
            warnings.append(
                "WARNING: --approve-importance does not include LOW but "
                "--approve-all-low was specified. Using --approve-importance levels only."
            )

    # Priority 4: approve_all_low (only if not superseded)
    elif approve_all_low:
        effective["approve_importance_levels"] = ["LOW"]

    # Priority 5: approve_validation_failed (additive, always applies)
    effective["approve_validation_failed"] = approve_validation_failed

    return effective, warnings


def should_bypass_no_selection_confirmation(
    no_confirm: bool = False,
    yes: bool = False,
    force: bool = False,
    approve_all: bool = False,
    skip_all_human: bool = False,
    approve_all_low: bool = False,
    approve_importance: Optional[List[str]] = None,
    approve_validation_failed: bool = False,
    dry_run: bool = False,
) -> bool:
    """Check if any flag implies deliberate user intent, bypassing the
    no-selections confirmation prompt."""
    return (
        no_confirm or yes or force or approve_all or skip_all_human
        or approve_all_low or bool(approve_importance)
        or approve_validation_failed or dry_run
    )


def filter_items(
    groups: List[Dict[str, Any]],
    min_priority: str = "low",
    skip_human_review: bool = False,
    approve_all_human: bool = False,
    approve_low_human: bool = False,
    approve_importance_levels: Optional[List[str]] = None,
    approve_validation_failed: bool = False,
    skip_all_human: bool = False,
    dry_run: bool = False
) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], List[Dict[str, Any]], Dict[str, Any]]:
    """
    Filter groups by validation status and importance.

    This shared function is used by both apply_suggestions_orchestrator.py
    and apply_code_fixes_orchestrator.py to avoid code duplication.

    Args:
        groups: List of grouped suggestions or issues
        min_priority: Minimum importance level to include (low, medium, high). Default: low (all valid items)
        skip_human_review: Skip all needs-human-decision items (legacy, prefer skip_all_human)
        approve_all_human: Auto-approve all needs-human-decision items
        approve_low_human: Auto-approve LOW importance needs-human-decision items
        approve_importance_levels: Auto-approve items at these importance levels
        approve_validation_failed: Auto-approve items with recoverable validation failures
        skip_all_human: Skip all needs-human-decision and validation_failed items
        dry_run: If True, don't modify groups, just report what would happen

    Returns:
        Tuple of (valid, needs_human, skipped, dry_run_report) lists
    """
    # Resolve conflicts first
    effective, warnings = resolve_bulk_option_conflicts(
        skip_all_human=skip_all_human,
        approve_all_human=approve_all_human,
        approve_all_low=approve_low_human,
        approve_importance_levels=approve_importance_levels,
        approve_validation_failed=approve_validation_failed
    )

    # Print warnings to stderr
    for warning in warnings:
        print(warning, file=sys.stderr)

    # The floor for valid items, in either case; one naming no level is LOW
    # (keep everything).
    min_importance = _importance.normalize(min_priority, "LOW")

    valid = []
    needs_human = []
    skipped = []
    dry_run_report = {
        "would_auto_approve": [],
        "would_skip": [],
        "warnings": warnings
    }

    for group in groups:
        status = group.get("validation_status", "needs-human-decision")
        importance = get_highest_importance(group)
        group["_importance"] = importance

        # Get error type for validation_failed items
        error_type = group.get("validation_error_type", group.get("error_type", "unknown"))

        if status == "invalid":
            skipped.append(group)
            continue

        # A "Let the agent decide" marker is an affirmative "route to the judge"
        # request and must never be auto-approved, regardless of the underlying
        # validation_status. This guards against conflicting overrides (e.g. a
        # group marked judge_decide that also got promoted to "valid", or a
        # group-level "valid" override alongside a per-suggestion judge_decide)
        # where the marker would otherwise fall through the status-specific
        # branches below. An explicit bulk *skip* still wins, matching the
        # needs-human-decision branch.
        if group.get(JUDGE_DECIDE) and not (
            effective["skip_all"] or skip_human_review
        ):
            needs_human.append(group)
            continue

        # Determine if this item should be auto-approved or skipped
        should_auto_approve = False
        should_skip = False
        approval_reason = None

        if status == "validation_failed":
            # Recoverable validation errors - can be revalidated or bulk approved
            if effective["skip_all"]:
                should_skip = True
            elif effective["approve_all"]:
                should_auto_approve = True
                approval_reason = "--approve-all"
            elif effective["approve_validation_failed"] and error_type != ERROR_TYPE_AMBIGUOUS:
                should_auto_approve = True
                approval_reason = "--approve-validation-failed"
            elif importance in effective["approve_importance_levels"]:
                should_auto_approve = True
                approval_reason = f"--approve-importance {importance}"

        elif status == "needs-human-decision":
            # Per-item "Let the agent decide" beats bulk *approval*: a marked item
            # is an affirmative "route to the judge" request, so keep it in
            # needs_human (never auto-approved/flipped to valid). Bulk *skip*
            # (--skip-all-human) is still honoured below — an explicit skip is a
            # safety choice, not a default-skip candidate.
            # NOTE: judge_decide is also handled by the status-agnostic guard
            # at the top of the loop; this branch-local check is a redundant
            # safety net kept for self-documentation.
            if group.get(JUDGE_DECIDE) and not (
                effective["skip_all"] or skip_human_review
            ):
                needs_human.append(group)
                continue
            # Check bulk approval options
            if effective["skip_all"]:
                should_skip = True
            elif skip_human_review:  # Legacy flag
                should_skip = True
            elif effective["approve_all"]:
                should_auto_approve = True
                approval_reason = "--approve-all"
            elif importance in effective["approve_importance_levels"]:
                should_auto_approve = True
                approval_reason = f"--approve-importance {importance}"

        elif status == "valid":
            if not _importance.at_least(importance, min_importance):
                skipped.append(group)
                continue
            else:
                valid.append(group)
                continue
        else:
            # Unknown status
            needs_human.append(group)
            continue

        # Apply the decision
        if should_auto_approve:
            if dry_run:
                dry_run_report["would_auto_approve"].append({
                    "group_index": group.get("group_index"),
                    "theme": group.get("theme", ""),
                    "importance": importance,
                    "original_status": status,
                    "reason": f"Would be auto-approved via {approval_reason}"
                })
                needs_human.append(group)  # Keep in needs_human for dry-run
            else:
                group["validation_status"] = "valid"
                group["validation_reason"] = f"Auto-approved (was {status}, importance={importance})"
                group["auto_approved"] = True
                group["auto_approval_reason"] = approval_reason
                valid.append(group)
        elif should_skip:
            if dry_run:
                dry_run_report["would_skip"].append({
                    "group_index": group.get("group_index"),
                    "theme": group.get("theme", ""),
                    "importance": importance,
                    "original_status": status,
                    "reason": "Would be skipped via --skip-all-human"
                })
            skipped.append(group)
        else:
            needs_human.append(group)

    return valid, needs_human, skipped, dry_run_report


def validate_judge_decide_items_honored(
    human_review_config: Dict[str, Any],
    recorded_decisions: Dict[str, Any],
) -> Tuple[bool, List[str]]:
    """Verify every report-pre-marked "Let the agent decide" item reached the judge.

    The per-item routing decision (judge-without-prompting vs. prompt) is made
    by the host agent following the prose in the apply instructions; this is a
    post-hoc audit, not a hard pre-flight gate. For every id in
    ``human_review_config["judge_decide_item_ids"]`` it checks that a decision
    was recorded and that the decision's ``batch_context.decision_source`` is
    ``judge_auto_decide`` or ``judge_auto_decide_salvage`` (i.e. it was
    actually routed to the judge, not prompted or skipped). A config or a
    record in the ``claude_*`` spelling an earlier version wrote reads the same.

    Args:
        human_review_config: The human_review_config from orchestrator output.
        recorded_decisions: The recorded decisions from state
            (group_id -> decision).

    Returns:
        Tuple of (is_valid, warnings).
        - is_valid: True if every pre-marked id was routed to the judge.
        - warnings: List of warning messages for any id that is missing a
          decision or whose decision carries a different source.
    """
    warnings: List[str] = []

    config = upgrade_legacy(copy.deepcopy(dict(human_review_config or {})))
    item_ids = [gid for gid in config.get(JUDGE_DECIDE_ITEM_IDS, []) if gid]
    if not item_ids:
        return True, []  # Nothing pre-marked, nothing to audit.

    is_valid = True

    for gid in item_ids:
        decision = recorded_decisions.get(gid)
        if not decision:
            is_valid = False
            warnings.append(
                f"WARNING: report-pre-marked 'Let the agent decide' item {gid} has "
                f"no recorded decision. It may have been prompted interactively "
                f"or dropped instead of routed to the judge."
            )
            continue
        batch_ctx = decision.get("batch_context") or {}
        source = batch_ctx.get("decision_source")
        if not is_judge_source(source):
            is_valid = False
            warnings.append(
                f"WARNING: report-pre-marked 'Let the agent decide' item {gid} was "
                f"recorded with decision_source {source!r}, not a judge-agent "
                f"source (judge_auto_decide / judge_auto_decide_salvage). It may have "
                f"been prompted instead of auto-decided."
            )

    return is_valid, warnings


def filter_user_skipped_groups(
    groups: List[Dict[str, Any]],
    skipped_group_hashes: Set[str],
    skipped_suggestion_hashes: Set[str],
    old_skipped_ids: Set[str],
) -> Tuple[List[Dict[str, Any]], int]:
    """Filter out skipped groups and remove skipped suggestions from remaining groups.

    Groups are matched by their ``group_hash`` field against *skipped_group_hashes*.
    Individual suggestions are matched by their ``suggestion_hash`` field against
    *skipped_suggestion_hashes*, or their legacy ID (e.g. ``S001``) against
    *old_skipped_ids*. Groups left with zero suggestions after individual
    filtering are dropped entirely.

    Unmatched hashes in the skip sets produce a warning on stderr rather than
    being silently ignored.

    Args:
        groups: List of group dicts, each containing a ``suggestions`` list.
            Each group should have a ``group_hash`` field, and each suggestion
            should have a ``suggestion_hash`` field (stamped by stamp_stable_ids).
        skipped_group_hashes: Group hash strings to skip entirely.
        skipped_suggestion_hashes: Suggestion hash strings to skip.
        old_skipped_ids: Legacy IDs (e.g. ``S001``) to skip.

    Returns:
        Tuple of (filtered_groups, user_skipped_count)
    """

    # --- Sanitize skipped_group_hashes: filter out non-str elements ---
    sanitized_group_hashes: Set[str] = set()
    for h in skipped_group_hashes:
        if not isinstance(h, str):
            print(
                f"WARNING: Skipped group hash {h!r} is not a string. "
                f"Ignoring.",
                file=sys.stderr,
            )
        else:
            sanitized_group_hashes.add(h)
    skipped_group_hashes = sanitized_group_hashes

    # --- Build set of known group hashes for validation ---
    known_group_hashes: Set[str] = set()
    known_suggestion_hashes: Set[str] = set()
    for group in groups:
        ghash = group.get("group_hash", "")
        if ghash:
            known_group_hashes.add(ghash)
        for sugg in group.get("suggestions", []):
            shash = sugg.get("suggestion_hash", "")
            if shash:
                known_suggestion_hashes.add(shash)

    # --- Warn about unmatched group hashes ---
    hex_re = re.compile(r'^[0-9a-f]{8,16}$')
    for h in sorted(skipped_group_hashes):
        if not hex_re.match(h):
            print(
                f"WARNING: Skipped group hash '{h}' is malformed "
                f"(expected 8-16 char hex string). Ignoring.",
                file=sys.stderr,
            )
        elif h not in known_group_hashes:
            # Check prefix match (display hash may be 8 chars of 16-char canonical)
            prefix_matches = [kh for kh in known_group_hashes if kh.startswith(h)]
            if prefix_matches:
                # Use the prefix match (should be exactly one)
                if len(prefix_matches) == 1:
                    skipped_group_hashes = (skipped_group_hashes - {h}) | {prefix_matches[0]}
                else:
                    print(
                        f"WARNING: Skipped group hash '{h}' matches multiple "
                        f"groups ({len(prefix_matches)} matches). Ignoring.",
                        file=sys.stderr,
                    )
            else:
                print(
                    f"WARNING: Skipped group hash '{h}' does not match any "
                    f"group in the current groups. Ignoring.",
                    file=sys.stderr,
                )

    # --- Sanitize skipped_suggestion_hashes ---
    sanitized_suggestion_hashes: Set[str] = set()
    for h in skipped_suggestion_hashes:
        if not isinstance(h, str):
            print(
                f"WARNING: Skipped suggestion hash {h!r} is not a string. "
                f"Ignoring.",
                file=sys.stderr,
            )
        else:
            sanitized_suggestion_hashes.add(h)
    skipped_suggestion_hashes = sanitized_suggestion_hashes

    # --- Resolve prefix matches for suggestion hashes ---
    resolved_suggestion_hashes: Set[str] = set()
    for h in skipped_suggestion_hashes:
        if h in known_suggestion_hashes:
            resolved_suggestion_hashes.add(h)
        else:
            # Check prefix match
            prefix_matches = [kh for kh in known_suggestion_hashes if kh.startswith(h)]
            if len(prefix_matches) == 1:
                resolved_suggestion_hashes.add(prefix_matches[0])
            elif len(prefix_matches) > 1:
                print(
                    f"WARNING: Skipped suggestion hash '{h}' matches multiple "
                    f"suggestions ({len(prefix_matches)} matches). Ignoring.",
                    file=sys.stderr,
                )
            else:
                if hex_re.match(h):
                    print(
                        f"WARNING: Skipped suggestion hash '{h}' does not match "
                        f"any suggestion in the current groups. Ignoring.",
                        file=sys.stderr,
                    )
                # If not hex, it might be a legacy G-format ID; skip silently
    skipped_suggestion_hashes = resolved_suggestion_hashes

    # --- Filter groups and suggestions ---
    result = []
    user_skipped_count = 0
    for group in groups:
        group_hash = group.get("group_hash", "")

        # Skip entire group if its hash is in the skip set
        if group_hash and group_hash in skipped_group_hashes:
            user_skipped_count += len(group.get("suggestions", []))
            continue

        # Filter individual suggestions within the group
        original_suggestions = group.get("suggestions", [])
        filtered_suggestions = []
        for sugg in original_suggestions:
            sugg_hash = sugg.get("suggestion_hash", "")
            old_id = sugg.get("id", "")  # Old format ID like "S001"

            # Skip if hash matches
            if sugg_hash and sugg_hash in skipped_suggestion_hashes:
                user_skipped_count += 1
                continue
            # Skip if legacy ID matches
            if old_id and old_id in old_skipped_ids:
                user_skipped_count += 1
                continue

            filtered_suggestions.append(sugg)

        # Only include group if it has remaining suggestions
        if filtered_suggestions:
            group_copy = dict(group)
            group_copy["suggestions"] = filtered_suggestions
            result.append(group_copy)
        elif original_suggestions:
            # Group had suggestions but all were skipped
            pass  # Already counted individually

    return result, user_skipped_count
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 321kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 321kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 321kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 321kUpdated Claude CodeCodexVerifiedInstall