@rune-kit/rune 2.2.1 → 2.2.2

package/docs/video-demo-plan.md

@@ -0,0 +1,172 @@
+# Rune Demo Video — Production Plan
+
+**Topic**: Rune plugin full demo — install to debug to ship
+**Audience**: Developers using AI coding assistants (Claude Code, Cursor, Windsurf)
+**Duration**: 180 seconds (3 minutes)
+**Platform**: YouTube (primary), Twitter/X (60s cut), GitHub README (embedded)
+**Style**: Screen recording + narration overlay, dark terminal theme
+
+---
+
+## Script (with timing marks)
+
+### HOOK (0:00–0:08)
+
+> "You're debugging for the 4th time. Claude keeps suggesting the same fix. Same loop. Same frustration."
+> [Screen: terminal showing repeated failed attempts]
+> "What if your AI assistant had a structured workflow that actually worked?"
+
+### INTRO (0:08–0:20)
+
+> "This is Rune — a 57-skill mesh that turns your AI coding assistant from a chatbot into an engineering team."
+> [Screen: Rune GitHub page, star count, "57 skills | 200+ connections"]
+> "It works on Claude Code, Cursor, Windsurf, and Antigravity. Let me show you."
+
+### SCENE 1: INSTALL (0:20–0:40)
+
+> "Install takes 10 seconds."
+> [Screen: terminal]
+> ```
+> claude plugin install rune-kit/rune
+> ```
+> [Plugin installs, shows "57 skills loaded"]
+> "For Cursor or Windsurf, one command compiles all skills into your IDE's format."
+> [Screen: terminal]
+> ```
+> npx --yes @rune-kit/rune init --platform cursor
+> ```
+> [Shows files being generated]
+
+### SCENE 2: ONBOARD (0:40–1:00)
+
+> "First thing — let Rune understand your project."
+> [Screen: terminal in a real project directory]
+> ```
+> /rune onboard
+> ```
+> [Shows scout scanning files, detecting Next.js + Prisma + TypeScript]
+> [Shows .rune/ directory being created with decisions.md, conventions.md]
+> "Rune scans your codebase, detects your stack, and creates context files that persist across sessions. No more re-explaining your project every time."
+
+### SCENE 3: DEBUG (1:00–1:30)
+
+> "Now let's debug. Users report login returns 401 for valid credentials."
+> [Screen: terminal]
+> ```
+> /rune debug "login returns 401 for valid credentials"
+> ```
+> [Shows debug skill activating]
+> [Shows scout finding auth files → debug reading them → identifying root cause]
+> "Rune's debug skill traces the code path, finds the root cause — an expired JWT secret rotation — and hands it to fix."
+> [Shows fix skill writing the code change]
+> [Shows verification running: lint pass, typecheck pass, tests pass]
+> "Fixed. Verified. One command."
+
+### SCENE 4: BUILD A FEATURE (1:30–2:15)
+
+> "Now let's build something. Add Stripe billing to our SaaS app."
+> [Screen: terminal]
+> ```
+> /rune cook "add Stripe subscription billing with plan management"
+> ```
+> [Shows cook Phase 1: scout scanning → detecting @rune/saas pack]
+> [Shows cook Phase 2: plan creating implementation steps]
+> [Shows adversary challenging the plan: "Missing webhook signature verification — CRITICAL"]
+> "See that? Before writing a single line of code, Rune's adversary skill red-teams the plan. Found a missing webhook security check."
+> [Shows plan updated → user approves]
+> [Shows cook Phase 3: test writing failing tests]
+> [Shows cook Phase 4: fix implementing code]
+> [Shows cook Phase 5: preflight + sentinel + review running in parallel]
+> [Shows cook Phase 6: all green]
+> "8 phases. TDD. Security scan. Code review. All orchestrated automatically."
+
+### SCENE 5: THE MESH (2:15–2:40)
+
+> "This isn't a list of independent tools. It's a mesh."
+> [Screen: animated diagram showing skill connections]
+> "When debug can't find the cause, it escalates to problem-solver. When cook hits a wall 3 times, it pivots to brainstorm. When sentinel finds a vulnerability, it blocks the commit."
+> [Shows mesh diagram with glowing connections]
+> "57 skills. 200+ connections. They talk to each other so you don't have to."
+
+### CTA (2:40–3:00)
+
+> "Rune is free and open source. MIT license."
+> [Screen: GitHub repo]
+> ```
+> claude plugin install rune-kit/rune
+> ```
+> "Or for any IDE:"
+> ```
+> npx --yes @rune-kit/rune init
+> ```
+> [Screen: landing page with GitHub stars]
+> "Less skills. Deeper connections. Link in description."
+
+---
+
+## Storyboard
+
+| Time | Visual | Audio | Transition |
+|------|--------|-------|------------|
+| 0:00 | Dark terminal, red error messages repeating | Narration: frustration hook | Fade in |
+| 0:08 | Rune GitHub page, hero section | Narration: intro | Cut |
+| 0:20 | Terminal: plugin install command | Narration: install | Cut |
+| 0:30 | Terminal: npx init for Cursor | Narration: multi-platform | Cut |
+| 0:40 | Terminal: /rune onboard in real project | Narration: onboard | Cut |
+| 0:50 | .rune/ directory tree appearing | Narration: context persistence | Slide in |
+| 1:00 | Terminal: /rune debug command | Narration: debug scenario | Cut |
+| 1:10 | Code files being read, root cause highlighted | Narration: tracing | Zoom |
+| 1:20 | Fix being written, tests passing | Narration: fixed + verified | Cut |
+| 1:30 | Terminal: /rune cook command | Narration: build feature | Cut |
+| 1:45 | Plan appearing, adversary challenge in red | Narration: red-team | Highlight |
+| 2:00 | TDD cycle: red → green → refactor | Narration: phases | Split screen |
+| 2:10 | Quality gates all green | Narration: automatic orchestration | Cut |
+| 2:15 | Mesh diagram (animated) | Narration: mesh explanation | Fade |
+| 2:30 | Connections glowing between skills | Narration: resilience | Pulse animation |
+| 2:40 | GitHub repo + install command | Narration: CTA | Cut |
+| 2:50 | Landing page | Narration: tagline | Fade out |
+
+---
+
+## Shot List
+
+| # | Type | Content | Duration | Notes |
+|---|------|---------|----------|-------|
+| 1 | Screen rec | Terminal with repeated errors | 8s | Use real project, dark theme |
+| 2 | Screen rec | Rune GitHub page scroll | 5s | Show stars, description |
+| 3 | Screen rec | `claude plugin install` | 8s | Real-time, no speedup |
+| 4 | Screen rec | `npx @rune-kit/rune init` | 8s | Show file generation |
+| 5 | Screen rec | `/rune onboard` full flow | 15s | Speed up 2x, show key moments |
+| 6 | Screen rec | `/rune debug` full flow | 25s | Speed up 2x, pause on root cause |
+| 7 | Screen rec | `/rune cook` full flow | 40s | Speed up 3x, pause on adversary + quality |
+| 8 | Graphic | Mesh diagram animation | 20s | Create with Motion Canvas or After Effects |
+| 9 | Screen rec | GitHub + install commands | 15s | Clean, centered text |
+| 10 | Graphic | Landing page + tagline | 10s | End card with links |
+
+---
+
+## Asset Checklist
+
+- [ ] Real project for demo (Next.js + Prisma SaaS app recommended)
+- [ ] Rune plugin installed and working
+- [ ] Terminal theme: dark, high contrast, large font (18-20pt)
+- [ ] Screen recording tool: OBS or Loom
+- [ ] Mesh diagram: create SVG or use Motion Canvas
+- [ ] Background music: lo-fi or minimal electronic (royalty-free)
+- [ ] Microphone for narration (or use ElevenLabs/AI voice)
+- [ ] Thumbnail: terminal screenshot + "57 Skills" text overlay
+- [ ] Captions/subtitles file (.srt) for accessibility
+
+## 60-Second Twitter/X Cut
+
+Use shots: 1 (3s) → 3 (5s) → 6 (15s) → 7 (20s) → 8 (10s) → 9 (7s)
+Skip: onboard detail, mesh explanation
+Hook: "Your AI assistant keeps failing? Try giving it a brain." + demo
+
+## Distribution
+
+- YouTube: full 3-min version with chapters
+- Twitter/X: 60s cut, captions baked in, no music
+- GitHub README: YouTube embed at top
+- Landing page: YouTube embed in hero section
+- Reddit r/ClaudeAI, r/cursor, r/webdev: link + text summary

package/extensions/ui/PACK.md

@@ -12,6 +12,8 @@ metadata:
 
 # @rune/ui
 
+> Design intelligence data: [UI/UX Pro Max](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill) (MIT) — 161 palettes, 84 styles, 73 font pairings, 99 UX guidelines. Located at `references/ui-pro-max-data/`.
+
 ## Purpose
 
 Frontend development accumulates invisible debt: ad-hoc color variables, mismatched font pairings, prop-drilled components, untested accessibility, janky animations, React anti-patterns, and slow page loads — all before you even decide what the product should *look* like. This pack addresses all layers systematically. Ten skills cover the full UI lifecycle: React codebase health scoring, Core Web Vitals performance auditing, token consistency, color palette selection, typography pairing, component composability, landing page structure, design-domain mapping, WCAG compliance, and motion polish. Run any skill independently or chain all ten as a comprehensive UI health check + design foundation generator.

package/extensions/ui/skills/design-decision.md

@@ -23,6 +23,8 @@ Emit a `design-system.md` file in the project root (or `.rune/`) with: color tok
 
 #### Domain → Style Matrix
 
+The matrix below provides default mappings. When `references/ui-pro-max-data/styles.csv` is available, query it for **84 additional styles** with industry-specific parameters — filter by domain column for expanded recommendations beyond these 10 defaults.
+
 ```
 Domain            Style              Palette              Typography         Component Aesthetic
 ─────────────────────────────────────────────────────────────────────────────────────────────
@@ -40,6 +42,14 @@ DevTools          Terminal + Crisp   terminal-dark        JetBrains Mono+Inter C
 * Palette not shown in palette-picker example block — generate with same CSS custom props pattern.
 ```
 
+#### Extended Data (UI/UX Pro Max)
+
+When `references/ui-pro-max-data/` exists:
+- `styles.csv` — 84 styles with color params, animation, WCAG levels, mobile flags
+- `typography.csv` — 73 font pairings with Google Fonts URLs, Tailwind config, mood keywords
+- `ui-reasoning.csv` — 161 industry-specific reasoning rules (filter by domain)
+- Query: filter CSV by domain/category column → get expanded recommendations
+
 #### Style Characteristic Reference
 
 ```

package/extensions/ui/skills/palette-picker.md

@@ -26,6 +26,8 @@ Run contrast checks: primary text on background (≥ 4.5:1), large headings (≥
 
 #### Decision Tree
 
+The tree below provides 10 default palettes. When `references/ui-pro-max-data/colors.csv` is available, query it for **161 industry-specific palettes** with full dark/light variants, semantic tokens, and design psychology notes. Filter by domain column for expanded options.
+
 ```
 Product Type          → Palette Recommendation
 ─────────────────────────────────────────────────
@@ -41,6 +43,15 @@ productivity / tools  → Calm Focus (gray-50 + indigo-700, minimal noise)
 developer tools       → Terminal Dark (zinc-950 + emerald-400 mono)
 ```
 
+#### Extended Palette DB (UI/UX Pro Max)
+
+When `references/ui-pro-max-data/colors.csv` exists:
+- 161 palettes with Primary, Secondary, Accent, Background, Foreground (dark+light)
+- Semantic tokens: Card, Muted, Border, Destructive, Ring variants
+- Design psychology notes per palette
+- Query: `grep -i "<domain>" references/ui-pro-max-data/colors.csv` → get domain-matched palettes
+- Anti-AI check: if selected palette uses #6366f1 (indigo) or #8b5cf6 (violet) as primary → flag and suggest alternatives from DB
+
 #### Palette Reference
 
 ```css

package/hooks/auto-format/index.cjs

@@ -0,0 +1,48 @@
+// Rune Auto-Format Hook
+// PostToolUse hook on Edit/Write — runs Prettier on JS/TS files after modification
+//
+// Only runs if Prettier is available in the project.
+// Silent pass-through if not applicable.
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+const input = JSON.parse(process.env.CLAUDE_TOOL_INPUT || '{}');
+const filePath = input.file_path || input.filePath || '';
+
+// Only format JS/TS/JSON/CSS files
+if (!/\.(js|jsx|ts|tsx|json|css|scss|md|html|yaml|yml)$/i.test(filePath)) {
+  process.exit(0);
+}
+
+// Check if file exists and is within a project with Prettier
+const dir = path.dirname(filePath);
+
+// Try to find prettier in the project
+let hasPrettier = false;
+try {
+  execSync('npx prettier --version', { cwd: dir, encoding: 'utf-8', stdio: 'pipe', timeout: 5000 });
+  hasPrettier = true;
+} catch {
+  // No Prettier available — skip silently
+}
+
+if (!hasPrettier) {
+  process.exit(0);
+}
+
+// Run Prettier on the file
+try {
+  execSync(`npx prettier --write "${filePath}"`, {
+    cwd: dir,
+    encoding: 'utf-8',
+    stdio: 'pipe',
+    timeout: 10000,
+  });
+  // Silent success — formatted files are seamless
+} catch (e) {
+  // Prettier failed — non-critical, just warn
+  console.log(`[Rune auto-format] Prettier failed on ${path.basename(filePath)}: ${e.message.split('\n')[0]}`);
+}
+
+process.exit(0);

package/hooks/context-watch/index.cjs

@@ -0,0 +1,68 @@
+// Rune Context Watch Hook
+// Lightweight tool call counter — detects context pressure and suggests rune:context-engine
+// Runs as PreToolUse hook on Edit/Write (high-cost operations)
+//
+// H3 Intelligence: also tracks tool type distribution and session start timestamp
+// for metrics aggregation at session end.
+//
+// Uses a temp file counter (survives across hook invocations within same session).
+// Zero overhead: just reads/increments a number. No token cost.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Counter file scoped to current working directory (hash of cwd)
+const cwd = process.cwd();
+const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+
+// Thresholds
+const FIRST_WARNING = 40;
+const REPEAT_INTERVAL = 20;
+const CRITICAL_THRESHOLD = 80;
+
+// Detect tool type from environment
+const toolName = process.env.CLAUDE_TOOL_NAME || 'unknown';
+
+// Read current state
+let state = { count: 0, lastWarning: 0, sessionStart: null, toolCounts: {} };
+try {
+  const raw = fs.readFileSync(counterFile, 'utf-8');
+  state = JSON.parse(raw);
+  // Ensure toolCounts exists (upgrade from old format)
+  if (!state.toolCounts) state.toolCounts = {};
+  if (!state.sessionStart) state.sessionStart = new Date().toISOString();
+} catch {
+  // First run or corrupted — start fresh
+  state.sessionStart = new Date().toISOString();
+}
+
+// Increment total and per-tool counters
+state.count += 1;
+state.toolCounts[toolName] = (state.toolCounts[toolName] || 0) + 1;
+
+// Check thresholds
+const count = state.count;
+const sinceLast = count - state.lastWarning;
+
+if (count >= CRITICAL_THRESHOLD && sinceLast >= REPEAT_INTERVAL) {
+  console.log(`\n🔴 [Rune context-watch] ${count} tool calls — context likely RED (>85%).`);
+  console.log('  RECOMMENDED: Invoke rune:context-engine for state save + /compact.');
+  console.log('  Risk: auto-compaction may lose critical decisions without state save.\n');
+  state.lastWarning = count;
+} else if (count >= FIRST_WARNING && sinceLast >= REPEAT_INTERVAL) {
+  console.log(`\n🟡 [Rune context-watch] ${count} tool calls — context filling up.`);
+  console.log('  Consider invoking rune:context-engine at the next logical boundary.');
+  console.log('  Or run /compact manually if at a good stopping point.\n');
+  state.lastWarning = count;
+}
+
+// Persist
+try {
+  fs.writeFileSync(counterFile, JSON.stringify(state));
+} catch {
+  // Non-critical — counter resets next run
+}
+
+process.exit(0);

package/hooks/hooks.json

@@ -0,0 +1,99 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" session-start",
+            "async": false
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Read|Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" pre-tool-guard",
+            "async": false
+          }
+        ]
+      },
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" context-watch",
+            "async": true
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" secrets-scan",
+            "async": false
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" auto-format",
+            "async": true
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" typecheck",
+            "async": true
+          }
+        ]
+      },
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" metrics-collector",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" pre-compact",
+            "async": false
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.cjs\" post-session-reflect",
+            "async": false
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/metrics-collector/index.cjs

@@ -0,0 +1,42 @@
+// Rune Metrics Collector Hook
+// PostToolUse on Skill — captures skill invocations for H3 mesh analytics
+// Append-only JSONL to tmpdir. Flushed to .rune/metrics/ at session end.
+// Async: true — never blocks skill execution.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const cwd = process.cwd();
+const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+const metricsFile = path.join(os.tmpdir(), `rune-metrics-${hash}.jsonl`);
+
+// Extract skill name from tool input
+const toolInput = process.env.CLAUDE_TOOL_INPUT || '';
+let skillName = 'unknown';
+try {
+  const parsed = JSON.parse(toolInput);
+  // Skill tool input has { skill: "rune:cook" } or { skill: "cook" }
+  const raw = parsed.skill || parsed.name || '';
+  skillName = raw.replace(/^rune:/, '');
+} catch {
+  // If not JSON, try raw string match
+  const match = toolInput.match(/(?:rune:)?([a-z][\w-]*)/i);
+  if (match) skillName = match[1];
+}
+
+if (skillName && skillName !== 'unknown') {
+  const entry = JSON.stringify({
+    ts: new Date().toISOString(),
+    skill: skillName,
+    event: 'invoke'
+  });
+
+  try {
+    fs.appendFileSync(metricsFile, entry + '\n');
+  } catch {
+    // Non-critical — metrics are best-effort
+  }
+}
+
+process.exit(0);

package/hooks/post-session-reflect/index.cjs

@@ -0,0 +1,153 @@
+// Rune Post-Session Reflect Hook
+// 1. Flushes session metrics from tmpdir to .rune/metrics/ (H3 Intelligence)
+// 2. Displays structured self-review checklist at session end (Stop event)
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const cwd = process.cwd();
+const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
+
+// === H3: Flush Session Metrics ===
+
+const metricsJsonl = path.join(os.tmpdir(), `rune-metrics-${hash}.jsonl`);
+const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+const runeMetricsDir = path.join(cwd, '.rune', 'metrics');
+
+try {
+  flushMetrics();
+} catch (e) {
+  // Metrics flush is best-effort — never block session end
+  // Silently ignore errors
+}
+
+function flushMetrics() {
+  // Read session skill invocations from tmpdir JSONL
+  let skillEvents = [];
+  if (fs.existsSync(metricsJsonl)) {
+    const lines = fs.readFileSync(metricsJsonl, 'utf-8').trim().split('\n').filter(Boolean);
+    for (const line of lines) {
+      try { skillEvents.push(JSON.parse(line)); } catch { /* skip malformed */ }
+    }
+  }
+
+  // Read context-watch state for tool counts and session timing
+  let watchState = { count: 0, sessionStart: null, toolCounts: {} };
+  if (fs.existsSync(counterFile)) {
+    try {
+      watchState = JSON.parse(fs.readFileSync(counterFile, 'utf-8'));
+    } catch { /* use defaults */ }
+  }
+
+  // Nothing to flush if no data
+  if (skillEvents.length === 0 && watchState.count === 0) return;
+
+  // Ensure .rune/metrics/ exists
+  fs.mkdirSync(runeMetricsDir, { recursive: true });
+
+  const now = new Date().toISOString();
+  const sessionStart = watchState.sessionStart || now;
+  const durationMin = Math.round((new Date(now) - new Date(sessionStart)) / 60000);
+
+  // Build skill usage map
+  const skillCounts = {};
+  const skillChain = [];
+  for (const evt of skillEvents) {
+    skillCounts[evt.skill] = (skillCounts[evt.skill] || 0) + 1;
+    skillChain.push(evt.skill);
+  }
+
+  // Determine primary skill (most invoked)
+  const primarySkill = Object.entries(skillCounts)
+    .sort((a, b) => b[1] - a[1])[0]?.[0] || 'none';
+
+  // Generate session ID
+  const sessionId = `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
+
+  // 1. Append to sessions.jsonl
+  const sessionEntry = {
+    id: sessionId,
+    date: now.slice(0, 10),
+    duration_min: durationMin,
+    tool_calls: watchState.count,
+    tool_distribution: watchState.toolCounts,
+    skill_invocations: skillEvents.length,
+    skills_used: Object.keys(skillCounts),
+    primary_skill: primarySkill
+  };
+
+  const sessionsFile = path.join(runeMetricsDir, 'sessions.jsonl');
+  fs.appendFileSync(sessionsFile, JSON.stringify(sessionEntry) + '\n');
+
+  // Cap at 100 sessions (rotate oldest)
+  try {
+    const allLines = fs.readFileSync(sessionsFile, 'utf-8').trim().split('\n').filter(Boolean);
+    if (allLines.length > 100) {
+      fs.writeFileSync(sessionsFile, allLines.slice(-100).join('\n') + '\n');
+    }
+  } catch { /* cap is best-effort */ }
+
+  // 2. Merge into skills.json (running totals)
+  const skillsFile = path.join(runeMetricsDir, 'skills.json');
+  let skillsData = { version: 1, updated: now, skills: {} };
+  if (fs.existsSync(skillsFile)) {
+    try {
+      skillsData = JSON.parse(fs.readFileSync(skillsFile, 'utf-8'));
+    } catch { /* start fresh */ }
+  }
+
+  for (const [skill, count] of Object.entries(skillCounts)) {
+    if (!skillsData.skills[skill]) {
+      skillsData.skills[skill] = { total_invocations: 0, last_used: now.slice(0, 10) };
+    }
+    skillsData.skills[skill].total_invocations += count;
+    skillsData.skills[skill].last_used = now.slice(0, 10);
+  }
+  skillsData.updated = now;
+
+  fs.writeFileSync(skillsFile, JSON.stringify(skillsData, null, 2) + '\n');
+
+  // 3. Append to chains.jsonl
+  if (skillChain.length > 0) {
+    const chainsFile = path.join(runeMetricsDir, 'chains.jsonl');
+    const chainEntry = {
+      session: sessionId,
+      chain: skillChain,
+      depth: skillChain.length
+    };
+    fs.appendFileSync(chainsFile, JSON.stringify(chainEntry) + '\n');
+  }
+
+  // 4. Cleanup tmpdir files
+  try { fs.unlinkSync(metricsJsonl); } catch { /* already gone */ }
+  // Note: counterFile is cleaned by session-start hook on next session
+
+  // Report metrics flush
+  const skillList = Object.entries(skillCounts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([s, c]) => `${s}(${c})`)
+    .join(', ');
+
+  console.log(`\n📊 [Rune metrics] Session ${sessionId} — ${durationMin}min, ${watchState.count} tool calls, ${skillEvents.length} skill invocations`);
+  if (skillList) console.log(`   Skills: ${skillList}`);
+  console.log(`   Saved to .rune/metrics/\n`);
+}
+
+// === Original: Verification Checklist ===
+
+console.log(`
+┌─────────────────────────────────────────────────────┐
+│  Rune Session End — Verification Checklist          │
+├─────────────────────────────────────────────────────┤
+│  Before closing this session, confirm:              │
+│                                                     │
+│  □ All TodoWrite tasks marked complete?             │
+│  □ Tests ran and passing?                           │
+│  □ No hardcoded secrets introduced?                 │
+│  □ If schema changed: migration + rollback exist?   │
+│  □ Verification ran (lint + types + build)?         │
+│                                                     │
+│  If any item is unclear → address it now.           │
+└─────────────────────────────────────────────────────┘
+`);