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!