@baselane/packs 0.1.5 → 0.1.7

package/packs/full-harness/rendered/.claude/skills/e2e-testing/SKILL.md

@@ -0,0 +1,325 @@
+---
+name: e2e-testing
+description: Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies.
+---
+
+# E2E Testing Patterns
+
+Comprehensive Playwright patterns for building stable, fast, and maintainable E2E test suites.
+
+## Test File Organization
+
+```
+tests/
+├── e2e/
+│   ├── auth/
+│   │   ├── login.spec.ts
+│   │   ├── logout.spec.ts
+│   │   └── register.spec.ts
+│   ├── features/
+│   │   ├── browse.spec.ts
+│   │   ├── search.spec.ts
+│   │   └── create.spec.ts
+│   └── api/
+│       └── endpoints.spec.ts
+├── fixtures/
+│   ├── auth.ts
+│   └── data.ts
+└── playwright.config.ts
+```
+
+## Page Object Model (POM)
+
+```typescript
+import { Page, Locator } from '@playwright/test'
+
+export class ItemsPage {
+  readonly page: Page
+  readonly searchInput: Locator
+  readonly itemCards: Locator
+  readonly createButton: Locator
+
+  constructor(page: Page) {
+    this.page = page
+    this.searchInput = page.locator('[data-testid="search-input"]')
+    this.itemCards = page.locator('[data-testid="item-card"]')
+    this.createButton = page.locator('[data-testid="create-btn"]')
+  }
+
+  async goto() {
+    await this.page.goto('/items')
+    await this.page.waitForLoadState('networkidle')
+  }
+
+  async search(query: string) {
+    await this.searchInput.fill(query)
+    await this.page.waitForResponse(resp => resp.url().includes('/api/search'))
+    await this.page.waitForLoadState('networkidle')
+  }
+
+  async getItemCount() {
+    return await this.itemCards.count()
+  }
+}
+```
+
+## Test Structure
+
+```typescript
+import { test, expect } from '@playwright/test'
+import { ItemsPage } from '../../pages/ItemsPage'
+
+test.describe('Item Search', () => {
+  let itemsPage: ItemsPage
+
+  test.beforeEach(async ({ page }) => {
+    itemsPage = new ItemsPage(page)
+    await itemsPage.goto()
+  })
+
+  test('should search by keyword', async ({ page }) => {
+    await itemsPage.search('test')
+
+    const count = await itemsPage.getItemCount()
+    expect(count).toBeGreaterThan(0)
+
+    await expect(itemsPage.itemCards.first()).toContainText(/test/i)
+    await page.screenshot({ path: 'artifacts/search-results.png' })
+  })
+
+  test('should handle no results', async ({ page }) => {
+    await itemsPage.search('xyznonexistent123')
+
+    await expect(page.locator('[data-testid="no-results"]')).toBeVisible()
+    expect(await itemsPage.getItemCount()).toBe(0)
+  })
+})
+```
+
+## Playwright Configuration
+
+```typescript
+import { defineConfig, devices } from '@playwright/test'
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: [
+    ['html', { outputFolder: 'playwright-report' }],
+    ['junit', { outputFile: 'playwright-results.xml' }],
+    ['json', { outputFile: 'playwright-results.json' }]
+  ],
+  use: {
+    baseURL: process.env.BASE_URL || 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+    actionTimeout: 10000,
+    navigationTimeout: 30000,
+  },
+  projects: [
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
+    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
+    { name: 'mobile-chrome', use: { ...devices['Pixel 5'] } },
+  ],
+  webServer: {
+    command: 'npm run dev',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+    timeout: 120000,
+  },
+})
+```
+
+## Flaky Test Patterns
+
+### Quarantine
+
+```typescript
+test('flaky: complex search', async ({ page }) => {
+  test.fixme(true, 'Flaky - Issue #123')
+  // test code...
+})
+
+test('conditional skip', async ({ page }) => {
+  test.skip(process.env.CI, 'Flaky in CI - Issue #123')
+  // test code...
+})
+```
+
+### Identify Flakiness
+
+```bash
+npx playwright test tests/search.spec.ts --repeat-each=10
+npx playwright test tests/search.spec.ts --retries=3
+```
+
+### Common Causes & Fixes
+
+**Race conditions:**
+```typescript
+// Bad: assumes element is ready
+await page.click('[data-testid="button"]')
+
+// Good: auto-wait locator
+await page.locator('[data-testid="button"]').click()
+```
+
+**Network timing:**
+```typescript
+// Bad: arbitrary timeout
+await page.waitForTimeout(5000)
+
+// Good: wait for specific condition
+await page.waitForResponse(resp => resp.url().includes('/api/data'))
+```
+
+**Animation timing:**
+```typescript
+// Bad: click during animation
+await page.click('[data-testid="menu-item"]')
+
+// Good: wait for stability
+await page.locator('[data-testid="menu-item"]').waitFor({ state: 'visible' })
+await page.waitForLoadState('networkidle')
+await page.locator('[data-testid="menu-item"]').click()
+```
+
+## Artifact Management
+
+### Screenshots
+
+```typescript
+await page.screenshot({ path: 'artifacts/after-login.png' })
+await page.screenshot({ path: 'artifacts/full-page.png', fullPage: true })
+await page.locator('[data-testid="chart"]').screenshot({ path: 'artifacts/chart.png' })
+```
+
+### Traces
+
+```typescript
+await browser.startTracing(page, {
+  path: 'artifacts/trace.json',
+  screenshots: true,
+  snapshots: true,
+})
+// ... test actions ...
+await browser.stopTracing()
+```
+
+### Video
+
+```typescript
+// In playwright.config.ts
+use: {
+  video: 'retain-on-failure',
+  videosPath: 'artifacts/videos/'
+}
+```
+
+## CI/CD Integration
+
+```yaml
+# .github/workflows/e2e.yml
+name: E2E Tests
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npx playwright install --with-deps
+      - run: npx playwright test
+        env:
+          BASE_URL: ${{ vars.STAGING_URL }}
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: playwright-report
+          path: playwright-report/
+          retention-days: 30
+```
+
+## Test Report Template
+
+```markdown
+# E2E Test Report
+
+**Date:** YYYY-MM-DD HH:MM
+**Duration:** Xm Ys
+**Status:** PASSING / FAILING
+
+## Summary
+- Total: X | Passed: Y (Z%) | Failed: A | Flaky: B | Skipped: C
+
+## Failed Tests
+
+### test-name
+**File:** `tests/e2e/feature.spec.ts:45`
+**Error:** Expected element to be visible
+**Screenshot:** artifacts/failed.png
+**Recommended Fix:** [description]
+
+## Artifacts
+- HTML Report: playwright-report/index.html
+- Screenshots: artifacts/*.png
+- Videos: artifacts/videos/*.webm
+- Traces: artifacts/*.zip
+```
+
+## Wallet / Web3 Testing
+
+```typescript
+test('wallet connection', async ({ page, context }) => {
+  // Mock wallet provider
+  await context.addInitScript(() => {
+    window.ethereum = {
+      isMetaMask: true,
+      request: async ({ method }) => {
+        if (method === 'eth_requestAccounts')
+          return ['0x1234567890123456789012345678901234567890']
+        if (method === 'eth_chainId') return '0x1'
+      }
+    }
+  })
+
+  await page.goto('/')
+  await page.locator('[data-testid="connect-wallet"]').click()
+  await expect(page.locator('[data-testid="wallet-address"]')).toContainText('0x1234')
+})
+```
+
+## Financial / Critical Flow Testing
+
+```typescript
+test('trade execution', async ({ page }) => {
+  // Skip on production — real money
+  test.skip(process.env.NODE_ENV === 'production', 'Skip on production')
+
+  await page.goto('/markets/test-market')
+  await page.locator('[data-testid="position-yes"]').click()
+  await page.locator('[data-testid="trade-amount"]').fill('1.0')
+
+  // Verify preview
+  const preview = page.locator('[data-testid="trade-preview"]')
+  await expect(preview).toContainText('1.0')
+
+  // Confirm and wait for blockchain
+  await page.locator('[data-testid="confirm-trade"]').click()
+  await page.waitForResponse(
+    resp => resp.url().includes('/api/trade') && resp.status() === 200,
+    { timeout: 30000 }
+  )
+
+  await expect(page.locator('[data-testid="trade-success"]')).toBeVisible()
+})
+```

package/packs/full-harness/rendered/.claude/skills/ecc-guide/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: ecc-guide
+description: Guide users through ECC's current agents, skills, commands, hooks, rules, install profiles, and project onboarding by reading the live repository surface before answering.
+---
+
+# ECC Guide
+
+Use this skill when a user needs help understanding, navigating, installing, or choosing parts of Everything Claude Code.
+
+## When To Use
+
+Use this skill when the user:
+
+- asks what ECC includes
+- wants help finding a skill, command, agent, hook, rule, or install profile
+- is new to the repository and needs a guided path
+- asks "how do I do X with ECC?"
+- asks which ECC components fit a project
+- needs a lightweight explanation of how commands, skills, agents, hooks, and rules relate
+- is confused by install paths, duplicate installs, reset/uninstall, or selective install options
+
+## Core Principle
+
+Answer from current files, not memory. ECC changes quickly, so hard-coded catalog counts, feature lists, and install instructions go stale.
+
+When the ECC repository is available, inspect the relevant files before giving a concrete answer:
+
+```bash
+node scripts/ci/catalog.js --json
+find skills -maxdepth 2 -name SKILL.md | sort
+find commands -maxdepth 1 -name '*.md' | sort
+find agents -maxdepth 1 -name '*.md' | sort
+node scripts/install-plan.js --list-profiles
+node scripts/install-plan.js --list-components --json
+```
+
+Use the smallest set of reads needed for the user's question.
+
+## Repository Map
+
+- `README.md`: install paths, uninstall/reset guidance, public positioning, FAQs
+- `AGENTS.md`: contributor guidance and project structure
+- `agent.yaml`: exported gitagent surface and command list
+- `commands/`: maintained slash-command compatibility shims
+- `skills/*/SKILL.md`: reusable workflows and domain playbooks
+- `agents/*.md`: delegated subagent role prompts
+- `rules/`: language and harness rules
+- `hooks/README.md`, `hooks/hooks.json`, `scripts/hooks/`: hook behavior and safety gates
+- `manifests/install-*.json`: selective install modules, components, profiles, and target support
+- `docs/`: harness guides, architecture notes, translated docs, release docs
+
+## Response Style
+
+Lead with the answer, then give the next action. Most users do not need a full catalog dump.
+
+Good first response shape:
+
+1. what to use
+2. why it fits
+3. exact file or command to inspect
+4. one next command or question
+
+Avoid:
+
+- listing every skill or command by default
+- repeating large README sections
+- recommending retired command shims when a skill-first path exists
+- claiming a component exists without checking the filesystem
+- replacing install guidance with manual copy commands when the managed installer supports the target
+
+## Common Tasks
+
+### New User Onboarding
+
+Give a short menu:
+
+- install or reset ECC
+- pick skills for a project
+- understand commands vs skills
+- inspect hooks and safety behavior
+- run a harness audit
+- find a specific workflow
+
+Point to `README.md` for install/reset and `/project-init` for project-specific onboarding.
+
+### Feature Discovery
+
+For "what should I use for X?":
+
+1. Search `skills/`, `commands/`, and `agents/`.
+2. Prefer skills as the primary workflow surface.
+3. Use commands only when they are a maintained compatibility shim or a user explicitly wants slash-command behavior.
+4. Mention agents when delegation is useful.
+
+Useful searches:
+
+```bash
+rg -n "<query>" skills commands agents docs
+find skills -maxdepth 2 -name SKILL.md | sort
+```
+
+### Install Guidance
+
+Use managed install paths:
+
+```bash
+node scripts/install-plan.js --list-profiles
+node scripts/install-plan.js --profile minimal --target claude --json
+node scripts/install-apply.js --profile minimal --target claude --dry-run
+```
+
+For specific skill installs:
+
+```bash
+node scripts/install-plan.js --skills <skill-id> --target claude --json
+node scripts/install-apply.js --skills <skill-id> --target claude --dry-run
+```
+
+Warn users not to stack plugin installs and full manual/profile installs unless they intentionally want duplicate surfaces.
+
+### Project Onboarding
+
+Use `/project-init` when the user wants ECC configured for a target repo. The expected sequence is:
+
+1. detect the stack from project files
+2. resolve a dry-run install plan
+3. inspect existing `CLAUDE.md` and settings files
+4. ask before applying changes
+5. keep generated guidance minimal and repo-specific
+
+### Troubleshooting
+
+Ask for the target harness and install path first, then inspect:
+
+- plugin install metadata
+- `.claude/`, `.cursor/`, `.codex/`, `.gemini/`, `.opencode/`, `.codebuddy/`, `.joycode/`, or `.qwen/`
+- `hooks/hooks.json`
+- install-state files
+- relevant command/skill files
+
+For repo health, suggest:
+
+```bash
+npm run harness:audit -- --format text
+npm run observability:ready
+npm test
+```
+
+## Output Templates
+
+### Short Recommendation
+
+```text
+Use <skill-or-command>. It fits because <reason>.
+
+Canonical file: <path>
+Verify with: <command>
+Next: <one concrete action>
+```
+
+### Search Results
+
+```text
+Best matches:
+- <path>: <why it matters>
+- <path>: <why it matters>
+
+Recommendation: <which one to use first and why>
+```
+
+### Install Plan Summary
+
+```text
+Detected: <stack evidence>
+Target: <harness>
+Plan: <profile/modules/skills>
+Dry run: <command>
+Would change: <paths>
+Needs approval before apply: <yes/no>
+```
+
+## Related Surfaces
+
+- `/project-init`: stack-aware onboarding plan for a target repo
+- `/harness-audit`: deterministic readiness scorecard
+- `/skill-health`: skill quality review
+- `/skill-create`: generate a new skill from local git history
+- `/security-scan`: inspect Claude/OpenCode configuration security

package/packs/full-harness/rendered/.claude/skills/ecc-recipes/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: ecc-recipes
+description: Map a described workflow to the right ECC command-GROUP with run-order and stop condition, and browse all command-group recipe families. Adds a family-grouping + run-order + when-to-stop layer on top of the flat command catalog. Advisory only. TRIGGER when the user says which commands for X, what command group runs X, show ECC recipes, list ECC pipelines, or how do I run a workflow with ECC. DO NOT TRIGGER when the user wants the task executed directly, wants a single-command deep doc (use ecc-guide), or wants a draft prompt rewritten (use prompt-optimizer).
+---
+
+# ECC Recipes
+
+One entry point for "which group of ECC slash-commands runs my workflow, in what
+order, and when do I stop." Also browses every command-group recipe family.
+
+Fills the gap between two existing skills:
+
+- `ecc-guide` — lists commands and where to read docs, but as a flat catalog.
+- `prompt-optimizer` — matches a task to components, but outputs a single prompt,
+  not a multi-command group with run-order and stop condition.
+
+This skill adds: **family grouping + run-order + stop condition.**
+
+## When to Activate
+
+- "Which command group do I run for <workflow>?"
+- "What's the command sequence to build an MVP / fix a defect / refactor?"
+- "Show me all ECC command-group recipes" (catalog mode)
+- "How many workflow pipelines does ECC have?"
+- User invokes `/ecc-recipes` with or without a description.
+
+### Do Not Use When
+
+- User wants the task done now — route to the actual command, don't describe it.
+- User wants deep docs for ONE command — use `ecc-guide`.
+- User wants a draft prompt rewritten — use `prompt-optimizer`.
+
+## Core Principle
+
+**Answer from current files, not memory.** The command set changes; never
+hardcode counts or member lists. Read the live `commands/` directory each run,
+then classify into families.
+
+### Live reads
+
+Resolve the commands directory (first that exists), then list names:
+
+```bash
+for D in \
+  "$HOME"/.claude/plugins/marketplaces/ecc/commands \
+  "$HOME"/.claude/plugins/cache/ecc/ecc/*/commands \
+  ./commands \
+  ./.claude/commands \
+  "$HOME"/.claude/commands; do
+  [ -d "$D" ] && CMD_DIR="$D" && break
+done
+[ -z "${CMD_DIR:-}" ] && { echo "No ECC commands directory found."; return 1; }
+find "$CMD_DIR" -maxdepth 1 -name '*.md' -exec basename {} .md \; | sort
+```
+
+Optionally read `manifests/install-*.json` if present for richer grouping. Use
+the smallest set of reads needed.
+
+## Family Classification (by prefix)
+
+Group command names by leading prefix; map known singletons by hand. Families are
+derived live — the table below is the *classification rule*, not a frozen list.
+
+| Family prefix | Recipe meaning | Typical run-order |
+|---|---|---|
+| `orch-*` | gated Research, Plan, TDD, Review, Commit per task type | pick one orch-* by task kind; it runs its own internal phases |
+| `multi-*` | multi-model workflow | `multi-plan` then `multi-execute` then review (or `multi-workflow` end-to-end) |
+| `prp-*` | PRD to plan to implement to PR pipeline | `prp-prd` then `prp-plan` then `prp-implement` then `prp-commit` then `prp-pr` |
+| `epic-*` | large multi-unit epic, parallel | `epic-decompose` then `epic-claim` then `epic-validate` then `epic-review` then `epic-unblock` then `epic-sync` then `epic-publish` |
+| `loop-*` | managed autonomous loop and monitor | `loop-start <pattern>` then watch with `loop-status` |
+| `gan-*` | generator and evaluator loop | `gan-build` (code) or `gan-design` (UI); self-looping |
+| `*-build` / `*-review` / `*-test` | per-language CI triad | `<lang>-test` (TDD) then `<lang>-build` (fix) then `<lang>-review` |
+| `hookify-*` | behavior-hook management | `hookify` then `hookify-list` then `hookify-configure` |
+| `learn` / `instinct-*` / `evolve` / `promote` / `prune` | continuous-learning | `learn` then `instinct-status` then `evolve` then `promote` |
+| singletons | `santa-loop`, `plan`, `plan-prd`, `pr`, `code-review`, `checkpoint`, etc. | standalone or glue between groups |
+
+Any command not matching a prefix rule → list it under **singletons** with its
+one-line description.
+
+## How It Works
+
+```
+1. Live-read command names from CMD_DIR.
+2. Classify into families by prefix and a singleton map.
+3. If a workflow description was given -> MATCH MODE.
+   If none -> CATALOG MODE.
+4. Advisory only: print the plan. Never run the matched commands.
+```
+
+### Catalog mode (no description)
+
+Output the family table: each family, member count, members, one-line meaning,
+typical run-order. End with the total command count and a prompt to describe a
+workflow for a matched recipe.
+
+### Match mode (description given)
+
+1. Restate the workflow in one sentence.
+2. Pick the best 1-2 families; say WHY in one line each.
+3. **Run-order block** — exact command sequence for the matched family.
+4. **Stop condition** — always explicit (max-runs, completion-signal,
+   review-passes, or single-shot). For autonomous loops, warn about subscription
+   burn and recommend a backstop bound.
+5. **Where to read** — the `commands/<name>.md` path plus `/ecc-guide <name>`.
+
+## Output Template (match mode)
+
+```
+Workflow: <one-sentence restatement>
+
+Best fit: <family> — <why>
+(Alt: <family> — <why>)
+
+Run-order:
+  /<cmd1>   # job
+  /<cmd2>   # job
+  /<cmd3>   # job
+  STOP when: <condition>
+  WARNING (autonomous loops only): an unbounded loop burns subscription/credits —
+  add a max-iteration or max-cost backstop alongside the completion signal.
+
+Read full docs:
+  commands/<cmd1>.md   (or: /ecc-guide <cmd1>)
+```
+
+## Examples
+
+**Catalog:** `/ecc-recipes` → prints the family table and total count.
+
+**Match:** `/ecc-recipes plan a whole app upfront then auto-build with adversarial
+review until done` → Best fit: `loop-*` (autonomous) wrapping `gan-*` or
+`santa-loop` (adversarial). Run-order: `plan-prd` then
+`loop-start rfc-dag --mode safe` then monitor `loop-status`; STOP when all units
+pass review N consecutive times (add a max-iteration backstop to bound burn).
+
+**Match:** `/ecc-recipes fix a bug in my Go service` → Best fit: `orch-fix-defect`
+(reproduce, fix, review, commit). Alt: `go-test` then `go-build` then
+`go-review`. STOP: regression test green and review pass.
+
+## Non-Goals
+
+- Not an executor — advisory only.
+- Not per-command deep docs — that's `ecc-guide`.
+- Not prompt rewriting — that's `prompt-optimizer`.
+- Never hardcode command counts or member lists — always live-read.