pi-skill-search 0.1.0

package/skills/deepinit/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: deepinit
+description: Deep codebase initialization with hierarchical AGENTS.md documentation
+---
+
+# Deep Init Skill
+
+Creates comprehensive, hierarchical AGENTS.md documentation across the entire codebase.
+
+## Core Concept
+
+AGENTS.md files serve as **AI-readable documentation** that helps agents understand:
+- What each directory contains
+- How components relate to each other
+- Special instructions for working in that area
+- Dependencies and relationships
+
+## Hierarchical Tagging System
+
+Every AGENTS.md (except root) includes a parent reference tag:
+
+```markdown
+<!-- Parent: ../AGENTS.md -->
+```
+
+This creates a navigable hierarchy:
+```
+/AGENTS.md                          ← Root (no parent tag)
+├── src/AGENTS.md                   ← <!-- Parent: ../AGENTS.md -->
+│   ├── src/components/AGENTS.md    ← <!-- Parent: ../AGENTS.md -->
+│   └── src/utils/AGENTS.md         ← <!-- Parent: ../AGENTS.md -->
+└── docs/AGENTS.md                  ← <!-- Parent: ../AGENTS.md -->
+```
+
+## AGENTS.md Template
+
+```markdown
+<!-- Parent: {relative_path_to_parent}/AGENTS.md -->
+<!-- Generated: {timestamp} | Updated: {timestamp} -->
+
+# {Directory Name}
+
+## Purpose
+{One-paragraph description of what this directory contains and its role}
+
+## Key Files
+{List each significant file with a one-line description}
+
+| File | Description |
+|------|-------------|
+| `file.ts` | Brief description of purpose |
+
+## Subdirectories
+{List each subdirectory with brief purpose}
+
+| Directory | Purpose |
+|-----------|---------|
+| `subdir/` | What it contains (see `subdir/AGENTS.md`) |
+
+## For AI Agents
+
+### Working In This Directory
+{Special instructions for AI agents modifying files here}
+
+### Testing Requirements
+{How to test changes in this directory}
+
+### Common Patterns
+{Code patterns or conventions used here}
+
+## Dependencies
+
+### Internal
+{References to other parts of the codebase this depends on}
+
+### External
+{Key external packages/libraries used}
+
+<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->
+```
+
+## Execution Workflow
+
+### Step 1: Map Directory Structure
+
+```
+Task(subagent_type="explore", model="haiku",
+  prompt="List all directories recursively. Exclude: node_modules, .git, dist, build, __pycache__, .venv, coverage, .next, .nuxt")
+```
+
+### Step 2: Create Work Plan
+
+Generate todo items for each directory, organized by depth level:
+
+```
+Level 0: / (root)
+Level 1: /src, /docs, /tests
+Level 2: /src/components, /src/utils, /docs/api
+...
+```

package/skills/deeptools/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: deeptools
+description: NGS analysis toolkit. BAM to bigWig conversion, QC (correlation, PCA, fingerprints), heatmaps/profiles (TSS, peaks), for ChIP-seq, RNA-seq, ATAC-seq visualization.
+---
+
+# deepTools: NGS Data Analysis Toolkit
+
+## Overview
+
+deepTools is a comprehensive suite of Python command-line tools designed for processing and analyzing high-throughput sequencing data. Use deepTools to perform quality control, normalize data, compare samples, and generate publication-quality visualizations for ChIP-seq, RNA-seq, ATAC-seq, MNase-seq, and other NGS experiments.
+
+**Core capabilities:**
+- Convert BAM alignments to normalized coverage tracks (bigWig/bedGraph)
+- Quality control assessment (fingerprint, correlation, coverage)
+- Sample comparison and correlation analysis
+- Heatmap and profile plot generation around genomic features
+- Enrichment analysis and peak region visualization
+
+## When to Use This Skill
+
+This skill should be used when:
+
+- **File conversion**: "Convert BAM to bigWig", "generate coverage tracks", "normalize ChIP-seq data"
+- **Quality control**: "check ChIP quality", "compare replicates", "assess sequencing depth", "QC analysis"
+- **Visualization**: "create heatmap around TSS", "plot ChIP signal", "visualize enrichment", "generate profile plot"
+- **Sample comparison**: "compare treatment vs control", "correlate samples", "PCA analysis"
+- **Analysis workflows**: "analyze ChIP-seq data", "RNA-seq coverage", "ATAC-seq analysis", "complete workflow"
+- **Working with specific file types**: BAM files, bigWig files, BED region files in genomics context
+
+## Quick Start
+
+For users new to deepTools, start with file validation and common workflows:
+
+### 1. Validate Input Files
+
+Before running any analysis, validate BAM, bigWig, and BED files using the validation script:
+
+```bash
+python scripts/validate_files.py --bam sample1.bam sample2.bam --bed regions.bed
+```
+
+This checks file existence, BAM indices, and format correctness.
+
+### 2. Generate Workflow Template
+
+For standard analyses, use the workflow generator to create customized scripts:
+
+```bash
+# List available workflows
+python scripts/workflow_generator.py --list
+
+# Generate ChIP-seq QC workflow
+python scripts/workflow_generator.py chipseq_qc -o qc_workflow.sh \
+    --input-bam Input.bam --chip-bams "ChIP1.bam ChIP2.bam" \
+    --genome-size 2913022398
+
+# Make executable and run
+chmod +x qc_workflow.sh
+./qc_workflow.sh
+```
+
+### 3. Most Common Operations
+
+See `assets/quick_reference.md` for frequently used commands and parameters.
+
+## Core Workflows
+
+deepTools workflows typically follow this pattern: **QC → Normalization → Comparison/Visualization**
+
+### ChIP-seq Quality Control Workflow
+
+When users request ChIP-seq QC or quality assessment:
+
+1. **Generate workflow script** using `scripts/workflow_generator.py chipseq_qc`
+2. **Key QC steps**:
+   - Sample correlation (multiBamSummary + plotCorrelation)
+   - PCA analysis (plotPCA)
+   - Coverage assessment (plotCoverage)
+   - Fragment size validation (bamPEFragmentSize)
+   - ChIP enrichment strength (plotFingerprint)
+
+**Interpreting results:**
+- **Correlation**: Replicates should cluster together with high correlation (>0.9)
+- **Fingerprint**: Strong ChIP shows steep rise; flat diagonal indicates poor enrichment
+
+### ChIP-seq Complete Analysis Workflow
+
+For full ChIP-seq analysis from BAM to visualizations:
+
+1. **Generate coverage tracks** with normalization (bamCoverage)
+2. **Create comparison tracks** (bamCompare for log2 ratio)
+3. **Compute signal matrices** around features (computeMatrix)
+4. **Generate visualizations** (plotHeatmap, plotProfile)
+5. **Enrichment analysis** at peaks (plotEnrichment)
+
+Use `scripts/workflow_generator.py chipseq_analysis` to generate template.
+
+Complete command sequences in `(see docs)` → "ChIP-seq Analysis Workflow"
+
+### RNA-seq Coverage Workflow
+
+For strand-specific RNA-seq coverage tracks:
+
+Use bamCoverage with `--filterRNAstrand` to separate forward and reverse strands.
+
+**Important:** NEVER use `--extendReads` for RNA-seq (would extend over splice junctions).
+
+Use normalization: CPM for fixed bins, RPKM for gene-level analysis.
+
+Template available: `scripts/workflow_generator.py rnaseq_coverage`
+
+Details in `(see docs)` → "RNA-seq Coverage Workflow"
+
+### ATAC-seq Analysis Workflow
+
+ATAC-seq requires Tn5 offset correction:
+
+

package/skills/delegation-patterns/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: delegation-patterns
+description: Subagent/team delegation workflow. Use when splitting work across pi-crew teams, direct agents, async background workers, chains, or parallel research/review tasks.
+---
+
+
+# delegation-patterns
+
+Use this skill when deciding how to delegate work.
+
+## Source patterns distilled
+
+- pi-subagents: foreground/background/parallel/chain execution, fork/fresh context, worktree isolation, result watcher
+- pi-crew: `src/extension/team-tool/run.ts`, `src/runtime/team-runner.ts`, `src/runtime/task-graph-scheduler.ts`, builtin `teams/*.team.md`, `workflows/*.workflow.md`
+- Existing pi-crew skill: `task-packet`
+
+## Rules
+
+- Delegate when tasks span multiple files/subsystems, need planning/review/verification, or can be independently researched.
+- Do not parallelize edits to the same file, symbol, migration path, manifest/lockfile, or generated schema unless explicitly sequenced.
+- Use read-only explorer/reviewer roles for source audit; implementation workers should receive narrow task packets.
+- For async/background work, provide concrete objective, scope, constraints, outputs, and verification. Do not spin in wait loops; retrieve results when notified or when needed.
+- For chain-style work, pass dependency outputs forward explicitly and require downstream workers to read upstream artifacts first.
+- Use worktree isolation for risky parallel code-changing tasks when repository cleanliness and merge plan allow it.
+- Require workers to report blockers and smallest recoverable next action rather than making broad assumptions.
+
+## Task packet checklist
+
+- objective
+- scope/paths
+- allowed edits vs read-only areas
+- constraints and project rules
+- dependencies/input artifacts
+- expected output artifacts
+- acceptance criteria
+- verification commands
+- escalation conditions
+
+## Anti-patterns
+
+- Sending broad “fix everything” prompts to multiple editors in one workspace.
+- Waiting for async workers by sleeping/polling when result notifications exist.
+- Letting review workers modify files.
+- Claiming completion without durable artifacts or verification evidence.
+
+## Verification
+
+For orchestration changes:
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/team-recommendation.test.ts test/unit/task-output-context-security.test.ts test/integration/phase3-runtime.test.ts
+npm test
+```
+

package/skills/depmap/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: depmap
+description: Query the Cancer Dependency Map (DepMap) for cancer cell line gene dependency scores (CRISPR Chronos), drug sensitivity data, and gene effect profiles. Use for identifying cancer-specific vulnerabilities, synthetic lethal interactions, and validating oncology drug targets.
+---
+
+# DepMap — Cancer Dependency Map
+
+## Overview
+
+The Cancer Dependency Map (DepMap) project, run by the Broad Institute, systematically characterizes genetic dependencies across hundreds of cancer cell lines using genome-wide CRISPR knockout screens (DepMap CRISPR), RNA interference (RNAi), and compound sensitivity assays (PRISM). DepMap data is essential for:
+- Identifying which genes are essential for specific cancer types
+- Finding cancer-selective dependencies (therapeutic targets)
+- Validating oncology drug targets
+- Discovering synthetic lethal interactions
+
+**Key resources:**
+- DepMap Portal: https://depmap.org/portal/
+- DepMap data downloads: https://depmap.org/portal/download/all/
+- Python package: `depmap` (or access via API/downloads)
+- API: https://depmap.org/portal/api/
+
+## When to Use This Skill
+
+Use DepMap when:
+
+- **Target validation**: Is a gene essential for survival in cancer cell lines with a specific mutation (e.g., KRAS-mutant)?
+- **Biomarker discovery**: What genomic features predict sensitivity to knockout of a gene?
+- **Synthetic lethality**: Find genes that are selectively essential when another gene is mutated/deleted
+- **Drug sensitivity**: What cell line features predict response to a compound?
+- **Pan-cancer essentiality**: Is a gene broadly essential across all cancer types (bad target) or selectively essential?
+- **Correlation analysis**: Which pairs of genes have correlated dependency profiles (co-essentiality)?
+
+## Core Concepts
+
+### Dependency Scores
+
+| Score | Range | Meaning |
+|-------|-------|---------|
+| **Chronos** (CRISPR) | ~ -3 to 0+ | More negative = more essential. Common essential threshold: −1. Pan-essential genes ~−1 to −2 |
+| **RNAi DEMETER2** | ~ -3 to 0+ | Similar scale to Chronos |
+| **Gene Effect** | normalized | Normalized Chronos; −1 = median effect of common essential genes |
+
+**Key thresholds:**
+- Chronos ≤ −0.5: likely dependent
+- Chronos ≤ −1: strongly dependent (common essential range)
+
+### Cell Line Annotations
+
+Each cell line has:
+- `DepMap_ID`: unique identifier (e.g., `ACH-000001`)
+- `cell_line_name`: human-readable name
+- `primary_disease`: cancer type
+- `lineage`: broad tissue lineage
+- `lineage_subtype`: specific subtype
+
+## Core Capabilities
+
+### 1. DepMap API
+
+```python
+import requests
+import pandas as pd
+
+BASE_URL = "https://depmap.org/portal/api"
+
+def depmap_get(endpoint, params=None):
+    url = f"{BASE_URL}/{endpoint}"
+    response = requests.get(url, params=params)
+    response.raise_for_status()
+    return response.json()
+```
+
+### 2. Gene Dependency Scores
+
+```python
+def get_gene_dependency(gene_symbol, dataset="Chronos_Combined"):
+    """Get CRISPR dependency scores for a gene across all cell lines."""
+    url = f"{BASE_URL}/gene"
+    params = {
+        "gene_id": gene_symbol,
+        "dataset": dataset
+    }
+    response = requests.get(url, params=params)
+    return response.json()
+
+# Alternatively, use the /data endpoint:
+def get_dependencies_slice(gene_symbol, dataset_name="CRISPRGeneEffect"):
+    """Get a gene's dependency slice from a dataset."""
+    url = f"{BASE_URL}/data/gene_dependency"
+    params = {"gene_name": gene_symbol, "dataset_name": dataset_name}
+    response = requests.get(url, params=params)
+    data = response.json()
+    return data
+```

package/skills/dhdna-profiler/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: dhdna-profiler
+description: Extract cognitive patterns and thinking fingerprints from any text. Use this skill when the user wants to analyze how someone thinks, understand cognitive style, profile writing or speech patterns, compare thinking styles between people, asks "what's my thinking style", "analyze how this person reasons", "cognitive profile", "thinking pattern", "DHDNA", "digital DNA", or wants to understand the mind behind any text. Also trigger when the user provides text and wants deeper insight into the author's reasoning patterns, decision-making style, or cognitive signature.
+---
+
+# DHDNA Profiler — Cognitive Pattern Extraction
+
+A structured system for extracting the cognitive fingerprint of any text's author. Based on the Digital Human DNA (DHDNA) framework — the theory that every mind has a unique signature pattern expressed through how it reasons, decides, values, and communicates.
+
+Published research: [DHDNA Pre-print (DOI: 10.5281/zenodo.18736629)](https://doi.org/10.5281/zenodo.18736629) | [IDNA Consolidation v2 (DOI: 10.5281/zenodo.18807387)](https://doi.org/10.5281/zenodo.18807387)
+
+## Core Concept
+
+Just as biological DNA encodes physical identity through base pairs, Digital Human DNA encodes cognitive identity through thinking patterns. Every person's combination of analytical depth, creative range, emotional processing, strategic thinking, and ethical reasoning creates a **unique cognitive signature** — as distinctive as a fingerprint.
+
+The profiler doesn't judge thinking as "good" or "bad." It maps the topology of how a mind works.
+
+## The 12 Cognitive Dimensions
+
+When profiling text, score each dimension on a 1–10 scale based on evidence in the text:
+
+| #   | Dimension                | What It Measures                                                 | Low Score (1-3)                    | High Score (8-10)                           |
+| --- | ------------------------ | ---------------------------------------------------------------- | ---------------------------------- | ------------------------------------------- |
+| 1   | **Analytical Depth**     | Logical rigor, structured reasoning, causal chains               | Intuitive, holistic, pattern-based | Systematic, proof-oriented, precise         |
+| 2   | **Creative Range**       | Novelty of connections, metaphor use, lateral thinking           | Conventional, incremental          | Paradigm-breaking, cross-domain synthesis   |
+| 3   | **Emotional Processing** | Emotional vocabulary, empathy signals, affect integration        | Detached, clinical                 | Emotionally rich, feeling-integrated        |
+| 4   | **Linguistic Precision** | Vocabulary sophistication, sentence architecture, rhetoric       | Simple, direct                     | Architecturally complex, nuanced            |
+| 5   | **Ethical Reasoning**    | Values signals, fairness concern, consequence awareness          | Pragmatic, outcome-focused         | Principle-driven, justice-oriented          |
+| 6   | **Strategic Thinking**   | Long-term planning, competitive awareness, resource optimization | Tactical, reactive                 | Multi-move, game-theoretic                  |
+| 7   | **Memory Integration**   | Reference to past experience, historical patterns, continuity    | Present-focused                    | Deep historical awareness, precedent-driven |
+| 8   | **Social Intelligence**  | Audience awareness, perspective-taking, relational framing       | Self-referential                   | Deeply other-aware, coalition-building      |
+| 9   | **Domain Expertise**     | Technical depth, specialized knowledge, jargon confidence        | Generalist                         | Deep specialist                             |
+
+### The 6 Tension Pairs
+
+Dimensions exist in tension — high scores on one often correlate with lower scores on its pair. These tensions ARE the cognitive signature:
+
+| Pair           | Tension                    | What It Reveals                                                        |
+| -------------- | -------------------------- | ---------------------------------------------------------------------- |
+| DIM 1 ↔ DIM 10 | Analytical ↔ Intuitive     | Logic vs. Gut — how the mind reaches conclusions                       |
+| DIM 3 ↔ DIM 6  | Emotional ↔ Strategic      | Heart vs. Head — what drives decisions                                 |
+| DIM 2 ↔ DIM 5  | Creative ↔ Ethical         | Freedom vs. Framework — innovation within or beyond rules              |
+| DIM 4 ↔ DIM 12 | Linguistic ↔ Metacognitive | Expression vs. Self-Awareness — external craft vs. internal reflection |
+| DIM 7 ↔ DIM 11 | Memory ↔ Temporal          | Past vs. Time Itself — experience vs. time-horizon                     |
+| DIM 8 ↔ DIM 9  | Social ↔ Domain            | Breadth vs. Depth — people skills vs. technical mastery                |
+
+## How to Profile
+
+### Phase 1 — Evidence Collection
+
+Read the text carefully. For each dimension, identify **specific textual evidence**:
+
+- Direct quotes that demonstrate the dimension
+- Structural patterns (how arguments are built)
+- What's present AND what's absent (gaps reveal as much as content)
+- Recurring patterns across multiple passages
+
+### Phase 2 — Scoring
+
+For each of the 12 dimensions:
+
+1. Score 1-10 based on evidence
+2. Cite the strongest textual evidence for that score
+3. Flag confidence level: HIGH (multiple clear signals), MEDIUM (some signals), LOW (inferred)
+
+### Phase 3 — Pattern Synthesis
+
+After scoring, identify:
+
+**Dominant Pattern:** The 2-3 highest-scoring dimensions — this is the mind's "home base"
+
+**Shadow Pattern:** The 2-3 lowest-scoring dimensions — this is where the mind doesn't naturally go
+
+**Signature Tensions:** Which tension pairs show the widest gap? These define the cognitive style more than any individual score.
+
+**Reasoning Topology:** How does the mind move through ideas?
+
+- Linear (A → B → C → conclusion)
+- Spiral (approaches the same idea from multiple angles, each time deeper)
+- Web (connects disparate domains into synthesis)
+
+### Phase 4 — Profile Output
+
+Present the profile as:
+
+

package/skills/diffdock/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: diffdock
+description: Diffusion-based molecular docking. Predict protein-ligand binding poses from PDB/SMILES, confidence scores, virtual screening, for structure-based drug design. Not for affinity prediction.
+---
+
+# DiffDock: Molecular Docking with Diffusion Models
+
+## Overview
+
+DiffDock is a diffusion-based deep learning tool for molecular docking that predicts 3D binding poses of small molecule ligands to protein targets. It represents the state-of-the-art in computational docking, crucial for structure-based drug discovery and chemical biology.
+
+**Core Capabilities:**
+- Predict ligand binding poses with high accuracy using deep learning
+- Support protein structures (PDB files) or sequences (via ESMFold)
+- Process single complexes or batch virtual screening campaigns
+- Generate confidence scores to assess prediction reliability
+- Handle diverse ligand inputs (SMILES, SDF, MOL2)
+
+**Key Distinction:** DiffDock predicts **binding poses** (3D structure) and **confidence** (prediction certainty), NOT binding affinity (ΔG, Kd). Always combine with scoring functions (GNINA, MM/GBSA) for affinity assessment.
+
+## When to Use This Skill
+
+This skill should be used when:
+
+- "Dock this ligand to a protein" or "predict binding pose"
+- "Run molecular docking" or "perform protein-ligand docking"
+- "Virtual screening" or "screen compound library"
+- "Where does this molecule bind?" or "predict binding site"
+- Structure-based drug design or lead optimization tasks
+- Tasks involving PDB files + SMILES strings or ligand structures
+- Batch docking of multiple protein-ligand pairs
+
+### Check Environment Status
+
+Before proceeding with DiffDock tasks, verify the environment setup:
+
+```bash
+# Use the provided setup checker
+python scripts/setup_check.py
+```
+
+This script validates Python version, PyTorch with CUDA, PyTorch Geometric, RDKit, ESM, and other dependencies.
+
+## Core Workflows
+
+### Workflow 1: Single Protein-Ligand Docking
+
+**Use Case:** Dock one ligand to one protein target
+
+**Input Requirements:**
+- Protein: PDB file OR amino acid sequence
+- Ligand: SMILES string OR structure file (SDF/MOL2)
+
+**Command:**
+```bash
+python -m inference \
+  --config default_inference_args.yaml \
+  --protein_path protein.pdb \
+  --ligand "CC(=O)Oc1ccccc1C(=O)O" \
+  --out_dir results/single_docking/
+
+### Workflow 2: Batch Processing Multiple Complexes
+
+**Use Case:** Dock multiple ligands to proteins, virtual screening campaigns
+
+**Step 1: Prepare Batch CSV**
+
+Use the provided script to create or validate batch input:
+
+```bash
+# Create template
+python scripts/prepare_batch_csv.py --create --output batch_input.csv
+
+# Validate existing CSV
+python scripts/prepare_batch_csv.py my_input.csv --validate
+```
+
+**CSV Format:**
+```csv
+complex_name,protein_path,ligand_description,protein_sequence
+complex1,protein1.pdb,CC(=O)Oc1ccccc1C(=O)O,
+complex2,,COc1ccc(C#N)cc1,MSKGEELFT...
+complex3,protein3.pdb,ligand3.sdf,
+```
+
+**Required Columns:**
+- `complex_name`: Unique identifier
+- `protein_path`: PDB file path (leave empty if using sequence)
+
+# Pre-compute embeddings
+python datasets/esm_embedding_preparation.py \
+  --protein_ligand_csv screening_input.csv \
+  --out_file protein_embeddings.pt
+
+# Run with pre-computed embeddings
+python -m inference \
+  --config default_inference_args.yaml \
+  --protein_ligand_csv screening_input.csv \
+  --esm_embeddings_path protein_embeddings.pt \
+  --out_dir results/screening/
+```

package/skills/dispatching-parallel-agents/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: dispatching-parallel-agents
+description: Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
+---
+
+# Dispatching Parallel Agents
+
+## Overview
+
+You delegate tasks to specialized agents with isolated context. By precisely crafting their instructions and context, you ensure they stay focused and succeed at their task. They should never inherit your session's context or history — you construct exactly what they need. This also preserves your own context for coordination work.
+
+When you have multiple unrelated failures (different test files, different subsystems, different bugs), investigating them sequentially wastes time. Each investigation is independent and can happen in parallel.
+
+**Core principle:** Dispatch one agent per independent problem domain. Let them work concurrently.
+
+## When to Use
+
+```dot
+digraph when_to_use {
+    "Multiple failures?" [shape=diamond];
+    "Are they independent?" [shape=diamond];
+    "Single agent investigates all" [shape=box];
+    "One agent per problem domain" [shape=box];
+    "Can they work in parallel?" [shape=diamond];
+    "Sequential agents" [shape=box];
+    "Parallel dispatch" [shape=box];
+
+    "Multiple failures?" -> "Are they independent?" [label="yes"];
+    "Are they independent?" -> "Single agent investigates all" [label="no - related"];
+    "Are they independent?" -> "Can they work in parallel?" [label="yes"];
+
+## The Pattern
+
+### 1. Identify Independent Domains
+
+Group failures by what's broken:
+- File A tests: Tool approval flow
+- File B tests: Batch completion behavior
+- File C tests: Abort functionality
+
+Each domain is independent - fixing tool approval doesn't affect abort tests.
+
+### 2. Create Focused Agent Tasks
+
+Each agent gets:
+- **Specific scope:** One test file or subsystem
+- **Clear goal:** Make these tests pass
+- **Constraints:** Don't change other code
+- **Expected output:** Summary of what you found and fixed
+
+### 3. Dispatch in Parallel
+
+```typescript
+// In Claude Code / AI environment
+Task("Fix agent-tool-abort.test.ts failures")
+Task("Fix batch-completion-behavior.test.ts failures")
+Task("Fix tool-approval-race-conditions.test.ts failures")
+// All three run concurrently
+```
+
+### 4. Review and Integrate
+
+When agents return:
+- Read each summary
+- Verify fixes don't conflict
+- Run full test suite
+- Integrate all changes
+
+## Agent Prompt Structure
+
+Good agent prompts are:
+1. **Focused** - One clear problem domain
+2. **Self-contained** - All context needed to understand the problem
+3. **Specific about output** - What should the agent return?
+
+```markdown
+Fix the 3 failing tests in src/agents/agent-tool-abort.test.ts:
+
+1. "should abort tool with partial output capture" - expects 'interrupted at' in message
+2. "should handle mixed completed and aborted tools" - fast tool aborted instead of completed
+3. "should properly track pendingToolCount" - expects 3 results but gets 0
+
+These are timing/race condition issues. Your task:
+
+## Common Mistakes
+
+**❌ Too broad:** "Fix all the tests" - agent gets lost
+**✅ Specific:** "Fix agent-tool-abort.test.ts" - focused scope
+
+**❌ No context:** "Fix the race condition" - agent doesn't know where
+**✅ Context:** Paste the error messages and test names
+
+**❌ No constraints:** Agent might refactor everything
+**✅ Constraints:** "Do NOT change production code" or "Fix tests only"
+
+**❌ Vague output:** "Fix it" - you don't know what changed
+**✅ Specific:** "Return summary of root cause and changes"
+
+## When NOT to Use
+
+**Related failures:** Fixing one might fix others - investigate together first
+**Need full context:** Understanding requires seeing entire system
+**Exploratory debugging:** You don't know what's broken yet
+**Shared state:** Agents would interfere (editing same files, using same resources)
+
+## Real Example from Session
+
+**Scenario:** 6 test failures across 3 files after major refactoring
+
+**Failures:**
+- agent-tool-abort.test.ts: 3 failures (timing issues)
+- batch-completion-behavior.test.ts: 2 failures (tools not executing)
+- tool-approval-race-conditions.test.ts: 1 failure (execution count = 0)
+
+**Decision:** Independent domains - abort logic separate from batch completion separate from race conditions
+
+**Dispatch:**
+
+