self-repair-pipeline

name: self-repair-pipeline description: Runs the full entry point self-repair pipeline. Detects entry points in Ariadne packages or external codebases, triages false positives via sub-agents, plans fixes for each issue group with competing proposals and multi-angle review, and creates backlog tasks. argument-hint: "[config-name | /path/to/repo | owner/repo (GitHub)]" disable-model-invocation: true allowed-tools: Bash(npx tsx:,pnpm exec tsx:), Read, Write, Task(triage-investigator, triage-aggregator, triage-rule-reviewer, fix-planner, plan-synthesizer, plan-reviewer, task-writer) hooks: Stop: - hooks: - type: command command: 'pnpm exec tsx "$CLAUDE_PROJECT_DIR/.claude/skills/self-repair-pipeline/scripts/triage_loop_stop.ts"' timeout: 30

Self-Repair Pipeline

Triage pipeline for entry point analysis: detect false positives, classify root causes, plan fixes, and create backlog tasks. Supports both self-analysis (Ariadne packages) and external codebase analysis.

Pipeline Overview

Analysis Target

User input: $ARGUMENTS

Resolve the analysis target from the user's input using this routing table:

Available project configs:

If no arguments are provided or the input is ambiguous, ask the user before proceeding.

Current State

!cat .claude/skills/self-repair-pipeline/triage_state/*_triage.json 2>/dev/null || echo "No active triage"

State and Output Locations

All paths above are relative to .claude/skills/self-repair-pipeline/.

Phase 1: Detect

Use the target resolved from the Analysis Target section above to construct the detect command.

# From project config (preferred for Ariadne packages)
pnpm exec tsx .claude/skills/self-repair-pipeline/scripts/detect_entrypoints.ts \
  --config .claude/skills/self-repair-pipeline/project_configs/core.json

# Local repository
pnpm exec tsx .claude/skills/self-repair-pipeline/scripts/detect_entrypoints.ts --path /path/to/repo

# GitHub repository
pnpm exec tsx .claude/skills/self-repair-pipeline/scripts/detect_entrypoints.ts --github owner/repo

Options: --config <file>, --path <dir>, --github <repo>, --branch <name>, --depth <n>, --output <file>, --include-tests, --folders <paths>, --exclude <patterns>

Tracked project configs for Ariadne packages: project_configs/{core,mcp,types}.json

Output: analysis_output/<project>/detect_entrypoints/<timestamp>.json

Phase 2: Prepare

Build triage state from the latest analysis output:

pnpm exec tsx .claude/skills/self-repair-pipeline/scripts/prepare_triage.ts \
  --analysis .claude/skills/self-repair-pipeline/analysis_output/<project>/detect_entrypoints/<timestamp>.json \
  --package <name> \
  --batch-size 5

Options: --analysis <path> (required), --package <name>, --state <path>, --batch-size <n> (default 5)

The script loads the known-entrypoints registry and classifies entries:

• known-tp: Matches registry — marked completed immediately
• llm-triage: No registry match — marked pending for investigation

Output: triage_state/{project}_triage.json

Phase 3: Triage Loop

The Stop hook (triage_loop_stop.ts) drives this phase as a state machine. Each time Claude tries to stop, the hook reads the state file, determines what to do next, and either BLOCKs with instructions or ALLOWs completion.

3a. Investigate Pending Entries

For each pending entry in the state file:

1. Read the entry's diagnosis field to select the prompt template:

   Diagnosis	Template	Focus
   callers-not-in-registry	templates/prompt_callers_not_in_registry.md	File coverage gap investigation
   callers-in-registry-unresolved	templates/prompt_resolution_failure.md	Resolution failure pattern identification
   callers-in-registry-wrong-target	templates/prompt_wrong_target.md	Wrong resolution target analysis
   All other diagnoses	templates/prompt_generic.md	Broad investigation

2. Read the template and substitute {{entry.*}} placeholders with values from the entry

3. Launch a triage-investigator sub-agent with run_in_background: true. Include output_path = triage_state/results/{entry.entry_index}.json in the prompt

4. Do not read or process the sub-agent's response. The stop hook merges result files automatically

Process entries in batches of batch_size (from state file). The stop hook re-triggers after each batch.

3b. Aggregation

When all entries are completed, the stop hook transitions to aggregation phase.

Launch a triage-aggregator sub-agent with the state file path. The aggregator:

• Reviews all completed entry results
• Groups entries by shared root cause
• Merges duplicate/overlapping group IDs
• Writes aggregation: { status: "completed", completed_at: ... } to the state file

3c. Meta-Review

If aggregation found false-positive entries, the stop hook transitions to meta-review phase.

Launch a triage-rule-reviewer sub-agent with the state file path. The reviewer:

• Analyzes false-positive patterns across entries
• Proposes deterministic classification rules
• Writes meta_review: { status: "completed", patterns: ..., completed_at: ... } to the state file

Phase 4: Fix Planning

If meta-review found multi-entry false-positive groups (>1 entry sharing the same group_id), the stop hook transitions to fix-planning phase. Single-entry groups are recorded but skipped.

Fix planning proceeds per group through four sub-phases:

4a. Planning

Launch 5 fix-planner sub-agents for each group. Each generates an independent fix proposal.

Output: triage_state/fix_plans/{group_id}/plan_{n}.md

Update plans_written in the state file after each plan is written.

4b. Synthesis

Launch a plan-synthesizer sub-agent that reads all 5 plans and produces a unified fix approach.

Output: triage_state/fix_plans/{group_id}/synthesis.md

Set synthesis_written: true in the state file.

4c. Review

Launch 4 plan-reviewer sub-agents, each reviewing from a different angle:

• Information architecture
• Simplicity
• Fundamentality
• Language coverage

Output: triage_state/fix_plans/{group_id}/review_{angle}.md

Update reviews_written in the state file after each review.

4d. Task Writing

Launch a task-writer sub-agent that creates a backlog task using templates/backlog_task_template.md.

Set task_file in the state file to the created task path.

Phase 5: Finalize

After the stop hook ALLOWs completion (all phases done or error exit), run finalization:

pnpm exec tsx .claude/skills/self-repair-pipeline/scripts/finalize_triage.ts \
  --state .claude/skills/self-repair-pipeline/triage_state/{project}_triage.json

Finalization:

• Partitions entries into true positives, dead code, and false-positive groups
• Saves triage results JSON to analysis_output/<project>/triage_results/
• Updates the known-entrypoints registry with confirmed true positives and dead code
• Writes triage patterns file (if meta-review produced patterns)

Architecture: Key Modules

All library modules live under src/:

Reference

• State Machine: Phase Transitions and BLOCK/ALLOW Logic
• Diagnosis Routes: Routing Table and Escape Hatch
• Sample Triage Output

Sub-Agents