@thebassclef/lite 1.3.0 → 1.4.1

package/dist/lite/lib/ancestor-claude-check.sh

@@ -0,0 +1,101 @@
+#!/bin/bash
+# tier: lite
+#
+# ancestor-claude-check.sh — walks up from a starting directory to $HOME
+# (or a provided ceiling) and echoes each ancestor .claude/ directory found.
+# Empty output = no ancestor .claude/ directories.
+#
+# Claude Code walks up from cwd loading .claude/ at every ancestor level.
+# A stale ancestor .claude/skills/ produces duplicate + often-outdated skill
+# entries in every child repo. Cold adopter can hit this on first install if
+# they have any legacy .claude/ in a parent dir. /onboard-repo Phase X calls
+# this helper to surface the class before proceeding.
+#
+# Contract:
+#   Args: $1 = starting directory (required; must exist)
+#         $2 = ceiling directory (optional; defaults to $HOME)
+#   Output: one absolute path per line, each an ancestor .claude/ directory
+#           between $1 (exclusive) and the ceiling (inclusive).
+#   Exit: 0 on clean walk (empty output OR one-or-more matches)
+#         1 on error (missing start dir, unreadable ancestor)
+#
+# Adopter cure hint printed to stderr per match — non-blocking:
+#   "cure: mv <path> <path>.stale-<date>"
+#
+# Ships bassclef-upstream#573. Sister to sibling ticket that adds the manual
+# audit step to the onboarding checklist.
+#
+# Anchors:
+#   @luminary saltzer-schroeder — complete mediation (every ancestor level checked)
+#   @luminary donald-norman — signifier + cure hint (adopter sees the issue + fix)
+
+set -euo pipefail
+
+_ancestor_claude_check_usage() {
+  cat >&2 <<'EOF'
+ancestor-claude-check.sh — walks up from <start> to <ceiling> reporting ancestor .claude/ dirs
+
+Usage:
+  bash lib/ancestor-claude-check.sh <start-dir> [ceiling-dir]
+
+Args:
+  <start-dir>    directory to start walking up from (required, must exist)
+  [ceiling-dir]  stop above this dir (default: $HOME)
+
+Output:
+  One absolute path per line for each ancestor .claude/ dir found.
+  Empty output = no ancestor .claude/ dirs (clean).
+
+Exit:
+  0 = clean walk (regardless of match count)
+  1 = error (missing start dir OR unreadable ancestor)
+
+Cure hint per match echoed to stderr, non-blocking.
+EOF
+}
+
+ancestor_claude_check() {
+  local start="${1:-}"
+  local ceiling="${2:-${HOME}}"
+
+  if [ -z "$start" ]; then
+    _ancestor_claude_check_usage
+    return 1
+  fi
+
+  if [ ! -d "$start" ]; then
+    echo "ancestor-claude-check: start dir not found: $start" >&2
+    return 1
+  fi
+
+  # Canonicalize both paths so comparison + traversal work under symlinks
+  local start_abs ceiling_abs
+  start_abs=$(cd "$start" && pwd -P)
+  ceiling_abs=$(cd "$ceiling" 2>/dev/null && pwd -P) || {
+    echo "ancestor-claude-check: ceiling dir not found: $ceiling" >&2
+    return 1
+  }
+
+  # Walk from parent of start up to (and including) ceiling
+  local cur="$start_abs"
+  local today
+  today=$(date -u +%Y-%m-%d)
+  while [ "$cur" != "/" ]; do
+    cur=$(dirname "$cur")
+    if [ -d "$cur/.claude" ]; then
+      echo "$cur/.claude"
+      echo "cure: mv \"$cur/.claude\" \"$cur/.claude.stale-$today\"" >&2
+    fi
+    # Stop after processing ceiling — do not walk above it
+    if [ "$cur" = "$ceiling_abs" ]; then
+      break
+    fi
+  done
+
+  return 0
+}
+
+# When invoked directly (not sourced), run against argv
+if [ "${BASH_SOURCE[0]:-}" = "${0}" ]; then
+  ancestor_claude_check "$@"
+fi

package/dist/lite/lib/fixture-builder.sh

@@ -12,6 +12,20 @@
 #   fixture_setup_substrate_sibling(fixture_dir, substrate_name)
 #   fixture_inject_pre_rename_refs(adopter_dir, canonical_substrate_dir)
 #
+# Cold-adopter-harness fixture (per bassclef-upstream#1789 goal 2026-09-19b):
+#   fixture_setup_cold_adopter_harness(target)  → echo cache path; runs
+#                                                  harness once per shard, caches
+#                                                  stdout+stderr for reuse
+#   harness_check_output(target)                → echo cached content
+#   harness_cache_path(target)                  → echo cache path (no side effects)
+#   harness_exit_code(target)                   → echo harness exit code from run
+#   fixture_cleanup_cold_adopter_harness()      → sweep harness fixture cache
+#
+# The harness fixture uses BASSCLEF_HARNESS_FIXTURE_ROOT env var if set,
+# otherwise $TMPDIR/bassclef-harness-fixture-$$ (per-shard PID scope).
+# Cache key is a short SHA of the canonicalized target path so different
+# targets do not collide.
+#
 # Override: SKIP_FIXTURE_BUILDER=1 — every public function exits 0 silently
 #                                    (fixture_init echoes empty path).
 # Logged via trace-helper per bassclef hook idiom.
@@ -188,3 +202,313 @@ fixture_inject_pre_rename_refs() {
 EOF
   return 0
 }
+
+# =============================================================================
+# Cold-adopter-harness fixture — bassclef-upstream#1789 goal 2026-09-19b
+# Runs the cold-adopter harness once per shard, caches stdout+stderr, exposes
+# an accessor. Tests grep cached content instead of re-invoking harness.
+# =============================================================================
+
+# _harness_fixture_root — echo the cache root path
+# Precedence:
+#   1. BASSCLEF_HARNESS_FIXTURE_ROOT env (explicit override — tests, prewarm job)
+#   2. SHARD_INDEX env (CI matrix — per-shard scope so tests in the SAME shard
+#      SHARE cache; without this, each test's own PID gives a fresh cache and
+#      the fixture saves nothing across tests)
+#   3. $$ (current shell PID — local single-test runs, per-process isolated)
+_harness_fixture_root() {
+  if [ -n "${BASSCLEF_HARNESS_FIXTURE_ROOT:-}" ]; then
+    echo "$BASSCLEF_HARNESS_FIXTURE_ROOT"
+  elif [ -n "${SHARD_INDEX:-}" ]; then
+    echo "${TMPDIR:-/tmp}/bassclef-harness-fixture-shard-${SHARD_INDEX}"
+  else
+    echo "${TMPDIR:-/tmp}/bassclef-harness-fixture-$$"
+  fi
+}
+
+# harness_cache_path <target>
+# Echo the cache file path for this target (public accessor). No side effects.
+# Target need not exist — the path is a function of the canonicalized target
+# string (or the raw string when canonicalization fails).
+harness_cache_path() {
+  local target="${1:?harness_cache_path requires target}"
+  # Canonicalize if possible; fall back to raw string when target doesn't exist
+  local canonical
+  canonical=$(cd "$target" 2>/dev/null && pwd) || canonical="$target"
+  local root
+  root=$(_harness_fixture_root)
+  local hash
+  # Use shasum on macOS + Linux; fall back to md5 hash if shasum unavailable
+  if command -v shasum >/dev/null 2>&1; then
+    hash=$(echo "$canonical" | shasum -a 256 | cut -c1-16)
+  elif command -v sha256sum >/dev/null 2>&1; then
+    hash=$(echo "$canonical" | sha256sum | cut -c1-16)
+  else
+    # Last resort — path basename + length; not collision-proof but works
+    hash=$(echo "$canonical" | tr -c 'a-zA-Z0-9' '_' | tail -c 16)
+  fi
+  echo "$root/harness-$hash.out"
+}
+
+# -----------------------------------------------------------------------------
+# fixture_setup_cold_adopter_harness <target>
+# Run the cold-adopter harness once per shard against <target>. Cache stdout
+# + stderr to a per-target file. Second call reuses cache. Echoes cache path.
+# Override SKIP_FIXTURE_BUILDER=1 — return 0 silently.
+# -----------------------------------------------------------------------------
+fixture_setup_cold_adopter_harness() {
+  if [ "${SKIP_FIXTURE_BUILDER:-0}" = "1" ]; then
+    return 0
+  fi
+  local target="${1:?fixture_setup_cold_adopter_harness requires target}"
+  # Canonicalize target path so different spellings share cache
+  local target_canonical
+  target_canonical=$(cd "$target" 2>/dev/null && pwd) || {
+    echo "fixture_setup_cold_adopter_harness: target does not exist: $target" >&2
+    return 1
+  }
+  local root
+  root=$(_harness_fixture_root)
+  mkdir -p "$root"
+  local cache_file
+  cache_file=$(harness_cache_path "$target_canonical")
+  local elapsed_marker="${cache_file}.elapsed"
+  local exit_marker="${cache_file}.exit"
+
+  # Reuse cache if present — cache lifetime is per-shard by design
+  if [ -f "$cache_file" ]; then
+    echo "$cache_file"
+    return 0
+  fi
+
+  # Locate the harness — derived from this lib's location
+  local this_lib="${BASH_SOURCE[0]}"
+  local lib_dir
+  lib_dir=$(cd "$(dirname "$this_lib")" && pwd)
+  local repo
+  repo=$(cd "$lib_dir/.." && pwd)
+  local harness="$repo/scripts/cold-adopter-harness-sync.sh"
+
+  if [ ! -f "$harness" ]; then
+    echo "fixture_setup_cold_adopter_harness: harness not found at $harness" >&2
+    return 1
+  fi
+
+  # Write to temp file + atomic rename so concurrent writers (rare — same PID
+  # scope) do not leave a partial cache readable to other callers.
+  local tmp_file="${cache_file}.tmp.$$"
+  local start end exit_code
+  # K1 instrumentation — record elapsed setup time
+  start=$(date +%s)
+  bash "$harness" --mode sync --target "$target_canonical" > "$tmp_file" 2>&1
+  exit_code=$?
+  end=$(date +%s)
+
+  # Atomic promotion — first writer wins; race loser removes their tmp file.
+  # POSIX rename is atomic within a filesystem. -n avoids clobbering a
+  # concurrent winner's cache (BSD + GNU mv both support -n since 2007).
+  if [ ! -f "$cache_file" ]; then
+    mv "$tmp_file" "$cache_file"
+    echo "$exit_code" > "$exit_marker"
+    echo "$((end - start))" > "$elapsed_marker"
+  else
+    rm -f "$tmp_file"
+  fi
+
+  echo "$cache_file"
+}
+
+# -----------------------------------------------------------------------------
+# harness_exit_code <target>
+# Echo the harness exit code from the cached run. Empty if cache absent.
+# Callers check this before trusting cache content — a non-zero exit means
+# the harness bailed out and content may be partial.
+# Override SKIP_FIXTURE_BUILDER=1 — echo nothing, return 0.
+# -----------------------------------------------------------------------------
+harness_exit_code() {
+  if [ "${SKIP_FIXTURE_BUILDER:-0}" = "1" ]; then
+    return 0
+  fi
+  local target="${1:?harness_exit_code requires target}"
+  local canonical
+  canonical=$(cd "$target" 2>/dev/null && pwd) || canonical="$target"
+  local cache_file
+  cache_file=$(harness_cache_path "$canonical")
+  local exit_marker="${cache_file}.exit"
+  if [ -f "$exit_marker" ]; then
+    cat "$exit_marker"
+  fi
+}
+
+# -----------------------------------------------------------------------------
+# harness_check_output <target>
+# Echo the cached harness stdout+stderr for <target>. Empty output if cache
+# not yet built (caller should invoke fixture_setup_cold_adopter_harness first).
+# Override SKIP_FIXTURE_BUILDER=1 — echo nothing, return 0.
+# -----------------------------------------------------------------------------
+harness_check_output() {
+  if [ "${SKIP_FIXTURE_BUILDER:-0}" = "1" ]; then
+    return 0
+  fi
+  local target="${1:?harness_check_output requires target}"
+  local target_canonical
+  target_canonical=$(cd "$target" 2>/dev/null && pwd) || return 0
+  local cache_file
+  cache_file=$(harness_cache_path "$target_canonical")
+  if [ -f "$cache_file" ]; then
+    cat "$cache_file"
+  fi
+}
+
+# -----------------------------------------------------------------------------
+# fixture_cleanup_cold_adopter_harness
+# Sweep the harness fixture cache. Idempotent.
+# Override SKIP_FIXTURE_BUILDER=1 — return 0 silently.
+# -----------------------------------------------------------------------------
+fixture_cleanup_cold_adopter_harness() {
+  if [ "${SKIP_FIXTURE_BUILDER:-0}" = "1" ]; then
+    return 0
+  fi
+  local root
+  root=$(_harness_fixture_root)
+  if [ -d "$root" ]; then
+    rm -f "$root"/harness-*.out "$root"/harness-*.elapsed "$root"/harness-*.exit "$root"/harness-*.tmp.* 2>/dev/null || true
+  fi
+  return 0
+}
+
+# -----------------------------------------------------------------------------
+# harness_adopter_shape_cache_path <source_target>
+# Echo the cache file path for adopter-shape output derived from <source_target>.
+# Public accessor. No side effects. Same shape as harness_cache_path but with
+# "-adopter-shape" suffix so upstream + adopter-shape caches never collide.
+# -----------------------------------------------------------------------------
+harness_adopter_shape_cache_path() {
+  local target="${1:?harness_adopter_shape_cache_path requires source target}"
+  local canonical
+  canonical=$(cd "$target" 2>/dev/null && pwd) || canonical="$target"
+  local root
+  root=$(_harness_fixture_root)
+  local hash
+  if command -v shasum >/dev/null 2>&1; then
+    hash=$(echo "$canonical" | shasum -a 256 | cut -c1-16)
+  elif command -v sha256sum >/dev/null 2>&1; then
+    hash=$(echo "$canonical" | sha256sum | cut -c1-16)
+  else
+    hash=$(echo "$canonical" | tr -c 'a-zA-Z0-9' '_' | tail -c 16)
+  fi
+  echo "$root/harness-adopter-shape-$hash.out"
+}
+
+# -----------------------------------------------------------------------------
+# fixture_setup_cold_adopter_shape <source_target>
+# Build one synthetic adopter-shape tmpdir per shard from <source_target>
+# (cp -R substrate + rm tests dirs), run the harness once against it, cache
+# stdout + stderr. Second call reuses cache. Echoes cache path.
+#
+# bassclef-upstream#1800 — closes the shard 1 duplicate for
+# cold-adopter-harness-adopter-mode.test.sh Test 1. Test 4 keeps its own
+# tmpdir invocation because rule injection invalidates this fixture's cache;
+# a rule-parameterized variant tracked as follow-on.
+#
+# Override SKIP_FIXTURE_BUILDER=1 — return 0 silently.
+# -----------------------------------------------------------------------------
+fixture_setup_cold_adopter_shape() {
+  if [ "${SKIP_FIXTURE_BUILDER:-0}" = "1" ]; then
+    return 0
+  fi
+  local source_target="${1:?fixture_setup_cold_adopter_shape requires source target}"
+  local source_canonical
+  source_canonical=$(cd "$source_target" 2>/dev/null && pwd) || {
+    echo "fixture_setup_cold_adopter_shape: source target does not exist: $source_target" >&2
+    return 1
+  }
+  local root
+  root=$(_harness_fixture_root)
+  mkdir -p "$root"
+  local cache_file
+  cache_file=$(harness_adopter_shape_cache_path "$source_canonical")
+  local elapsed_marker="${cache_file}.elapsed"
+  local exit_marker="${cache_file}.exit"
+
+  # Reuse cache if present — cache lifetime is per-shard by design
+  if [ -f "$cache_file" ]; then
+    echo "$cache_file"
+    return 0
+  fi
+
+  # Locate the harness — derived from this lib's location
+  local this_lib="${BASH_SOURCE[0]}"
+  local lib_dir
+  lib_dir=$(cd "$(dirname "$this_lib")" && pwd)
+  local repo
+  repo=$(cd "$lib_dir/.." && pwd)
+  local harness="$repo/scripts/cold-adopter-harness-sync.sh"
+
+  if [ ! -f "$harness" ]; then
+    echo "fixture_setup_cold_adopter_shape: harness not found at $harness" >&2
+    return 1
+  fi
+
+  # Build the adopter-shape tmpdir — cp -R substrate + rm tests dirs
+  local adopter_tmpdir
+  adopter_tmpdir=$(mktemp -d "${TMPDIR:-/tmp}/adopter-shape-fixture-XXXXXX")
+  # cp only the surfaces the harness reads; suppress errors on optional dirs
+  cp -R \
+    "$source_canonical/.claude" \
+    "$source_canonical/scripts" \
+    "$source_canonical/lib" \
+    "$source_canonical/standards" \
+    "$source_canonical/architecture" \
+    "$source_canonical/presence" \
+    "$adopter_tmpdir/" 2>/dev/null || true
+  # rm tests dirs to force adopter-shape (0 tests)
+  rm -rf \
+    "$adopter_tmpdir/.claude/hooks/tests" \
+    "$adopter_tmpdir/scripts/tests" \
+    "$adopter_tmpdir/lib/tests" 2>/dev/null || true
+
+  # Run harness with SHAPE_D_BLOCK=0 to match adopter-mode.test.sh semantics
+  # (forces ADVISORY output so DEAD-LETTER surfaces without failing the process)
+  local tmp_file="${cache_file}.tmp.$$"
+  local start end exit_code
+  start=$(date +%s)
+  SHAPE_D_BLOCK=0 bash "$harness" --mode sync --target "$adopter_tmpdir" > "$tmp_file" 2>&1
+  exit_code=$?
+  end=$(date +%s)
+
+  # Cleanup the tmpdir — cache holds the output; tmpdir was ephemeral
+  rm -rf "$adopter_tmpdir" 2>/dev/null || true
+
+  # Atomic promotion — first writer wins; race loser removes their tmp file
+  if [ ! -f "$cache_file" ]; then
+    mv "$tmp_file" "$cache_file"
+    echo "$exit_code" > "$exit_marker"
+    echo "$((end - start))" > "$elapsed_marker"
+  else
+    rm -f "$tmp_file"
+  fi
+
+  echo "$cache_file"
+}
+
+# -----------------------------------------------------------------------------
+# harness_check_output_adopter_shape <source_target>
+# Echo the cached harness stdout+stderr for the adopter-shape variant of
+# <source_target>. Empty output if cache not yet built (caller should invoke
+# fixture_setup_cold_adopter_shape first).
+# Override SKIP_FIXTURE_BUILDER=1 — echo nothing, return 0.
+# -----------------------------------------------------------------------------
+harness_check_output_adopter_shape() {
+  if [ "${SKIP_FIXTURE_BUILDER:-0}" = "1" ]; then
+    return 0
+  fi
+  local target="${1:?harness_check_output_adopter_shape requires source target}"
+  local canonical
+  canonical=$(cd "$target" 2>/dev/null && pwd) || return 0
+  local cache_file
+  cache_file=$(harness_adopter_shape_cache_path "$canonical")
+  if [ -f "$cache_file" ]; then
+    cat "$cache_file"
+  fi
+}

package/dist/lite/lib/workflow-metrics.sh

@@ -0,0 +1,166 @@
+#!/bin/bash
+# tier: lite
+# Workflow metrics measurement library — Module B4 per
+# docs/decompositions/2026-09-18-ci-cd-subsystem.md.
+#
+# Records CI workflow run durations + shard breakdowns. Enables Phase
+# checkpoint sampling per canvas activity diagram. Every downstream
+# Phase 1-4 cure references this lib to prove KPI moves.
+#
+# Closes sunj-labs/bassclef-upstream#1307 (parent epic #1750, rank 0).
+#
+# Anchor luminaries:
+#   @luminary nicole-forsgren — DORA metrics
+#   @luminary john-ousterhout — deep module (hides store shape)
+#   @luminary michael-nygard — fail-soft on missing dir / jq / disk
+#
+# Storage: atomic file per run at
+#   ${STORE_DIR}/YYYY-MM-DD-<workflow>-<run_id>.json
+#
+# Usage:
+#   source lib/workflow-metrics.sh
+#   record_metric <workflow> <run_id> <duration_seconds> <shard_breakdown> [store_dir]
+#   query_metrics [store_dir] [workflow_filter]
+#   compute_median [store_dir] [workflow_filter]
+#
+# Fail-soft everywhere — missing dir, missing jq, disk full all return
+# non-error exits. Missing metrics never turn CI red.
+
+# Default store dir
+_workflow_metrics_default_store() {
+  local repo_root
+  repo_root=$(git rev-parse --show-toplevel 2>/dev/null || echo "$PWD")
+  echo "$repo_root/state/workflow-metrics"
+}
+
+# record_metric <workflow> <run_id> <duration_seconds> <shard_breakdown> [store_dir]
+#
+# Writes a JSON entry to $store_dir/YYYY-MM-DD-<workflow>-<run_id>.json.
+# Fail-soft in every branch — dir creation, jq missing, disk full all
+# return exit 0.
+record_metric() {
+  local workflow="${1:-}"
+  local run_id="${2:-}"
+  local duration="${3:-}"
+  local shard_breakdown="${4:-}"
+  local store_dir="${5:-$(_workflow_metrics_default_store)}"
+
+  # Fail-soft on missing args — never break the calling workflow
+  if [ -z "$workflow" ] || [ -z "$run_id" ] || [ -z "$duration" ]; then
+    return 0
+  fi
+
+  # Fail-soft on dir creation failure
+  mkdir -p "$store_dir" 2>/dev/null || return 0
+
+  local date_prefix
+  date_prefix=$(date -u +"%Y-%m-%d")
+  local timestamp
+  timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+  local file_path="$store_dir/${date_prefix}-${workflow}-${run_id}.json"
+
+  # Build JSON. Prefer jq for correctness; fall back to raw string.
+  if command -v jq >/dev/null 2>&1; then
+    jq -n \
+      --arg workflow "$workflow" \
+      --arg run_id "$run_id" \
+      --argjson duration_seconds "$duration" \
+      --arg shard_breakdown "$shard_breakdown" \
+      --arg timestamp "$timestamp" \
+      '{workflow: $workflow, run_id: $run_id, duration_seconds: $duration_seconds, shard_breakdown: $shard_breakdown, timestamp: $timestamp}' \
+      > "$file_path" 2>/dev/null || return 0
+  else
+    # Fallback — construct JSON by hand
+    printf '{"workflow":"%s","run_id":"%s","duration_seconds":%s,"shard_breakdown":"%s","timestamp":"%s"}\n' \
+      "$workflow" "$run_id" "$duration" "$shard_breakdown" "$timestamp" > "$file_path" 2>/dev/null || return 0
+  fi
+
+  return 0
+}
+
+# query_metrics [store_dir] [workflow_filter]
+#
+# Emits one line per entry to stdout: run_id duration_seconds workflow
+# If workflow_filter is set, only entries matching that workflow are emitted.
+# Empty store or missing dir returns empty output + exit 0.
+query_metrics() {
+  local store_dir="${1:-$(_workflow_metrics_default_store)}"
+  local workflow_filter="${2:-}"
+
+  # Missing dir → empty output
+  if [ ! -d "$store_dir" ]; then
+    return 0
+  fi
+
+  # Find all JSON files under store_dir; fail-soft on empty
+  local files
+  files=$(find "$store_dir" -maxdepth 1 -name '*.json' -type f 2>/dev/null)
+  if [ -z "$files" ]; then
+    return 0
+  fi
+
+  local file workflow run_id duration
+  while IFS= read -r file; do
+    [ -z "$file" ] && continue
+    if command -v jq >/dev/null 2>&1; then
+      workflow=$(jq -r '.workflow // ""' "$file" 2>/dev/null)
+      run_id=$(jq -r '.run_id // ""' "$file" 2>/dev/null)
+      duration=$(jq -r '.duration_seconds // 0' "$file" 2>/dev/null)
+    else
+      workflow=$(grep -o '"workflow":"[^"]*"' "$file" | cut -d'"' -f4)
+      run_id=$(grep -o '"run_id":"[^"]*"' "$file" | cut -d'"' -f4)
+      duration=$(grep -o '"duration_seconds":[0-9]*' "$file" | cut -d':' -f2)
+    fi
+
+    if [ -n "$workflow_filter" ] && [ "$workflow" != "$workflow_filter" ]; then
+      continue
+    fi
+
+    echo "$run_id $duration $workflow"
+  done <<< "$files"
+
+  return 0
+}
+
+# compute_median [store_dir] [workflow_filter]
+#
+# Emits the median duration for entries in the store, optionally filtered
+# by workflow. Empty store returns 0.
+compute_median() {
+  local store_dir="${1:-$(_workflow_metrics_default_store)}"
+  local workflow_filter="${2:-}"
+
+  local durations
+  durations=$(query_metrics "$store_dir" "$workflow_filter" | awk '{print $2}' | sort -n)
+
+  if [ -z "$durations" ]; then
+    echo "0"
+    return 0
+  fi
+
+  local count
+  count=$(echo "$durations" | wc -l | tr -d ' ')
+
+  if [ "$count" -eq 0 ]; then
+    echo "0"
+    return 0
+  fi
+
+  local mid
+  if [ $((count % 2)) -eq 1 ]; then
+    # Odd count — middle element
+    mid=$(( (count + 1) / 2 ))
+    echo "$durations" | sed -n "${mid}p"
+  else
+    # Even count — average of two middle elements
+    local upper=$((count / 2 + 1))
+    local lower=$((count / 2))
+    local u l
+    u=$(echo "$durations" | sed -n "${upper}p")
+    l=$(echo "$durations" | sed -n "${lower}p")
+    echo $(( (u + l) / 2 ))
+  fi
+
+  return 0
+}

package/dist/lite/presence/install/bassclef-configs.template.jsonc

@@ -0,0 +1,76 @@
+{ "tier": "lite",
+  // Adopter-facing default for `.claude/bassclef-configs.jsonc`.
+  // Ships via lite manifest per bassclef-cli#104. `bassclef init` copies this
+  // file to `.claude/bassclef-configs.jsonc` on first-run. Adopters edit it
+  // to tune per-repo behavior.
+  //
+  // Full field catalog + validation: standards/state-spine/schemas/bassclef-configs.schema.json
+  // Field reference doc:              standards/bassclef-configs-schema.md
+  //
+  // Every field below is optional. Absent fields fall back to substrate defaults.
+  // ----- tech stack -----
+  // Declares your primary framework so per-stack skills (SDLC gates,
+  // dependency check, migration discipline) load the right sibling docs.
+  // Common values: "nextjs", "vite-react", "remix", "fastapi", "rails",
+  //                "express", "go-http", or omit for framework-agnostic.
+  //
+  // "tech_stack": {
+  //   "frontend": "nextjs",
+  //   "pkg_manager": "pnpm",
+  //   "orm": "prisma",
+  //   "lang": "typescript"
+  // },
+
+  // ----- prose discipline -----
+  // Controls the /kiss words Stop hook. Values:
+  //   true      — advisory (default; findings to stderr, session continues)
+  //   "strict"  — blocks the stop on jargon findings, forces a rewrite turn
+  //   false     — disabled
+  //
+  // "prose_discipline": {
+  //   "kiss_words_turn_prose": true
+  // },
+
+  // ----- testing tier per path -----
+  // Extends .claude/rules/testing-tier-config.md with per-repo path matchers.
+  // Tier 0 = strict TDD (test mtime <= source mtime, BLOCK at pre-commit)
+  // Tier 1 = test-with (WARN at pre-commit if new source has no matching test)
+  // Tier 2 = smoke (advisory)
+  // Tier 3 = manual verify (silent)
+  //
+  // "testing": {
+  //   "global_floor": 1,
+  //   "path_matchers": [
+  //     { "match": "src/middleware.ts", "tier": 0 },
+  //     { "match": "src/lib/auth/**",   "tier": 0 },
+  //     { "match": "src/app/**",        "tier": 2 }
+  //   ]
+  // },
+
+  // ----- /promote target -----
+  // Where /promote sends substrate proposals. Two shapes:
+  //   "<owner>/<repo>"  — gh issue create --repo <value>
+  //   "email:<address>" — mailto: URL printed for you to send
+  // Absent — /promote falls back to current-repo filing.
+  //
+  // "promote_target": "your-org/your-substrate-fork",
+
+  // ----- longrun orchestrator merge mode -----
+  // Controls how /longrun handles PR merges within its bet scope.
+  //   "operator-gated"           — every PR pauses for your review (default)
+  //   "agent-merges-within-scope" — orchestrator merges autonomously within
+  //                                 bet scope; hard_ceilings stay blocking
+  //
+  // "longrun": {
+  //   "orchestrator_merge": {
+  //     "mode": "operator-gated",
+  //     "hard_ceilings": ["auth", "schema", "security", "prod-deploy", "blast-radius-floor"]
+  //   }
+  // },
+
+  // ----- adopter defaults -----
+  // Per-adopter tunings. See standards/bassclef-configs-schema.md
+  // for the full field list.
+  //
+  // "adopter_defaults": {}
+}