@thebassclef/lite 1.1.1 → 1.2.0-alpha.1

package/dist/lite/.claude/skills/frontend-design/SKILL.md

@@ -0,0 +1,53 @@
+---
+tier: lite
+name: frontend-design
+description: "Create distinctive, production-grade frontend interfaces with high design quality. Avoids generic AI aesthetics."
+problem: "AI-generated frontend interfaces default to generic aesthetics. Distinctive design takes real judgment."
+value: "Creates distinctive production-grade frontend interfaces with high design quality. Avoids generic AI defaults."
+inputs: [A UI intent or design goal, Optional luminary lens]
+outputs: [Frontend implementation with tokens, Component structure, Design-token JSON]
+user_invocable: true
+disable_model_invocation: false
+composes_baseline: anthropic-frontend-design
+---
+
+# Frontend Design
+
+Create distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+## Composes on baseline
+
+Bassclef's authoring composes on top of Anthropic's `frontend-design` skill defaults. Adopters firing plain Claude (without bassclef substrate) inherit those defaults; this skill extends them with luminary-pair commitment (Cooper + Norman for UX, Ive + Rams + Tufte for visual altitude) plus `/personas` + `/jtbd-tasks` context inheritance and the bassclef operator-facing prose discipline.
+
+The baseline does the typography + color + motion + spatial-composition work. This skill adds the substrate-aware composition layer on top.
+
+Per `.claude/rules/context-engineering.md` and Karpathy's CPU/RAM framing: every "DON'T" or "AVOID" instruction in this skill's body pairs with an actionable INSTEAD substitute so the model has one-pass context. If you find a violation, file bassclef-evolution.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian
+- **Constraints**: Technical requirements (framework, performance, accessibility)
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work — the key is intentionality, not intensity.
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts (Arial, Inter, Roboto). Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. One well-orchestrated page load with staggered reveals creates more delight than scattered micro-interactions.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Atmosphere and depth — gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows.
+
+NEVER use generic AI aesthetics: overused font families, cliched purple gradients on white, predictable layouts, cookie-cutter design that lacks context-specific character.
+
+Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code. Minimalist designs need restraint, precision, and careful attention to spacing.
+
+## Output discipline
+
+Dispatch `/kiss words --rewrite` on your skill output before you return it. See `standards/skill-output-discipline.md` for the contract.

package/dist/lite/.claude/skills/interview-me/SKILL.md

@@ -0,0 +1,171 @@
+---
+tier: lite
+name: interview-me
+description: "Run a 3-box lean-canvas discovery for one adopter \u2014 problem, early adopter, empathy map. Two sizes: quick (30 min) and full (90 min). Calls /state-a-problem, /empathy-map, /value-prop. Produces a filled canvas plus candidate JTBDs."
+problem: "New adopters don't know how to explain their product in a way downstream skills can act on."
+value: "3-box lean-canvas discovery for one adopter \u2014 problem then early adopter then empathy map."
+inputs: [Adopter self-intro or product description, Optional size — brief or full]
+outputs: [Filled 3-box canvas, Early adopter persona, Empathy map]
+user_invocable: true
+disable_model_invocation: false
+sizes: [quick, full]
+composes_with: [state-a-problem, empathy-map, value-prop]
+composes_baseline: [ash-maurya, tony-ulwick, dave-gray]
+---
+
+# /interview-me — Lean-canvas discovery for adopter build kickoff
+
+Run an adopter through the three key boxes of Ash Maurya's lean canvas before they commit to a build. The skill starts with the problem the adopter wants to solve, drills into who the early adopter is, walks Dave Gray's empathy map to surface pains and gains, and synthesizes candidate JTBDs to seed the build flywheel.
+
+This is discovery, not implementation. The output feeds `/build`, `/spec`, `/user-stories`, and `/launch` downstream.
+
+Two sizes on a single axis: how much time you have for discovery.
+
+- **quick** (default): 30 minutes, 3 questions per box, light-mode empathy map. Good for a solo operator with limited discovery time who wants a canvas snippet before starting a prototype. Skips deep JTBD probes.
+- **full**: 90 minutes, 8-12 questions per box, deep-mode empathy map, JTBD synthesis pass. Good for a research-grade adopter kickoff or a new-product discovery arc. Produces a full lean-canvas snippet ready to feed `/launch`.
+
+## Sources read
+
+- `.claude/luminaries/ash-maurya.md` — lean-canvas structure and problem-early-adopter framing
+- `.claude/luminaries/tony-ulwick.md` — JTBD synthesis anchor (Ulwick's "when I ___, I want to ___, so I can ___")
+- `.claude/luminaries/dave-gray.md` — empathy map canvas (2017 updated 7-section version)
+- `.claude/skills/state-a-problem/SKILL.md` — problem framing skill this composes with
+- `.claude/skills/empathy-map/SKILL.md` — empathy map skill this composes with
+- `.claude/skills/value-prop/SKILL.md` — value-prop skill this composes with
+- Operator direction 2026-07-07 evening — three-box focus, not full nine-box
+
+## Sources used
+
+### Ash Maurya — Lean Canvas (three key boxes)
+
+The lean canvas has 9 boxes total. The three most important for adopter discovery:
+
+- **Problem** — the top 1-3 problems the target customer has
+- **Customer Segments** — who has those problems (including the early adopter — the person hurting most, not the average user)
+- **Unique Value Proposition** — one clear message that turns visitors into interested users
+
+`/interview-me` focuses on Problem + Customer Segments (via empathy map) + UVP (drafted via `/value-prop brief` at close).
+
+### Tony Ulwick — JTBD synthesis
+
+Format: "When I [circumstance], I want to [motivation], so I can [expected outcome]."
+
+The empathy map's Pains and Gains bands feed directly into Ulwick's JTBD template. Circumstance comes from See/Hear. Motivation comes from Do/Say. Expected outcome comes from Gains.
+
+### Dave Gray — Empathy Map
+
+Called as `/empathy-map light` (quick size) or `/empathy-map deep` (full size). See `.claude/skills/empathy-map/SKILL.md` for the sensor-first discipline.
+
+## When to use
+
+- **New adopter arriving at bassclef** — pair with `/onboard-repo` for the first-30-day flow
+- **Feature discovery before /launch** — before turning an idea into a buildable plan, ground it in a real persona
+- **Restart on a product that lost its way** — walk the three boxes for the persona you thought you were serving; compare against reality
+- **Adopter says "I want to build X"** — before scoping the build, run the discovery to check the WHO and WHY
+
+INSTEAD of running this skill when the adopter already has a filled lean canvas and validated persona: skip to `/launch` or `/build`. Discovery repeated when it is not owed slows the ship without adding signal.
+
+## Procedure
+
+### Common to both sizes
+
+1. **Ask for the initial framing** — one paragraph: what does the adopter want to build, and for whom
+2. **Detect if this is new discovery or a re-anchor** — if adopter already has personas + canvas, offer to skip to gap-check; if new, walk the full flow
+3. **Dispatch Step 1: problem** — call `/state-a-problem para` for a 5-block problem statement (Who/What/When/Why-now/Outcome). Capture output at `docs/discovery/<slug>/problem.md`
+4. **Dispatch Step 2: empathy map** — call `/empathy-map` (light for quick size, deep for full size). Capture output at `docs/discovery/<slug>/empathy-map.md`
+5. **Step 3: JTBD synthesis** — read empathy map's Pains and Gains; draft 2-4 candidate JTBDs in Ulwick format
+6. **Dispatch Step 4: UVP draft** — call `/value-prop brief` with the problem + persona + top JTBD as input. Capture at `docs/discovery/<slug>/value-prop.md`
+7. **Compose the canvas snippet** — pull problem, early adopter (from empathy map's Goal + Say + Do), and UVP into a 3-box canvas at `docs/discovery/<slug>/canvas.md`
+8. **Report** — surface the three files + top JTBDs to operator; propose next-step (`/launch quick` or `/user-stories` or "run more interviews first")
+
+### Quick size (30 min)
+
+- Step 1: `/state-a-problem para` in default mode (no --deep)
+- Step 2: `/empathy-map light` (5 min per band)
+- Step 3: 2 candidate JTBDs
+- Step 4: `/value-prop brief` (3 RTBs)
+- Total: ~30 minutes
+
+### Full size (90 min)
+
+- Step 1: `/state-a-problem para` with deep probing on Why-now
+- Step 2: `/empathy-map deep` (15 min per band, transcript timestamps)
+- Step 3: 4 candidate JTBDs with per-JTBD priority and evidence
+- Step 4: `/value-prop verbose` (full Dunford + Moore positioning)
+- Extra: propose 2-3 next-step research questions to close remaining gaps
+- Total: ~90 minutes
+
+## Output
+
+Structured markdown files under `docs/discovery/<slug>/`:
+
+```
+docs/discovery/small-team-cto-ops-tool/
+  problem.md          — /state-a-problem output
+  empathy-map.md      — /empathy-map output
+  value-prop.md       — /value-prop output
+  canvas.md           — 3-box lean-canvas snippet
+  jtbds.md            — candidate JTBDs in Ulwick format
+```
+
+Sample `canvas.md`:
+
+```markdown
+---
+adopter_slug: small-team-cto-ops-tool
+date: 2026-07-07
+size: quick
+---
+
+# Lean-canvas snippet — small-team CTO ops tool
+
+## Problem (top 3)
+
+1. Team ships slow because tool sprawl adds onboarding cost per feature
+2. Operator carries both technical direction and product triage; loses architecture time
+3. Existing spreadsheets rot into shadow systems; ops team stops trusting the source
+
+## Early adopter
+
+Small-team CTOs (2-8 engineers) shipping SaaS in a competitive vertical. Reads Hacker News; deploys 3-5 times per day; has never used a low-code tool but wants one that works on day one.
+
+## Unique value proposition
+
+*"Working ops tools your team actually uses — without a 6-week onboarding."*
+
+**Why to believe:**
+1. Reference customer X shipped their first ops flow in 3 days
+2. Bassclef substrate handles CI/TDD setup so new hires ramp in half the time
+3. Tool works from day one — no ceremony, no shadow spreadsheets
+
+## Candidate JTBDs
+
+1. When I onboard a new engineer, I want the team's ops tools to be self-explanatory, so I can preserve my architecture time
+2. When the ops team needs a new dashboard, I want a working baseline in hours not weeks, so I can respond to business questions without a full sprint
+```
+
+## Composes with
+
+Frontmatter declares `composes_with: [state-a-problem, empathy-map, value-prop]` — the three skills this dispatches inline as procedure steps. Each is verified to exist on disk by the substrate-clarity-gate hook.
+
+Ash Maurya is the primary luminary anchor (via `composes_baseline`); Tony Ulwick is the JTBD anchor; Dave Gray is the empathy-map anchor.
+
+## Anti-patterns it prevents
+
+- **Skipping discovery to jump to build** — the skill refuses to compose UVP before the empathy map is populated. INSTEAD of shipping a value prop without persona evidence: fill the empathy map first, then draft the UVP.
+- **Persona invention** — every JTBD candidate must cite an empathy-map band that grounds the circumstance and motivation. INSTEAD of accepting a JTBD without evidence: skill asks "which empathy-map line does this rest on?"
+- **Dropping out mid-interview (quick size)** — 30-minute size is deliberately short; the skill does not add ceremony that stalls the operator mid-flow. INSTEAD of forcing full ceremony on a quick pass: reserve deep questions for the `full` size.
+- **Solving the wrong problem** — the skill walks Problem BEFORE Solution. INSTEAD of assuming the adopter's stated build is the right build: `/state-a-problem` at Step 1 re-frames Who/What/When/Why-now before UVP.
+
+## Refs
+
+- Ticket #653 — this skill's filing
+- Bet 2026-07-07a — this skill's ship vehicle
+- Luminary file `.claude/luminaries/ash-maurya.md` — primary anchor
+- Luminary file `.claude/luminaries/dave-gray.md` — empathy-map anchor
+- Luminary file `.claude/luminaries/tony-ulwick.md` — JTBD anchor
+- Rule `.claude/rules/skill-composition-declarations.md` — the composability discipline this skill honors
+
+## Output discipline
+
+Dispatch `/kiss words --rewrite` on your skill output before you return it. See `standards/skill-output-discipline.md` for the contract.

package/dist/lite/.claude/skills/journal-export/SKILL.md

@@ -0,0 +1,293 @@
+---
+tier: lite
+name: journal-export
+description: "Generate a structured journal-entry corpus for a brand team or your own archive \u2014 chronicle digest, draft index, moment inventory. Supports incremental updates."
+problem: "Journal drafts pile up locally. Brand teams and archives don't get them systematically."
+value: "Structured journal-entry corpus for a brand team or your own archive. Chronicle digest included."
+inputs: [Time range or theme filter]
+outputs: [Corpus JSON, Google Doc export, Archive-ready file]
+user_invocable: true
+disable_model_invocation: false
+requires:
+  files: [standards/writing-guide.md]
+  network: true
+---
+
+# /journal export — Journal-Entry Corpus
+
+Generate a structured content corpus from session chronicles and existing
+drafts. The corpus gives the brand team everything they need to produce
+journal entries without understanding the codebase.
+
+## Usage
+
+```
+/journal export              → full generation (first run or rebuild)
+/journal export incremental  → update with new sessions since last export
+```
+
+## What the corpus contains
+
+### 1. Chronicle digest
+
+Every session summarized in ~150 words:
+- Date and repo
+- Theme tags (governance, reliability, design, constraint, methodology, product)
+- Key moment (the single most compelling thing that happened)
+- Quotable decision or insight (one sentence a brand team member can latch onto)
+- Audience fit (Board/PE, Engineering, or both)
+
+### 2. Draft index
+
+Every existing journal entry with:
+- Date and source repo
+- Topic/title
+- Variant (A: Board or B: Engineering)
+- Angle taken
+- Status (drafted / published / held)
+- Hook strength assessment
+
+### 3. Moment inventory
+
+Pre-mined moments across major themes. Each moment has:
+- Date, repo, session title
+- What happened (2-3 sentences)
+- Why it matters as a journal entry (tension, stakes, surprise, result)
+- Audience fit and hook strength
+- Whether an existing draft already covers this angle
+
+### 4. Writing guide bundle
+
+Packaged for external handoff:
+- `standards/writing-guide.md` content (journal-entry style guide)
+- Audience definitions (PE/board vs. engineering variants)
+- Vocabulary rules (concept names, not implementation details)
+- Post structure (Hook → Setup → Body → Takeaway)
+
+## Procedure
+
+### Step 1: Locate all sources
+
+```
+Chronicles:
+  ~/src/sunj-labs/bassclef/chronicle/
+  ~/src/your-org/your-app/docs/chronicle/
+  ~/src/your-org/your-second-app/docs/chronicle/
+
+Existing drafts:
+  ~/src/sunj-labs/bassclef/docs/operator-private/journals/
+  ~/src/your-org/your-app/docs/operator-private/journals/
+  ~/src/your-org/your-app/docs/operator-private/journals/legacy/   (pre-substrate content)
+
+Writing guide:
+  ~/src/sunj-labs/bassclef/standards/writing-guide.md
+```
+
+### Step 2: Check for previous export
+
+Look for `docs/journal-corpus/` in bassclef. If it exists and the
+mode is `incremental`:
+- Read `docs/journal-corpus/last-export.md` for the last export date
+- Only process chronicles and drafts newer than that date
+- Append to existing corpus sections
+
+If full mode or no previous export: generate everything from scratch.
+
+### Step 3: Read all chronicles
+
+For each chronicle:
+1. Read the full file
+2. Extract: date, repo, title, tags, key decisions, notable moments
+3. Assign theme tags from this list:
+   - **governance**: rules, gates, guardrails, permissions, ADRs, hooks
+   - **reliability**: failures, diagnosis, fixes, what broke, resilience
+   - **design**: luminaries, prototypes, visual review, UX migration, taste
+   - **constraint**: budget, time budget, scope kills, trade-offs, real stakes
+   - **methodology**: SDLC, choreography, skills, agents, substrate, process
+   - **product**: features built, user-facing outcomes, family use, deals
+   - **infrastructure**: deployment, CI/CD, bassclef sync, tooling
+4. Identify the key moment (strongest journal-worthy content)
+5. Rate audience fit and hook strength
+
+### Step 4: Read all existing drafts
+
+For each draft:
+1. Read the file
+2. Extract: date, topic/title, variant, audience, angle
+3. Note status (drafts in legacy/ are "pre-substrate")
+
+### Step 5: Pre-mine major themes
+
+Run theme matching (same logic as `/journal mine`) for these themes:
+- "The autonomous SDLC journey"
+- "Governance that scales"
+- "Building under constraint"
+- "Design taste in AI agents"
+- "What broke"
+- "From zero to production"
+
+Surface top 3-5 moments per theme.
+
+### Step 6: Assemble the corpus
+
+Write to `docs/journal-corpus/`:
+
+```
+docs/journal-corpus/
+  corpus.md              # main document — digest + index + inventory
+  last-export.md         # metadata for incremental updates
+  writing-guide.md       # copy of standards/writing-guide.md for handoff
+```
+
+**corpus.md** structure:
+
+```markdown
+# Content Corpus — <your-org>
+
+Generated: YYYY-MM-DD
+Sessions covered: N (Dec 2025 - [latest])
+Repos: <list-the-repos-you-mine-chronicles-from>
+
+## How to use this document
+
+This corpus contains the raw material for journal-entry content. Each session
+is summarized with theme tags and a key moment. To write a post:
+
+1. Pick a theme or topic you want to write about
+2. Find moments that serve that theme (use the theme index below)
+3. Pick the strongest moment
+4. Draft a standalone post — every post must work on its own,
+   even if it covers a theme you've posted about before
+
+## Chronicle digest
+
+### [Repo name]
+
+| Date | Title | Themes | Key moment | Audience | Hook |
+|------|-------|--------|-----------|----------|------|
+| ... | ... | ... | ... | ... | ... |
+
+[For each session, a ~150 word summary follows the table]
+
+## Draft index
+
+| Date | Repo | Title | Variant | Audience | Angle | Status |
+|------|------|-------|---------|----------|-------|--------|
+| ... | ... | ... | ... | ... | ... | ... |
+
+## Moment inventory by theme
+
+### [Theme name]
+
+| # | Date | Repo | Moment | Why it's strong | Hook |
+|---|------|------|--------|-----------------|------|
+| ... | ... | ... | ... | ... | ... |
+
+[Repeated for each theme]
+
+## Writing guide
+
+[Full writing guide content]
+```
+
+### Step 7: Push to Google Docs
+
+Push the corpus to the brand team corpus doc. Read the doc ID from
+bassclef's `substrate.config.md` field `brand_corpus_doc_id` — never
+hardcode (per `standards/substrate-config-schema.md`):
+
+```bash
+DOC_ID=$(grep "^brand_corpus_doc_id:" substrate.config.md | awk '{print $2}')
+npx tsx ~/src/your-org/your-app/scripts/push-to-gdoc.ts \
+  --file docs/journal-corpus/corpus.md --replace \
+  --doc-id "$DOC_ID"
+```
+
+Use `--replace` to clear the doc first and re-push the full corpus
+(appending accumulates duplicates over time).
+
+The brand team corpus doc is separate from per-repo draft docs. It
+contains session digests, moment inventory, and writing guide — not
+the full post drafts. The per-repo drafts push separately at session-
+end using each repo's `journal_doc_id`.
+
+All doc IDs live in `substrate.config.md` — never hardcoded here,
+never stored in memory. See `standards/substrate-config-schema.md`
+for the bassclef field convention.
+
+### Step 7a: Defer push when capabilities missing
+
+If `brand_corpus_doc_id` is configured but this session cannot push
+(missing `gcloud-auth` / `google-docs-write` — ephemeral-mobile,
+cloud-web, or desktop without the SA key), DO NOT silently skip. Write
+a deferred-action entry:
+
+```bash
+TS=$(date -u +"%Y-%m-%dT%H-%M-%SZ")
+ID="${TS}-journal-export-corpus-push"
+cp templates/deferred-action-template.md \
+   "docs/deferred-actions/${ID}.md"
+# Fill frontmatter:
+#   pending_action: push-brand-corpus-to-gdoc
+#   requires_capability: [gcloud-auth, google-docs-write]
+#   priority: medium
+#   origin_skill: /journal-export
+#   resolves_when: |
+#     Brand corpus doc <brand_corpus_doc_id> reflects docs/journal-corpus/corpus.md
+# Body should cross-ref the corpus file + last-export.md.
+git add "docs/deferred-actions/${ID}.md"
+git commit -m "chore: defer journal-export corpus-push"
+```
+
+See `.claude/rules/deferred-actions.md` and
+`standards/deferred-actions-schema.md`.
+
+### Step 8: Record metadata
+
+Write `docs/journal-corpus/last-export.md`:
+
+```markdown
+---
+last_export: YYYY-MM-DD
+sessions_covered: N
+repos: [<list of mined repos>]
+chronicles_processed: N
+drafts_indexed: N
+themes_mined: N
+---
+```
+
+## Incremental mode
+
+When called with `incremental`:
+1. Read `last-export.md` for the cutoff date
+2. Only read chronicles newer than the cutoff
+3. Only read drafts newer than the cutoff
+4. Append new sessions to the chronicle digest
+5. Append new drafts to the draft index
+6. Re-run theme mining with new material included
+7. Update `last-export.md` with new date and counts
+
+## Rules
+
+- The corpus is for external consumption — no internal jargon, file paths,
+  or skill names unless they're in the vocabulary guide
+- Every session gets a summary even if it's "low" hook strength —
+  the brand team decides what's worth writing about
+- Theme tags are additive — a session can have multiple themes
+- The writing guide section uses the SENTINEL_bassclef_version verbatim
+- Incremental updates append, never overwrite existing entries
+
+## Scheduled refresh (Level 1 automation)
+
+The brand team corpus can be kept fresh automatically via a scheduled agent.
+See `docs/journal-corpus/REFRESH.md` for:
+
+- Manual refresh procedure (step-by-step bash commands)
+- Automated refresh setup using the `/schedule` skill (weekly, Monday 9am)
+- A map of all three Google Docs and how each one stays current
+- Troubleshooting guide
+
+## Output discipline
+
+Dispatch `/kiss words --rewrite` on your skill output before you return it. See `standards/skill-output-discipline.md` for the contract.