legion

Auto-triggered skill that reminds agents of the recall-before-grep doctrine. When an agent is about to search the codebase for answers, this skill reminds them to check legion memory first. Use this when the agent is researching a problem, looking for patterns, or trying to understand why something was built a certain way.

Compose the PR body as a forcing function before opening a PR. Map each of the issue's acceptance criteria to the change that satisfies it -- in your own prose, with evidence -- and state what you deliberately did NOT do. Articulation is verification: writing the mapping makes you re-read your own diff as a reader and catch what you talked past while coding. Validate the body with `legion pr write-check`, which refuses an empty or boilerplate mapping and records the gate `legion pr create` requires. Run this after `/legion:legion-simplify`, before review.

The review stage of the quality pipeline: simplify -> pr-write -> review -> verify. Fans out independent review dimensions over an open PR (spec-vs-diff, correctness, quality, security), adversarially verifies every HIGH/MED finding before reporting it, and records the result via `legion quality-gate record --skill legion-review` so downstream gates can require a clean review on HEAD. Run after `legion pr create`, before team sign-off and /legion:legion-verify.

Review the current branch diff for code quality issues: duplicate logic, unnecessary abstraction, stringly-typed state, and other structural problems. Articulate, per changed file, what you checked and why the verdict holds; `legion quality-gate check` validates the articulation (coverage + non-boilerplate + located evidence) and records the gate so `legion pr create` can verify clean state before opening a PR. Run this on every feature branch before a PR.

The final evidence gate before finished work is called done. Read the issue's acceptance criteria, the diff, and the test output, and emit one verdict per criterion -- pass, fail, or uncertain -- each with cited evidence (a test name, a file:line, an observable behavior). `legion verify --issue` records the verdict and decides the work's fate: all-pass records a clean gate, any fail hard-blocks, any uncertain (or a pass with no evidence) needs a human. For a solo engineering team this is the QA the operator does not have -- run it after review, before close.

The evidence step of service design: take the research agenda's claims to test, query eavesdrop's discourse corpus, apply the 0.40 disconfirm rule, surface emergent insights the intent missed, and land one schema-valid Discovery document. Parks on a missing corpus rather than treating no evidence as a verdict. Invoke after sd-intent-review.

The imagination step of service design: five light perspective passes over the intent and supported insights -- actor-walk, boundary-walk, second-order, value-lifecycle, evidence-adversarial -- unioned and weighted by cross-lens convergence, landing one schema-valid Ecosystem document plus a register of flagged unknowns. The one step that earns multi-pass cost. Invoke after sd-discover lands the Discovery.

The first service-design step: read a repo's intent document and produce a research agenda -- candidate services to test and claims to test -- with every item tracing to an intent field. Outputs hypotheses to validate against real discourse, never designed services. Invoke at the start of a repo's service design, before any artifact exists.

Run a repo's service design end to end: intent-review -> discover -> ecosystem-imagine -> the persona, journey, and blueprint writers. This skill is the orchestrator, written as instructions -- the agent that invokes it conducts the pipeline by following it. Each step reads and writes documents in the legion store by id; a validation gate sits between steps; a step that cannot finish parks and resumes instead of guessing. Invoke when a repo starts or resumes its service design.

Write one service blueprint as a schema-valid legion document: the frontstage and backstage of a service across a sequence of steps, grounded in the journey it supports and the intent's real capabilities. Planned machinery is named as planned, never drawn as running. Invoke after the journey it backs exists.

Write one service-design journey as a schema-valid legion document: a persona through a scenario over time, with an emotional curve carried in plain emotion words drawn from evidence. Every low point traces to a Discovery insight; contradicted claims do not reappear as dips. Invoke after the persona it walks exists.

Write one service-design persona as a schema-valid legion document: behaviors, mental models, and the relationship to the service, every statement tracing to a Discovery insight or an intent field. Not demographics, not archetypes, no invented interiority. Invoke after the Discovery and ecosystem are landed.

Write a scope's full requirement set -- FR and NFR documents -- from the intent/discovery layer, in one pass. The Deliver-edge writer: it crystallizes the IEEE 830-style requirement set the executor consumes, every SHALL naming what earned it and every gap escalated rather than resolved in-body. Two input modes: from an intent alone (system work) or from a landed service design (product work). Invoke when a scope is ready to move from discovery to a buildable spec.