consilium

Files (14)

• SKILL.md
• consilium-config-example.md · references/
• role-file-contract.md · references/
• architect.md · roles/
• engineer.md · roles/
• marketing.md · roles/
• pm.md · roles/
• qa.md · roles/
• researcher.md · roles/
• scribe.md · roles/
• security-ops.md · roles/
• skeptic.md · roles/
• ux.md · roles/
• yagni-cop.md · roles/

SKILL.md (first lines)

# Consilium

The consilium drains queued `consilium-review` orchestrator tasks one at a time, running the full 5-stage pipeline per task. On every successful task, the verdict + scribe summary mirror onto the seed and the `sidekick-idea.reviewed` event fires. On any stage failure, the task transitions to `failed` and the next queued task continues.

For *what* a sidekick seed is and how it gets captured, read [Phase 0's `sidekick-capture` Feature](../../spec/features/sidekick-capture/README.md). For the verdict gate's full algorithm, read [REQ `arbiter-gate-rules`](../../spec/features/sidekick-consilium/README.md#req-arbiter-gate-rules) in this skill's source Feature.

## When to Use

- The user typed `/consilium` or "run the consilium" or any other trigger phrase.
- The user wants to drain queued sidekick captures into reviewed verdicts.

## Pre-flight

Before claiming any task — and **before the Stage 3 nine-role panel** — verify the cross-repo dependencies are present:

1. **specscore present + capable (capability-gated detection).** Per [`../shared/cli-detection.md`](../shared/cli-detection.md), `consilium` is a **capability-gated** skill: it needs the `specscore consilium verdict` subcommand, not merely the binary. Do **not** run a standalone `command -v` probe; detect by invoking `specscore consilium verdict` (e.g. with `--help`) and branch on the exit status:
   - **exit `127`** (binary not installed) → emit the install message (point the user at `/specscore:install`) and stop.
   - **exit `8`** (`UnsupportedCommand` — unsupported subcommand / too old) → the binary is present but predates `consilium verdict`; emit an **upgrade** message: "Phase 1 requires `specscore` with the `consilium verdict` subcommand (cross-repo dependency, tracked in `spec/plans/sidekick-consilium-arbiter-companion.md`). Upgrade and re-run."
   - **any other non-zero** → surface the CLI's error.
   This capability check MUST run here, before the Stage 3 panel — never after.
2. The orchestrator CLI is on PATH — the task lifecycle lives there (`orchestrator task claim`, `orchestrator task update`).
3. `orchestrator task types` — must include `consilium-review`. If absent, exit cleanly with the analogous message referencing the task-type companion plan.

If either cross-repo dependency is missing, do NOT claim any task and do NOT modify any file. Exit with the actionable error.

## The pipeline (per claimed task)

Once pre-flight passes, claim all `queued` tasks and run this pipeline once per claim:

```
1. CLI gather       (deterministic, ~1K tokens of context)
2. Researcher       (one LLM call, produces briefing pack)
3. Expert panel     (N parallel LLM calls, one per active roster role)
4. CLI arbiter      (deterministic, applies the gate rules)
5. Scribe           (one LLM call, advisory only)
```

Each stage emits a transcript record (see "Transcript capture" below). Stage failures transition the task to `failed` with a typed reason; the next task continues.

## Transcript capture (REQ `pipeline-transcript-capture`)

The skill MUST capture a structured transcript record at EACH stage's start and finalize at its end. This is NOT optional and NOT retrofittable — every stage's instructions below interleave transcript capture as integral to the stage, not a bolt-on.

**Transcript structure** (one entry per stage, plus per-role entries for the panel stage):

```yaml
pipeline_transcript:
  - stage: gather
    started_at: <ISO-8601>
    ended_at: <ISO-8601>
    outcome: ok | failed
    error: <string, only when outcome: failed>
    commands: [<bash commands run>]
    output_summary: <stdout/stderr truncated to 4KB>
  - stage: researcher
    started_at: …
    ended_at: …
    outcome: ok | failed
    input: { seed_path: <path>, raw_context_ref: <path> }
    output: { briefing_pack: <markdown string or ref> }
  - stage: panel
    started_at: …
    ended_at: …
    outcome: ok | failed
    roles:                                # one entry per active roster role
      - role: <role-slug>
        input_includes_briefing: true
        tool_calls: [<tool-name>, ...]    # empty list if none
        vote: { verdict: …, confidence: …, cost: …, complexity: …, argument: … }
  - stage: arbiter
    started_at: …
    ended_at: …
    outcome: ok | failed
    input: { votes_path: <path>, roster_path: <path>, gate_path: <path>, seed_path: <path> }
    output: { verdict: …, rule_trace: […], excluded_votes: […], denominators: {...} }
  - stage: scribe
    started_at: …
    ended_at: …
    outcome: ok | failed
    input: { verdict: …, votes: […], briefing_ref: <path> }
    output: { summary_paragraph: <≤500 chars> }
```

**The transcript is written to the orchestrator task as `pipeline_transcript` before the task transitions to `complete`.** This is what makes the transcript-shape ACs (`pipeline-runs-five-stages-in-order`, `every-expert-receives-briefing-and-may-research-deeper`, `panel-fans-out-in-parallel`, `pipeline-transcript-payload-shape`) observable. If the transcript is missing or malformed, the task MUST transition to `failed` with reason `malformed-transcript` — even if the verdict itself is otherwise valid.

## Stage 1: CLI gather (deterministic)

**Transcript:** start a record with `stage: gather, started_at: <now>`.

Run these commands in order (capture stdout + stderr; truncate the summary to 4KB):

```bash
# 1. Related features
specscore feature list --related "$SEED_SLUG" 2>&1 | head -50

# 2. Code-to-spec refs for captured_during
specscore code refs "$CAPTURED_DURING" 2>&1 | head -50

# 3. Recent git activity in relevant paths
git log --oneline --since="30 days ago" -- "$CAPTURED_DURING" 2>&1 | head -20

# 4. Prior captures within the dedupe window (30 days)
ls -t spec/ideas/seeds/ 2>/dev/null | head -10
```

Assemble the outputs into a single context bundle file at `.specscore/consilium/<task-id>/raw-context.md`. This file is the researcher's primary input.

**Transcript:** finalize with `ended_at: <now>, outcome: ok, commands: […], output_summary: <truncated combined output>`. On any command failure, set `outcome: failed, error: <stderr first line>` and transition the task to `failed` with reason `gather-failed`.

## Stage 2: Researcher (one LLM call)

**Transcript:** start a record with `stage: researcher, started_at: <now>`.

Dispatch one Agent tool call with:

- `subagent_type: general-purpose`
- The seed file's full content + the raw context bundle from Stage 1
- The researcher prompt body from `skills/consilium/roles/researcher.md` (read it and include verbatim as the agent's instruction prompt)

From specscore/specstudio-skills, MIT.

More from specscore/specstudio-skills