Catchup

Table of Contents

• Overview
• When to Use
• Activation
• Progressive Loading
• 4-Step Methodology
• Output Format

Catchup Analysis Methodology

Overview

Structured method for quickly understanding recent changes in git repositories, meeting notes, sprint progress, document revisions, or system logs. Answers "what changed and what matters?" efficiently.

When To Use

• Joining ongoing work or returning after absence
• Before planning or reviewing handoffs
• Any "what happened and what's next" context

When NOT To Use

• Doing detailed

diff analysis - use diff-analysis instead

• Full code review needed
• use review-core instead

Activation

Keywords: catchup, summary, status, progress, context, handoff Cues: "get me up to speed", "current status", "summarize progress"

Progressive Loading

Load modules based on context:

Git: Load modules/git-catchup-patterns.md for git commands. Consider sanctum:git-workspace-review for initial data gathering.

Documents/Notes: Load modules/document-analysis-patterns.md for meeting notes, sprint tracking, document revisions.

Logs/Events: Load modules/log-analysis-patterns.md for time-series and metric analysis.

Always Available: imbue:proof-of-work, TodoWrite workflow, structured output.

Required TodoWrite Items

1. catchup:context-confirmed - Boundaries established 2. catchup:delta-captured - Changes enumerated 3. catchup:insights-extracted - Themes identified 4. catchup:followups-recorded - Actions captured

4-Step Methodology

Step 1: Confirm Context

Define scope (git branch, sprint, meetings), baseline (last state), and current target. See modules for commands.

Step 2: Capture Delta

Enumerate changed items with metrics. Prioritize source/config/docs over generated artifacts. See modules for strategies.

Step 3: Extract Insights

Per item: What (change), Why (motivation), Implications (tests/risks/deps). Rollup into themes.

Step 4: Record Follow-ups

Capture: Tests, Documentation, Reviews, Blockers, Questions. If none, state explicitly.

Output Format

## Summary
[2-3 sentence theme + risk overview]

## Key Changes
- [Item]: [what/why/implication]

## Follow-ups
- [ ] [Action with owner]

## Blockers/Questions
- [Item requiring resolution]

Verification: Run the command with --help flag to verify availability.

Integration

Use imbue:diff-analysis for risk assessment, imbue:proof-of-work for reproducibility, sanctum:git-workspace-review for git data. Feed to brainstorming or writing-plans as needed.

Token Conservation

Reference paths and lines (don't reproduce). Summarize outputs. Defer deep analysis. Use progressive loading.

Exit Criteria

• Four TodoWrite items completed
• Context/delta/insights/follow-ups captured
• Stakeholders understand state without re-reading sources

Document Analysis Patterns

Meeting Notes Analysis

When catching up on meeting notes or discussions:

Context Establishment:

• Identify date range: "Last meeting I attended was [date]"
• Note participants involved
• Identify meeting series or project name

Delta Capture:

• List topics discussed (agenda items)
• Enumerate decisions made
• Identify action items assigned
• Note open questions or blocked items

Insight Extraction:

• What changed since last meeting?
• What decisions affect ongoing work?
• What consensus emerged on contentious topics?
• What new information affects project direction?

Sprint/Ticket Catchup Patterns

For Jira, GitHub Issues, or similar tracking systems:

Context:

• Last sprint/milestone reviewed
• Current sprint/milestone
• Team velocity or capacity changes

Delta:

• Tickets completed since baseline
• Tickets in progress
• New tickets added to backlog
• Priority shifts or re-ordering

Insights:

• Velocity trends (ahead/behind schedule?)
• Risk indicators (blocked tickets, dependencies)
• Scope changes (new requirements, deferred items)
• Team capacity changes

Document Revision Tracking

When reviewing evolving documents (specs, designs, RFCs):

Context:

• Last version reviewed (version number, date, or commit)
• Current version
• Document type and audience

Delta:

• Sections added, modified, or removed
• Comments or review feedback incorporated
• Status changes (draft → review → approved)

Insights:

• Requirements changes and rationale
• Design decisions made or reversed
• Unresolved discussions or open questions
• Approval status and blockers

Generic Document Delta Patterns

Efficient Enumeration:

• Focus on substantive changes (ignore typos, formatting)
• Identify authors/contributors to understand perspective
• Note timestamp for context
• Track references to external decisions or dependencies

Token Conservation:

• Summarize content rather than quoting verbatim
• Reference section headings and key points
• List decisions/actions rather than narrative
• Use bullet points for scanning efficiency

Git Catchup Patterns

Git Context Establishment

Use these commands to establish git repository context:

pwd                                                 # Show current directory
git status -sb | head -n 1                          # Show current branch and status
git rev-parse --abbrev-ref --symbolic-full-name @{u}  # Show the upstream branch, if one is being tracked

These help answer:

• Where am I working?
• What branch am I on?
• Is this branch tracking a remote?

Git Delta Capture

Efficiently capture changes between states:

git diff --stat ${BASE}...HEAD                      # Show summary statistics
git diff --name-only ${BASE}...HEAD                 # List changed files
git log --oneline ${BASE}...HEAD                    # Show commit history

Key Patterns:

• Use --stat for high-level overview (files changed, insertions/deletions)
• Use --name-only for enumeration without content
• Use ... three-dot syntax to show changes on current branch since divergence

Semantic Delta Capture (sem)

When sem is available (see leyline:sem-integration), enhance delta capture with entity-level diffs:

# Entity-level change summary across commits
sem diff --format json ${BASE}...HEAD

# Track a specific entity's evolution
sem log <entity-name>

Note: sem may not support three-dot (...) range

syntax directly. If sem diff fails with a range,

resolve the merge base first:

BASE=$(git merge-base main HEAD) then pass

sem diff --format json $BASE HEAD.

Key advantages over git diff --stat:

• Shows which functions/classes changed, not just files
• Distinguishes additions from modifications from renames
• sem log tracks an entity across renames

When sem is unavailable, fall back to the git commands in the section above.

Git-Specific Insights Extraction

Targeted inspection commands:

git show --stat <commit>                            # Show specific commit changes
git diff ${BASE}...HEAD -- path/to/file             # Examine specific file changes
git log -p --follow -- path/to/file                 # File history with patches

Efficient Reading:

• Use git show for commit-level understanding
• Use git diff with file paths for focused analysis
• Avoid git log -p without limits (token-heavy)

Integration with Sanctum

Before running catchup analysis, use sanctum:git-workspace-review to gather:

• Repository confirmation (pwd, branch)
• Status overview (staged vs unstaged)
• Diff statistics
• Diff details

Then proceed with catchup-specific insight extraction and follow-up identification.

Sanctum provides the raw data; catchup extracts insights and concrete next steps.

Common Patterns

Feature Branch Catchup:

BASE=$(git merge-base main HEAD)
git diff --stat main...HEAD
git log --oneline main...HEAD

Release Catchup:

git diff --stat v1.0.0...v1.1.0
git log --oneline --graph v1.0.0...v1.1.0

Daily Standup Catchup:

git log --since="yesterday" --oneline --all
git diff --stat HEAD@{yesterday}...HEAD

Log Analysis Patterns

System Log Catchup

When catching up on system behavior via logs:

Context Establishment:

• Identify time window: "Last check was [timestamp]"
• Note log sources (application, system, service)
• Identify environment (prod, staging, dev)
• Baseline normal behavior

Delta Capture:

• Count log entries by severity (ERROR, WARN, INFO)
• Enumerate unique error types
• Identify anomalies or patterns
• Note frequency changes (spike, drop, stable)

Efficient Commands:

# Count by severity
grep -c "ERROR" logfile.log
grep -c "WARN" logfile.log

# Unique error messages
grep "ERROR" logfile.log | cut -d: -f3 | sort | uniq -c | sort -rn | head -20

# Time-based filtering
awk '$1 >= "2025-12-04" && $1 <= "2025-12-05"' logfile.log

Event Stream Analysis

For application events, audit logs, or metrics:

Context:

• Event source and schema
• Baseline event rate
• Time window of interest
• Expected vs actual patterns

Delta:

• New event types introduced
• Event rate changes (throughput)
• Failed vs successful event ratios
• Outliers or anomalies

Insights:

• Performance trends (response times, throughput)
• Error patterns (recurring, transient, progressive)
• User behavior changes
• System health indicators

Time-Window Analysis

Comparing time windows:

# Events today vs yesterday
comm -13 <(grep "2025-12-04" events.log | sort) \
         <(grep "2025-12-05" events.log | sort)

# Hourly breakdown
awk '{print substr($1,12,2)}' logfile.log | sort | uniq -c

Pattern Detection:

• Periodic patterns (hourly, daily, weekly cycles)
• Correlation between events
• Cascading failures
• Recovery patterns

Metric-Based Catchup

When logs include metrics or measurements:

Delta:

• Min/max/avg changes
• Percentile shifts (p50, p95, p99)
• Threshold violations
• Trend direction (improving, degrading, stable)

Insights:

• Capacity planning needs
• Performance regression sources
• Resource utilization trends
• SLA compliance status

Token Conservation

• Use aggregation (counts, uniques) over raw logs
• Sample representative entries, don't reproduce all
• Reference log files and line numbers for detail
• Summarize patterns rather than listing every entry
• Defer deep debugging to specialized tools/skills