conversation-dump - SKILL.md Agent Skill

name: conversation-dump description: Use when analyzing conversation patterns — extracts dialog from Claude Code or Codex CLI history, classifies each user message across 6 academic dimensions (Bloom's cognitive level, Graesser question depth, Paul & Elder reasoning probe, Walton presupposition quality, Long & Sato discourse function, Graesser generation mechanism), and outputs tagged dialog reports

Dialog Analysis

Analyze all conversation sessions from a chosen source (Claude Code or Codex CLI) in three phases: batch extraction, topic classification, and deep 6-dimension analysis.

Phase 1 — Extract

Ask the user to choose a source: claude or codex.

List and extract ALL sessions in batch using the Python script:

python skills/conversation-dump/extract_dialog.py list --source claude --project all
python skills/conversation-dump/extract_dialog.py list --source codex

Extract every listed session and save the JSON output to a staging directory:

mkdir -p docs/dialog/<source>/extracted
python skills/conversation-dump/extract_dialog.py extract --source <source> --session <id> > docs/dialog/<source>/extracted/<session-id>.json

Run extractions in parallel (batch shell commands). Skip sessions that yield 0 user turns after filtering.

Phase 2 — Classify by Topic

Dispatch fast available agents in parallel to classify each extracted session by conversation topic. Each agent receives a batch of ~20 extracted JSON files and returns a topic label for each.

Topic taxonomy (closed set):

Slug	Description
`skill-design`	Designing or refining skill definitions
`brainstorming`	Research ideation, /brainstorm-ideas sessions
`code-review`	Reviewing code or PRs
`debugging`	Fixing bugs, diagnosing failures
`documentation`	Writing or editing docs, READMEs
`ci-cd`	CI/CD pipelines, GitHub Actions, deployment
`refactoring`	Restructuring existing code
`research`	Literature search, paper discussion
`plugin-management`	Plugin install, config, marketplace
`slide-creation`	Presentations, Typst/LaTeX slides
`paper-review`	Reviewing or analyzing academic papers
`testing`	Writing or running tests
`configuration`	Settings, environment, permissions
`project-setup`	Scaffolding, init, dependencies
`automated`	No real human messages (system/skill invocations only)
`other`	Does not fit any above — agent must propose a slug

Topic classification rules:

Read the user messages in each session (first 3-5 turns are usually enough)
Assign ONE slug from the taxonomy above
Only use other when no existing slug fits; include a proposed new slug and one-line description
After all agents return, review other entries: merge into existing slugs where possible, or promote a new slug if 3+ sessions share it

After all agents return, organize files into topic folders:

mkdir -p docs/dialog/<source>/<topic>
mv docs/dialog/<source>/extracted/<session-id>.json docs/dialog/<source>/<topic>/

Write a topic index to docs/dialog/<source>/topics.md:

# Topic Index

| Topic | Sessions | Description |
|-------|----------|-------------|
| skill-design | 12 | Designing or refining skill definitions |
| brainstorming | 8 | Research ideation using /brainstorm-ideas |
| ... | ... | ... |
| **Total** | **N** | |

Present the topic index to the user and ask which topics to analyze in depth (or "all").

Phase 3 — Deep Analysis

For each session in the selected topics, classify ALL user messages across 6 dimensions. Use parallel agents (batch ~5 sessions per agent).

The 6 dimensions:

Prefix	Dimension	Tags
`bloom:`	Cognitive Level	remember, understand, apply, analyze, evaluate, create
`depth:`	Question Depth	shallow/intermediate/deep + Graesser category (e.g., `deep/causal-antecedent`). For non-questions: use the depth of the cognitive task implied by the message.
`probe:`	Reasoning Probe	clarification, assumption-probe, evidence-probe, perspective, implication, meta-question, none
`presup:`	Presupposition Quality	sound, existential-gap, factive-gap, loaded, complex, ambiguous, missing-context, leading
`discourse:`	Discourse Function	referential, display, rhetorical, confirmation-check, clarification-request, indirect-request
`mechanism:`	Generation Mechanism	knowledge-deficit, common-ground, action-coordination, conversation-control, exploration, debugging, undetermined

For full classification criteria, decision rules, tie-breaking rules, and examples, see classification-criteria.md.

Quick classification guidelines:

When two bloom levels seem equally valid, pick the higher one (the message is at least that complex)
depth always includes a Graesser sub-category after the slash (e.g., deep/causal-antecedent, shallow/verification)
probe:none is the default for non-probing messages — do not force a probe type
presup:sound is the default for well-formed messages — only flag issues when genuinely present
When mechanism is ambiguous between exploration and debugging, check whether the user has a specific failure in mind (debugging) or is open-ended (exploration)

Classifying non-question messages: Commands, confirmations, and statements carry the same dimensions:

A command like "fix the tests" → bloom:apply, depth:deep/instrumental, probe:none, presup:sound, discourse:indirect-request, mechanism:action-coordination
A confirmation like "yes" or "option A" → bloom:remember, depth:shallow/verification, probe:none, presup:sound, discourse:confirmation-check, mechanism:common-ground
Feedback like "no, not that approach" → bloom:evaluate, depth:deep/judgmental, probe:none, presup:sound, discourse:referential, mechanism:conversation-control

For any presupposition issue or non-obvious classification, add a brief Note explaining the reasoning.

Phase 4 — Output

Per-session reports: Overwrite the extracted JSON file at docs/dialog/<source>/<topic>/<session-id>.json with the enriched version containing tags. This replaces the raw Phase 1 output with the fully classified version.

Schema:

{
  "source": "<claude|codex>",
  "session_id": "<id>",
  "topic": "<topic slug>",
  "timestamp": "<ISO 8601>",
  "turns": [
    {
      "index": 1,
      "user": "<user message text>",
      "assistant": "<assistant response, truncated>",
      "tags": {
        "bloom": "analyze",
        "depth": "deep/causal-antecedent",
        "probe": "assumption-probe",
        "presup": "sound",
        "discourse": "referential",
        "mechanism": "exploration"
      },
      "note": "<explanation if non-obvious, otherwise null>"
    }
  ]
}

For any presupposition issue or non-obvious classification, populate the note field for that turn.

Aggregate report: After all sessions are processed, write docs/dialog/<source>/summary.md with:

Total sessions analyzed (by topic, and how many were skipped as automated/empty)
Combined message count across all sessions
Aggregate distribution for each dimension (counts + percentages)
Per-topic breakdown (which topics show which patterns)
Presupposition issues found (session + turn numbers)
Top patterns (2-3 sentences characterizing the user's overall conversation style across sessions)