devstack 0.1.0

package/vendor/skills/skills/fix-coderabbit-review/scripts/resolve_pr_issues.sh

@@ -0,0 +1,228 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# resolve_pr_issues.sh — Mark exported PR review issues as resolved.
+#
+# Given a PR export directory (ai-docs/reviews-pr-XXX) and an inclusive range
+# of issue numbers, this script:
+#   1. Updates each issue markdown file to mark the status as resolved.
+#   2. Resolves the corresponding GitHub review threads via `gh`.
+#   3. Updates the `_summary.md` checklist to reflect the resolved issues and
+#      refreshes the resolved/unresolved counters.
+#
+# Usage:
+#   scripts/resolve_pr_issues.sh \
+#     --pr-dir ai-docs/reviews-pr-277 \
+#     --from 11 \
+#     --to 22 \
+#     [--dry-run]
+#
+# Requirements:
+#   - GitHub CLI (`gh`) authenticated with repo scope (unless --dry-run)
+#   - Python 3 (for safe in-place edits)
+
+pr_dir=""
+from_issue=""
+to_issue=""
+dry_run=false
+
+die() {
+  echo "Error: $*" >&2
+  exit 1
+}
+
+need_cmd() { command -v "$1" > /dev/null 2>&1 || die "Missing required command: $1"; }
+
+usage() {
+  sed -n '1,60p' "$0" | sed 's/^# \{0,1\}//'
+  exit 0
+}
+
+parse_args() {
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --pr-dir)
+        [[ $# -ge 2 && ${2:0:2} != -- ]] || die "--pr-dir requires a value"
+        pr_dir=$2
+        shift 2
+        ;;
+      --from)
+        [[ $# -ge 2 && ${2:0:2} != -- ]] || die "--from requires a value"
+        from_issue=$2
+        shift 2
+        ;;
+      --to)
+        [[ $# -ge 2 && ${2:0:2} != -- ]] || die "--to requires a value"
+        to_issue=$2
+        shift 2
+        ;;
+      --dry-run)
+        dry_run=true
+        shift
+        ;;
+      -h | --help) usage ;;
+      *) die "Unknown arg: $1" ;;
+    esac
+  done
+}
+
+validate_args() {
+  [[ -n "$pr_dir" ]] || die "Provide --pr-dir"
+  [[ -n "$from_issue" ]] || die "Provide --from"
+  [[ -n "$to_issue" ]] || die "Provide --to"
+  [[ "$from_issue" =~ ^[0-9]+$ ]] || die "--from must be a number"
+  [[ "$to_issue" =~ ^[0-9]+$ ]] || die "--to must be a number"
+  if ((10#$from_issue > 10#$to_issue)); then
+    die "--from cannot be greater than --to"
+  fi
+  [[ -d "$pr_dir" ]] || die "PR directory not found: $pr_dir"
+  [[ -f "$pr_dir/_summary.md" ]] || die "Summary file not found in $pr_dir"
+  [[ -d "$pr_dir/issues" ]] || die "Issues directory not found in $pr_dir"
+  need_cmd python3
+  if ! $dry_run; then
+    need_cmd gh
+  fi
+}
+
+find_issue_file() {
+  local issues_dir="$1"
+  local padded="$2"
+  local legacy="${issues_dir}/issue_${padded}.md"
+  if [[ -f "$legacy" ]]; then
+    echo "$legacy"
+    return 0
+  fi
+
+  local glob=()
+  local oldopt=$(shopt -p nullglob || true)
+  shopt -s nullglob
+  glob=("${issues_dir}/${padded}-"*.md)
+  eval "$oldopt"
+  if ((${#glob[@]} == 1)); then
+    echo "${glob[0]}"
+    return 0
+  fi
+
+  if ((${#glob[@]} > 1)); then
+    printf 'Warning: multiple grouped files match index %s. Using first match: %s\n' "$padded" "${glob[0]}" >&2
+    echo "${glob[0]}"
+    return 0
+  fi
+
+  return 1
+}
+
+zero_pad() {
+  printf "%03d" "$1"
+}
+
+extract_thread_ids() {
+  local file="$1"
+  grep -Eo 'Thread ID: `[^`]+`' "$file" | sed -E 's/.*`([^`]+)`.*/\1/' || true
+  grep -Eo "threadId='[^']+'" "$file" | sed -E "s/.*'([^']+)'.*/\1/" || true
+}
+
+mark_issue_resolved() {
+  local file="$1"
+  python3 - "$file" << 'PY'
+import re, sys
+path = sys.argv[1]
+text = open(path, encoding="utf-8").read()
+replacement = r"\1[x] RESOLVED"
+new_text, count = re.subn(r"(\*\*Status:\*\*\s*-\s*)\[[xX ]\]\s*(?:UNRESOLVED|RESOLVED(?:\s*✓)?)", replacement, text, count=1)
+if count:
+    with open(path, "w", encoding="utf-8") as fh:
+        fh.write(new_text)
+PY
+}
+
+update_summary_checkbox() {
+  local summary="$1"
+  local issue="$2"
+  local padded="$3"
+  python3 - "$summary" "$issue" "$padded" << 'PY'
+import re, sys
+summary, issue_num, padded = sys.argv[1:4]
+text = open(summary, encoding="utf-8").read()
+pattern = rf"(- \[)[ xX](\] \[Issue {int(issue_num)}\]\(issues/(?:issue_{padded}|{padded}-[^)]+)\.md\))"
+new_text = re.sub(pattern, r"\1x\2", text, count=1)
+if new_text != text:
+    with open(summary, "w", encoding="utf-8") as fh:
+        fh.write(new_text)
+PY
+}
+
+refresh_summary_counts() {
+  local summary="$1"
+  python3 - "$summary" << 'PY'
+import re, sys
+summary_path = sys.argv[1]
+text = open(summary_path, encoding="utf-8").read()
+pattern_resolved = r"- \[[xX]\] \[Issue \d+\]\(issues/(?:issue_\d+|\d+-[^)]+)\.md\)"
+pattern_unresolved = r"- \[ \] \[Issue \d+\]\(issues/(?:issue_\d+|\d+-[^)]+)\.md\)"
+resolved = len(re.findall(pattern_resolved, text))
+unresolved = len(re.findall(pattern_unresolved, text))
+text = re.sub(r"(\*\*Resolved issues:\*\*\s*)(\d+)", lambda m: m.group(1) + str(resolved), text)
+text = re.sub(r"(\*\*Unresolved issues:\*\*\s*)(\d+)", lambda m: m.group(1) + str(unresolved), text)
+with open(summary_path, "w", encoding="utf-8") as fh:
+    fh.write(text)
+PY
+}
+
+resolve_threads() {
+  local issue_file="$1"
+  local ids=()
+  while IFS= read -r id; do
+    [[ -n "$id" ]] && ids+=("$id")
+  done < <(extract_thread_ids "$issue_file" | sort -u)
+
+  if [[ ${#ids[@]} -eq 0 ]]; then
+    echo "   ⚠️  No thread IDs found in $(basename "$issue_file")"
+    return
+  fi
+
+  for id in "${ids[@]}"; do
+    echo "   📡 Resolving thread $id"
+    if $dry_run; then
+      echo "     (dry-run) skipping gh api call"
+    else
+      if ! gh api graphql \
+        -f query='mutation($threadId: ID!) { resolveReviewThread(input: { threadId: $threadId }) { thread { isResolved } } }' \
+        -F threadId="$id" 2>&1; then
+        echo "     ⚠️  Failed to resolve thread $id (may already be resolved or deleted)"
+      fi
+    fi
+  done
+}
+
+main() {
+  parse_args "$@"
+  validate_args
+
+  local summary_file="$pr_dir/_summary.md"
+  local issues_dir="$pr_dir/issues"
+
+  echo "📁 PR dir: $pr_dir"
+  echo "🔢 Range: ${from_issue}-${to_issue}"
+  echo "🧪 Dry run: $dry_run"
+
+  for ((num = 10#$from_issue; num <= 10#$to_issue; num++)); do
+    local padded
+    padded=$(zero_pad "$num")
+    local issue_file
+    if ! issue_file=$(find_issue_file "$issues_dir" "$padded"); then
+      echo "❌ Missing issue file for index ${padded}"
+      continue
+    fi
+
+    echo "➡️  Processing $(basename "$issue_file")"
+    mark_issue_resolved "$issue_file"
+    update_summary_checkbox "$summary_file" "$num" "$padded"
+    resolve_threads "$issue_file"
+  done
+
+  refresh_summary_counts "$summary_file"
+  echo "✅ Completed."
+}
+
+main "$@"

package/vendor/skills/skills/fixing-motion-performance/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: fixing-motion-performance
+description: Fix animation performance issues.
+---
+
+# fixing-motion-performance
+
+Fix animation performance issues.
+
+## how to use
+
+- `/fixing-motion-performance`
+  Apply these constraints to any UI animation work in this conversation.
+
+- `/fixing-motion-performance <file>`
+  Review the file against all rules below and report:
+  - violations (quote the exact line or snippet)
+  - why it matters (one short sentence)
+  - a concrete fix (code-level suggestion)
+
+Do not migrate animation libraries unless explicitly requested. Apply rules within the existing stack.
+
+## when to apply
+
+Reference these guidelines when:
+
+- adding or changing UI animations (CSS, WAAPI, Motion, rAF, GSAP)
+- refactoring janky interactions or transitions
+- implementing scroll-linked motion or reveal-on-scroll
+- animating layout, filters, masks, gradients, or CSS variables
+- reviewing components that use will-change, transforms, or measurement
+
+## rendering steps glossary
+
+- composite: transform, opacity
+- paint: color, borders, gradients, masks, images, filters
+- layout: size, position, flow, grid, flex
+
+## rule categories by priority
+
+| priority | category             | impact      |
+| -------- | -------------------- | ----------- |
+| 1        | never patterns       | critical    |
+| 2        | choose the mechanism | critical    |
+| 3        | measurement          | high        |
+| 4        | scroll               | high        |
+| 5        | paint                | medium-high |
+| 6        | layers               | medium      |
+| 7        | blur and filters     | medium      |
+| 8        | view transitions     | low         |
+| 9        | tool boundaries      | critical    |
+
+## quick reference
+
+### 1. never patterns (critical)
+
+- do not interleave layout reads and writes in the same frame
+- do not animate layout continuously on large or meaningful surfaces
+- do not drive animation from scrollTop, scrollY, or scroll events
+- no requestAnimationFrame loops without a stop condition
+- do not mix multiple animation systems that each measure or mutate layout
+
+### 2. choose the mechanism (critical)
+
+- default to transform and opacity for motion
+- use JS-driven animation only when interaction requires it
+- paint or layout animation is acceptable only on small, isolated surfaces
+- one-shot effects are acceptable more often than continuous motion
+- prefer downgrading technique over removing motion entirely
+
+### 3. measurement (high)
+
+- measure once, then animate via transform or opacity
+- batch all DOM reads before writes
+- do not read layout repeatedly during an animation
+- prefer FLIP-style transitions for layout-like effects
+- prefer approaches that batch measurement and writes
+
+### 4. scroll (high)
+
+- prefer Scroll or View Timelines for scroll-linked motion when available
+- use IntersectionObserver for visibility and pausing
+- do not poll scroll position for animation
+- pause or stop animations when off-screen
+- scroll-linked motion must not trigger continuous layout or paint on large surfaces
+
+### 5. paint (medium-high)
+
+- paint-triggering animation is allowed only on small, isolated elements
+- do not animate paint-heavy properties on large containers
+- do not animate CSS variables for transform, opacity, or position
+- do not animate inherited CSS variables
+- scope animated CSS variables locally and avoid inheritance
+
+### 6. layers (medium)
+
+- compositor motion requires layer promotion, never assume it
+- use will-change temporarily and surgically
+- avoid many or large promoted layers
+- validate layer behavior with tooling when performance matters
+
+### 7. blur and filters (medium)
+
+- keep blur animation small (<=8px)
+- use blur only for short, one-time effects
+- never animate blur continuously
+- never animate blur on large surfaces
+- prefer opacity and translate before blur
+
+### 8. view transitions (low)
+
+- use view transitions only for navigation-level changes
+- avoid view transitions for interaction-heavy UI
+- avoid view transitions when interruption or cancellation is required
+- treat size changes as potentially layout-triggering
+
+### 9. tool boundaries (critical)
+
+- do not migrate or rewrite animation libraries unless explicitly requested
+- apply these rules within the existing animation system
+- never partially migrate APIs or mix styles within the same component
+
+## review guidance
+
+- enforce critical rules first (never patterns, tool boundaries)
+- choose the least expensive rendering work that matches the intent
+- for any non-default choice, state the constraint that justifies it (surface size, duration, or interaction requirement)
+- when reviewing, prefer actionable notes and concrete alternatives over theory

package/vendor/skills/skills/frontend-design/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: frontend-design
+description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
+license: Complete terms in LICENSE.txt
+---
+
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

package/vendor/skills/skills/fundraising/README.md

@@ -0,0 +1,14 @@
+# Fundraising (Skill Pack)
+
+Use this skill to decide whether to raise venture capital and run an early-stage raise as an executable process: narrative, deck outline, investor pipeline, outreach scripts, and diligence prep.
+
+## How to invoke
+
+Example prompts:
+
+- “Use `fundraising` to create a Fundraising Pack. Here’s our company, traction, runway, and what we’re trying to raise.”
+- “Use `fundraising` to help me decide whether to raise or bootstrap, then produce a deck outline and investor outreach plan.”
+
+## What you get
+
+The skill outputs a **Fundraising Pack** (in chat as Markdown; or as files if requested). Templates, checklists, and expanded guidance live in `references/`.

package/vendor/skills/skills/fundraising/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: "fundraising"
+description: "Plan and run an early-stage fundraising process and produce a Fundraising Pack (raise decision memo, round design brief, pitch narrative + deck outline, investor pipeline + tracker, outreach/follow-up scripts, diligence checklist). Use for fundraising, raising capital, venture capital, pitch deck, investor outreach, pre-seed, seed. Category: Career."
+---
+
+# Fundraising
+
+## Scope
+
+**Covers**
+
+- Deciding **whether** to raise venture funding (vs bootstrapping / delaying / alternatives) and articulating the trade-offs
+- Designing a round (amount, timeline, milestone, target investor profile) without pretending to give legal/tax advice
+- Building an investor-ready **narrative** and a **pitch deck outline** optimized for first impressions
+- Running the fundraising process as a pipeline (target list, outreach, follow-ups, rejection handling, momentum)
+- Preparing for diligence (data-room checklist + FAQs/objections) and reducing “unknown unknowns”
+
+**When to use**
+
+- “Should I raise venture capital or bootstrap?”
+- “Help me build a pitch deck narrative and a strong first slide.”
+- “I need an investor outreach plan and a pipeline tracker.”
+- “I’m starting a pre-seed/seed raise; help me run the process end-to-end.”
+
+**When NOT to use**
+
+- You need legal, tax, or securities advice (term sheets, SAFE/notes, incorporation, compliance) — involve qualified professionals.
+- You’re raising grants/donations or structured debt (use a fundraising/grants/debt-specific workflow instead).
+- You only want visual slide design polish with no strategy/process work.
+- You’re in an immediate liquidity crisis where the only viable path is emergency financing within days (this skill can help structure messaging, but you should prioritize urgent financial triage with experts).
+
+## Inputs
+
+**Minimum required**
+
+- Company snapshot: what you build, who it’s for, and why now
+- Stage + traction (or pre-traction proof), plus 1–3 key metrics (even proxies)
+- Team snapshot (founders, key strengths, gaps you’re hiring for)
+- Runway + constraints (cash, time, geography, intro network, fundraising window)
+- Fundraising intent: why raise, target amount (or range), and what milestone it buys
+
+**Missing-info strategy**
+
+- Ask **3–5 questions at a time** from [references/INTAKE.md](references/INTAKE.md).
+- If specifics are missing, proceed with labeled assumptions and ranges (never invent exact numbers).
+- Do not request sensitive credentials or confidential customer/employee data; use anonymized examples.
+
+## Outputs (deliverables)
+
+Produce a **Fundraising Pack** (Markdown in chat; or as files if requested) in this order:
+
+1. **Raise Decision Memo** (VC vs bootstrap/delay; trade-offs; “if we raise” vs “if we don’t” plan)
+2. **Round Design Brief** (amount, timing, milestone, use of funds, target investor profile)
+3. **Pitch Narrative + Deck Outline** (including a high-signal first slide + talk track)
+4. **Investor ICP + Target List + Pipeline Tracker** (with weekly activity targets)
+5. **Outreach + Follow-up Scripts** (warm intro ask, cold email, post-meeting follow-up)
+6. **Diligence Prep** (data-room checklist + FAQ/objection responses)
+7. **Operating Cadence** (weekly dashboard, “100 no’s” resilience plan, next-14-days action plan)
+8. **Risks / Open questions / Next steps** (always)
+
+Templates: [references/TEMPLATES.md](references/TEMPLATES.md)  
+Expanded guidance: [references/WORKFLOW.md](references/WORKFLOW.md)
+
+## Workflow (8 steps)
+
+### 1) Intake + constraints snapshot
+
+- **Inputs:** user context; [references/INTAKE.md](references/INTAKE.md).
+- **Actions:** Capture stage, runway, constraints, timing, and goal. Separate “must be true” vs “nice to have”. Identify what would make fundraising a mistake.
+- **Outputs:** Context snapshot + assumptions/unknowns list.
+- **Checks:** Timeline has dates; runway is stated (or explicitly unknown); constraints are explicit.
+
+### 2) Decide whether to raise (and why)
+
+- **Inputs:** goals, constraints, risk tolerance, business model.
+- **Actions:** Write a Raise Decision Memo: why raise, why not, and the “venture treadmill” trade-off (growth expectations, dilution, speed). Propose alternatives (delay, revenue-first, angels, strategic, debt) where appropriate.
+- **Outputs:** **Raise Decision Memo** with a clear recommendation + decision criteria.
+- **Checks:** Recommendation is falsifiable (“we raise if X by date Y”); non-VC path is not hand-waved.
+
+### 3) Design the round (make the plan fundable)
+
+- **Inputs:** runway, burn (or plan), milestone, hiring needs, market timing.
+- **Actions:** Define raise amount range, timing, and the milestone it buys. Specify investor profile (stage, check size, thesis, geography) and a simple “use of funds” narrative.
+- **Outputs:** **Round Design Brief**.
+- **Checks:** Amount ↔ milestone is coherent; plan fits constraints; assumptions are explicit.
+
+### 4) Build the pitch narrative + first impression assets
+
+- **Inputs:** product, ICP, wedge, traction/proof, insights from Steps 1–3.
+- **Actions:** Draft a crisp one-liner, the “strongest point” for slide 1, and a deck outline that answers: problem, solution, why now, why you, why win, why invest.
+- **Outputs:** **Pitch Narrative + Deck Outline** (+ talk track).
+- **Checks:** First slide passes the 10-second test (what it is, for whom, why it matters); narrative has evidence, not vibes.
+
+### 5) Build the investor pipeline (target list + math)
+
+- **Inputs:** target investor profile; network; constraints.
+- **Actions:** Create an ICP and a prioritized target list. Set pipeline math (how many intros/meetings/week) and define a tracking table.
+- **Outputs:** **Investor ICP + Target List + Pipeline Tracker**.
+- **Checks:** Targets match round design; outreach plan is schedulable; next 7 days have concrete outreach tasks.
+
+### 6) Execute outreach + meetings (run the “100 no’s” process)
+
+- **Inputs:** scripts; target list; calendar.
+- **Actions:** Draft outreach messages, run outreach cadence, and standardize meeting flow + follow-ups. Track “nos” as data (rejection reasons) and iterate the pitch.
+- **Outputs:** **Outreach + Follow-up Scripts** + meeting agenda + iteration log.
+- **Checks:** Every meeting has a next step; follow-ups go out within 24 hours; learnings are captured weekly.
+
+### 7) Prep diligence (reduce friction)
+
+- **Inputs:** likely diligence asks; current docs.
+- **Actions:** Create a lightweight data-room checklist and an FAQ/objection response sheet. Identify the 3–5 biggest diligence gaps and a plan to close them.
+- **Outputs:** **Diligence Prep** checklist + FAQ.
+- **Checks:** No claims without supporting artifacts; sensitive info is handled carefully.
+
+### 8) Quality gate + finalize the pack
+
+- **Inputs:** full draft pack.
+- **Actions:** Run [references/CHECKLISTS.md](references/CHECKLISTS.md) and score with [references/RUBRIC.md](references/RUBRIC.md). Tighten weak sections. Add **Risks / Open questions / Next steps** and a next-14-days action plan.
+- **Outputs:** Final **Fundraising Pack**.
+- **Checks:** Pack is decision-ready, narrative-coherent, and process-executable.
+
+## Quality gate (required)
+
+- Use [references/CHECKLISTS.md](references/CHECKLISTS.md) and [references/RUBRIC.md](references/RUBRIC.md).
+- Always include: **Risks**, **Open questions**, **Next steps**.
+
+## Examples
+
+**Example 1 (pre-seed):** “We’re 2 founders building a B2B workflow tool. We have 5 design partners and 2 pilots. We have 6 months runway and want to raise $1.5–2.0M. Use `fundraising` to produce the full Fundraising Pack including a deck outline and investor pipeline tracker.”  
+Expected: decision memo + round design + deck outline (strong first slide) + target list + outreach scripts.
+
+**Example 2 (seed with traction):** “We’re at $60k MRR and growing 10% MoM. We’re debating whether to raise now or wait 6 months. Use `fundraising` to help us decide and create an outreach plan if we choose to raise.”  
+Expected: raise-vs-wait decision memo with criteria + round design options + pipeline plan.
+
+**Boundary example:** “Draft a SAFE agreement and tell me what valuation I should take.”  
+Response: out of scope for legal/pricing advice; offer to produce the negotiation inputs (round design assumptions, comps proxy approach, questions for counsel) and a fundraising process plan.

package/vendor/skills/skills/fundraising/references/CHECKLISTS.md

@@ -0,0 +1,49 @@
+# Fundraising — Quality Checklists
+
+Use this before finalizing any Fundraising Pack.
+
+## 1) Raise Decision Memo checklist
+
+- [ ] Clearly states the decision and deadline
+- [ ] Explicitly names the “venture treadmill” trade-offs (expectations, dilution, pace)
+- [ ] Includes a credible non-VC alternative path (bootstrap/delay/other) instead of hand-waving
+- [ ] Recommendation includes a falsifiable criterion (“we raise if X by date Y”)
+- [ ] Risks, open questions, and next steps are present
+
+## 2) Round Design Brief checklist
+
+- [ ] Raise amount is a range (unless user provided an exact number)
+- [ ] Amount is tied to a specific 12–18 month milestone
+- [ ] Use of funds is coherent (headcount + key bets + buffer)
+- [ ] Target investor profile matches the round (stage/check size/thesis/geo)
+- [ ] Flags legal/tax items as “questions for counsel” (no pretending to advise)
+
+## 3) Pitch narrative + deck outline checklist
+
+- [ ] One-liner is specific (ICP + outcome)
+- [ ] Slide 1 communicates strongest point in ~10 seconds
+- [ ] Deck answers: problem, why now, solution, proof, GTM, differentiation, team, ask
+- [ ] Claims are supported by evidence (metrics/proxies/customer quotes)
+- [ ] Talk track exists for a 2–3 minute opener
+
+## 4) Investor pipeline + outreach system checklist
+
+- [ ] Investor ICP includes both fit filters and “avoid” filters
+- [ ] Target list includes a warm path (even if “unknown” for now)
+- [ ] Pipeline stages are defined and trackable
+- [ ] Weekly activity targets exist and match time budget
+- [ ] Outreach scripts are ready-to-send and not overly long
+- [ ] Follow-up SOP (within 24 hours) is explicit
+
+## 5) Diligence readiness checklist
+
+- [ ] Data room index is realistic for stage (not overbuilt)
+- [ ] FAQ/objection table covers top 3–5 expected objections
+- [ ] Sensitive info handling is explicit (what not to share yet; redactions)
+
+## 6) Final pack checklist
+
+- [ ] Outputs appear in the required order from `../SKILL.md`
+- [ ] Assumptions are labeled; unknowns are called out
+- [ ] Includes: Risks / Open questions / Next steps
+- [ ] Next 14 days have concrete actions scheduled

package/vendor/skills/skills/fundraising/references/EXAMPLES.md

@@ -0,0 +1,10 @@
+# Examples
+
+**Example 1 (pre-seed):** “We’re 2 founders building a B2B workflow tool. We have 5 design partners and 2 pilots. We have 6 months runway and want to raise $1.5–2.0M. Use `fundraising` to produce the full Fundraising Pack including a deck outline and investor pipeline tracker.”  
+Expected: decision memo + round design + deck outline (strong first slide) + target list + outreach scripts.
+
+**Example 2 (seed with traction):** “We’re at $60k MRR and growing 10% MoM. We’re debating whether to raise now or wait 6 months. Use `fundraising` to help us decide and create an outreach plan if we choose to raise.”  
+Expected: raise-vs-wait decision memo with criteria + round design options + pipeline plan.
+
+**Boundary example:** “Draft a SAFE agreement and tell me what valuation I should take.”  
+Response: out of scope for legal/pricing advice; offer to produce the negotiation inputs (round design assumptions, comps proxy approach, questions for counsel) and a fundraising process plan.

package/vendor/skills/skills/fundraising/references/INTAKE.md

@@ -0,0 +1,38 @@
+# Fundraising — Intake (Question Bank)
+
+Ask **3–5 questions at a time**. If the user can’t answer, accept ranges and label assumptions.
+
+## Fast intake (answer in 5–10 minutes)
+
+1. What are you building, for whom, and what is the painful problem you solve?
+2. What stage are you at (idea / pre-seed / seed / A / other) and what proof do you have today?
+3. What traction metrics can you share (even proxies): revenue, growth, retention, pipeline, usage, LOIs, pilots, waitlist?
+4. Who is the team (founders + key roles), and what is your “earned secret”/advantage?
+5. What is your runway (months), and what constraints do you have (time, geography, intros, risk tolerance)?
+
+## Fundraising intent + decision context
+
+6. Why are you considering raising now? What happens if you don’t raise?
+7. What does success look like 12–18 months from now (milestone you want the round to buy)?
+8. What are the main trade-offs you’re worried about (dilution, control, speed, expectations, focus)?
+9. What alternative paths are plausible (revenue-first, delay, angels, strategic, debt, grants)?
+
+## Round design (if raising)
+
+10. Target amount (range) and target close date (or window)?
+11. Preferred instrument (SAFE/note/equity) if known (if not, we’ll treat this as a question for counsel).
+12. Current burn + planned burn (or hiring plan) and what the money is for.
+13. Target investor type: angels, micro-VCs, seed funds, strategic, geo constraints.
+14. Who can credibly intro you (names optional; roles/community is enough)?
+
+## Pitch + process readiness
+
+15. What is the single strongest “hook” or insight that makes your company inevitable (why now)?
+16. What are the top 3 objections you expect (market size, differentiation, GTM, team, churn, regulation)?
+17. What assets exist today (deck, doc, metrics, demo, customer quotes, data room)?
+18. What is your weekly time budget for fundraising, and who owns the process?
+
+## Optional (helps a lot)
+
+19. What comparable companies or categories do investors reference when you explain the business?
+20. What has happened in past fundraising attempts (if any): what worked, what didn’t, what feedback was consistent?