Skill: athola/nm-imbue-catchup (version 1.0.2)

--- name: catchup description: | Summarize recent changes from git history for context recovery, handoffs, and sprint review version: 1.9.5 triggers: - summarization - context-acquisition - insights - follow-ups metadata: {"openclaw": {"homepage": "https://github.com/athola/claude-night-market/tree/master/plugins/imbue", "emoji": "\ud83e\udd9e", "requires": {"config": ["night-market.imbue:proof-of-work"]}}} source: claude-night-market source_plugin: imbue --- > **Night Market Skill** — ported from [claude-night-market/imbue](https://github.com/athola/claude-night-market/tree/master/plugins/imbue). For the full experience with agents, hooks, and commands, install the Claude Code plugin. ## Table of Contents - [Overview](#overview) - [When to Use](#when-to-use) - [Activation](#activation) - [Progressive Loading](#progressive-loading) - [4-Step Methodology](#4-step-methodology) - [Output Format](#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 - 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 + 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 ## Troubleshooting ### Common Issues **Command not found** Ensure all dependencies are installed and in PATH **Permission errors** Check file permissions and run with appropriate privileges **Unexpected behavior** Enable verbose logging with `--verbose` flag

path: modules/document-analysis-patterns.md
content: ---
name: document-analysis-patterns
description: Document and meeting notes analysis patterns for catchup
parent_skill: imbue:catchup
category: analysis-patterns
tags: [documents, meetings, notes, tracking]
estimated_tokens: 300
---

# 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 + key points
- List decisions/actions rather than narrative
- Use bullet points for scanning efficiency


path: modules/git-catchup-patterns.md
content: ---
name: git-catchup-patterns
description: Git-specific commands and patterns for catchup analysis
parent_skill: imbue:catchup
category: technical-patterns
tags: [git, version-control, delta-capture]
estimated_tokens: 400
---

# Git Catchup Patterns

## Git Context Establishment

Use these commands to establish git repository context:

```bash
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:

```bash
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:

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

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

**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:

```bash
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 actionable items.**

## Common Patterns

**Feature Branch Catchup:**
```bash
BASE=$(git merge-base main HEAD)
git diff --stat main...HEAD
git log --oneline main...HEAD
```

**Release Catchup:**
```bash
git diff --stat v1.0.0...v1.1.0
git log --oneline --graph v1.0.0...v1.1.0
```

**Daily Standup Catchup:**
```bash
git log --since="yesterday" --oneline --all
git diff --stat HEAD@{yesterday}...HEAD
```


path: modules/log-analysis-patterns.md
content: ---
name: log-analysis-patterns
description: System log and event stream analysis patterns for catchup
parent_skill: imbue:catchup
category: analysis-patterns
tags: [logs, events, monitoring, time-series]
estimated_tokens: 300
---

# 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:**
```bash
# 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:**
```bash
# 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 + line numbers for detail
- Summarize patterns rather than listing every entry
- Defer deep debugging to specialized tools/skills


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: clean (LOW)