@accelerationguy/accel 1.0.0

package/modules/momentum/src/commands/status.md

@@ -0,0 +1,28 @@
+---
+name: momentum:status
+description: Quick workspace health check
+allowed-tools: [Read, Glob, Bash]
+---
+
+<objective>
+One-liner workspace health status — drift score and area summary.
+
+**When to use:** Quick check, "workspace status", "how's my workspace".
+</objective>
+
+<execution_context>
+@.claude/skills/momentum/tasks/status.md
+</execution_context>
+
+<context>
+@.accel/momentum/workspace.json
+@.accel/momentum/STATE.md
+</context>
+
+<process>
+Follow task: @.claude/skills/momentum/tasks/status.md
+</process>
+
+<success_criteria>
+- [ ] Health status displayed
+</success_criteria>

package/modules/momentum/src/commands/surface-convert.md

@@ -0,0 +1,35 @@
+---
+name: momentum:surface-convert
+description: Convert a markdown file into a data surface
+argument-hint: "<file-path>"
+allowed-tools: [Read, Write, Edit, Glob, Bash, AskUserQuestion]
+---
+
+<objective>
+Convert an existing @-mentioned markdown file into a structured data surface. Analyzes structure, proposes schema, migrates content.
+
+**When to use:** User has a markdown file they want to convert to a structured surface.
+</objective>
+
+<execution_context>
+@.claude/skills/momentum/tasks/surface-convert.md
+@.accel/momentum/hooks/_template.py
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.accel/momentum/workspace.json
+</context>
+
+<process>
+Follow task: @.claude/skills/momentum/tasks/surface-convert.md
+</process>
+
+<success_criteria>
+- [ ] .accel/momentum/data/{name}.json created with migrated items
+- [ ] .accel/momentum/hooks/{name}-hook.py created
+- [ ] workspace.json updated with surface registration
+- [ ] settings.json updated with hook entry
+- [ ] Original markdown file preserved
+</success_criteria>

package/modules/momentum/src/commands/surface-create.md

@@ -0,0 +1,34 @@
+---
+name: momentum:surface-create
+description: Create a new data surface (guided)
+argument-hint: "[surface-name]"
+allowed-tools: [Read, Write, Edit, Glob, Bash, AskUserQuestion]
+---
+
+<objective>
+Create a new data surface through guided conversation. Generates JSON data file, injection hook, workspace.json registration, and settings.json hook entry.
+
+**When to use:** User wants to track something new as a structured data surface.
+</objective>
+
+<execution_context>
+@.claude/skills/momentum/tasks/surface-create.md
+@.accel/momentum/hooks/_template.py
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.accel/momentum/workspace.json
+</context>
+
+<process>
+Follow task: @.claude/skills/momentum/tasks/surface-create.md
+</process>
+
+<success_criteria>
+- [ ] .accel/momentum/data/{name}.json created
+- [ ] .accel/momentum/hooks/{name}-hook.py created
+- [ ] workspace.json updated with surface registration
+- [ ] settings.json updated with hook entry
+</success_criteria>

package/modules/momentum/src/commands/surface-list.md

@@ -0,0 +1,27 @@
+---
+name: momentum:surface-list
+description: Show all registered data surfaces
+allowed-tools: [Read, Bash]
+---
+
+<objective>
+Display all registered data surfaces with item counts and hook status.
+
+**When to use:** User wants to see what surfaces exist.
+</objective>
+
+<execution_context>
+@.claude/skills/momentum/tasks/surface-list.md
+</execution_context>
+
+<context>
+@.accel/momentum/workspace.json
+</context>
+
+<process>
+Follow task: @.claude/skills/momentum/tasks/surface-list.md
+</process>
+
+<success_criteria>
+- [ ] All registered surfaces displayed with counts
+</success_criteria>

package/modules/momentum/src/commands/vector-hygiene.md

@@ -0,0 +1,33 @@
+---
+name: momentum:vector-hygiene
+description: Vector domain maintenance and rule review
+allowed-tools: [Read, Write, Edit, Glob, Grep, Bash, AskUserQuestion]
+---
+
+<objective>
+Vector rule lifecycle management — review staleness, dedup, staging pipeline, domain health.
+
+**When to use:** "vector hygiene", "review vector rules", "clean up vector".
+</objective>
+
+<execution_context>
+@.claude/skills/momentum/tasks/vector-hygiene.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.vector/manifest
+@.accel/momentum/workspace.json
+</context>
+
+<process>
+Follow task: @.claude/skills/momentum/tasks/vector-hygiene.md
+</process>
+
+<success_criteria>
+- [ ] All domains reviewed for staleness
+- [ ] Duplicate/conflicting rules identified
+- [ ] Staging pipeline processed
+- [ ] vector_hygiene.last_run updated in workspace.json
+</success_criteria>

package/modules/momentum/src/framework/context/momentum-principles.md

@@ -0,0 +1,71 @@
+# Momentum Principles
+
+## Core Laws
+
+1. **If it's not current, it's harmful.** Stale context documents feed AI bad information. Maintenance isn't optional.
+2. **Every file earns its place.** If you can't explain why it's here in 5 seconds, it moves or dies.
+3. **Archive > delete.** When in doubt, archive. You can always delete later. You can't un-delete.
+4. **The workspace is the product.** Treat it like production code, not a scratch pad.
+5. **Clean as you go.** The best time to file something correctly is when you create it. The second best time is now.
+6. **Scaffold generates manifest. Manifest drives everything.** One configuration point. No manual bookkeeping.
+7. **Tools register themselves.** Drive projects auto-register with Momentum. No human memory required.
+
+## Drift Score
+
+Drift is the gap between documented state and actual state. Measured in days-overdue across all tracked areas.
+
+- **0** — Everything current. Workspace is clean.
+- **1-7** — Minor drift. Normal during execution sprints. Fix at next groom.
+- **8-14** — Moderate drift. Context documents are likely misleading AI. Groom soon.
+- **15+** — Critical drift. Sessions are operating on stale context. Groom NOW.
+
+## Maintenance Cadence
+
+| What | Default Cadence | Override |
+|------|----------------|---------|
+| ACTIVE.md | Every session or weekly | workspace.json |
+| BACKLOG.md | Weekly groom | workspace.json |
+| Project directory | Monthly | workspace.json |
+| Tools/MCP | Monthly | workspace.json |
+| System layer | Monthly | workspace.json |
+| Full audit | Quarterly or after major shifts | On demand |
+
+## Backlog Rules
+
+Items have time-based properties enforced by grooming:
+
+- **Added** — auto-set when item enters backlog
+- **Review-by** — priority-based: High=7d, Medium=14d, Low=30d
+- **Staleness** — 2x review-by threshold. Auto-archive if reached without action.
+
+During groom: items past review-by surface as "decide or kill." Items past staleness auto-archive with a note.
+
+## Graduation Flow
+
+Backlog items don't sit forever. They graduate to ACTIVE.md when the operator is ready to work on them.
+
+```
+BACKLOG (waiting review)
+  → ACTIVE.md TASKS (standalone, bounded work items)
+  → ACTIVE.md PROJECT (complex work warranting its own project entry)
+  → DONE (closed with outcome + date)
+```
+
+**TASKS vs PROJECTS:** A task is bounded — it has a finish line. "Extract .mcp.json secrets" is a task. "Build the Vector MCP server" might start as a task but could become a project if it grows. The operator decides during groom.
+
+**Graduation is never automatic.** The groom flow asks explicitly: "Ready to work on any backlog items?" The operator decides what graduates and where it lands.
+
+**Items can also move backward:** An ACTIVE task that loses priority can return to backlog. A project that stalls can move to DEFERRED. Nothing is permanent.
+
+## Scaffold Modes
+
+Momentum scaffold operates in two modes:
+
+- **Standard** (`/momentum:scaffold`) — Data layer only. Creates `.accel/momentum/` with workspace.json, STATE.md, ROADMAP.md. Scans and tracks what exists. Framework-agnostic.
+- **Full** (`/momentum:scaffold --full`) — Data layer + operational templates. Creates ACTIVE.md, BACKLOG.md from templates. Offers CLAUDE.md audit. Sets up symlinks. The "batteries included" version for AI builders who want the full system.
+
+Standard mode works for any workspace. Full mode provides Yogi's proven operational structure.
+
+## File Location
+
+Momentum operates strictly out of `.accel/momentum/`. All state files (ACTIVE.md, BACKLOG.md, STATE.md, workspace.json, ROADMAP.md) live in `.accel/momentum/`. Symlinks at workspace root are a **migration tool only** — offered when existing references (CLAUDE.md @mentions, hooks) would break. New installations never need symlinks. `.accel/momentum/` is the canonical location.

package/modules/momentum/src/framework/frameworks/audit-strategies.md

@@ -0,0 +1,53 @@
+# Audit Strategies
+
+Reusable audit strategies that can be applied to any workspace area. The workspace manifest (`workspace.json`) maps areas to strategies. The audit command reads the manifest and applies the appropriate strategy to each area.
+
+## Strategies
+
+### staleness
+**Applies to:** Working memory files (ACTIVE.md, BACKLOG.md, any tracked document)
+**What it does:** Check file modification timestamps against configured thresholds. Flag files past their groom cadence.
+**Config:**
+- `threshold_days` — days after which the file is considered stale
+**Output:** List of stale files with age, recommended action (update or review)
+
+### classify
+**Applies to:** Directories with lifecycle items (projects/, clients/)
+**What it does:** List all items in the directory. For each, present to operator for classification: active, archive, or delete. Check for planning docs, recent activity, git history.
+**Config:**
+- `states` — classification options (default: ["active", "archive", "delete"])
+- `archive_path` — where archived items go (default: `{path}/_archive/`)
+**Output:** Classification decisions, items moved to archive, items deleted
+
+### cross-reference
+**Applies to:** Tools/servers that have a config file mapping (e.g., MCP servers vs .mcp.json)
+**What it does:** Compare directory contents against a configuration file. Identify directories not referenced in config (orphaned) and config entries pointing to missing directories (broken).
+**Config:**
+- `config_file` — path to the configuration file to cross-reference
+**Output:** Orphaned items, broken references, recommendations
+
+### dead-code
+**Applies to:** System directories (hooks, commands, skills)
+**What it does:** Scan for files that appear unused — no references from other files, no recent invocations, no clear purpose. Presents findings for human decision.
+**Config:**
+- `reference_check` — whether to search for references in other files (default: true)
+**Output:** Potentially dead files with evidence, operator decides keep/delete
+
+### pipeline-status
+**Applies to:** Content pipelines, task queues, any workflow with stages
+**What it does:** Check items in each pipeline stage. Flag stuck items (in same stage too long), empty stages, bottlenecks.
+**Config:**
+- `stages` — ordered list of pipeline stages
+- `stuck_threshold_days` — days in one stage before flagging
+**Output:** Pipeline health report, stuck items, stage distribution
+
+## Extending Strategies
+
+Custom strategies can be added for workspace-specific needs. A strategy is defined by:
+1. A name (kebab-case)
+2. What it applies to (description)
+3. What it checks (logic)
+4. What config it needs (parameters)
+5. What it outputs (findings format)
+
+Add custom strategies to this file and reference them in `workspace.json`.

package/modules/momentum/src/framework/frameworks/satellite-registration.md

@@ -0,0 +1,44 @@
+# Satellite Registration Framework
+
+## What Are Satellites
+
+Satellites are projects that live in their own git repos inside the workspace (e.g., `apps/*`). They run their own Claude Code sessions independently. Momentum needs visibility into them without owning them.
+
+## Registration Flow
+
+### Automatic (via Drive init)
+When `/drive:init` runs in a subdirectory:
+1. Check if parent directory has `.accel/momentum/workspace.json`
+2. If yes, write registration entry: project name, path, engine type, state file path, date
+3. Report: "Registered with Momentum workspace: {workspace-name}"
+
+### Automatic (via Momentum scaffold)
+When `/momentum:scaffold` runs:
+1. Scan configured satellite directories (default: `apps/`)
+2. Detect existing `.drive/` directories
+3. Auto-register discovered projects
+4. Report: "Found {N} satellite projects. Registered."
+
+### Automatic (via Momentum groom)
+During groom:
+1. Read registered satellites from workspace.json
+2. Check each path exists (clean up broken registrations)
+3. Scan satellite directories for unregistered projects with `.drive/`
+4. Flag: "Found unregistered project: {name}. Register?"
+
+## Health Checks
+
+During `/momentum:pulse` and `/momentum:groom`, for each satellite:
+1. Read the state file (e.g., `.drive/STATE.md`)
+2. Check last modification date
+3. Extract current phase/milestone if parseable
+4. Report health: active, stale, or unknown
+
+Momentum never modifies satellite state. It only reads and reports. Drive (or whatever engine) manages the project. Momentum manages the workspace those projects live in.
+
+## Deregistration
+
+Satellites are deregistered when:
+- The project directory no longer exists (auto-cleaned during groom)
+- The user explicitly removes it during audit
+- The project is archived (moved to `_archive/` or similar)

package/modules/momentum/src/framework/tasks/audit-claude-md.md

@@ -0,0 +1,68 @@
+<purpose>
+Audit an existing CLAUDE.md and generate a recommended alternative (CLAUDE.accel/momentum.md) that follows Momentum workspace conventions. Never overwrites the user's existing file.
+</purpose>
+
+<user-story>
+As an AI builder setting up Momentum, I want my CLAUDE.md audited against best practices, so that I get a recommended version I can adopt without losing my current config.
+</user-story>
+
+<when-to-use>
+- During /momentum:scaffold (optional step)
+- When user says "audit my claude.md", "improve my claude.md"
+- Entry point routes here via /momentum:audit-claude-md
+</when-to-use>
+
+<steps>
+
+<step name="read_existing" priority="first">
+Read the user's existing CLAUDE.md.
+
+1. Read `CLAUDE.md` from workspace root
+2. If no CLAUDE.md exists, skip audit and generate fresh from template
+3. Parse sections: identify what's covered (identity, structure, conventions, tool config, etc.)
+4. Note what's missing vs Momentum best practices
+</step>
+
+<step name="assess_and_recommend">
+Compare against Momentum workspace conventions.
+
+Check for:
+- [ ] Working memory references (@ACTIVE.md, @BACKLOG.md, @STATE.md)
+- [ ] Workspace structure tree (accurate to actual filesystem?)
+- [ ] Git strategy documentation
+- [ ] Tool priority declarations (LSP, etc.)
+- [ ] Business/identity context (who, what, why)
+- [ ] Vector/Momentum integration references
+- [ ] Key locations table
+- [ ] Documentation system description
+- [ ] Banned words / style preferences
+
+For each missing or outdated section, prepare a recommendation.
+</step>
+
+<step name="generate_alternative">
+Generate CLAUDE.accel/momentum.md as a recommended version.
+
+1. Build a complete CLAUDE.md following Momentum conventions
+2. Preserve all existing content that's still accurate
+3. Add missing sections from Momentum template
+4. Update workspace structure tree to match actual filesystem
+5. Write to `CLAUDE.accel/momentum.md` (NOT CLAUDE.md)
+6. Present diff summary: "Here's what changed vs your current CLAUDE.md"
+
+Tell user: "Review CLAUDE.accel/momentum.md. If you want to adopt it, rename it to CLAUDE.md. Your original is untouched."
+</step>
+
+</steps>
+
+<output>
+CLAUDE.accel/momentum.md file in workspace root — a recommended CLAUDE.md following Momentum conventions. Original CLAUDE.md is never modified.
+</output>
+
+<acceptance-criteria>
+- [ ] Existing CLAUDE.md read and analyzed
+- [ ] All Momentum best-practice sections checked
+- [ ] CLAUDE.accel/momentum.md generated with recommendations
+- [ ] Original CLAUDE.md untouched
+- [ ] User informed of differences and how to adopt
+</acceptance-criteria>

package/modules/momentum/src/framework/tasks/audit.md

@@ -0,0 +1,64 @@
+<purpose>
+Deep workspace optimization. Dynamically generate audit phases from the workspace manifest, run each area's configured audit strategy, and execute operator-approved changes.
+</purpose>
+
+<user-story>
+As an AI builder, I want a thorough workspace audit that adapts to my workspace structure, so that every area gets properly reviewed regardless of how complex my setup is.
+</user-story>
+
+<when-to-use>
+- Quarterly or after major workspace shifts
+- When user says "momentum audit", "deep clean", "optimize workspace"
+- Entry point routes here via /momentum:audit
+</when-to-use>
+
+<steps>
+
+<step name="generate_phases" priority="first">
+Read workspace manifest and generate audit phases dynamically.
+
+1. Read `.accel/momentum/workspace.json`
+2. For each area, create an audit phase using its configured strategy
+3. Present phase list: "Audit will cover {N} phases: {list with strategies}"
+4. Create task tracking for each phase
+
+**Wait for operator confirmation. Allow them to skip or reorder phases.**
+</step>
+
+<step name="execute_phases">
+Run each phase using its configured audit strategy.
+
+For each phase:
+1. Announce: "Phase {N}: {area-name} ({strategy})"
+2. Execute the strategy (reference frameworks/audit-strategies.md)
+3. Present findings
+4. Collect operator decisions (keep/archive/delete/move)
+5. Execute approved changes
+6. Mark phase complete
+
+Strategies are documented in `@frameworks/audit-strategies.md`.
+</step>
+
+<step name="record_audit">
+Record the audit results.
+
+1. Update `.accel/momentum/STATE.md`
+2. Write audit record to `.accel/momentum/audits/{YYYY-MM-DD}.md`
+3. Log to `.accel/momentum/ROADMAP.md`
+4. Report final summary: phases completed, items changed, new drift score
+</step>
+
+</steps>
+
+<output>
+Complete workspace audit with dynamic phases. All areas reviewed, changes executed, audit recorded.
+</output>
+
+<acceptance-criteria>
+- [ ] Phases generated dynamically from manifest (not hardcoded)
+- [ ] Each area audited using its configured strategy
+- [ ] Operator approved all changes before execution
+- [ ] Audit record written to audits/ directory
+- [ ] STATE.md updated
+- [ ] ROADMAP.md updated with audit entry
+</acceptance-criteria>

package/modules/momentum/src/framework/tasks/groom.md

@@ -0,0 +1,164 @@
+<purpose>
+Structured weekly maintenance cycle. Walk through each workspace area, review with operator, enforce backlog time-based rules, graduate ready items, and log the groom.
+</purpose>
+
+<user-story>
+As an AI builder, I want a guided workspace maintenance session, so that my context documents stay current, my backlog items graduate when ready, and my workspace doesn't drift.
+</user-story>
+
+<when-to-use>
+- Weekly (on configured groom day)
+- When pulse reports overdue grooming
+- When user says "momentum groom", "let's groom", "workspace maintenance"
+- Entry point routes here via /momentum:groom
+</when-to-use>
+
+<steps>
+
+<step name="assess_scope" priority="first">
+Determine what needs grooming.
+
+1. Read `.accel/momentum/workspace.json` manifest
+2. Read `.accel/momentum/STATE.md` for last groom dates per area
+3. Identify which areas are due for grooming (past their cadence)
+4. Sort by staleness (most overdue first)
+5. Present: "Groom session starting. {N} areas due for review: {list}. Estimated time: {N*5} minutes."
+
+**Wait for operator confirmation before proceeding.**
+</step>
+
+<step name="groom_active">
+Review ACTIVE.md — the working memory for projects and tasks.
+
+1. Read `.accel/momentum/ACTIVE.md`
+2. Present summary: "{N} projects, {N} tasks, last updated {date}"
+3. For each project: "Still active? Status changed? Next action current?"
+4. For each task in TASKS section: "Done? Still in progress? Blocked?"
+5. Close completed tasks (move to DONE/CLOSED with outcome + date)
+6. Ask: "Anything new to add?"
+7. Update timestamp
+
+Voice-friendly: walk through one entry at a time, wait for response.
+</step>
+
+<step name="groom_backlog">
+Review BACKLOG.md — enforce time-based rules AND handle graduation.
+
+**Time-based enforcement:**
+1. For each item, check Added date against review-by threshold:
+   - High priority: 7 days
+   - Medium priority: 14 days
+   - Low priority: 30 days
+2. Items past review-by → surface: "These items need a decision: {list}"
+3. Items past staleness (2x review-by) → "Auto-archiving: {list} (past {N} days without action)"
+4. Process operator decisions on each flagged item
+
+**Graduation check:**
+5. For each remaining item, ask: "Ready to work on any of these?"
+6. If yes — determine destination:
+   - **As a TASK:** Item is bounded, standalone work. Move to ACTIVE.md → TASKS section.
+     Format: `### {Task Name}` with Status, Next, Blocked, Notes fields.
+   - **As a PROJECT:** Item is complex enough to warrant its own project entry.
+     Move to ACTIVE.md under appropriate priority section with full project format.
+   - **Stay in backlog:** Not ready yet. Keep with updated review-by date.
+7. For graduated items: remove from BACKLOG.md, add to ACTIVE.md in correct section
+8. Update BACKLOG.md timestamp
+
+**The graduation question is explicit every groom.** Items don't graduate silently — the operator decides.
+</step>
+
+<step name="groom_directories">
+Review directory-type areas (projects/, clients/, tools/).
+
+For each directory area due for grooming:
+1. List contents
+2. Flag anything that looks orphaned or new since last groom
+3. Ask: "Anything to archive, delete, or reclassify?"
+4. Execute approved changes
+</step>
+
+<step name="groom_satellites">
+Review Drive satellite project health.
+
+1. Read `.accel/momentum/workspace.json` — collect all satellite entries where `groom_check: true`
+2. If no satellites have `groom_check: true` → skip this step silently
+3. For each eligible satellite:
+   a. Read its STATE.md at the path in `satellite.state` (relative to workspace root)
+   b. If STATE.md is missing or unreadable → note as "⚠️ {name}: STATE.md not found"
+   c. Get last activity timestamp:
+      - PRIMARY: read `satellite.last_activity` from workspace.json entry (ISO timestamp written by session-start hook from drive.json)
+      - FALLBACK: if `last_activity` not present in workspace.json, parse "Last activity" line from the satellite's STATE.md
+      - If neither available → note as "⚠️ {name}: cannot determine last activity"
+   d. Parse "Loop Position" section from STATE.md → extract PLAN/APPLY/UNIFY markers (✓ = done, ○ = pending)
+   e. Evaluate health criteria:
+      - **STUCK LOOP**: Loop shows PLAN ✓ APPLY ○ or PLAN ✓ APPLY ✓ UNIFY ○, AND last activity > 7 days ago
+      - **ABANDONED PHASE**: Last activity > 14 days ago AND milestone status is not COMPLETE
+      - **MILESTONE DRIFT**: Milestone marked COMPLETE, loop shows ○ ○ ○ (no new milestone started), AND last activity > 14 days ago
+4. Collect all issues across satellites
+5. If issues found: surface as:
+   ```
+   ⚠️ Satellite health issues:
+     - {satellite-name}: {issue type} (last active: {date})
+   ```
+6. If no issues: output single line "Satellites: all healthy ({N} checked)"
+
+**Report only — do NOT auto-fix.** Operator decides what to do with flagged satellites.
+</step>
+
+<step name="groom_system">
+Review system layer areas (hooks, commands, skills, Vector).
+
+1. Quick scan for obvious dead items
+2. Only flag if something clearly wrong
+3. Ask: "Any system changes to note?"
+4. If Vector hygiene is enabled (workspace.json `vector_hygiene.proactive: true`):
+   - Check `.vector/staging/` for pending proposals
+   - Check rule timestamps for staleness
+   - Surface: "{N} staged proposals, {N} stale rules — run /momentum:vector-hygiene?"
+</step>
+
+<step name="log_groom">
+Record the groom session.
+
+1. Update `.accel/momentum/STATE.md` with new timestamps for all groomed areas
+2. Reset drift score
+3. Write groom summary to `.accel/momentum/grooming/{YYYY}-W{NN}.md`:
+   ```markdown
+   # Groom Summary — Week {NN}, {YYYY}
+
+   **Date:** {YYYY-MM-DD}
+   **Areas Reviewed:** {list}
+   **Drift Score:** {before} → 0
+
+   ## Changes
+   - {what changed}
+
+   ## Graduated from Backlog
+   - {item} → ACTIVE.md TASKS / PROJECT
+
+   ## Archived / Killed
+   - {item} (reason)
+
+   ## Next Groom Due
+   {YYYY-MM-DD}
+   ```
+4. Report: "Groom complete. Drift score: 0. Next groom due: {date}."
+</step>
+
+</steps>
+
+<output>
+Updated workspace state. All due areas reviewed and current. Backlog time-based rules enforced. Ready items graduated. Groom summary logged.
+</output>
+
+<acceptance-criteria>
+- [ ] All overdue areas reviewed with operator
+- [ ] ACTIVE.md and BACKLOG.md timestamps updated
+- [ ] Backlog time-based rules enforced (review-by, staleness)
+- [ ] Graduation question asked explicitly for backlog items
+- [ ] Graduated items properly moved to ACTIVE.md (TASKS or PROJECT)
+- [ ] STATE.md updated with new groom date
+- [ ] Groom summary written to grooming/ directory
+- [ ] Drift score reset to 0
+- [ ] Operator confirmed completion of each area
+</acceptance-criteria>

package/modules/momentum/src/framework/tasks/history.md

@@ -0,0 +1,34 @@
+<purpose>
+Show workspace evolution over time. Read ROADMAP.md and present the chronological record of major workspace changes.
+</purpose>
+
+<user-story>
+As an AI builder, I want to see how my workspace has evolved, so that I can understand the trajectory and make informed decisions about future changes.
+</user-story>
+
+<when-to-use>
+- When user wants to review workspace history
+- Entry point routes here via /momentum:history
+</when-to-use>
+
+<steps>
+
+<step name="read_history" priority="first">
+Read and present workspace evolution.
+
+1. Read `.accel/momentum/ROADMAP.md`
+2. Present chronologically: dates, what changed, why
+3. Include audit summaries and major groom outcomes
+4. If ROADMAP.md is empty or missing: "No history yet. Run /momentum:audit or /momentum:groom to start building your workspace timeline."
+</step>
+
+</steps>
+
+<output>
+Chronological workspace evolution timeline from ROADMAP.md.
+</output>
+
+<acceptance-criteria>
+- [ ] History presented in clear chronological format
+- [ ] Includes both audits and significant groom outcomes
+</acceptance-criteria>