glori-builder 1.0.0

package/.claude/skills/story-builder/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: story-builder
+description: Build comprehensive user stories through structured developer interview — feeds into domain-capture for business logic extraction
+argument-hint: <path-to-prd.md OR "new" for interactive creation>
+disable-model-invocation: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# User Story Builder
+
+## Input Validation
+
+Input: `$ARGUMENTS`
+
+If `$ARGUMENTS` is empty or missing, say: "Usage: `/story-builder .claude/prds/project-prd.md` or `/story-builder new`" and STOP.
+
+If `$ARGUMENTS` is "new", we will create stories from scratch through interview.
+If `$ARGUMENTS` is a file path, verify the file exists. If not, say: "PRD not found at {path}" and STOP.
+
+## Step 1: Identify User Types
+
+### If working from a PRD:
+
+Read the PRD file. Extract every mentioned user type, role, or persona. Present them:
+
+"I found these user types in the PRD:
+1. {user type 1} — {brief description}
+2. {user type 2} — {brief description}
+..."
+
+Ask: "Are these all the user types? Are there any I missed? Any that interact with the system indirectly (admins, testers, API consumers, external systems)?"
+
+### If "new" (no PRD):
+
+Ask: "Who are ALL the people and systems that interact with this application? Think about:
+- The primary end user
+- Administrators or managers
+- Other team roles (testers, support staff, etc.)
+- External systems that send data in (webhooks, APIs)
+- Background processes that act autonomously
+
+List every actor, even if they only do one thing."
+
+Wait for response. Compile the complete user type list.
+
+## Step 2: Map User Journeys Per User Type
+
+For EACH user type identified, walk through their complete journey:
+
+"Let's map everything **{user type}** does. I'll walk through their journey from the moment they first interact with the system."
+
+### Questions per user type:
+
+**Entry Point:**
+"How does {user type} first arrive? What do they see? Is there onboarding?"
+
+**Primary Actions:**
+"What are the main things {user type} does day-to-day? Walk me through a typical session."
+
+**For each action mentioned, drill down:**
+"When {user type} does {action}:
+- What do they see before they act?
+- What do they click/tap/submit?
+- What should happen immediately (optimistic UI)?
+- What should happen in the background?
+- What should other users see as a result?
+- What happens if it fails?
+- Can they undo it?"
+
+**Edge Actions:**
+"What does {user type} do that's NOT part of the daily routine? Settings changes, bulk operations, exports, one-time setup?"
+
+**Exit Points:**
+"How does {user type} leave? Do they log out? Does the session expire? Is there state to preserve?"
+
+## Step 3: Write User Stories
+
+After each user type's journey is complete, write the stories IMMEDIATELY (don't wait for all user types).
+
+Create or append to `.claude/user-stories/{user-type-slug}.md`:
+
+```markdown
+# User Stories: {User Type Name}
+
+## Role Description
+{Who this person is, what they care about, their skill level}
+
+## Daily Workflow
+{The typical session flow, in order}
+
+---
+
+### Story: {Short descriptive name}
+
+**As a** {user type},
+**I want to** {specific action with detail},
+**So that** {business value or outcome}.
+
+#### Scenario: Happy Path
+```
+GIVEN {starting state}
+WHEN {user action}
+THEN {expected result}
+AND {additional consequences — count updates, notifications, status changes}
+```
+
+#### Scenario: Error Case
+```
+GIVEN {starting state}
+WHEN {user action with bad input or failed condition}
+THEN {error handling — what user sees, what gets rolled back}
+```
+
+#### Scenario: Edge Case
+```
+GIVEN {unusual but valid starting state}
+WHEN {user action}
+THEN {expected behavior in this edge case}
+```
+
+#### Affected Entities
+- {entity}: {what changes — field, value, side effect}
+- {entity}: {what changes}
+
+#### Business Rules
+- {any rule that governs this action}
+- {any invariant that must hold}
+
+#### UI States
+- **Loading**: {what user sees while action processes}
+- **Success**: {what user sees on success}
+- **Error**: {what user sees on failure}
+- **Empty**: {what user sees if there's no data}
+
+---
+```
+
+Write stories using the GIVEN/WHEN/THEN format. This is critical — it makes the stories directly testable and directly translatable to business rules for the domain expert.
+
+**Every story MUST include:**
+- At least the happy path scenario
+- Affected entities with specific field changes
+- Business rules that govern the action
+- UI states (loading, success, error, empty)
+
+**Add edge case and error scenarios when:**
+- The developer mentioned them during the interview
+- The action modifies counts or status fields
+- The action affects multiple entities
+- The action can fail partially
+
+## Step 4: Cross-Cutting Concerns
+
+After all user types are covered, ask about rules that apply EVERYWHERE:
+
+"Now let's talk about rules that apply across the entire application:
+
+1. **Authentication**: What happens when a session expires mid-action?
+2. **Authorization**: Are there actions that some user types can see but not perform?
+3. **Multi-tenancy**: What's the isolation boundary? Can users ever see other tenants' data?
+4. **Real-time updates**: When one user acts, do other users see updates immediately?
+5. **Audit trail**: Are there actions that need to be logged for compliance?
+6. **Rate limiting**: Are there actions that need throttling?
+7. **Data retention**: Is anything soft-deleted vs hard-deleted?"
+
+Write cross-cutting stories to `.claude/user-stories/cross-cutting.md`.
+
+## Step 5: Write Story Index
+
+Create `.claude/user-stories/INDEX.md`:
+
+```markdown
+# User Stories Index
+
+Generated: {today's date}
+Project: {project name or directory}
+
+## User Types
+| User Type | Story Count | File |
+|-----------|-------------|------|
+| {type} | {count} | {filename} |
+
+## Story Summary
+| ID | Story Name | User Type | Entities Affected | Has Edge Cases |
+|----|-----------|-----------|-------------------|----------------|
+| US-001 | {name} | {type} | {entities} | Yes/No |
+
+## Cross-Cutting Rules
+{count} rules documented in cross-cutting.md
+
+## Coverage Gaps
+{list any areas the developer wants to revisit later}
+
+## Next Step
+Run `/domain-capture greenfield .claude/user-stories/INDEX.md` to extract
+business rules from these stories into the knowledge base.
+```
+
+## Step 6: Commit
+
+```bash
+git add .claude/user-stories/
+git commit -m "docs: add user stories from story-builder session"
+```
+
+Report to the user:
+
+> **User stories complete.**
+> - User types covered: {count}
+> - Total stories: {count}
+> - Stories with edge cases: {count}
+> - Cross-cutting rules: {count}
+> - Coverage gaps: {count}
+>
+> **Next step**: Run `/domain-capture greenfield .claude/user-stories/INDEX.md`
+> to extract business rules into the knowledge base.
+
+Then STOP.
+
+## Rules
+
+- NEVER invent stories — only document what the developer describes
+- NEVER skip the drill-down questions for primary actions
+- One user type at a time — complete it fully before moving to the next
+- Write stories incrementally after each user type, not at the end
+- Every story must have GIVEN/WHEN/THEN scenarios — no vague descriptions
+- Every story must list affected entities — this feeds the domain expert
+- If the developer says "same as {other user type} but with {difference}", still write separate stories with the differences explicit
+- If the developer says "I'll think about that later", add it to Coverage Gaps
+- The story files are designed to feed directly into `/domain-capture greenfield` — maintain the structured format exactly
+- Number stories sequentially across all files (US-001, US-002, etc.) for easy reference

package/.claude/skills/tab-control/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: tab-control
+description: Create or update .wezterm/project.md with tab name and color
+allowed-tools: Bash, AskUserQuestion, Read, Write
+disable-model-invocation: true
+---
+
+# Tab Control Workflow
+
+Creates or updates a `.wezterm/project.md` file in the project root with a
+tab name on line 1 and a tab color on line 2. If the file already exists,
+shows the current values and lets the user change them.
+
+## Usage
+
+```
+/tab-control
+```
+
+## Instructions
+
+### Step 1: Detect Project Root
+
+```bash
+PROJECT_ROOT=$(git rev-parse --show-toplevel)
+```
+
+### Step 2: Check for Existing Configuration
+
+Check if `.wezterm/project.md` already exists:
+
+```bash
+test -f "$PROJECT_ROOT/.wezterm/project.md" && echo "exists" || echo "missing"
+```
+
+**If it exists**, read the current values and show them to the user:
+
+```bash
+CURRENT_NAME=$(sed -n '1p' "$PROJECT_ROOT/.wezterm/project.md")
+CURRENT_COLOR=$(sed -n '2p' "$PROJECT_ROOT/.wezterm/project.md")
+```
+
+Tell the user: "Current tab config: **NAME** with **COLOR** color."
+
+### Step 3: Ask for Name
+
+Use AskUserQuestion to ask: "What name should appear on the tab?"
+
+- If updating an existing config, include the current name as the first
+  option with "(Keep current)" appended, plus an "Other" option for custom input.
+- If creating new, just ask with a free-text prompt (provide the project
+  directory basename as a suggested default).
+
+### Step 4: Ask for Color
+
+Use AskUserQuestion to ask: "Which color for the tab?"
+
+Offer these 5 options (all values are hex color codes):
+1. **Cyan** - `#00CED1`
+2. **Gold** - `#FFD700`
+3. **Light Blue** - `#87CEEB`
+4. **Orange** - `#FF7F50`
+5. **Green** - `#32CD32`
+
+If updating an existing config, note which color is currently selected in
+the option descriptions.
+
+### Step 5: Write Configuration
+
+Create the directory and file:
+
+```bash
+mkdir -p "$PROJECT_ROOT/.wezterm"
+```
+
+Write `project.md` with exactly two lines:
+- Line 1: the chosen name
+- Line 2: the chosen hex color code (e.g., `#87CEEB`)
+
+Use the Write tool to create `$PROJECT_ROOT/.wezterm/project.md`.
+
+### Step 6: Report
+
+```
+## Tab Configured
+
+**Name:** CHOSEN_NAME
+**Color:** CHOSEN_COLOR
+**File:** .wezterm/project.md
+```
+
+If this was an update, note what changed.

package/.claude/statusline-command.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+
+# Claude Code Status Bar — Minimal, color-coded segments
+# Designed for warm dark theme with true-color ANSI
+# Target render: <50ms (no network calls, single jq, cached git)
+
+# --- 1. Read JSON from stdin, extract ALL fields in one jq call ---
+input=$(cat)
+eval "$(echo "$input" | jq -r '
+  "cwd=" + (.workspace.current_dir // "" | @sh) + "\n" +
+  "project_dir=" + (.workspace.project_dir // "" | @sh) + "\n" +
+  "model=" + (.model.display_name // "" | @sh) + "\n" +
+  "version=" + (.version // "" | @sh) + "\n" +
+  "used_pct=" + (.context_window.used_percentage // 0 | tostring | @sh)
+')"
+
+# Default used_pct to 0 if empty or non-numeric
+[[ "$used_pct" =~ ^[0-9]+$ ]] || used_pct=0
+
+# --- 2. Abbreviate path ---
+home_dir="$HOME"
+if [ -n "$project_dir" ] && [ "$project_dir" != "null" ] && [ "$project_dir" != "$home_dir" ]; then
+  proj_base=$(basename "$project_dir")
+  if [ "$cwd" = "$project_dir" ] || [ -z "$cwd" ] || [ "$cwd" = "null" ]; then
+    display_path="~/${proj_base}"
+  else
+    rel_path="${cwd#"$project_dir"}"
+    display_path="~/${proj_base}${rel_path}"
+  fi
+elif [ -n "$cwd" ] && [ "$cwd" != "null" ] && [ "$cwd" != "$home_dir" ]; then
+  display_path="${cwd/#$home_dir/\~}"
+else
+  display_path="~"
+fi
+
+# --- 3. Get git branch (cached, 5s TTL) ---
+git_cache="/tmp/claude-statusline-git-cache"
+git_dir="${project_dir:-$cwd}"
+branch=""
+
+if [ -n "$git_dir" ] && [ "$git_dir" != "null" ]; then
+  cache_valid=0
+  if [ -f "$git_cache" ]; then
+    if stat -c %Y "$git_cache" >/dev/null 2>&1; then
+      cache_mtime=$(stat -c %Y "$git_cache")
+    else
+      cache_mtime=$(stat -f %m "$git_cache")
+    fi
+    cache_age=$(( $(date +%s) - cache_mtime ))
+    cached_dir=$(head -1 "$git_cache" 2>/dev/null)
+    if [ "$cache_age" -le 5 ] && [ "$cached_dir" = "$git_dir" ]; then
+      cache_valid=1
+      branch=$(tail -1 "$git_cache" 2>/dev/null)
+    fi
+  fi
+
+  if [ "$cache_valid" -eq 0 ]; then
+    branch=$(git -C "$git_dir" --no-optional-locks branch --show-current 2>/dev/null || echo "")
+    printf '%s\n%s\n' "$git_dir" "$branch" > "$git_cache" 2>/dev/null
+  fi
+fi
+
+# --- 4. Determine context threshold color + indicator ---
+if [ "$used_pct" -ge 90 ]; then
+  bar_r=239; bar_g=83; bar_b=80
+  indicator=" new session recommended"
+elif [ "$used_pct" -ge 75 ]; then
+  bar_r=230; bar_g=74; bar_b=25
+  indicator=" consider new session"
+elif [ "$used_pct" -ge 60 ]; then
+  bar_r=217; bar_g=119; bar_b=87
+  indicator=" compacting"
+elif [ "$used_pct" -ge 50 ]; then
+  bar_r=255; bar_g=183; bar_b=77
+  indicator=" compact soon"
+else
+  bar_r=129; bar_g=199; bar_b=132
+  indicator=""
+fi
+
+# --- 4.5. Check for quetrex-base update ---
+update_notice=""
+update_flag="$HOME/.claude/.quetrex-update-available"
+if [ -f "$update_flag" ]; then
+  available_version=$(cat "$update_flag" 2>/dev/null)
+  [ -n "$available_version" ] && update_notice="  ⬆ quetrex-base v${available_version} · /quetrex-update"
+fi
+
+# --- 5. Terminal width ---
+term_width=${COLUMNS:-$(tput cols 2>/dev/null || echo 80)}
+
+# --- 6. Print Line 1: icon+path  icon+branch  icon+model  right-aligned-version ---
+c_path="\033[38;2;217;119;87m"
+c_branch="\033[38;2;77;182;172m"
+c_model="\033[38;2;120;113;108m"
+c_version="\033[38;2;68;64;60m"
+c_reset="\033[0m"
+
+icon_dir="📂"
+icon_model="🤖"
+
+seg_path="${icon_dir} ${display_path}"
+seg_branch=""
+[ -n "$branch" ] && seg_branch="${branch}"
+seg_model="${icon_model} ${model}"
+seg_version=""
+[ -n "$version" ] && [ "$version" != "null" ] && seg_version="v${version}"
+
+emoji_extra=1
+plain_left="${seg_path}"
+[ -n "$seg_branch" ] && plain_left="${plain_left}   ${seg_branch}"
+plain_left="${plain_left}   ${seg_model}"
+emoji_extra=$((emoji_extra + 1))
+plain_len=$(( ${#plain_left} + emoji_extra ))
+
+colored_left="${c_reset}${icon_dir} ${c_path}${display_path}${c_reset}"
+[ -n "$seg_branch" ] && colored_left="${colored_left}   ${c_branch}${branch}${c_reset}"
+colored_left="${colored_left}   ${c_reset}${icon_model} ${c_model}${model}${c_reset}"
+
+if [ -n "$seg_version" ]; then
+  version_len=${#seg_version}
+  gap=$(( term_width - plain_len - version_len ))
+  [ "$gap" -lt 1 ] && gap=1
+  padding=$(printf '%*s' "$gap" '')
+  printf "%b%s%b%s%b\n" "$colored_left" "$padding" "$c_version" "$seg_version" "$c_reset"
+else
+  printf "%b\n" "$colored_left"
+fi
+
+# --- 7. Print Line 2: colored bar + percentage + compact indicator + update notice ---
+pct_label=" ${used_pct}%"
+indicator_len=0
+[ -n "$indicator" ] && indicator_len=${#indicator}
+update_len=0
+[ -n "$update_notice" ] && update_len=${#update_notice}
+label_len=$(( ${#pct_label} + indicator_len + update_len ))
+
+bar_width=$(( term_width - label_len ))
+[ "$bar_width" -lt 10 ] && bar_width=10
+
+filled=$(( used_pct * bar_width / 100 ))
+empty=$(( bar_width - filled ))
+
+bar_filled=""
+bar_empty=""
+for ((i=0; i<filled; i++)); do bar_filled+="▰"; done
+for ((i=0; i<empty; i++)); do bar_empty+="▱"; done
+
+c_empty="\033[38;2;68;64;60m"
+c_bar="\033[38;2;${bar_r};${bar_g};${bar_b}m"
+c_update="\033[38;2;77;182;172m"
+
+printf "%b%s%b%s%b%s%b%s%b%s%b\n" \
+  "$c_bar" "$bar_filled" \
+  "$c_empty" "$bar_empty" \
+  "$c_bar" "$pct_label" \
+  "$c_bar" "$indicator" \
+  "$c_update" "$update_notice" \
+  "$c_reset"

package/.claude/team-protocol.md

@@ -0,0 +1,28 @@
+# Agent Team Protocol
+
+## When to use a team
+- Work touches 3+ files across layers (UI + API + DB)
+- For simpler work, use a single subagent or work directly
+
+## Roles
+- **Lead**: Plans, creates tasks, coordinates. Never writes code.
+- **Teammates**: Independent Claude instances that claim and complete tasks. They don't inherit the lead's conversation — every teammate's brief must include what to build, the files they own, and relevant patterns.
+
+## Plan
+- Each task = a clear deliverable (file, function, or test), small enough to be independently testable
+- **File ownership is the #1 rule: no two teammates edit the same file**
+- Split work along file boundaries; shared types/interfaces go in a dependency task that completes first
+- Declare task dependencies and include acceptance criteria
+
+## Team size
+- Start with 3–5 teammates for most workflows
+
+## Coordinate
+- Monitor via TaskList
+- Send targeted messages — don't broadcast
+
+## Validate
+- Each teammate runs the verification chain in `~/.claude/CLAUDE.md` before marking complete
+- Tests are part of the task that owns the code (or hand off to a `test-writer` agent in the same task)
+- Lead runs the same verification chain before opening the PR
+- On failure, send feedback to the responsible teammate

package/README.md

@@ -0,0 +1,86 @@
+# Glori Builder
+
+Claude Code base configuration for development teams. Agents, skills, and commands for a complete AI-powered development pipeline — from Linear issue to merged PR.
+
+## Install
+
+```bash
+npm install -g glori-builder
+```
+
+Or install directly from GitHub (works with private repos — requires GitHub access):
+
+```bash
+npm install -g github:Barnhardt-Enterprises-Inc/quetrex-base
+```
+
+## First Time on a New Machine
+
+```bash
+/quetrex-setup
+```
+
+Configures GitHub CLI auth, git identity, Linear API key, and direnv.
+
+## First Time on a New Project
+
+```bash
+/project-setup    # CI, branch protection, direnv
+/create-rules     # Stack configuration (Next.js, Python, Rust, Rails, iOS, Go, Node.js)
+```
+
+## Working Issues
+
+```bash
+/issue-prd QUE-123    # Start a Linear issue through the full pipeline
+/merge-issue QUE-123  # Merge the PR and update Linear
+```
+
+## Auto-Pilot (Walk Away Mode)
+
+```bash
+/plan-project         # Plan a new project → creates all Linear issues
+/auto-pilot PROJECT-ID  # Works every issue autonomously until the backlog is empty
+```
+
+## The Pipeline
+
+```
+/issue-prd → architect → developer(s) → QA → reviewer → git-workflow → /merge-issue
+```
+
+Each stage is a specialized agent. QA proves green with actual exit codes. The reviewer (Opus) reads the full diff. PRs squash-merge to main.
+
+## All Commands
+
+| Command | What it does |
+|---|---|
+| `/quetrex-docs` | Full reference — pipeline, commands, agents, setup |
+| `/quetrex-setup` | One-time machine setup |
+| `/project-setup` | One-time project setup |
+| `/create-rules` | Generate project stack configuration |
+| `/update-rules` | Audit and fix existing project rules |
+| `/plan-project` | Plan a new project from scratch |
+| `/plan-feature` | Plan a feature for an existing codebase |
+| `/issue-prd QUE-123` | Start a Linear issue through the pipeline |
+| `/issue-rework QUE-123` | Rework after tester feedback |
+| `/auto-pilot PROJECT-ID` | Autonomous project execution |
+| `/merge-issue QUE-123` | Merge PR, update Linear |
+| `/deploy-setup` | Generate project-specific deploy skill |
+| `/secrets` | Manage API keys |
+| `/quetrex-update` | Check for and apply updates |
+
+## Updates
+
+```bash
+/quetrex-update
+```
+
+Checks the installed version against npm latest and updates if behind.
+
+## Requirements
+
+- Node.js 18+
+- Claude Code
+- GitHub CLI (`gh auth login`)
+- Linear API key (configured via `/quetrex-setup`)

package/install.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const src = path.join(__dirname, '.claude');
+const dest = path.join(os.homedir(), '.claude');
+
+// Files that are never copied or overwritten — user-owned
+const PROTECTED = new Set(['secrets.env']);
+
+function copyDir(srcDir, destDir) {
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFile(srcPath, destPath);
+    }
+  }
+}
+
+function copyFile(srcPath, destPath) {
+  const name = path.basename(srcPath);
+
+  if (PROTECTED.has(name)) {
+    return; // Never touch user secrets
+  }
+
+  if (name === 'settings.json') {
+    mergeSettings(srcPath, destPath);
+    return;
+  }
+
+  fs.copyFileSync(srcPath, destPath);
+  console.log(`  copied: ${destPath.replace(os.homedir(), '~')}`);
+}
+
+function mergeSettings(srcPath, destPath) {
+  const incoming = JSON.parse(fs.readFileSync(srcPath, 'utf8'));
+  let existing = {};
+  if (fs.existsSync(destPath)) {
+    try { existing = JSON.parse(fs.readFileSync(destPath, 'utf8')); } catch {}
+  }
+  const merged = deepMerge(existing, incoming);
+  fs.writeFileSync(destPath, JSON.stringify(merged, null, 2) + '\n');
+  console.log(`  merged: ${destPath.replace(os.homedir(), '~')}`);
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (key in result) {
+      if (isPlainObject(result[key]) && isPlainObject(source[key])) {
+        result[key] = deepMerge(result[key], source[key]);
+      }
+      // existing scalar value wins — never overwrite
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function ensureSecretsEnv() {
+  const secretsPath = path.join(dest, 'secrets.env');
+  if (!fs.existsSync(secretsPath)) {
+    fs.writeFileSync(secretsPath, [
+      '#!/bin/bash',
+      '# quetrex-base secrets — never commit this file',
+      '# Add to your shell profile (~/.zshrc or ~/.bashrc):',
+      '#   source ~/.claude/secrets.env',
+      '#',
+      '# Managed by /secrets and /quetrex-setup',
+      '',
+    ].join('\n'));
+    try {
+      fs.chmodSync(secretsPath, 0o600);
+    } catch {}
+    console.log('  created: ~/.claude/secrets.env (run /quetrex-setup to configure keys)');
+  }
+}
+
+if (!fs.existsSync(src)) {
+  console.log('quetrex/base: no .claude directory found, skipping install');
+  process.exit(0);
+}
+
+console.log('quetrex/base: installing Claude Code configuration...');
+copyDir(src, dest);
+ensureSecretsEnv();
+console.log('quetrex/base: done. Restart Claude Code to load new agents and skills.');