# Wrap it up Human Guide

## What This Is For
Session conclusion and handoff generator. It gives the agent a clearer input/output frame for wrap it up: what context to ask for, what decisions to make, and what usable artifact to return.

Use this as a human-readable version of the Wrap it up agent skill. It is meant for marketers, operators, founders, and other non-coders who want the workflow without reading agent-specific implementation instructions.

## When To Use This
- Use this when you need a repeatable process for wrap it up.
- Use this when the task needs judgment, examples, constraints, or a clear output format rather than a one-off prompt.
- Use this when you want to hand an AI assistant enough context to produce a usable marketing artifact.

## When Not To Use This
- Do not use this when you only need a quick factual answer.
- Do not use this when the work depends on private data you cannot share with the assistant.
- Do not use this as a replacement for legal, compliance, financial, or medical review.

## What You Need Before Starting
- The goal or business outcome you want.
- The audience, customer segment, or market context.
- Any source material the assistant should respect, such as notes, briefs, examples, URLs, or brand guidance.
- Constraints such as tone, length, channel, deadline, region, or approval requirements.
- A clear definition of what a good final answer should look like.

## Step-By-Step Workflow
1. State the job clearly: "Use the Wrap it up guide to help me with..."
2. Add context: audience, goal, offer, channel, source material, and constraints.
3. Ask the assistant to identify missing inputs before producing the final output.
4. Have the assistant follow the skill-specific guidance below.
5. Review the result against the final checklist and ask for revisions where needed.

## Skill-Specific Guidance
- Files changed (staged and unstaged)
- Commit range (first and last commit touched this session)
- Diff summary (files touched, insertions, deletions)
- The user's original request(s) and how they evolved
- Every explicit decision made and the rationale
- Every error encountered and how it was resolved
- Files created, modified, or deleted (cross-reference with git)
- Patterns or conventions established
- Work that was explicitly deferred or left incomplete
- Project structure (run `tree` at depth 2-3 if not already known)
- Key configuration files and their purpose
- Active dependencies and versions

## Decision Points And Nuance
The original skill emphasizes: Overview, Output Locations, Workflow, Phase 1: Gather Session Intelligence, Phase 2: Produce the Session Log, Phase 3: Update Codebase Documentation, Phase 4: Produce the Handoff Document, Phase 5: Verify and Summarize, Quick Reference, Keywords.

Use these questions to steer the work:
- What is the intended audience or buyer?
- What source material must be preserved?
- What should the assistant optimize for: clarity, persuasion, accuracy, speed, creativity, or conversion?
- What examples represent the desired quality bar?
- What should the assistant avoid?

## Common Mistakes
- Before writing any output, collect the following data. Use scripts and shell commands to avoid consuming context window on raw data.
- Load `references/session-log-format.md` for the complete format specification. At minimum, the log must include:
- **Read-before-write rule**: Always read the current state of a documentation file before editing it. Never overwrite documentation blindly.
- Additive by default — append or insert; never remove existing content unless it is factually incorrect
- Minimal and precise — add only what a future reader needs; do not narrate
- **Active Context** — The 3-5 most important facts the next agent must know

## Copy-And-Paste Prompt
```text
Use the Wrap it up human guide.

My goal:
[Describe the business outcome]

Audience:
[Describe who this is for]

Context and source material:
[Paste notes, examples, links, or existing copy]

Constraints:
[Tone, length, channel, timeline, must-include items, must-avoid items]

Before producing the final output, ask me for any missing information that would materially improve the result.
```

## Final Checklist
- [ ] The output matches the original goal.
- [ ] The audience and context are reflected in the answer.
- [ ] Important constraints and source material were preserved.
- [ ] The assistant made the relevant decisions explicit.
- [ ] The final artifact is ready to use, review, or hand to the next person.

## Source
This guide was generated from the Block skill entry for `wrap-it-up`.

## Source Skill Notes
These notes preserve the nuance from the original skill. Use them as supporting reference when the workflow above feels too generic.

# Wrap It Up

## Overview

Decompose the current working session into three structured, persistent outputs designed for maximum continuity and minimum onboarding cost across sessions. Every output is written to a standard location under `.goose/session/` so the companion `boot-up` skill can discover them automatically.

## Output Locations

All outputs are written relative to the project root. When no project root is discernible, use the current working directory.

| Output | Path | Purpose |
|---|---|---|
| Session Log | `.goose/session/SESSION_LOG.md` | Chronological, factual record of the session |
| Handoff Doc | `.goose/session/HANDOFF.md` | Agent-optimized brief for the next session |
| Codebase Docs | Project-appropriate locations (README.md, CHANGELOG.md, `docs/`, etc.) | Updated living documentation |

The `assets/` directory in this skill contains template files that can be referenced for structure. The `references/` directory contains detailed format specifications.

## Workflow

### Phase 1: Gather Session Intelligence

Before writing any output, collect the following data. Use scripts and shell commands to avoid consuming context window on raw data.

**Git intelligence** — Run `scripts/gather-session-stats.sh` from the project root. This script captures:
- Files changed (staged and unstaged)
- Commit range (first and last commit touched this session)
- Diff summary (files touched, insertions, deletions)
- Branch and remote status

If the script is not available or the project is not a git repo, gather equivalent information manually with individual commands.

**Conversation intelligence** — Extract from the current conversation:
- The user's original request(s) and how they evolved
- Every explicit decision made and the rationale
- Every error encountered and how it was resolved
- Files created, modified, or deleted (cross-reference with git)
- Patterns or conventions established
- Work that was explicitly deferred or left incomplete

**Codebase intelligence** — Note the current state of:
- Project structure (run `tree` at depth 2-3 if not already known)
- Key configuration files and their purpose
- Active dependencies and versions
- Environment-specific setup (API keys needed, services running, ports in use)

### Phase 2: Produce the Session Log

Write `.goose/session/SESSION_LOG.md`. This is the authoritative factual record.

Load `references/session-log-format.md` for the complete format specification. At minimum, the log must include:

1. **Header**: Session date, duration (approximate), project/repo
2. **Objectives**: What the user set out to accomplish
3. **Chronological Log**: Time-ordered entries covering every significant action
   - Each entry: timestamp (approximate), action taken, files affected, outcome
   - Mark decisions with `[DECISION]` and errors with `[ERROR]` / `[RESOLVED]`
4. **Key Decisions**: Extracted list of every decision with rationale
5. **Errors & Resolutions**: Every error encountered and its fix
6. **File Manifest**: Every file created or modified, with a one-line summary of changes
7. **Deferred Work**: Explicit list of items mentioned but not completed
8. **Environment Notes**: Services running, ports used, credentials needed, gotchas

### Phase 3: Update Codebase Documentation

Identify all living documentation that should reflect the session's changes. Load `references/doc-update-guide.md` for detailed heuristics.

**Read-before-write rule**: Always read the current state of a documentation file before editing it. Never overwrite documentation blindly.

**Files to consider updating**:
- `README.md` — If new features, setup steps, or usage patterns were added
- `CHANGELOG.md` — If this project maintains one, append an entry
- `docs/` directory — Any architecture docs, API docs, or guides affected by changes
- `CLAUDE.md` — If project conventions or instructions for AI agents changed
- `.cursor/rules/` or similar — If project-specific AI rules were modified

**Update principles**:
- Additive by default — append or insert; never remove existing content unless it is factually incorrect
- Minimal and precise — add only what a future reader needs; do not narrate
- Cross-reference the session log for full context (`see .goose/session/SESSION_LOG.md`)