name	chronicle-project-tracker
description	Manage Chronicle project development using database-tracked milestones, next steps, and roadmap visualization. Works with MCP tools (fast, structured) or CLI commands (portable). Use when planning features, tracking progress, viewing roadmap, or linking sessions to milestones. Eliminates manual DEVELOPMENT_HISTORY.md updates.

Chronicle Project Tracker

This skill helps you manage project development meta-state using Chronicle's built-in project tracking features. Use MCP tools for programmatic access or CLI commands for portability.

Auto-Activation

This skill auto-activates! (Milestone #13)

Prompts like "what's next?" or "show roadmap" automatically trigger this skill. No manual loading needed!

Trigger patterns: what's next, show roadmap, create milestone, track progress See: docs/HOOKS.md for full details

When to Use This Skill

Use this skill when:

Planning new features or milestones
Tracking development progress
Viewing project roadmap
Linking sessions to milestones
Checking what's in progress or planned
Answering "what should I work on next?"
Generating progress reports

Available Tools (MCP + CLI)

MCP Tools (Programmatic Access)

Query Tools:

mcp__chronicle__get_milestones(status, milestone_type, limit) - List milestones
mcp__chronicle__get_milestone(milestone_id) - Get milestone details
mcp__chronicle__get_next_steps(completed, milestone_id, limit) - List next steps
mcp__chronicle__get_roadmap(days) - View project roadmap

Update Tools:

mcp__chronicle__update_milestone_status(milestone_id, new_status) - Update status
mcp__chronicle__complete_next_step(step_id) - Mark step complete

CLI Commands (Portable)

See "CLI Commands Reference" section below for full list.

Key commands:

chronicle milestones - List milestones
chronicle roadmap - View roadmap
chronicle next-steps - List next steps
chronicle milestone-complete <id> - Mark complete

Workflow: Planning a New Feature

When user wants to add a new feature:

Check existing roadmap to avoid duplicates:

roadmap = mcp__chronicle__get_roadmap(days=30)
# Review planned milestones

Create milestone via CLI (user runs this):

chronicle milestone "Feature name" \
  --description "What it does" \
  --type feature \
  --priority 1 \
  --tags "phase-5,api,backend"

Break down into next steps:

chronicle next-step "Design API endpoints" --priority 1 --effort medium --milestone <ID>
chronicle next-step "Write tests" --priority 2 --effort small --milestone <ID>
chronicle next-step "Document in README" --priority 3 --effort small --milestone <ID>

Update status when starting work:

mcp__chronicle__update_milestone_status(milestone_id=1, new_status="in_progress")

Workflow: Session Linking

When completing a development session:

Get session ID from recent sessions:

sessions = mcp__chronicle__get_sessions(limit=5)
latest_session_id = sessions[0]['id']

Find active milestone:

milestones = mcp__chronicle__get_milestones(status="in_progress")
active_milestone_id = milestones[0]['id']

Link them (user runs this):

chronicle link-session <session_id> --milestone <milestone_id>

Complete next steps as work progresses:

mcp__chronicle__complete_next_step(step_id=1)

Workflow: Generating Progress Reports

When user asks "what did I accomplish this week?":

Get roadmap:

roadmap = mcp__chronicle__get_roadmap(days=7)

Extract info:
- roadmap['recently_completed'] - Milestones completed in last 7 days
- roadmap['in_progress'] - Current active work
- roadmap['summary'] - Statistics

Get linked sessions for each completed milestone:

for milestone in roadmap['recently_completed']:
    milestone_details = mcp__chronicle__get_milestone(milestone['id'])
    sessions = milestone_details['linked_sessions']
    # Summarize work done

Format report showing:
- Completed milestones with linked sessions
- Git commits from those sessions
- Time spent (from session durations)
- Key files modified

Workflow: Viewing Roadmap

When user asks "what's next?" or "show me the roadmap":

# Get full roadmap
roadmap = mcp__chronicle__get_roadmap(days=7)

# Present in organized format:
print("🚧 IN PROGRESS:")
for m in roadmap['in_progress']:
    print(f"  - {m['title']} ({len(m['related_sessions'])} sessions)")

print("\n📋 PLANNED (High Priority):")
for m in roadmap['planned_high_priority']:
    print(f"  - [P{m['priority']}] {m['title']}")

print("\n🔜 NEXT STEPS:")
for step in roadmap['pending_next_steps']:
    effort = f" [{step['estimated_effort']}]" if step['estimated_effort'] else ""
    print(f"  - [P{step['priority']}] {step['description']}{effort}")

print("\n✅ RECENTLY COMPLETED:")
for m in roadmap['recently_completed']:
    print(f"  - {m['title']} ({m['completed_at']})")

Workflow: Completing a Milestone

When all work for a milestone is done:

Verify all next steps completed:

steps = mcp__chronicle__get_next_steps(milestone_id=<ID>, completed=False)
if len(steps['next_steps']) == 0:
    # All done!

Mark milestone complete (user runs):
```
chronicle milestone-complete <ID>
```

Auto-generates documentation by querying:

milestone = mcp__chronicle__get_milestone(<ID>)
# Has all linked sessions, commits, duration
# Can auto-update DEVELOPMENT_HISTORY.md or export to Obsidian

Querying Examples

"What features are in progress?"

milestones = mcp__chronicle__get_milestones(status="in_progress")
for m in milestones['milestones']:
    sessions = len(m['related_sessions'])
    print(f"{m['title']}: {sessions} sessions so far")

"What's the highest priority work?"

roadmap = mcp__chronicle__get_roadmap()
top_planned = roadmap['planned_high_priority'][0]
print(f"Next up: {top_planned['title']} (P{top_planned['priority']})")

"Show me all optimization work"

milestones = mcp__chronicle__get_milestones(milestone_type="optimization")

"What work did session 16 contribute to?"

# Get all milestones
all_milestones = mcp__chronicle__get_milestones(limit=100)
for m in all_milestones['milestones']:
    if 16 in m['related_sessions']:
        print(f"Session 16 worked on: {m['title']}")

Statistics & Reports

Weekly Progress Report

roadmap = mcp__chronicle__get_roadmap(days=7)

completed_count = len(roadmap['recently_completed'])
in_progress_count = len(roadmap['in_progress'])

print(f"Week of {date}:")
print(f"✅ {completed_count} milestones completed")
print(f"🚧 {in_progress_count} milestones in progress")
print(f"⏰ {roadmap['summary']['total_next_steps'] - roadmap['summary']['completed_next_steps']} pending tasks")

Milestone Velocity

# Get all completed milestones
completed = mcp__chronicle__get_milestones(status="completed", limit=100)

# Calculate average time from creation to completion
durations = []
for m in completed['milestones']:
    created = datetime.fromisoformat(m['created_at'])
    completed_at = datetime.fromisoformat(m['completed_at'])
    durations.append((completed_at - created).days)

avg_days = sum(durations) / len(durations)
print(f"Average milestone completion time: {avg_days:.1f} days")

Auto-Documentation Pattern

Instead of manually updating DEVELOPMENT_HISTORY.md:

# Query completed milestones
completed = mcp__chronicle__get_milestones(status="completed")

# For each milestone, get details
for milestone in completed['milestones']:
    details = mcp__chronicle__get_milestone(milestone['id'])

    # Extract:
    # - Title, description
    # - Related sessions (with summaries)
    # - Related commits (with messages)
    # - Duration (from session data)
    # - Files modified (from commits)

    # Generate markdown section
    md = f"### {details['title']}\n"
    md += f"{details['description']}\n\n"
    md += f"**Status**: {details['status']}\n"
    md += f"**Sessions**: {len(details['linked_sessions'])}\n"
    md += f"**Commits**: {len(details['linked_commits'])}\n"

    # Could write to DEVELOPMENT_HISTORY.md or Obsidian

Integration with Other Skills

With chronicle-workflow

After completing a session, use this skill to:

Link session to active milestone
Mark next steps as complete
Check roadmap for what to work on next

With chronicle-session-documenter

When documenting a session to Obsidian:

Include milestone information
Add wikilinks to related milestones
Tag with milestone tags

With chronicle-context-retriever

When searching past work:

Filter by milestone
Find all sessions for a feature
See historical progress on similar work

CLI Commands Reference

Milestones:

chronicle milestone "Title" --description "Desc" --type feature --priority 1 --tags "tag1,tag2"
chronicle milestones --status in_progress
chronicle milestone-show <ID>
chronicle milestone-status <ID> in_progress
chronicle milestone-complete <ID>

Next Steps:

chronicle next-step "Description" --priority 1 --effort medium --category feature --milestone <ID>
chronicle next-steps --milestone <ID>
chronicle next-step-complete <ID>

Linking:

chronicle link-session <session_id> --milestone <ID>

Roadmap:

chronicle roadmap --days 7

Database Tables

project_milestones

id - Unique ID
title - Milestone name
description - Details
status - planned, in_progress, completed, archived
milestone_type - feature, bugfix, optimization, documentation
priority - 1 (highest) to 5 (lowest)
created_at - Creation timestamp
completed_at - Completion timestamp
related_sessions - JSON array of session IDs
related_commits - JSON array of commit SHAs
tags - JSON array of tags

next_steps

id - Unique ID
description - What needs to be done
priority - 1 (highest) to 5 (lowest)
estimated_effort - small, medium, large
category - feature, optimization, fix, docs
created_by - session_16, manual, ai-suggestion
completed - 0 or 1
created_at - Creation timestamp
completed_at - Completion timestamp
related_milestone_id - FK to milestone

Pro Tips

Start milestones early - Link sessions as you go
Use priority levels - Helps roadmap show what's important
Tag milestones - Makes filtering easier (e.g., "phase-5", "api", "frontend")
Break down features - Create next steps for each milestone
Link sessions retroactively - After work is done, link to milestone
Query before planning - Check roadmap to avoid duplicate work
Use milestone types - Distinguishes features from bugfixes
Complete next steps - Helps track progress within a milestone
Auto-document - Query completed milestones to generate reports
Review roadmap weekly - Stay aligned on priorities

Benefits Over Manual Documentation

Before (manual DEVELOPMENT_HISTORY.md):

Manual updates required
Easy to forget to document
Hard to query programmatically
No linking between sessions/commits/features
Becomes stale quickly

After (database-tracked milestones):

Automatic tracking via MCP tools
Queryable (e.g., "what's in progress?")
Sessions auto-link to milestones
Commits auto-link to sessions
Real-time roadmap view
Can generate reports on-demand
Powers AI-driven development insights

Example: Meta-Development

Chronicle uses Chronicle to track its own development:

# Milestone #1: Add project tracking to Chronicle
chronicle milestone "Add project tracking to Chronicle" \
  --description "Database-tracked milestones and next steps" \
  --type feature \
  --priority 1 \
  --tags "phase-5,project-tracking,meta"

# Break down work
chronicle next-step "Design database schema" --priority 1 --effort medium --milestone 1
chronicle next-step "Add CLI commands" --priority 1 --effort large --milestone 1
chronicle next-step "Add MCP tools" --priority 1 --effort medium --milestone 1
chronicle next-step "Create Chronicle Skills" --priority 2 --effort medium --milestone 1
chronicle next-step "Write tests" --priority 2 --effort small --milestone 1
chronicle next-step "Update documentation" --priority 3 --effort small --milestone 1

# Mark in progress
chronicle milestone-status 1 in_progress

# As work completes
chronicle next-step-complete 1
chronicle next-step-complete 2
# ... etc

# Link current session
chronicle link-session 18 --milestone 1

# When done
chronicle milestone-complete 1

# Generate report
chronicle milestone-show 1

This skill represents Chronicle's dogfooding: using Chronicle to build Chronicle!

chronicle-project-tracker

Install Skill

SKILL.md