Project Memory Tracking Skill

Use this skill to maintain persistent memory of project state, services built, features implemented, and decisions made. This gives agents context about what's been done without re-analyzing the entire codebase.

When to Use

•Before starting work - Load project context
•After implementing features - Save what was built
•After QA testing - Save test results and screenshots
•After fixing issues - Track what was fixed
•When switching services - Save/load context
•During planning - Reference existing work

Why This Is Critical

Without Memory:

•❌ Agents don't know what's already built
•❌ Repeat analysis of same code
•❌ Lose context between sessions
•❌ Forget decisions made
•❌ Re-discover same issues
•❌ Can't reference previous work

With Memory:

•✅ Agents know project state
•✅ Reference existing services
•✅ Maintain context across sessions
•✅ Remember decisions and rationale
•✅ Track issue history
•✅ Build on previous work

What This Skill Tracks

1. Services Inventory

yaml

services:
  auth:
    type: microservice
    api:
      project: auth/auth-api
      port: 8001
      docker_ip: 172.18.0.2
      database: stylemate_auth
      health_endpoint: /health
      endpoints:
        - POST /api/auth/login
        - POST /api/auth/register
        - POST /api/auth/refresh
        - GET /api/auth/profile
      jwt_config:
        issuer: stylemate-auth
        audience: stylemate-services
        claims: [sub, email, role, business_id, email_confirmed]
    ui:
      project: auth/auth-ui
      port: 3001
      docker_ip: 172.18.0.3
      routes:
        - /login
        - /register
        - /profile
      federation_remote: auth_ui
    status: production
    last_modified: 2025-01-15T14:30:00Z
    created_by: dotnet-engineer-agent
    qa_status: verified_complete
    qa_date: 2025-01-15T16:00:00Z

  scheduling:
    type: microservice
    api:
      project: scheduling/scheduling-api
      port: 8003
      docker_ip: 172.18.0.4
      database: stylemate_scheduling
      endpoints:
        - GET /api/scheduling/schedules
        - POST /api/scheduling/schedules
        - PUT /api/scheduling/schedules/{id}
        - DELETE /api/scheduling/schedules/{id}
    ui:
      project: scheduling/scheduling-ui
      port: 3003
      docker_ip: 172.18.0.5
      routes:
        - /schedules
        - /schedules/create
        - /schedules/edit/{id}
    status: production
    last_modified: 2025-01-15T17:45:00Z
    features:
      - Schedule CRUD
      - Calendar view
      - Date filtering
    qa_cycles: 2
    screenshots_captured: 70

2. Features Implemented

yaml

features:
  schedule_management:
    service: scheduling
    type: crud
    description: Staff can create, edit, delete schedules
    components:
      - ScheduleCalendar.tsx
      - ScheduleForm.tsx
      - ScheduleList.tsx
    api_endpoints:
      - POST /api/scheduling/schedules
      - GET /api/scheduling/schedules
      - PUT /api/scheduling/schedules/{id}
      - DELETE /api/scheduling/schedules/{id}
    implemented_by: ui-engineer-agent
    implementation_date: 2025-01-15T14:30:00Z
    qa_by: qa-frontend-engineer
    qa_status: verified_complete
    qa_cycles: 2
    issues_found: 5
    issues_fixed: 5
    screenshots: [list of 70 screenshot files]
    responsive_breakpoints_tested: [375, 414, 768, 1024, 1280, 1920]

3. Database Schemas

yaml

databases:
  stylemate_scheduling:
    service: scheduling
    tables:
      schedules:
        columns:
          - id: UUID (PK)
          - business_id: UUID (FK, indexed)
          - employee_id: UUID (FK)
          - date: Date
          - start_time: Time
          - end_time: Time
          - is_active: Boolean
          - created_at: Timestamp
          - updated_at: Timestamp
        indexes:
          - business_id
          - employee_id
          - date
        migrations:
          - 20250115_CreateSchedules.cs

4. QA Test Results

yaml

qa_results:
  schedule_calendar_page:
    feature: Schedule Calendar Page
    date: 2025-01-15T17:45:00Z
    qa_agent: qa-frontend-engineer
    cycles: 2

    cycle_1:
      date: 2025-01-15T15:00:00Z
      pass_rate: 75%
      passed: 15
      failed: 5
      critical_issues: 2
      screenshots: 35
      issues:
        - Horizontal scroll on mobile 375px (CRITICAL)
        - Touch targets 32px, need 44px (CRITICAL)
        - Tablet layout broken
        - Console error: undefined property
        - Loading state not visible
      status: REJECTED

    cycle_2:
      date: 2025-01-15T17:45:00Z
      pass_rate: 100%
      passed: 20
      failed: 0
      critical_issues: 0
      screenshots: 35
      status: APPROVED

    final_status: VERIFIED_COMPLETE
    total_screenshots: 70
    screenshot_files: [list of files]

5. Architectural Decisions

yaml

decisions:
  decision_001:
    date: 2025-01-15T10:00:00Z
    title: Use Clean Architecture in single project
    context: Need to organize .NET microservices
    decision: Implement Clean Architecture within single project (not separate assemblies)
    rationale: Simpler for small microservices, easier to maintain
    alternatives_considered:
      - Separate projects for each layer (too complex for small services)
      - No architecture (too messy)
    decided_by: work-planner-agent
    status: active

  decision_002:
    date: 2025-01-15T11:30:00Z
    title: Mobile-first responsive design
    context: UI must work on mobile and desktop
    decision: Design for mobile first (375px), then enhance for desktop
    rationale: Most staff use phones in salon
    decided_by: software-engineer-agent
    status: active

6. Issues Tracked

yaml

issues:
  issue_001:
    feature: Schedule Calendar
    date_found: 2025-01-15T15:00:00Z
    found_by: qa-frontend-engineer
    severity: CRITICAL
    description: Horizontal scroll on mobile 375px
    cause: Fixed width container (1200px)
    fix: Removed fixed widths, used max-width 100%
    fixed_by: ui-engineer-agent
    date_fixed: 2025-01-15T16:30:00Z
    verified_by: verification-agent
    date_verified: 2025-01-15T17:45:00Z
    status: RESOLVED

  issue_002:
    feature: Schedule Calendar
    date_found: 2025-01-15T15:00:00Z
    found_by: qa-frontend-engineer
    severity: CRITICAL
    description: Touch targets only 32px (need 44px)
    fix: Increased button size to 48px
    status: RESOLVED

7. Docker Network Configuration

yaml

docker:
  network:
    name: stylemate_net
    subnet: 172.18.0.0/16
    driver: bridge

  containers:
    auth_ui:
      image: auth-ui:latest
      ip: 172.18.0.3
      ports: ["3001:80"]
      status: running
      health_check: /remoteEntry.js

    auth_api:
      image: auth-api:latest
      ip: 172.18.0.2
      ports: ["8001:80"]
      status: running
      health_check: /health

    scheduling_ui:
      image: scheduling-ui:latest
      ip: 172.18.0.5
      ports: ["3003:80"]
      status: running
      health_check: /remoteEntry.js

Memory Operations

Load Project State

bash

# Get all context at start of session
memory_load_all()

Returns complete project state:

•All services
•All features
•Recent QA results
•Open issues
•Architectural decisions
•Docker configuration

Save Service Built

bash

memory_save_service(
  name: "scheduling",
  type: "microservice",
  api: { ... },
  ui: { ... },
  features: [ ... ]
)

Save Feature Implemented

bash

memory_save_feature(
  name: "schedule_management",
  service: "scheduling",
  components: [ ... ],
  endpoints: [ ... ],
  implemented_by: "ui-engineer-agent"
)

Save QA Results

bash

memory_save_qa_result(
  feature: "schedule_calendar_page",
  cycle: 1,
  pass_rate: 75,
  issues: [ ... ],
  screenshots: [ ... ]
)

Save Architectural Decision

bash

memory_save_decision(
  title: "Use mobile-first design",
  decision: "Design for mobile first...",
  rationale: "Most users on mobile..."
)

Save Issue

bash

memory_save_issue(
  description: "Horizontal scroll on mobile",
  severity: "CRITICAL",
  feature: "Schedule Calendar",
  found_by: "qa-frontend-engineer"
)

Update Issue Status

bash

memory_update_issue(
  issue_id: "issue_001",
  status: "RESOLVED",
  fixed_by: "ui-engineer-agent",
  fix_description: "Removed fixed widths"
)

Save Task List (NEW - for orchestration)

bash

memory_save_task_list(
  feature: "inventory_management",
  tasks: [
    { id: "task_001", name: "Plan feature", agent: "work-planner-agent", ... },
    { id: "task_002", name: "Backend API", agent: "dotnet-engineer-agent", ... },
    ...
  ],
  status: "in_progress"
)

Update Task Status (NEW)

bash

memory_update_task(
  task_id: "task_002",
  status: "completed",
  completed: "2025-10-31T10:30:00Z",
  results: { endpoints_created: 5, tests_passing: true }
)

Query Memory

bash

# Get specific service
memory_get_service("scheduling")

# Get all features for a service
memory_get_features(service: "scheduling")

# Get task list for a feature (NEW)
memory_get_task_list("inventory_management")

# Get specific task (NEW)
memory_get_task("task_002")

# Get tasks by status (NEW)
memory_get_tasks_by_status("inventory_management", "pending")
memory_get_tasks_by_status("inventory_management", "running")
memory_get_tasks_by_status("inventory_management", "failed")

# Get recent QA results
memory_get_qa_results(limit: 5)

# Get open issues
memory_get_issues(status: "OPEN")

# Get Docker IPs
memory_get_docker_ips()

Integration with Agents

software-engineer-agent

yaml

At start:
  - Load project state from memory
  - Check existing services
  - Reference previous decisions

During work:
  - Save features as implemented
  - Save QA results
  - Track issues found/fixed

At end:
  - Update service status
  - Save final QA results
  - Update memory with new state

context-manager agent

yaml

Primary memory manager:
  - Load all context at session start
  - Provide context to other agents
  - Keep memory up-to-date
  - Track service inventory
  - Maintain Docker IP mappings

qa-frontend-engineer

yaml

During testing:
  - Load service info (Docker IP, ports)
  - Reference previous QA results
  - Compare with baseline

After testing:
  - Save QA results
  - Save screenshot list
  - Save issues found
  - Update service QA status

verification-agent

yaml

During verification:
  - Load acceptance criteria
  - Reference previous cycles
  - Track verification history

After verification:
  - Save verification result
  - Update issue statuses
  - Save cycle metrics

Memory Schema

Service Schema

typescript

interface Service {
  name: string
  type: 'microservice' | 'library' | 'shared'
  api?: {
    project: string
    port: number
    docker_ip: string
    database: string
    health_endpoint: string
    endpoints: string[]
    jwt_config?: JWTConfig
  }
  ui?: {
    project: string
    port: number
    docker_ip: string
    routes: string[]
    federation_remote: string
  }
  status: 'development' | 'qa' | 'production'
  last_modified: string
  created_by: string
  qa_status: 'pending' | 'testing' | 'verified_complete'
  qa_date?: string
}

Feature Schema

typescript

interface Feature {
  name: string
  service: string
  type: 'crud' | 'view' | 'form' | 'integration'
  description: string
  components: string[]
  api_endpoints: string[]
  implemented_by: string
  implementation_date: string
  qa_by?: string
  qa_status: 'pending' | 'testing' | 'verified_complete'
  qa_cycles: number
  issues_found: number
  issues_fixed: number
  screenshots: string[]
  responsive_breakpoints_tested: number[]
}

QA Result Schema

typescript

interface QAResult {
  feature: string
  date: string
  qa_agent: string
  cycles: number
  cycle_results: QACycle[]
  final_status: 'VERIFIED_COMPLETE' | 'FAILED'
  total_screenshots: number
  screenshot_files: string[]
}

interface QACycle {
  cycle_number: number
  date: string
  pass_rate: number
  passed: number
  failed: number
  critical_issues: number
  screenshots: number
  issues: Issue[]
  status: 'APPROVED' | 'REJECTED'
}

Issue Schema

typescript

interface Issue {
  id: string
  feature: string
  date_found: string
  found_by: string
  severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW'
  description: string
  cause?: string
  fix?: string
  fixed_by?: string
  date_fixed?: string
  verified_by?: string
  date_verified?: string
  status: 'OPEN' | 'IN_PROGRESS' | 'RESOLVED'
  screenshots?: string[]
}

Task Schema (NEW - for orchestration)

typescript

interface Task {
  id: string                          // task_001, task_002, etc.
  name: string                        // Human-readable task name
  agent: string                       // Which agent executes this task
  dependencies: string[]              // Task IDs that must complete first
  status: 'pending' | 'running' | 'completed' | 'failed' | 'needs_retest'
  context_needed: {
    [key: string]: any               // Minimal context needed
    load_from_memory: string[]       // What to load from memory
  }
  created: string                     // ISO timestamp
  started?: string                    // When execution started
  completed?: string                  // When execution finished
  results?: any                       // Summary results (details in memory)
  error?: string                      // Error if failed
  correction?: string                 // If needs_retest, what was fixed
}

interface TaskList {
  feature: string                     // Feature name
  tasks: Task[]                       // All tasks
  created: string                     // When task list created
  status: 'in_progress' | 'completed' | 'paused' | 'failed'
  current_phase?: string              // planning, development, qa, verification
}

Example Usage Flow

Starting New Feature

javascript

// 1. software-engineer-agent loads context
const projectState = memory_load_all()

console.log('Existing services:', projectState.services)
console.log('Recent features:', projectState.features)
console.log('Docker IPs:', projectState.docker.containers)

// 2. Reference existing service
const schedulingService = memory_get_service('scheduling')
console.log('Scheduling API at:', schedulingService.api.docker_ip)
console.log('Existing endpoints:', schedulingService.api.endpoints)

// 3. Implement new feature
// ... implementation work ...

// 4. Save new feature to memory
memory_save_feature({
  name: 'schedule_recurring',
  service: 'scheduling',
  type: 'crud',
  description: 'Create recurring schedules',
  components: ['RecurringScheduleForm.tsx', 'RecurrencePattern.tsx'],
  api_endpoints: ['POST /api/scheduling/recurring-schedules'],
  implemented_by: 'ui-engineer-agent',
  implementation_date: '2025-01-16T10:00:00Z'
})

// 5. Run QA
// ... QA testing ...

// 6. Save QA results
memory_save_qa_result({
  feature: 'schedule_recurring',
  cycle: 1,
  date: '2025-01-16T12:00:00Z',
  qa_agent: 'qa-frontend-engineer',
  pass_rate: 100,
  passed: 20,
  failed: 0,
  critical_issues: 0,
  screenshots: 35,
  issues: [],
  status: 'APPROVED'
})

// 7. Update service
memory_update_service('scheduling', {
  last_modified: '2025-01-16T12:00:00Z',
  features: [...existing, 'schedule_recurring']
})

Loading Context for QA

javascript

// qa-frontend-engineer gets Docker IP from memory
const service = memory_get_service('scheduling')
const dockerIP = service.ui.docker_ip
const testURL = `http://${dockerIP}:80`

console.log('Testing URL:', testURL)

// Reference previous QA results
const previousQA = memory_get_qa_results(feature: 'schedule_calendar_page')
console.log('Previous issues found:', previousQA[0].cycle_results[0].issues)
console.log('Verify those are still fixed...')

Verification Agent Checking History

javascript

// verification-agent loads QA history
const qaHistory = memory_get_qa_results(feature: 'schedule_recurring')

console.log('QA Cycles:', qaHistory[0].cycles)
console.log('Cycle 1 pass rate:', qaHistory[0].cycle_results[0].pass_rate)
console.log('Issues found:', qaHistory[0].cycle_results[0].issues.length)

if (qaHistory[0].final_status === 'VERIFIED_COMPLETE') {
  console.log('✅ Feature verified complete')
  memory_update_feature('schedule_recurring', {
    qa_status: 'verified_complete'
  })
}

Memory Persistence

Storage Location

code

.claude/memory/
├── services.json          # All services
├── features.json          # All features
├── qa_results.json        # QA test results
├── issues.json            # Issue tracking
├── decisions.json         # Architectural decisions
├── docker.json            # Docker network state
└── screenshots/           # Screenshot metadata
    ├── schedule_calendar/
    │   ├── manifest.json
    │   └── cycle_1/
    │       ├── mobile_portrait_scroll_0.png
    │       ├── mobile_portrait_scroll_1.png
    │       └── ...

Memory Maintenance

bash

# Clean old QA results (keep last 10 per feature)
memory_cleanup_qa_results()

# Archive completed issues
memory_archive_issues(status: 'RESOLVED', older_than: '30 days')

# Update Docker IPs (containers may restart)
memory_refresh_docker_ips()

# Backup memory
memory_backup()

Benefits

For Agents:

•✅ Know what's already built
•✅ Reference existing services
•✅ Don't repeat work
•✅ Learn from previous issues
•✅ Maintain context across sessions

For Users:

•✅ See project history
•✅ Track what's been implemented
•✅ Review QA results
•✅ Understand decisions made
•✅ Reference documentation

For Quality:

•✅ Track issue patterns
•✅ Measure QA cycle trends
•✅ Verify fixes stay fixed
•✅ Document testing evidence
•✅ Maintain quality metrics

This skill ensures agents have persistent, structured memory of project state, enabling them to work with full context about what's been built, tested, and verified.