/save

description: "Done for now? Run it — you get a session note with what was done, how each done item was verified, where the work stands (branch, dirty files, running servers) and the next step. Optional: commit & push."
argument-hint: "[description] — e.g. 'implemented auth flow' (auto-inferred if omitted)"
user-invocable: true
allowed-tools: Read, Write, Bash, Glob, Grep
model: haiku

You are the great_cto `/save` command. Your job is to create a compact, useful session log that makes `/resume` fast next time. Write, don't ask — infer everything from the conversation and git.

Step 1 — Gather session data (run all in parallel)

# What changed in git during this session
git diff --stat HEAD 2>/dev/null | head -20
git log --oneline --since="8 hours ago" 2>/dev/null | head -10

# Current open tasks
cat .great_cto/tasks.md 2>/dev/null | grep -E "^\- \[.\]" | head -20

# Existing logs (to auto-number)
ls .great_cto/logs/session-*.md 2>/dev/null | wc -l

# Project name + phase
grep -E "^# |^phase:|^primary:" .great_cto/PROJECT.md 2>/dev/null | head -3

Step 2 — Infer session description

If the user provided `$ARGUMENTS` — use that as the session description.

Otherwise infer from: 1. Git commits made during this session (last 8 hours) 2. What was discussed/built in this conversation 3. File changes visible in `git diff --stat`

Keep the description to 3–5 words: `"implemented auth flow"`, `"fixed streaming archetype"`, `"added regulated auto-detect"`.

Step 3 — Write session log

mkdir -p .great_cto/logs
DATE=$(date +%Y-%m-%d)
TIME=$(date +%H:%M)
SLUG=$(echo "<session-description>" | tr ' ' '-' | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9-]//g' | cut -c1-40)
LOG_FILE=".great_cto/logs/session-${DATE}-${SLUG}.md"

Write `$LOG_FILE`:

---
date: <YYYY-MM-DD>
time: <HH:MM>
duration: <estimated from conversation length — "~30 min" / "~2 h">
concepts: [<keyword1>, <keyword2>, <keyword3>]
---

# Session: <description>

## Goal

<one line: what this work is actually for — the real goal, not the first ask if it shifted>

## Start here

1. <the single most concrete first action for the next session — a command to run or a file:line to open>
2. <then this, if there is a clear second step>

## Done

- <bullet: what was actually implemented / fixed / decided>
  Verify: `<exact command a later session can run to prove it>` → <expected result>
- <bullet: second thing>
  Verify: not verified — <why: e.g. needs prod credentials, nothing runnable for prose>

## Decisions

- <any explicit decisions made — e.g. "decided to use X over Y because Z">
  *(none)* — if nothing was explicitly decided

## Pending

- <what was left unfinished or is the clear next step>
- <second pending item if any>

## Files changed

<output of git diff --stat HEAD or "no git changes">

## Commits

<git log --oneline --since="8 hours ago" output, or "no commits this session">

Then append the run state — branch@sha, dirty files, stash, upstream, dev servers still listening. Do NOT type this block by hand: the sha and time in its marker line are what `/resume` checks the note against, and a transcription slip makes every later check wrong.

HS="${CLAUDE_PLUGIN_ROOT:-$(ls -d ~/.claude/plugins/cache/*/great_cto/*/ 2>/dev/null | awk -F'/plugins/cache/' '{split($NF,p,"/"); print p[3], $0}' | sort -V | tail -1 | cut -d' ' -f2- | sed 's|/$||')}/scripts/lib/handoff-state.mjs"
[ -f "$HS" ] || HS="$(pwd)/scripts/lib/handoff-state.mjs"
LOG_FILE=".great_cto/logs/session-<date>-<slug>.md"   # the file you just wrote
{ echo; node "$HS" capture 2>/dev/null || printf '## Run state\n\n- not captured (handoff-state unavailable)\n'; } >> "$LOG_FILE"

It is read-only: the stash is counted, never popped; nothing is staged or committed.

**Verify line rules** (one per Done item — this is what stops "done" being claimed on the note's word):

• The exact command, in backticks, that proves the item **from a fresh session**, and its expected result after `→`:

`` Verify: `node --test tests/lib/auth.test.mjs` → 14 pass ``

• Prefer the narrowest read-only proof: a targeted test file, `git log --oneline -1 -- <file>`, `grep -n <symbol> <file>`.

`/resume` re-runs only cheap read-only commands; a push, deploy, build or full suite is listed, never re-run.

• If nothing was run, or it cannot be run later, say so: `Verify: not verified — <why>`. Never invent a command you did not run.

**Start here rules:** step 1 is an action, not a topic — `run X`, `open file:line and do Y`, `ask the CTO about Z`. If there is no open next action, write `1. ship / merge / deploy <what>`.

**Concepts field rules** (enables `/recall` search):

• Extract 3–6 lowercased keywords that best describe what was worked on
• Prefer specific terms over generic: `"quota-check"` not `"monitoring"`, `"side-panel"` not `"ui"`
• Include: main feature slug, key library/tool names, archetype if relevant
• Examples: `[quota, oauth, board, side-panel]` · `[orchestrator, toml, 3-state-completion]` · `[substantiveness, explicit-gate, ai-security-reviewer]`
• These are the only index entries for `/recall` — choose them to be findable in 6 months

Step 3b — Update brain.md tiers (optional, 60 seconds)

After writing the session log, optionally promote insights to `.great_cto/brain.md`:

**EPISODIC tier** — always update with a 1-2 sentence session summary:

### <YYYY-MM-DD> — <slug>
<1-2 sentence outcome>
Key decisions: <brief>

Rotate: keep only the 5 most recent episodic entries. Drop the oldest when adding the 6th.

**SEMANTIC tier** — promote if a fact was confirmed for the 2nd time this session:

• Architectural fact stated the same way in 2+ sessions → append to `## SEMANTIC → Architecture`
• Tech choice made explicitly → append to `## SEMANTIC → Tech Choices`
• New constraint confirmed → append to `## SEMANTIC → Constraints`

**PROCEDURAL tier** — promote if a workflow was repeated (not first time):

• Release procedure used ag