@rune-kit/rune 2.1.1

package/skills/journal/SKILL.md

@@ -0,0 +1,190 @@
+---
+name: journal
+description: Persistent state tracking and Architecture Decision Records across sessions. Manages progress state, module health, dependency graphs, and ADRs for any workflow.
+metadata:
+  author: runedev
+  version: "0.2.0"
+  layer: L3
+  model: haiku
+  group: state
+  tools: "Read, Write, Edit, Glob, Grep"
+---
+
+# journal
+
+## Purpose
+
+Persistent state tracking and Architecture Decision Records across sessions. Journal manages the state files that allow any workflow to span multiple sessions without losing progress — rescue operations, feature development, deploy decisions, or audit findings. Separate from session-bridge which handles general context injection — journal writes durable, human-readable state that survives compaction.
+
+## Triggers
+
+- Called by any skill needing decision persistence or progress tracking
+- Auto-trigger: after surgeon completes a module, after deploy, after audit phases
+
+## Calls (outbound)
+
+None — pure L3 state management utility.
+
+## Called By (inbound)
+
+- `surgeon` (L2): update progress after each surgery session
+- `rescue` (L1): read state for rescue dashboard
+- `autopsy` (L2): save initial health assessment
+- `cook` (L1): record key architectural decisions made during feature development
+- `deploy` (L2): record deploy decision, rollback plan, and post-deploy status
+- `audit` (L2): save AUDIT-REPORT.md and record health trend entry
+- `incident` (L2): record incident timeline and postmortem
+- `skill-forge` (L2): record skill creation decisions and rationale
+
+## Files Managed
+
+```
+.rune/RESCUE-STATE.md      — Human-readable rescue progress (loaded into context)
+.rune/module-status.json   — Machine-readable module states
+.rune/dependency-graph.mmd — Mermaid diagram, color-coded by health
+.rune/adr/                 — Architecture Decision Records (one per decision)
+```
+
+## Execution
+
+### Step 1 — Load state
+
+Use `Read` to load current rescue state:
+
+```
+Read: .rune/RESCUE-STATE.md
+Read: .rune/module-status.json
+```
+
+If either file does not exist, initialize it with an empty template:
+
+- `RESCUE-STATE.md`: create with header `# Rescue State\n\n**Started**: [date]\n**Phase**: 1\n`
+- `module-status.json`: create with `{ "modules": [], "lastUpdated": "[iso-date]" }`
+
+Parse `module-status.json` to extract current module states and health scores.
+
+### Step 2 — Update progress
+
+For each module that was completed during this session:
+
+1. Locate the module entry in the parsed `module-status.json`
+2. Update its fields:
+   - `status`: set to `"complete"` (or `"in-progress"` / `"blocked"` as appropriate)
+   - `healthScore`: set to the post-surgery score (0-100)
+   - `completedAt`: set to current ISO timestamp
+3. Mark the active module pointer in `RESCUE-STATE.md` — update the `**Current Module**` line to the next pending module
+
+Use `Write` to save the updated `module-status.json`.
+
+Use `Edit` to update the relevant lines in `RESCUE-STATE.md` (current phase, current module, counts of completed vs pending).
+
+### Step 3 — Record decisions
+
+For each architectural decision or trade-off made during this session (applies to any workflow — feature development, deploy, rescue, audit):
+
+1. Generate an ADR filename: `.rune/adr/ADR-[NNN]-[slug].md` where NNN is the next sequential number
+2. Use `Write` to create the ADR file with this format:
+
+```markdown
+# ADR-[NNN]: [Decision Title]
+
+**Date**: [YYYY-MM-DD]
+**Status**: Accepted
+**Workflow**: [rescue | cook | deploy | audit | other]
+**Scope**: [affected module, feature, or system area]
+
+## Context
+[Why this decision was needed — what problem or trade-off prompted it]
+
+## Decision
+[What was decided — be specific, not "we chose X" but "we chose X over Y"]
+
+## Rationale
+[Why this approach over alternatives — cite specific constraints or evidence]
+
+## Consequences
+[Impact on files/modules/future work — include rollback path if relevant]
+
+## Rejected Alternatives
+[List what was considered but NOT chosen, and why. This prevents future sessions from re-visiting dead ends.]
+- **[Alternative A]**: Rejected because [specific reason — constraint, performance, complexity]
+- **[Alternative B]**: Rejected because [specific reason]. May reconsider if [condition changes].
+```
+
+### Step 4 — Update dependency graph
+
+If any module dependencies changed during this session (new imports, removed dependencies, refactored interfaces):
+
+Use `Read` on `.rune/dependency-graph.mmd` to load the current Mermaid diagram.
+
+Use `Edit` to update the affected node entries:
+- Change node color/style to reflect new health status (e.g., `style ModuleName fill:#00d084` for healthy, `fill:#ff6b6b` for broken)
+- Add or remove edges as dependencies changed
+
+Use `Write` to save the updated `.rune/dependency-graph.mmd`.
+
+### Step 5 — Save state
+
+Use `Write` to finalize any remaining state file changes not already saved in Steps 2-4.
+
+Confirm all four managed files are consistent:
+- `RESCUE-STATE.md` reflects current phase and module
+- `module-status.json` has updated scores and timestamps
+- ADR files exist for all decisions made
+- `dependency-graph.mmd` reflects current module relationships
+
+### Step 6 — Report
+
+Emit the journal update summary to the calling skill.
+
+## Output Format
+
+```
+## Journal Update
+- **Phase**: [current rescue phase]
+- **Module**: [current module]
+- **Health**: [before] → [after]
+- **ADRs Written**: [count]
+- **Files Updated**: [list of .rune/ files modified]
+- **Next Module**: [next in queue, or "rescue complete"]
+```
+
+## Context Recovery (new session)
+
+```
+1. Read .rune/RESCUE-STATE.md   → full rescue history
+2. Read .rune/module-status.json → module states and health scores
+3. Read git log                  → latest changes since last session
+4. Read CLAUDE.md               → project conventions
+→ Result: Zero context loss across rescue sessions
+```
+
+## Constraints
+
+1. MUST record decisions with rationale — not just "decided to use X"
+2. MUST timestamp all entries
+3. MUST NOT log sensitive data (secrets, tokens, credentials)
+4. MUST work for any workflow — never require rescue-specific fields to be present
+
+## Sharp Edges
+
+Known failure modes for this skill. Check these before declaring done.
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| ADR written from memory instead of actual session events | HIGH | Only record decisions that were explicitly made in this session — don't reconstruct |
+| RESCUE-STATE.md initialized without content when called from non-rescue workflows | MEDIUM | If caller is not rescue/surgeon, skip RESCUE-STATE.md initialization — use progress.md instead |
+| Overwriting human-written ADR content on re-run | CRITICAL | MUST check if ADR-[NNN].md exists before writing — never overwrite, increment NNN |
+| Empty ADR Rationale field ("decided to use X") | MEDIUM | Constraint 1 blocks this — re-prompt for rationale before writing |
+
+## Done When
+
+- All decisions from the session recorded as ADR files with rationale
+- Progress state updated (module status, phase, or deploy event as appropriate)
+- Dependency graph updated if module relationships changed
+- Journal Update summary emitted to calling skill
+- No existing ADR files overwritten
+
+## Cost Profile
+
+~200-500 tokens input, ~100-300 tokens output. Haiku. Pure file management.

package/skills/launch/SKILL.md

@@ -0,0 +1,330 @@
+---
+name: launch
+description: "Deploy + marketing orchestrator. Use when user says 'launch', 'ship to production', 'deploy and announce', or 'go live'. Runs the full pipeline — pre-flight tests, deployment, live verification, marketing asset creation, and announcement."
+context: fork
+agent: general-purpose
+disable-model-invocation: true
+metadata:
+  author: runedev
+  version: "0.3.0"
+  layer: L1
+  model: sonnet
+  group: orchestrator
+  tools: "Read, Write, Edit, Bash, Glob, Grep"
+---
+
+# launch
+
+## Purpose
+
+Orchestrate the full deployment and marketing pipeline. Launch coordinates testing, deployment, live site verification, marketing asset creation, and public announcement. One command to go from "code ready" to "product live and marketed."
+
+<HARD-GATE>
+- ALL tests must pass before any deploy attempt. Zero exceptions. Block deploy if any of: tests failing, TypeScript errors present, build fails, or sentinel CRITICAL issues detected.
+</HARD-GATE>
+
+## Triggers
+
+- `/rune launch` — manual invocation
+- Called by `team` when delegating launch tasks
+
+## Calls (outbound)
+
+- `test` (L2): pre-deployment full test suite
+- `audit` (L2): pre-launch health check — full 7-phase quality gate
+- `deploy` (L2): push to target platform
+- `incident` (L2): if post-launch health check fails → triage and contain
+- `browser-pilot` (L3): verify live site screenshots and performance
+- `marketing` (L2): create launch assets (landing copy, social, SEO)
+- `watchdog` (L3): setup post-deploy monitoring
+- `video-creator` (L3): create launch/demo video content
+- L4 extension packs: domain-specific launch patterns when context matches (e.g., @rune/devops for infrastructure, @rune/ecommerce for storefront)
+
+## Called By (inbound)
+
+- User: `/rune launch` direct invocation
+- `team` (L1): when team delegates launch phase
+
+---
+
+## Execution
+
+### Step 0 — Artifact Readiness Check
+
+Before starting the pipeline, verify that prerequisite artifacts exist. Scan using `Glob` — do NOT hardcode paths, use discovery patterns.
+
+```
+REQUIRED ARTIFACTS:
+  Source code:        Glob **/*.{ts,tsx,js,jsx,py,rs,go} — at least 1 match
+  Build config:       Glob {package.json,Cargo.toml,pyproject.toml,go.mod} — at least 1 match
+  Tests:              Glob **/*.{test,spec}.* OR **/test_*.* — at least 1 match
+
+RECOMMENDED ARTIFACTS (warn if missing, don't block):
+  Design system:      Glob .rune/design-system.md — if frontend project
+  Deploy config:      Glob {vercel.json,netlify.toml,Dockerfile,fly.toml,.github/workflows/*} — any 1
+  README:             Glob README.md
+  Environment:        Glob .env.example OR .env.production — warn about secrets if .env found
+
+BLOCKING CONDITIONS:
+  ❌ No source code found → STOP: "Nothing to deploy"
+  ❌ No build config found → STOP: "No project config detected — cannot determine build/deploy"
+  ❌ No tests found → WARN: "No tests detected — pre-flight will run build-only verification"
+```
+
+Report artifact status before proceeding:
+```
+## Artifact Check
+- Source: ✅ [N] files ([language])
+- Build config: ✅ [file]
+- Tests: ✅ [N] test files | ⚠️ No tests found
+- Deploy config: ✅ [platform] | ⚠️ Not found (will detect in Phase 2)
+- Design system: ✅ .rune/design-system.md | ⚠️ Not found (run /rune design first for UI projects)
+```
+
+### Step 1 — Initialize TodoWrite
+
+```
+TodoWrite([
+  { content: "PRE-FLIGHT: Run full test suite and verification", status: "pending", activeForm: "Running pre-flight checks" },
+  { content: "DEPLOY: Detect platform and push to production", status: "pending", activeForm: "Deploying to production" },
+  { content: "VERIFY LIVE: Check live URL and setup monitoring", status: "pending", activeForm: "Verifying live deployment" },
+  { content: "MARKET: Generate landing copy and social assets", status: "pending", activeForm: "Generating marketing assets" },
+  { content: "ANNOUNCE: Present all marketing assets to user", status: "pending", activeForm: "Preparing announcement" }
+])
+```
+
+---
+
+### Phase 1 — PRE-FLIGHT
+
+Mark todo[0] `in_progress`.
+
+```
+REQUIRED SUB-SKILL: rune:verification
+→ Invoke `verification` with scope: "full".
+→ verification runs: type check, lint, unit tests, integration tests, build.
+→ Capture: passed count, failed count, coverage %, build output.
+```
+
+<HARD-GATE>
+Block deploy if ANY of:
+  [ ] Tests failing (failed count > 0)
+  [ ] TypeScript errors present
+  [ ] Build fails
+  [ ] sentinel CRITICAL issues detected (invoke rune:sentinel if not already run)
+
+If any check fails:
+  → STOP immediately
+  → Report: "PRE-FLIGHT FAILED — deploy blocked"
+  → List all failures with file + line references
+  → Do NOT proceed to Phase 2
+</HARD-GATE>
+
+Mark todo[0] `completed` only when ALL checks pass.
+
+---
+
+### Phase 2 — DEPLOY
+
+Mark todo[1] `in_progress`.
+
+**2a. Detect deployment platform.**
+
+```
+Bash: ls package.json
+Read: package.json  (check "scripts" for deploy, build, start commands)
+
+Platform detection (in order):
+  1. Check package.json scripts for "vercel" → platform = Vercel
+  2. Check package.json scripts for "netlify" → platform = Netlify
+  3. Check for vercel.json or .vercel/ dir → platform = Vercel
+  4. Check for netlify.toml → platform = Netlify
+  5. Check for Dockerfile or fly.toml → platform = custom/fly.io
+  6. Fallback: ask user for deploy command before continuing
+```
+
+**2b. Execute deploy command.**
+
+```
+Vercel:
+  Bash: npx vercel --prod
+  Capture: deployment URL from stdout
+
+Netlify:
+  Bash: npx netlify deploy --prod --dir=[build_output_dir]
+  Capture: deployment URL from stdout
+
+Custom (package.json script):
+  Bash: npm run deploy
+  Capture: deployment URL or status from stdout
+
+Fly.io:
+  Bash: flyctl deploy
+  Capture: deployment URL from stdout
+```
+
+```
+Error recovery:
+  If deploy command exits non-zero:
+    → Capture full stderr
+    → Report: "DEPLOY FAILED: [error summary]"
+    → Do NOT proceed to Phase 3
+    → Present raw error to user for diagnosis
+```
+
+Mark todo[1] `completed` when deploy returns a live URL.
+
+---
+
+### Phase 3 — VERIFY LIVE
+
+Mark todo[2] `in_progress`.
+
+**3a. Verify live site.**
+
+```
+REQUIRED SUB-SKILL: rune:browser-pilot
+→ Invoke `browser-pilot` with the deployed URL.
+→ browser-pilot checks: page loads (HTTP 200), no console errors, critical UI elements visible.
+→ Capture: screenshot, status code, load time, any JS errors.
+```
+
+```
+Error recovery:
+  If browser-pilot returns non-200 or JS errors:
+    → Report: "LIVE VERIFY FAILED: [details]"
+    → Do NOT proceed to Phase 4
+    → Present screenshot + error log to user
+```
+
+**3b. Setup monitoring.**
+
+```
+REQUIRED SUB-SKILL: rune:watchdog
+→ Invoke `watchdog` with: url=[deployed URL], interval=5min, alert_on=[5xx, timeout].
+→ watchdog configures health check endpoint monitoring.
+→ Capture: monitoring confirmation + health endpoint path.
+```
+
+Mark todo[2] `completed` when live verification passes and monitoring is active.
+
+---
+
+### Phase 4 — MARKET
+
+Mark todo[3] `in_progress`.
+
+**4a. Generate marketing assets.**
+
+```
+REQUIRED SUB-SKILL: rune:marketing
+→ Invoke `marketing` with: project context, deployed URL, key features.
+→ marketing generates:
+    - Landing page hero copy (headline, subheadline, CTA)
+    - Twitter/X announcement thread (3-5 tweets)
+    - LinkedIn post
+    - Product Hunt tagline + description
+    - SEO meta tags (title, description, og:image alt)
+→ Capture: all generated copy as structured output.
+```
+
+**4b. Optional — launch video.**
+
+```
+If user requested video content:
+  REQUIRED SUB-SKILL: rune:video-creator
+  → Invoke `video-creator` with: deployed URL, feature list, target platform.
+  → Capture: video script + asset manifest.
+```
+
+Mark todo[3] `completed` when all requested assets are generated.
+
+---
+
+### Phase 5 — ANNOUNCE
+
+Mark todo[4] `in_progress`.
+
+Present all assets to user in structured format. Do not auto-publish — user approves before posting.
+
+```
+Present:
+  - Deployed URL (clickable)
+  - Monitoring status
+  - All marketing copy blocks (ready to copy-paste)
+  - Video script (if generated)
+  - Next steps checklist
+```
+
+Mark todo[4] `completed`.
+
+---
+
+## Constraints
+
+1. MUST pass ALL tests before any deploy attempt — zero exceptions
+2. MUST pass sentinel security scan before deploy — no CRITICAL findings allowed
+3. MUST have rollback plan documented before deploying to production
+4. MUST NOT deploy and run marketing simultaneously — deploy first, verify, then market
+5. MUST verify deploy is live and healthy before triggering marketing skills
+
+## Mesh Gates
+
+| Gate | Requires | If Missing |
+|------|----------|------------|
+| Test Gate | verification output showing all green | Run rune:verification first |
+| Security Gate | sentinel output with no CRITICAL findings | Run rune:sentinel first |
+| Deploy Gate | Successful deploy confirmation before marketing | Deploy first |
+
+## Output Format
+
+```
+## Launch Report
+- **Status**: live | failed | partial
+- **URL**: [deployed URL]
+- **Tests**: [passed]/[total]
+
+### Deployment
+- Platform: [Vercel | Netlify | custom]
+- Build: [success | failed]
+- URL: [live URL]
+
+### Monitoring
+- Health endpoint: [path]
+- Check interval: 5min
+- Watchdog: active | failed
+
+### Marketing Assets
+- Hero copy: [ready | skipped]
+- Twitter thread: [ready | skipped]
+- LinkedIn post: [ready | skipped]
+- Product Hunt: [ready | skipped]
+- SEO meta: [ready | skipped]
+- Launch video: [ready | skipped]
+```
+
+## Sharp Edges
+
+Known failure modes for this skill. Check these before declaring done.
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| Attempting deploy with failing tests or TypeScript errors | CRITICAL | HARD-GATE blocks this — pre-flight must be 100% green |
+| Running marketing before deploy verified live | HIGH | Constraint 4: deploy → verify HTTP 200 → THEN market. Never simultaneous |
+| No rollback plan before production deploy | MEDIUM | Constraint 3: document rollback strategy before running deploy command |
+| Platform auto-detected incorrectly (wrong deploy command) | MEDIUM | Verify platform config files before running — ask if ambiguous |
+| Marketing assets generated from assumptions rather than scout output | MEDIUM | Step 1 requires scout to run — copy based on actual features, not assumptions |
+
+## Done When
+
+- Pre-flight PASS: all tests, types, lint, build, and sentinel green
+- Deploy command succeeded with live URL captured
+- Live site returns HTTP 200 (curl or browser-pilot confirmed)
+- watchdog monitoring active on deployed URL
+- All requested marketing assets generated (or skipped with reason)
+- User presented with all assets before any publishing
+- Launch Report emitted with URL, monitoring status, and asset list
+
+## Cost Profile
+
+~$0.08-0.15 per launch. Sonnet for coordination, delegates to haiku for scanning.