agent-method 1.5.12

package/templates/starter/Management/DIGEST.md

@@ -0,0 +1,23 @@
+# Management Digest
+
+<!-- AGENT: Append a row for every HIGH-EFFORT task only.
+     This is the primary management-facing project record — managers and leads
+     read this to understand what significant work happened, without parsing
+     detailed session logs or operational files.
+
+     Low-effort tasks (lookups, status checks, clarifications) are NOT recorded here.
+     See SESSION-LOG.md for complete session data. -->
+
+## What qualifies as high-effort
+
+- Multi-file changes (3+ files)
+- Architectural or design decisions
+- Phase completions
+- Complex queries requiring research or multi-step execution
+- New feature implementations
+
+## Digest
+
+| Date | Task | Query | Outcome | Key Changes | Decisions | Effort | Time |
+|------|------|-------|---------|-------------|-----------|--------|------|
+<!-- Rows added automatically by agent for high-effort tasks -->

package/templates/starter/Management/STATUS.md

@@ -0,0 +1,46 @@
+# Project Status
+
+<!-- AGENT: Update this file after significant milestones (phase completions,
+     architectural decisions, blocker changes). This is the management-facing
+     health snapshot — read by leads to understand project state at a glance.
+
+     Do NOT update for routine work. Only update when the project's overall
+     status, direction, or risk profile changes. -->
+
+## Current state
+
+| Field | Value |
+|-------|-------|
+| Phase | {current phase} |
+| Status | {active / blocked / complete} |
+| Active work | {brief description of current task} |
+| Last milestone | {most recent completed phase or significant deliverable} |
+| Next milestone | {what's coming next} |
+
+## Recent decisions
+
+<!-- AGENT: Keep the 5 most recent significant decisions here.
+     Full decision history lives in STATE.md. -->
+
+| Date | Decision | Impact |
+|------|----------|--------|
+<!-- Last 5 significant decisions -->
+
+## Blockers & risks
+
+<!-- AGENT: List active blockers and known risks. Remove when resolved. -->
+
+| Type | Description | Since | Severity |
+|------|-------------|-------|----------|
+<!-- {blocker/risk} | {description} | {date} | {high/medium/low} -->
+
+## Health indicators
+
+<!-- AGENT: Update these after each high-effort task or milestone. -->
+
+| Indicator | Status | Notes |
+|-----------|--------|-------|
+| Scope | {stable / expanding / contracting} | {brief note} |
+| Velocity | {steady / accelerating / slowing} | {brief note} |
+| Technical debt | {low / medium / high} | {brief note} |
+| Context freshness | {current / slightly stale / stale} | {last refresh date} |

package/templates/starter/PLAN.md

@@ -0,0 +1,67 @@
+# Current Plan
+
+<!-- INSTRUCTION: This file contains ONE task at a time. Replace the entire
+     contents when starting a new task — never accumulate multiple plans.
+     The agent proposes the plan and waits for human approval before executing. -->
+
+## {Task name}
+
+### Objective
+
+{What this task achieves. One clear sentence.}
+
+### Prerequisites
+
+<!-- INSTRUCTION: What must be true before starting this task? -->
+
+- {Prior phase or task complete}
+- {Required files or context available}
+
+### Dependencies
+
+<!-- INSTRUCTION: What depends on this task? What does this task block? -->
+
+- {Phase/task that depends on this completing}
+
+---
+
+### Step 1: {Step name}
+
+**Objective**: {What this step achieves}
+
+**Read**: {Files to read before this step}
+**Produce**: {Files created or modified by this step}
+
+**Substeps**:
+- a. {First substep}
+- b. {Second substep}
+
+**Verify**: {How to confirm this step is complete and correct}
+
+---
+
+### Step 2: {Step name}
+
+**Objective**: {What this step achieves}
+
+**Read**: {Files to read}
+**Produce**: {Files created or modified}
+
+**Verify**: {Verification criteria}
+
+---
+
+<!-- INSTRUCTION: Add more steps as needed. Each step should have:
+     - Clear objective
+     - Read/produce specs (what files are involved)
+     - Substeps (if complex)
+     - Verification criteria (how to confirm it's done right) -->
+
+### Completion criteria
+
+{Task name} is done when:
+1. {Criterion 1 — specific and measurable}
+2. {Criterion 2}
+3. {Criterion 3}
+
+**Next after {task name}**: {What comes next}

package/templates/starter/PROJECT-PROFILE.md

@@ -0,0 +1,44 @@
+# Project Profile
+
+<!-- INSTRUCTION: This file is maintained by the agent. It tracks your project's
+     type, lifecycle stage, and active extensions. The agent reads this to adjust
+     feature priorities and workflow selection. You can also update it manually
+     when your project's situation changes.
+
+     Fill in the initial values during setup. The agent updates lifecycle stage
+     and maturity as the project evolves. -->
+
+## Project identity
+
+- **Types**: [{project-type}]
+- **Extensions**: [{extensions-applied}]
+
+<!-- INSTRUCTION: Project types: code, data, analytical, mixed, general.
+     Extensions: code-project, data-exploration, analytical-system, or none. -->
+
+## Lifecycle
+
+- **Stage**: {stage}
+- **Maturity**: {maturity}
+- **Last transition**: {date} ({from} -> {to})
+
+<!-- INSTRUCTION: Lifecycle stages:
+     - discovery: Understanding an existing project (brownfield entry)
+     - design: Defining architecture and structure (greenfield start)
+     - development: Building and iterating (active implementation)
+     - evolution: Maintaining and extending (stable baseline)
+
+     Maturity levels: new, early, established, legacy.
+     The agent suggests transitions; you decide when to move. -->
+
+## Extension stack
+
+| Extension | Applied | Source |
+|-----------|---------|--------|
+| code-project | {yes/no} | {setup.sh / manual} |
+| data-exploration | {yes/no} | {setup.sh / manual} |
+| analytical-system | {yes/no} | {setup.sh / manual} |
+
+<!-- INSTRUCTION: Track which extensions are active. Extensions can be added
+     mid-project without re-running setup.sh — merge the extension file
+     into your entry point manually and update this table. -->

package/templates/starter/PROJECT.md

@@ -0,0 +1,80 @@
+# {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}
+
+## Agent onboarding
+
+<!-- AGENT: Use these questions to populate this file during the first session.
+     Ask the user each question, draft this file from the answers, and show the
+     draft at the Stage 1 checkpoint before writing. Remove this section after
+     the file is populated — it's scaffolding, not permanent content. -->
+
+### Greenfield (no existing codebase)
+
+Ask the user:
+1. What is your project about? (1-2 sentences for the description above)
+2. Who is it for? (populate the Audiences table)
+3. What problem does it solve? (populate the Problem section)
+4. What technologies, languages, or frameworks will you use? (informs Solution + structure)
+5. What are 2-3 guiding principles for this project? (populate Principles)
+6. What is the top-level directory structure? (populate Project structure table)
+
+### Brownfield (existing codebase)
+
+<!-- AGENT: For brownfield projects, you've already scanned the project at Stage 1.
+     Pre-fill as much as possible from scan results. Only ask what you couldn't determine. -->
+
+Pre-fill from scan:
+- **Description**: infer from README, package.json description, or top-level docs
+- **Project structure**: build from directory listing — auto-populate the table
+- **Technologies**: extract from package.json, requirements.txt, config files, imports
+
+Ask the user only what the scan couldn't determine:
+1. Is this description accurate? (confirm or correct the auto-generated description)
+2. Who is the primary audience? (rarely inferable from code alone)
+3. What problem does this solve from the user's perspective? (intent, not implementation)
+4. What guiding principles drive decisions on this project? (conventions, priorities)
+5. Are there directories I should know about that aren't obvious from the structure? (hidden patterns, legacy areas)

package/templates/starter/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/starter/Reviews/INDEX.md

@@ -0,0 +1,75 @@
+# Project Reviews
+
+<!-- AGENT: This is the review dashboard — a synthesized view of project intelligence.
+     Update sections when the corresponding source file changes significantly.
+
+     Source files: ROADMAP.md, PLAN.md, STATE.md, todos/backlog.md
+     When this file exceeds 300 lines, split sections into individual files
+     in this directory (roadmap.md, plan.md, state.md, backlog.md). -->
+
+## At a glance
+
+| Area | Status | Last updated |
+|------|--------|-------------|
+| Roadmap | {on track / behind / ahead} | {date} |
+| Plan | {active / blocked / between tasks} | {date} |
+| State | {N decisions, N blockers, N open questions} | {date} |
+| Backlog | {N items} | {date} |
+
+## Roadmap review
+
+<!-- AGENT: Synthesize from ROADMAP.md. Phase progress, milestone tracking. -->
+
+### Phase progress
+
+| Phase | Status | Completion |
+|-------|--------|------------|
+<!-- Populate from ROADMAP.md -->
+
+### Velocity notes
+
+<!-- Brief observations about project velocity and trajectory. -->
+
+## Plan review
+
+<!-- AGENT: Synthesize from PLAN.md. Current task status, execution patterns. -->
+
+### Current task
+
+<!-- What's being worked on, how it's progressing. -->
+
+### Execution patterns
+
+<!-- Observations about plan execution — revision patterns, task sizing accuracy. -->
+
+## State review
+
+<!-- AGENT: Synthesize from STATE.md. Decision trends, blocker aging, question resolution. -->
+
+### Decision summary
+
+- **Total decisions**: {count}
+- **Recent decisions** (last 5):
+
+<!-- List last 5 decisions from STATE.md -->
+
+### Blocker status
+
+<!-- Active blockers, how long they've been open, resolution progress. -->
+
+### Open questions
+
+<!-- Active open questions, aging analysis, resolution rate. -->
+
+## Backlog review
+
+<!-- AGENT: Synthesize from todos/backlog.md. Item counts, categories, aging. -->
+
+### Summary
+
+- **Total items**: {count}
+- **Categories**: {list with counts}
+
+### Aging
+
+<!-- How old are backlog items? Any that need attention? -->

package/templates/starter/SESSION-LOG.md

@@ -0,0 +1,102 @@
+# Session Log
+
+Append-only session observation log for case study data collection. Each session adds a metrics entry at close. High-effort tasks log immediately at task completion. This file is read-only during extraction (never during normal work).
+
+<!-- AGENT INSTRUCTION: At the end of every session — or immediately after any high-effort task —
+     append a new entry below using the format in "Entry 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} |
+
+## Effort classification
+
+| Effort | Description | When to log |
+|--------|-------------|-------------|
+| **low** | Quick answer, single file or no changes, <5 min | At session close |
+| **medium** | Multi-step work, several file changes, 5-30 min | At session close |
+| **high** | Complex multi-file changes, architecture decisions, extensive debugging, 30+ min | Immediately at task completion |
+
+## Assessment scales
+
+**Ambiguity** (agent-assessed — how clear was the user's request?):
+- **low**: Clear, specific request with sufficient context
+- **medium**: Request understood but required interpretation or assumptions
+- **high**: Vague or ambiguous, required significant clarification
+
+**Context level** (agent-assessed — how much project context was loaded?):
+- **very low**: No project files loaded, answered from general knowledge
+- **low**: Entry point only
+- **medium**: Entry point + STATE.md + 1-2 project files
+- **high**: Entry point + STATE.md + specialist context + multiple project files
+- **very high**: Extensive project context, multiple specialists, cross-file analysis
+
+**User response** (agent-observed — how did the user respond to the result?):
+- **accepted**: User proceeded to next step without changes
+- **edited**: User manually modified the agent's output
+- **revised**: User asked agent to redo or revise the result
+- **rejected**: User said no or declined the result entirely
+- **redirected**: User changed approach or gave new instructions
+
+**Refinement magnitude** (for medium/high effort only — how much changed from first attempt to final?):
+- **none**: Accepted as-is, 0% changed
+- **minor**: Small fixes — typos, naming, formatting (<10% changed)
+- **moderate**: Logic or structural changes, added/removed sections (10–50% changed)
+- **major**: Significant rework of approach or content (50–80% changed)
+- **rework**: Mostly rewritten, original approach abandoned (>80% changed)
+
+**Delta categories** (what kinds of changes were needed — select all that apply):
+- **accuracy**: Factual errors or incorrect implementation
+- **completeness**: Missing parts, incomplete coverage
+- **approach**: Wrong method or strategy
+- **scope**: Over-scoped or under-scoped
+- **style**: Formatting, naming, conventions
+
+## Observation checklist
+
+At session close (or high-effort task completion), reflect on these before writing the 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)
+8. How much effort did this task require? (low / medium / high)
+9. How ambiguous was the user's request? (low / medium / high)
+10. How much project context was loaded? (very low / low / medium / high / very high)
+11. LLM token usage (input + output), tool call count, and wall time?
+12. How did the user respond to the result? (accepted / edited / revised / rejected / redirected)
+13. For medium/high effort: how many revision cycles before acceptance?
+14. What magnitude of change between first attempt and final result? (none / minor / moderate / major / rework)
+15. What categories of refinement were needed? (accuracy / completeness / approach / scope / style)
+
+## Entry format
+
+<!-- Append new entries below. Format: -->
+<!--
+### S{N} — {YYYY-MM-DD} — {brief title}
+Model: {model} | Profile: {profile} | Workflow: {WF-XX}
+Effort: {low / medium / high} | Ambiguity: {low / medium / high} | Context: {very low / low / medium / high / very high}
+LLM tokens: ~{N}k ({N} input + {N} output) | Tool calls: {N} | Wall time: ~{N} min
+Queries: {query types encountered}
+Features: {feature IDs activated}
+Cascades: {triggered}/{expected} | Decisions: {count}
+Response: {accepted / edited / revised / rejected / redirected}
+Revisions: {0 | count of revision cycles} | Magnitude: {none / minor / moderate / major / rework}
+Delta: {n/a | categories: accuracy, completeness, approach, scope, style} | Survival: ~{N}%
+Delta notes: {n/a | brief description of what changed between first attempt and final}
+Friction: {none | brief description}
+Finding: {none | observation with methodology implication}
+-->
+
+## Session entries

package/templates/starter/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/starter/SUMMARY.md

@@ -0,0 +1,27 @@
+# Summary
+
+<!-- AGENT: This file is the session audit trail — a chronological record of work done.
+     The management digest has moved to Management/DIGEST.md.
+     Append an entry after each session or significant task using the format below.
+     Never edit previous entries. -->
+
+## Session audit trail
+
+<!-- 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/starter/agentWorkflows/INDEX.md

@@ -0,0 +1,61 @@
+# Agent Workflows
+
+<!-- AGENT: This file tracks how the methodology performs in practice.
+     Update after high-effort sessions by reviewing SESSION-LOG.md patterns.
+
+     Source: SESSION-LOG.md entries, agent self-observation during sessions.
+     When this file exceeds 300 lines, split sections into individual files
+     in this directory (sessions.md, patterns.md, observations.md). -->
+
+## Workflow summary
+
+| Workflow | Times used | Last used | Typical effort |
+|----------|-----------|-----------|---------------|
+<!-- Populate from SESSION-LOG.md workflow field -->
+
+## Session patterns
+
+<!-- AGENT: Synthesize from SESSION-LOG.md. Look for patterns across sessions. -->
+
+### Effort distribution
+
+| Effort level | Count | Percentage |
+|-------------|-------|------------|
+| Low | {N} | {%} |
+| Medium | {N} | {%} |
+| High | {N} | {%} |
+
+### Common query types
+
+<!-- Which query types appear most often? -->
+
+### Acceptance rates
+
+<!-- How often is agent output accepted vs. revised? -->
+
+- **Accepted**: {count} ({%})
+- **Edited**: {count} ({%})
+- **Revised**: {count} ({%})
+- **Rejected**: {count} ({%})
+- **Redirected**: {count} ({%})
+
+## Behavioral patterns
+
+<!-- AGENT: Record patterns observed across sessions. What works well, what causes friction. -->
+
+### What works
+
+<!-- Patterns that consistently lead to accepted results. -->
+
+### Friction points
+
+<!-- Recurring issues, methodology rules that cause difficulty. -->
+
+## Observations
+
+<!-- AGENT: Record methodology observations — findings with implications for
+     how the methodology could be improved or adapted for this project. -->
+
+| Date | Observation | Implication | Severity |
+|------|-------------|-------------|----------|
+<!-- Append observations as they arise -->

package/templates/starter/intro/README.md

@@ -0,0 +1,37 @@
+# Methodology Overview
+
+This project uses the **wwa** (Working With Agents) methodology for AI-agent-assisted development. The methodology gives your AI agent persistent memory, structured workflows, and scoped context loading across sessions.
+
+## How it works
+
+Your agent reads an entry point file (CLAUDE.md, .cursorrules, or AGENT.md) at the start of every session. That file tells the agent:
+
+- **What to read** — scoping rules match your question to the right files
+- **What to update** — cascade rules keep dependent files in sync
+- **How to work** — workflows guide the agent through structured steps
+
+Key files the agent manages:
+
+| File | Purpose |
+|------|---------|
+| STATE.md | Decisions, blockers, current position (cross-session memory) |
+| PLAN.md | Current task with verification criteria |
+| ROADMAP.md | Phase breakdown with gate criteria |
+| .context/BASE.md | Core project context — architecture, codebase map |
+| .context/DOCS-MAP.md | Maps your project components to their documentation |
+
+## Your project's docs/
+
+The `docs/` folder is reserved for **your project's documentation** — API references, architecture guides, setup instructions, etc. It is not created at setup time. Instead, the agent proposes new docs/ files as your project grows, based on scaffolding rules in `.context/DOCS-MAP.md`.
+
+## Full documentation
+
+For the complete methodology guide, templates reference, and architecture docs:
+
+**https://github.com/anthropics/agent-method**
+
+Key pages:
+- [Quick Start](https://github.com/anthropics/agent-method/blob/main/docs/guides/quick-start.md)
+- [For Developers](https://github.com/anthropics/agent-method/blob/main/docs/guides/for-developers.md)
+- [File Roles](https://github.com/anthropics/agent-method/blob/main/docs/architecture/file-roles.md)
+- [CLI Tools](https://github.com/anthropics/agent-method/blob/main/docs/guides/for-developers/cli-tools.md)

package/templates/starter/registry/feature-registry.yaml

@@ -0,0 +1,25 @@
+# Feature Registry — Index
+# Split into registry/features/. Tools reassemble on load.
+# CLI: wwa route, wwa check, wwa scan, wwa init
+#
+# Four layers:
+#   1. Feature catalog — WHAT each capability is
+#   2. Guided workflows — HOW features compose into task patterns
+#   3. Agent protocol — WHY the agent does what it does
+#   4. Routing rules — HOW queries map to features automatically
+
+version: v1.6
+
+layers:
+  - id: catalog
+    file: features/catalog.yaml
+    description: "Domains + features — WHAT each capability is"
+  - id: workflows
+    file: features/workflows.yaml
+    description: "Guided workflows — HOW features compose into task patterns"
+  - id: protocol
+    file: features/protocol.yaml
+    description: "Agent behavioral protocol — WHY the agent does what it does"
+  - id: routing
+    file: features/routing.yaml
+    description: "Routing rules — HOW queries map to features automatically"