/skill-pipeline

name: skill-pipeline
description: >
  Pipeline orchestrator that classifies incoming coding tasks and routes them
  through the correct combination of skills at the right depth. Implements two
  feedback loops: the inner loop (detect, verify, recover) runs within a session
  via plan-interview, intent-framed-agent, context-surfing, verify-gate,
  self-healing (active recovery on failure), simplify-and-harden, and
  self-improvement. The outer loop (inspect, encode, regress-test) runs across
  sessions via learning-aggregator, harness-updater, and eval-creator.
  pre-flight-check bridges the two by surfacing accumulated knowledge — past
  heals and learnings — at session start. Handles standard, orchestrated-batch,
  CI, and outer-loop pipeline variants. Does not replace individual skills;
  dispatches to them.

Skill Pipeline

The conductor, not a player. This skill classifies tasks, selects the pipeline variant, calibrates depth, and orchestrates handoffs between skills. It produces no artifacts of its own — its output is routing decisions that activate other skills.

Task Classification

On every coding task, classify before acting. Evaluate scope signals and map to a task class.

**Input signals:** file count, task description, existing plan/handoff files, batch indicators, CI environment.

Task received
  │
  ├─ Trivial (typo, rename, version bump)
  │  → No skills. Just do it.
  │
  ├─ Small (isolated fix, single-file, <10 logic lines)
  │  → verify-gate + simplify-and-harden
  │
  ├─ Medium (feature in known area, 2-5 files)
  │  → intent-framed-agent + verify-gate + simplify-and-harden
  │
  ├─ Large (complex refactor, new architecture, unfamiliar codebase, high-risk logic)
  │  → Full standard pipeline
  │  → Recommend /plan-interview before starting
  │
  ├─ Long-running (multi-session, high context pressure, prior handoff exists)
  │  → Full standard pipeline with context-surfing as critical skill
  │
  └─ Batch (multiple features from spec, 5+ discrete tasks, issue triage)
     → Orchestrated standard pipeline with bounded work units and independent audits

When uncertain, start with Medium. Add skills if drift or quality issues appear mid-task.

For detailed heuristics, edge cases, and examples: read `references/classification-rules.md`.

Pipeline Selection

Route task class to the right variant:

| Task Class | Variant | Rationale | |------------|---------|-----------| | Trivial | None | No overhead needed | | Small | Standard (minimal) | Verify + S&H only | | Medium | Standard (partial) | Scope monitoring + verify + review | | Large | Standard (full) | Full inner loop with planning | | Long-running | Standard (full) | Context-surfing is critical | | Batch | Orchestrated standard | Bounded work units with per-unit gates | | CI environment | CI | Headless review | | Periodic | Outer loop | Cross-session improvement |

**Heuristic:** Use the standard pipeline for both depth and breadth. For batch work, split the scope into bounded units and use `control-session-orchestrator` only when persistent multi-session coordination is available and useful. CI pipeline applies when `CI=true` or `GITHUB_ACTIONS=true`.

Activation Sequences

Standard Pipeline (Inner Loop)

pre-flight-check (SessionStart hook — surfaces prior learnings + heals)
  → classify
  → (recommend /plan-interview if Large or Long-running)
  → intent-framed-agent (at planning-to-execution transition)
  → context-surfing (Large/Long-running or explicit high-context-pressure use; concurrent with intent monitoring)
  → [IMPLEMENTATION]
  → self-healing  ← inner-loop recovery primitive; called whenever a command/test/build/external call fails or a helper is missing.
  →                Diagnoses, patches, verifies, files HEAL- entry. Resumes when verified.
  → verify-gate (compile + test + lint; fix loop if red — fix loop calls self-healing)
  → simplify-and-harden (post-completion, if non-trivial diff)
  → self-improvement (on errors, corrections, S&H learning candidates, recurring heal handoffs)

**Skill-by-class activation:**

| Skill | Trivial | Small | Medium | Large | Long-running | |-------|---------|-------|--------|-------|-------------| | pre-flight-check | Hook | Hook | Hook | Hook | Hook | | plan-interview | - | - | - | Recommend | Recommend | | intent-framed-agent | - | - | Activate | Activate | Activate | | context-surfing | - | - | - | Activate | Critical | | verify-gate | - | Activate | Activate | Activate | Activate | | self-healing | On failure | On failure | On failure | On failure | On failure | | simplify-and-harden | - | If non-trivial | If non-trivial | If non-trivial | If non-trivial | | self-improvement | On error only | On error only | On error/completion | On error/completion | On error/completion |

Orchestrated Batch Pipeline

classify (Batch)
  → (recommend /plan-interview if no spec exists)
  → split the scope into bounded work units
  → control-session-orchestrator when persistent multi-session coordination is available
    ├─ each unit follows its appropriate standard-pipeline depth
    ├─ verify-gate after each implementation unit
    ├─ independent simplify, harden, and spec auditors review the combined result
    └─ verify-gate after audit-driven fixes
  → self-improvement

If persistent orchestration is unavailable, process the same bounded units sequentially. Do not weaken verification, approval, or independent-review gates because parallel execution is unavailable.

CI Pipeline

classify (CI detected)
  → simplify-and-harden-ci (headless scan, PR changed files only)
  → self-improvement-ci (pattern aggregation, promotion recommendations)

Outer Loop Pipeline

The outer loop runs across sessions, not within them. Trigger on cadence (weekly, sprint boundary) or when `pre-flight-check` surfaces promotion-ready patterns.

learning-aggregator (read .learnings/, find patterns, rank promotion candidates)
  → harness-upda