agent-method 1.5.12

package/templates/README.md

@@ -0,0 +1,363 @@
+# Template Kit
+
+Copyable project templates. Pick one, copy it into your project root, fill in PROJECT.md, and start working with your AI agent.
+
+## Starter template (minimum viable)
+
+For most projects. Gives you cross-session memory, scoped context loading, persistent codebase understanding, lifecycle tracking, structured execution, and management reporting.
+
+```
+starter/
+  CLAUDE.md           # Claude Code entry point (auto-loaded)
+  .cursorrules        # Cursor entry point (auto-loaded)
+  AGENT.md            # Generic entry point (manual loading)
+  PROJECT.md          # Your project vision -- fill this in first
+  PROJECT-PROFILE.md  # Project type, lifecycle stage, active extensions (agent-maintained)
+  STATE.md            # Decisions, blockers, current position
+  ROADMAP.md          # Phase breakdown with gate criteria
+  PLAN.md             # Current task with verification criteria
+  SUMMARY.md          # Session audit trail
+  SESSION-LOG.md      # Session metrics for case study data
+  .context/
+    BASE.md           # Core context -- always loaded with entry point
+    PROTOCOL.yaml     # Agent protocol -- scoping, cascade, conventions, close-check
+    INDEX.yaml        # Navigation manifest -- file inventory, project metadata, metrics
+    METHODOLOGY.md    # Onboarding protocol and format specs (loaded on-demand)
+  registry/
+    feature-registry.yaml  # Feature registry index (layers → features/)
+    features/
+      catalog.yaml         # Domains + features
+      workflows.yaml       # Guided workflows
+      protocol.yaml        # Agent behavioral protocol directives
+      routing.yaml         # Query patterns + activation rules
+    doc-tokens.yaml        # Project metrics, doc dependency graph, terminology (created at init, updated by wwa close)
+  Management/
+    DIGEST.md         # High-effort task digest for managers
+    STATUS.md         # Project health snapshot
+  Reviews/
+    INDEX.md          # Synthesized project intelligence dashboard
+  agentWorkflows/
+    INDEX.md          # Agent workflow performance overview
+  intro/
+    README.md         # Methodology overview + link to full docs
+```
+
+**Setup**: Delete the two entry point files you don't use. Keep the one that matches your agent runtime.
+
+**What you get**: Persistent decisions, scoped file reading, phase-gated execution, atomic task tracking, configurable interaction level, persistent codebase context, management digest, project reviews, workflow analysis, docs dependency mapping, document dependency graph with terminology capture, configurable project boundaries (visibility, distribution, path resolution via PROTOCOL.yaml).
+
+**docs/ is for your project**: The `docs/` folder is not pre-created — the agent creates `.context/DOCS-MAP.md` during first-session onboarding and proposes docs/ files as your project grows based on its scaffolding rules.
+
+**What you don't get**: Specialist context pairing, full review drill-downs, full workflow analysis files.
+
+## Full template (complete methodology)
+
+For complex or multi-phase projects where context management and dual-audience separation matter.
+
+```
+full/
+  CLAUDE.md           # Claude Code entry point (auto-loaded)
+  .cursorrules        # Cursor entry point (auto-loaded)
+  AGENT.md            # Generic entry point (manual loading)
+  PROJECT.md          # Vision, audiences, structure
+  PROJECT-PROFILE.md  # Project type, lifecycle, extensions (agent-maintained)
+  STATE.md            # Decisions, blockers, position, open questions
+  REQUIREMENTS.md     # Scoped features with phase traceability
+  ROADMAP.md          # Phase breakdown with gate criteria
+  PLAN.md             # Current atomic task
+  SUMMARY.md          # Session audit trail
+  SESSION-LOG.md      # Session metrics for case study data
+  .context/
+    BASE.md           # Core context -- always loaded with entry point
+    PROTOCOL.yaml     # Agent protocol -- scoping, cascade, conventions, close-check
+    INDEX.yaml        # Navigation manifest -- file inventory, project metadata, metrics
+    METHODOLOGY.md    # Onboarding protocol and format specs (loaded on-demand)
+    REGISTRY.md       # Navigation registry for split file trees
+    COMPOSITION.md    # Specialist template for analytical projects
+  registry/
+    feature-registry.yaml  # Feature registry index (layers → features/)
+    features/
+      catalog.yaml         # Domains + features
+      workflows.yaml       # Guided workflows
+      protocol.yaml        # Agent behavioral protocol directives
+      routing.yaml         # Query patterns + activation rules
+    doc-tokens.yaml        # Project metrics, doc dependency graph, terminology (created at init, updated by wwa close)
+  Management/
+    DIGEST.md         # High-effort task digest for managers
+    STATUS.md         # Project health snapshot
+  Reviews/
+    INDEX.md          # Synthesized project intelligence dashboard
+    roadmap.md        # Phase progress synthesis
+    plan.md           # Plan execution history
+    project.md        # Project scope evolution
+    requirements.md   # Requirements traceability matrix
+    state.md          # Decision trends and blocker analysis
+    backlog.md        # Backlog health and aging
+  agentWorkflows/
+    INDEX.md          # Agent workflow performance overview
+    sessions.md       # Session analysis from SESSION-LOG.md
+    patterns.md       # Extracted behavioral patterns
+    observations.md   # Case study observations
+  intro/
+    README.md         # Methodology overview + link to full docs
+  todos/
+    backlog.md        # Captured ideas for future work
+```
+
+**Setup**: Delete the two entry point files you don't use. Keep the one that matches your agent runtime.
+
+**What you get**: Everything in starter, plus specialist context pairing, dependency cascade, execution history, human dashboard scaffold, backlog capture, full review drill-downs, full workflow analysis, full communication point structure (direction, checkpoint, record).
+
+## Template content: guided, not empty
+
+Template files ship with **inline instructions** — structured prompts that show both the user and the agent what goes in each section. The agent can read these instructions and help populate the files.
+
+Example from a guided PROJECT.md:
+```markdown
+# {Your Project Name}
+
+<!-- INSTRUCTION: Replace with a 2-3 sentence description of your project -->
+{Describe what your project does and who it's for}
+
+## Problem
+<!-- INSTRUCTION: What problem does this solve? 2-3 bullet points. -->
+
+## Solution
+<!-- INSTRUCTION: How does the project solve the problem? -->
+```
+
+Example from a guided .context/BASE.md:
+```markdown
+# Base Context — Always Loaded
+
+## What this system is
+<!-- INSTRUCTION: 2-3 sentences describing your project's architecture -->
+
+## Codebase map
+<!-- INSTRUCTION: Table of directories, their purposes, and key patterns -->
+<!-- The agent will help populate this from a codebase scan -->
+| Path | Purpose | Key patterns |
+|------|---------|-------------|
+
+## Pairing protocol
+| Task type | Pair BASE.md with |
+|-----------|-------------------|
+<!-- INSTRUCTION: Add rows as you create specialist .context/ files -->
+```
+
+The inline instructions serve as:
+- **User guidance**: Human sees what to fill in
+- **Agent prompts**: Agent reads the instructions and can help populate
+- **Structure enforcement**: Files have the right sections from day one
+
+## Bootstrapping: new project vs existing codebase
+
+### Greenfield (starting from scratch)
+
+1. Copy template into your project root
+2. Delete the two entry point files you don't use
+3. Fill in PROJECT.md with your project vision
+4. Start a conversation — the agent helps populate .context/BASE.md as you build
+
+### Brownfield (existing codebase)
+
+1. Copy template into your existing project root
+2. Delete the two entry point files you don't use
+3. Fill in PROJECT.md with your project vision
+4. Ask the agent: "Scan the codebase and populate the context files"
+5. Agent activates the **Discovery workflow (WF-08)**:
+   - **Inventory**: Walks entire project structure, maps directories and files
+   - **Map**: Traces dependencies (packages, imports, services)
+   - **Extract**: Identifies patterns, conventions, and architectural decisions
+   - **Assess**: Evaluates technical debt, risks, and improvement opportunities
+   - **Bootstrap**: Writes .context/BASE.md, proposes specialists, updates scoping table
+6. Agent updates PROJECT-PROFILE.md lifecycle stage to "discovery"
+7. You approve specialist files; agent transitions lifecycle to "development" when ready
+
+### Integration profiles
+
+Both templates support three integration profiles that control how much methodology surface area gets installed. This is critical for brownfield projects and lighter models.
+
+| Profile | Target model | What's installed | Entry point budget |
+|---------|-------------|-----------------|-------------------|
+| **Lite** | Haiku, GPT-3.5 | STATE.md + .context/METHODOLOGY.md | 25 lines |
+| **Standard** | Sonnet, GPT-4 | STATE.md, PLAN.md, .context/BASE.md, .context/METHODOLOGY.md | 40 lines |
+| **Full** | Opus, o1 | All intelligence layer files | 60 lines |
+
+For lite and standard profiles, operational details (workflows, extended conventions, do-not rules) overflow to `.context/METHODOLOGY.md` — loaded on-demand via the scoping table, not every session. This keeps the entry point lean enough for lighter models to process reliably.
+
+When setup.sh detects an existing entry point file, it uses the **brownfield merge protocol**: methodology content is appended to the existing file rather than overwriting it.
+
+See `docs/architecture/integration-profiles.md` for the full specification.
+
+### Interaction level (in entry point)
+
+Both templates include an interaction level setting in the entry point:
+
+```markdown
+## Interaction level
+mode: checkpoint    # autonomous | checkpoint | collaborative | supervised
+```
+
+| Level | Agent behavior |
+|-------|---------------|
+| **autonomous** | Executes full plan, reports at completion |
+| **checkpoint** | Proposes plan, executes after approval, reports at completion |
+| **collaborative** | Back-and-forth at each step |
+| **supervised** | Explains intent before every file change |
+
+## Entry points (all three included)
+
+Both templates ship with all three entry point variants. Pick the one that matches your runtime and delete the others:
+
+| File | Runtime | Auto-loaded? |
+|------|---------|:------------:|
+| `CLAUDE.md` | Claude Code | Yes |
+| `.cursorrules` | Cursor | Yes |
+| `AGENT.md` | Any agent (manual loading) | No |
+
+All three contain identical scoping rules, cascade structure, and conventions — only the filename and auto-loading behavior differ.
+
+Standalone entry point files are also available in `entry-points/` for reference or individual use.
+
+## Project-type extensions
+
+The starter and full templates ship with **universal** scoping rules, cascade rules, and workflows that work for any project. For project-type-specific capabilities, apply an extension.
+
+```
+extensions/
+  MANIFEST.md             # Extension composition rules, compatibility matrix
+  code-project.md         # Code-specific: scoping, cascade, WF-02, specialists
+  data-exploration.md     # Data-specific: exploration commands, WF-05, specialists
+  analytical-system.md    # Analytical-specific: chain work, evaluation, WF-06, specialists
+```
+
+### How to apply an extension
+
+1. Open the extension file (e.g., `extensions/code-project.md`)
+2. Copy each section's rows into the corresponding section of your entry point
+3. Create the recommended specialist .context/ files as your project grows
+4. Delete the extension file — it's a reference, not a runtime artifact
+
+### Extensions are additive
+
+Extensions add rows to existing tables — they never override universal content. You can apply multiple extensions for projects that span types:
+
+```
+Base entry point (universal)
+  + code-project.md (code scoping, cascade, WF-02)
+  + data-exploration.md (exploration scoping, cascade, WF-05)
+  + analytical-system.md (chain/evaluation scoping, cascade, WF-06)
+  = Mixed project entry point (any combination)
+```
+
+### Registry-driven derivation
+
+Extensions are derived from the feature registry (`docs/internal/feature-registry.yaml`). Each extension's scoping rules trace to registry `query_patterns`, cascade rules trace to registry `dependencies`, and workflows trace to registry `workflows`. See `docs/internal/entry-point-derivation.md` for the derivation specification.
+
+## What the entry point embeds
+
+The entry point is a thin boot loader (~50 lines) that directs the agent to structured YAML files:
+
+- **Boot sequence** — 5-step "On every query" that loads STATE.md and `.context/PROTOCOL.yaml`
+- **Settings** — Mode (interaction level), tier (standard/full), and method version
+- **CLI tools** — Reference table of `wwa` commands (low cognitive load)
+- **Do-not rules** — Negative constraints (highest ROI in auto-loaded file)
+- **Close sentinel** — "Before ending this response" block exploiting LLM recency bias
+
+The agent protocol (scoping rules, cascade triggers, conventions, close-check obligations) lives in `.context/PROTOCOL.yaml` — structured YAML that is denser, single-purpose, and machine-parseable. The navigation manifest (`.context/INDEX.yaml`) provides a file inventory with roles so agents know what exists without scanning.
+
+An agent reading the entry point + PROTOCOL.yaml can follow the full behavioral protocol without accessing any other methodology documentation.
+
+## Context maintenance
+
+Context files are living documents. As your project evolves, the agent keeps them current:
+
+- **Code changes** → Agent updates .context/BASE.md codebase map via cascade
+- **New domain areas** → Agent suggests creating specialist .context/ files
+- **Architecture decisions** → Agent records them in relevant .context/ files
+- **Context drift** → Ask the agent "refresh the project context" to resync
+
+See `docs/architecture/context-pairing.md` for the full context maintenance lifecycle.
+
+## How to use
+
+### Recommended: npx
+
+```bash
+npx agent-method init code ~/my-project
+```
+
+Replace `code` with: `context`, `data`, `mix`, or `general`.
+
+### Manual
+
+1. Copy `starter/` or `full/` into your project root
+2. Delete the two entry point files you don't use
+3. Fill in `PROJECT.md` with your project vision
+4. Start a conversation with your agent — it reads the entry point and knows what to do
+5. For existing codebases: ask the agent to scan and populate context files
+
+See `docs/guides/quick-start.md` for a detailed walkthrough.
+
+## CLI Tools (optional)
+
+The methodology works without any tooling. For teams that want additional validation and automation:
+
+```bash
+npx agent-method                        # zero-install (Node.js 18+)
+npm install -g agent-method             # permanent install
+pip install wwa-tools          # Python alternative
+```
+
+### Developer commands
+
+| Command | Use case |
+|---------|----------|
+| `wwa check` | Validate entry point (auto-finds CLAUDE.md/.cursorrules/AGENT.md) |
+| `wwa scan` | Detect project type from directory contents |
+| `wwa project-discovery` / `wwa context-refresh` / `wwa plan-create` | Test how discovery, refresh, or planning queries route through the pipeline |
+| `wwa plan` | Display current plan status from PLAN.md |
+| `wwa implement` | Show implementation guidance for current step |
+| `wwa review` | Display project review dashboard |
+| `wwa digest` | Show management digest |
+| `wwa close` | Session close checklist, project snapshot, updates registry/doc-tokens.yaml |
+| `wwa refine` | Extract refinement report (auto-finds SESSION-LOG.md) |
+| `wwa casestudy` | Extract case study with project tokens + methodology reference data |
+| `wwa docs` | Show docs coverage report from DOCS-MAP.md |
+| `wwa status` | Check if methodology version is current |
+| `wwa upgrade` | Brownfield-safe update (adds missing files, updates version) |
+| `wwa init <type>` | Set up a new project |
+| `wwa completion` | Generate shell tab-completion (bash/zsh/fish/PowerShell) |
+
+**Safety invariant**: The CLI tool never modifies user source code. Only `.md` and `.yaml`/`.yml` files are writable.
+
+### Project types
+
+Use friendly names everywhere — all commands accept aliases:
+
+```bash
+wwa init code      # software project
+wwa init context   # analytical/prompt project (e.g. PromptStudy)
+wwa init data      # data index/querying project (e.g. SysMLv2)
+wwa init mix       # multi-type project
+```
+
+### Advanced: pipeline subcommands
+
+For internal debugging of routing logic, the CLI exposes `wwa pipeline classify|select|resolve|cascade|test`. These are intended for tool development and are not needed in normal project workflows.
+
+### Dependencies
+
+**Node.js (npx / npm)**:
+- Node.js 18+
+- commander ^12.0, js-yaml ^4.1, inquirer ^9.0, chalk ^5.0
+
+**Python (pip)**:
+- Python 3.9+
+- PyYAML >= 6.0, Click >= 8.0
+
+### Future enhancements
+
+- MCP server: `pip install wwa-tools[mcp]` — exposes pipeline as agent-callable tools
+- Registry watcher: `pip install wwa-tools[watch]` — proactive validation on file changes

package/templates/entry-points/.cursorrules

@@ -0,0 +1,90 @@
+# {Project Name} — Agent Entry Point
+
+<!-- INSTRUCTION: Replace {Project Name} and write a 1-2 sentence project description below -->
+{Describe what your project does, its architecture, and key technologies.}
+
+## On every query
+
+1. This file is auto-loaded — read it first
+2. Read `STATE.md` for current position, decisions, blockers
+3. Read `.context/PROTOCOL.yaml` for scoping, cascade, and conventions
+4. Scope query against PROTOCOL.yaml `scoping:` section
+5. After work, check PROTOCOL.yaml `close_check` before ending response
+
+## Settings
+
+mode: checkpoint
+<!-- autonomous | checkpoint | collaborative | supervised -->
+<!-- checkpoint: propose plan, wait for approval, report at completion (default) -->
+
+tier: full
+<!-- lite | standard | full -->
+<!-- lite: minimal rules, STATE.md only — for Haiku or simple projects -->
+<!-- standard: core rules + context pairing — for Sonnet (default) -->
+<!-- full: all rules, all intelligence layer files — for Opus or complex projects -->
+
+method_version: 1.6
+<!-- Use `wwa status` to compare against latest -->
+
+## CLI tools (optional)
+
+Install: `npm install -g agent-method` (then use `wwa`), or `pip install wwa-tools`.
+
+| When you want to... | Run |
+|---------------------|-----|
+| Validate this entry point | `wwa check` |
+| See what type of project this is | `wwa scan` |
+| Test how a query routes | `wwa route "your question"` |
+| See current plan status | `wwa plan` |
+| Get implementation guidance | `wwa implement` |
+| View project review dashboard | `wwa review` |
+| Show management digest | `wwa digest` |
+| Session close + project snapshot | `wwa close` |
+| Extract a refinement report | `wwa refine` |
+| Extract a case study (with project tokens) | `wwa casestudy` |
+| Check docs coverage | `wwa docs` |
+| Show dependency graph | `wwa deps` |
+| Generate document registry | `wwa doc-review` |
+| Check methodology version | `wwa status` |
+| Update methodology files | `wwa upgrade` |
+| Set up a new project | `wwa init` |
+| Run project discovery workflow | `wwa project-discovery` |
+| Run context refresh workflow | `wwa context-refresh` |
+| Run phase completion workflow | `wwa phase-complete` |
+| Show routing for backlog | `wwa backlog` |
+| Run planning workflow | `wwa plan-create` |
+| Run dependency analysis workflow | `wwa dependency-analysis` |
+| Run debt assessment workflow | `wwa debt-assessment` |
+| Run docs update workflow | `wwa docs-update` |
+| Run cross-reference workflow | `wwa cross-reference` |
+| Append to backlog / decision / finding / session / summary | `wwa add <type> [content]` |
+
+When doing **project review** or **self-review** sessions, use the collection checklist for capture format: `docs/internal/review/collection-checklist.md` (if present).
+
+<!-- INSTRUCTION: The agent can suggest these commands when the user asks about validation,
+     project setup, or methodology updates. All commands auto-detect project type and find
+     entry points automatically. Add --json for machine-readable output. -->
+
+## Do not
+
+- Modify project source code, tests, or pre-existing documentation through methodology operations — only create/modify methodology files (STATE.md, .context/, PLAN.md, etc.)
+- Delete existing project files during brownfield integration — methodology is additive only
+- Load files not in PROTOCOL.yaml scoping read-set for the current query type
+- Defer STATE.md decision recording to end of session
+- Skip cascade checks after file changes
+- Load multiple specialist .context/ files for a single query
+- Record routine queries in STATE.md or SESSION-LOG.md — only decisions, blockers, and high-effort work warrant documentation
+
+<!-- INSTRUCTION: Add project-specific "do not" rules as you discover common mistakes -->
+
+## First session
+
+<!-- AGENT: If PROJECT.md contains {placeholder} text, this is a first session. -->
+Follow the onboarding protocol in `.context/METHODOLOGY.md` — it guides you through
+greenfield (4 stages) or brownfield (5 stages) setup with checkpoints at each step.
+
+## Before ending this response
+
+Read `.context/PROTOCOL.yaml` `close_check`. For each triggered item,
+update the target file now. A response that modifies files but skips
+triggered obligations is incomplete.

package/templates/entry-points/AGENT.md

@@ -0,0 +1,90 @@
+# {Project Name} — Agent Entry Point
+
+<!-- INSTRUCTION: Replace {Project Name} and write a 1-2 sentence project description below -->
+{Describe what your project does, its architecture, and key technologies.}
+
+## On every query
+
+1. This file is auto-loaded — read it first
+2. Read `STATE.md` for current position, decisions, blockers
+3. Read `.context/PROTOCOL.yaml` for scoping, cascade, and conventions
+4. Scope query against PROTOCOL.yaml `scoping:` section
+5. After work, check PROTOCOL.yaml `close_check` before ending response
+
+## Settings
+
+mode: checkpoint
+<!-- autonomous | checkpoint | collaborative | supervised -->
+<!-- checkpoint: propose plan, wait for approval, report at completion (default) -->
+
+tier: full
+<!-- lite | standard | full -->
+<!-- lite: minimal rules, STATE.md only — for Haiku or simple projects -->
+<!-- standard: core rules + context pairing — for Sonnet (default) -->
+<!-- full: all rules, all intelligence layer files — for Opus or complex projects -->
+
+method_version: 1.6
+<!-- Use `wwa status` to compare against latest -->
+
+## CLI tools (optional)
+
+Install: `npm install -g agent-method` (then use `wwa`), or `pip install wwa-tools`.
+
+| When you want to... | Run |
+|---------------------|-----|
+| Validate this entry point | `wwa check` |
+| See what type of project this is | `wwa scan` |
+| Test how a query routes | `wwa project-discovery` / `wwa context-refresh` / `wwa plan-create` (see CLI docs) |
+| See current plan status | `wwa plan` |
+| Get implementation guidance | `wwa implement` |
+| View project review dashboard | `wwa review` |
+| Show management digest | `wwa digest` |
+| Session close + project snapshot | `wwa close` |
+| Extract a refinement report | `wwa refine` |
+| Extract a case study (with project tokens) | `wwa casestudy` |
+| Check docs coverage | `wwa docs` |
+| Show dependency graph | `wwa deps` |
+| Generate document registry | `wwa doc-review` |
+| Check methodology version | `wwa status` |
+| Update methodology files | `wwa upgrade` |
+| Set up a new project | `wwa init` |
+| Run project discovery workflow | `wwa project-discovery` |
+| Run context refresh workflow | `wwa context-refresh` |
+| Run phase completion workflow | `wwa phase-complete` |
+| Show routing for backlog | `wwa backlog` |
+| Run planning workflow | `wwa plan-create` |
+| Run dependency analysis workflow | `wwa dependency-analysis` |
+| Run debt assessment workflow | `wwa debt-assessment` |
+| Run docs update workflow | `wwa docs-update` |
+| Run cross-reference workflow | `wwa cross-reference` |
+| Append to backlog / decision / finding / session / summary | `wwa add <type> [content]` |
+
+When doing **project review** or **self-review** sessions, use the collection checklist for capture format: `docs/internal/review/collection-checklist.md` (if present).
+
+<!-- INSTRUCTION: The agent can suggest these commands when the user asks about validation,
+     project setup, or methodology updates. All commands auto-detect project type and find
+     entry points automatically. Add --json for machine-readable output. -->
+
+## Do not
+
+- Modify project source code, tests, or pre-existing documentation through methodology operations — only create/modify methodology files (STATE.md, .context/, PLAN.md, etc.)
+- Delete existing project files during brownfield integration — methodology is additive only
+- Load files not in PROTOCOL.yaml scoping read-set for the current query type
+- Defer STATE.md decision recording to end of session
+- Skip cascade checks after file changes
+- Load multiple specialist .context/ files for a single query
+- Record routine queries in STATE.md or SESSION-LOG.md — only decisions, blockers, and high-effort work warrant documentation
+
+<!-- INSTRUCTION: Add project-specific "do not" rules as you discover common mistakes -->
+
+## First session
+
+<!-- AGENT: If PROJECT.md contains {placeholder} text, this is a first session. -->
+Follow the onboarding protocol in `.context/METHODOLOGY.md` — it guides you through
+greenfield (4 stages) or brownfield (5 stages) setup with checkpoints at each step.
+
+## Before ending this response
+
+Read `.context/PROTOCOL.yaml` `close_check`. For each triggered item,
+update the target file now. A response that modifies files but skips
+triggered obligations is incomplete.

package/templates/entry-points/CLAUDE.md

@@ -0,0 +1,88 @@
+# {Project Name} — Agent Entry Point
+
+<!-- INSTRUCTION: Replace {Project Name} and write a 1-2 sentence project description below -->
+{Describe what your project does, its architecture, and key technologies.}
+
+## On every query
+
+1. This file is auto-loaded — read it first
+2. Read `STATE.md` for current position, decisions, blockers
+3. Read `.context/PROTOCOL.yaml` for scoping, cascade, and conventions
+4. Scope query against PROTOCOL.yaml `scoping:` section
+5. After work, check PROTOCOL.yaml `close_check` before ending response
+
+## Settings
+
+mode: checkpoint
+<!-- autonomous | checkpoint | collaborative | supervised -->
+<!-- checkpoint: propose plan, wait for approval, report at completion (default) -->
+
+tier: full
+<!-- lite | standard | full -->
+<!-- lite: minimal rules, STATE.md only — for Haiku or simple projects -->
+<!-- standard: core rules + context pairing — for Sonnet (default) -->
+<!-- full: all rules, all intelligence layer files — for Opus or complex projects -->
+
+method_version: 1.6
+<!-- Use `wwa status` to compare against latest -->
+
+## CLI tools (optional)
+
+Install: `npm install -g agent-method` (then use `wwa`), or `pip install wwa-tools`.
+
+| When you want to... | Run |
+|---------------------|-----|
+| Validate this entry point | `wwa check` |
+| See what type of project this is | `wwa scan` |
+| Test how a query routes | `wwa project-discovery` / `wwa context-refresh` / `wwa plan-create` (see CLI docs) |
+| See current plan status | `wwa plan` |
+| Get implementation guidance | `wwa implement` |
+| View project review dashboard | `wwa review` |
+| Show management digest | `wwa digest` |
+| Session close + project snapshot | `wwa close` |
+| Extract a refinement report | `wwa refine` |
+| Extract a case study (with project tokens) | `wwa casestudy` |
+| Check docs coverage | `wwa docs` |
+| Check methodology version | `wwa status` |
+| Update methodology files | `wwa upgrade` |
+| Set up a new project | `wwa init` |
+| Run project discovery workflow | `wwa project-discovery` |
+| Run context refresh workflow | `wwa context-refresh` |
+| Run phase completion workflow | `wwa phase-complete` |
+| Show routing for backlog | `wwa backlog` |
+| Run planning workflow | `wwa plan-create` |
+| Run dependency analysis workflow | `wwa dependency-analysis` |
+| Run debt assessment workflow | `wwa debt-assessment` |
+| Run docs update workflow | `wwa docs-update` |
+| Run cross-reference workflow | `wwa cross-reference` |
+| Append to backlog / decision / finding / session / summary | `wwa add <type> [content]` |
+
+When doing **project review** or **self-review** sessions, use the collection checklist for capture format: `docs/internal/review/collection-checklist.md` (if present).
+
+<!-- INSTRUCTION: The agent can suggest these commands when the user asks about validation,
+     project setup, or methodology updates. All commands auto-detect project type and find
+     entry points automatically. Add --json for machine-readable output. -->
+
+## Do not
+
+- Modify project source code, tests, or pre-existing documentation through methodology operations — only create/modify methodology files (STATE.md, .context/, PLAN.md, etc.)
+- Delete existing project files during brownfield integration — methodology is additive only
+- Load files not in PROTOCOL.yaml scoping read-set for the current query type
+- Defer STATE.md decision recording to end of session
+- Skip cascade checks after file changes
+- Load multiple specialist .context/ files for a single query
+- Record routine queries in STATE.md or SESSION-LOG.md — only decisions, blockers, and high-effort work warrant documentation
+
+<!-- INSTRUCTION: Add project-specific "do not" rules as you discover common mistakes -->
+
+## First session
+
+<!-- AGENT: If PROJECT.md contains {placeholder} text, this is a first session. -->
+Follow the onboarding protocol in `.context/METHODOLOGY.md` — it guides you through
+greenfield (4 stages) or brownfield (5 stages) setup with checkpoints at each step.
+
+## Before ending this response
+
+Read `.context/PROTOCOL.yaml` `close_check`. For each triggered item,
+update the target file now. A response that modifies files but skips
+triggered obligations is incomplete.