Running Log

Name: running-log Version: 2.0 Domain: Process Memory, Decision Tracking, Cross-Session Learning Status: Redesigned based on Phase 2 validation findings

Purpose

Maintain a persistent, schema-driven running log that captures:

• Ideas (human quick-capture backlog)
• Consultations (AI-detected external sources)
• Process Memory (AI-detected reasoning patterns)

Creates searchable, auto-organized entry backlog across sessions through three distinct workflows:

1. Human quick-capture (/idea)
2. AI auto-detection (Consultation, Process Memory)
3. Post-processing librarian (/review-backlog)

Critical Design Insight: Human entry workflows differ fundamentally from AI auto-detection workflows. v2.0 separates these cleanly.

Architecture: Three-Component System

Component 1: /idea Command (Human Territory)

Purpose: Ultra-minimal quick capture while working

Workflow:

User: /idea Local copies of Anthropic docs in AI-optimized format
→ Entry created immediately with defaults
→ User continues work

What AI fills automatically:

• Entry ID: #ID-YYYYMMDD-NNN (auto-incremented)
• Timestamp: ISO 8601
• Confidence/Priority: TBD (To Be Determined - evaluated during backlog review)
• Status: Backlog (default for all ideas)
• Tags: AI-generated from description + existing tag taxonomy
• Type: Idea/Note
• Profile: Active profile (e.g., DEVELOPER)

Entry Schema (Ideas):

## Idea/Note | #ID-YYYYMMDD-NNN | [ISO 8601 Timestamp]

**Description**: [User-provided 1-line description]
**Confidence/Priority**: TBD
**Status**: Backlog
**Type**: Idea/Note
**Profile**: [Active Profile]
**Tags**: [AI-generated tags]

---

Why this works:

• Zero friction: User types one line, gets back to work
• No nonsensical prompts for confidence (ideas are captured, not evaluated)
• No status guessing (all ideas start as backlog)
• Consistent tags (AI prevents million inconsistent human tags)
• Evaluation happens later during /review-backlog

Component 2: AI Auto-Detection (AI Territory)

Purpose: Monitor Claude's responses for reasoning patterns worth capturing

Entry Types:

Consultation (External Sources)

AI detects when referencing external knowledge:

• Documentation lookups
• Perplexity/research queries
• User-provided references
• Framework/library citations

Auto-generates:

## Consultation | #ID-YYYYMMDD-NNN | [Timestamp]

**Description**: [What was consulted]
**Source**: [Citation/URL]
**Confidence**: [AI's confidence in source quality: High/Med/Low]
**Status**: Reviewed
**Type**: Consultation
**Profile**: [Active Profile]
**Tags**: [domain, source-type, framework]

---

Process Memory (AI Reasoning Patterns)

AI detects loggable reasoning patterns in its own responses:

Pattern 1: Uncertainty

/uncertainty\s+(on|about|regarding|around)\s+([^.!?]+)/i

→ Logs: What's uncertain, confidence level

Pattern 2: Assumption

/assum(e|ing|ption)\s+(that|about|the)\s+([^.!?]+)/i

→ Logs: Assumption made, validation status

Pattern 3: Confidence Threshold

/confidence\s+(less\s+than|below|<)\s*(\d+)%?/i

→ Logs: Low-confidence item needing validation

Pattern 4: Decision/Fork

/(fork|branch|decision\s+point|chose|decided|rejected)\s+(in|on)?\s*([^.!?]+)/i

→ Logs: Decision made, alternatives considered, rationale

Pattern 5: Critical Signal

/critical|blocker|blocking|must\s+(clarify|understand|verify)/i

→ Logs: Critical issue flagged, requires attention

Auto-generates:

## Process Memory | #ID-YYYYMMDD-NNN | [Timestamp]

**Description**: [Reasoning pattern detected]
**Confidence**: [AI's certainty about this pattern: 0-100%]
**Status**: [Assumed/Validated/Rejected]
**Type**: Process Memory
**Profile**: [Active Profile]
**Tags**: [pattern-type, domain, criticality]
**Pattern Detected**: [Which regex matched]
**Raw Output**: [Exact phrase from Claude's response]

**Extended Context**:
[Why this pattern matters, implications, next steps]

---

Cadence: 3 automatic checks per session

1. Session Start: Continuity from previous session
2. Mid-Toolchain: After floor(tool_count / 3) tools executed
3. Session End: Archive session learnings

Confidence Thresholds (Auto-log only if >= threshold):

• DEVELOPER: 75%
• RESEARCHER: 60%
• ENGINEER: 70%
• DEFAULT: 70%

Noise Filtering:

1. Confidence threshold (above)
2. Entry cap per session (DEVELOPER: 8, RESEARCHER: 12, ENGINEER: 10)
3. Deduplication (Levenshtein 85% similarity suppresses duplicates)

Component 3: /review-backlog Command (Librarian Function)

Purpose: Post-process entries to organize, prioritize, and link

What it does:

1. Relationship Identification: AI analyzes all entries and identifies connections
2. Tag Refinement: Harmonizes tags across entries, suggests taxonomy improvements
3. Prioritization: Reviews TBD priorities, suggests High/Med/Low based on context
4. Linking: Populates Linked To field by finding related entries
5. Auto-Section Generation: Regenerates High-Priority Ideas, Open Risks, Linked Insights

Usage:

/review-backlog                 # Review all entries, suggest actions
/review-backlog --ideas         # Review only ideas (prioritize, link)
/review-backlog --risks         # Review low-confidence items
/review-backlog --link #ID-001  # Find and link entries related to #ID-001

Example Output:

🔍 Backlog Review Results

Ideas Requiring Prioritization (5):
- #ID-20251222-001: Local AI-optimized docs → Suggested: High (aligns with knowledge-base work)
- #ID-20251221-003: Plugin permission system → Suggested: Med (dependent on architecture)

Suggested Links (3):
- #ID-20251222-001 ← #ID-20251221-008 (both reference documentation workflows)
- #ID-20251221-005 → #ID-20251221-003 (decision impacts idea)

Tag Harmonization:
- Rename "docs" → "documentation" (4 entries)
- Merge "anthropic-api" + "anthropic" (2 entries)

Apply changes? [Y/n]

Why separate from capture:

• Humans can't know relationships while capturing ideas mid-work
• Requires full-backlog context to identify patterns
• Deliberate activity, not real-time capture
• AI analyzes relationships humans can't see

File Structure

project/
├── .claude/
│   ├── RUNNING_LOG.md              # Main log (auto-sections + chronological)
│   ├── LAST_ENTRIES.md             # Dedup tracking (20 most recent)
│   └── skills/
│       └── running-log/
│           └── SKILL.md            # This specification
└── [project files]

RUNNING_LOG.md Structure

# Running Log - DEVELOPER Profile

**Created**: [ISO 8601]
**Last Updated**: [ISO 8601]

---

## Auto-Generated Sections

### 🔥 High-Priority Ideas
[Auto-populated from ideas tagged High, status ≠ Done]

### ⚠️ Open Risks / Low-Confidence Items
[Auto-populated from Process Memory with confidence < 60%]

### 🔗 Linked Process Insights
[Auto-populated from entries with Linked To populated]

---

## Entry Backlog

[Entries in reverse chronological order]

---

Commands Summary

/idea [DESCRIPTION]

Quick-capture idea while working. AI fills all other fields with defaults.

/idea Local copies of Anthropic docs in AI-optimized format

/review-backlog [OPTIONS]

Post-process entries: prioritize, link, harmonize tags.

/review-backlog                 # Full review
/review-backlog --ideas         # Ideas only
/review-backlog --risks         # Low-confidence items
/review-backlog --link #ID-001  # Link related entries

/running-log --show [N]

Display last N entries (default: 10).

/running-log --show 5

/running-log --debug

Show last 5 entries with full details including regex detection.

/running-log --debug

Configuration

running_log:
  enabled: true
  file_path: ".claude/RUNNING_LOG.md"
  state_file: ".claude/LAST_ENTRIES.md"

  profiles:
    DEVELOPER:
      threshold: 75
      entry_cap: 8
    RESEARCHER:
      threshold: 60
      entry_cap: 12
    ENGINEER:
      threshold: 70
      entry_cap: 10
    DEFAULT:
      threshold: 70
      entry_cap: 8

  deduplication:
    enabled: true
    levenshtein_threshold: 0.85
    cross_session: true

  idea_defaults:
    confidence: "TBD"
    status: "Backlog"
    auto_tag: true  # AI generates tags from description

Migration from v1.0

Changes:

1. /log command removed → Use /idea [description] instead
2. Interactive prompting removed → /idea is one-line only
3. Confidence/Status for ideas → Now defaults (TBD/Backlog)
4. Tags → AI-generated, not human-entered
5. Linked To → Post-processing via /review-backlog, not capture-time
6. /review command → Renamed to /review-backlog with expanded functions

Existing logs compatible: v1.0 entries remain valid, new entries use v2.0 schema

Design Rationale (Phase 2 Learnings)

Problem 1: Nonsensical Fields for Ideas

v1.0: Asked humans for confidence/priority when capturing ideas Issue: Ideas are captured for later evaluation, not evaluated at capture time v2.0 Fix: Defaults to TBD/Backlog, evaluation happens during /review-backlog

Problem 2: Inconsistent Human Tags

v1.0: Asked humans to enter free-form tags Issue: Million inconsistent tags, none relevant v2.0 Fix: AI auto-generates tags from description + existing taxonomy

Problem 3: Impossible "Linked To" Field

v1.0: Asked humans to provide entry IDs while capturing Issue: Humans don't memorize IDs mid-work v2.0 Fix: AI identifies relationships during /review-backlog post-processing

Problem 4: Monolithic Command

v1.0: Single /log command tried to handle all entry types Issue: Human quick-capture ≠ AI auto-detection workflows v2.0 Fix: Split into /idea (human), auto-detection (AI), /review-backlog (librarian)

Version & Maintenance

Current: v2.0 (Redesigned based on Phase 2 validation) Previous: v1.0 (Phase 1 spec-only)

Expected Updates:

• v2.1: Post-deployment tuning based on real usage
• v3.0: Multi-repository support, cross-project insights

Schema Stability: Core schema stable. Thresholds may adjust based on empirical data.

Next Steps

1. Implement /idea command (minimal quick-capture)
2. Implement /review-backlog command (librarian functions)
3. Update existing /running-log command for display-only modes
4. Test with real workflows across 5+ sessions
5. Collect usage data, tune thresholds

End of SKILL.md Specification v2.0

This specification reflects critical design learnings from Phase 2 validation. The three-component architecture (quick-capture, auto-detection, post-processing) separates human and AI workflows appropriately.