owflow 0.1.1 → 0.1.3

package/dist/skills/standards-discover/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: standards-discover
+description: Discover coding standards from project configuration files, code patterns, documentation, and external sources (PRs, CI/CD)
+user-invocable: true
+---
+
+# Standards Discovery Skill
+
+Analyzes multiple project sources in parallel to discover coding standards, conventions, and best practices. Aggregates findings with confidence scoring, presents for user approval, and applies approved standards via `docs-manager` skill.
+
+## Core Principles
+
+1. **Parallel Execution**: Launch discovery subagents concurrently for speed (~45-60s vs ~2-4min sequential)
+2. **Evidence-Based**: Every finding must cite specific files, line counts, or config rules as evidence
+3. **Confidence Scoring**: Multi-factor confidence based on source count, consistency, and explicitness
+4. **Deduplication**: Same standard found across sources merges into single finding with combined evidence
+5. **Graceful Degradation**: Skip unavailable sources (no gh CLI, no docs) without failing entire workflow
+
+---
+
+## Input Parameters
+
+| Parameter         | Default | Description                                                                                                                                     |
+| ----------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--scope`         | `full`  | Discovery scope: `full`, `quick`, or any category name (baseline: `global`, `frontend`, `backend`, `testing`; custom categories also supported) |
+| `--confidence`    | `60`    | Minimum confidence threshold (0-100) for displaying findings                                                                                    |
+| `--auto-apply`    | `false` | Auto-apply standards with confidence >= 90% without asking                                                                                      |
+| `--skip-external` | `false` | Skip GitHub PR analysis and CI/CD sources                                                                                                       |
+| `--pr-count`      | `20`    | Number of recent merged PRs to analyze                                                                                                          |
+
+**Scope determines which phases run:**
+
+| Scope      | Config (P1)      | Code (P2)      | Docs (P3) | External (P4) |
+| ---------- | ---------------- | -------------- | --------- | ------------- |
+| `full`     | Yes              | Yes            | Yes       | Yes           |
+| `global`   | Yes              | Yes (limited)  | Yes       | Yes           |
+| `frontend` | FE configs       | FE files       | Yes       | Yes           |
+| `backend`  | BE configs       | BE files       | Yes       | Yes           |
+| `testing`  | Test configs     | Test files     | Yes       | Yes           |
+| `quick`    | Yes              | No             | No        | No            |
+| `[custom]` | Relevant configs | Filtered files | Yes       | Yes           |
+
+Custom scope values are matched against existing `.owflow/docs/standards/*/` directories and filter analysis to relevant files.
+
+---
+
+## Phase Configuration
+
+| Phase | Subject                          | activeForm                         |
+| ----- | -------------------------------- | ---------------------------------- |
+| 1     | Plan discovery scope             | Planning discovery scope           |
+| 2     | Analyze configuration files      | Analyzing configuration files      |
+| 3     | Mine code patterns               | Mining code patterns               |
+| 4     | Extract documentation standards  | Extracting documentation standards |
+| 5     | Analyze external sources         | Analyzing external sources         |
+| 6     | Aggregate & deduplicate findings | Aggregating findings               |
+| 7     | Review findings with user        | Reviewing findings                 |
+| 8     | Apply approved standards         | Applying standards                 |
+| 9     | Generate summary report          | Generating summary                 |
+
+**Task Tracking**: At start of Phase 1, use `TaskCreate` for all phases above (pending). Set dependencies: Phases 2-5 blocked by Phase 1 (they run in parallel after planning). Phase 6 blocked by Phases 2-5. Phases 7-9 sequential. At each phase start: `TaskUpdate` to `in_progress`. At each phase end: `TaskUpdate` to `completed`. For phases skipped due to scope (e.g., Phases 3-4 when `--scope=quick`), mark `completed` with `metadata: {skipped: true, reason: "scope=quick"}`.
+
+---
+
+## Execution Workflow
+
+### Phase 1: Planning & Initialization
+
+1. **Parse options** from command arguments
+2. **Check prerequisites**: Verify `.owflow/docs/` exists. If not, offer to run `/flow-init` first
+3. **Read existing standards** from `.owflow/docs/INDEX.md` to identify updates vs creates and avoid duplicates
+4. **Display discovery plan** showing scope, sources, and estimated time
+5. **Get user confirmation** via question before proceeding
+
+---
+
+### Phase 2-5: Parallel Discovery
+
+> **CRITICAL: Launch all applicable subagents in ONE message for parallel execution.**
+
+**Step 1: Determine which phases to run** based on scope and flags.
+
+**Step 1.5: Create temp output directory** — Run `mktemp -d` via Bash to create a unique temp directory for this invocation. Store the path (e.g., `/tmp/abc123`). Each subagent will write its results to a dedicated file in this directory: `{tmpdir}/config.yml`, `{tmpdir}/code.yml`, `{tmpdir}/docs.yml`, `{tmpdir}/external.yml`.
+
+**Step 2: Read prompt templates**
+
+> **STOP — Do NOT skip this step. Do NOT write prompts from memory.**
+
+Use the Read tool to load ONLY the reference files for phases you will execute:
+
+| Phase               | Condition                 | Read This File                           |
+| ------------------- | ------------------------- | ---------------------------------------- |
+| 2: Config Analysis  | Always                    | `references/config-analyzer-prompt.md`   |
+| 3: Code Patterns    | scope != `quick`          | `references/code-pattern-prompt.md`      |
+| 4: Documentation    | scope != `quick`          | `references/docs-extractor-prompt.md`    |
+| 5: External Sources | `--skip-external` not set | `references/external-analyzer-prompt.md` |
+
+**SELF-CHECK**: Did you read the template files with the Read tool? If not, go back and read them now.
+
+**Step 3: Adapt templates** — Replace `[scope]`, `[confidence]`, and other placeholders with actual values. Replace the `[output_file]` placeholder in each template with the actual temp file path for that phase (e.g., `{tmpdir}/config.yml`).
+
+**Step 4: Launch subagents in parallel** — Use the Task tool with `subagent_type: general-purpose` for each phase.
+
+> ❌ **WRONG** — launching one agent per message, waiting for result, then launching the next.
+> ✅ **CORRECT** — launching ALL applicable agents (2–4 Task calls) in a SINGLE message.
+
+**Step 5: Wait** for ALL subagents to complete, then read each temp file using the Read tool to collect findings.
+
+**Step 6: Display progress** — Show count of findings per phase.
+
+---
+
+### Phase 6: Aggregation & Deduplication
+
+**Read** `references/aggregation-strategy.md` for confidence scoring methodology.
+
+1. **Combine** all findings from Phases 2-5
+2. **Deduplicate** by grouping on `category + standard_name` — merge evidence and sources
+3. **Calculate final confidence** using multi-factor scoring from the reference
+4. **Detect conflicts** — flag contradictory standards (e.g., ESLint says semicolons, Prettier says no)
+5. **Categorize** into High (>= 80%), Medium (60-79%), Low (< 60%)
+6. **Filter** by `--confidence` threshold
+
+Display aggregation summary: total raw findings, unique standards, conflicts detected.
+
+---
+
+### Phase 7: User Review & Approval
+
+**Step 1: Present full summary table** — Before any approval prompts, output ALL findings in a table grouped by confidence level. Each group has a header with count:
+
+```
+### High Confidence (>=80%) — 5 standards
+
+| # | Standard | Category | Score | Sources | Description |
+|---|----------|----------|-------|---------|-------------|
+| 1 | no-semicolons | global | 92 | config, code, docs | Omit semicolons in all JS/TS files |
+| 2 | ... | ... | ... | ... | ... |
+
+### Medium Confidence (60-79%) — 3 standards
+...
+
+### Low Confidence (<60%) — 2 standards
+...
+
+### Conflicts — 1 detected
+| # | Standard | Conflict | Sources A | Sources B |
+```
+
+The **Sources** column lists all contributing sources for each finding (config, code, docs, PRs, CI, pre-commit). This gives users full visibility before making decisions.
+
+**Step 2: Approval flow** — After the summary table:
+
+- **High confidence (>= 80%)**: Use question offering batch approval ("Apply all N high-confidence standards") or individual drill-down review. For drill-down, show full detail per finding: all evidence items with source attribution, examples (preferred/avoid), and confidence score breakdown (which factors contributed how many points).
+
+- **Medium confidence (60-79%)**: Present each individually with full detail (evidence, examples, confidence breakdown). Use question with Accept/Modify/Skip options per finding.
+
+- **Low confidence (< threshold)**: Show the summary table rows only. Offer to expand details or skip all.
+
+- **Conflicts**: Present each conflict showing both sides with their evidence and sources. Use question to resolve (pick side A, pick side B, skip, or custom).
+
+If `--auto-apply` is set, automatically approve findings with confidence >= 90% and only prompt for the rest.
+
+---
+
+### Phase 8: Application
+
+> **DELEGATION REQUIRED**: Do NOT write standard files directly using Write/Edit tools. ALL file operations MUST go through the `docs-operator` subagent (Task tool).
+>
+> **SELF-CHECK before each file operation**: "Am I about to write a file directly? STOP — invoke docs-operator via Task tool instead."
+
+For each approved standard:
+
+1. **Prepare content** — Standard name, description, examples (preferred/avoid), rationale from evidence, source citations. Format each standard as a `###` heading with 1-10 lines description (excluding code snippets). Group related standards into the same topic file. Add brief code examples only when they clarify the practice.
+2. **Check if file exists** — Determine create vs update action
+3. **Invoke `docs-operator` subagent** via Task tool (subagent_type: `docs-operator`) — Pass prepared content. For creates: new file. For updates: merge new findings with existing. Wait for completion, then continue with the next standard.
+4. **After all standards applied, invoke `docs-operator` subagent** via Task tool to regenerate INDEX.md. Wait for completion, then continue with step 5.
+5. **Invoke `docs-operator` subagent** via Task tool to verify AGENTS.md integration — ensure standards directory is referenced. Wait for completion, then display the application summary.
+
+Display application summary: created count, updated count, total active.
+
+---
+
+### Phase 9: Summary Report
+
+Display final results:
+
+- Sources analyzed (config files, code files sampled, docs parsed, PRs reviewed)
+- Standards applied (created/updated counts by category)
+- Standards skipped (low confidence, user declined)
+- Next steps (review, commit, re-run schedule)
+
+---
+
+## Error Handling
+
+| Situation               | Strategy                                              |
+| ----------------------- | ----------------------------------------------------- |
+| `.owflow/docs/` missing | Offer `/flow-init`, abort if declined                 |
+| gh CLI unavailable      | Skip PR analysis, continue with other sources         |
+| GitHub API rate limit   | Skip PR analysis, note in report                      |
+| Config file parse error | Skip that file, log warning, continue                 |
+| No standards found      | Suggest lowering threshold or checking specific scope |
+| docs-manager fails      | Offer retry/skip/cancel per standard                  |
+| Subagent returns empty  | Note in report, proceed with available findings       |
+
+---
+
+## Integration
+
+| Integrates With                      | How                                                              |
+| ------------------------------------ | ---------------------------------------------------------------- |
+| `docs-manager` skill                 | Creates/updates standard files, regenerates INDEX.md             |
+| `implementation-plan-executor` skill | Discovered standards immediately available via INDEX.md          |
+| `standards-update` command           | Complementary: discover = automated bulk, update = manual single |
+
+---
+
+## Examples
+
+```bash
+# Full discovery (default)
+/standards-discover
+
+# Quick scan (config files only, ~30-60s)
+/standards-discover --scope=quick
+
+# Frontend standards only
+/standards-discover --scope=frontend
+
+# High confidence, auto-apply
+/standards-discover --confidence=80 --auto-apply
+
+# Skip external analysis (offline/no GitHub)
+/standards-discover --skip-external
+```

package/dist/skills/standards-discover/references/aggregation-strategy.md

@@ -0,0 +1,76 @@
+# Aggregation Strategy — Confidence Scoring & Deduplication
+
+## Deduplication Rules
+
+Group findings by `category + standard_name`. When multiple findings match:
+
+1. **Merge evidence** — Combine all evidence items from all sources
+2. **Track sources** — Note which phases contributed (config, code, docs, external)
+3. **Take strongest description** — Prefer documented > config > code-inferred
+4. **Preserve examples** — Combine unique examples
+
+## Confidence Scoring
+
+Calculate final confidence using these factors:
+
+### Source Count (max 45 points)
+- Each unique source: +15 points (config, code-patterns, documentation, pr-reviews, ci-config, pre-commit)
+- Cap at 45 points (3+ sources)
+
+### Consistency (max 20 points)
+- >= 90% consistency across sampled files: +20
+- 70-89% consistency: +10
+- < 70% consistency: +0
+
+### Explicitness (max 15 points)
+- Found in config file (explicit rule): +15
+- Found in documentation (explicitly stated): +10
+- Inferred from code patterns only: +5
+
+### Evidence Strength (max 20 points)
+- Per evidence item: +5 points, cap at 20 (4+ evidence items)
+
+### PR Feedback Boost (max 10 points)
+- 5+ PR reviews mention this: +10
+- 3-4 PR reviews: +5
+
+**Final score**: Sum of factors, capped at 100.
+
+## Conflict Detection
+
+Flag conflicts when two findings for the same aspect give contradictory guidance:
+
+- Same tool, different settings (e.g., ESLint vs Prettier disagreeing on semicolons)
+- Documentation says one thing, config enforces another
+- Code patterns don't match documented standards
+
+Present each conflict to user with both sides and evidence.
+
+## Confidence Categories
+
+| Level | Range | Guidance |
+|-------|-------|----------|
+| High | >= 80% | Strong evidence, multiple sources. Safe to apply. |
+| Medium | 60-79% | Some evidence, may need clarification. Review recommended. |
+| Low | < 60% | Weak or inconsistent patterns. May indicate area needing standardization. |
+
+## Presentation Order
+
+1. High confidence findings (batch approval option)
+2. Medium confidence findings (individual review)
+3. Conflicts (resolution required)
+4. Low confidence findings (informational, skip option)
+
+## Presentation Format
+
+Before approval prompts, present a **full summary table** grouped by confidence level. Each finding row shows:
+
+- **Standard name** and **category**
+- **Confidence score** (numeric, 0-100)
+- **Sources** — all contributing sources listed (e.g., "config, code, docs"). This is key for user trust and decision-making.
+- **Brief description** (one line, truncated if needed)
+
+When drilling into individual findings (medium confidence, or user-requested drill-down), show:
+- Full description and examples (preferred/avoid patterns)
+- Evidence items with source attribution (which source provided each piece of evidence)
+- Confidence score breakdown: show points from each factor (source count, consistency, explicitness, evidence strength, PR boost) so user understands why the score is what it is

package/dist/skills/standards-discover/references/code-pattern-prompt.md

@@ -0,0 +1,68 @@
+# Code Pattern Analyzer — Subagent Prompt Template
+
+Analyze source code patterns to discover coding conventions and standards used in the project.
+
+## Task
+
+Sample code files, detect consistent patterns in naming/imports/structure, return findings as YAML.
+
+## Sampling Strategy
+
+For performance, sample rather than exhaustive analysis:
+
+- **Frontend files**: Sample up to 50 files (`*.ts`, `*.tsx`, `*.js`, `*.jsx`, `*.vue`, `*.svelte`)
+- **Backend files**: Sample up to 50 files (`*.py`, `*.rb`, `*.java`, `*.go`, `*.rs`)
+- **Test files**: Sample up to 30 files (`*.test.*`, `*.spec.*`, `*_test.*`)
+
+Use Glob to find files, then Read a representative sample from different directories.
+
+## Patterns to Detect
+
+1. **File Naming**: PascalCase, kebab-case, snake_case, camelCase — calculate consistency %
+2. **Import Patterns**: Absolute vs relative, path aliases (`@/`), import grouping/sorting
+3. **Error Handling**: try/catch usage, custom error classes, error wrapping, logging patterns
+4. **Component Structure** (frontend): Functional vs class components, hooks usage, props patterns
+5. **API Patterns** (backend): Endpoint naming, resource naming (plural/singular), versioning
+6. **Function Style**: Arrow functions vs declarations, async/await vs promises
+7. **Type Patterns**: TypeScript strictness, type vs interface usage, generics patterns
+
+## Consistency Threshold
+
+Only report patterns with **>= 60% consistency** across sampled files.
+
+Calculate: `(files following pattern / total files sampled) * 100`
+
+## Categorization
+
+Discover existing categories from `.owflow/docs/standards/*/`. Baseline categories: `global/`, `frontend/`, `backend/`, `testing/`. Propose new categories if patterns don't fit existing ones.
+
+## Confidence Range
+
+Code pattern findings: **60-88%** confidence. Higher when consistency is >= 90%.
+
+## Output Format
+
+Return YAML:
+
+```yaml
+findings:
+  - category: "[category/subcategory]"
+    standard_name: "[Short Name]"
+    description: "[What the convention is]"
+    confidence: [60-88]
+    evidence:
+      - "[X] of [Y] files follow this pattern"
+      - "Examples: [file1], [file2], [file3]"
+    source: "code-patterns"
+    examples:
+      - "[Correct pattern example]"
+```
+
+## Rules
+
+- Sample files randomly across directories for representative results
+- Report file counts in evidence (e.g., "247 of 250 .tsx files use PascalCase")
+- Only report patterns with >= 60% consistency
+- Return empty findings list if no clear patterns emerge
+- Focus on actionable, consistent patterns — not one-off occurrences
+- Do NOT write any files to the project directory. Write your YAML results to: `[output_file]` (the orchestrator replaces this placeholder with an actual temp file path when invoking you).

package/dist/skills/standards-discover/references/config-analyzer-prompt.md

@@ -0,0 +1,67 @@
+# Config Standards Analyzer — Subagent Prompt Template
+
+Analyze project configuration files to discover coding standards and conventions.
+
+## Task
+
+Find and analyze configuration files, extract standards, return structured findings as YAML.
+
+## Configuration Files to Analyze
+
+1. **Linter configs**: `.eslintrc.*`, `.prettierrc*`, `pylintrc`, `.pylintrc`, `.rubocop.yml`, `biome.json`
+2. **Compiler configs**: `tsconfig.json`, `jsconfig.json`
+3. **Package managers**: `package.json` (scripts, conventions), `requirements.txt`, `Gemfile`, `pom.xml`, `go.mod`
+4. **Editor configs**: `.editorconfig` (indentation, line endings, charset)
+5. **Container configs**: `Dockerfile`, `docker-compose.yml`
+
+## What to Extract
+
+For each config file found, extract rules/settings that indicate coding standards:
+
+- **ESLint**: Naming conventions, code style (quotes, semicolons, indentation), framework patterns, import rules
+- **Prettier**: Formatting rules (semi, singleQuote, trailingComma, tabWidth, printWidth)
+- **TypeScript**: Compiler strictness (strict, noImplicitAny), module resolution, path aliases
+- **Package.json**: Script patterns, testing conventions, pre-commit hooks (husky/lint-staged)
+- **EditorConfig**: Indentation style/size, charset, line endings, trailing whitespace
+- **Biome**: Combined lint + format rules
+
+## Categorization
+
+Discover existing categories from `.owflow/docs/standards/*/`. Baseline categories:
+
+- `global/` — Language-agnostic (indentation, line endings, general error handling)
+- `frontend/` — UI-specific (React rules, CSS conventions, component patterns)
+- `backend/` — Server-specific (API rules, database conventions)
+- `testing/` — Test-related (test frameworks, coverage requirements)
+
+Propose new categories if findings don't fit existing ones.
+
+## Confidence Range
+
+Config-based findings: **70-85%** confidence (explicit configuration = strong evidence).
+
+## Output Format
+
+Return YAML:
+
+```yaml
+findings:
+  - category: "[category/subcategory]"
+    standard_name: "[Short Name]"
+    description: "[What the standard requires]"
+    confidence: [70-85]
+    evidence:
+      - "[config-file]: [specific rule or setting]"
+    source: "config"
+    examples:
+      - "[Brief correct example if applicable]"
+```
+
+## Rules
+
+- Only include findings with clear evidence from actual config files
+- Be specific in descriptions (not "follow ESLint rules" but "use single quotes for strings")
+- Include exact file paths in evidence
+- Return empty findings list if no config files found
+- Focus on actionable, verifiable standards
+- Do NOT write any files to the project directory. Write your YAML results to: `[output_file]` (the orchestrator replaces this placeholder with an actual temp file path when invoking you).

package/dist/skills/standards-discover/references/docs-extractor-prompt.md

@@ -0,0 +1,65 @@
+# Documentation Standards Extractor — Subagent Prompt Template
+
+Extract coding standards and conventions explicitly documented in project files.
+
+## Task
+
+Find and parse documentation files, extract explicitly stated standards, return findings as YAML.
+
+## Documentation Files to Analyze
+
+1. **README.md** — Look for: Code Style, Contributing Guidelines, Conventions, Best Practices sections
+2. **CONTRIBUTING.md** — PR requirements, commit conventions, testing requirements, code review standards
+3. **ARCHITECTURE.md** / `docs/architecture/` — Design patterns, architectural decisions
+4. **ADRs** (Architecture Decision Records) — `adr/`, `decisions/`, `docs/decisions/` directories
+5. **AGENTS.md** / `.claude/AGENTS.md` — AI-specific coding instructions and project conventions
+6. **Code of Conduct**, **STYLEGUIDE.md** — If present
+
+## What to Extract
+
+Look for explicit standard statements:
+
+- "We use..." / "This project uses..."
+- "Always..." / "Never..."
+- "Prefer X over Y"
+- "Required: ..." / "Must..."
+- Code examples showing correct/incorrect patterns
+- Numbered rules or guidelines lists
+
+**Only extract explicitly stated standards** — do not infer from code examples alone.
+
+## Categorization
+
+Discover existing categories from `.owflow/docs/standards/*/`. Baseline categories: `global/`, `frontend/`, `backend/`, `testing/`. Propose new categories if patterns don't fit existing ones.
+
+## Confidence Range
+
+Documentation findings: **80-92%** confidence (explicitly documented = strong evidence).
+
+Higher end (90+) when multiple docs agree or when stated as mandatory rules.
+
+## Output Format
+
+Return YAML:
+
+```yaml
+findings:
+  - category: "[category/subcategory]"
+    standard_name: "[Short Name]"
+    description: "[What the standard requires]"
+    confidence: [80-92]
+    evidence:
+      - '[filename]: "[exact quote or paraphrase]"'
+    source: "documentation"
+    examples:
+      - "[Example from docs if provided]"
+```
+
+## Rules
+
+- Include exact quotes or close paraphrases in evidence
+- Note which file each standard comes from
+- Return empty findings list if no documentation files found
+- Prioritize actionable, clear standards over vague guidance
+- Do not duplicate what config files already enforce — focus on human-written guidelines
+- Do NOT write any files to the project directory. Write your YAML results to: `[output_file]` (the orchestrator replaces this placeholder with an actual temp file path when invoking you).

package/dist/skills/standards-discover/references/external-analyzer-prompt.md

@@ -0,0 +1,75 @@
+# External Standards Analyzer — Subagent Prompt Template
+
+Analyze pull requests, CI/CD configurations, and pre-commit hooks to discover enforced standards.
+
+## Task
+
+Mine external sources for standards evidence, return findings as YAML.
+
+## Sources to Analyze
+
+### 1. Pull Requests (via gh CLI)
+
+**First check availability:**
+```bash
+which gh && gh auth status
+```
+
+If gh CLI available:
+- Get last `[pr_count]` merged PRs: `gh pr list --state merged --limit [pr_count] --json number,title`
+- For each PR, check review comments for repeated feedback patterns
+- Look for: "Please use...", "Always...", "Avoid...", "Per our convention...", "Style:", "Nit:"
+- Only report patterns that appear in **3+ different PRs** (significant feedback, not one-off)
+
+If gh CLI unavailable: skip PR analysis, note in output, not an error.
+
+### 2. CI/CD Workflows
+
+- **GitHub Actions**: `.github/workflows/*.yml`
+- **GitLab CI**: `.gitlab-ci.yml`
+- **Other**: `Jenkinsfile`, `.circleci/config.yml`, `.travis.yml`
+
+Extract: lint steps, test requirements, coverage thresholds, build quality gates, pre-deployment checks.
+
+### 3. Pre-commit Hooks
+
+- **Husky**: `.husky/` directory (pre-commit, pre-push scripts)
+- **pre-commit framework**: `.pre-commit-config.yaml`
+- **lint-staged**: `lint-staged` config in `package.json` or `.lintstagedrc`
+
+Extract: mandatory checks, formatting enforcement, commit message validation.
+
+## Confidence Ranges
+
+| Source | Confidence Range | Rationale |
+|--------|-----------------|-----------|
+| CI/CD enforced standards | 85-95% | Enforced by automation — very reliable |
+| Pre-commit hooks | 80-90% | Actively enforced on every commit |
+| PR review patterns (5+ PRs) | 70-80% | Strong team consensus |
+| PR review patterns (3-4 PRs) | 60-70% | Emerging pattern |
+
+## Output Format
+
+Return YAML:
+
+```yaml
+github_available: true  # or false
+findings:
+  - category: "[category/subcategory]"
+    standard_name: "[Short Name]"
+    description: "[What the standard requires]"
+    confidence: [60-95]
+    evidence:
+      - "[source]: [specific evidence]"
+    source: "[pr-reviews|ci-config|pre-commit]"
+    examples: []
+```
+
+## Rules
+
+- Handle gh CLI gracefully — return `github_available: false` and empty PR findings, not error
+- Only report PR patterns appearing in 3+ different PRs
+- For CI/CD: extract specific thresholds and rules, not just "runs tests"
+- Return empty findings list if no external sources available
+- Be specific: "80% coverage required" not "has coverage check"
+- Do NOT write any files to the project directory. Write your YAML results to: `[output_file]` (the orchestrator replaces this placeholder with an actual temp file path when invoking you).