@rune-kit/rune 2.8.0 → 2.10.0

package/compiler/transforms/branding.js

@@ -12,7 +12,7 @@
 export const BRANDING_FOOTER = [
   '',
   '---',
-  '> **Rune Skill Mesh** — 59 skills, 200+ connections, 14 extension packs',
+  '> **Rune Skill Mesh** — 62 skills, 215+ connections, 14 extension packs',
   '> [Landing Page](https://rune-kit.github.io/rune) · [Source](https://github.com/rune-kit/rune) (MIT)',
   '> **Rune Pro** ($49 lifetime) — product, sales, data-science, support packs → [rune-kit/rune-pro](https://github.com/rune-kit/rune-pro)',
   '> **Rune Business** ($149 lifetime) — finance, legal, HR, enterprise-search packs → [rune-kit/rune-business](https://github.com/rune-kit/rune-business)',

package/extensions/ui/skills/animation-patterns.md

@@ -24,6 +24,27 @@ Use Grep to find every animation/transition declaration. Verify each is wrapped
 **Step 4 — Page transition patterns**
 Apply View Transitions API for same-document navigations (SvelteKit, Astro, vanilla JS). For React/Next.js, use Framer Motion `AnimatePresence` + `layoutId` for shared layout animations. Emit transition wrapper component with both strategies.
 
+**Step 5 — Mood-to-Animation Timing**
+
+If `.rune/design-system.md` contains a `## Mood` section, read the selected mood and apply the matching motion profile. This ensures animation feel aligns with the product's emotional intent — not just technical correctness.
+
+| Mood | Duration | Easing | Hover | Enter/Exit | Scroll | Signature |
+|------|----------|--------|-------|------------|--------|-----------|
+| **Impressed** | 0.8-1.2s | `ease-out` | Scale 1.03 + deep shadow | Fade-up 24px | Parallax layers | Staggered reveals with 100ms delay between items |
+| **Excited** | 0.4-0.6s | `spring(1, 80, 10)` | Scale 1.06 + color shift | Slide-in from edge | Snap scroll | Overshoot on entry (1.56 bounce), pulse on data change |
+| **Calm** | 0.6-0.8s | `ease-out-quad` | Subtle opacity 0.8→1 | Slow fade 300ms | Gentle float | Breathing rhythm on idle elements (opacity 0.7↔1, 4s loop) |
+| **Confident** | 0.3-0.5s | `ease` | Precise underline/border | Clean slide 16px | None or minimal | Sharp, decisive — no overshoot, no bounce |
+| **Playful** | 0.4-0.6s | `spring(1, 100, 12)` | Wobble or tilt (rotate ±2°) | Bounce-in from bottom | Elastic snap | Squish on click (scaleX 1.05, scaleY 0.95), emoji-like feedback |
+| **Techy** | 0.15-0.3s | `ease-out` | Glow border or underline | Instant or 100ms fade | Sticky headers | Typewriter text, cursor blink, terminal-feel transitions |
+| **Professional** | 0.2-0.3s | `ease` | Background tint only | Simple fade | Fixed header | Minimal — motion serves function, never decoration |
+| **Inspired** | 0.5-0.8s | `cubic-bezier(0.4, 0, 0.2, 1)` | Reveal hidden detail | Scroll-driven enter | Parallax + reveal | Cinematic — content appears as user discovers, like turning pages |
+
+**Usage rules:**
+1. Read mood from `.rune/design-system.md` → select matching row → apply as default motion tokens
+2. If no mood defined, fall back to **Professional** (safest, least opinionated)
+3. ALL timing values must be wrapped in `prefers-reduced-motion` check — mood doesn't override accessibility
+4. Mood overrides generic Step 2 micro-interactions where they conflict
+
 #### Example
 
 ```tsx

package/extensions/ui/skills/component-patterns.md

@@ -24,6 +24,31 @@ Write the refactored component skeleton following the compound component pattern
 **Step 4 — Composition vs inheritance + slot patterns**
 After structural refactor, audit for slot opportunities (Svelte `<slot>`, Vue `v-slot`, React `children` with typed slots). Enforce: prefer composition (pass components as props) over inheritance (extend base class). Flag any `extends React.Component` or class-based patterns for migration.
 
+**Step 5 — Bento Card Archetypes**
+
+When designing card-based layouts, apply named archetypes instead of uniform grids. Each archetype has a specific interaction model and animation signature. Mix archetypes within a page to create visual hierarchy.
+
+| Archetype | Content Type | Layout | Interaction | Animation |
+|-----------|-------------|--------|-------------|-----------|
+| **Intelligent List** | Ranked/sortable items (leaderboard, top assets, recent activity) | Vertical stack, auto-reorders | Drag to reorder, click to expand | `layoutId` shared animation on reorder — items slide to new position (Framer Motion `layout` prop) |
+| **Command Input** | Search, AI prompt, quick actions | Single input + dropdown results | Type to filter, keyboard nav, Enter to execute | Typewriter placeholder text + shimmer gradient on focus + results fade-in with 50ms stagger |
+| **Live Status** | Real-time metrics (uptime, price, active users) | Compact card, number-dominant | Hover for sparkline/history | Breathing pulse on idle (opacity 0.85↔1, 3s), overshoot scale on value change (spring) |
+| **Wide Data Stream** | Horizontal feed (news, transactions, timeline) | Full-width horizontal scroll or infinite carousel | Swipe/drag, auto-advance optional | Infinite scroll with momentum, snap to item, fade edges to signal overflow |
+| **Contextual Panel** | Detail view, settings, metadata | Expandable from parent card or sidebar | Click parent → panel slides in | Stagger children (50ms each), float-in from right (translateX 24px → 0) |
+
+**Anti-patterns for card layouts:**
+- ❌ **Uniform grid** — all cards same size, same padding, same content structure = AI signature
+- ❌ **Card soup** — cards with no clear grouping or hierarchy
+- ❌ **Static bento** — bento layout without interaction model = decorative, not functional
+
+**Composition rules:**
+1. A page should use 2-4 archetypes max — more = visual noise
+2. **Live Status** cards cluster together (dashboard KPI row)
+3. **Intelligent List** is the primary content area — usually takes 60%+ of viewport
+4. **Command Input** is a singleton — ONE per page, always accessible (often pinned top or Cmd+K)
+5. **Wide Data Stream** breaks vertical rhythm — use as section separator between dense blocks
+6. **Contextual Panel** is secondary — triggered by interaction, never shown by default on load
+
 #### Example
 
 ```tsx

package/extensions/ui/skills/landing-patterns.md

@@ -84,7 +84,7 @@ export function SplitHero() {
           <em className="not-italic text-[var(--primary)]">before the sprint</em>
         </h1>
         <p className="text-[var(--text-secondary)] text-body leading-relaxed mb-8 max-w-md">
-          Rune wires your AI coding assistant to a mesh of 55 skills so you spend time building, not prompting.
+          Rune wires your AI coding assistant to a mesh of 62 skills so you spend time building, not prompting.
         </p>
         <div className="flex flex-wrap gap-3">
           <a

package/hooks/context-watch/index.cjs

@@ -1,68 +1,95 @@
-// 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);
+// 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.
+//
+// Data source: stdin JSON from Claude Code (not env vars)
+
+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;
+
+// Read stdin JSON to get tool name (Claude Code passes hook data via stdin)
+let stdinData = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => { stdinData += chunk; });
+process.stdin.on('end', () => {
+  let toolName = 'unknown';
+  try {
+    const parsed = JSON.parse(stdinData);
+    toolName = parsed.tool || parsed.tool_name || 'unknown';
+  } catch {
+    // Fallback to env var for backwards compatibility
+    toolName = process.env.CLAUDE_TOOL_NAME || 'unknown';
+  }
+
+  // Read current state
+  let state = { count: 0, lastWarning: 0, sessionStart: null, sessionId: null, toolCounts: {} };
+  try {
+    const raw = fs.readFileSync(counterFile, 'utf-8');
+    state = JSON.parse(raw);
+    // Ensure fields exist (upgrade from old format)
+    if (!state.toolCounts) state.toolCounts = {};
+    if (!state.sessionStart) state.sessionStart = new Date().toISOString();
+    if (!state.sessionId) {
+      const s = state.sessionStart;
+      state.sessionId = `s-${s.slice(0, 10).replace(/-/g, '')}-${s.slice(11, 19).replace(/:/g, '')}`;
+    }
+  } catch {
+    // First run or corrupted — start fresh
+    const now = new Date().toISOString();
+    state.sessionStart = now;
+    state.sessionId = `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
+  }
+
+  // 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;
+  }
+
+  // Pass through stdin to stdout (required for PreToolUse hooks)
+  if (stdinData) process.stdout.write(stdinData);
+
+  // Persist
+  try {
+    fs.writeFileSync(counterFile, JSON.stringify(state));
+  } catch {
+    // Non-critical — counter resets next run
+  }
+
+  process.exit(0);
+});
+
+// Handle empty stdin (pipe closed immediately)
+process.stdin.on('error', () => process.exit(0));
+process.stdin.resume();

package/hooks/metrics-collector/index.cjs

@@ -1,42 +1,86 @@
-// 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);
+// 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.
+//
+// Data source: stdin JSON from Claude Code (not env vars)
+
+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`);
+const watchFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
+
+// Read stdin JSON to get tool input (Claude Code passes hook data via stdin)
+let stdinData = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', chunk => { stdinData += chunk; });
+process.stdin.on('end', () => {
+  let skillName = 'unknown';
+
+  try {
+    const hookData = JSON.parse(stdinData);
+    // PostToolUse stdin: { tool: "Skill", tool_input: { skill: "rune:cook", ... }, tool_result: ... }
+    const toolInput = hookData.tool_input || {};
+    const raw = toolInput.skill || toolInput.name || '';
+    skillName = raw.replace(/^rune:/, '') || 'unknown';
+  } catch {
+    // Fallback: try env var for backwards compatibility
+    const toolInput = process.env.CLAUDE_TOOL_INPUT || '';
+    try {
+      const parsed = JSON.parse(toolInput);
+      const raw = parsed.skill || parsed.name || '';
+      skillName = raw.replace(/^rune:/, '');
+    } catch {
+      const match = toolInput.match(/(?:rune:)?([a-z][\w-]*)/i);
+      if (match) skillName = match[1];
+    }
+  }
+
+  if (skillName && skillName !== 'unknown') {
+    const now = Date.now();
+    const ts = new Date(now).toISOString();
+
+    // Read session ID from context-watch state (shared tmpdir file)
+    let sessionId = null;
+    try {
+      const watchState = JSON.parse(fs.readFileSync(watchFile, 'utf-8'));
+      sessionId = watchState.sessionId || null;
+    } catch { /* no watch state yet */ }
+
+    // Compute duration since last skill event (approximate skill execution time)
+    let durationMs = null;
+    try {
+      const lines = fs.readFileSync(metricsFile, 'utf-8').trim().split('\n').filter(Boolean);
+      if (lines.length > 0) {
+        const last = JSON.parse(lines[lines.length - 1]);
+        durationMs = now - new Date(last.ts).getTime();
+        // Cap at 10 minutes — longer gaps are idle time, not skill duration
+        if (durationMs > 600000) durationMs = null;
+      }
+    } catch { /* first event or read error */ }
+
+    const entry = JSON.stringify({
+      ts,
+      skill: skillName,
+      event: 'invoke',
+      session_id: sessionId,
+      duration_ms: durationMs
+    });
+
+    try {
+      fs.appendFileSync(metricsFile, entry + '\n');
+    } catch {
+      // Non-critical — metrics are best-effort
+    }
+  }
+
+  process.exit(0);
+});
+
+// Handle empty stdin (pipe closed immediately)
+process.stdin.on('error', () => process.exit(0));
+process.stdin.resume();

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

@@ -15,6 +15,32 @@ 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');
 
+// Resolve skill names → expected model from agent frontmatter
+// Reads agents/*.md at flush time — no runtime model detection needed
+// Map skill names → models, weighted by invocation count
+// skillCounts: { skillName: invocationCount }
+function resolveSkillModels(skillCounts) {
+  const models = {};
+  const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || path.join(__dirname, '..', '..');
+  const agentsDir = path.join(pluginRoot, 'agents');
+
+  if (!fs.existsSync(agentsDir)) return models;
+
+  for (const [skill, count] of Object.entries(skillCounts)) {
+    try {
+      const agentFile = path.join(agentsDir, `${skill}.md`);
+      if (!fs.existsSync(agentFile)) continue;
+      const content = fs.readFileSync(agentFile, 'utf-8');
+      const match = content.match(/^model:\s*(\w+)/m);
+      if (match) {
+        const model = match[1];
+        models[model] = (models[model] || 0) + count;
+      }
+    } catch { /* best-effort */ }
+  }
+  return models;
+}
+
 try {
   flushMetrics();
 } catch (e) {
@@ -33,7 +59,7 @@ function flushMetrics() {
   }
 
   // Read context-watch state for tool counts and session timing
-  let watchState = { count: 0, sessionStart: null, toolCounts: {} };
+  let watchState = { count: 0, sessionStart: null, sessionId: null, toolCounts: {} };
   if (fs.existsSync(counterFile)) {
     try {
       watchState = JSON.parse(fs.readFileSync(counterFile, 'utf-8'));
@@ -50,20 +76,28 @@ function flushMetrics() {
   const sessionStart = watchState.sessionStart || now;
   const durationMin = Math.round((new Date(now) - new Date(sessionStart)) / 60000);
 
-  // Build skill usage map
+  // Build skill usage map and duration aggregation
   const skillCounts = {};
+  const skillDurations = {};
   const skillChain = [];
   for (const evt of skillEvents) {
     skillCounts[evt.skill] = (skillCounts[evt.skill] || 0) + 1;
     skillChain.push(evt.skill);
+    if (evt.duration_ms != null) {
+      skillDurations[evt.skill] = (skillDurations[evt.skill] || 0) + evt.duration_ms;
+    }
   }
 
   // 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, '')}`;
+  // Map skills to expected models from agent definitions (weighted by invocation count)
+  const modelsUsed = resolveSkillModels(skillCounts);
+
+  // Use session ID from context-watch (shared) or generate new
+  const sessionId = watchState.sessionId
+    || `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
 
   // 1. Append to sessions.jsonl
   const sessionEntry = {
@@ -74,7 +108,9 @@ function flushMetrics() {
     tool_distribution: watchState.toolCounts,
     skill_invocations: skillEvents.length,
     skills_used: Object.keys(skillCounts),
-    primary_skill: primarySkill
+    primary_skill: primarySkill,
+    models_used: modelsUsed,
+    skill_durations: Object.keys(skillDurations).length > 0 ? skillDurations : undefined
   };
 
   const sessionsFile = path.join(runeMetricsDir, 'sessions.jsonl');

package/hooks/session-start/index.cjs

@@ -8,10 +8,16 @@ const os = require('os');
 const cwd = process.cwd();
 const runeDir = path.join(cwd, '.rune');
 
-// Reset context-watch counter on session start (fresh context window)
+// Initialize fresh session state (shared between context-watch and metrics-collector)
 const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);
 const counterFile = path.join(os.tmpdir(), `rune-context-watch-${hash}.json`);
-try { fs.unlinkSync(counterFile); } catch { /* no counter yet — fine */ }
+const now = new Date().toISOString();
+const sessionId = `s-${now.slice(0, 10).replace(/-/g, '')}-${now.slice(11, 19).replace(/:/g, '')}`;
+try {
+  fs.writeFileSync(counterFile, JSON.stringify({
+    count: 0, lastWarning: 0, sessionStart: now, sessionId, toolCounts: {}
+  }));
+} catch { /* non-critical */ }
 
 if (fs.existsSync(runeDir)) {
   const stateFiles = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.8.0",
-  "description": "61-skill mesh for AI coding assistants — 5-layer architecture, 200+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
+  "version": "2.10.0",
+  "description": "62-skill mesh for AI coding assistants — 5-layer architecture, 215+ connections, 8 platforms (Claude Code, Cursor, Windsurf, Antigravity, Codex, OpenCode, OpenClaw, Generic)",
   "type": "module",
   "bin": {
     "rune": "./compiler/bin/rune.js"

package/skills/audit/SKILL.md

@@ -8,6 +8,7 @@ metadata:
   model: sonnet
   group: quality
   tools: "Read, Bash, Glob, Grep"
+  emit: audit.complete
 ---
 
 # audit

package/skills/autopsy/SKILL.md

@@ -3,7 +3,7 @@ name: autopsy
 description: Full codebase health assessment. Analyzes complexity, dependencies, dead code, tech debt, and git hotspots. Produces a health score and rescue plan.
 metadata:
   author: runedev
-  version: "0.3.0"
+  version: "0.4.0"
   layer: L2
   model: opus
   group: rescue
@@ -32,6 +32,32 @@ Full codebase health assessment for legacy projects. Autopsy analyzes complexity
 
 ## Execution Steps
 
+### Step 0 — Repo intelligence (if GitHub-hosted)
+
+If the project is a GitHub repository, gather repo-level metrics before diving into code:
+
+```bash
+# Fetch via GitHub API (requires gh CLI or curl + GITHUB_TOKEN)
+gh api repos/{owner}/{repo} --jq '{stars: .stargazers_count, forks: .forks_count, open_issues: .open_issues_count, license: .license.spdx_id, language: .language, topics: .topics, created: .created_at, pushed: .pushed_at}'
+
+# Contributor count and top contributors
+gh api repos/{owner}/{repo}/contributors --jq 'length' 
+gh api repos/{owner}/{repo}/contributors --jq '.[0:5] | .[] | "\(.login): \(.contributions)"'
+
+# Commit frequency (last 52 weeks)
+gh api repos/{owner}/{repo}/stats/commit_activity --jq '[.[] | .total] | add'
+
+# Language byte distribution
+gh api repos/{owner}/{repo}/languages
+```
+
+Record in working notes:
+- **Activity signal**: commits/week (>5 = active, 1-5 = maintained, <1 = stale)
+- **Bus factor**: contributor count (1 = critical risk, 2-3 = low, >5 = healthy)
+- **Community signal**: stars/forks ratio, open issue count, staleness of latest push
+
+Skip this step for local-only projects with no remote.
+
 ### Step 1 — Structure scan
 
 Call `rune:scout` with a request for a full project map. Ask scout to return:
@@ -84,6 +110,12 @@ git log --before="1 year ago" --format="%H" | head -1 | xargs -I{} git diff --na
 
 # Authors per file (high author count = high churn risk)
 git log --format="%an" -- <file> | sort -u | wc -l
+
+# Commit velocity by month (trend detection)
+git log --format="%Y-%m" | sort | uniq -c | tail -12
+
+# Issue/PR close rate (GitHub only)
+gh api repos/{owner}/{repo}/issues --jq '[.[] | select(.pull_request == null)] | length'
 ```
 
 Identify:
@@ -91,6 +123,7 @@ Identify:
 - God files (> 500 LOC with many importers)
 - Hotspot files (changed most often = highest bug density)
 - Dead files (no importers, no recent commits)
+- Velocity trend: accelerating, stable, or decelerating (compare last 3 months)
 
 ### Step 5 — Generate RESCUE-REPORT.md
 
@@ -108,7 +141,22 @@ Generated: [date]
 | [name] | [n]   | [low/med/high] | [%] | [low/med/high] | [tier] | [1-N] |
 
 ## Dependency Graph
-[Mermaid diagram of module coupling]
+[Mermaid flowchart of module coupling — use subgraphs for clusters]
+
+## Language Distribution
+[Mermaid pie chart — e.g., pie title Languages "TypeScript" : 65 "JavaScript" : 20 "CSS" : 15]
+
+## Commit Velocity (Last 12 Months)
+[Trend: accelerating / stable / decelerating — include monthly commit counts]
+
+## Repo Intelligence (GitHub only)
+| Metric | Value | Signal |
+|--------|-------|--------|
+| Stars | [n] | [community interest level] |
+| Contributors | [n] | [bus factor: critical/low/healthy] |
+| Open issues | [n] | [maintenance signal] |
+| Commits/week | [n] | [activity: active/maintained/stale] |
+| Last push | [date] | [freshness] |
 
 ## Surgery Queue (Priority Order)
 1. [module] — Score: [n] — [primary reason] — Suggested pattern: [pattern]
@@ -136,6 +184,34 @@ Output a summary of the findings:
 - Confirm RESCUE-REPORT.md was saved
 - Recommended next step: call `rune:safeguard` on the top-priority module
 
+## Confidence Scoring
+
+Every finding in the autopsy report MUST carry a confidence level:
+
+| Level | Range | Criteria |
+|-------|-------|----------|
+| High | 90-100% | Measured directly from code/git — LOC counted, tests run, deps parsed |
+| Medium | 70-89% | Inferred from strong signals — file patterns, naming conventions, partial git data |
+| Low | 50-69% | Estimated from weak signals — no git history, binary files, generated code |
+
+Rules:
+- Health scores backed by actual code metrics → High confidence
+- Health scores using git archaeology only (no code read) → Medium confidence
+- Health scores for modules where files couldn't be read (binary, encrypted, too large) → Low confidence
+- **Overall report confidence** = weighted average of module confidences (by LOC weight)
+- Include confidence in RESCUE-REPORT.md header: `Confidence: [High|Medium|Low] ([n]%)`
+
+## Multi-Round Analysis
+
+Autopsy follows a broad-to-narrow pattern to avoid missing systemic issues:
+
+1. **Round 1 — Surface scan** (Steps 0-1): Repo metrics + structure map. Goal: identify scope and major clusters.
+2. **Round 2 — Module deep dive** (Steps 2-3): Read and score each module. Goal: quantified health per module.
+3. **Round 3 — Cross-cutting analysis** (Step 4): Git archaeology + dependency graph. Goal: find systemic risks invisible at module level (circular deps, hotspot clusters, bus factor).
+4. **Round 4 — Synthesis** (Steps 5-6): Combine all rounds into prioritized report. Findings from later rounds may revise earlier scores.
+
+Do NOT skip rounds. Round 3 cross-cutting analysis frequently reveals risks that per-module analysis misses (e.g., a "healthy" module that is the single point of failure for 10 others).
+
 ## Health Score Factors
 
 ```