end

Files (1)

• SKILL.md

SKILL.md (first lines)

# end (/end)

The evening half of the daily lifecycle pair (mirror of `/catchup`). The single front door for
closing a working session. **It triages, then delegates — it does not reimplement** what
`decision-log` and `session-handoff` already do. That delegation is the whole point: one skill
to remember, no duplicated routing logic, no overlap drift.

## Step 1 — TRIAGE: is this worth routing at all?

Judge by what was *learned or changed* this session, not just by whether files moved.

**Scratch session** — close clean only when ALL of these hold: a quick question or explanation,
with no decision, no discovery/gotcha, no pivot, no config/tool-surface change, and no file work
you did this session. → Say plainly: **"Scratch session — nothing worth routing. Closing clean."**
Optionally offer *one* line: "Want a single-line log entry anyway? (y/n)". Then **stop** — no
delegation, no manufactured insights.

**Substantive — route it (Step 2)** if ANY of these hold, *even with zero file edits*:

- A decision, pivot, or discovery/gotcha the user flagged.
- A **config / tool-surface / security change** — installed or configured an MCP, changed a
  setting or permission, set up a token or auth scope. These persist beyond the session, so they
  must leave at least a one-line environment breadcrumb (in the daily log or a memory entry) —
  **with any secret/token value redacted: refer to it by name only (e.g. "the Firecrawl API
  key"), and never reprint the literal secret value anywhere, even while explaining that you're
  redacting it** (workspace no-secrets rule). A config change is the opposite of scratch
  precisely because it outlives the session.
- A new cross-session fact, a multi-step build, or the user explicitly asks to capture.
- Files you created/edited *this session* (≥1 meaningful change).

**Do NOT count as substance:** pre-existing uncommitted/dirty state you didn't touch this session,
or generated/transient artifacts (`__pycache__/`, build output, lockfile churn). Flag them as a
housekeeping note if useful, but on their own they don't make a session substantive.

## Step 2 — Detect context, then route ONLY what applies

Walk up from cwd to classify where you are.

**First, reconcile git against STATUS — this is what stops drift at the source.** Before routing any STATUS/log work, in each scaffolded project touched this session:

- Run `git log --oneline -10` + `git status --short`, and read STATUS.md's `_Last updated: YYYY-MM-DD_` line.
- Run `git log --since="<that date>" --oneline` (and eyeball the date of `git log -1`). **If commits landed after STATUS's last-updated date — or commits this session moved past what STATUS's "What's next" describes — STATUS is behind and the delta MUST be captured.** This is the exact failure that breaks tomorrow's `/catchup`: work shipped in the same session as a decision, and STATUS still reads "about to start."
- Don't rely only on what surfaced in conversation. A session that *executed* a plan often shipped more than was discussed — the commit subjects since the STATUS date are the ground truth for what actually changed. Feed that delta into the `decision-log` hand-off so STATUS's "What's next" reflects what's genuinely left, not what was already done.
- If `git status` shows uncommitted content you touched this session, flag it in the close-out so it's not silently lost (the user commits; you don't).

Then route each surfaced piece by delegating:

| What surfaced this session | Route → delegate to | Only when |
|---|---|---|
| Project state changed (tasks done, milestone, new "next") | **`decision-log`** Update Mode → STATUS + daily log | always, for any project |
| A decision worth recording | **`decision-log`** `/decide` (new ADR) | a deliberate trade-off was made |
| A reversal of a prior decision | **`decision-log`** `/supersede NNNN` | this overrides an accepted ADR |
| A cross-session fact (status, scope, contact changed) | **memory** entry under `~/.claude/projects/<encoded-cwd>/memory/` + MEMORY.md line | the fact will matter next session **and clears the specificity gate below** |
| project-specific fact OR reusable Team-KB pattern | **`session-handoff`** (`/wrap`) | cwd is inside the SU Workspace (detect `ExampleApp/` or `Team Knowledge Base/` walking up) |
| Where you stopped / next step | breadcrumb | always — make sure the log's **Next** line and STATUS **What's next** are set so tomorrow's `/catchup` reads cleanly |

Rules that keep routing honest:
- **Delegate by invoking, don't re-author.** For STATUS/log/ADR work, **invoke the
  `decision-log` skill** and let it produce and gate its own drafts — do NOT hand-write the
  ADR / STATUS / log markdown yourself inside `/end`. Re-authoring it here silently re-encodes
  decision-log's templates and drifts the moment that skill changes. Your job is the triage,
  the routing decision, and the hand-off — not the artifact. Same for Workspace knowledge:
  invoke `session-handoff`, don't reproduce its four-block output.
- **Scope the `session-handoff` hand-off to knowledge only** — SU `learnings/`, Team-KB `wiki/`,
  and memory. STATUS / daily-log / ADRs are `decision-log`'s territory. If you let
  `session-handoff` *also* draft project STATUS/ADRs, you double-propose the same artifact.
  One owner per artifact.
- Route **only** what applies to where you are. In a bare external code project, the
  SU-learnings / Team-KB routes simply don't fire — STATUS/log + memory + breadcrumb are the
  whole job. Don't offer Workspace routes outside the Workspace.
- If multiple pieces surfaced, handle each separately — don't cram a pattern into a log entry
  or a decision into memory.
- **Specificity gate before anything graduates to memory.** A memory entry must be a *specific,
  reusable* fact that will still be actionable cold next session — not a vague activity summary.
  Keep: "the Confluence export fails closed on inherited read-restrictions via `restrictions.py`."
  Reject: "worked on the export tool today" (that's a log line, not a memory). If the candidate
  doesn't name a concrete system/file/decision/contact and a reason it matters later, route it to
  the daily log instead and write nothing to memory. This keeps `MEMORY.md` high-signal.

## Step 3 — Bootstrap offer (project has no scaffolding yet)

If this is a code project being built but `docs/STATUS.md` + `docs/log/` don't exist, and there's
something worth tracking, **offer** (don't force):

> "This project has no STATUS/log yet. Want me to scaffold it (via `decision-log` Init Mode) so
> `/catchup` and `/end` have something durable to read? (y/n)"

On **yes** → run `decision-log` Init Mode (it builds STATUS + decisions/ + today's log from
existing context, draft-first). On **no** → fall back to a single session-draft breadcrumb and
move on. Never scaffold silently.

**Missing VISION in an already-scaffolded project.** If `docs/STATUS.md` + `docs/decisions/`
already exist but there's no `docs/VISION.md` (the enduring charter — the top layer), and this
was a substantive session, **offer** (don't force):

> "This project has STATUS/ADRs but no VISION.md (its enduring north star). Want me to author it
> now via `decision-log` (it'll ask ~3 questions, then load-only forever after)? (y/n)"

On **yes** → run `decision-log` (its Step 1 backfill routes straight into the one-time VISION
interview, draft-first). On **no** → leave it; the session-start hook and `/catchup` will keep
the gap visible next time. Author once, never nag mid-session.

## Step 4 — Approval gate, no commit

- Everything is **draft-first**: show proposed writes (delegated skills handle their own
  draft/approve prompts) and wait for explicit approval before anything hits disk.
- **Never `git add` / `git commit`.** Consistent with the user's git discipline and with every
  other skill in this harness. Leave staging to the user.

## Step 5 — Clear the routed session-draft(s)

If this close-out consumed one or more unattended captures from `~/.claude/session-drafts/`
(the SessionEnd-hook output), then **after the user approves the writes**, move those draft
files into `~/.claude/session-drafts/routed/` (create it if missing). This is what stops
`/catchup` from re-surfacing them as "pending" forever. If nothing was approved/written, leave
the drafts in place. Never delete a draft — archiving to `routed/` preserves the trail.

## Relationship to the rest of the harness

From julianhernandez2155/claude-code-harness, MIT.

More from julianhernandez2155/claude-code-harness