# Evening

> End-of-day recap that proves what actually got done today — aggregates today's Claude Code sessions, git commits, and beads activity into an honest accomplishment log. The counter to the "I did nothing today" feeling. Use when user says evening, end of day, wrap up, recap today, "what did I actually do today", "did I do anything today", or feels like the day was a mess/wasted.

- Skill: `thatmike1/evening` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add thatmike1/evening`
- Raw SKILL.md: https://api.skillmd.com/api/skills/thatmike1/evening/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: thatmike1 (https://skillmd.com/u/thatmike1)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/thatmike1/evening

---


# /evening

Produce an honest end-of-day accomplishment log. The sibling of /morning: morning plans the day forward, evening proves the day backward. The user often invokes this feeling like the day was wasted — the job is to show the receipts, not to flatter.

## Mode Detection

| Signal | Mode |
|--------|------|
| `/evening` | **global** — everything today (default) |
| `/evening repo` / `/evening here` / "what did we do HERE" or similar this-project phrasing | **repo** — only the current project's day |

Unlike /morning, global is the default — the end-of-day question is usually "what did I do overall". In global mode, still pass the current project's stream first if it had activity.

## Workflow

### Step 1: Gather

Reuses the /morning gather script (sibling skill in the same repo) with the `today` range:

```bash
node <skills-repo>/morning/scripts/gather-context.mjs --mode <repo|global> --range today [--project <cwd>]
```

Supplement with anything visible in the current conversation (work done in this very session won't be in the session index yet — include it from context).

Each CC session reports a **Tools** line (e.g. `Edit×12, Write×3, Bash×40, Agent×2, Skill×1`) — read it as receipts:
- `Edit`/`Write`/`Bash` counts → **Shipped** (files changed, commands run) even when the prose is thin
- `Agent`/`Task` counts → directed-agent work (directing is doing)
- `Skill`/`mcp__*` counts → tooling/infra/automation, the **Invisible work** the "did nothing" feeling erases
This is the hard signal that turns a "felt unproductive" day into a list of artifacts.

### Step 1b: The hours

```bash
node <skills-repo>/evening/scripts/compute-hours.mjs [--project <cwd>] [--exclude <this-session-id>] [--json]
```

Always pass `--exclude` with the current session's id — writing the recap is not work the day should be billed for. Get the id from the transcript path in your own context; skip the flag only if you genuinely can't find it, and say so.

The script slices the day into quarter-hours, counts a quarter-hour as active for a session when it emitted at least one record inside it, then shares each one out among whatever was live in it. Two splits come back: equal shares, and shares weighted by how busy each session was. **They should land close together — a line where they diverge sharply is one to describe rather than quote.** Both sum to the day's real active wall-clock, so they can be logged as-is.

Per-session output gives you the active windows, event count, cwd branch, and how much of the time was background agents. Sessions are not streams: fold several sessions into one stream when they're the same piece of work, and sum their split hours. Do not sum the `solo` column — it double-counts overlap on purpose.

Read the numbers as a floor. Time on a phone, a build the user ran themselves, and thinking away from the keyboard are all invisible to this. Say so once rather than presenting the total as measured fact.

### Step 2: Synthesize the receipts

Group into a timeline of work streams, then for each stream pull out:

- **Shipped**: commits, closed beads issues, merged branches — the hard receipts
- **Decided**: decisions made, approaches settled, things de-risked (a settled architecture question is output even with zero diff)
- **Invisible work**: triage, planning, issue filing, tooling/skills/infra, seeds, env setup, reviews of agent output — name it explicitly; this is the work the "did nothing" feeling erases
- **Open loops**: what's mid-flight, parked, or handed to an AFK instance — with where it stands

### Step 3: The verdict

End with 2-4 sentences of honest day assessment:

- Count the receipts ("4 commits, 3 issues closed, 2 filed, 1 skill shipped")
- Use the hours to explain the day's *feel*, not to grade it — several threads sharing the same quarter-hours is why a full day can read as a blur, and that's a scheduling fact, not a failure
- Name the day's shape ("scattered morning, locked-in afternoon" is a pattern, not a failure)
- If the day genuinely was thin, say so plainly and point at the single most useful thing it produced — don't inflate
- If meta/tooling work dominated, say why it counts (it compounds; tomorrow is faster)

## Rules

- Receipts over vibes: every claim links to an artifact (commit hash, issue id, file, doc)
- Chronological-ish, but group by stream, not by hour — nobody needs minute-level accounting
- Don't moralize about distraction gaps; mention them only if the user asks where time went
- Include work done by directed agents/instances today — directing is doing
- If context is thin, say so honestly rather than padding
- Keep it scannable: short sections, bold the artifacts

## Output Format

See [references/output-format.md](references/output-format.md).

