Conversation Summary

Conversation Summary

Transform long conversations into structured granular analyses and a cohesive narrative synthesis. Designed for conversations too large for a single context window.

Workflow

Phase 1: Preparation

1. Assess the input. Read the file to determine format and size. 2. Chunk the conversation into segments of ~60-80K chars each. Split at natural boundaries (time gaps, topic shifts, message breaks). Never split mid-message. 3. Save chunks to chunks/chunk_1.txt through chunks/chunk_N.txt. 4. Determine chunk count from total size. Aim for 5-10 chunks. Fewer than 5 loses granularity; more than 10 creates too many analysis files.

For ChatGPT JSON exports, parse the JSON to extract messages first, then chunk the plain text. If the conversation has clear date/topic breaks, prefer those as chunk boundaries.

Phase 2: Parallel Granular Analysis

Spawn one `joes-toolkit:conversation-chunk-analyzer` agent per chunk using run_in_background: true. Each agent reads one chunk and produces a standardized 8-section analysis.

Task(
  subagent_type="joes-toolkit:conversation-chunk-analyzer",
  run_in_background=true,
  prompt="Analyze chunk {N} of {TOTAL}. Context: {BRIEF_DESCRIPTION}. {CONTINUITY_CONTEXT}. Read: {CHUNK_PATH}. Write analysis to: {OUTPUT_PATH}"
)

Key points:

• The agent produces an 8-section format: Timeline & Context, Key Events, Exact Words, Advice Given vs Acted On, Physical/Setup Details, Participant Observations, Emotional Arc, Open Threads
• Sections are adaptable by conversation type — see references/conversation-types.md
• The previous chunk's last 2 lines provide continuity context for the next chunk's agent
• Exact quotes are non-negotiable — 10-20 per chunk minimum

Phase 3: Collect and Verify

Each agent writes its full analysis to the output file and returns only a brief summary (chunk number, quote count, top theme, open threads). This keeps the orchestrator's context small even when many agents finish simultaneously.

1. Wait for all agents to complete (use TaskOutput with block: true). 2. Confirm each agent reported success and its output file path. 3. Verify all analysis files exist with Glob.

Phase 4: Narrative Synthesis

Spawn one `joes-toolkit:conversation-synthesizer` agent with access to all analysis files. It reads every analysis and produces a cohesive narrative synthesis.

Task(
  subagent_type="joes-toolkit:conversation-synthesizer",
  prompt="Synthesize analyses into a narrative. Analysis files: {LIST_PATHS}. Write to: {SYNTHESIS_PATH}"
)

Key points:

• Structure emerges from content — don't force a template
• Weave in exact quotes from the analyses
• Literary quality — engaging narrative, not a clinical report
• Aim for 5,000-8,000 words depending on source length
• Every claim traceable to a specific analysis

File Structure

{working-directory}/
├── chunks/
│   ├── chunk_1.txt
│   ├── chunk_1_analysis.md
│   ├── chunk_2.txt
│   ├── chunk_2_analysis.md
│   ├── ...
│   ├── chunk_N.txt
│   └── chunk_N_analysis.md
└── synthesis.md

Key Principles

1. Exact quotes are non-negotiable. The participant's own words reveal more than any paraphrase. 2. Granularity before synthesis. The per-chunk analyses are the foundation. The synthesis is built on them, not instead of them. 3. Parallel execution is essential. Each chunk analysis is independent — always run them concurrently. 4. Adapt the template, don't force it. Drop irrelevant sections, add domain-specific ones. 5. The synthesis should be literary. Not a report — a narrative. 6. Opus for synthesis, sonnet for analysis. Detail extraction = sonnet. Creative narrative construction = opus.

Examples

# Basic usage
/conversation-summary ~/exports/chatgpt-export.json

# Specify chunk count
/conversation-summary ~/interviews/transcript.md --chunks 6

# Skip to synthesis if analyses already exist
/conversation-summary ~/project/chunks/ --synthesis-only

Notes

• Chunk boundaries must respect message boundaries — never split mid-message
• Total processing time scales with chunk count (parallel) + synthesis (sequential): expect 3-8 minutes for a typical long conversation
• For batch processing a directory of conversations, process each file independently using the same workflow

Chunk Analysis Prompt Template

Use this template when spawning per-chunk analysis agents.

Agent Prompt

You are analyzing chunk {N} of {TOTAL} from a long conversation. Your job is to produce a deeply granular analysis — not a summary. Extract specifics: exact quotes, precise observations, concrete details.

Context: {BRIEF_DESCRIPTION_OF_CONVERSATION}

{If N > 1: "The previous chunk ended with: {LAST_2_LINES_OF_PREVIOUS_CHUNK}"}

Read the chunk file at: {CHUNK_PATH}

Produce your analysis in this exact 8-section format:

## Timeline & Context
When does this chunk sit in the overall story? What's the state of affairs at the start? What period does it cover?

## Key Events (chronological, detailed)
Number each event. Include specific details — what exactly happened, what was said, what changed. Don't summarize; narrate with precision. Include behavioral observations, decisions made, and turning points.

## Exact Words (selected quotes)
Pull 10-20 of the most revealing, emotional, or important verbatim quotes. Use blockquotes. Choose quotes that capture voice, reveal character, show emotion, or mark turning points. Include typos/informal spelling as-is.

## Advice/Guidance Given vs Acted On
If the conversation involves any advice, recommendations, or suggestions: what was recommended, what was actually done, and where did the participants diverge from guidance? Note when someone pushed back and why.

## Physical/Setup Details
Any concrete details about the environment, equipment, tools, systems, locations, or logistics mentioned. These ground the analysis in specifics.

## Participant Observations
Specific behavioral notes for each participant. What patterns emerge? What personality traits are visible? How do they interact differently with different people/topics?

## Emotional Arc
Map the emotional journey through this chunk. What's the emotional state at entry, how does it shift, what triggers the shifts? Use evidence from tone, word choice, and explicit statements.

## Open Threads
What questions are unresolved at the end of this chunk? What's been set up but not yet paid off? What will the next chunk likely need to address?

Write the analysis to: {OUTPUT_PATH}

Section Customization

The 8 sections above are defaults. Adapt to fit the conversation type:

Critical Guidance

• Exact Words is non-negotiable. Without verbatim quotes the analysis becomes generic. 10-20 quotes minimum per chunk.
• Narrate, don't summarize. Key Events should read like a detailed account, not bullet-point highlights.
• Preserve voice. Include typos, informal spelling, slang as-is. These reveal character.
• Track divergence. When advice is given but not followed, that's always significant. Note why they diverged.

Conversation Type Adaptations

ChatGPT/AI Conversation Exports

• Often very long (500K+ chars)
• Look for the AI's role: advisor, collaborator, sounding board
• The human's relationship with the AI is itself a thread worth analyzing
• Export formats: JSON (ChatGPT), markdown, plain text
• For ChatGPT JSON exports, parse the JSON to extract messages first, then chunk the plain text

Interview Transcripts

• Replace "Advice Given vs Acted On" with "Questions & Responses"
• Focus on what the interviewee reveals vs. what they're asked
• Track interviewer technique as a separate thread

Group Chats / Slack Exports

• Track multiple participants separately in "Participant Observations"
• Note alliance formation, disagreements, who defers to whom
• Thread structure may need different chunking (by thread, not by time)

Meeting Notes / Minutes

• Focus on decisions made, action items, and who committed to what
• "Open Threads" becomes "Action Items & Follow-ups"
• Shorter synthesis, more structured output

Support / Troubleshooting Logs

• Replace "Emotional Arc" with "Resolution Progress"
• Track what was tried, what failed, what finally worked
• The sequence of attempted solutions is the narrative

Narrative Synthesis Prompt Template

Use this template when spawning the synthesis agent after all chunk analyses are complete.

Agent Prompt

You have {N} granular analyses of a long conversation. Read all of them, then write a narrative synthesis that tells the complete story.

Analysis files:
{LIST_ALL_ANALYSIS_FILE_PATHS}

Write to: {SYNTHESIS_PATH}

Guidelines:
- Structure the synthesis into clear sections that emerge from the content (don't force a template — let the material dictate the structure)
- Common sections that work well:
  - The Full Arc (complete narrative from start to finish)
  - The Cast (character portraits of key participants)
  - Phase Transitions (major turning points)
  - The Emotional Journey
  - Recurring Threads (patterns that repeat across the conversation)
  - What Worked and What Didn't
  - Where Things Stand (current state at conversation's end)
- Weave in exact quotes from the analyses — they're the life of the document
- Include specific details (equipment, timestamps, behavioral patterns) naturally in the prose
- Preserve literary quality — this should read as engaging long-form narrative, not a clinical report
- Aim for roughly 5,000-8,000 words depending on source length
- Every claim should be traceable to a specific analysis

Key Principles

• Literary, not clinical. The synthesis is a narrative, not a report. The reader should feel the emotional journey and meet participants as characters.
• Quotes are the life of the document. Weave exact quotes from the analyses into the prose. Without them, the synthesis loses its power.
• Let structure emerge. Don't force sections. If the conversation has a strong technical thread, create a section for it. If there's no clear "cast," skip character portraits.
• Details ground the narrative. Equipment, timestamps, locations, specific behavioral patterns — these make the synthesis feel real rather than abstract.
• Traceable claims. Every assertion should be supportable by evidence in the granular analyses.

Model Routing

Use opus for synthesis. The chunk analyses are detail extraction (sonnet handles well). The synthesis requires creative narrative construction and cross-chunk pattern recognition — opus is better here.