/plamen-l1

description: "Launch the V2 deterministic L1 audit pipeline for Go/Rust node clients (same as /plamen-l1-wizard). Experimental."

Plamen L1 Infrastructure Audit Pipeline

Step -1: Route to V2 L1 Wizard (MANDATORY first check)

**Routing rule** (evaluate `$ARGUMENTS` exactly once, before any other step):

• If `$ARGUMENTS` is empty OR does NOT contain the literal token `wrapper-launch`:
• **STOP processing this file.** Read and execute

`~/.claude/commands/plamen-l1-wizard.md` from its Step 1 onward, passing `$ARGUMENTS` through unchanged. The wizard collects L1 audit parameters and launches `~/.claude/scripts/plamen_driver.py` with `pipeline=l1`.

• Do NOT run any of the Step 0..Step 6 sections below in interactive mode.

Those sections are section-extracted by the driver one phase at a time via `claude -p --resume` invocations with `wrapper-launch` set; they are not a complete interactive pipeline.

• If `$ARGUMENTS` contains `wrapper-launch`:
• You are running INSIDE a driver subprocess. Proceed to Step 0 below.

> **Why this routing exists**: pre-v2.0.0 `/plamen-l1` was an LLM orchestrator > with the same context-saturation failure modes as the SC V1 prompt > (silent step-skipping on long audits, files claimed-written-but-missing > on disk, compaction-induced data loss). v2.0.0 replaced it with the > deterministic Python driver. The interactive surface now points at the > wizard so users get the reliable path by default.

---

> **Experimental.** L1 mode is newer than the SC pipeline and being validated > against benchmark targets (Geth, Reth, CometBFT, Cosmos SDK). Bug classes, > phase ordering, and evidence tags are L1-specific (see below) and **do not > apply to smart-contract codebases** — run `/plamen` (without `l1`) for > Solidity / Move / Solana / Soroban. See `docs/l1-mode/design.md` for the > full specification.

> **Scope**: Go and Rust L1 / L2 node clients — Geth, Erigon, Reth, Lighthouse, CometBFT, Cosmos SDK, Substrate, op-geth, op-reth, and their forks. Targets T0 (patch review) / T1 (subsystem audit) / T2 (whole-client via multi-scoped runs) / T3 (full client, shallower coverage).

> **Architecture**: Unlike smart-contract modes, L1 mode: > - Runs **Phase 0.5 Bake** before recon (scip-go / rust-analyzer scip / Opengrep baseline) > - Decomposes breadth by **layer** (network / consensus / execution / crypto / storage / rpc / mempool), not by file cluster > - Spawns **two new depth agent roles** (`depth-consensus-invariant`, `depth-network-surface`) > - **Removes Phase 4c chain analysis** — L1 bugs are point vulnerabilities, not compound exploits > - Uses **new evidence tags** in Phase 5: `[DIFF-PASS]`, `[CONFORMANCE-PASS]`, `[NON-DET-PASS]`, `[FUZZ-PASS]`, `[LSP-TRACE]` alongside `[POC-PASS]` and `[CODE-TRACE]` > - Applies the **L1-specific severity matrix** at `docs/l1-mode/severity-matrix.md`, not the smart-contract matrix in `rules/report-template.md`

Orchestration Protocol

**MANDATORY**: Before starting any audit work, read and apply `~/.claude/rules/orchestrator-rules.md`. It contains the AUDIT MODES table, CRITICAL RULES 1-16, and the orchestration architecture. You are the orchestrator — those rules govern how you spawn agents, manage phases, and enforce completeness.

Step 0: L1 Audit Wizard

Parse `$ARGUMENTS` for pre-filled values (shortcut handling):

• First token is `l1` — already known, strip it.
• If the next token is an absolute path, set `PROJECT_PATH` to that path. Otherwise use cwd.
• `light` / `core` / `thorough` → set `L1_DEPTH` accordingly. Default `core`. This controls depth loop iterations, niche agent activation, and verification scope — same semantics as the smart-contract mode axis.
• `scope:<subdir>` → set `SUBSYSTEM_SCOPE=<subdir>`. Audit only that subsystem (T1) or mark as T2 multi-scoped-run component. Default: no scope restriction.
• `target-type:{patch|subsystem|feature|whole}` → set the tier explicitly. Default: inferred from `SCOPE` and diff detection.
• `docs:<path-or-url>` → protocol spec / whitepaper / audit docs to ingest in recon.
• `nodocs` → explicit no docs.
• `wrapper-launch` → same as smart-contract mode; skip cost estimate + confirmation, jump to Step 1.
• `proven-only: true` → cap unproven findings (no mechanical evidence tag) at Low severity.

Step 0a: Banner + Toolchain Check

Output the banner (same as plamen.md Step 0a), then add the L1 header:

┌─ L1 Infrastructure Mode (experimental) ────────────────────┐
│  Scope: Go / Rust node clients (50k-500k LOC)              │
│  Tiers: T0 patch  |  T1 subsystem  |  T2 whole-client      │
│  Phase 4c: REMOVED (point vulnerabilities don't chain)     │
│  Evidence tags: [DIFF-PASS] [NON-DET-PASS] [LSP-TRACE] ... │
└────────────────────────────────────────────────────────────┘

**Toolchain probe** (L1-specific additions to the standard probe):

export PATH="$HOME/.cargo/bin:$HOME/go/bin:$HOME/.local/bin:$PATH" && \
echo "L1 Toolchain:" && \
echo -n "  Primitives: " && \
(command -v scip-go >/dev/null 2>&1 && echo -n "✓scip-go " || echo -n "✗scip-go ") && \
(command -v rust-analyzer >/dev/null 2>&1 && echo -n "✓rust-analyzer " || echo -n "✗rust-analyzer ") && \
(command -v ast-grep >/dev/null 2>&1 && echo -n "✓ast-grep " || echo -n "✗ast-grep ") && \
(command -v opengrep >/dev/null 2>&1 && echo -n "✓opengrep " || echo -n "○opengrep ") && \
(command -v codeql >/dev/null 2>&1 && echo -n "✓codeql" || echo -n "○codeql") && echo "" && \
echo -n "  Targets: " && \
(command -v go >/dev/null 2>&1 && echo -n "✓go($(go version 2>/dev/null | awk '{print $3}')) " || echo -n "✗go ") && \
(command -v cargo >/dev/null 2>&1 && echo -n "✓cargo($(cargo --version 2>/dev/null | awk '{print $2}'))" || echo -n "✗cargo") && echo ""

Missing `scip-go`, `rust-analyzer`, or `ast-grep` is a **hard blocker** — L1 mode requires the primitive layer. Stop and instruct the user to install:

scip-go:       go install github.com/scip-code/s