qualia-framework 2.1.0

package/framework/scripts/showcase-video-recorder/ffmpeg-builder.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * FFmpeg Command Builder for Showcase Videos
+ * Bundled with showcase-video-recorder skill
+ *
+ * Usage:
+ *   node ffmpeg-builder.js <input.webm> <output.mp4> [scenes.json]
+ *
+ * If scenes.json not provided, reads from stdin.
+ * scenes.json format: [{ "name": "landing", "time": 0, "speed": 1.0 }, ...]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TARGET_DURATION = 60; // seconds
+
+function buildFfmpegCommand(inputFile, outputFile, scenes) {
+  // Validate scenes
+  if (!scenes || scenes.length < 2) {
+    throw new Error('Need at least 2 scene markers (start + end)');
+  }
+
+  // Ensure scenes are sorted by time
+  scenes.sort((a, b) => a.time - b.time);
+
+  // Build segments (each scene runs until the next scene starts)
+  const segments = [];
+  for (let i = 0; i < scenes.length - 1; i++) {
+    const raw = scenes[i + 1].time - scenes[i].time;
+    const speed = scenes[i].speed || 1.3; // default speed if not specified
+    const final = raw / speed;
+    segments.push({
+      name: scenes[i].name,
+      start: scenes[i].time,
+      end: scenes[i + 1].time,
+      raw,
+      speed,
+      final,
+    });
+  }
+
+  // Calculate total
+  const totalFinal = segments.reduce((sum, s) => sum + s.final, 0);
+
+  // Print segment breakdown
+  console.log('=== SEGMENT BREAKDOWN ===');
+  for (const s of segments) {
+    console.log(`  ${s.name}: ${s.raw.toFixed(1)}s raw -> ${s.final.toFixed(1)}s @ ${s.speed}x`);
+  }
+  console.log(`  TOTAL: ${totalFinal.toFixed(1)}s (target: ${TARGET_DURATION}s)`);
+
+  if (totalFinal < 45 || totalFinal > 75) {
+    console.warn(`\n  WARNING: Total duration ${totalFinal.toFixed(1)}s is outside 45-75s range.`);
+    console.warn('   Adjust speeds and re-run.\n');
+  }
+
+  // Build ffmpeg filter_complex
+  const N = segments.length;
+  const splitOutputs = segments.map((_, i) => `[s${i + 1}]`).join('');
+  const trimFilters = segments.map((s, i) =>
+    `[s${i + 1}]trim=start=${s.start.toFixed(3)}:end=${s.end.toFixed(3)},setpts=(PTS-STARTPTS)/${s.speed}[v${i + 1}]`
+  ).join(';\n    ');
+  const concatInputs = segments.map((_, i) => `[v${i + 1}]`).join('');
+
+  const cmd = `ffmpeg -i "${inputFile}" \\
+  -filter_complex "
+    [0:v]split=${N}${splitOutputs};
+    ${trimFilters};
+    ${concatInputs}concat=n=${N}:v=1:a=0[out]
+  " \\
+  -map "[out]" \\
+  -c:v libx264 -preset medium -crf 20 \\
+  -pix_fmt yuv420p -r 30 -s 1920x1080 \\
+  -movflags +faststart \\
+  "${outputFile}"`;
+
+  return { cmd, segments, totalFinal };
+}
+
+function autoTuneSpeeds(scenes, targetDuration = TARGET_DURATION) {
+  const scenesCopy = scenes.map(s => ({ ...s }));
+
+  // Default all to 1.3x if no speed set
+  for (const s of scenesCopy) {
+    if (!s.speed) s.speed = 1.3;
+  }
+
+  // Calculate initial total
+  let total = 0;
+  for (let i = 0; i < scenesCopy.length - 1; i++) {
+    const raw = scenesCopy[i + 1].time - scenesCopy[i].time;
+    total += raw / scenesCopy[i].speed;
+  }
+
+  // Iteratively adjust
+  const maxIterations = 20;
+  for (let iter = 0; iter < maxIterations; iter++) {
+    const ratio = total / targetDuration;
+    if (Math.abs(ratio - 1.0) < 0.05) break; // Within 5% of target
+
+    // Scale all speeds proportionally
+    for (const s of scenesCopy) {
+      s.speed = Math.min(4.0, Math.max(0.8, s.speed * ratio));
+    }
+
+    // Recalculate
+    total = 0;
+    for (let i = 0; i < scenesCopy.length - 1; i++) {
+      const raw = scenesCopy[i + 1].time - scenesCopy[i].time;
+      total += raw / scenesCopy[i].speed;
+    }
+  }
+
+  // Round speeds to 1 decimal
+  for (const s of scenesCopy) {
+    s.speed = Math.round(s.speed * 10) / 10;
+  }
+
+  return scenesCopy;
+}
+
+// CLI entry point
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  if (args.length < 2) {
+    console.log('Usage: node ffmpeg-builder.js <input.webm> <output.mp4> [scenes.json]');
+    console.log('\nscenes.json example:');
+    console.log(JSON.stringify([
+      { name: 'landing', time: 0, speed: 1.0 },
+      { name: 'dashboard', time: 8, speed: 1.5 },
+      { name: 'feature-a', time: 20, speed: 1.2 },
+      { name: 'end', time: 80 },
+    ], null, 2));
+    process.exit(1);
+  }
+
+  const [inputFile, outputFile, scenesFile] = args;
+
+  let scenes;
+  if (scenesFile) {
+    scenes = JSON.parse(fs.readFileSync(scenesFile, 'utf-8'));
+  } else {
+    // Read from stdin
+    console.log('Paste scene timestamps JSON (Ctrl+D when done):');
+    const input = fs.readFileSync('/dev/stdin', 'utf-8');
+    scenes = JSON.parse(input);
+  }
+
+  // Auto-tune if speeds not all defined
+  const hasAllSpeeds = scenes.every(s => s.speed !== undefined);
+  if (!hasAllSpeeds) {
+    console.log('Auto-tuning speeds to hit ~60s...');
+    scenes = autoTuneSpeeds(scenes);
+  }
+
+  const { cmd, totalFinal } = buildFfmpegCommand(inputFile, outputFile, scenes);
+
+  console.log('\n=== FFMPEG COMMAND ===');
+  console.log(cmd);
+
+  console.log(`\nEstimated output: ${totalFinal.toFixed(1)}s`);
+  console.log('Run the command above to process the video.');
+}
+
+module.exports = { buildFfmpegCommand, autoTuneSpeeds };

package/framework/scripts/showcase-video-recorder/playwright-helpers.js

@@ -0,0 +1,216 @@
+/**
+ * Playwright Recording Helpers
+ * Bundled with showcase-video-recorder skill
+ *
+ * Usage: const helpers = require('./playwright-helpers');
+ */
+
+/**
+ * Mask all input fields to hide credentials.
+ * Call BEFORE submitting login forms.
+ */
+async function maskInputs(page) {
+  await page.evaluate(() => {
+    document.querySelectorAll('input[type="password"], input[type="email"], input[type="text"]')
+      .forEach(el => {
+        el.style.webkitTextSecurity = 'disc';
+        el.style.color = 'transparent';
+        el.style.textShadow = '0 0 8px rgba(255,255,255,0.5)';
+      });
+  });
+}
+
+/**
+ * Smooth scroll with cubic ease-in-out.
+ * @param {import('playwright').Page} page
+ * @param {number} targetY - Target scroll position in pixels
+ * @param {number} duration - Animation duration in ms (default 1500)
+ */
+async function smoothScroll(page, targetY, duration = 1500) {
+  await page.evaluate(async ({ targetY, duration }) => {
+    const startY = window.scrollY;
+    const distance = targetY - startY;
+    const startTime = performance.now();
+    return new Promise(resolve => {
+      function step(currentTime) {
+        const elapsed = currentTime - startTime;
+        const progress = Math.min(elapsed / duration, 1);
+        // Cubic ease-in-out
+        const ease = progress < 0.5
+          ? 4 * progress * progress * progress
+          : 1 - Math.pow(-2 * progress + 2, 3) / 2;
+        window.scrollTo(0, startY + distance * ease);
+        if (progress < 1) requestAnimationFrame(step);
+        else resolve();
+      }
+      requestAnimationFrame(step);
+    });
+  }, { targetY, duration });
+}
+
+/**
+ * Click a button by its accessible name, with fallback to text content.
+ * @returns {boolean} true if clicked, false if not found
+ */
+async function clickButton(page, text, timeout = 5000) {
+  try {
+    const btn = page.getByRole('button', { name: text });
+    await btn.waitFor({ state: 'visible', timeout });
+    await btn.scrollIntoViewIfNeeded();
+    await page.waitForTimeout(300);
+    await btn.click();
+    return true;
+  } catch {
+    try {
+      const fallback = page.locator(`text="${text}"`).first();
+      await fallback.waitFor({ state: 'visible', timeout: 3000 });
+      await fallback.click();
+      return true;
+    } catch {
+      console.log(`[WARN] Button not found: "${text}" — skipping`);
+      return false;
+    }
+  }
+}
+
+/**
+ * Type text with natural human-like timing variation.
+ * @param {number} baseDelay - Base delay between keystrokes in ms
+ */
+async function naturalType(page, selector, text, baseDelay = 80) {
+  const el = page.locator(selector).first();
+  await el.waitFor({ state: 'visible', timeout: 5000 });
+  await el.click();
+  await page.waitForTimeout(200);
+  for (const char of text) {
+    await el.type(char, { delay: 0 });
+    const delay = baseDelay + Math.random() * 60 - 30;
+    await page.waitForTimeout(Math.max(30, delay));
+  }
+}
+
+/**
+ * Add a custom cursor highlight ring that follows mouse movement.
+ * Teal border (#00FFD1) with purple click feedback (#8B5CF6).
+ * Must be called after every page navigation (ring is lost on navigation).
+ */
+async function addCursorHighlight(page) {
+  await page.evaluate(() => {
+    // Remove existing ring if present
+    const existing = document.getElementById('cursor-highlight');
+    if (existing) existing.remove();
+
+    const ring = document.createElement('div');
+    ring.id = 'cursor-highlight';
+    ring.style.cssText = `
+      position: fixed; width: 28px; height: 28px;
+      border: 2px solid #00FFD1; border-radius: 50%;
+      pointer-events: none; z-index: 999999;
+      transform: translate(-50%, -50%);
+      transition: all 0.15s ease-out;
+      box-shadow: 0 0 10px rgba(0,255,209,0.3);
+    `;
+    document.body.appendChild(ring);
+
+    document.addEventListener('mousemove', e => {
+      ring.style.left = e.clientX + 'px';
+      ring.style.top = e.clientY + 'px';
+    });
+
+    document.addEventListener('mousedown', () => {
+      ring.style.borderColor = '#8B5CF6';
+      ring.style.transform = 'translate(-50%, -50%) scale(0.8)';
+      ring.style.boxShadow = '0 0 20px rgba(139,92,246,0.5)';
+    });
+
+    document.addEventListener('mouseup', () => {
+      ring.style.borderColor = '#00FFD1';
+      ring.style.transform = 'translate(-50%, -50%) scale(1)';
+      ring.style.boxShadow = '0 0 10px rgba(0,255,209,0.3)';
+    });
+  });
+}
+
+/**
+ * Click a navigation link by its text content.
+ * Waits for network idle after navigation.
+ */
+async function clickNavLink(page, text, timeout = 8000) {
+  try {
+    const link = page.locator(`a:has-text("${text}")`).first();
+    await link.waitFor({ state: 'visible', timeout: 5000 });
+    await link.click();
+    await page.waitForLoadState('networkidle', { timeout });
+    await page.waitForTimeout(1500);
+    return true;
+  } catch {
+    console.log(`[WARN] Nav link not found: "${text}" — skipping`);
+    return false;
+  }
+}
+
+/**
+ * Hover over an element to trigger hover states for visual effect.
+ */
+async function hoverElement(page, selector, duration = 1000) {
+  try {
+    const el = page.locator(selector).first();
+    await el.waitFor({ state: 'visible', timeout: 3000 });
+    await el.hover();
+    await page.waitForTimeout(duration);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Scene timestamp tracker for ffmpeg post-processing.
+ */
+class SceneTracker {
+  constructor() {
+    this.scenes = [];
+    this.startTime = null;
+  }
+
+  start() {
+    this.startTime = Date.now();
+    this.mark('start');
+  }
+
+  mark(name) {
+    if (!this.startTime) this.startTime = Date.now();
+    const elapsed = (Date.now() - this.startTime) / 1000;
+    this.scenes.push({ name, time: elapsed });
+    console.log(`[SCENE] ${name} @ ${elapsed.toFixed(1)}s`);
+  }
+
+  getScenes() {
+    return this.scenes;
+  }
+
+  printSummary() {
+    console.log('\n=== SCENE TIMESTAMPS ===');
+    console.log(JSON.stringify(this.scenes, null, 2));
+
+    // Calculate raw durations
+    console.log('\n=== SEGMENT DURATIONS ===');
+    for (let i = 0; i < this.scenes.length - 1; i++) {
+      const raw = this.scenes[i + 1].time - this.scenes[i].time;
+      console.log(`  ${this.scenes[i].name}: ${raw.toFixed(1)}s`);
+    }
+    const total = this.scenes[this.scenes.length - 1].time - this.scenes[0].time;
+    console.log(`  TOTAL RAW: ${total.toFixed(1)}s`);
+  }
+}
+
+module.exports = {
+  maskInputs,
+  smoothScroll,
+  clickButton,
+  naturalType,
+  addCursorHighlight,
+  clickNavLink,
+  hoverElement,
+  SceneTracker,
+};

package/framework/scripts/speak.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""ElevenLabs TTS - pipe text to this script to hear it spoken."""
+
+import sys
+import os
+import subprocess
+import tempfile
+
+from elevenlabs import ElevenLabs
+
+API_KEY = os.environ.get("ELEVEN_API_KEY")
+VOICE_ID = os.environ.get("ELEVEN_VOICE_ID", "PB6BdkFkZLbI39GHdnbQ")
+
+if not API_KEY:
+    sys.exit(0)
+
+def speak(text: str):
+    if not text.strip():
+        return
+
+    client = ElevenLabs(api_key=API_KEY)
+
+    audio = client.text_to_speech.convert(
+        voice_id=VOICE_ID,
+        text=text,
+        model_id="eleven_turbo_v2_5",
+    )
+
+    # Write to temp file and play
+    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
+        for chunk in audio:
+            f.write(chunk)
+        f.flush()
+
+        # Play with mpv, ffplay, or paplay
+        for cmd in [
+            ["mpv", "--no-video", "--really-quiet", f.name],
+            ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet", f.name],
+            ["paplay", f.name],
+        ]:
+            try:
+                subprocess.run(cmd, check=True)
+                break
+            except FileNotFoundError:
+                continue
+
+        os.unlink(f.name)
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        text = " ".join(sys.argv[1:])
+    else:
+        text = sys.stdin.read()
+
+    speak(text)

package/framework/scripts/speak.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# Quick TTS wrapper for hooks
+# Requires ELEVEN_API_KEY env var (set in shell profile or .env.claude)
+# Cross-platform: detects Windows venv path vs Unix venv path
+export PYTHONWARNINGS="ignore::UserWarning"
+export ELEVEN_VOICE_ID="${ELEVEN_VOICE_ID:-PB6BdkFkZLbI39GHdnbQ}"
+
+TEXT="${1:-}"
+if [ -n "$TEXT" ] && [ -n "$ELEVEN_API_KEY" ]; then
+    # Cross-platform venv python detection
+    VENV_PYTHON="$HOME/.claude/venv/bin/python"
+    if [ ! -f "$VENV_PYTHON" ]; then
+        VENV_PYTHON="$HOME/.claude/venv/Scripts/python"
+    fi
+    if [ -f "$VENV_PYTHON" ]; then
+        echo "$TEXT" | "$VENV_PYTHON" "$HOME/.claude/scripts/speak.py" &
+    fi
+fi

package/framework/scripts/status.sh

@@ -0,0 +1,138 @@
+#!/bin/bash
+# GSD Status Dashboard - Quick project state overview
+# Usage: status.sh [project_path]
+
+set -e
+
+PROJECT_DIR="${1:-.}"
+cd "$PROJECT_DIR"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+DIM='\033[2m'
+NC='\033[0m' # No Color
+
+# Header
+echo ""
+echo -e "${BOLD}═══════════════════════════════════════════════════════════${NC}"
+echo -e "${BOLD}  GSD STATUS: $(basename "$PWD")${NC}"
+echo -e "${BOLD}═══════════════════════════════════════════════════════════${NC}"
+
+# Check if GSD project
+if [ ! -d ".planning" ]; then
+    echo -e "\n${YELLOW}⚠ No .planning/ directory - not a GSD project${NC}"
+    echo -e "${DIM}Run /gsd:new-project to initialize${NC}\n"
+    exit 0
+fi
+
+# Current Phase from STATE.md
+echo -e "\n${CYAN}▸ CURRENT POSITION${NC}"
+if [ -f ".planning/STATE.md" ]; then
+    # Extract current phase line
+    PHASE_LINE=$(grep -E "^(current_phase|## Current|Phase:)" .planning/STATE.md 2>/dev/null | head -1 || echo "")
+    if [ -n "$PHASE_LINE" ]; then
+        echo -e "  $PHASE_LINE"
+    fi
+
+    # Extract status
+    STATUS_LINE=$(grep -E "^(status:|Status:)" .planning/STATE.md 2>/dev/null | head -1 || echo "")
+    if [ -n "$STATUS_LINE" ]; then
+        echo -e "  $STATUS_LINE"
+    fi
+else
+    echo -e "  ${YELLOW}No STATE.md found${NC}"
+fi
+
+# Phase Overview from ROADMAP.md
+echo -e "\n${CYAN}▸ PHASES${NC}"
+if [ -f ".planning/ROADMAP.md" ]; then
+    # Count phases and show completion
+    TOTAL_PHASES=$(grep -cE "^## Phase [0-9]" .planning/ROADMAP.md 2>/dev/null || echo "0")
+    COMPLETE_PHASES=$(grep -cE "\[x\]|✓|complete" .planning/ROADMAP.md 2>/dev/null || echo "0")
+    echo -e "  Progress: ${GREEN}$COMPLETE_PHASES${NC}/${TOTAL_PHASES} phases"
+
+    # List phases
+    grep -E "^## Phase [0-9]" .planning/ROADMAP.md 2>/dev/null | head -10 | while read -r line; do
+        echo -e "  ${DIM}$line${NC}"
+    done
+else
+    echo -e "  ${YELLOW}No ROADMAP.md found${NC}"
+fi
+
+# Plans in current phase
+echo -e "\n${CYAN}▸ PLANS${NC}"
+if [ -d ".planning/phases" ]; then
+    # Find most recent phase directory
+    LATEST_PHASE=$(ls -d .planning/phases/*/ 2>/dev/null | sort -V | tail -1)
+    if [ -n "$LATEST_PHASE" ]; then
+        PHASE_NAME=$(basename "$LATEST_PHASE")
+        TOTAL_PLANS=$(ls -1 "$LATEST_PHASE"*-PLAN.md 2>/dev/null | wc -l | tr -d ' ')
+        COMPLETE_PLANS=$(ls -1 "$LATEST_PHASE"*-SUMMARY.md 2>/dev/null | wc -l | tr -d ' ')
+        echo -e "  ${BOLD}$PHASE_NAME${NC}: ${GREEN}$COMPLETE_PLANS${NC}/${TOTAL_PLANS} plans complete"
+
+        # List incomplete plans
+        for plan in "$LATEST_PHASE"*-PLAN.md; do
+            if [ -f "$plan" ]; then
+                PLAN_NAME=$(basename "$plan" -PLAN.md)
+                SUMMARY="${plan/-PLAN.md/-SUMMARY.md}"
+                if [ -f "$SUMMARY" ]; then
+                    echo -e "  ${GREEN}✓${NC} $PLAN_NAME"
+                else
+                    echo -e "  ${YELLOW}○${NC} $PLAN_NAME ${DIM}(pending)${NC}"
+                fi
+            fi
+        done 2>/dev/null
+    fi
+else
+    echo -e "  ${YELLOW}No phases directory${NC}"
+fi
+
+# Blockers from STATE.md
+echo -e "\n${CYAN}▸ BLOCKERS${NC}"
+if [ -f ".planning/STATE.md" ]; then
+    BLOCKERS=$(sed -n '/## Blockers/,/^##/p' .planning/STATE.md 2>/dev/null | grep -E "^-" | head -5)
+    if [ -n "$BLOCKERS" ]; then
+        echo -e "${RED}$BLOCKERS${NC}"
+    else
+        echo -e "  ${GREEN}None${NC}"
+    fi
+else
+    echo -e "  ${DIM}Unknown${NC}"
+fi
+
+# Git status (brief)
+echo -e "\n${CYAN}▸ GIT${NC}"
+if git rev-parse --git-dir > /dev/null 2>&1; then
+    BRANCH=$(git branch --show-current 2>/dev/null || echo "detached")
+    CHANGES=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')
+    COMMITS_AHEAD=$(git rev-list --count @{u}..HEAD 2>/dev/null || echo "?")
+    echo -e "  Branch: ${BOLD}$BRANCH${NC}"
+    echo -e "  Uncommitted: $CHANGES files"
+    [ "$COMMITS_AHEAD" != "?" ] && echo -e "  Ahead of remote: $COMMITS_AHEAD commits"
+else
+    echo -e "  ${YELLOW}Not a git repo${NC}"
+fi
+
+# Suggested next action
+echo -e "\n${CYAN}▸ NEXT ACTION${NC}"
+if [ -f ".planning/STATE.md" ]; then
+    # Simple heuristic based on state
+    if grep -qE "needs.*(plan|planning)" .planning/STATE.md 2>/dev/null; then
+        echo -e "  ${BOLD}/gsd:plan-phase${NC}"
+    elif grep -qE "needs.*(exec|execution)" .planning/STATE.md 2>/dev/null; then
+        echo -e "  ${BOLD}/gsd:execute-phase${NC}"
+    elif grep -qE "needs.*(verify|verification)" .planning/STATE.md 2>/dev/null; then
+        echo -e "  ${BOLD}/gsd:verify-work${NC}"
+    else
+        echo -e "  ${BOLD}/gsd:progress${NC} ${DIM}(check state)${NC}"
+    fi
+else
+    echo -e "  ${BOLD}/gsd:new-project${NC}"
+fi
+
+echo -e "\n${DIM}─────────────────────────────────────────────────────────────${NC}\n"

package/framework/scripts/sync-to-framework.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Sync ~/.claude/ framework files → ~/Projects/qualia-framework/framework/
+# Run this after making changes to ~/.claude/ to prepare for distribution
+# Usage: ~/.claude/scripts/sync-to-framework.sh
+
+source "$HOME/.claude/hooks/qualia-colors.sh"
+
+SRC="$HOME/.claude"
+DEST="$HOME/Projects/qualia-framework/framework"
+
+if [ ! -d "$DEST" ]; then
+    printf "${Q_FAIL}  ✗ Framework repo not found at ~/Projects/qualia-framework${Q_RESET}\n"
+    exit 1
+fi
+
+q_header "SYNC TO FRAMEWORK REPO"
+
+# Sync framework components (these are the distributable parts)
+COMPONENTS=(
+    "skills"
+    "agents"
+    "hooks"
+    "rules"
+    "knowledge"
+    "qualia-engine"
+    "scripts"
+)
+
+for comp in "${COMPONENTS[@]}"; do
+    if [ -d "$SRC/$comp" ]; then
+        rsync -a --delete \
+            --exclude="node_modules" \
+            --exclude=".DS_Store" \
+            --exclude="retros/" \
+            --exclude="project-notes/" \
+            --exclude="session-digest.md" \
+            "$SRC/$comp/" "$DEST/$comp/"
+        COUNT=$(find "$DEST/$comp" -type f | wc -l)
+        q_pass "$comp ($COUNT files)"
+    fi
+done
+
+# Sync individual files
+cp "$SRC/CLAUDE.md" "$DEST/../templates/CLAUDE-owner.md" 2>/dev/null && q_pass "CLAUDE.md → templates/CLAUDE-owner.md"
+cp "$SRC/statusline-command.sh" "$DEST/statusline-command.sh" 2>/dev/null && q_pass "statusline-command.sh"
+cp "$SRC/askpass.sh" "$DEST/askpass.sh" 2>/dev/null && q_pass "askpass.sh"
+cp "$SRC/install.sh" "$DEST/../install.sh" 2>/dev/null && q_pass "install.sh"
+cp "$SRC/install.ps1" "$DEST/../install.ps1" 2>/dev/null && q_pass "install.ps1"
+
+# Don't sync: secrets, session data, history, plugins, caches, personal memories
+# Those stay local to each machine
+
+# Show what changed in the repo
+echo ""
+cd "$HOME/Projects/qualia-framework"
+CHANGED=$(git status --porcelain | wc -l)
+if [ "$CHANGED" -gt 0 ]; then
+    q_warn "$CHANGED files changed"
+    git status --short | head -20
+    echo ""
+    printf "${Q_DIM}  Ready to commit. Run:${Q_RESET}\n"
+    printf "${Q_TEAL}  cd ~/Projects/qualia-framework && git add -A && git commit -m 'chore: sync framework updates' && git push${Q_RESET}\n"
+else
+    q_pass "Already up to date"
+fi