AgentDB State Manager Skill

AgentDB State Manager Skill

Purpose

The AgentDB State Manager provides persistent database storage for workflow state tracking using DuckDB through Claude Code's AgentDB integration. This skill enables:

• Read-only analytics: Complex queries over workflow history without parsing files
• Checkpoint management: Store/​recover context checkpoints at 100K token threshold
• Dependency resolution: Query task dependencies and critical paths
• Metrics analysis: Historical trends, time-in-phase, bottleneck identification

Primary source of truth: TODO_*.md files (AgentDB is an analytics cache)

Primary purpose: Data gathering and analysis

Workflow phase: Cross-phase (Utilities) - All phases (1-6)

When to Use

Use this skill when:

• Querying complex task dependencies or critical paths
• Analyzing workflow metrics (time-in-phase, completion rates)
• Storing context checkpoints at 100K tokens
• Tracking state transitions and historical trends
• Avoiding repetitive TODO file parsing for analytics

Triggered by keywords: "analyze workflow", "query state", "checkpoint", "workflow metrics", "task dependencies"

Integration with Workflow

Phase integration: Cross-phase (Utilities)

This skill integrates with all workflow phases:

Phase 0 (Setup):

• Initialize AgentDB schema on first use
• Load canonical state definitions from workflow-states.json

Phase 1 (Planning - BMAD):

• Track BMAD Q&A responses
• Store epic definitions and requirements

Phase 2 (Specification + Implementation):

• Sync tasks from TODO_*.md to AgentDB
• Query task dependencies for parallel execution
• Track implementation progress

Phase 3 (Quality):

• Store quality gate results
• Track test coverage trends
• Historical quality metrics

Phase 4 (Integration):

• Store as-built deviation data
• Metrics for feedback loop
• Compare planning vs actual

Phase 5 (Release):

• Release workflow state tracking
• Final QA checkpoint data

Phase 6 (Hotfix):

• Hotfix-specific state tracking
• Emergency rollback data

Context checkpoints (all phases):

• Store checkpoint at 100K tokens
• Faster resume with structured queries vs file parsing

Orchestrator integration:

• workflow-orchestrator optionally calls AgentDB for complex queries
• Fallback to file parsing if AgentDB unavailable
• Automatic sync after TODO file updates

Official Documentation Alignment

This skill follows the local workflow system patterns which extend official Claude Code skill specifications:

Official Claude Code Skills:

• Specification: https://docs.claude.com/en/docs/agents-and-tools/agent-skills
• Building Agents: https://docs.claude.com/en/docs/agents-and-tools/building-agents
• AgentDB Documentation: (Reference from TODO_agentdb-prompt-template.md)

Local Pattern Extensions:

file_structure:

• Local: ['SKILL.md', 'CLAUDE.md', 'README.md', 'CHANGELOG.md', 'ARCHIVED/', 'scripts/', 'templates/']
• Official: ['skill.md', 'README.md']
• Rationale: Extended structure supports multi-phase workflow with version tracking, context files, and archived materials

frontmatter:

• Local: YAML with 'name', 'version', 'description' fields
• Official: YAML with 'name', 'description' fields only
• Rationale: 'version' field enables semantic versioning integration with validate_versions.py and UPDATE_CHECKLIST.md workflow

directory_organization:

• Local: scripts/, templates/ subdirectories
• Official: Flat structure with skill.md
• Rationale: Separates Python code (scripts/) from templates (workflow-states.json) for better maintainability

These extensions support the multi-phase workflow system while maintaining compatibility with core Claude Code concepts.

Architecture

Data Flow (Read-Only Analytics Mode)

TODO_*.md (source of truth)
    ↓
sync_todo_to_db.py
    ↓
AgentDB (DuckDB)
    ↓
query_state.py / analyze_metrics.py
    ↓
Analytics results

Session ID Generation

AgentDB requires a session ID for database identification. This skill uses:

Method: Timestamp-based (reproducible)

from datetime import datetime
import hashlib

# Generate session ID from current timestamp
current_time = datetime.utcnow().isoformat()
session_id = hashlib.md5(current_time.encode()).hexdigest()[:16]
# Example: "f8e7d6c5b4a39281"

Rationale: Provides reproducible session IDs across agent invocations within the same timeframe, balancing uniqueness with reproducibility.

Schema Design (Immutable Append-Only)

Core principle: NEVER UPDATE or DELETE records - always INSERT new records

Primary table: workflow_records

CREATE TABLE IF NOT EXISTS workflow_records (
    record_id UUID PRIMARY KEY DEFAULT uuid(),
    record_datetimestamp TIMESTAMP DEFAULT current_timestamp,
    object_id VARCHAR NOT NULL,     -- Stable ID for workflow object
    object_type VARCHAR NOT NULL,   -- 'feature', 'task', 'epic', etc.
    object_state VARCHAR NOT NULL,  -- '20_in-progress', '99_done', etc.
    object_metadata JSON             -- Framework, dependencies, etc.
);

CREATE INDEX idx_records_object
ON workflow_records(object_id, record_datetimestamp DESC);

Current state query pattern:

-- Get latest state for each object
SELECT DISTINCT ON (object_id)
    object_id, object_type, object_state, object_metadata
FROM workflow_records
WHERE object_type = 'task'
ORDER BY object_id, record_datetimestamp DESC;

Usage

1. Initialize AgentDB (First Use)

# Initialize database schema and load state definitions
python .claude/​skills/​agentdb-state-manager/​scripts/​init_database.py

What it does:

• Creates workflow_records table
• Loads workflow-states.json
• Sets up indexes for efficient queries
• Stores session metadata

2. Sync TODO Files to AgentDB

# Sync all TODO_*.md files to database
python .claude/​skills/​agentdb-state-manager/​scripts/​sync_todo_to_db.py

# Sync specific TODO file
python .claude/​skills/​agentdb-state-manager/​scripts/​sync_todo_to_db.py \
  TODO_feature_20251023T143000Z_my-feature.md

What it does:

• Parses YAML frontmatter from TODO files
• Converts to immutable append-only records
• Stores workflow progress, tasks, quality gates
• Preserves full state history

3. Query Current Workflow State

# Get current state of all workflows
python .claude/​skills/​agentdb-state-manager/​scripts/​query_state.py

# Query specific workflow
python .claude/​skills/​agentdb-state-manager/​scripts/​query_state.py \
  --slug my-feature

# Query task dependencies
python .claude/​skills/​agentdb-state-manager/​scripts/​query_state.py \
  --dependencies --task impl_003

What it does:

• Queries latest state for each object
• Resolves task dependencies
• Identifies blocked tasks
• Shows critical path

4. Analyze Workflow Metrics

# Generate metrics report
python .claude/​skills/​agentdb-state-manager/​scripts/​analyze_metrics.py

# Historical trends
python .claude/​skills/​agentdb-state-manager/​scripts/​analyze_metrics.py \
  --trends --days 30

# Bottleneck analysis
python .claude/​skills/​agentdb-state-manager/​scripts/​analyze_metrics.py \
  --bottlenecks

What it does:

• Calculates time-in-phase for workflows
• Identifies bottlenecks and slow phases
• Tracks quality gate pass/​fail rates
• Compares planning estimates vs actual

5. Context Checkpoint Management

# Store checkpoint at 100K tokens
python .claude/​skills/​agentdb-state-manager/​scripts/​checkpoint_manager.py \
  store --todo TODO_feature_*.md

# List available checkpoints
python .claude/​skills/​agentdb-state-manager/​scripts/​checkpoint_manager.py list

# Restore from checkpoint
python .claude/​skills/​agentdb-state-manager/​scripts/​checkpoint_manager.py \
  restore --checkpoint-id <uuid>

What it does:

• Stores complete workflow state to AgentDB
• Records token count, phase, step, last task
• Provides resume instructions
• Faster recovery than parsing TODO files

Best Practices

1. AgentDB as Analytics Cache

✓ DO: Treat TODO_*.md files as source of truth ✗ DON'T: Modify TODO files based on AgentDB state

Rationale: Files are git-tracked and permanent; AgentDB sessions last 24 hours

2. Sync After TODO Updates

✓ DO: Run sync_todo_to_db.py after every TODO file update ✗ DON'T: Let AgentDB state drift from file state

Rationale: AgentDB is a cache - it must stay synchronized

3. Use for Complex Queries Only

✓ DO: Use AgentDB for dependency graphs, metrics, historical analysis ✗ DON'T: Use for simple current state queries (parse TODO file instead)

Rationale: Minimize token overhead - use database for queries that justify the cost

4. Immutable Records

✓ DO: Always INSERT new records for state changes ✗ DON'T: UPDATE or DELETE existing records

Rationale: Preserves full history for temporal analysis

5. Session Lifetime Awareness

✓ DO: Re-initialize at session start if needed ✗ DON'T: Assume AgentDB persists across days

Rationale: 24-hour auto-deletion - treat as ephemeral cache

Scripts Reference

init_database.py

Purpose: Initialize AgentDB schema and load state definitions When to run: First use in a session, or if schema corrupted Token cost: ~300-400 tokens

sync_todo_to_db.py

Purpose: Sync TODO_*.md files to AgentDB When to run: After every TODO file update Token cost: ~200-300 tokens per TODO file

query_state.py

Purpose: Query current workflow state and dependencies When to run: Complex state queries (dependency graphs, critical paths) Token cost: ~100-200 tokens per query

analyze_metrics.py

Purpose: Historical metrics and trend analysis When to run: End of phase, workflow retrospectives Token cost: ~400-600 tokens (complex queries)

checkpoint_manager.py

Purpose: Store/​restore context checkpoints When to run: At 100K token threshold, or before context reset Token cost: ~200-400 tokens (store + verify)

Token Efficiency

Before AgentDB (Manual File Parsing)

Complex dependency query:

1. Read TODO_*.md file (~1,500 tokens)
2. Parse YAML frontmatter (~500 tokens)
3. Iterate through tasks (~1,000 tokens)
4. Resolve dependencies (~800 tokens) Total: ~3,800 tokens

After AgentDB (Database Query)

Same query:

1. Run query_state.py --dependencies (~200 tokens)
2. Parse SQL results (~100 tokens) Total: ~300 tokens

Savings: ~3,500 tokens (92% reduction) for complex queries

Context Checkpoint Recovery

Before AgentDB:

• Parse TODO_*.md (~1,500 tokens)
• Reconstruct state (~1,000 tokens)
• Determine next step (~800 tokens) Total: ~3,300 tokens

After AgentDB:

• Query checkpoint table (~150 tokens)
• Load resume instructions (~100 tokens) Total: ~250 tokens

Savings: ~3,050 tokens (92% reduction)

Integration with Other Skills

workflow-orchestrator

• Calls query_state.py for complex next-step determination
• Uses checkpoint_manager.py at 100K tokens
• Falls back to file parsing if AgentDB unavailable

workflow-utilities

• todo_updater.py triggers sync_todo_to_db.py after updates
• Dual write: update file + sync to database

speckit-author

• Uses AgentDB for as-built metrics (update_asbuilt.py)
• Queries historical planning accuracy

quality-enforcer

• Stores quality gate results to AgentDB
• Tracks coverage trends over time

bmad-planner

• Stores BMAD Q&A responses
• Epic definition tracking

Related Documentation

• CLAUDE.md - Claude Code usage context
• README.md - Human-readable overview
• CHANGELOG.md - Version history
• templates/​workflow-states.json - Canonical state definitions

Related Skills

• workflow-orchestrator - Calls AgentDB for complex queries
• workflow-utilities - Triggers sync after TODO updates
• speckit-author - Uses for as-built metrics
• quality-enforcer - Stores quality gate results
• bmad-planner - Stores planning data

Limitations

1. Session lifetime: AgentDB persists for 24 hours, then auto-deleted
2. Source of truth: TODO_*.md files remain authoritative
3. Sync overhead: ~200-300 tokens per sync operation
4. DuckDB constraints: Optimized for OLAP (analytics), not OLTP (transactions)
5. No vector search: Unlike PostgreSQL pgvector

Academic References

This skill implements the MIT Agent Synchronization Pattern based on:

Meng, E., & Jackson, D. (2025). "What You See Is What It Does: A Structural Pattern for Legible Software." Onward! at SPLASH 2025. arXiv:2508.14511v1. https://arxiv.org/abs/2508.14511

Key concepts from the paper:

• Concepts: Fully independent services (implemented as agents/​worktrees)
• Synchronizations: Event-based rules mediating between services (implemented as agent_synchronizations table)

The pattern improves incrementality, integrity, and transparency in multi-agent workflows.

Version History

v1.0.0 (2025-11-02):

• Initial release
• Read-only analytics mode
• Sync from TODO files to AgentDB
• Complex query support (dependencies, metrics)
• Context checkpoint storage
• All phases (1-6) integration