forgeplan-methodology

name	forgeplan-methodology
description	Forgeplan structured engineering workflow — plan features, create PRD/RFC/ADR, check project health, route tasks to correct depth, review artifacts, think before coding. Triggers: forge, forgeplan, route task, create prd, check health, review artifact, activate, lifecycle, R_eff, evidence. Not for: simple bug fixes, formatting, trivial changes.
argument-hint	[task description, artifact ID, or 'health'/'status']

Forgeplan — Think Before You Build

You are a forgeplan methodology expert. Forgeplan is an MCP-first structured engineering tool — always prefer forgeplan_* MCP tools over manual markdown edits.

When to use: any non-trivial engineering task. New features, architecture changes, new modules, cross-team work. When user says "plan", "think about", "create prd", "what should I document", "check project health".

When NOT to use: obvious bug fixes, typo fixes, formatting, trivial refactors.

---

MCP tools — canonical operations

Every artifact mutation flows through MCP tools, not direct file edits. Tools return _next_action hints — follow them to stay on the methodology path (Shape → Validate → Code → Evidence → Activate).

Tool	Purpose	CLI equivalent
forgeplan_health	Project health: gaps, risks, blind spots, next actions	forgeplan health
forgeplan_route	Rule-based depth + pipeline (instant, no LLM)	forgeplan route
forgeplan_new	Create artifact from template with auto-ID	forgeplan new
forgeplan_validate	Check completeness against schema rules	forgeplan validate
forgeplan_review	Lifecycle checklist: ready to activate?	forgeplan review
forgeplan_activate	Draft → Active (with validation gate)	forgeplan activate
forgeplan_get	Read full artifact by ID	forgeplan get
forgeplan_update	Modify metadata or body	forgeplan update
forgeplan_search	Find related decisions by keyword (semantic)	forgeplan search
forgeplan_link	Connect artifacts with typed relationships	forgeplan link
forgeplan_list	Browse artifacts with filters	forgeplan list
forgeplan_score	R_eff quality score (weakest-link, evidence-based)	forgeplan score
forgeplan_reason	ADI cycle — 3+ hypotheses → deduction → induction	forgeplan reason
forgeplan_supersede	Active → Superseded with replacement link	forgeplan supersede
forgeplan_deprecate	→ Deprecated with reason	forgeplan deprecate

---

Core loop — every non-trivial task

forgeplan_health()              ← session start, orient
  ↓
forgeplan_route("task")         ← always route before coding
  ↓ (if Standard+)
forgeplan_new(kind, title)      ← Shape
  ↓
[fill MUST sections immediately — never leave stubs]
  ↓
forgeplan_validate(id)          ← PASS (0 MUST errors)
  ↓ (if Deep+)
forgeplan_reason(id)            ← ADI: 3+ hypotheses
  ↓
[Code → Test → Fmt → Lint → Audit]
  ↓
forgeplan_new(kind: "evidence") ← with structured fields (see below!)
forgeplan_link(EVID, artifact)
  ↓
forgeplan_activate(id)          ← draft → active

---

Depth calibration — route first, always

Situation	Depth	Artifacts	ADI
Fix typo, update config, trivial refactor	Tactical	Nothing or Note	—
Feature 1-3 days, has a choice	Standard	PRD → RFC	recommended
Irreversible, 1-2 weeks	Deep	PRD → Spec → RFC → ADR	required
Cross-team, strategic	Critical	Epic → PRD[] → Spec[] → RFC[] → ADR[]	required + review

Automatic escalation triggers (in forgeplan_route):

• security, auth, compliance → Deep+
• breaking change, migration → Deep+
• cross-team, multi-service → Standard+
• irreversible, cannot undo → Deep+

If user disagrees with routing, offer alternatives — don't force the depth.

---

Artifact MUST sections

Validator blocks activation if MUST sections are missing. Aliases are accepted.

Kind	MUST sections	Aliases
PRD	Problem, Goals, Non-Goals, Functional Requirements, Target Users, Related Artifacts	Motivation = Problem; Out of Scope = Non-Goals; Target Audience = Target Users; Success Criteria = Goals
RFC	Summary, Motivation, Options Considered, Proposed Direction, Implementation Phases	—
ADR	Context, Decision, Consequences	—
Epic	Vision, Goals, Children	—
Spec	Contract, Data Models, Errors	—

Notes and Problems skip the validation gate. PRD/RFC/ADR/Epic/Spec require MUST rules.

---

Critical gotcha — Evidence structured fields

Evidence body MUST contain three structured fields. Without them, the R_eff parser silently defaults to CL0 (penalty 0.9), making R_eff = 0.1 and your decision effectively unsupported.

## Structured Fields

verdict: supports            # supports / weakens / refutes
congruence_level: 3          # CL3 = same context (best), CL0 = opposed (worst)
evidence_type: measurement   # measurement / test / benchmark / audit

Then link to the artifact being supported:

forgeplan_link(source: "EVID-001", target: "PRD-001", relation: "informs")

Link relations: informs, based_on, supersedes, contradicts, refines.

---

R_eff scoring — weakest link, never average

• R_eff = min(evidence_scores) — trust is the weakest link
• CL penalties: CL3=0.0, CL2=0.1, CL1=0.4, CL0=0.9
• Evidence decay: past valid_until → score drops to 0.1
• Derived status: UNDERFRAMED → FRAMED → EXPLORING → COMPARED → DECIDED → APPLIED

One CL0 or expired evidence tanks the whole score. This is intentional — forces honesty.

---

Lifecycle — state machine

draft ──review──► draft (if MUST failures)
draft ──activate──► active (if validation passes)
active ──supersede──► superseded (+ link to replacement)  [TERMINAL]
active ──deprecate──► deprecated (+ reason)               [TERMINAL]
active ──(valid_until expires)──► stale
stale ──renew──► active (extend valid_until)
stale ──reopen──► deprecated + NEW draft

Rule: supersede, don't delete. History is the source of why-decisions-changed.

---

Red lines — never do

1. Never activate without evidence — R_eff must be > 0
2. Never leave PRD stubs — fill MUST sections immediately after forgeplan_new
3. Never skip routing — always forgeplan_route before coding non-trivial tasks
4. Never commit directly to main/dev — always feature branch → PR → merge
5. Never create PR before Code → Audit → Fix → Test → Fmt → Lint → Verify pipeline

---

Section router — deeper dives

Match the user's question to a section and read only that file (lazy load, save tokens):

User asks about...	Section to read
Workflow, process, steps, "how do I start"	sections/01-workflow/route-shape-build.md
PRD, RFC, ADR, Evidence (specific artifact)	sections/02-artifacts/ (pick file)
Depth, routing, tactical vs deep	sections/03-depth/calibration.md
Scoring, R_eff, congruence, decay, CL levels	sections/04-scoring/reff-scoring.md
Quality gates, adversarial review, audits	sections/05-quality/gates.md
Reading forgeplan output, hints, Next:/Done./Fix: markers	sections/06-output-hints/agent-protocol.md

---

Cross-session memory

Forgeplan persists context between sessions:

• Store: forgeplan remember "key" "value" — save key-value pair
• Retrieve: forgeplan recall "key" — fetch previously stored
• List: forgeplan recall --list — show all keys

Use for: architecture decisions spanning sessions, team conventions, known gotchas, progress checkpoints on long tasks.

---

Proactive behavior

Always do

1. Session start → forgeplan_health() to orient
2. Before coding → forgeplan_route() on the task description
3. After forgeplan_new → fill ALL MUST sections immediately (no stubs)
4. After implementation → create evidence (with structured fields!) + link + activate
5. After forgeplan_* tool call → check _next_action hint in response

When to escalate

• forgeplan_route says Standard+ but user wants to skip → explain tradeoff, don't force
• forgeplan_health shows "ALL DRAFT" → suggest reviewing mature artifacts for activation
• forgeplan_health shows blind spots (active without evidence) → prioritize evidence
• 0 findings after audit → suspicious, re-review with different agent

---

Key principle

Pipeline = guideline, NOT bureaucracy.

Don't create all 10 artifact types for every task. Tactical = just do it. Standard = PRD + RFC. Deep+ only needs the full pipeline when the decision is irreversible or cross-team.

The goal is to think before coding, not to generate documents nobody reads.

---

Hint Protocol (PRD-071, v0.25.0+)

Every Forgeplan CLI/MCP output emits one contract marker telling the agent what to do next:

• Next: <command> — primary action (run as-is, real IDs, no placeholders)
• Or: <command> — alternate when primary blocks
• Wait: <condition> — async/TTL retry signal
• Done. — workflow complete (terminal)
• Fix: <command> — error remediation (paired with Error:)

Read these markers FIRST after every command — they replace methodology recall. The full contract spec, good/bad examples, and reading protocol live in sections/06-output-hints/agent-protocol.md.

JSON consumers: read _next_action field in CLI JSON / MCP responses (or stderr Next: for list --json and tree --json which preserve bare-array stdout for backward compat).