Debug Log Analysis

Mode: Cognitive/Prompt-Driven — No standalone utility script; use via agent context.

Debug Log Analysis

Structured workflow for extracting actionable signal from Claude Code session debug logs. Use during reflection cycles, incident response, or when diagnosing agent failures.

When to Use

• After any session with unexpected agent failures or stalls
• When reflection-agent needs telemetry to contextualize task completions
• When debugging hook errors that appear opaque in task outputs
• When the router reports "agent completed but didn't call TaskUpdate"

Prerequisites

The scripts/reduce-debug-log.mjs script auto-detects the most recent log when no file argument is provided. It copies the log to .tmp/ and produces a reduced version there.

Step 0: Determine Analysis Mode

Two modes are available:

Auto mode (recommended): Let pnpm debug:reduce find and process the most recent log automatically.

Manual mode: Provide a specific session UUID or log file path.

Step 1: Locate and Reduce the Debug Log

IMPORTANT: Always find the most recent log dynamically. NEVER hardcode session UUIDs.

Auto mode (preferred)

# Auto-detect most recent log, copy to .tmp/, reduce in place
cd /c/dev/projects/agent-studio && node scripts/reduce-debug-log.mjs 2>&1

# The script prints:
# Auto-detected debug log: /home/user/.claude/debug/{session-uuid}.txt
# Copied to: .tmp/{session-uuid}.txt
# Original: N lines -> kept (issue-like): M -> ... -> after dedupe: K
# Output: .tmp/{session-uuid}-reduced.txt

Capture the output paths from the script output for subsequent steps.

Manual mode (when a specific session is needed)

# List recent debug logs sorted by modification time (most recent first)
ls -t "$HOME/.claude/debug/"*.txt 2>/dev/null | head -5

# Or on Windows (Git Bash):
ls -t "$USERPROFILE/.claude/debug/"*.txt 2>/dev/null | head -5

Pick the target log path, then:

# Copy to temp (never operate on the original)
mkdir -p .claude/context/tmp
cp "$HOME/.claude/debug/{session-uuid}.txt" ".claude/context/tmp/debug-session-copy.txt"

# Run reducer with explicit output path
node scripts/reduce-debug-log.mjs \
  ".claude/context/tmp/debug-session-copy.txt" \
  --output ".claude/context/tmp/debug-session-reduced.txt"

Verify reduction succeeded

# Check sizes
wc -l ".claude/context/tmp/debug-session-copy.txt"
wc -l ".claude/context/tmp/debug-session-reduced.txt"

Expected: reduced file is 1-5% of original line count (98%+ noise removed).

Step 2: Compare Original vs Reduced

Calculate what was filtered out to understand the filter quality:

ORIGINAL_LINES=$(wc -l < ".claude/context/tmp/debug-session-copy.txt")
REDUCED_LINES=$(wc -l < ".claude/context/tmp/debug-session-reduced.txt")
echo "Original: $ORIGINAL_LINES lines | Reduced: $REDUCED_LINES lines"
echo "Kept: $(echo "scale=1; $REDUCED_LINES * 100 / $ORIGINAL_LINES" | bc)%"

Note any anomalies — e.g., if reduction is less than 90%, the session had unusually many errors.

Step 3: Read Reduced Log

Read .claude/context/tmp/debug-session-reduced.txt in full.

Step 4: Categorize Error Patterns in Reduced Log

For each line in the reduced log, classify into:

Step 5: Cross-Reference Top Errors in Full Log

For the top 3 most frequent error categories:

1. Grep the FULL (unreduced) log copy for the error signature 2. Find the 10 lines before and after each occurrence 3. Identify: which tool call triggered it, which agent was running, what it was trying to do

# Use the full copy (not the original, not the reduced)
grep -n "PreToolUse:Write" ".claude/context/tmp/debug-session-copy.txt" | head -30
grep -n "File does not exist" ".claude/context/tmp/debug-session-copy.txt" | head -30
grep -n "timeout" ".claude/context/tmp/debug-session-copy.txt" -i | head -30

Step 6: Cleanup Temp Files

After analysis, clean up the working copy (keep the reduced file for the report if needed):

rm -f ".claude/context/tmp/debug-session-copy.txt"
# Optionally keep the reduced file for reference; delete when done
# rm -f ".claude/context/tmp/debug-session-reduced.txt"

Step 7: Produce Structured Report

Write to .claude/context/reports/reflections/debug-log-analysis-{YYYY-MM-DD}.md:

<!-- Agent: reflection-agent | Skill: debug-log-analysis | Session: {YYYY-MM-DD} -->

# Debug Log Analysis — {YYYY-MM-DD}

**Source log:** {path to original log — auto-detected or provided}
**Session UUID:** {session-uuid extracted from filename}
**Log statistics:**

- Original: {N} lines / {bytes} bytes
- Reduced: {M} lines / {bytes} bytes
- Reduction ratio: {X}%
  **Analysis timestamp:** {ISO-8601}

## Error Summary

| Category           | Count | Severity | Root Cause |
| ------------------ | ----- | -------- | ---------- |
| Hook Block (Write) | N     | CRITICAL | ...        |
| Read Miss          | N     | HIGH     | ...        |
| ...                |       |          |            |

## Top 3 Deep Dives

### 1. {Most frequent error}

**Frequency:** N occurrences
**First occurrence:** line {N}, timestamp {T}
**Context:** {what the agent was doing}
**Root cause:** {why it happened}
**Fix:** {concrete recommendation}

### 2. ...

### 3. ...

## Observability Gaps Found

List any gaps where the log entry doesn't have enough info to diagnose the error.

## Recommendations

- [ ] Immediate P0: {fix}
- [ ] P1: {fix}
- [ ] P2: {fix}

Known Observability Gaps (Agent-Studio v2026-02)

These gaps exist in the current debug log format:

1. Hook rejection body not logged — When unified-creator-guard.cjs blocks a Write, the rejection reason is not captured in the debug log. You see PreToolUse:Write blocked but not WHY.

• Workaround: Check process.stderr output separately; or read the hook source to infer the rule that fired.

2. Agent identity missing from error lines — Error lines don't include which spawned agent caused the error.

• Workaround: Correlate timestamps with task spawn/completion entries.

3. Read failure file path omitted — File does not exist lines don't always include the file path.

• Workaround: Look at the preceding tool call line for the attempted path.

4. Streaming stalls unattributed — A 5+ minute stall appears as a timestamp gap with no context.

• Workaround: The tool call preceding the gap is the likely cause.

5. No success logging — Only failures are prominent. Successful tool calls produce minimal log entries.

• Workaround: Count total tool uses from task summary metadata.

Integration with Reflection

Reflection agents should invoke this skill for HIGH-priority reflection requests:

// In reflection agent, for high-priority triggers:
if (priority === 'high' && debugLogPath) {
  Skill({ skill: 'debug-log-analysis' });
  // Include findings in reflection report
}

Iron Laws

1. ALWAYS copy the debug log before any analysis — never operate on the original file; in-place operations corrupt the forensic artifact. 2. NEVER report a root cause based on a single grep match — always read at least 10 lines of context before and after the match to understand what the agent was actually doing. 3. ALWAYS run the reducer script (Step 2) before attempting to read a full debug log — unfiltered debug logs contain 98%+ noise that obscures real signals. 4. NEVER skip the structured error report (Step 6) — an informal verbal summary is not a deliverable; the markdown report is required for reflection-agent to incorporate findings. 5. ALWAYS write new recurring error patterns to .claude/context/memory/issues.md — patterns not written to memory will recur invisibly across sessions.

Anti-Patterns

Memory Protocol (MANDATORY)

After completing:

• New error pattern found → .claude/context/memory/issues.md
• New observability gap found → .claude/context/memory/issues.md
• Pattern that recurs across sessions → .claude/context/memory/learnings.md

ASSUME INTERRUPTION: If it's not in memory, it didn't happen.

Invoke the debug-log-analysis skill and follow it exactly as presented to you

debug-log-analysis Research Requirements

Generated: 2026-02-28

Skill Description

'Structured debug log analysis for Claude Code sessions — copy log, run reducer, extract error patterns, correlate with full log, produce observability report. Fills 5 identified gaps: hook error body capture, agent identity, file path tracking, stall correlation, success visibility.'

Research Areas

• Current best practices for debug-log-analysis
• Industry standards and tooling
• Integration patterns

Source References

• To be populated by skill-updater research phase

debug-log-analysis Rules

Purpose

'Structured debug log analysis for Claude Code sessions — copy log, run reducer, extract error patterns, correlate with full log, produce observability report. Fills 5 identified gaps: hook error body capture, agent identity, file path tracking, stall correlation, success visibility.'

Best Practices

• Follow established patterns
• Validate inputs at boundaries

Integration Points

See SKILL.md for complete documentation.

debug-log-analysis Implementation Template

Goal

• Define target outcome and acceptance criteria.

TDD

1. Red 2. Green 3. Refactor

Verification

• lint
• format
• targeted tests