agent-method 1.5.0

package/templates/full/PROJECT.md

@@ -0,0 +1,46 @@
+# {Your Project Name}
+
+<!-- INSTRUCTION: Replace with a 2-3 sentence description of your project.
+     Include what it does, who it's for, and what technologies it uses. -->
+{Describe what your project does and who it's for}
+
+## Problem
+
+<!-- INSTRUCTION: What problem does this solve? 2-3 bullet points. -->
+
+- {Problem statement 1}
+- {Problem statement 2}
+
+## Solution
+
+<!-- INSTRUCTION: How does the project solve the problem? Brief description of the approach. -->
+
+{Describe your approach}
+
+## Project structure
+
+<!-- INSTRUCTION: Table of top-level directories and their purposes.
+     The agent uses this to understand the project layout.
+     For existing codebases, ask the agent to help populate this from a scan. -->
+
+| Path | Purpose |
+|------|---------|
+| {src/} | {Source code} |
+| {docs/} | {Documentation} |
+
+## Audiences
+
+<!-- INSTRUCTION: Who interacts with this project? Users, developers, managers, agents? -->
+
+| Audience | What they need |
+|----------|---------------|
+| {Developer} | {Working code, clear architecture} |
+| {User} | {Functional product} |
+
+## Principles
+
+<!-- INSTRUCTION: 3-5 guiding principles for decision-making on this project. -->
+
+1. {Principle 1}
+2. {Principle 2}
+3. {Principle 3}

package/templates/full/REQUIREMENTS.md

@@ -0,0 +1,30 @@
+# Requirements
+
+<!-- INSTRUCTION: Define what the project must achieve. Each requirement has an ID,
+     description, phase traceability, and status. Requirements drive the ROADMAP. -->
+
+## Functional requirements
+
+| ID | Requirement | Phase | Status |
+|----|-------------|-------|--------|
+| R1 | {What the system must do} | {Phase #} | pending |
+| R2 | {Second requirement} | {Phase #} | pending |
+| R3 | {Third requirement} | {Phase #} | pending |
+
+<!-- INSTRUCTION: Add requirements as they're identified. Link each to the phase
+     where it will be delivered. Mark "done" when the phase gate passes. -->
+
+## Non-functional requirements
+
+| ID | Requirement | Phase | Status |
+|----|-------------|-------|--------|
+| NF1 | {Performance, security, or usability requirement} | {Phase #} | pending |
+
+## Traceability
+
+<!-- INSTRUCTION: This section maps requirements to deliverables.
+     Update when requirements are completed or deliverables change. -->
+
+| Requirement | Delivered by | Verified by |
+|-------------|-------------|-------------|
+| R1 | {Deliverable name or file} | {How it was verified} |

package/templates/full/ROADMAP.md

@@ -0,0 +1,39 @@
+# Roadmap
+
+<!-- INSTRUCTION: Define phases with deliverables and gate criteria.
+     Each phase should have:
+     - A clear objective (1 sentence)
+     - A deliverable table (what, requirement, status)
+     - A gate (how you know the phase is done)
+     Copy the Phase template below for each phase in your project. -->
+
+## Phase 1 — {Phase name} [status]
+
+<!-- INSTRUCTION: Replace {Phase name} with a descriptive name.
+     Set [status] to one of: current, pending, done -->
+
+{One sentence describing what this phase achieves.}
+
+| Deliverable | Requirement | Status |
+|-------------|-------------|--------|
+| {Deliverable 1} | {Which requirement it satisfies} | pending |
+| {Deliverable 2} | {Which requirement it satisfies} | pending |
+
+**Gate**: {How you know this phase is complete. Be specific — measurable criteria.}
+
+---
+
+## Phase 2 — {Phase name} [pending]
+
+{One sentence describing what this phase achieves.}
+
+| Deliverable | Requirement | Status |
+|-------------|-------------|--------|
+| {Deliverable 1} | {Requirement} | pending |
+
+**Gate**: {Completion criteria}
+
+---
+
+<!-- INSTRUCTION: Add more phases as needed. Each phase should be achievable
+     in 1-5 sessions. If a phase takes longer, split it. -->

package/templates/full/SESSION-LOG.md

@@ -0,0 +1,41 @@
+# Session Log
+
+Append-only session observation log for case study data collection. Each session adds a micro-entry at close. This file is read-only during extraction (never during normal work).
+
+<!-- AGENT INSTRUCTION: At the end of every session, append a new entry below using this format.
+     Do NOT read this file during normal work — only append to it.
+     Do NOT modify or delete previous entries.
+     When this file exceeds 300 lines, archive older entries to session-log/batch-{N}.md -->
+
+## Project context
+
+| Field | Value |
+|-------|-------|
+| Project name | {project name} |
+| Project type | {code / data / analytical / mixed / general} |
+| Integration profile | {lite / standard / full} |
+| Extension(s) | {code-project / data-exploration / analytical-system / none} |
+| Observation started | {date} |
+
+## Observation checklist
+
+At session close, reflect on these before writing the micro-entry:
+1. Which workflow did this session follow?
+2. Which query types were encountered?
+3. Which features visibly activated? (context loading, cascade, decision recording, scoping)
+4. Were any cascades expected but missed?
+5. Were any decisions deferred instead of recorded immediately?
+6. Was there friction with any methodology rule?
+7. Any degradation signals? (HAI-05: cascade misses, instruction loss, shallow context)
+
+## Session entries
+
+<!-- Append new entries below. Format:
+### S{N} — {YYYY-MM-DD} — {brief title}
+Model: {model} | Profile: {profile} | Workflow: {WF-XX}
+Queries: {query types encountered}
+Features: {feature IDs activated}
+Cascades: {triggered}/{expected} | Decisions: {count}
+Friction: {none | brief description}
+Finding: {none | observation with methodology implication}
+-->

package/templates/full/STATE.md

@@ -0,0 +1,42 @@
+# State
+
+## Current position
+
+- **Phase**: {Phase name or number}
+- **Status**: {What's happening now}
+- **Next**: {What comes after the current work}
+- **Active context**: `.context/BASE.md`
+
+<!-- INSTRUCTION: Update this section every session. The next session reads this
+     to know where to pick up. Be specific about what's in progress and what's next. -->
+
+## Decisions
+
+| Date | Decision | Rationale |
+|------|----------|-----------|
+<!-- INSTRUCTION: Add decisions HERE, in the SAME response as the work that
+     produced them. Never defer to end of session. If the session is interrupted,
+     the decision survives. Format: date, what was decided, why. -->
+
+## Blockers
+
+<!-- INSTRUCTION: List anything preventing progress. Remove when resolved. -->
+
+None currently.
+
+## Open questions
+
+<!-- INSTRUCTION: When the agent encounters uncertainty, it writes a numbered
+     question here. When resolved, don't delete — add the resolution inline.
+     This preserves reasoning history. -->
+
+1. {Open question — describe what's uncertain and why it matters}
+
+## Variant log
+
+<!-- INSTRUCTION: Optional. Track experiment variants if your project involves
+     A/B testing, prompt variants, or configuration comparison. Delete if unused. -->
+
+| Run | Scenario | Variant | Avg Score | Notes |
+|-----|----------|---------|-----------|-------|
+| -- | -- | -- | -- | No runs executed yet |

package/templates/full/SUMMARY.md

@@ -0,0 +1,24 @@
+# Summary
+
+<!-- INSTRUCTION: This is the execution history — the audit trail.
+     Append a new entry at the END of this file after each task or session.
+     Never edit previous entries. The "Next" field bridges to the following session. -->
+
+<!-- INSTRUCTION: Use this format for each entry:
+
+## {Date} — {Brief title}
+
+**Plan**: {What was planned for this session}
+**Outcome**: {What was actually accomplished}
+
+**Files created**:
+- {path/to/new-file.md}
+
+**Files updated**:
+- {path/to/updated-file.md} — {what changed}
+
+**Key decisions**:
+- {Decision and rationale — should match what's in STATE.md}
+
+**Next**: {What should happen in the following session — this is the bridge}
+-->

package/templates/full/docs/index.md

@@ -0,0 +1,46 @@
+# {Project Name} — Documentation
+
+<!-- INSTRUCTION: This is the human-facing project dashboard.
+     It provides a high-level view of the project for non-agent audiences
+     (managers, reviewers, teammates). Keep it visual and navigable. -->
+
+## Project overview
+
+<!-- INSTRUCTION: Brief description of what the project does and its current state.
+     Link to PROJECT.md for the full vision. -->
+
+See [PROJECT.md](../PROJECT.md) for the full project vision and scope.
+
+## Current status
+
+<!-- INSTRUCTION: Update this when phases complete. Show progress at a glance. -->
+
+| Phase | Status | Gate |
+|-------|--------|------|
+| Phase 1 — {name} | {pending/in-progress/done} | {PASSED / not yet} |
+| Phase 2 — {name} | {pending} | {not yet} |
+
+## Architecture
+
+<!-- INSTRUCTION: High-level architecture description for human readers.
+     Diagrams, component descriptions, key design decisions. -->
+
+{Describe or diagram your project architecture}
+
+## Key decisions
+
+<!-- INSTRUCTION: Surface important decisions from STATE.md in a human-readable format.
+     Not every decision — just the ones that affect the project's direction. -->
+
+| Decision | Rationale | Date |
+|----------|-----------|------|
+| {Important decision} | {Why} | {When} |
+
+## Navigation
+
+<!-- INSTRUCTION: Add links to other docs as you create them. -->
+
+| Document | What it covers |
+|----------|---------------|
+| [PROJECT.md](../PROJECT.md) | Project vision and scope |
+| [ROADMAP.md](../ROADMAP.md) | Phase breakdown and progress |

package/templates/full/todos/backlog.md

@@ -0,0 +1,19 @@
+# Backlog
+
+<!-- INSTRUCTION: Capture ideas and future work here as they arise during sessions.
+     This prevents scope creep while ensuring good ideas aren't lost.
+     Mark items [x] when they're completed or moved into the active plan. -->
+
+Ideas and future work captured during development.
+
+## {Category 1}
+
+<!-- INSTRUCTION: Group related items under descriptive headings.
+     Add new categories as different domains of future work emerge. -->
+
+- [ ] {Idea or future task description}
+- [ ] {Another idea}
+
+## {Category 2}
+
+- [ ] {Idea or future task description}

package/templates/starter/.context/BASE.md

@@ -0,0 +1,66 @@
+# Base Context — Always Loaded
+
+<!-- INSTRUCTION: This file is loaded EVERY session alongside the entry point.
+     Keep it under 100 lines. It gives the agent persistent understanding of
+     your project's architecture and structure. -->
+
+## What this system is
+
+<!-- INSTRUCTION: 2-3 sentences describing your project's architecture.
+     What does it do? What are the main components? What technologies? -->
+
+{Describe your project architecture here}
+
+## System model
+
+<!-- INSTRUCTION: How do the project's components relate to each other?
+     A simple flow or diagram description. For code projects, describe
+     the data/control flow. -->
+
+{component A} --> {component B} --> {component C}
+
+## Codebase map
+
+<!-- INSTRUCTION: Table of directories, their purposes, and key patterns.
+     The agent uses this to navigate without re-exploring every session.
+     For existing codebases, ask the agent: "Scan the codebase and populate this map" -->
+
+| Path | Purpose | Key patterns |
+|------|---------|-------------|
+| {src/} | {Source code} | {language, framework} |
+| {tests/} | {Test suite} | {testing framework} |
+
+## Dependencies
+
+<!-- INSTRUCTION: Key external dependencies and their roles.
+     Not an exhaustive list — just the ones that affect architecture decisions. -->
+
+| Dependency | Role |
+|------------|------|
+| {framework} | {What it provides} |
+
+## Pairing protocol
+
+<!-- INSTRUCTION: Maps task types to specialist context files.
+     Add rows as you create specialist .context/ files.
+     Each query type should pair BASE.md with exactly ONE specialist. -->
+
+| Task type | Pair BASE.md with |
+|-----------|-------------------|
+| {domain-work-type} | .context/{SPECIALIST}.md |
+
+<!-- INSTRUCTION: To create a specialist file, identify a recurring domain area
+     in your project that needs its own deep context. Keep each specialist
+     under 150 lines. The agent can help create them during context refresh. -->
+
+## Navigation
+
+<!-- INSTRUCTION: Quick reference to key project files and their roles. -->
+
+| File | Purpose |
+|------|---------|
+| {AGENT.md / CLAUDE.md} | Agent entry point — scoping, cascade |
+| STATE.md | Current position and decisions |
+| PLAN.md | Current atomic task |
+| ROADMAP.md | Phase breakdown and progress |
+| PROJECT.md | Project vision and structure |

package/templates/starter/.context/METHODOLOGY.md

@@ -0,0 +1,70 @@
+# Methodology Reference
+
+Pair with: entry point (CLAUDE.md / .cursorrules / AGENT.md)
+Use when: agent needs operational guidance beyond entry point rules
+
+This file contains methodology operational details that overflow from the entry point. For lite and standard integration profiles, the entry point stays lean — this file provides depth when needed.
+
+## Workflows
+
+Select based on query type:
+- **General task** — Review, Plan, Implement, Document, Update
+- **Code change** — Review, Plan, Implement, Context-sync, Update
+- **Context refresh** — Scan, Compare, Update-context, Cascade, Record
+- **First session** — Detect, Initialize, Map, Pair, Ready
+- **Discovery (brownfield)** — Inventory, Map-dependencies, Extract-patterns, Assess, Bootstrap
+
+## Interaction level
+
+The entry point's `mode` setting controls checkpoint density:
+
+| Level | Behavior |
+|-------|----------|
+| autonomous | Execute full plan, report at completion |
+| checkpoint | Propose plan, wait for approval, report at completion (default) |
+| collaborative | Back-and-forth at each step |
+| supervised | Explain intent before every file change |
+
+## Extended conventions
+
+These conventions supplement the core set in the entry point:
+- Every code change is also a context change — update the codebase map
+- Keep intelligence layer files under 300 lines — split into index + components subdirectory when exceeded
+- SUMMARY.md entries follow audit trail format: date, plan, outcome, files, decisions, next
+
+## Safety invariants
+
+These rules are absolute — they hold regardless of profile, project type, or lifecycle stage:
+
+- **Never modify project source code** through methodology operations — only create/modify methodology files (STATE.md, .context/, PLAN.md, etc.)
+- **Never delete existing project files** — methodology integration is purely additive
+- **Never overwrite existing entry point content** — only append methodology sections
+
+## Do-not rules
+
+- Load files not in the scoping table's 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
+- Update docs/ for typo fixes or internal-only changes
+
+## File scale management
+
+When any intelligence layer file exceeds 300 lines (~3,750 tokens):
+1. Split into index file (original path) + components subdirectory
+2. Index keeps active content + navigation table
+3. Components hold archived sections grouped by semantic boundary
+4. Update .context/REGISTRY.md (if it exists) with new file entries
+
+## Audit trail format
+
+SUMMARY.md session entries follow this structure:
+```
+### {date} — {brief description}
+**Plan**: {what was planned}
+**Outcome**: {what was done}
+**Files created**: {list}
+**Files updated**: {list}
+**Decisions**: {key decisions made}
+**Next**: {what should happen next session}
+```

package/templates/starter/.cursorrules

@@ -0,0 +1,113 @@
+# {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. Check `PROJECT-PROFILE.md` for lifecycle stage and active extensions
+4. Scope based on query type (see table below)
+
+## Scoping rules
+
+| Query type | Read before acting | Update after acting |
+|------------|-------------------|-------------------|
+| **Planning / roadmap** | REQUIREMENTS.md, ROADMAP.md | STATE.md, PLAN.md |
+| **Context refresh** | .context/ (all), project structure | .context/, this file (if scoping rules affected) |
+| **Project discovery** | Project structure, package files, key source files | .context/BASE.md, .context/ specialists, STATE.md |
+| **{your-domain-type}** | .context/BASE.md + .context/{SPECIALIST}.md | {affected working files} |
+| **Methodology guidance** | .context/METHODOLOGY.md | -- |
+| **Phase completion** | SUMMARY.md | SUMMARY.md, STATE.md, ROADMAP.md |
+| **Backlog / ideas** | todos/backlog.md | todos/backlog.md |
+
+<!-- INSTRUCTION: Replace the {your-domain-type} row with project-specific query types.
+     Each should pair .context/BASE.md with one specialist. Add as many rows as needed. -->
+
+## Dependency cascade
+
+When a file changes, check this table and update dependent files in the same response.
+
+| When this changes | Also update |
+|------------------|-------------|
+| Phase completion | SUMMARY.md (add entry), STATE.md (update position), ROADMAP.md (mark done) |
+| Requirements change | REQUIREMENTS.md, ROADMAP.md, PLAN.md (if current task affected) |
+| New decision made | STATE.md (decisions table — record immediately, never defer) |
+| Open question resolved | STATE.md (mark resolved with resolution text, don't delete) |
+| Project structure | .context/BASE.md (codebase map), this file (if new query types needed) |
+| Intelligence layer file exceeds 300 lines | Restructure into index + components subdirectory (keep active content, archive completed sections) |
+| New domain area | .context/BASE.md, consider new .context/ specialist, this file (if new scoping row) |
+| Lifecycle stage change | PROJECT-PROFILE.md (update stage + date), STATE.md (record decision) |
+| Session close | SESSION-LOG.md (append micro-entry — workflow, features, cascades, friction, findings) |
+
+<!-- INSTRUCTION: Add project-specific cascade rules below the universal ones above. -->
+
+## Workflow
+
+Select based on query type:
+- **General task** — Review, Plan, Implement, Document, Update
+- **Code change** — Review, Plan, Implement, Context-sync, Update
+- **Context refresh** — Scan, Compare, Update-context, Cascade, Record
+- **First session** — Detect, Initialize, Map, Pair, Ready
+- **Discovery (brownfield)** — Inventory, Map-dependencies, Extract-patterns, Assess, Bootstrap
+
+## Interaction level
+
+mode: checkpoint
+<!-- autonomous | checkpoint | collaborative | supervised -->
+<!-- checkpoint: propose plan, wait for approval, report at completion (default) -->
+
+## Model tier
+
+tier: standard
+<!-- lite | standard | full -->
+<!-- lite: minimal rules, STATE.md only, 2 cascade rules — for Haiku or simple projects -->
+<!-- standard: core rules + context pairing, overflow to .context/METHODOLOGY.md — for Sonnet (default) -->
+<!-- full: all rules in entry point, all intelligence layer files — for Opus or complex projects -->
+
+## Method version
+
+method_version: 1.5
+<!-- Tracks which methodology version generated this entry point -->
+<!-- Use `agent-method status` to compare against latest -->
+
+## CLI tools (optional)
+
+Available via `npx agent-method` (zero-install) or `pip install agent-method-tools`:
+
+| When you want to... | Run |
+|---------------------|-----|
+| Validate this entry point | `agent-method check` |
+| See what type of project this is | `agent-method scan` |
+| Test how a query routes | `agent-method route "your question"` |
+| Extract a refinement report | `agent-method refine` |
+| Check methodology version | `agent-method status` |
+| Update methodology files | `agent-method upgrade` |
+| See what an entry point should contain | `agent-method init code` / `context` / `data` / `mix` |
+
+<!-- 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. -->
+
+## Conventions
+
+- Record decisions in STATE.md in the SAME response as the work — never defer
+- Load .context/BASE.md + one specialist per query — never all context files
+- After every file change, check the cascade table — deferred cascades don't happen
+- Every code change is also a context change — update the codebase map
+- Surface uncertainty as open questions in STATE.md — never guess silently
+- Keep intelligence layer files under 300 lines — split into index + components subdirectory when exceeded
+- Propose plans and wait for approval — the human controls direction
+- At session close, append a micro-entry to SESSION-LOG.md — never skip, never read previous entries during normal work
+
+## 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 the scoping table's 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
+
+<!-- INSTRUCTION: Add project-specific "do not" rules as you discover common mistakes -->

package/templates/starter/AGENT.md

@@ -0,0 +1,113 @@
+# {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. Check `PROJECT-PROFILE.md` for lifecycle stage and active extensions
+4. Scope based on query type (see table below)
+
+## Scoping rules
+
+| Query type | Read before acting | Update after acting |
+|------------|-------------------|-------------------|
+| **Planning / roadmap** | REQUIREMENTS.md, ROADMAP.md | STATE.md, PLAN.md |
+| **Context refresh** | .context/ (all), project structure | .context/, this file (if scoping rules affected) |
+| **Project discovery** | Project structure, package files, key source files | .context/BASE.md, .context/ specialists, STATE.md |
+| **{your-domain-type}** | .context/BASE.md + .context/{SPECIALIST}.md | {affected working files} |
+| **Methodology guidance** | .context/METHODOLOGY.md | -- |
+| **Phase completion** | SUMMARY.md | SUMMARY.md, STATE.md, ROADMAP.md |
+| **Backlog / ideas** | todos/backlog.md | todos/backlog.md |
+
+<!-- INSTRUCTION: Replace the {your-domain-type} row with project-specific query types.
+     Each should pair .context/BASE.md with one specialist. Add as many rows as needed. -->
+
+## Dependency cascade
+
+When a file changes, check this table and update dependent files in the same response.
+
+| When this changes | Also update |
+|------------------|-------------|
+| Phase completion | SUMMARY.md (add entry), STATE.md (update position), ROADMAP.md (mark done) |
+| Requirements change | REQUIREMENTS.md, ROADMAP.md, PLAN.md (if current task affected) |
+| New decision made | STATE.md (decisions table — record immediately, never defer) |
+| Open question resolved | STATE.md (mark resolved with resolution text, don't delete) |
+| Project structure | .context/BASE.md (codebase map), this file (if new query types needed) |
+| Intelligence layer file exceeds 300 lines | Restructure into index + components subdirectory (keep active content, archive completed sections) |
+| New domain area | .context/BASE.md, consider new .context/ specialist, this file (if new scoping row) |
+| Lifecycle stage change | PROJECT-PROFILE.md (update stage + date), STATE.md (record decision) |
+| Session close | SESSION-LOG.md (append micro-entry — workflow, features, cascades, friction, findings) |
+
+<!-- INSTRUCTION: Add project-specific cascade rules below the universal ones above. -->
+
+## Workflow
+
+Select based on query type:
+- **General task** — Review, Plan, Implement, Document, Update
+- **Code change** — Review, Plan, Implement, Context-sync, Update
+- **Context refresh** — Scan, Compare, Update-context, Cascade, Record
+- **First session** — Detect, Initialize, Map, Pair, Ready
+- **Discovery (brownfield)** — Inventory, Map-dependencies, Extract-patterns, Assess, Bootstrap
+
+## Interaction level
+
+mode: checkpoint
+<!-- autonomous | checkpoint | collaborative | supervised -->
+<!-- checkpoint: propose plan, wait for approval, report at completion (default) -->
+
+## Model tier
+
+tier: standard
+<!-- lite | standard | full -->
+<!-- lite: minimal rules, STATE.md only, 2 cascade rules — for Haiku or simple projects -->
+<!-- standard: core rules + context pairing, overflow to .context/METHODOLOGY.md — for Sonnet (default) -->
+<!-- full: all rules in entry point, all intelligence layer files — for Opus or complex projects -->
+
+## Method version
+
+method_version: 1.5
+<!-- Tracks which methodology version generated this entry point -->
+<!-- Use `agent-method status` to compare against latest -->
+
+## CLI tools (optional)
+
+Available via `npx agent-method` (zero-install) or `pip install agent-method-tools`:
+
+| When you want to... | Run |
+|---------------------|-----|
+| Validate this entry point | `agent-method check` |
+| See what type of project this is | `agent-method scan` |
+| Test how a query routes | `agent-method route "your question"` |
+| Extract a refinement report | `agent-method refine` |
+| Check methodology version | `agent-method status` |
+| Update methodology files | `agent-method upgrade` |
+| See what an entry point should contain | `agent-method init code` / `context` / `data` / `mix` |
+
+<!-- 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. -->
+
+## Conventions
+
+- Record decisions in STATE.md in the SAME response as the work — never defer
+- Load .context/BASE.md + one specialist per query — never all context files
+- After every file change, check the cascade table — deferred cascades don't happen
+- Every code change is also a context change — update the codebase map
+- Surface uncertainty as open questions in STATE.md — never guess silently
+- Keep intelligence layer files under 300 lines — split into index + components subdirectory when exceeded
+- Propose plans and wait for approval — the human controls direction
+- At session close, append a micro-entry to SESSION-LOG.md — never skip, never read previous entries during normal work
+
+## 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 the scoping table's 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
+
+<!-- INSTRUCTION: Add project-specific "do not" rules as you discover common mistakes -->