@thebassclef/lite 1.9.16 → 1.9.19

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.1",
+  "marker_tag": "release-2026-10-18-3b0203d5",
+  "release_date": "2026-10-18T14:59:01Z",
+  "release_sha": "3b0203d5",
+  "release_tag": "v1.11.1"
 }

package/dist/lite/lib/install-written-paths.sh

@@ -112,6 +112,100 @@ _iwp_manifest_valid() {
   return 0
 }
 
+# ---- Ajv-runtime schema validator (bassclef-upstream#2157 step 6) ----
+#
+# Wraps the install-written-paths manifest in ajv-based schema validation.
+# Called from install_written_paths_verify (read-side gate) + from
+# install_written_paths_register (post-write gate).
+#
+# Reads via is_install_written_path stay cheap (no ajv — hot path).
+# Writes are rare, so post-write ajv cost is acceptable.
+#
+# Fail-soft on ajv missing (adopter machine without ajv-cli): returns 0.
+# Mirrors the step 2 validator pattern at scripts/validate-cross-repo-contracts.sh:139-144.
+# This keeps lite-tier adopters working when ajv is not installed; the step 3
+# CI gate catches drift at every PR regardless of adopter ajv presence.
+#
+# @pattern patterns/code/ousterhout/deep-module.md  — one wrapper, many callers
+# @pattern patterns/code/vernon/anticorruption-layer.md — ajv at the write boundary
+
+_iwp_schema_path() {
+  local root="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+  echo "$root/standards/state-spine/schemas/install-written-paths.schema.json"
+}
+
+# _iwp_ajv_validate <manifest-path>
+# Returns 0 when ajv absent (fail-soft) OR when ajv confirms the manifest
+# conforms to standards/state-spine/schemas/install-written-paths.schema.json.
+# Returns 1 when ajv is present AND the manifest fails schema validation.
+_iwp_ajv_validate() {
+  local manifest_file="${1:-}"
+  [ -n "$manifest_file" ] || return 1
+  [ -f "$manifest_file" ] || return 1
+
+  if ! command -v ajv >/dev/null 2>&1; then
+    _iwp_log "ajv-validate skip reason=ajv-missing manifest=$manifest_file"
+    return 0
+  fi
+
+  local schema
+  schema=$(_iwp_schema_path)
+  if [ ! -f "$schema" ]; then
+    _iwp_log "ajv-validate skip reason=schema-missing path=$schema"
+    return 0
+  fi
+
+  if ajv validate -s "$schema" -d "$manifest_file" --spec=draft2020 -c ajv-formats >/dev/null 2>&1; then
+    _iwp_log "ajv-validate pass manifest=$manifest_file"
+    return 0
+  fi
+
+  _iwp_log "ajv-validate fail manifest=$manifest_file"
+  return 1
+}
+
+# ---- CLI init.manifest.json fallback (bassclef-upstream#2138) ----
+#
+# bassclef-cli's `bassclef init` writes `.bassclef/init.manifest.json`
+# with its own schema (per bassclef-cli/src/lib/manifest-types.ts):
+#   { schema_version: 2|3, entries: [{path, template, outcome, ...}] }
+#
+# When upstream's state/install-written-paths.json doesn't have an
+# entry for a path, fall back to this CLI manifest. Treat outcome in
+# {created, updated, unchanged} as install-written. Treat refused |
+# error as NOT install-written (the write didn't actually land, so
+# discipline should still fire).
+#
+# No hash verification against the CLI manifest. The CLI schema uses
+# `content_hash_sha256` without the `sha256:` prefix; shape-mismatch
+# is tolerated because the fallback is a presence + outcome check,
+# not an integrity check. The upstream manifest keeps strict hash
+# verification per Hoare.
+_iwp_init_manifest_path() {
+  local root="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+  echo "$root/.bassclef/init.manifest.json"
+}
+
+# Returns 0 when the path is present in the CLI init manifest with
+# outcome in {created, updated, unchanged}. Returns 1 otherwise
+# (missing file, malformed JSON, path absent, or outcome refused/error).
+_iwp_init_manifest_has_path() {
+  local tgt="${1:-}"
+  [ -n "$tgt" ] || return 1
+  local init_manifest
+  init_manifest=$(_iwp_init_manifest_path)
+  [ -f "$init_manifest" ] || return 1
+  command -v jq >/dev/null 2>&1 || return 1
+  # Guard against malformed JSON: jq -e . exits non-zero on parse failure.
+  jq -e . "$init_manifest" >/dev/null 2>&1 || return 1
+  local outcome
+  outcome=$(jq -r --arg path "$tgt" '.entries[]? | select(.path == $path) | .outcome' "$init_manifest" 2>/dev/null)
+  case "$outcome" in
+    created|updated|unchanged) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
 # ---- Public API ----
 
 # install_written_paths_register <path> <writer>
@@ -182,7 +276,19 @@ install_written_paths_register() {
   fi
 
   rm -f "$tmp" 2>/dev/null || true
-  _iwp_log "register path=$tgt writer=$writer"
+
+  # Post-write ajv check (step 6 — bassclef-upstream#2157). On fail, surface
+  # a warning but keep the write — fail-soft so adopters never lose data
+  # over schema drift. The step 2 validator + step 3 CI gate + step 5 release
+  # gate catch drift at later layers; this layer is advisory at write-time.
+  if ! _iwp_ajv_validate "$mpath"; then
+    echo "install-written-paths: WARNING — manifest at $mpath fails ajv schema validation after register" >&2
+    echo "install-written-paths: entry kept; run 'install_written_paths_verify' for details" >&2
+    _iwp_log "register path=$tgt writer=$writer post-write-ajv=fail"
+  else
+    _iwp_log "register path=$tgt writer=$writer post-write-ajv=pass"
+  fi
+
   return 0
 }
 
@@ -204,10 +310,17 @@ is_install_written_path() {
   local mpath
   mpath=$(_iwp_manifest_path)
 
-  # Fail-soft: manifest missing or malformed → not install-written
+  # Fail-soft: upstream manifest missing or malformed. Before giving
+  # up, consult the CLI init manifest (bassclef-upstream#2138). Cold
+  # adopters that ran only `bassclef init` have no upstream manifest
+  # yet; the CLI manifest is their only install-written source.
   if ! _iwp_manifest_valid; then
-    _iwp_log "check path=$tgt result=false reason=no-manifest-or-malformed"
     [ -f "$mpath" ] && echo "install-written-paths: manifest malformed; treating as not-install-written" >&2
+    if _iwp_init_manifest_has_path "$tgt"; then
+      _iwp_log "check path=$tgt result=true reason=cli-init-manifest-fallback-no-upstream-manifest"
+      return 0
+    fi
+    _iwp_log "check path=$tgt result=false reason=no-manifest-or-malformed"
     return 1
   fi
 
@@ -220,6 +333,14 @@ is_install_written_path() {
   local recorded_hash
   recorded_hash=$(jq -r --arg path "$tgt" '.entries[] | select(.path == $path) | .content_hash' "$mpath" 2>/dev/null)
   if [ -z "$recorded_hash" ] || [ "$recorded_hash" = "null" ]; then
+    # Fallback per bassclef-upstream#2138 — the CLI's `bassclef init`
+    # writes `.bassclef/init.manifest.json` with its own shape. Lite
+    # adopters hit the lead-lens 3-marker gate because the two manifests
+    # never agreed. Consult the CLI manifest before giving up.
+    if _iwp_init_manifest_has_path "$tgt"; then
+      _iwp_log "check path=$tgt result=true reason=cli-init-manifest-fallback"
+      return 0
+    fi
     _iwp_log "check path=$tgt result=false reason=not-in-manifest"
     return 1
   fi
@@ -335,6 +456,125 @@ install_written_paths_rebuild() {
   return 0
 }
 
+# install_written_paths_rebuild_from_lite_manifest <lite-manifest-path>
+#
+# Bulk-rebuild cure per bassclef-upstream#2200.
+#
+# Replaces the fragment's 451 serial `install_written_paths_register` loop
+# with one atomic rebuild. Reads lite-manifest.json, computes SHA256 per
+# path that exists on disk, writes the full entries array in one jq pass
+# to a tmp file, runs ajv once, then atomically moves tmp over manifest.
+#
+# Deep module per @luminary john-ousterhout — one verb hides the whole
+# rebuild path. Caller stays dumb. Register's per-path semantics stay
+# untouched for ad-hoc callers (hook-connect, migrations) that need
+# per-call ajv (PR #2174 intent preserved).
+#
+# Postcondition (per @luminary tony-hoare):
+#   On return 0: manifest at _iwp_manifest_path() carries one entry per
+#   lite-manifest.json path that passes _iwp_validate_path AND exists on
+#   disk; writer=bassclef-sync-template; content_hash=sha256:<hex>;
+#   written_at=current UTC timestamp. Schema-valid per ajv when ajv present.
+#   On return 1: lite-manifest missing OR malformed; existing manifest
+#   untouched (atomic mv never ran).
+#
+# Returns:
+#   0  success (manifest written)
+#   1  lite-manifest missing | malformed | jq missing
+install_written_paths_rebuild_from_lite_manifest() {
+  local lite_manifest="${1:-}"
+
+  if [ -z "$lite_manifest" ] || [ ! -f "$lite_manifest" ]; then
+    _iwp_log "bulk-rebuild fail reason=lite-manifest-missing path=$lite_manifest"
+    return 1
+  fi
+
+  if ! command -v jq >/dev/null 2>&1; then
+    echo "install-written-paths: jq not available; cannot bulk-rebuild" >&2
+    return 1
+  fi
+
+  # Precondition: lite-manifest.json is valid JSON
+  if ! jq -e . "$lite_manifest" >/dev/null 2>&1; then
+    _iwp_log "bulk-rebuild fail reason=lite-manifest-malformed path=$lite_manifest"
+    return 1
+  fi
+
+  local mpath
+  mpath=$(_iwp_manifest_path)
+  mkdir -p "$(dirname "$mpath")"
+
+  local root="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+  local now
+  now=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+  # Build entries array in a tmp jq-input file: one JSON object per line.
+  # Each line is a {path, writer, written_at, content_hash} record.
+  # Skip entries that fail path validation OR have no file on disk.
+  local jq_input
+  jq_input=$(mktemp)
+  # shellcheck disable=SC2064
+  trap "rm -f \"$jq_input\"" RETURN
+
+  local registered=0
+  local skipped=0
+  while IFS= read -r rel_path; do
+    [ -z "$rel_path" ] && continue
+    if ! _iwp_validate_path "$rel_path"; then
+      skipped=$((skipped + 1))
+      continue
+    fi
+    local full_path
+    case "$rel_path" in
+      /*) full_path="$rel_path" ;;
+      *) full_path="$root/$rel_path" ;;
+    esac
+    if [ ! -f "$full_path" ]; then
+      skipped=$((skipped + 1))
+      continue
+    fi
+    local hash
+    hash=$(_iwp_sha256 "$full_path")
+    if [ -z "$hash" ]; then
+      skipped=$((skipped + 1))
+      continue
+    fi
+    jq -cn --arg p "$rel_path" --arg w "bassclef-sync-template" --arg ts "$now" --arg h "$hash" \
+      '{path:$p, writer:$w, written_at:$ts, content_hash:$h}' >> "$jq_input"
+    registered=$((registered + 1))
+  done < <(jq -r '.entries[]?.path // empty' "$lite_manifest")
+
+  # Build the manifest from the per-line records using jq --slurp.
+  # Tmp filename MUST end in .json so ajv's auto-detect reads it as JSON
+  # instead of trying to require() it as a module (macOS mktemp without
+  # --suffix produces extensionless files that fail ajv's parse).
+  local tmp
+  tmp="$mpath.rebuild.$$.json"
+  if ! jq -s --arg sv "$_IWP_SCHEMA_VERSION" \
+    '{schema_version:$sv, entries:.}' "$jq_input" > "$tmp"; then
+    rm -f "$tmp" 2>/dev/null || true
+    _iwp_log "bulk-rebuild fail reason=jq-slurp-failed registered=$registered"
+    return 1
+  fi
+
+  # Post-write ajv validate; on fail, keep old manifest (atomic safety per Nygard)
+  if ! _iwp_ajv_validate "$tmp"; then
+    echo "install-written-paths: WARNING — bulk-rebuild output fails ajv; keeping prior manifest" >&2
+    rm -f "$tmp" 2>/dev/null || true
+    _iwp_log "bulk-rebuild fail reason=ajv-validate registered=$registered"
+    return 1
+  fi
+
+  if ! mv "$tmp" "$mpath"; then
+    rm -f "$tmp" 2>/dev/null || true
+    _iwp_log "bulk-rebuild fail reason=mv-failed registered=$registered"
+    return 1
+  fi
+
+  _iwp_log "bulk-rebuild ok registered=$registered skipped=$skipped mpath=$mpath"
+  return 0
+}
+
 # install_written_paths_verify
 # Returns 0 on well-formed manifest, 1 on schema violation.
 install_written_paths_verify() {
@@ -365,5 +605,12 @@ install_written_paths_verify() {
     return 1
   fi
 
+  # Ajv-runtime schema check (step 6 — bassclef-upstream#2157).
+  # Fail-soft on ajv missing (returns 0); strict reject on schema failure.
+  if ! _iwp_ajv_validate "$mpath"; then
+    echo "install-written-paths: manifest fails ajv schema validation" >&2
+    return 1
+  fi
+
   return 0
 }