Add a wrap-up skill to use after an orchestrated or interactive session

[williamthorsen]

Problem

After orchestrated coding runs and interactive sessions, there is recurring housekeeping work that depends on the user remembering to invoke individual skills (/create-ticket, /create-devlog, /summarize-chat, etc.). In practice, this means wrap-up activities are often skipped, and valuable institutional knowledge — deferred items, discoveries about the codebase, insights from difficult bug fixes — is lost.

The cost compounds over time: deferred items never become tickets, surprising findings aren't documented, and the same issues are re-discovered in later sessions.

Design considerations

Dispatcher vs. specialized skills

Decision: single entry point, context-adaptive behavior.

A single /wrap-up skill that detects the session type and adjusts its recommendations. This follows the established pattern where /orchestrate-dev and /orchestrate-review are thin wrappers around the orchestrate engine.

Why not multiple specialized skills (/wrap-up-orchestrated, /wrap-up-interactive):

• Cognitive overhead: the user must remember which variant to invoke
• Blurred boundaries: many sessions are hybrid (start interactive, switch to orchestrated)
• Duplicate logic: 70%+ of wrap-up activities are shared across session types
• Discoverability: one skill is easier to make habitual than three

Auto-detection vs. explicit tagging

Decision: auto-detect deferred items from conversation context.

The skill scans conversation history for deferred items using heuristic keywords ("out of scope", "deferred", "TODO", "follow-up", etc.). This may surface false positives, but the user filters them in the checklist confirmation step. This is preferable to explicit tagging because it requires no discipline during the session and catches items that weren't formally deferred.

Autonomous vs. prompted execution

Decision: prompted (semi-autonomous).

The skill presents a tailored checklist and waits for user confirmation before executing any actions. The user can add, remove, or modify items. This keeps the user in control while eliminating the cognitive burden of remembering what needs doing.

Proposed solution

Skill phases

Phase 1: Session assessment

Inspect context to classify the session and identify wrap-up candidates:

Signal	Source	Detection method
Orchestrated run	run-index.json in artifact dir	Check for run artifacts matching current branch/ticket
Deferred items	Run summary or conversation	Parse "Deferred items" section from run-summary; scan conversation for heuristic keywords
Code changes	Git	git diff against merge base; uncommitted/unpushed state
Discoveries	Conversation	Scan for insights, surprising findings, pattern documentation
Review findings	Review artifacts or conversation	Unresolved findings from review cycle
Session type	Composite signal	Orchestrated / interactive dev / research / review

Phase 2: Checklist presentation

Present the user with a tailored checklist of recommended activities. Example:

## Session wrap-up

Based on this session, here's what I recommend:

### Deferred items → tickets
- [ ] "Add retry logic to webhook delivery" (mentioned as out of scope)
- [ ] "Migrate legacy date format in API responses" (flagged by reviewer, deferred)

### Discoveries → documentation
- [ ] Record insight: factory layer naming convention mismatch (ticket comment)
- [ ] Record fix: race condition in run-index writes (devlog)

### Session artifacts
- [ ] Create devlog for this session's work
- [ ] Summarize conversation

### Code hygiene
- [ ] Summarize changes (for PR preparation)

Which of these should I proceed with? (You can adjust the list.)

Phase 3: Execution

Delegate selected activities to existing skills:

Activity	Delegates to
Create ticket for deferred item	/create-ticket
Record discovery as ticket comment	gh issue comment
Create devlog	/create-devlog
Summarize conversation	/summarize-chat
Summarize changes	/summarize-change
Record skill mistake	/record-skill-mistake

Phase 4: Summary

Report what was done: tickets created (with links), artifacts saved (with paths), items skipped.

Session-type adaptations

The skill adjusts its default checklist based on detected session type:

Session type	Default activities
Orchestrated dev	Deferred items → tickets (from run-summary), discoveries → comments, devlog
Interactive dev	Deferred items → tickets (from conversation), discoveries, devlog, summarize changes
Research/exploration	Discoveries → comments or devlog, summarize chat
Review	Unresolved findings → tickets, discoveries

Orchestration integration: prompted Phase 6

After the orchestrator writes the run-summary (Phase 5), it presents the wrap-up checklist and waits for user confirmation before executing. This is the highest-leverage integration point because orchestrated runs already track deferred items structurally.

Key design principles

1. Assessment before action — never auto-execute; always present a checklist for user confirmation
2. Delegate, don't duplicate — every action routes through an existing skill
3. Context-adaptive, not context-rigid — detect session type but let the user override
4. Idempotent-safe — don't re-create tickets that already exist
5. Conversational memory — scan conversation history, not just git state, because deferred items and discoveries often live only in the dialogue

Implementation plan

Step 1: Create wrap-up/SKILL.md

Create packages/agents/content/skills/wrap-up/SKILL.md with:

• Assessment logic (session type detection, deferred item scanning)
• Checklist generation and presentation
• Delegation to existing skills for execution
• Summary reporting

Step 2: Integrate as prompted Phase 6 in orchestration pipeline

Modify packages/agents/content/skills/orchestrate/SKILL.md to add an optional wrap-up phase after Phase 5 (Summary), triggered when the run-summary contains deferred items or notable insights.

Step 3: Add cross-references from related skills

Update /orchestrate-dev and /summarize-chat to mention /wrap-up as a recommended follow-up.

Acceptance criteria

• Must: Detect and present deferred items from conversation history and run-summary artifacts
• Must: Delegate to existing skills (/create-ticket, /create-devlog, etc.) for all actions
• Must: Present checklist for user confirmation before executing any action
• Should: Adapt default checklist based on detected session type (orchestrated, interactive, research, review)
• Should: Report results with ticket links and artifact paths
• Nice: Integrate as prompted Phase 6 in orchestration pipeline