@thebassclef/lite 1.9.15 → 1.9.18

package/dist/lite/.claude/skills/onboard-repo/SKILL.md

@@ -356,7 +356,80 @@ this divider.
 Run each phase in order. Operator confirms before destructive or
 cross-repo actions. Each phase is independently re-runnable.
 
-#### Phase 0 — Refuse to run from main
+#### Phase 0 — Preflight checks (OAuth, git identity, branch)
+
+Phase 0 bundles three cheap preflight checks before any Phase 1 work runs. The checks fire together so adopter sees all gaps at once, not one at a time. Per bassclef-upstream#2242 preflight-first SKILL design + folds C1 + C4 from the 2026-10-14 pre-mortem.
+
+##### 0.1 Claude OAuth probe (per bassclef-upstream#2233)
+
+Cold adopters have hit `/onboard-repo` with expired OAuth tokens. The skill wastes an orientation turn, then returns `Login expired · Please run /login`. The adopter re-fires the skill after login. Preflight the probe so the login prompt lands before any phase work.
+
+Run the cheap-hello pattern (per memory `feedback_oauth_verify_via_cheap_hello`):
+
+```bash
+if ! command -v claude >/dev/null 2>&1; then
+  cat >&2 <<'EOF'
+
+🛑 /onboard-repo preflight — Claude CLI not found on PATH.
+
+Install Claude Code first. Then re-fire /onboard-repo.
+
+EOF
+  exit 1
+fi
+
+if ! timeout 10 claude -p "say hello" >/dev/null 2>&1; then
+  cat >&2 <<'EOF'
+
+🛑 /onboard-repo preflight — Claude OAuth check failed.
+
+Run `/login` first. Then re-fire `/onboard-repo`.
+
+EOF
+  exit 1
+fi
+```
+
+Two checks: binary on PATH, then OAuth probe. Cost: ~2s on green path.
+
+##### 0.2 Git identity preflight (per bassclef-upstream#2232)
+
+`/onboard-repo` runs commit paths in Phase 2. Git fails with `Author identity unknown` when `user.name` or `user.email` is unset. The adopter sees the gap mid-flow and has to answer a 3-option prompt. Preflight the check so the question lands here, not later.
+
+```bash
+GIT_NAME=$(git config --get user.name 2>/dev/null || echo "")
+GIT_EMAIL=$(git config --get user.email 2>/dev/null || echo "")
+
+if [ -z "$GIT_NAME" ] || [ -z "$GIT_EMAIL" ]; then
+  cat >&2 <<'EOF'
+
+🛑 /onboard-repo preflight — git identity not set.
+
+Pick one option (then re-fire /onboard-repo):
+
+  1. GitHub no-reply address (private, derived from `gh api user`):
+       (requires `gh auth login` first — see Prerequisites)
+       GH_USER=$(gh api user --jq .login)
+       GH_ID=$(gh api user --jq .id)
+       git config --global user.name "$GH_USER"
+       git config --global user.email "${GH_ID}+${GH_USER}@users.noreply.github.com"
+
+  2. Your own name + email:
+       git config --global user.name "Your Name"
+       git config --global user.email "you@example.com"
+
+  3. Fixture smoke (keep repo-local identity for test runs):
+       git config user.name "fixture"
+       git config user.email "fixture@localhost"
+
+EOF
+  exit 1
+fi
+```
+
+Three options cover the common paths. GitHub no-reply is private and matches the pattern bassclef uses for its own commits.
+
+##### 0.3 Refuse to run from main
 
 Substrate changes go through PRs, same as feature work. If `/onboard-repo`
 runs from `main`, every scaffold (`.claude/`, `CLAUDE.md`,
@@ -427,6 +500,59 @@ operator-decision items.
 
 Idempotent API calls against the target repo via `gh`.
 
+##### 1.0a Repo-name collision helper (per bassclef-upstream#2236)
+
+When an agent or adopter runs `gh repo create` on behalf of `/onboard-repo` and the name is taken, iterate the suffix one-by-one is slow. A cold adopter on 2026-10-13 hit three round-trips before landing on `-4`. Enumerate the taken set in ONE call. Propose the lowest free name up front.
+
+Use this helper whenever the flow creates a new repo:
+
+```bash
+basename="bassclef-smoke-test"   # or whatever the adopter picked
+owner=$(gh api user --jq .login)
+
+# Pull every repo under $owner starting with $basename in ONE call
+taken=$(gh repo list "$owner" --json name --jq "[.[].name | select(startswith(\"$basename\"))] | sort" 2>/dev/null)
+
+# Find lowest free suffix
+suffix=""
+for i in '' $(seq 2 100); do
+  candidate="${basename}$([ -n "$i" ] && echo "-$i")"
+  if ! jq -e --arg c "$candidate" '.[] | select(. == $c)' <<<"$taken" >/dev/null 2>&1; then
+    suffix="$i"
+    break
+  fi
+done
+
+proposed="${basename}$([ -n "$suffix" ] && echo "-$suffix")"
+echo "Taken under $owner matching ${basename}*: $taken"
+echo "Proposed free name: $proposed"
+echo "Accept '$proposed'? Or type your own:"
+```
+
+One `gh repo list` call enumerates every conflict. One prompt proposes the next free name. Adopter accepts or renames in one turn.
+
+##### 1.0 Write the temperance marker up-front (per bassclef-upstream#2237)
+
+`/onboard-repo` is the scope decision. Running it means the operator picked this plan. The `pre-build-gate.sh` BLOCK on first Edit is a false positive. The scope landed at skill dispatch, not mid-skill.
+
+Write the marker now, before any Edit tool call fires:
+
+```bash
+mkdir -p state/markers/temperance
+BRANCH=$(git branch --show-current)
+cat > "state/markers/temperance/${BRANCH}.marker" <<EOF
+# Temperance marker — /onboard-repo
+- date: $(date -u +%Y-%m-%d)
+- branch: ${BRANCH}
+- scope-decision: scaffold bassclef setup via /onboard-repo
+- right-thing: adopter needs .claude/ + .gitignore + .bassclef/ wiring
+- right-way: idempotent API calls + file writes contained to adopter repo
+- drift-trigger: operator asks for scope outside the standard bootstrap set
+EOF
+```
+
+The marker satisfies `pre-build-gate.sh` at the right scope boundary. Phase 2's first Edit (settings.json, bassclef-configs.jsonc, .gitignore) proceeds clean. No mid-flow BLOCK banner.
+
 ##### 1.1 Create the 11 standard labels
 
 ```bash
@@ -462,31 +588,33 @@ immediately without waiting for a sync cycle.
 
 ##### 1.2 Protect main from force-push and deletion
 
-**Heads up — GitHub free-tier adopters on PRIVATE repos:** the API call
-below returns HTTP 403 ("Upgrade to GitHub Pro or make this repository
-public") on free-tier accounts, because branch protection is a paid
-feature for private repos. Public repos get branch protection on every
-plan, free included. Pick a path below BEFORE running the call.
+Branch protection on private repos is a paid GitHub feature. Free plan + private repo returns HTTP 403 on the API call. Public repos get branch protection on every plan.
 
-Three ways to clear this step:
-
-1. **Make the repo public** — simplest; free plan includes branch
-   protection on public repos. Good fit when the code is open source
-   or ships to adopters anyway.
-2. **Upgrade the GitHub plan** — Pro / Team / Enterprise includes
-   branch protection on private repos.
-3. **Skip the API call** — rely on local safety (no `git push --force`
-   habits, PR review, pre-commit hooks). Mark the repo config so later
-   phases know branch protection is operator-managed, not substrate-
-   managed. See the fallback block below.
+Preflight the plan + visibility pair. Skip the API call cleanly when free + private (per bassclef-upstream#2235). No adopter prompt, no 403 noise:
 
 ```bash
 DEFAULT_BRANCH=$(gh repo view "$REPO" --json defaultBranchRef -q '.defaultBranchRef.name')
+PLAN=$(gh api /user --jq .plan.name 2>/dev/null || echo "unknown")
+VISIBILITY=$(gh repo view "$REPO" --json visibility --jq .visibility 2>/dev/null || echo "UNKNOWN")
 
-# Pro / public-repo path — run the API call.
-gh api "repos/$REPO/branches/$DEFAULT_BRANCH/protection" \
-  --method PUT \
-  --input - <<EOF
+if [ "$PLAN" = "free" ] && [ "$VISIBILITY" = "PRIVATE" ]; then
+  echo "Preflight: free plan + private repo. GitHub free does not offer branch protection on private repos. Skipping API call."
+  mkdir -p docs
+  cat >> docs/onboard-notes.md <<'NOTE'
+## Branch protection — operator-managed
+
+GitHub free plan does not offer branch protection on private repos.
+This repo relies on:
+- Local discipline: no `git push --force` to main.
+- PR review before merge.
+- Pre-commit hooks shipped by bassclef.
+
+Revisit if the repo moves to public, or the plan upgrades to Pro+.
+NOTE
+else
+  gh api "repos/$REPO/branches/$DEFAULT_BRANCH/protection" \
+    --method PUT \
+    --input - <<EOF
 {
   "required_status_checks": null,
   "enforce_admins": false,
@@ -496,6 +624,7 @@ gh api "repos/$REPO/branches/$DEFAULT_BRANCH/protection" \
   "allow_deletions": false
 }
 EOF
+fi
 ```
 
 Minimum defense: no force-push or deletion of main. PR reviews NOT
@@ -503,25 +632,6 @@ required here — agent-created PRs (bassclef-sync) need to merge
 without human intervention for the mobile-sync story. Add stricter
 rules per-repo in `.github/branch-protection.yml` if the repo warrants.
 
-**Free-tier private-repo fallback (path 3 above).** If the API
-returned 403 and the operator picked "skip and manage locally":
-
-```bash
-# Record the choice so later audits know main is not API-protected.
-mkdir -p .claude
-cat >> .claude/onboard-notes.md <<'NOTE'
-## Branch protection — operator-managed
-
-GitHub free-tier does not include branch protection on private repos.
-This repo relies on:
-- Local discipline: no `git push --force` to main.
-- PR review before merge.
-- Pre-commit hooks shipped by bassclef.
-
-Revisit if the repo moves to public, or the plan upgrades to Pro+.
-NOTE
-```
-
 The adopter can revisit this step after switching to public OR
 upgrading the plan.
 
@@ -550,6 +660,25 @@ production deploy target.
 
 **Working directory: target repo.** All file writes happen here.
 
+##### 2.0 Opt-in prompt pattern — lead with VALUE (per bassclef-upstream#2234)
+
+Phase 2 fires four opt-in prompts: auto-update sync (2.1), auto-save cron (2.3.10), Concise output style (2.7), and deploy-host (3.5). The cold-adopter on 2026-10-13 wrote: "need to understand value of auto-save in the text". Current prompts render as 4-option tables with recommended labels but no VALUE row.
+
+Every opt-in prompt the agent dispatches via `AskUserQuestion` MUST prepend one plain-English sentence on what the adopter gets. Keep the multi-option schema. Add value to the option body text.
+
+**Pattern.** Each option description starts with the value sentence, then the mechanism:
+
+- `description: "What this is for: <one-sentence benefit>. <one-sentence mechanism>."`
+
+**Worked examples.** Agent composes these from the SKILL body text + the ticket semantics:
+
+- **auto_sync** → "What this is for: your repo pulls bassclef skills + rules every session so you stay current. Mechanism: SessionStart hook fetches the latest tarball."
+- **auto-save cron** → "What this is for: your work saves every 20 minutes so a crash or power loss costs minutes, not hours. Mechanism: launchd job (macOS) or Task Scheduler (Windows) commits uncommitted changes."
+- **Concise output style** → "What this is for: Claude Code leads replies with the result, skips step-by-step narration, and skips the closing recap. Mechanism: adds `outputStyle: Concise` to your `~/.claude/settings.json`."
+- **deploy-host** → "What this is for: your repo deploys to a live URL when main merges. Mechanism: AWS Amplify app + DNS + certificate via `/provision-deploy-host`."
+
+The agent uses these as templates. One sentence of value. One sentence of mechanism. Then the standard options list.
+
 ##### 2.1 Install the auto-update script (off by default per bassclef#939)
 
 ```bash
@@ -1357,6 +1486,41 @@ EOF
 The sync hook will add its managed symlink block on next run; this
 seeds the file with everything else.
 
+##### 2.7 Prompt to enable Concise output style (ADR-049 opt-in)
+
+**Working directory: operator home.** Writes land in `~/.claude/`, not the target repo.
+
+Anthropic ships four output styles. Concise leads with the result. It skips step-by-step narration. It skips closing recap. Three bassclef steering dimensions line up with Concise. Five bassclef dimensions stay in play at the project layer. They are grade target, jargon wordlist, appositive discipline, metric feedback, writing-craft discipline. Concise at operator scope cuts per-turn reminders. It covers three bassclef dimensions on its own.
+
+Fire this phase only when `concise_prompt_should_fire` returns 0. That means no declined sentinel. It also means no outputStyle set to Concise yet.
+
+```bash
+HELPER="$CLAUDE_PROJECT_DIR/.claude/skills/onboard-repo/concise-prompt.sh"
+source "$HELPER"
+concise_prompt_should_fire || { echo "Concise prompt skipped (declined or already set)."; return 0 2>/dev/null || true; }
+```
+
+Prompt the operator:
+
+> Enable Concise output style? (Y/n/skip)
+> - **Y** — write `"outputStyle": "Concise"` to `~/.claude/settings.json`. jq read-modify-write. Every pre-existing field survives.
+> - **n** — keep Default style. Do not prompt again.
+> - **skip** — do not change settings. Re-prompt on next `/onboard-repo` run.
+
+Default is **Y**.
+
+Apply the pick via the helper:
+
+```bash
+concise_prompt_apply "$CHOICE"   # Y | n | skip
+```
+
+The helper writes atomically. On **Y** it uses `jq '. + {"outputStyle": "Concise"}'` plus `mktemp` plus `mv`. No partial write ever lands. On **n** it writes `~/.claude/state/concise-prompt-declined`. On **skip** it writes `~/.claude/state/concise-prompt-skipped` so the operator sees the prompt again next run.
+
+Characterization test at `.claude/skills/onboard-repo/tests/concise-prompt.test.sh` pins all three paths plus field preservation (T1-T11; 11 tests).
+
+Per ADR-049 opt-in default off. The prompt defaults to Y. The operator picks explicitly. The helper NEVER writes without an explicit choice.
+
 #### Phase 3 — Create starter docs (CLAUDE.md, whereami)
 
 **Working directory: target repo.**

package/dist/lite/.claude/skills/onboard-repo/concise-prompt.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# tier: lite
+# install-class: project
+# concise-prompt.sh — handle Y/n/skip for Anthropic Concise output style.
+# Called by /onboard-repo SKILL Phase 2.7. Writes operator ~/.claude/settings.json
+# atomically via jq read-modify-write so every pre-existing field survives.
+#
+# Per Longrun 2 Step 2g (bassclef-upstream#2197).
+# ADR-049 opt-in default off — adopter picks Y explicitly.
+#
+# Env: HOME_OVERRIDE points at a fixture home for testing.
+# Returns:
+#   0 — path applied (Y wrote field, n wrote declined sentinel, skip wrote skip sentinel)
+#   1 — jq missing OR write failed (fail-soft; operator sees warning)
+#   2 — invalid choice
+
+set +e
+
+concise_prompt_apply() {
+  local choice="${1:-}"
+  local home="${HOME_OVERRIDE:-$HOME}"
+  local settings="$home/.claude/settings.json"
+  local state_dir="$home/.claude/state"
+  mkdir -p "$home/.claude" "$state_dir" 2>/dev/null
+
+  case "$choice" in
+    Y|y)
+      if ! command -v jq >/dev/null 2>&1; then
+        echo "concise-prompt: jq not installed; skipping outputStyle write" >&2
+        return 1
+      fi
+      [ -f "$settings" ] || echo '{}' > "$settings"
+      local tmp
+      tmp=$(mktemp 2>/dev/null) || return 1
+      if jq '. + {"outputStyle": "Concise"}' "$settings" > "$tmp" 2>/dev/null; then
+        mv "$tmp" "$settings"
+      else
+        rm -f "$tmp" 2>/dev/null
+        return 1
+      fi
+      rm -f "$state_dir/concise-prompt-skipped" "$state_dir/concise-prompt-declined" 2>/dev/null
+      return 0
+      ;;
+    n|N)
+      touch "$state_dir/concise-prompt-declined" 2>/dev/null || return 1
+      return 0
+      ;;
+    skip|SKIP|s|S)
+      touch "$state_dir/concise-prompt-skipped" 2>/dev/null || return 1
+      return 0
+      ;;
+    *)
+      return 2
+      ;;
+  esac
+}
+
+concise_prompt_should_fire() {
+  local home="${HOME_OVERRIDE:-$HOME}"
+  local state_dir="$home/.claude/state"
+  local settings="$home/.claude/settings.json"
+  [ -f "$state_dir/concise-prompt-declined" ] && return 1
+  if [ -f "$settings" ] && command -v jq >/dev/null 2>&1; then
+    if jq -e '.outputStyle == "Concise"' "$settings" >/dev/null 2>&1; then
+      return 1
+    fi
+  fi
+  return 0
+}
+
+if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
+  concise_prompt_apply "${1:-}"
+fi

package/dist/lite/.claude/skills/onboard-repo/write-state-marker.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+# tier: lite
+# write-state-marker.sh — Phase 2.3.9 helper for /onboard-repo (bassclef-upstream#664).
+# Retagged standard→lite per bassclef-upstream#2140 (Cure 1) so lite adopters
+# running /onboard-repo at Phase 2.3.9 capture the state marker cleanly.
+# Script shape is small (≤80 lines, no bash gotchas); belongs in the lite bundle.
+#
+# Writes .claude/state/onboard-repo.state.json capturing which mode ran, when,
+# and which files landed. Re-runs append to history[] instead of clobbering.
+#
+# Usage:
+#   bash .claude/skills/onboard-repo/write-state-marker.sh <mode>
+#
+# Env:
+#   ONBOARD_TARGET_DIR   root of the adopter repo (defaults to $PWD)
+#
+# Composes with:
+#   - Configs UI first-run overlay (bassclef/configs/, bet 2026-07-08a WU-7)
+#   - @luminary john-ousterhout — deep module — one script, one job
+
+set -eu
+
+MODE="${1:-default}"
+TARGET="${ONBOARD_TARGET_DIR:-$PWD}"
+
+mkdir -p "$TARGET/.claude/state"
+MARKER="$TARGET/.claude/state/onboard-repo.state.json"
+NOW=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+# Collect paths written to the adopter repo — check for existence.
+PATHS_JSON='['
+sep=""
+for p in \
+  ".claude/bassclef-configs.jsonc" \
+  ".bassclef-source.json" \
+  ".claude/CLAUDE.md" \
+  "docs/whereami.md"; do
+  if [ -f "$TARGET/$p" ]; then
+    PATHS_JSON="$PATHS_JSON$sep\"$p\""
+    sep=","
+  fi
+done
+PATHS_JSON="$PATHS_JSON]"
+
+if [ -f "$MARKER" ]; then
+  # Existing marker — append prior run to history[]; keep top-level as this run.
+  python3 - "$MARKER" "$MODE" "$NOW" "$PATHS_JSON" <<'PY'
+import json, sys
+marker_path = sys.argv[1]
+mode = sys.argv[2]
+now = sys.argv[3]
+paths_written = json.loads(sys.argv[4])
+with open(marker_path) as f:
+    data = json.load(f)
+history = data.get("history", [])
+history.append({
+    "mode": data.get("mode", "unknown"),
+    "timestamp_iso": data.get("timestamp_iso", "unknown"),
+    "paths_written": data.get("paths_written", []),
+})
+data["mode"] = mode
+data["timestamp_iso"] = now
+data["paths_written"] = paths_written
+data["history"] = history
+data["skill_version"] = data.get("skill_version", "1.0")
+with open(marker_path, "w") as f:
+    json.dump(data, f, indent=2)
+PY
+else
+  cat > "$MARKER" <<JSON
+{
+  "mode": "$MODE",
+  "timestamp_iso": "$NOW",
+  "paths_written": $PATHS_JSON,
+  "history": [],
+  "skill_version": "1.0"
+}
+JSON
+fi
+
+echo "wrote onboard-repo state marker at $MARKER (mode: $MODE)"

package/dist/lite/.claude/skills/pre-mortem/SKILL.md

@@ -111,13 +111,69 @@ For non-always-fire scope, `/pre-mortem light` picks 3 lenses appropriate to the
 - Per lens: 5-8 imagined failures written by operator; Claude collates without ranking during the pass
 - Follow-up pass: pick top 5 risks total (across all lenses); name owner + mitigation per risk
 - Output at `docs/risk-ledgers/<slug>.md` — short-form ledger
+- **Write marker at `state/markers/pre-mortem/<branch-slug>.marker`** — downstream skills (`/build` Phase 3, Reviewer) read it. See § Marker contract below.
 
 ### Full mode (90 min)
 
+<!-- FKGL-EXEMPT: full-mode bullets inherit light-mode shape with denser per-risk fields (severity + trigger + mitigation); dense bullet reference list, not prose. -->
 - 5-8 rotating lenses per domain map
 - Per lens: 10-15 imagined failures; per-risk severity (high/medium/low); per-risk trigger signal (what would tell operator the risk materialized); per-risk mitigation
 - Follow-up pass: rank all risks by severity × probability; name owner + mitigation trigger + monitoring signal per top-10 risks
 - Output at `docs/risk-ledgers/<slug>.md` — research-grade ledger
+- **Write marker at `state/markers/pre-mortem/<branch-slug>.marker`** — downstream skills read it. See § Marker contract below.
+<!-- /FKGL-EXEMPT -->
+
+<!-- FKGL-EXEMPT: § Marker contract — technical reference with bash fenced blocks and marker body template; not prose. Per bassclef-upstream#2175 Batch B — F4. -->
+
+## Marker contract (per bassclef-upstream#2175 Batch B — F4)
+
+After the risk ledger lands, write a marker at `state/markers/pre-mortem/<branch-slug>.marker`. Downstream skills read it. `/build` Phase 3 surfaces the top risks. Reviewer reads it during review.
+
+Marker body shape:
+
+```
+# Pre-mortem marker — <scope>
+- date: YYYY-MM-DD
+- branch: <branch name>
+- ledger: docs/risk-ledgers/<slug>.md
+- mode: light | full
+- lenses: lead-slug + supporting slugs (comma list)
+- top-5 risks: one line per risk — <severity glyph> <one-sentence summary> (<lens slug>)
+- disposition: fold | monitor | scope-cut per risk
+```
+
+The ledger path is the canonical reference. The top-5 risks give a scan summary. Lenses pin the authoring luminaries.
+
+```bash
+BRANCH=$(git branch --show-current)
+BRANCH_SLUG=$(echo "$BRANCH" | tr '/' '-')
+mkdir -p state/markers/pre-mortem
+cat > "state/markers/pre-mortem/${BRANCH_SLUG}.marker" <<EOF
+# Pre-mortem marker — <scope>
+- date: $(date -u +%Y-%m-%d)
+- branch: $BRANCH
+- ledger: docs/risk-ledgers/<slug>.md
+- mode: light
+- lenses: <lead-slug>, <supporting-slug-1>, <supporting-slug-2>
+- top-5 risks:
+  - 🔴 <risk one summary> (<lens-slug>)
+  - 🟡 <risk two summary> (<lens-slug>)
+  - 🟢 <risk three summary> (<lens-slug>)
+  - 🟡 <risk four summary> (<lens-slug>)
+  - 🔴 <risk five summary> (<lens-slug>)
+- disposition: fold per risk (name mitigation inline)
+EOF
+```
+
+Guard the git-stage with a check-ignore test — adopter repos vary on whether `state/markers/` is tracked:
+
+```bash
+if ! git check-ignore -q "state/markers/pre-mortem/${BRANCH_SLUG}.marker" 2>/dev/null; then
+  git add "state/markers/pre-mortem/${BRANCH_SLUG}.marker"
+fi
+```
+
+<!-- /FKGL-EXEMPT -->
 
 ## Output
 

package/dist/lite/.claude/skills/sprint/SKILL.md

@@ -100,6 +100,21 @@ Option labels are typeable letters per memory `feedback_keyboard_typeable_option
 
 **Step 0** — Lead with a `/value-prop tweet` claim (≤180 chars) plus a `/kiss words` grade-10 summary (2-3 sentences). This is what the operator reads first on mobile. Tables come after.
 
+**Step 0.5 — First-run detection (per bassclef-upstream#2009; Sam-A).** Before any thread walk fires, check whether the repo is cold. Cold means:
+
+- `docs/whereami.md` is missing OR has no `iteration_bet:` + no `next_bet:` field, AND
+- `docs/canvases/` is empty or missing, AND
+- `docs/roadmaps/` is empty or missing, AND
+- `state/markers/temperance/` is empty or missing
+
+When cold, jump straight to Step 7d. Skip Steps 1-6. The cold-repo output uses plain adopter vocabulary — no "parent-goal thread", no "orientation gates", no "roadmap reconcile", no "tier taxonomies". A cold adopter has no model for those words yet.
+
+Routing hint for cold adopters points at the build path:
+
+> New here? Try `/stage` for a clickable mock of your idea, `/launch` for a full variant gallery, or `/build` to ship against an existing spec. These let you see something real on your screen before learning the deeper surface area.
+
+When warm (any of the four signals present), continue to Step 1.
+
 **Step 1** — Orientation gates. Check `state/markers/orientation-gate/<branch-slug>.marker`. Check `state/markers/roadmap-reconcile-gate/<branch-slug>.marker`. When either is missing on a feature branch, refuse Step 7. Point at the BLOCKED block. On main this step is silent.
 
 **Step 2** — Walk the parent chain before reading leaf state. Read the active goal's parent_drivers via `state_iteration_bet_active`. Walk up to parent_bet when present. Walk further until parent_goal is null. Read parent_roadmap when any goal in the chain has one. Fetch its `last_event` and `next_pending` via `state_roadmap_get`. Surface active goal plus parent goal plus parent roadmap plus combined parent_drivers.
@@ -177,11 +192,17 @@ Instead of refusing to render, `/sprint` reads three fallback sources:
 
 From these sources, propose 3 candidate options in the same card + scan-table shape (Step 7c). Cite the source per option — for example, "From your open issues #NNN + recent commits on `<area>`". The value-prop per option comes from what the source itself says, not from a strategic doc.
 
-End with a plain-English hint pointing the adopter at ways to sharpen future runs:
+End with two plain-English hints. The first points the adopter at the build path — the fastest route from idea to something on screen:
+
+> New here? Try `/stage` for a clickable mock, `/launch` for a full variant gallery, or `/build` to ship against an existing spec. These let you see something real on your screen before learning the deeper surface area.
+
+The second hint points at ways to sharpen future runs:
+
+> Want sharper option proposals from `/sprint` later? Author strategic docs first — `/lean-canvas` (business model), `/spec` (buildable spec), or `/user-stories` (backlog shape). These feed `/sprint` on future calls.
 
-> Want sharper option proposals next time? Author strategic docs first — `/lean-canvas` (business model), `/spec` (buildable spec), or `/user-stories` (INVEST backlog). These feed `/sprint` on future calls.
+Both hints are opt-in. The adopter does NOT need to author strategic docs to get value from this call. This mirrors `/onboard-repo` Path B "greenfield-from-intent" — the skill produces useful output on its first fire, and hints at deeper flows without gating on them.
 
-The fallback is opt-in on the hint side. The adopter does NOT need to author strategic docs to get value from this call. This mirrors `/onboard-repo` Path B "greenfield-from-intent" — the skill produces useful output on its first fire, and hints at deeper flows without gating on them.
+Note per Sam PDF cure (bassclef-upstream#2009): the first hint takes precedence over the second. Sam's bounce rule is that unfamiliar vocabulary at first mention causes exit. The build path uses adopter-vocab (`/stage`, `/launch`, `/build`); the strategic-docs path uses deeper vocab (`/lean-canvas`, `/user-stories`). First hint fires first.
 
 Note per risk ledger R2: production fixture harness for this fallback path uses a brownfield fixture (no canvas, no whereami) so the fallback runs under test. Adding that fixture ships as a follow-on when the fallback surface gets its first Tier 0 test.
 

package/dist/lite/.claude/skills/temperance/SKILL.md

@@ -82,7 +82,9 @@ State these five lines after the checklist:
 - **What you are NOT doing** — the temptations you resist.
 - **Verification plan** — how you will know it works.
 
-Then write the gate marker. BOTH the ephemeral flag AND the durable git-tracked marker. The pre-build-gate hook accepts either. The durable marker lets the 5-session compliance counter see mobile firings that would evaporate at sandbox teardown.
+Then write the gate marker. BOTH the ephemeral flag AND the durable marker. The pre-build-gate hook accepts either. The durable marker lets the 5-session compliance counter see mobile firings that would evaporate at sandbox teardown.
+
+<!-- FKGL-EXEMPT: bash command block; shell commands are not graded prose. F6 cure per bassclef-upstream#2175 Batch B wraps git add in check-ignore guard. -->
 
 ```bash
 BRANCH=$(git branch --show-current)
@@ -93,13 +95,22 @@ SESSION_ID=${CLAUDE_SESSION_ID:-$$}
 # Ephemeral flag (existing pre-build-gate contract)
 touch "/tmp/claude-temperance-done-${SESSION_ID}-${BRANCH_HASH}"
 
-# Durable git-tracked marker
+# Durable marker (gitignore-aware per F6 cure)
 mkdir -p state/markers/temperance
 date -u +%Y-%m-%dT%H:%M:%SZ > "state/markers/temperance/${BRANCH_SLUG}.marker"
-git add "state/markers/temperance/${BRANCH_SLUG}.marker"
+
+# F6 cure (bassclef-upstream#2175 Batch B) — skip git add when the path is
+# ignored. Adopter repos vary on whether state/markers/ is tracked. The marker
+# write stays unconditional (local file always). The stage runs only when the
+# path is tracked.
+if ! git check-ignore -q "state/markers/temperance/${BRANCH_SLUG}.marker" 2>/dev/null; then
+  git add "state/markers/temperance/${BRANCH_SLUG}.marker"
+fi
 ```
 
-The durable marker commits with the branch's normal flow. `state/markers/` is git-tracked per `.claude/rules/mobile-ephemeral-session.md` section 2.
+<!-- /FKGL-EXEMPT -->
+
+The durable marker always lands as a local file. The git stage runs only when the adopter repo tracks `state/markers/`. Per `.claude/rules/mobile-ephemeral-session.md` section 2 and `.claude/rules/session-artifacts.md` posture note.
 
 Then proceed with the work.
 

package/dist/lite/README.md

@@ -13,6 +13,8 @@ description: A shared substrate for working with AI coding agents.
 
 **A shared substrate for working with AI coding agents.** Install it once into your repo, and every Claude Code session starts loaded: skills you invoke, rules the agent reads, specialist agents you dispatch, practitioner profiles it designs against, hooks that catch mistakes, plus the standards and decision records that wire them together.
 
+**What lands on disk.** Bassclef installs its working files under `.claude/`, plus one project-state document at `docs/whereami.md`, a config at `substrate.config.md`, and a `CLAUDE.md` that loads them. Most of these are bassclef's own files — you normally don't edit them. Your own code is untouched.
+
 Run `/skills` or `/luminary` in any session to see exactly what your install carries. The counts differ by tier, so this README does not print them.
 
 The agent reads your rules, knows the catalog, handles failure cleanly, and ships with discipline. You stop re-explaining your conventions every session — the difference between an assistant you brief and a band that already knows the set.

package/dist/lite/bassclef-version.json

@@ -1,7 +1,7 @@
 {
-  "version": "v1.8.0",
-  "marker_tag": "release-2026-10-06-a874c748",
-  "release_date": "2026-10-06T20:56:57Z",
-  "release_sha": "a874c748",
-  "release_tag": "v1.8.0"
+  "version": "v1.11.0",
+  "marker_tag": "release-2026-10-17-fcf192d8",
+  "release_date": "2026-10-17T23:16:18Z",
+  "release_sha": "fcf192d8",
+  "release_tag": "v1.11.0"
 }