pipeline-conductor

Files (2)

• SKILL.md
• SKILL_detail.md

SKILL.md (first lines)

# pipeline-conductor — Chained Verification Sweep

Chains the four standalone FH verification pipelines into a gated sequence. Each step receives the previous step's verdict before proceeding. Aggregates all findings into a single structured report at the end.

The gap this closes: harvest-loop, steel-quench, phantom-quench, and sim-conductor are each invocable independently but have no automatic hand-off between them. Running them sequentially by hand loses inter-step signal — a FAIL in step 2 should block step 3 rather than silently continuing. pipeline-conductor enforces that ordering.

## Triggers

- `/pipeline-conductor`
- "Run the full verification pipeline", "chain all four verifications"
- "End-to-end sweep before I push", "verify everything at once"
- "I want to run all the checks in order", "do a full harness review"
- "Run quench then grounding then sim", "chain the pipelines"
- "Full pipeline on this skill", "sweep this asset before release"

> **Disambiguation**: "run the pipeline" alone may trigger harvest-loop (which uses identical phrasing). Prefer "run pipeline-conductor" or "chain all verifications" for unambiguous activation.

## Modes

| Flag | Steps run | When to use |
|---|---|---|
| `--full` (default) | Steps 1 → 2 → 3 → 4 | Complete verification sweep |
| `--quick` | Steps 2 → 3 only | Fast adversarial + phantom check; skip knowledge loop and simulation |
| `--no-sim` | Steps 1 → 2 → 3 | Skip sim-conductor (e.g., no sim environment available) |

**Mode qualifier on verdicts**: `CLEAN (--quick)` and `CLEAN (--no-sim)` do not qualify as pre-release gates. Only `CLEAN (--full)` is sufficient for external publish or PR approval.

## Verdict Format

Every step emits exactly one verdict line before handing control to the next step:

```
Verdict: PASS | CONDITIONAL_PASS | FAIL | ESCALATE
Basis:   [one-line summary of deciding factor]
```

| Verdict | Meaning | Chain behavior |
|---|---|---|
| `PASS` | Step complete, no blocking issues | Proceed to next step |
| `CONDITIONAL_PASS` | Issues found but none are blockers; must be resolved before final report | Capture items, proceed to next step; flag in final report |
| `FAIL` | Blocking issue found | Halt chain, surface to user immediately |
| `ESCALATE` | Ambiguous state requiring human judgment | Pause chain, present three options to user |

`CONDITIONAL_PASS` means proceed, not skip — captured items accumulate into the final report's Pending section and must be addressed before the sweep is considered clean. `FAIL` halts the chain (user decides fix-and-resume or abandon). `ESCALATE` pauses the chain pending the user's choice.

### ESCALATE Handling

When any step returns `ESCALATE`, present:

> "Step N returned ESCALATE: [basis]. Choose:
> (a) Make a decision — state your judgment and I will incorporate it and continue the chain.
> (b) Accept and continue — mark this as PENDING in the report and proceed to the next step.
> (c) Abort — close the sweep as BLOCKED."

- Option (a): User provides judgment → incorporate as resolution note → re-evaluate step gate with decision context → continue chain.
- Option (b): Mark ESCALATE item as PENDING → continue chain from step N+1.
- Option (c): Halt, output BLOCKED report with ESCALATE item in blocking section.

---

## Step 0. Scope, Mode, and Translation

Determine before running any pipeline step:

1. **Scope**: single skill (path to `SKILL.md`) · specific asset (file/directory) · full harness (`plugins/` + `templates/`)
2. **Mode**: `--quick`, `--no-sim`, or `--full` (default)
3. **Branch**: current git branch (used for regression guard and report header)

If scope is not specified, ask: *"What should I sweep? (e.g., a specific skill path, a directory, or the full harness)"* **Do not infer scope** — a wrong scope produces misleading verdicts.

Output the sweep plan and get Y/N confirmation before running.

> **Detail**: See `SKILL_detail.md §Output-Formats` — sweep plan block, per-step verdict blocks, aggregated report template — read when emitting any step output.

### Scope Translation Table

The four constituent skills use heterogeneous scope models. Translate the pipeline scope to each skill's invocation form before running any step:

| Pipeline scope | harvest-loop (Step 1) | steel-quench (Step 2) | phantom-quench (Step 3) | sim-conductor (Step 4) |
|---|---|---|---|---|
| Single SKILL.md | Check session findings relevant to this skill; propose mode only | Adversarial attack on this SKILL.md | Back-trace claims in this SKILL.md to declared sources | Area D (artifact review) on this SKILL.md |
| Specific directory | Check session findings in this domain | Attack all SKILL.md files in directory | Back-trace all claims in directory | Area A + Area D on the domain |
| Full harness | Check all recent session findings | Attack all harness assets under scope | Back-trace all claims across harness | Area A + Area B + Area D |

---

## Step 0.5. return-path-gate — Pre-flight Chain Audit

> Skip only when scope is a single non-pipeline skill. **return-path-gate not installed is a recorded
> degrade, never a free skip**: proceed, but record `degraded: return-path-gate (not installed)` in the
> final report — and, symmetric with the user-override row below, the sweep **cannot reach
> `CLEAN (--full)`**. A missing tool must not pass more cheaply than an explicit refusal (that
> asymmetry trains uninstalling the gate).

Run `/return-path-gate --skill [scope]`.

| return-path-gate result | Step 0.5 verdict | Chain behavior |
|---|---|---|
| 0 OPEN chains | `PASS` | Proceed |
| MEDIUM/LOW severity OPEN chains only | `CONDITIONAL_PASS` | Proceed; capture in Pending |
| 1+ HIGH severity OPEN chains | `FAIL` | **Halt sweep** — fix chains before running pipeline |

**Skip override rule**: `S` (skip on FAIL) is available but must be declared explicitly. Skipping records as `degraded: return-path-gate (user override)` in the final report and the sweep **cannot reach `CLEAN (--full)` status** regardless of subsequent step verdicts.

---

## Step 1. harvest-loop — Knowledge Loop Check

> Skipped in `--quick` mode.

Check for harvest-loop signals in the current session — read session context rather than invoking harvest-loop directly (a mid-sweep invocation would conflict with the sweep's own pattern collection).

**Typed-first parsing (codex M3 2026-08-10)**: if a harvest-loop output block exists, classify
ONLY from its final non-empty `Verdict:` line; absent/malformed → `ESCALATE`. The prose rows below
apply ONLY to pre-contract historical runs (no typed line anywhere in the output).

| harvest-loop result | pipeline-conductor verdict |
|---|---|
| Typed `Verdict: PASS` | `PASS` |

From chrono-meta/forge-harness, MIT.

More from chrono-meta/forge-harness