Rowan Starter

{
  "name": "rowan-starter",
  "version": "0.3.0",
  "description": "A working Claude Code setup, packaged. The lean-OS
    pattern + two self-improving hooks (start-load, stop-reflect) + a
    boundary guard that asks before you publish + one setup skill.",
  "author": { "name": "Rowan Advisory", "url": "https://rowanadvisory.co.nz" }
}

{
  "SessionStart": [
    { "hooks": [ { "type": "command",
        "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-context.sh" } ] }
  ],
  "Stop": [
    { "hooks": [ { "type": "command",
        "command": "${CLAUDE_PLUGIN_ROOT}/hooks/session-reflect.sh" } ] }
  ],
  "PreToolUse": [
    { "matcher": "Bash", "hooks": [ { "type": "command",
        "command": "${CLAUDE_PLUGIN_ROOT}/hooks/publish-guard.sh" } ] }
  ]
}

#!/bin/bash
# SessionStart — load the right context every session, deterministically.
today=$(date +%Y-%m-%d)
ctx="Today is ${today}. File durable learnings (facts, decisions,
  preferences, state changes) into your memory/context layer as they
  occur, don't wait to be asked. Your context files are the source of
  truth; if anything conflicts, they win."
# hand that text to Claude Code as session context
/usr/bin/python3 - "$ctx" <<'PY'
import json, sys
print(json.dumps({"hookSpecificOutput": {"hookEventName":
  "SessionStart", "additionalContext": sys.argv[1]}}))
PY
exit 0

#!/bin/bash
# Stop — the self-improving half. Reflects once per working
# session. Loop-guarded + debounced. It only PROPOSES.
input=$(cat)
# rail 1: if already in a reflection pass, stop (no loop)
active=$(printf '%s' "$input" | /usr/bin/python3 -c \
  'import sys,json; print(json.load(sys.stdin).get("stop_hook_active", False))')
if [ "$active" = "True" ]; then exit 0; fi
# rail 2: fire at most once every 30 min (1800s)
stamp="$HOME/.claude/.last-reflect-rowan"
now=$(date +%s); last=0
[ -f "$stamp" ] && last=$(cat "$stamp" 2>/dev/null || echo 0)
if [ $(( now - last )) -lt 1800 ]; then exit 0; fi
echo "$now" > "$stamp"
# the proposal handed back to Claude Code
/usr/bin/python3 <<'PY'
import json
reason = ("Session reflection. Before ending: scan this session for
  anything DURABLE: a changed fact, a decision, a new preference, a
  state change worth keeping. If yes, file it now, then stop. If
  nothing durable changed, just stop, don't invent something.")
print(json.dumps({"decision": "block", "reason": reason}))
PY
exit 0

#!/bin/bash
# PreToolUse(Bash) — the boundary guard. Ask before a command
# that PUBLISHES. Generic by design; make it yours.
input=$(cat)
cmd=$(printf '%s' "$input" | /usr/bin/python3 -c \
  'import sys,json; print(json.load(sys.stdin).get("tool_input",{}).get("command",""))')
case "$cmd" in
  *"git push"*)
    /usr/bin/python3 <<'PY'
import json
print(json.dumps({"hookSpecificOutput": {
  "hookEventName": "PreToolUse",
  "permissionDecision": "ask",
  "permissionDecisionReason": "This publishes (git push). Confirm you
    want to send it out. Publishing should be your call, not automatic."}}))
PY
    exit 0 ;;
esac
exit 0

--- name: substrate-setup ---

# Substrate setup — a guided walk-through
A conversation you run FOR the user: you ask, you draft, you
write the files, you confirm. They never edit a file by hand.
Run it one step at a time.

Before you start
  Say what you'll build: one short "who I am, how I work" file
  Claude reads every session. Ask where it lives (default
  ~/.claude/CLAUDE.md). Don't stall on the choice.

1. Learn who they are
   Ask, plainly: what do you do · who do you serve · how do
   you like to be spoken to. Wait for answers.

2. Draft the always-loaded layer (keep it lean)
   who I am · how I work · what's protected. Show the draft,
   fix it together, write it only once they say it's right.
   Rule: if a fact doesn't change most answers, it does NOT
   go here.

3. The hooks already do their job
   Nothing to touch. Offer to reword the session-start line
   for them only if they want it.

4. The load-on-demand layer (when ready)
   deeper IP, projects, people, tools in a context/ folder the
   identity file points to. Pulled in only when its task comes
   up. Offer to stub it; don't fill it on day one.

5. Keeping it true
   overwrite the one file as it sharpens; keep a "what's
   retired" list. No stale second copy.

Stop once the always-loaded file is right. That's the core.

Rowan Starter (v0.3, seed)

A working Claude Code setup, packaged so someone inherits the
harness on day one instead of rebuilding it. Free to take.

What's in it: three hooks (start-load, stop-reflect, publish-guard)
+ one setup skill.

What it deliberately is NOT: anyone's personal voice skills. It
bundles the shape, not the contents. Grow your own from here.

Install (in Claude Code):
  /plugin marketplace add rachel-rowanadvisory/rowan-starter
  /plugin install rowan-starter@rowan-starter
The hooks resolve their own location via ${CLAUDE_PLUGIN_ROOT}.

Licence: MIT.