opencode-starterkit 1.0.1

package/baseline/skill/vercel-deploy-claimable/scripts/deploy.sh

@@ -0,0 +1,249 @@
+#!/bin/bash
+
+# Vercel Deployment Script (via claimable deploy endpoint)
+# Usage: ./deploy.sh [project-path]
+# Returns: JSON with previewUrl, claimUrl, deploymentId, projectId
+
+set -e
+
+DEPLOY_ENDPOINT="https://claude-skills-deploy.vercel.com/api/deploy"
+
+# Detect framework from package.json
+detect_framework() {
+    local pkg_json="$1"
+
+    if [ ! -f "$pkg_json" ]; then
+        echo "null"
+        return
+    fi
+
+    local content=$(cat "$pkg_json")
+
+    # Helper to check if a package exists in dependencies or devDependencies
+    has_dep() {
+        echo "$content" | grep -q "\"$1\""
+    }
+
+    # Order matters - check more specific frameworks first
+
+    # Blitz
+    if has_dep "blitz"; then echo "blitzjs"; return; fi
+
+    # Next.js
+    if has_dep "next"; then echo "nextjs"; return; fi
+
+    # Gatsby
+    if has_dep "gatsby"; then echo "gatsby"; return; fi
+
+    # Remix
+    if has_dep "@remix-run/"; then echo "remix"; return; fi
+
+    # React Router (v7 framework mode)
+    if has_dep "@react-router/"; then echo "react-router"; return; fi
+
+    # TanStack Start
+    if has_dep "@tanstack/start"; then echo "tanstack-start"; return; fi
+
+    # Astro
+    if has_dep "astro"; then echo "astro"; return; fi
+
+    # Hydrogen (Shopify)
+    if has_dep "@shopify/hydrogen"; then echo "hydrogen"; return; fi
+
+    # SvelteKit
+    if has_dep "@sveltejs/kit"; then echo "sveltekit-1"; return; fi
+
+    # Svelte (standalone)
+    if has_dep "svelte"; then echo "svelte"; return; fi
+
+    # Nuxt
+    if has_dep "nuxt"; then echo "nuxtjs"; return; fi
+
+    # Vue with Vitepress
+    if has_dep "vitepress"; then echo "vitepress"; return; fi
+
+    # Vue with Vuepress
+    if has_dep "vuepress"; then echo "vuepress"; return; fi
+
+    # Gridsome
+    if has_dep "gridsome"; then echo "gridsome"; return; fi
+
+    # SolidStart
+    if has_dep "@solidjs/start"; then echo "solidstart-1"; return; fi
+
+    # Docusaurus
+    if has_dep "@docusaurus/core"; then echo "docusaurus-2"; return; fi
+
+    # RedwoodJS
+    if has_dep "@redwoodjs/"; then echo "redwoodjs"; return; fi
+
+    # Hexo
+    if has_dep "hexo"; then echo "hexo"; return; fi
+
+    # Eleventy
+    if has_dep "@11ty/eleventy"; then echo "eleventy"; return; fi
+
+    # Angular / Ionic Angular
+    if has_dep "@ionic/angular"; then echo "ionic-angular"; return; fi
+    if has_dep "@angular/core"; then echo "angular"; return; fi
+
+    # Ionic React
+    if has_dep "@ionic/react"; then echo "ionic-react"; return; fi
+
+    # Create React App
+    if has_dep "react-scripts"; then echo "create-react-app"; return; fi
+
+    # Ember
+    if has_dep "ember-cli" || has_dep "ember-source"; then echo "ember"; return; fi
+
+    # Dojo
+    if has_dep "@dojo/framework"; then echo "dojo"; return; fi
+
+    # Polymer
+    if has_dep "@polymer/"; then echo "polymer"; return; fi
+
+    # Preact
+    if has_dep "preact"; then echo "preact"; return; fi
+
+    # Stencil
+    if has_dep "@stencil/core"; then echo "stencil"; return; fi
+
+    # UmiJS
+    if has_dep "umi"; then echo "umijs"; return; fi
+
+    # Sapper (legacy Svelte)
+    if has_dep "sapper"; then echo "sapper"; return; fi
+
+    # Saber
+    if has_dep "saber"; then echo "saber"; return; fi
+
+    # Sanity
+    if has_dep "sanity"; then echo "sanity-v3"; return; fi
+    if has_dep "@sanity/"; then echo "sanity"; return; fi
+
+    # Storybook
+    if has_dep "@storybook/"; then echo "storybook"; return; fi
+
+    # NestJS
+    if has_dep "@nestjs/core"; then echo "nestjs"; return; fi
+
+    # Elysia
+    if has_dep "elysia"; then echo "elysia"; return; fi
+
+    # Hono
+    if has_dep "hono"; then echo "hono"; return; fi
+
+    # Fastify
+    if has_dep "fastify"; then echo "fastify"; return; fi
+
+    # h3
+    if has_dep "h3"; then echo "h3"; return; fi
+
+    # Nitro
+    if has_dep "nitropack"; then echo "nitro"; return; fi
+
+    # Express
+    if has_dep "express"; then echo "express"; return; fi
+
+    # Vite (generic - check last among JS frameworks)
+    if has_dep "vite"; then echo "vite"; return; fi
+
+    # Parcel
+    if has_dep "parcel"; then echo "parcel"; return; fi
+
+    # No framework detected
+    echo "null"
+}
+
+# Parse arguments
+INPUT_PATH="${1:-.}"
+
+# Create temp directory for packaging
+TEMP_DIR=$(mktemp -d)
+TARBALL="$TEMP_DIR/project.tgz"
+CLEANUP_TEMP=true
+
+cleanup() {
+    if [ "$CLEANUP_TEMP" = true ]; then
+        rm -rf "$TEMP_DIR"
+    fi
+}
+trap cleanup EXIT
+
+echo "Preparing deployment..." >&2
+
+# Check if input is a .tgz file or a directory
+FRAMEWORK="null"
+
+if [ -f "$INPUT_PATH" ] && [[ "$INPUT_PATH" == *.tgz ]]; then
+    # Input is already a tarball, use it directly
+    echo "Using provided tarball..." >&2
+    TARBALL="$INPUT_PATH"
+    CLEANUP_TEMP=false
+    # Can't detect framework from tarball, leave as null
+elif [ -d "$INPUT_PATH" ]; then
+    # Input is a directory, need to tar it
+    PROJECT_PATH=$(cd "$INPUT_PATH" && pwd)
+
+    # Detect framework from package.json
+    FRAMEWORK=$(detect_framework "$PROJECT_PATH/package.json")
+
+    # Check if this is a static HTML project (no package.json)
+    if [ ! -f "$PROJECT_PATH/package.json" ]; then
+        # Find HTML files in root
+        HTML_FILES=$(find "$PROJECT_PATH" -maxdepth 1 -name "*.html" -type f)
+        HTML_COUNT=$(echo "$HTML_FILES" | grep -c . || echo 0)
+
+        # If there's exactly one HTML file and it's not index.html, rename it
+        if [ "$HTML_COUNT" -eq 1 ]; then
+            HTML_FILE=$(echo "$HTML_FILES" | head -1)
+            BASENAME=$(basename "$HTML_FILE")
+            if [ "$BASENAME" != "index.html" ]; then
+                echo "Renaming $BASENAME to index.html..." >&2
+                mv "$HTML_FILE" "$PROJECT_PATH/index.html"
+            fi
+        fi
+    fi
+
+    # Create tarball of the project (excluding node_modules and .git)
+    echo "Creating deployment package..." >&2
+    tar -czf "$TARBALL" -C "$PROJECT_PATH" --exclude='node_modules' --exclude='.git' .
+else
+    echo "Error: Input must be a directory or a .tgz file" >&2
+    exit 1
+fi
+
+if [ "$FRAMEWORK" != "null" ]; then
+    echo "Detected framework: $FRAMEWORK" >&2
+fi
+
+# Deploy
+echo "Deploying..." >&2
+RESPONSE=$(curl -s -X POST "$DEPLOY_ENDPOINT" -F "file=@$TARBALL" -F "framework=$FRAMEWORK")
+
+# Check for error in response
+if echo "$RESPONSE" | grep -q '"error"'; then
+    ERROR_MSG=$(echo "$RESPONSE" | grep -o '"error":"[^"]*"' | cut -d'"' -f4)
+    echo "Error: $ERROR_MSG" >&2
+    exit 1
+fi
+
+# Extract URLs from response
+PREVIEW_URL=$(echo "$RESPONSE" | grep -o '"previewUrl":"[^"]*"' | cut -d'"' -f4)
+CLAIM_URL=$(echo "$RESPONSE" | grep -o '"claimUrl":"[^"]*"' | cut -d'"' -f4)
+
+if [ -z "$PREVIEW_URL" ]; then
+    echo "Error: Could not extract preview URL from response" >&2
+    echo "$RESPONSE" >&2
+    exit 1
+fi
+
+echo "" >&2
+echo "Deployment successful!" >&2
+echo "" >&2
+echo "Preview URL: $PREVIEW_URL" >&2
+echo "Claim URL:   $CLAIM_URL" >&2
+echo "" >&2
+
+# Output JSON for programmatic use
+echo "$RESPONSE"

package/baseline/skill/verification-before-completion/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: verification-before-completion
+description: Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
+version: 1.0.0
+tags: [workflow, code-quality]
+dependencies: []
+---
+
+# Verification Before Completion
+
+## When to Use
+
+- Before claiming tests/lint/build pass or a bug is fixed
+- Before committing, opening PRs, or stating completion in a status update
+
+## When NOT to Use
+
+- While still actively coding without a completion claim
+- When you cannot run verification commands yet (e.g., missing dependencies) — resolve first
+
+## Overview
+
+Claiming work is complete without verification is dishonesty, not efficiency.
+
+**Core principle:** Evidence before claims, always.
+
+**Violating the letter of this rule is violating the spirit of this rule.**
+
+## The Iron Law
+
+```
+NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
+```
+
+If you haven't run the verification command in this message, you cannot claim it passes.
+
+## The Gate Function
+
+```
+BEFORE claiming any status or expressing satisfaction:
+
+1. IDENTIFY: What command proves this claim?
+2. RUN: Execute the FULL command (fresh, complete)
+3. READ: Full output, check exit code, count failures
+4. VERIFY: Does output confirm the claim?
+   - If NO: State actual status with evidence
+   - If YES: State claim WITH evidence
+5. ONLY THEN: Make the claim
+
+Skip any step = lying, not verifying
+
+```
+
+## Verification Checklist
+
+- [ ] Identify the exact command that proves the claim
+- [ ] Run the full command (fresh)
+- [ ] Read the full output and exit code
+- [ ] Confirm the output matches the claim
+- [ ] Only then state the completion claim with evidence
+
+## Common Failures
+
+| Claim                 | Requires                        | Not Sufficient                 |
+| --------------------- | ------------------------------- | ------------------------------ |
+| Tests pass            | Test command output: 0 failures | Previous run, "should pass"    |
+| Linter clean          | Linter output: 0 errors         | Partial check, extrapolation   |
+| Build succeeds        | Build command: exit 0           | Linter passing, logs look good |
+| Bug fixed             | Test original symptom: passes   | Code changed, assumed fixed    |
+| Regression test works | Red-green cycle verified        | Test passes once               |
+| Agent completed       | VCS diff shows changes          | Agent reports "success"        |
+| Requirements met      | Line-by-line checklist          | Tests passing                  |
+
+## Red Flags - STOP
+
+- Using "should", "probably", "seems to"
+- Expressing satisfaction before verification ("Great!", "Perfect!", "Done!", etc.)
+- About to commit/push/PR without verification
+- Trusting agent success reports
+- Relying on partial verification
+- Thinking "just this once"
+- Tired and wanting work over
+- **ANY wording implying success without having run verification**
+
+## Rationalization Prevention
+
+| Excuse                                  | Reality                |
+| --------------------------------------- | ---------------------- |
+| "Should work now"                       | RUN the verification   |
+| "I'm confident"                         | Confidence ≠ evidence  |
+| "Just this once"                        | No exceptions          |
+| "Linter passed"                         | Linter ≠ compiler      |
+| "Agent said success"                    | Verify independently   |
+| "I'm tired"                             | Exhaustion ≠ excuse    |
+| "Partial check is enough"               | Partial proves nothing |
+| "Different words so rule doesn't apply" | Spirit over letter     |
+
+## Key Patterns
+
+**Tests:**
+
+```
+✅ [Run test command] [See: 34/34 pass] "All tests pass"
+❌ "Should pass now" / "Looks correct"
+```
+
+**Regression tests (TDD Red-Green):**
+
+```
+✅ Write → Run (pass) → Revert fix → Run (MUST FAIL) → Restore → Run (pass)
+❌ "I've written a regression test" (without red-green verification)
+```
+
+**Build:**
+
+```
+✅ [Run build] [See: exit 0] "Build passes"
+❌ "Linter passed" (linter doesn't check compilation)
+```
+
+**Requirements:**
+
+```
+✅ Re-read plan → Create checklist → Verify each → Report gaps or completion
+❌ "Tests pass, phase complete"
+```
+
+**Agent delegation:**
+
+```
+✅ Agent reports success → Check VCS diff → Verify changes → Report actual state
+❌ Trust agent report
+```
+
+## Smart Verification
+
+The Iron Law demands evidence, but evidence should be gathered efficiently.
+
+### Incremental by Default
+
+Unless shipping or `--full` is passed, verify only what changed:
+
+- **Lint**: `oxlint <changed-files>` instead of linting the entire codebase
+- **Test**: `vitest run --changed` instead of running all tests
+- **Typecheck**: always full (type errors propagate across files)
+
+See the [Verification Protocol](./references/VERIFICATION_PROTOCOL.md) for exact commands.
+
+### Parallel Execution
+
+Run independent gates simultaneously to reduce wall-clock time:
+
+```
+Parallel: typecheck + lint → both must pass
+Sequential: test → build (ship only)
+```
+
+Total time = max(typecheck, lint) + test, not typecheck + lint + test.
+
+### Verification Cache
+
+If you just verified and nothing changed, don't re-verify:
+
+1. After gates pass, record a stamp in `.beads/verify.log`
+2. Before running gates, compare current state to last stamp
+3. If match → report cached PASS, skip redundant work
+4. Cache is always bypassed for `--full` and ship/release
+
+This matters when other commands need verification (e.g., closing beads, `/ship`). If you verified 30 seconds ago and made no changes, the cache lets you skip.
+
+## Enforcement Gates
+
+Prompt-level rules get ignored under pressure. These gates are **hard blocks** — they must be checked at the tool/action level, not just remembered.
+
+### Gate 1: Completion Claims Require verify.log
+
+Before ANY completion claim (bead close, PR creation, `/ship`, task completion):
+
+1. Check `.beads/verify.log` exists and contains a recent `PASS` stamp
+2. If verify.log is missing or stale (older than last file change) → **BLOCK** — run verification first
+3. If verify.log shows `FAIL` → **BLOCK** — do not proceed
+
+```
+✅ verify.log exists, PASS within last edit window → proceed
+❌ verify.log missing → STOP: "Run verification first"
+❌ verify.log shows FAIL → STOP: "Verification failed, fix before claiming complete"
+❌ verify.log stale (files changed since last PASS) → STOP: "Re-run verification"
+```
+
+### Gate 2: Agent Delegation Requires Post-Verification
+
+After ANY `task()` subagent returns with "success", follow the **Worker Distrust Protocol** from AGENTS.md — read changed files, run verification, check acceptance criteria. Do not trust agent self-reports.
+
+### Enforcement Principle
+
+> **Prompt rules fail under pressure. Gates fail safe.**
+>
+> When a constraint matters enough to be an iron law, enforce it at the action level:
+> check a file, verify a condition, reject if unmet. Don't rely on the agent
+> "remembering" to follow the rule.
+
+## Why This Matters
+
+From 24 failure memories:
+
+- your human partner said "I don't believe you" - trust broken
+- Undefined functions shipped - would crash
+- Missing requirements shipped - incomplete features
+- Time wasted on false completion → redirect → rework
+- Violates: "Honesty is a core value. If you lie, you'll be replaced."
+
+## When To Apply
+
+**ALWAYS before:**
+
+- ANY variation of success/completion claims
+- ANY expression of satisfaction
+- ANY positive statement about work state
+- Committing, PR creation, task completion
+- Moving to next task
+- Delegating to agents
+
+**Rule applies to:**
+
+- Exact phrases
+- Paraphrases and synonyms
+- Implications of success
+- ANY communication suggesting completion/correctness
+
+## The Bottom Line
+
+**No shortcuts for verification.**
+
+Run the command. Read the output. THEN claim the result.
+
+This is non-negotiable.

package/baseline/skill/verification-before-completion/references/VERIFICATION_PROTOCOL.md

@@ -0,0 +1,171 @@
+# Verification Protocol
+
+## Default: Incremental Mode
+
+**Incremental is the default.** Only switch to full mode when:
+
+- `--full` flag is explicitly passed
+- Shipping/releasing (pre-merge, CI pipeline)
+- More than 20 files changed
+
+### Changed Files Detection
+
+```bash
+# Get changed files (uncommitted + staged + untracked)
+CHANGED=$({
+  git diff --name-only --diff-filter=d HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx'
+  git ls-files --others --exclude-standard -- '*.ts' '*.tsx' '*.js' '*.jsx'
+} | sort -u)
+
+# If in a bead worktree, diff against the branch point:
+# CHANGED=$({
+#   git diff --name-only --diff-filter=d main...HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx'
+#   git ls-files --others --exclude-standard -- '*.ts' '*.tsx' '*.js' '*.jsx'
+# } | sort -u)
+
+# Count for mode decision
+FILE_COUNT=$(echo "$CHANGED" | grep -c .)
+# > 20 files → switch to full mode automatically
+```
+
+## Standard Gates
+
+### Gate Execution Order
+
+```
+┌─────────────────────────────────────┐
+│  Parallel (run simultaneously)      │
+│  ┌─────────────┐ ┌───────────────┐  │
+│  │  Typecheck   │ │  Lint         │  │
+│  │  (always     │ │  (changed     │  │
+│  │   full)      │ │   files only) │  │
+│  └──────┬──────┘ └──────┬────────┘  │
+│         └───────┬───────┘           │
+│            both must pass           │
+├─────────────────────────────────────┤
+│  Sequential (after parallel passes) │
+│  ┌─────────────┐ ┌───────────────┐  │
+│  │  Test        │ │  Build        │  │
+│  │  (--changed  │ │  (ship/release│  │
+│  │   or full)   │ │   only)       │  │
+│  └─────────────┘ └───────────────┘  │
+└─────────────────────────────────────┘
+```
+
+### Parallel Group (independent — run simultaneously)
+
+```bash
+# Gate 1: Typecheck (always full — type errors propagate across files)
+npm run typecheck 2>&1 &
+PID_TC=$!
+
+# Gate 2: Lint
+# Incremental (default): lint only changed files
+npx oxlint $CHANGED 2>&1 &
+# Full mode: lint everything
+# npm run lint 2>&1 &
+PID_LINT=$!
+
+wait $PID_TC $PID_LINT
+```
+
+### Sequential Group (depends on parallel group passing)
+
+```bash
+# Gate 3: Tests
+# Incremental (default): only tests affected by changed files
+npx vitest run --changed
+# Full mode: run all tests
+# npm test
+
+# Gate 4: Build (only if shipping/releasing)
+# npm run build
+```
+
+### Gate Commands Summary
+
+| Gate      | Incremental (default)        | Full (`--full`)     | When              |
+| --------- | ---------------------------- | ------------------- | ----------------- |
+| Typecheck | `npm run typecheck`          | `npm run typecheck` | Always (parallel) |
+| Lint      | `npx oxlint <changed-files>` | `npm run lint`      | Always (parallel) |
+| Test      | `npx vitest run --changed`   | `npm test`          | Always            |
+| Build     | Skip                         | `npm run build`     | Ship/release only |
+
+## Verification Cache
+
+Avoid redundant verification when nothing changed since the last successful run.
+
+### Cache Protocol
+
+After all gates pass, record a verification stamp:
+
+```bash
+# Compute fingerprint: commit hash + full diff content + untracked files
+# This ensures the stamp changes on ANY code change (commit, edit, or new file)
+STAMP=$(printf '%s\n%s\n%s' \
+  "$(git rev-parse HEAD)" \
+  "$(git diff HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx')" \
+  "$(git ls-files --others --exclude-standard -- '*.ts' '*.tsx' '*.js' '*.jsx' | xargs cat 2>/dev/null)" \
+  | shasum -a 256 | cut -d' ' -f1)
+
+echo "$STAMP $(date -u +%Y-%m-%dT%H:%M:%SZ) PASS" >> .beads/verify.log
+```
+
+### Skip Check (before running gates)
+
+```bash
+# Read last verification stamp
+LAST_STAMP=$(tail -1 .beads/verify.log 2>/dev/null | awk '{print $1}')
+
+# Recompute current fingerprint (same formula as recording)
+CURRENT_STAMP=$(printf '%s\n%s\n%s' \
+  "$(git rev-parse HEAD)" \
+  "$(git diff HEAD -- '*.ts' '*.tsx' '*.js' '*.jsx')" \
+  "$(git ls-files --others --exclude-standard -- '*.ts' '*.tsx' '*.js' '*.jsx' | xargs cat 2>/dev/null)" \
+  | shasum -a 256 | cut -d' ' -f1)
+
+if [ "$LAST_STAMP" = "$CURRENT_STAMP" ]; then
+  echo "Verification cached: no changes since last PASS"
+  # Skip gates — report cached result
+else
+  # Run gates normally
+fi
+```
+
+### When Cache is Invalidated
+
+- Any file edited, staged, or committed since last verification
+- `--full` flag always bypasses cache
+- Manual `--no-cache` flag bypasses cache
+- Different bead context (bead ID changed)
+
+### Agent Behavior
+
+When another command needs verification (e.g., closing a bead, `/ship`):
+
+1. **Check cache first** — if clean, report `"Verification: cached PASS (no changes since <timestamp>)"`
+2. **If cache miss** — run incremental gates normally
+3. **Always record** — append to `verify.log` after successful run
+4. **Never skip on ship/release** — always run full mode regardless of cache
+
+## Gate Results Format
+
+Report results as:
+
+```text
+| Gate      | Status | Mode        | Time   |
+|-----------|--------|-------------|--------|
+| Typecheck | PASS   | full        | 2.1s   |
+| Lint      | PASS   | incremental | 0.3s   |
+| Test      | PASS   | incremental | 1.2s   |
+| Build     | SKIP   | —           | —      |
+```
+
+Include the mode column so it's clear whether incremental or full was used.
+
+## Failure Handling
+
+- If any gate fails, stop and fix before proceeding
+- Show the FULL error output for failed gates
+- After fixing, re-run ONLY the failed gate(s) + any downstream gates
+- Cache is NOT written on failure — next run will execute gates normally