Sk Pipeline Grilling

Pipeline Grilling — Brief-Hardening Interrogation

Hardens a pipeline brief and fills knowledge gaps before the architect designs the topology. Trigger from creating-a-pipeline Phase 2 (MODE=brief) and Phase 3 (MODE=architectural). Adapted from the crawl/grill/reconcile protocol of create-aiboarding.

Operation

PASS A — Brief Hardening (MODE=brief)

A1 · SILENT CRAWL (Track A) — partly conditional

• Hold all findings silently. Do NOT reveal them until A3.
• Always (context-independent):
  • Enumerate existing pipelines via sk-pipeline-paths.ENUMERATE_ALL_SCOPE_ROOTS → detect name overlap / reuse / collision against name.
  • Read platform_profile.capabilities → which patterns / isolation / parallelism are possible.
• Only when pipeline_type == project_embedded:
  • Bounded scan of the target workspace: dependency manifests, top-level directory structure, key README/docs. Bounded — never a full read of every file. Prefer Glob for structure + targeted Grep over broad Reads.
• When pipeline_type == self_contained: skip the codebase scan entirely; the always-on scans still run.

A2 · GRILL (Track B)

• One question at a time. NEVER batch questions.
• Challenge vague answers; push for a targeted brain-dump per micro-topic instead of accepting hand-waving.
• Walk the conceptual tree across micro-topics:
  1. Goal — push until measurable.
  2. Success criteria — observable, concrete.
  3. Pipeline I/O contract — exactly what enters the pipeline and exactly what it emits (format included).
  4. Rough step decomposition — the stages, not fine-grained per-step contracts.
  5. Failure modes — where it breaks; capture ≥1 pipeline-level mode.

A3 · RECONCILIATION (HARD GATE)

• Confront the held Track A findings against the user's A2 answers; grill ONLY on discrepancies.
• Confrontation scope depends on what was crawled:
  • project-embedded: codebase contradictions (e.g. "the brief says the pipeline reads test results, but the repo has no test runner — where do results come from?") PLUS registry/capability contradictions.
  • self-contained: registry/capability contradictions only (e.g. "a pipeline named X already exists in {scope} doing Y — how does this differ?"). NO "the repo lacks X" challenges.
• Do not exit until ZERO unresolved discrepancies remain (scoped to whatever crawl ran).

EXIT BAR — gate opens only when ALL true

• measurable goal
• explicit success criteria
• pipeline-level I/O contract
• rough step decomposition
• ≥1 pipeline-level failure mode
• zero unresolved crawl discrepancies (scoped to the crawl that ran)

OUTPUT — hardened_brief

Return a structured object:

{
  pipeline_type: "project_embedded" | "self_contained",
  goal, success_criteria, io_contract,
  step_decomposition: [...],
  captured_failure_modes: [...]
}

PASS B — Architectural Confirmation (MODE=architectural)

PASS C — Optimization Reconciliation (MODE=optimization)

OUTPUT — optimization_plan

Return a structured object:

{
  accepted:      [ {id, axis, proposed_change, suggested_engine}, ... ],
  rejected:      [ {id, reason}, ... ],
  modifications: [ {id, original, modified_change}, ... ],
  success_criteria: <how the optimization will be judged better>
}

Reference Files

• sk-pipeline-paths/SKILL.md — ENUMERATE_ALL_SCOPE_ROOTS for the registry scan.
• sk-pipeline-patterns/SKILL.md — pattern tradeoffs referenced in Pass B.
• sk-4d-method/SKILL.md — the per-invocation wrapper this complements.
• creating-a-pipeline/SKILL.md — the orchestrator that invokes both modes.