Session Close

Purpose

Close a session by reflecting on outcomes and feeding structured data to the CLI. The CLI performs all writes atomically (session index, patterns, coaching, session state, profile). The skill only does inference: reflect and produce structured output.

Mastery Levels (ShuHaRi)

Experience level affects verbosity of the handoff message, not the operations.

Steps (2)

Step 1: Reflect & Produce Structured Output

Use inference to reflect on the session:

•Summary: What was accomplished? (1-2 sentences)
•Session type: feature, research, maintenance, infrastructure, ideation
•Outcomes: List of concrete deliverables
•Patterns: Any new learnings? (check against existing — query if needed)
•Corrections: Any behavioral corrections observed? (what + lesson)
•Coaching: Reflect on the working relationship (see below)
•Current work: Epic, story, phase, branch for continuity
•Pending: Decisions, blockers, next actions
•Tangents: Check conversation for ideas → add to dev/parking-lot.md

Write the structured output as a YAML state file:

yaml

# /tmp/session-output.yaml
summary: "Session protocol implementation"
type: feature
outcomes:
  - "Tasks 1-6 complete"
  - "136 tests passing"
patterns:
  - description: "Pattern description here"
    context: "tag1,tag2"
    type: process
corrections:
  - what: "Behavioral observation"
    lesson: "Lesson learned"
coaching:                                # Only include fields that changed
  trust_level: "developing"              # new → developing → established → deep
  strengths:
    - "structured thinking"
    - "design discipline"
  growth_edge: "async patterns"
  autonomy: "high within defined scope"
  relationship:
    quality: "productive"                # new → productive → established → deep
    trajectory: "growing"                # starting → growing → stable → deepening
  communication_notes:
    - "prefers direct, concise"
current_work:
  epic: E15
  story: S15.7
  phase: implement
  branch: story/s15.7/session-protocol
pending:
  decisions: []
  blockers: []
  next_actions:
    - "Continue with Task 7"
notes: "Any free-form notes"

Step 2: Feed CLI

bash

rai session close --state-file /tmp/session-output.yaml --project "$(pwd)"

This single command atomically:

•Records session in sessions/index.jsonl
•Appends patterns to patterns.jsonl
•Updates coaching (corrections + observations) in ~/.rai/developer.yaml
•Writes .raise/rai/session-state.yaml
•Clears current_session in profile

Alternative (simple close): For quick sessions without state file:

bash

rai session close --summary "Quick fix session" --type maintenance --project "$(pwd)"

With inline pattern/correction:

bash

rai session close \
  --summary "Session description" \
  --type feature \
  --pattern "New pattern learned" \
  --correction "What happened" \
  --correction-lesson "What to do instead" \
  --project "$(pwd)"

After the CLI call, output a brief handoff:

code

## Next Session
**Continue:** [next step]
**Open:** [unresolved questions, if any]

Output

All writes are done by the CLI in Step 2 — the skill does NOT call separate memory/telemetry commands.

File	Update	Writer
`.raise/rai/personal/sessions/index.jsonl`	Session record	CLI
`.raise/rai/memory/patterns.jsonl`	New patterns	CLI
`~/.rai/developer.yaml`	Coaching + clear session	CLI
`.raise/rai/session-state.yaml`	Working state	CLI
`dev/parking-lot.md`	Tangents	Skill (Edit)

Notes

•One CLI call does all data plumbing — no separate add-session/add-pattern/emit-session
•Idempotent: can close multiple times (second close overwrites with more current data)
•State file is the richest path; CLI flags are for simple/quick closes

•Calibration (if stories completed): still run separately:

bash

rai memory add-calibration {story_id} --name "Name" -s {size} -a {actual_mins}

References

•Complement: /rai-session-start
•Session state: .raise/rai/session-state.yaml
•Memory: .raise/rai/memory/
•Tangents: dev/parking-lot.md