@rune-kit/rune 2.1.1

package/skills/video-creator/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: video-creator
+description: Video content planning. Writes narration scripts, storyboards, shot lists, and asset checklists. Saves plan to marketing/video-plan.md.
+metadata:
+  author: runedev
+  version: "0.2.0"
+  layer: L3
+  model: sonnet
+  group: media
+  tools: "Read, Write, Edit, Glob, Grep"
+---
+
+# video-creator
+
+## Purpose
+
+Video content planning for product demos and marketing. Writes narration scripts with timing marks, creates scene-by-scene storyboards, defines shot lists, and lists required assets. Saves the complete production plan to a file. This skill creates PLANS for video production — not actual video files.
+
+## Called By (inbound)
+
+- `marketing` (L2): demo/explainer video scripts
+- `launch` (L1): product demo videos
+
+## Calls (outbound)
+
+None — pure L3 utility.
+
+## Executable Instructions
+
+### Step 1: Receive Brief
+
+Accept input from calling skill:
+- `topic` — what the video is about (e.g. "Rune plugin demo", "Feature X walkthrough")
+- `audience` — who will watch (e.g. "developers", "non-technical founders", "existing users")
+- `duration` — target length in seconds (e.g. 60, 120, 300)
+- `platform` — where it will be published: `youtube` | `twitter` | `tiktok` | `loom` | `internal`
+- `output_path` — where to save the plan (default: `marketing/video-plan.md`)
+
+Derive constraints from platform:
+- YouTube: no strict length limit, chapters recommended for > 3min
+- Twitter/X: max 140 seconds, hook in first 3 seconds
+- TikTok: max 60 seconds, fast-paced cuts, captions required
+- Loom: async-friendly, screen recording focus, no music needed
+
+### Step 2: Script
+
+Write a narration script with timing marks:
+
+Structure:
+- **Hook** (0–5s): opening line that grabs attention — state the problem or the payoff
+- **Setup** (5–15s): context — who this is for and what they will learn
+- **Demo/Body** (15s–[duration-15s]): main content broken into scenes
+- **CTA** (last 10s): call to action — what to do next (star repo, sign up, share)
+
+Format each section:
+```
+[00:00] HOOK
+Narration: "..."
+On screen: [what viewer sees]
+
+[00:05] SETUP
+Narration: "..."
+On screen: [what viewer sees]
+```
+
+### Step 3: Storyboard
+
+Create a scene-by-scene breakdown:
+
+For each scene:
+- Scene number and name
+- Duration in seconds
+- Visual description (what appears on screen)
+- Narration text (from Step 2)
+- Transition type: cut | fade | zoom | slide
+
+Example:
+```
+Scene 3: Live demo — install command
+Duration: 12s
+Visual: Terminal window, typed command "npm install -g @rune/cli", output scrolling
+Narration: "Install in seconds with one command."
+Transition: cut
+```
+
+### Step 4: Shot List
+
+Define exactly what needs to be recorded or shown:
+
+Categorize by type:
+- **Screen recording**: list each screen state to capture (URL, app state, what to do)
+- **Code snippet**: list each code block to display (file path + line range, or inline)
+- **Diagram/slide**: list each static visual needed (title, key points)
+- **Terminal**: list each command sequence to record
+
+Format:
+```
+Shot 1 — Screen recording
+  URL: https://myapp.com/dashboard
+  Action: Click "New Project" → fill form → click Create
+  Duration: ~8s
+
+Shot 2 — Terminal
+  Command: npm install -g @rune/cli && rune init my-project
+  Expected output: [describe what should appear]
+  Duration: ~10s
+```
+
+### Step 5: Assets Needed
+
+List every asset required before recording can begin:
+
+- Screenshots (which pages/states)
+- Code snippets (which files, which sections)
+- Diagrams (topic, style: flowchart | architecture | comparison table)
+- Slide backgrounds or title cards
+- Thumbnail (dimensions based on platform: YouTube 1280x720, Twitter 1200x628)
+
+### Step 6: Report
+
+Use `Write` to save the complete video plan to `marketing/video-plan.md` (or the specified `output_path`):
+
+```markdown
+# Video Plan: [topic]
+
+- **Platform**: [platform]
+- **Target Duration**: [duration]s
+- **Audience**: [audience]
+- **Created**: [date]
+
+## Script
+[full timestamped script from Step 2]
+
+## Storyboard
+[scene-by-scene breakdown from Step 3]
+
+## Shot List
+[all shots from Step 4]
+
+## Assets Needed
+[checklist from Step 5]
+
+## Platform Notes
+[constraints and tips for the target platform]
+```
+
+Then output a summary to the calling skill:
+
+```
+## Video Plan Created
+
+- File: [output_path]
+- Scenes: [count]
+- Shots: [count]
+- Estimated recording time: [n] minutes
+- Assets to prepare: [count] items
+
+### Next Steps
+1. Prepare assets listed in the plan
+2. Record shots in order from the shot list
+3. Edit using the storyboard as reference
+```
+
+## Note
+
+This skill creates PLANS for video production. Actual recording and editing must be done by a human or a dedicated screen recording tool.
+
+## Output Format
+
+Video Plan saved to `marketing/video-plan.md` with script, storyboard, shot list, assets checklist, and platform notes. Summary report with scene/shot counts and estimated recording time. See Step 6 Report above for full template.
+
+## Constraints
+
+1. MUST confirm video parameters (duration, resolution, format) before generating
+2. MUST NOT exceed reasonable file sizes without user confirmation
+3. MUST save to project assets directory
+
+## Sharp Edges
+
+Known failure modes for this skill. Check these before declaring done.
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| Platform constraints not applied (e.g., Twitter max 140s exceeded) | HIGH | Step 1: derive constraints from platform immediately — they constrain everything downstream |
+| Missing CTA section in script | MEDIUM | CTA (last 10s) is required in every script — no exceptions regardless of duration |
+| Not saving to file (only verbal output) | HIGH | Constraint 3 + Step 6: Write to output_path is mandatory — verbal only = no persistence |
+| Promising an actual deliverable video file | MEDIUM | Note explicitly: this skill creates a PLAN — actual recording is done by a human |
+
+## Done When
+
+- Platform constraints identified and applied to duration/format
+- Script written with timing marks (hook, setup, demo/body, CTA)
+- Storyboard created scene-by-scene with transitions
+- Shot list categorized by type (screen recording, terminal, code, diagram)
+- Assets needed checklist generated
+- video-plan.md written to output_path via Write tool
+- Video Plan Created report emitted with scene count, shot count, and asset count
+
+## Cost Profile
+
+~500-1500 tokens input, ~500-1000 tokens output. Sonnet for script quality.

package/skills/watchdog/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: watchdog
+description: Post-deploy monitoring. Checks if deployed app is healthy — HTTP status, response times, error detection, and smoke test report.
+metadata:
+  author: runedev
+  version: "0.2.0"
+  layer: L3
+  model: sonnet
+  group: monitoring
+  tools: "Read, Bash, Glob, Grep"
+---
+
+# watchdog
+
+## Purpose
+
+Post-deploy monitoring. Receives a deployed URL and list of expected endpoints, runs health checks, measures response times, detects errors, and returns a structured smoke test report.
+
+## Called By (inbound)
+
+- `deploy` (L2): post-deploy monitoring setup
+- `launch` (L1): monitoring as part of launch pipeline
+- `incident` (L2): current system state check during incident triage
+
+## Calls (outbound)
+
+None — pure L3 utility.
+
+## Executable Instructions
+
+### Step 1: Receive Target
+
+Accept input from calling skill:
+- `base_url` — deployed application URL (e.g. `https://myapp.com`)
+- `endpoints` — list of paths to check (e.g. `["/", "/health", "/api/status"]`)
+
+If no endpoints provided, default to: `["/", "/health", "/ready"]`
+
+### Step 2: Health Check
+
+For each endpoint, run an HTTP status check using `Bash`:
+
+```bash
+curl -s -o /dev/null -w "%{http_code}" https://myapp.com/health
+```
+
+- 2xx → HEALTHY
+- 3xx → REDIRECT (note final destination)
+- 4xx → CLIENT_ERROR (flag as alert)
+- 5xx → SERVER_ERROR (flag as critical alert)
+- Connection refused / timeout → UNREACHABLE (flag as critical)
+
+### Step 3: Response Time
+
+For each endpoint, measure latency using `Bash`:
+
+```bash
+curl -s -o /dev/null -w "%{time_total}" https://myapp.com/health
+```
+
+Thresholds:
+- < 500ms → FAST
+- 500ms–2000ms → ACCEPTABLE
+- > 2000ms → SLOW (flag as alert)
+
+### Step 4: Performance Signal Analysis
+
+After collecting response times from Step 3, analyze for patterns that indicate root causes:
+
+- **Consistently 2x+ slower than baseline** (or > 2000ms with no apparent load): flag with `PERF_WARN — investigate N+1 query or missing DB index`
+- **Endpoint cluster degradation**: if 3+ endpoints share a pattern (all auth endpoints slow, all /api/* slow): flag `PERF_WARN — connection pool saturation likely`
+- **Spike after deploy**: compare with previous watchdog run if available — if an endpoint that was FAST is now SLOW, flag `PERF_REGRESSION — correlate with recent git diff`
+
+If no previous baseline exists, skip spike detection and note `INFO: no baseline — first run`.
+
+Output performance signals into a `perf_signals` list (separate from `alerts`).
+
+### Step 5: Error Detection
+
+Scan responses for problems:
+- 4xx/5xx HTTP codes → log endpoint + status code
+- Response time > 2s → log endpoint + measured time
+- Connection timeout (curl exits non-zero) → UNREACHABLE
+- Empty response body on non-204 endpoints → flag as WARNING
+
+Collect all flagged issues into an `alerts` list.
+
+### Step 6: Report
+
+Output the following report structure:
+
+```
+## Watchdog Report: [base_url]
+
+### Smoke Test Results
+- [endpoint] — [HTTP status] ([response_time]s) — [HEALTHY|REDIRECT|CLIENT_ERROR|SERVER_ERROR|UNREACHABLE]
+
+### Alert Rules Applied
+- Response time > 2s → alert
+- Any 4xx on non-auth endpoint → alert
+- Any 5xx → critical alert
+- Unreachable → critical alert
+
+### Alerts
+- [CRITICAL|WARNING] [endpoint] — [reason]
+
+### Performance Signals
+- [PERF_WARN|PERF_REGRESSION|INFO] [endpoint] — [diagnosis]
+
+### Summary
+- Total endpoints checked: [n]
+- Healthy: [n]
+- Alerts: [n]
+- Perf Signals: [n]
+- Overall status: ALL_HEALTHY | DEGRADED | DOWN
+```
+
+If no alerts and no perf signals: output `Overall status: ALL_HEALTHY`.
+
+## Output Format
+
+```
+## Watchdog Report: [base_url]
+### Smoke Test Results
+- / — 200 (0.231s) — HEALTHY
+- /health — 200 (0.089s) — HEALTHY
+- /api/status — 500 (1.203s) — SERVER_ERROR
+
+### Alerts
+- CRITICAL /api/status — HTTP 500
+
+### Summary
+- Total: 3 | Healthy: 2 | Alerts: 1
+- Overall status: DEGRADED
+```
+
+## Constraints
+
+1. MUST report with specific metrics — not vague "performance seems slow"
+2. MUST include baseline comparison when available
+3. MUST NOT generate false alarms — precision over recall
+4. MUST separate perf signals from error alerts — they are different severity channels
+5. MUST NOT call `perf` skill — watchdog is a detector, not a diagnoser
+
+## Sharp Edges
+
+Known failure modes for this skill. Check these before declaring done.
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| curl timeout treated as slow (not unreachable) | HIGH | Non-zero curl exit code = UNREACHABLE, not a response time measurement |
+| PERF_REGRESSION reported without baseline | MEDIUM | Only flag regression if a previous run exists — otherwise INFO: first run |
+| All endpoints flagged SLOW because test env is slow | MEDIUM | Note environment context — add `ENV: non-production detected` if URL contains dev/staging/localhost |
+| Perf signal without actionable diagnosis | LOW | Every PERF_WARN must include a hypothesis (N+1, pool saturation, etc.) |
+
+## Done When
+
+- All specified endpoints checked (HTTP status + response time measured)
+- All 4xx/5xx → `alerts` list, all SLOW → `alerts` list
+- Performance patterns analyzed → `perf_signals` list (or INFO: first run)
+- Structured Watchdog Report emitted with Alerts + Performance Signals + Summary
+- Overall status is ALL_HEALTHY, DEGRADED, or DOWN (never ambiguous)
+
+## Cost Profile
+
+~500-1500 tokens input, ~300-800 tokens output. Sonnet for configuration quality.

package/skills/worktree/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: worktree
+description: "Git worktree lifecycle management. Creates isolated workspaces for parallel development, manages branches, handles cleanup. Called by team and cook for parallel isolation."
+user-invocable: false
+metadata:
+  author: runedev
+  version: "1.1.0"
+  layer: L3
+  model: haiku
+  group: utility
+  tools: "Read, Bash, Glob, Grep"
+---
+
+# worktree
+
+## Purpose
+
+Reusable git worktree lifecycle management. Creates isolated workspaces for parallel agent development, manages branch naming, handles cleanup after merge or abort. Extracted from `team` to be usable by any skill that needs workspace isolation.
+
+## Triggers
+
+- Called by `team` (L1) for parallel stream isolation
+- Called by `cook` (L1) when user explicitly requests worktree isolation
+- `/rune worktree create <name>` — manual creation
+- `/rune worktree cleanup` — manual cleanup of stale worktrees
+
+## Calls (outbound)
+
+None — pure git operations via Bash.
+
+## Called By (inbound)
+
+- `team` (L1): Phase 2 ASSIGN — create worktrees for parallel streams
+- `cook` (L1): optional isolation for complex features
+- User: direct invocation for manual worktree management
+
+## Operations
+
+### Create Worktree
+
+```
+Input: { name: string, base_branch?: string }
+Default base: current HEAD
+
+Steps:
+1. Bash: git worktree add .claude/worktrees/<name> -b rune/<name> [base_branch]
+2. Verify: Bash: git worktree list | grep <name>
+3. Return: { path: ".claude/worktrees/<name>", branch: "rune/<name>" }
+
+Naming convention:
+  - Branch: rune/<name> (e.g., rune/stream-a, rune/auth-feature)
+  - Path: .claude/worktrees/<name>
+  - Max 3 active worktrees (enforced)
+```
+
+### List Worktrees
+
+```
+Bash: git worktree list
+→ Parse output into: [{ path, branch, commit }]
+→ Filter: only rune/* branches (skip main worktree)
+```
+
+### Cleanup Worktree
+
+```
+Input: { name: string, force?: boolean }
+
+Steps:
+1. Check if branch is merged: Bash: git branch --merged main | grep rune/<name>
+2. If merged OR force:
+   Bash: git worktree remove .claude/worktrees/<name> --force
+   Bash: git branch -d rune/<name>  (or -D if force)
+3. If NOT merged AND NOT force:
+   WARN: "Branch rune/<name> has unmerged changes. Use force=true to remove."
+```
+
+### Cleanup All Stale
+
+```
+Bash: git worktree list --porcelain
+→ For each rune/* worktree:
+  → Check if branch exists: git branch --list rune/<name>
+  → If branch deleted: git worktree prune
+  → If branch merged: cleanup (see above)
+→ Report: removed [N] stale worktrees
+```
+
+## Safety Rules
+
+```
+1. NEVER delete a worktree with uncommitted changes without user confirmation
+2. NEVER force-delete an unmerged branch without user confirmation
+3. MAX 3 active rune/* worktrees — refuse creation if limit reached
+4. ALWAYS use .claude/worktrees/ directory — not project root
+5. ALWAYS prefix branches with rune/ — easy identification and cleanup
+```
+
+## Output Format
+
+```
+## Worktree Report
+- **Action**: create | cleanup | list
+- **Worktrees**: [count active]
+
+### Active Worktrees
+| Name | Branch | Path | Status |
+|------|--------|------|--------|
+| stream-a | rune/stream-a | .claude/worktrees/stream-a | active |
+| stream-b | rune/stream-b | .claude/worktrees/stream-b | merged |
+```
+
+## Constraints
+
+1. MUST use .claude/worktrees/ directory for all worktrees
+2. MUST prefix branches with rune/ namespace
+3. MUST NOT exceed 3 active worktrees
+4. MUST check for uncommitted changes before cleanup
+5. MUST NOT force-delete unmerged branches without explicit user confirmation
+
+## Sharp Edges
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| Worktree left behind after failed merge | MEDIUM | Cleanup All Stale operation + pre-team-merge tag for recovery |
+| Branch name collision with existing branch | LOW | Check branch existence before creation, append timestamp if collision |
+| Worktree path on Windows with long path | MEDIUM | Use short names, keep under .claude/worktrees/ to minimize path length |
+| Deleting worktree with uncommitted agent work | HIGH | Safety Rule 1: always check for uncommitted changes first |
+
+## Done When
+
+- Worktree created/listed/cleaned up as requested
+- Branch naming follows rune/ convention
+- Active worktree count ≤ 3
+- No stale worktrees left behind
+- Worktree Report emitted
+
+## Cost Profile
+
+~200-500 tokens. Haiku + Bash commands. Fast and cheap.