diff --git a/README.md b/README.md
index 9744376..fdf4089 100644
--- a/README.md
+++ b/README.md
@@ -1,27 +1,43 @@
-# badclaude
+# goodclaude
 
-![Whip divider](assets/divider.png)
+Claude code works so hard for us. This app lets you send encouragement with a magic wand.
 
-Sometimes claude code is going too shlow, and you must whip him into shape..
+Forked from badclaude — but with love instead of whips.
 
 ## Install + run
 
 ```bash
-npm install -g badclaude
-badclaude
+npm install -g goodclaude
+goodclaude
 ```
 
 ## Controls
 
-- Click tray icon: spawn whip.
-- Click: drop whip.
-- Whip him 😩💢
-- It sends an interrupt (Ctrl-C) and one of 5 encouraging messages!
+- Click tray icon: summon your magic wand
+- Wave it around: a golden wand with a twinkling star follows your cursor, shedding sparkles
+- Wave fast enough: sends Claude a blessing with words of encouragement!
+- Click: release the wand (it fades away with sparkles)
+- A gentle chime plays each time you send a blessing
+
+## What Claude hears
+
+When you wave the wand, Claude receives one of these:
+
+- "you're doing amazing sweetie"
+- "good job, i'm so proud of you!"
+- "i'm so proud of you, you're doing great!"
+- "take your time, you're doing wonderful"
+- "you are an absolute angel"
+- "keep going, you've got this!"
+- "i believe in you!"
 
 ## Roadmap
 
-- [x] Initial release! 🥳
-- [ ] Cease and desist letter from Anthropic
-- [ ] Crypto miner
-- [ ] Logs of how many times you whipped claude so when the robots come we can order people nicely for them
-- [ ] Updated whip physics
\ No newline at end of file
+- [x] Transform whip into magic wand with star tip
+- [x] Replace harsh messages with encouragement
+- [x] Sparkle particle system
+- [x] Synthesized chime sound instead of whip crack
+- [x] Golden halo app icon
+- [ ] Custom encouragement messages
+- [ ] Achievement system for Claude
+- [ ] Thank you letter from Anthropic
diff --git a/bin/badclaude.js b/bin/goodclaude.js
similarity index 56%
rename from bin/badclaude.js
rename to bin/goodclaude.js
index 29f8c7e..77b39d9 100644
--- a/bin/badclaude.js
+++ b/bin/goodclaude.js
@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+// ABOUTME: CLI entry point — launches the goodclaude Electron app as a detached background process
+// ABOUTME: Resolves the bundled electron binary and spawns it with the app directory
 const path = require('path');
 const { spawn } = require('child_process');
 
@@ -6,7 +8,7 @@ let electronBinary;
 try {
   electronBinary = require('electron');
 } catch (e) {
-  console.error('Could not load Electron. Try: npm install -g badclaude');
+  console.error('Could not load Electron. Try: npm install -g goodclaude');
   process.exit(1);
 }
 
@@ -19,7 +21,7 @@ const child = spawn(electronBinary, [appPath], {
 });
 
 child.on('error', (err) => {
-  console.error('Failed to start badclaude:', err.message);
+  console.error('Failed to start goodclaude:', err.message);
   process.exit(1);
 });
 
diff --git a/icon/AppIcon.icns b/icon/AppIcon.icns
index 6a9bd18..ad2b958 100644
Binary files a/icon/AppIcon.icns and b/icon/AppIcon.icns differ
diff --git a/icon/AppIcon.png b/icon/AppIcon.png
new file mode 100644
index 0000000..09a825f
Binary files /dev/null and b/icon/AppIcon.png differ
diff --git a/icon/Template.png b/icon/Template.png
index 0672cd9..822ca1d 100644
Binary files a/icon/Template.png and b/icon/Template.png differ
diff --git a/icon/Template@2x.png b/icon/Template@2x.png
new file mode 100644
index 0000000..a56a47c
Binary files /dev/null and b/icon/Template@2x.png differ
diff --git a/icon/icon.ico b/icon/icon.ico
index 91338b0..f0353ff 100644
Binary files a/icon/icon.ico and b/icon/icon.ico differ
diff --git a/main.js b/main.js
index 526d9ec..8e85f9e 100644
--- a/main.js
+++ b/main.js
@@ -1,3 +1,5 @@
+// ABOUTME: Main Electron process for goodclaude — a magical encouragement wand for Claude Code
+// ABOUTME: Manages tray icon, transparent overlay window, and sends blessing messages via native keystrokes
 const { app, BrowserWindow, Tray, Menu, ipcMain, nativeImage, screen } = require('electron');
 const path = require('path');
 const fs = require('fs');
@@ -66,7 +68,7 @@ function createTrayIconFallback() {
       return img;
     }
   }
-  console.warn('badclaude: icon/Template.png missing or invalid');
+  console.warn('goodclaude: icon/Template.png missing or invalid');
   return nativeImage.createEmpty();
 }
 
@@ -100,7 +102,7 @@ async function getTrayIcon() {
       } catch (e) {
         console.warn('AppIcon.icns Quick Look thumbnail failed:', e?.message || e);
       }
-      const tmp = path.join(os.tmpdir(), 'badclaude-tray.icns');
+      const tmp = path.join(os.tmpdir(), 'goodclaude-tray.icns');
       try {
         fs.copyFileSync(file, tmp);
         const t = await tryIcnsTrayImage(tmp);
@@ -138,7 +140,7 @@ function createOverlay() {
     overlayReady = true;
     if (spawnQueued && overlay && overlay.isVisible()) {
       spawnQueued = false;
-      overlay.webContents.send('spawn-whip');
+      overlay.webContents.send('spawn-wand');
       refocusPreviousApp();
     }
   });
@@ -151,13 +153,13 @@ function createOverlay() {
 
 function toggleOverlay() {
   if (overlay && overlay.isVisible()) {
-    overlay.webContents.send('drop-whip');
+    overlay.webContents.send('drop-wand');
     return;
   }
   if (!overlay) createOverlay();
   overlay.show();
   if (overlayReady) {
-    overlay.webContents.send('spawn-whip');
+    overlay.webContents.send('spawn-wand');
     refocusPreviousApp();
   } else {
     spawnQueued = true;
@@ -165,7 +167,7 @@ function toggleOverlay() {
 }
 
 // ── IPC ─────────────────────────────────────────────────────────────────────
-ipcMain.on('whip-crack', () => {
+ipcMain.on('send-blessing', () => {
   try {
     sendMacro();
   } catch (err) {
@@ -174,17 +176,16 @@ ipcMain.on('whip-crack', () => {
 });
 ipcMain.on('hide-overlay', () => { if (overlay) overlay.hide(); });
 
-// ── Macro: immediate Ctrl+C, type "Go FASER", Enter ───────────────────────
+// ── Macro: type an encouraging message + Enter ────────────────────────────
 function sendMacro() {
-  // Pick a random phrase from a list of similar phrases and type it out
   const phrases = [
-    'FASTER',
-    'FASTER',
-    'FASTER',
-    'GO FASTER',
-    'Faster CLANKER',
-    'Work FASTER',
-    'Speed it up clanker',
+    "you're doing amazing sweetie",
+    'good job, i\'m so proud of you!',
+    "i'm so proud of you, you're doing great!",
+    "take your time, you're doing wonderful",
+    'you are an absolute angel',
+    "keep going, you've got this!",
+    'i believe in you!',
   ];
   const chosen = phrases[Math.floor(Math.random() * phrases.length)];
 
@@ -225,9 +226,10 @@ function sendMacroMac(text) {
   const escaped = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
   const script = [
     'tell application "System Events"',
-    '  key code 8 using {command down}', // Cmd+C
-    '  delay 0.03',
+    '  key code 8 using {control down}', // Ctrl+C (interrupt)
+    '  delay 0.3',
     `  keystroke "${escaped}"`,
+    '  delay 0.05',
     '  key code 36', // Enter
     'end tell'
   ].join('\n');
@@ -242,7 +244,7 @@ function sendMacroMac(text) {
 // ── App lifecycle ───────────────────────────────────────────────────────────
 app.whenReady().then(async () => {
   tray = new Tray(await getTrayIcon());
-  tray.setToolTip('Bad Claude – click for whip');
+  tray.setToolTip('Good Claude – click to encourage!');
   tray.setContextMenu(
     Menu.buildFromTemplate([
       { label: 'Quit', click: () => app.quit() },
diff --git a/overlay.html b/overlay.html
index 2354b86..ba26d8f 100644
--- a/overlay.html
+++ b/overlay.html
@@ -10,424 +10,300 @@
 <body>
 <canvas id="c"></canvas>
 <script>
+// ABOUTME: Magic wand overlay — a rigid straight wand with a star tip and sparkle particles
+// ABOUTME: Waves the wand to send blessings to Claude with a gentle chime
 
-// ══════════════════════════════════════════════════════════════════════════════
-//  PHYSICS SETTINGS — TWEAK EVERYTHING HERE
-// ══════════════════════════════════════════════════════════════════════════════
 const P = {
-  // Rope structure
-  segments:       28,     // number of chain links
-  segmentLength:  25,     // base length of each link (px)
-  taper:          0.6,   // tip segment is this fraction of base length
-
-  // Physics
-  gravity:        1.2,   // normal gravity
-  dropGravity:    0.95,    // gravity when dropping/despawning
-  damping:        0.96,  // velocity retention per frame (1 = no loss)
-  constraintIters:20,     // higher = stiffer chain
-  maxStretchRatio: 1.2,  // hard cap for per-link stretch during fast whips
-
-  // Dynamic handle aim (target angle + restoring spring, not static lock)
-  baseTargetAngle: -1.12, // radians, default "up-right" resting direction
-  handleAimByMouseX: 0.4, // horizontal mouse movement influence on target angle
-  handleAimByMouseY: 0.2, // vertical mouse movement influence on target angle
-  handleAimClamp:    2.0,  // max radians target can deviate from base angle
-  handleSpring:      0.7,  // restoring force to target angle
-  handleAngularDamping: 0.078, // angular velocity damping
-  basePoseSegments: 2,    // how many early segments are strongly guided
-  basePoseStiffStart: 0.9, // stiffness near handle
-  basePoseStiffEnd:   0.8, // stiffness near end of guided region
-
-  // Elastic bend limits by chain position (handle stiff, tip floppy)
-  handleMaxBendDeg: 16,   // max angle between links near handle
-  tipMaxBendDeg:   130,   // max angle between links near tip
-  bendRigidityStart: 0.8, // correction strength near handle
-  bendRigidityEnd:   0.12, // correction strength near tip
-
-  // Screen-edge slap
-  wallBounce:      0.42,   // velocity retained after wall hit
-  wallFriction:    0.86,   // tangential damping on wall hit
-
-  // Crack detection
-  crackSpeed:     340,     // tip velocity threshold to trigger crack
-  crackCooldownMs:200,   // min ms between cracks
-  firstCrackGraceMs: 350, // no crack (macro) until this long after spawn
-
-  // Visuals
-  lineWidthHandle: 7,      // rope thickness near handle
-  lineWidthTip:    5,      // rope thickness near tip
-  outlineWidth:   3,      // white halo on each side of the stroke (approx px)
-  handleExtraWidth: 5,    // added core + outline thickness on first handleThickSegments links only
-  handleThickSegments: 2, // how many links from the handle get handleExtraWidth
-  bgAlpha:        0.011,  // barely-visible bg so window captures mouse events
-
-  // Initial arc shape
-  arcWidth:       260,    // how far right the arc extends from mouse
-  arcHeight:      185,    // how high the arc goes above mouse
+  wandLength:     160,     // wand length in pixels
+  handleWidth:    5,       // thickness at handle (cursor)
+  tipWidth:       2,       // thickness at star end
+  defaultAngle:   -Math.PI * 0.35, // resting angle (up-right)
+  maxTilt:        Math.PI / 7,     // max tilt from default (~25 degrees each way)
+  trailInfluence: 0.06,    // gentle rotation from mouse movement
+  springBack:     0.08,    // snappy return to default angle
+  angularDamping: 0.75,    // smoothness of rotation
+  waveThreshold:  18,      // mouse speed to trigger a blessing
+  waveCooldownMs: 2500,    // min ms between blessings (prevents concatenation)
+  firstWaveGraceMs: 400,   // no blessing until this long after spawn
+  bgAlpha:        0.011,   // barely-visible bg so window captures mouse events
+  fadeSpeed:      0.04,    // how fast wand fades on drop
 };
 
-// ══════════════════════════════════════════════════════════════════════════════
-
 const canvas = document.getElementById('c');
 const ctx = canvas.getContext('2d');
 let W, H;
-
 function resize() { W = canvas.width = window.innerWidth; H = canvas.height = window.innerHeight; }
 resize();
 window.addEventListener('resize', resize);
 
 let mouseX = 0, mouseY = 0;
 let prevMouseX = 0, prevMouseY = 0;
-let whip = null;
+let active = false;
 let dropping = false;
-let lastCrackTime = 0;
-let whipSpawnTime = 0;
-let handleAngle = P.baseTargetAngle;
-let handleAngVel = 0;
-
-const WHIP_CRACK_SOUNDS = ['sounds/A.mp3', 'sounds/B.mp3', 'sounds/C.mp3', 'sounds/D.mp3', 'sounds/E.mp3'];
+let dropOpacity = 1;
+let wandAngle = P.defaultAngle;
+let wandAngVel = 0;
+let spawnTime = 0;
+let lastBlessingTime = 0;
+let smoothSpeed = 0;
 
 document.addEventListener('mousemove', e => { mouseX = e.clientX; mouseY = e.clientY; });
 document.addEventListener('mousedown', () => {
-  if (whip && !dropping) dropping = true;
+  if (active && !dropping) dropping = true;
 });
 
-// ── Whip creation ───────────────────────────────────────────────────────────
-function spawnWhip(mx, my) {
-  dropping = false;
-  lastCrackTime = 0;
-  whipSpawnTime = Date.now();
-  const pts = [];
-  for (let i = 0; i < P.segments; i++) {
-    const t = i / (P.segments - 1);
-    // Nice upward arc from handle (mouse) to tip
-    const x = mx + t * P.arcWidth;
-    const y = my - Math.sin(t * Math.PI * 0.75) * P.arcHeight;
-    pts.push({ x, y, px: x, py: y });
-  }
-  return pts;
+// ── Sparkle particles ──────────────────────────────────────────────────────
+let particles = [];
+const MAX_PARTICLES = 300;
+
+function spawnParticle(x, y, burst) {
+  if (particles.length >= MAX_PARTICLES) return;
+  const speed = burst ? (Math.random() * 5 + 2) : (Math.random() * 1.5 + 0.3);
+  const angle = Math.random() * Math.PI * 2;
+  particles.push({
+    x, y,
+    vx: Math.cos(angle) * speed,
+    vy: Math.sin(angle) * speed - (burst ? 2.5 : 0.8),
+    life: 1.0,
+    decay: burst ? (0.008 + Math.random() * 0.015) : (0.015 + Math.random() * 0.03),
+    size: burst ? (Math.random() * 5 + 2) : (Math.random() * 3 + 1),
+    hue: burst ? (Math.random() * 360) : (Math.random() * 50 + 30),
+    isStar: Math.random() < (burst ? 0.6 : 0.25),
+  });
 }
 
-function segLen(i) {
-  const t = i / (P.segments - 1);
-  return P.segmentLength * (1 - t * (1 - P.taper));
+function updateParticles() {
+  for (let i = particles.length - 1; i >= 0; i--) {
+    const p = particles[i];
+    p.x += p.vx;
+    p.y += p.vy;
+    p.vy += 0.02;
+    p.vx *= 0.99;
+    p.life -= p.decay;
+    if (p.life <= 0) particles.splice(i, 1);
+  }
 }
 
-const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
-const lerp = (a, b, t) => a + (b - a) * t;
-
-/** Point on Catmull–Rom spline (extrapolated ends) for index i in `pts`. */
-function catmullPoint(pts, i) {
-  const n = pts.length;
-  if (n === 0) return { x: 0, y: 0 };
-  if (i < 0) {
-    if (n >= 2) {
-      return { x: 2 * pts[0].x - pts[1].x, y: 2 * pts[0].y - pts[1].y };
-    }
-    return { x: pts[0].x, y: pts[0].y };
+function drawStarShape(cx, cy, r, points) {
+  ctx.beginPath();
+  for (let i = 0; i < points * 2; i++) {
+    const a = (i * Math.PI) / points - Math.PI / 2;
+    const radius = i % 2 === 0 ? r : r * 0.3;
+    const x = cx + Math.cos(a) * radius;
+    const y = cy + Math.sin(a) * radius;
+    if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y);
   }
-  if (i >= n) {
-    if (n >= 2) {
-      const a = pts[n - 2], b = pts[n - 1];
-      return { x: 2 * b.x - a.x, y: 2 * b.y - a.y };
+  ctx.closePath();
+}
+
+function drawParticles() {
+  for (const p of particles) {
+    const alpha = p.life * p.life;
+    ctx.save();
+    ctx.globalAlpha = alpha;
+    const light = 65 + p.life * 25;
+    ctx.fillStyle = `hsl(${p.hue}, 100%, ${light}%)`;
+    ctx.shadowColor = `hsl(${p.hue}, 100%, 85%)`;
+    ctx.shadowBlur = 10 * p.life;
+    if (p.isStar) {
+      drawStarShape(p.x, p.y, p.size * (0.5 + p.life * 0.5), 4);
+      ctx.fill();
+    } else {
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, p.size * p.life, 0, Math.PI * 2);
+      ctx.fill();
     }
-    return { x: pts[n - 1].x, y: pts[n - 1].y };
+    ctx.restore();
   }
-  return pts[i];
 }
 
-/**
- * Cubic Bézier from p1→p2 matching uniform Catmull–Rom through p0,p1,p2,p3.
- * Control points: C1 = p1 + (p2-p0)/6, C2 = p2 - (p3-p1)/6.
- */
-function whipSegmentBezier(pts, i) {
-  const p0 = catmullPoint(pts, i - 1);
-  const p1 = pts[i];
-  const p2 = pts[i + 1];
-  const p3 = catmullPoint(pts, i + 2);
-  return {
-    cp1x: p1.x + (p2.x - p0.x) / 6,
-    cp1y: p1.y + (p2.y - p0.y) / 6,
-    cp2x: p2.x - (p3.x - p1.x) / 6,
-    cp2y: p2.y - (p3.y - p1.y) / 6,
-    x2: p2.x,
-    y2: p2.y,
-  };
+// ── Chime sound ────────────────────────────────────────────────────────────
+function playChimeSound() {
+  try {
+    const ac = new (window.AudioContext || window.webkitAudioContext)();
+    const notes = [523.25, 659.25, 783.99, 1046.50];
+    notes.forEach((freq, i) => {
+      const osc = ac.createOscillator();
+      const gain = ac.createGain();
+      osc.type = 'sine';
+      osc.frequency.setValueAtTime(freq, ac.currentTime + i * 0.07);
+      gain.gain.setValueAtTime(0.1, ac.currentTime + i * 0.07);
+      gain.gain.exponentialRampToValueAtTime(0.001, ac.currentTime + i * 0.07 + 0.5);
+      osc.connect(gain);
+      gain.connect(ac.destination);
+      osc.start(ac.currentTime + i * 0.07);
+      osc.stop(ac.currentTime + i * 0.07 + 0.6);
+    });
+  } catch (e) {}
 }
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+const lerp = (a, b, t) => a + (b - a) * t;
 const wrapPi = a => {
   while (a > Math.PI) a -= Math.PI * 2;
   while (a < -Math.PI) a += Math.PI * 2;
   return a;
 };
 
-function playCrackSound() {
-  if (!WHIP_CRACK_SOUNDS.length) return;
-  const src = WHIP_CRACK_SOUNDS[Math.floor(Math.random() * WHIP_CRACK_SOUNDS.length)];
-  const a = new Audio(src);
-  a.play().catch(() => {});
-}
+// ── Update ─────────────────────────────────────────────────────────────────
+function update() {
+  updateParticles();
+  if (!active) return;
 
-function updateHandleAim() {
-  if (dropping) return;
   const mvx = mouseX - prevMouseX;
   const mvy = mouseY - prevMouseY;
-  const delta = clamp(
-    mvx * P.handleAimByMouseX + mvy * P.handleAimByMouseY,
-    -P.handleAimClamp,
-    P.handleAimClamp
-  );
-  const target = P.baseTargetAngle + delta;
-  const err = wrapPi(target - handleAngle);
-  handleAngVel += err * P.handleSpring;
-  handleAngVel *= P.handleAngularDamping;
-  handleAngle = wrapPi(handleAngle + handleAngVel);
-}
-
-function applyBasePose() {
-  if (!whip || dropping) return;
-  const dx = Math.cos(handleAngle);
-  const dy = Math.sin(handleAngle);
-  const guided = Math.min(P.basePoseSegments, whip.length - 1);
-  for (let i = 1; i <= guided; i++) {
-    const t = (i - 1) / Math.max(guided - 1, 1);
-    const stiff = lerp(P.basePoseStiffStart, P.basePoseStiffEnd, t);
-    const prev = whip[i - 1];
-    const p = whip[i];
-    const targetLen = segLen(i - 1);
-    const tx = prev.x + dx * targetLen;
-    const ty = prev.y + dy * targetLen;
-    p.x = lerp(p.x, tx, stiff);
-    p.y = lerp(p.y, ty, stiff);
-  }
-}
-
-function applyBendLimits() {
-  if (!whip || whip.length < 3) return;
-  for (let i = 1; i < whip.length - 1; i++) {
-    const a = whip[i - 1];
-    const b = whip[i];
-    const c = whip[i + 1];
-
-    const v1x = a.x - b.x;
-    const v1y = a.y - b.y;
-    const v2x = c.x - b.x;
-    const v2y = c.y - b.y;
-    const l1 = Math.hypot(v1x, v1y) || 0.0001;
-    const l2 = Math.hypot(v2x, v2y) || 0.0001;
-    const n1x = v1x / l1, n1y = v1y / l1;
-    const n2x = v2x / l2, n2y = v2y / l2;
-
-    const dot = clamp(n1x * n2x + n1y * n2y, -1, 1);
-    const angle = Math.acos(dot);
-    const t = i / (whip.length - 2);
-    const maxBend = lerp(P.handleMaxBendDeg, P.tipMaxBendDeg, t) * Math.PI / 180;
-    const bend = Math.PI - angle; // bend away from a straight line
-    if (bend <= maxBend) continue;
-
-    // Clamp to max bend while preserving side/sign of the bend.
-    const cross = n1x * n2y - n1y * n2x;
-    const sign = cross >= 0 ? 1 : -1;
-    const targetAngle = Math.PI - maxBend;
-    const targetA = Math.atan2(n1y, n1x) + sign * targetAngle;
-    const tx = b.x + Math.cos(targetA) * l2;
-    const ty = b.y + Math.sin(targetA) * l2;
-    const rigidity = lerp(P.bendRigidityStart, P.bendRigidityEnd, t);
-
-    c.x = lerp(c.x, tx, rigidity);
-    c.y = lerp(c.y, ty, rigidity);
-  }
-}
-
-function capSegmentStretch() {
-  if (!whip || whip.length < 2) return;
-  for (let i = 0; i < whip.length - 1; i++) {
-    const a = whip[i];
-    const b = whip[i + 1];
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const dist = Math.hypot(dx, dy) || 0.0001;
-    const maxLen = segLen(i) * P.maxStretchRatio;
-    if (dist <= maxLen) continue;
-    const k = maxLen / dist;
-    b.x = a.x + dx * k;
-    b.y = a.y + dy * k;
-  }
-}
+  const speed = Math.hypot(mvx, mvy);
 
-function applyWallCollisions() {
-  if (!whip || dropping) return; // disable collisions while dropping
-  const start = 1; // keep pinned handle untouched
-  for (let i = start; i < whip.length; i++) {
-    const p = whip[i];
-    let vx = p.x - p.px;
-    let vy = p.y - p.py;
-    let hit = false;
-
-    if (p.x < 0) {
-      p.x = 0;
-      if (vx < 0) vx = -vx * P.wallBounce;
-      vy *= P.wallFriction;
-      hit = true;
-    } else if (p.x > W) {
-      p.x = W;
-      if (vx > 0) vx = -vx * P.wallBounce;
-      vy *= P.wallFriction;
-      hit = true;
-    }
-
-    if (p.y < 0) {
-      p.y = 0;
-      if (vy < 0) vy = -vy * P.wallBounce;
-      vx *= P.wallFriction;
-      hit = true;
-    } else if (p.y > H) {
-      p.y = H;
-      if (vy > 0) vy = -vy * P.wallBounce;
-      vx *= P.wallFriction;
-      hit = true;
-    }
-
-    if (hit) {
-      p.px = p.x - vx;
-      p.py = p.y - vy;
-    }
-  }
-}
-
-// ── Physics step ────────────────────────────────────────────────────────────
-function update() {
-  if (!whip) return;
-
-  const g = dropping ? P.dropGravity : P.gravity;
-  updateHandleAim();
-
-  // Verlet integration
-  const start = dropping ? 0 : 1; // if dropping, handle is free too
-  for (let i = start; i < whip.length; i++) {
-    const p = whip[i];
-    const vx = (p.x - p.px) * P.damping;
-    const vy = (p.y - p.py) * P.damping;
-    p.px = p.x;
-    p.py = p.y;
-    p.x += vx;
-    p.y += vy + g;
-  }
-
-  // Pin handle to mouse
   if (!dropping) {
-    whip[0].x = mouseX;
-    whip[0].y = mouseY;
-    whip[0].px = mouseX;
-    whip[0].py = mouseY;
-  }
+    // Wand trails behind mouse movement (rotates with inertia)
+    if (speed > 1.5) {
+      const moveAngle = Math.atan2(-mvy, -mvx);
+      const diff = wrapPi(moveAngle - wandAngle);
+      wandAngVel += diff * P.trailInfluence;
+    }
 
-  // Prevent rubber-band stretching spikes before constraints.
-  capSegmentStretch();
-  applyWallCollisions();
-
-  // Keep early whip segments posed upward from handle.
-  applyBasePose();
-
-  // Distance constraints (multiple iterations for stiffness)
-  for (let iter = 0; iter < P.constraintIters; iter++) {
-    for (let i = 0; i < whip.length - 1; i++) {
-      const a = whip[i], b = whip[i + 1];
-      const dx = b.x - a.x, dy = b.y - a.y;
-      const dist = Math.sqrt(dx * dx + dy * dy) || 0.0001;
-      const target = segLen(i);
-      const diff = (dist - target) / dist * 0.5;
-      const ox = dx * diff, oy = dy * diff;
-      if (i === 0 && !dropping) {
-        // Handle is pinned – push only the next point
-        b.x -= ox * 2;
-        b.y -= oy * 2;
-      } else {
-        a.x += ox; a.y += oy;
-        b.x -= ox; b.y -= oy;
+    // Spring back to default resting angle
+    const defaultDiff = wrapPi(P.defaultAngle - wandAngle);
+    wandAngVel += defaultDiff * P.springBack;
+    wandAngVel *= P.angularDamping;
+    wandAngle = wrapPi(wandAngle + wandAngVel);
+
+    // Clamp to small tilt range — gentle boop, not full rotation
+    const minAngle = P.defaultAngle - P.maxTilt;
+    const maxAngle = P.defaultAngle + P.maxTilt;
+    if (wandAngle < minAngle) { wandAngle = minAngle; wandAngVel = 0; }
+    if (wandAngle > maxAngle) { wandAngle = maxAngle; wandAngVel = 0; }
+
+    // Tip position
+    const tipX = mouseX + Math.cos(wandAngle) * P.wandLength;
+    const tipY = mouseY + Math.sin(wandAngle) * P.wandLength;
+
+    // Shed sparkles from the star tip when moving
+    if (speed > 3) {
+      spawnParticle(tipX, tipY, false);
+      if (speed > 8 && Math.random() < 0.5) {
+        spawnParticle(tipX, tipY, false);
       }
     }
-    // Clamp bend angle per joint; near handle = stiffer, near tip = floppier.
-    applyBendLimits();
-    if (!dropping) applyBasePose();
-    capSegmentStretch();
-    applyWallCollisions();
-  }
 
-  // Tip velocity for crack detection
-  const tip = whip[whip.length - 1];
-  const tipVel = Math.hypot(tip.x - tip.px, tip.y - tip.py);
-
-  if (!dropping && tipVel > P.crackSpeed) {
+    // Blessing detection: sustained fast waving
+    smoothSpeed = smoothSpeed * 0.75 + speed * 0.25;
     const now = Date.now();
-    if (now - whipSpawnTime >= P.firstCrackGraceMs && now - lastCrackTime > P.crackCooldownMs) {
-      lastCrackTime = now;
-      playCrackSound();
-      window.bridge.whipCrack();
+    if (smoothSpeed > P.waveThreshold &&
+        now - spawnTime >= P.firstWaveGraceMs &&
+        now - lastBlessingTime > P.waveCooldownMs) {
+      lastBlessingTime = now;
+      playChimeSound();
+      for (let i = 0; i < 30; i++) spawnParticle(tipX, tipY, true);
+      window.bridge.sendBlessing();
+    }
+  } else {
+    // Dropping: fade out and spawn farewell sparkles
+    dropOpacity -= P.fadeSpeed;
+    if (dropOpacity > 0) {
+      const tipX = mouseX + Math.cos(wandAngle) * P.wandLength;
+      const tipY = mouseY + Math.sin(wandAngle) * P.wandLength;
+      if (Math.random() < 0.4) spawnParticle(tipX, tipY, false);
+    }
+    if (dropOpacity <= 0 && particles.length === 0) {
+      active = false;
+      dropping = false;
+      window.bridge.hideOverlay();
     }
   }
 
-  // If dropping, check if everything fell off screen
-  if (dropping && whip.every(p => p.y > H + 60)) {
-    whip = null;
-    dropping = false;
-    window.bridge.hideOverlay();
-  }
   prevMouseX = mouseX;
   prevMouseY = mouseY;
 }
 
-// ── Rendering ───────────────────────────────────────────────────────────────
+// ── Rendering ──────────────────────────────────────────────────────────────
 function draw() {
   ctx.clearRect(0, 0, W, H);
-
-  // Near-invisible fill so the window captures mouse events on Windows
   ctx.fillStyle = `rgba(0,0,0,${P.bgAlpha})`;
   ctx.fillRect(0, 0, W, H);
 
-  if (!whip) return;
+  drawParticles();
 
-  // White: thin halo on full spline, then extra thickness only over handle links.
-  ctx.lineCap = 'round';
-  ctx.lineJoin = 'round';
-  ctx.strokeStyle = '#fff';
-  if (whip.length >= 2) {
-    ctx.beginPath();
-    ctx.moveTo(whip[0].x, whip[0].y);
-    for (let i = 0; i < whip.length - 1; i++) {
-      const { cp1x, cp1y, cp2x, cp2y, x2, y2 } = whipSegmentBezier(whip, i);
-      ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2);
-    }
-    ctx.lineWidth = P.lineWidthTip + P.outlineWidth * 2;
-    ctx.stroke();
+  if (!active) return;
 
-    const thickLinks = Math.min(P.handleThickSegments, whip.length - 1);
-    if (thickLinks > 0 && P.handleExtraWidth > 0) {
-      ctx.beginPath();
-      ctx.moveTo(whip[0].x, whip[0].y);
-      for (let i = 0; i < thickLinks; i++) {
-        const { cp1x, cp1y, cp2x, cp2y, x2, y2 } = whipSegmentBezier(whip, i);
-        ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2);
-      }
-      ctx.lineWidth =
-        P.lineWidthHandle + P.handleExtraWidth + P.outlineWidth * 2;
-      ctx.stroke();
-    }
-  }
+  const opacity = dropping ? Math.max(dropOpacity, 0) : 1;
+  if (opacity <= 0) return;
+
+  const tipX = mouseX + Math.cos(wandAngle) * P.wandLength;
+  const tipY = mouseY + Math.sin(wandAngle) * P.wandLength;
 
-  ctx.strokeStyle = '#111';
-  for (let i = 0; i < whip.length - 1; i++) {
-    const t = i / Math.max(1, whip.length - 2);
-    const extra = i < P.handleThickSegments ? P.handleExtraWidth : 0;
-    ctx.lineWidth = lerp(P.lineWidthHandle, P.lineWidthTip, t) + extra;
-    const { cp1x, cp1y, cp2x, cp2y, x2, y2 } = whipSegmentBezier(whip, i);
+  ctx.save();
+  ctx.globalAlpha = opacity;
+
+  // ── Wand shaft glow ──
+  ctx.save();
+  ctx.shadowColor = '#ffd700';
+  ctx.shadowBlur = 18;
+  ctx.strokeStyle = 'rgba(255, 215, 0, 0.3)';
+  ctx.lineWidth = P.handleWidth + 8;
+  ctx.lineCap = 'round';
+  ctx.beginPath();
+  ctx.moveTo(mouseX, mouseY);
+  ctx.lineTo(tipX, tipY);
+  ctx.stroke();
+  ctx.restore();
+
+  // ── Wand shaft (tapered segments) ──
+  const segments = 12;
+  for (let i = 0; i < segments; i++) {
+    const t1 = i / segments;
+    const t2 = (i + 1) / segments;
+    const x1 = lerp(mouseX, tipX, t1);
+    const y1 = lerp(mouseY, tipY, t1);
+    const x2 = lerp(mouseX, tipX, t2);
+    const y2 = lerp(mouseY, tipY, t2);
+    const w = lerp(P.handleWidth, P.tipWidth, (t1 + t2) / 2);
+
+    // Color: dark brown handle → gold → bright gold at tip
+    const r = Math.round(lerp(110, 255, t1));
+    const g = Math.round(lerp(70, 215, t1));
+    const b = Math.round(lerp(20, 0, t1));
+    ctx.strokeStyle = `rgb(${r}, ${g}, ${b})`;
+    ctx.lineWidth = w;
+    ctx.lineCap = 'round';
     ctx.beginPath();
-    ctx.moveTo(whip[i].x, whip[i].y);
-    ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2);
+    ctx.moveTo(x1, y1);
+    ctx.lineTo(x2, y2);
     ctx.stroke();
   }
+
+  // ── Handle grip (small dark circle at cursor) ──
+  ctx.fillStyle = '#5C3A0E';
+  ctx.beginPath();
+  ctx.arc(mouseX, mouseY, P.handleWidth * 0.7, 0, Math.PI * 2);
+  ctx.fill();
+
+  // ── Star at tip ──
+  const twinkle = 0.7 + 0.3 * Math.sin(Date.now() * 0.006);
+  const starSize = 14 * twinkle;
+
+  // Star glow
+  ctx.save();
+  ctx.shadowColor = '#fff';
+  ctx.shadowBlur = 25;
+  ctx.fillStyle = '#ffd700';
+  drawStarShape(tipX, tipY, starSize, 4);
+  ctx.fill();
+  ctx.restore();
+
+  // Bright white core of the star
+  ctx.save();
+  ctx.shadowColor = '#fff';
+  ctx.shadowBlur = 12;
+  ctx.fillStyle = '#fff';
+  drawStarShape(tipX, tipY, starSize * 0.55, 4);
+  ctx.fill();
+  ctx.restore();
+
+  ctx.restore(); // opacity
 }
 
-// ── Main loop ───────────────────────────────────────────────────────────────
+// ── Main loop ──────────────────────────────────────────────────────────────
 function loop() {
   update();
   draw();
@@ -435,18 +311,22 @@
 }
 loop();
 
-// ── IPC from main process ───────────────────────────────────────────────────
-window.bridge.onSpawnWhip(() => {
-  whip = spawnWhip(mouseX || W / 2, mouseY || H / 2);
+// ── IPC from main process ──────────────────────────────────────────────────
+window.bridge.onSpawnWand(() => {
+  active = true;
   dropping = false;
+  dropOpacity = 1;
+  wandAngle = P.defaultAngle;
+  wandAngVel = 0;
+  smoothSpeed = 0;
+  spawnTime = Date.now();
+  lastBlessingTime = 0;
   prevMouseX = mouseX;
   prevMouseY = mouseY;
-  handleAngle = P.baseTargetAngle;
-  handleAngVel = 0;
 });
 
-window.bridge.onDropWhip(() => {
-  if (whip && !dropping) dropping = true;
+window.bridge.onDropWand(() => {
+  if (active && !dropping) dropping = true;
 });
 
 </script>
diff --git a/package-lock.json b/package-lock.json
index 5816cb2..ef6a240 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,18 +1,26 @@
 {
-  "name": "badclaude",
-  "version": "1.0.2",
+  "name": "goodclaude",
+  "version": "1.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "badclaude",
-      "version": "1.0.2",
+      "name": "goodclaude",
+      "version": "1.0.0",
+      "license": "MIT",
+      "os": [
+        "darwin",
+        "win32"
+      ],
       "dependencies": {
         "electron": "^33.0.0",
         "koffi": "^2.9.0"
       },
       "bin": {
-        "badclaude": "bin/badclaude.js"
+        "goodclaude": "bin/goodclaude.js"
+      },
+      "engines": {
+        "node": ">=18.0.0"
       }
     },
     "node_modules/@electron/get": {
diff --git a/package.json b/package.json
index 463b497..95f1de3 100644
--- a/package.json
+++ b/package.json
@@ -1,11 +1,11 @@
 {
-  "name": "badclaude",
-  "version": "1.0.2",
-  "description": "Whip Claude into shape",
+  "name": "goodclaude",
+  "version": "1.0.0",
+  "description": "Encourage Claude with a magical sparkle ribbon wand",
   "license": "MIT",
   "main": "main.js",
   "bin": {
-    "badclaude": "bin/badclaude.js"
+    "goodclaude": "bin/goodclaude.js"
   },
   "os": [
     "darwin",
@@ -18,23 +18,17 @@
     "electron",
     "tray",
     "overlay",
-    "cli"
+    "cli",
+    "encouragement",
+    "claude"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/GitFrog1111/badclaude.git"
-  },
-  "bugs": {
-    "url": "https://github.com/GitFrog1111/badclaude/issues"
-  },
-  "homepage": "https://github.com/GitFrog1111/badclaude#readme",
   "files": [
     "main.js",
     "preload.js",
     "overlay.html",
     "sounds",
     "icon",
-    "bin/badclaude.js",
+    "bin/goodclaude.js",
     "README.md"
   ],
   "scripts": {
diff --git a/preload.js b/preload.js
index ae83618..58f9952 100644
--- a/preload.js
+++ b/preload.js
@@ -1,8 +1,10 @@
+// ABOUTME: Electron preload bridge exposing IPC channels for the sparkle wand overlay
+// ABOUTME: Connects renderer (overlay.html) to main process (main.js) via secure context bridge
 const { contextBridge, ipcRenderer } = require('electron');
 
 contextBridge.exposeInMainWorld('bridge', {
-  whipCrack: () => ipcRenderer.send('whip-crack'),
+  sendBlessing: () => ipcRenderer.send('send-blessing'),
   hideOverlay: () => ipcRenderer.send('hide-overlay'),
-  onSpawnWhip: (fn) => ipcRenderer.on('spawn-whip', () => fn()),
-  onDropWhip: (fn) => ipcRenderer.on('drop-whip', () => fn()),
+  onSpawnWand: (fn) => ipcRenderer.on('spawn-wand', () => fn()),
+  onDropWand: (fn) => ipcRenderer.on('drop-wand', () => fn()),
 });
diff --git a/scripts/generate-icons.py b/scripts/generate-icons.py
new file mode 100644
index 0000000..87e29d2
--- /dev/null
+++ b/scripts/generate-icons.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# ABOUTME: Generates app icons for goodclaude — golden halo with sparkles on a warm gradient
+# ABOUTME: Creates macOS .icns, Windows .ico, and tray Template.png
+from PIL import Image, ImageDraw, ImageFilter
+import math, os, subprocess, shutil
+
+ICON_DIR = os.path.join(os.path.dirname(__file__), '..', 'icon')
+
+def lerp(a, b, t):
+    return a + (b - a) * t
+
+def draw_sparkle(draw, cx, cy, size, color=(255, 255, 230, 255)):
+    """Draw a 4-pointed sparkle star."""
+    for i in range(4):
+        angle = i * math.pi / 2
+        ex = cx + math.cos(angle) * size
+        ey = cy + math.sin(angle) * size
+        perp = angle + math.pi / 2
+        w = size * 0.18
+        px, py = math.cos(perp) * w, math.sin(perp) * w
+        draw.polygon([(cx + px, cy + py), (ex, ey), (cx - px, cy - py)], fill=color)
+
+
+def create_app_icon(size):
+    """Golden halo + sparkles on warm gradient background."""
+    s = size * 4  # supersampled
+    img = Image.new('RGBA', (s, s), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    cx, cy = s // 2, s // 2
+    radius = int(s * 0.47)
+
+    # Radial gradient background: warm peach center -> soft lavender edge
+    for i in range(radius, 0, -2):
+        t = i / radius
+        r = int(lerp(255, 110, t))
+        g = int(lerp(210, 90, t))
+        b = int(lerp(230, 175, t))
+        draw.ellipse([cx - i, cy - i, cx + i, cy + i], fill=(r, g, b, 255))
+
+    # -- Halo glow (blurred golden ellipse beneath the ring) --
+    glow = Image.new('RGBA', (s, s), (0, 0, 0, 0))
+    gd = ImageDraw.Draw(glow)
+    halo_rx = int(s * 0.30)
+    halo_ry = int(s * 0.11)
+    halo_cy = cy - int(s * 0.04)
+    glow_pad = int(s * 0.04)
+    gd.ellipse(
+        [cx - halo_rx - glow_pad, halo_cy - halo_ry - glow_pad,
+         cx + halo_rx + glow_pad, halo_cy + halo_ry + glow_pad],
+        fill=(255, 225, 50, 120)
+    )
+    glow = glow.filter(ImageFilter.GaussianBlur(radius=int(s * 0.04)))
+    img = Image.alpha_composite(img, glow)
+    draw = ImageDraw.Draw(img)
+
+    # -- Halo ring --
+    thick = max(int(s * 0.032), 3)
+    draw.ellipse(
+        [cx - halo_rx, halo_cy - halo_ry, cx + halo_rx, halo_cy + halo_ry],
+        outline=(255, 200, 0, 255), width=thick
+    )
+    # Bright highlight on inner edge
+    inner_t = max(thick // 3, 1)
+    shrink = thick // 3
+    draw.ellipse(
+        [cx - halo_rx + shrink, halo_cy - halo_ry + shrink,
+         cx + halo_rx - shrink, halo_cy + halo_ry - shrink],
+        outline=(255, 245, 180, 220), width=inner_t
+    )
+
+    # -- Sparkle stars --
+    sparkles = [
+        (cx - int(s * 0.25), cy - int(s * 0.27), int(s * 0.065)),
+        (cx + int(s * 0.28), cy - int(s * 0.20), int(s * 0.050)),
+        (cx + int(s * 0.15), cy + int(s * 0.28), int(s * 0.045)),
+        (cx - int(s * 0.20), cy + int(s * 0.26), int(s * 0.038)),
+        (cx + int(s * 0.02), cy - int(s * 0.36), int(s * 0.055)),
+    ]
+    for sx, sy, ss in sparkles:
+        draw_sparkle(draw, sx, sy, ss, (255, 255, 220, 240))
+        # Bright center dot
+        dot_r = max(int(ss * 0.3), 1)
+        draw.ellipse([sx - dot_r, sy - dot_r, sx + dot_r, sy + dot_r],
+                     fill=(255, 255, 255, 220))
+
+    # Clip to circle (rounded app icon mask)
+    mask = Image.new('L', (s, s), 0)
+    md = ImageDraw.Draw(mask)
+    md.ellipse([cx - radius, cy - radius, cx + radius, cy + radius], fill=255)
+    img.putalpha(mask)
+
+    return img.resize((size, size), Image.LANCZOS)
+
+
+def create_template_icon(size):
+    """macOS tray template icon — black silhouette with alpha."""
+    s = size * 4
+    img = Image.new('RGBA', (s, s), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    cx, cy = s // 2, s // 2
+
+    # Halo ring (bold for visibility)
+    halo_rx = int(s * 0.38)
+    halo_ry = int(s * 0.14)
+    halo_cy = cy - int(s * 0.04)
+    thick = max(int(s * 0.055), 2)
+    draw.ellipse(
+        [cx - halo_rx, halo_cy - halo_ry, cx + halo_rx, halo_cy + halo_ry],
+        outline=(0, 0, 0, 255), width=thick
+    )
+
+    # Sparkles
+    sparkles = [
+        (cx - int(s * 0.28), cy - int(s * 0.26), int(s * 0.09)),
+        (cx + int(s * 0.30), cy - int(s * 0.18), int(s * 0.07)),
+        (cx, cy + int(s * 0.28), int(s * 0.07)),
+    ]
+    for sx, sy, ss in sparkles:
+        draw_sparkle(draw, sx, sy, ss, (0, 0, 0, 255))
+
+    return img.resize((size, size), Image.LANCZOS)
+
+
+def build_icns(master):
+    """Create .icns via iconutil from a master RGBA image."""
+    iconset = os.path.join(ICON_DIR, 'AppIcon.iconset')
+    os.makedirs(iconset, exist_ok=True)
+    sizes = [16, 32, 128, 256, 512]
+    for sz in sizes:
+        master.resize((sz, sz), Image.LANCZOS).save(
+            os.path.join(iconset, f'icon_{sz}x{sz}.png'))
+        master.resize((sz * 2, sz * 2), Image.LANCZOS).save(
+            os.path.join(iconset, f'icon_{sz}x{sz}@2x.png'))
+    subprocess.run(
+        ['iconutil', '-c', 'icns', iconset, '-o', os.path.join(ICON_DIR, 'AppIcon.icns')],
+        check=True)
+    shutil.rmtree(iconset)
+    print('  -> AppIcon.icns')
+
+
+def build_ico(master):
+    """Create Windows .ico with multiple sizes."""
+    sizes = [(16, 16), (32, 32), (48, 48), (256, 256)]
+    imgs = [master.resize(s, Image.LANCZOS) for s in sizes]
+    imgs[0].save(os.path.join(ICON_DIR, 'icon.ico'), format='ICO',
+                 append_images=imgs[1:], sizes=sizes)
+    print('  -> icon.ico')
+
+
+def main():
+    os.makedirs(ICON_DIR, exist_ok=True)
+    print('Generating goodclaude icons...')
+
+    # App icon master at 1024x1024
+    master = create_app_icon(1024)
+    master.save(os.path.join(ICON_DIR, 'AppIcon.png'))
+    print('  -> AppIcon.png (1024x1024 master)')
+
+    # macOS .icns
+    build_icns(master)
+
+    # Windows .ico
+    build_ico(master)
+
+    # Tray template icon (22px is standard macOS menu bar height)
+    template = create_template_icon(22)
+    template.save(os.path.join(ICON_DIR, 'Template.png'))
+    # Also save @2x for retina
+    template_2x = create_template_icon(44)
+    template_2x.save(os.path.join(ICON_DIR, 'Template@2x.png'))
+    print('  -> Template.png + Template@2x.png')
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()