worclaude 2.7.1 → 2.9.0

package/templates/skills/universal/subagent-usage.md

@@ -67,14 +67,27 @@ coordination overhead grows.
 Some agents use `git worktree` to make changes without affecting your working tree:
 
 How it works:
-1. Agent creates a worktree from your current branch
+1. Agent creates a worktree based on `origin/HEAD` (see gotcha below)
 2. Makes changes in the worktree (isolated from your files)
 3. Commits changes
 4. You merge or cherry-pick the results
 
-Agents with worktree isolation: code-simplifier, test-writer, verify-app, ci-fixer,
+Agents with worktree isolation: code-simplifier, test-writer, verify-app,
 bug-fixer, refactorer, doc-writer.
 
+### Base-branch gotcha
+
+Both `claude --worktree` and the Agent `isolation: "worktree"` option create the
+worktree from `origin/HEAD`, **not** your current branch. If your working branch is
+ahead of whatever `origin/HEAD` points to (typically `origin/main`), the worktree
+will miss those commits.
+
+Run `worclaude doctor` to diagnose. Fix locally with `git remote set-head origin
+<your-branch>` (reversible via `--auto` or `main`). The bundled `bug-fixer`,
+`verify-app`, and `test-writer` agents include a freshness preamble that resets
+their worktree to match the parent's current branch automatically; other worktree
+agents do not.
+
 Benefits:
 - Agent's changes don't conflict with your uncommitted work
 - You can review agent changes before merging

package/src/data/agent-registry.js

@@ -1,365 +0,0 @@
-/**
- * Agent routing metadata for every agent in the registry.
- * Used by the agent-routing generator to produce the routing skill file.
- * Separate from agents.js because this data is only consumed by the generator,
- * not by CLI prompts or display logic.
- */
-export const AGENT_REGISTRY = {
-  // --- Universal agents ---
-
-  'plan-reviewer': {
-    category: 'universal',
-    model: 'Opus',
-    isolation: 'none',
-    pipelineStage: 'Stage 2: Review',
-    triggerType: 'manual',
-    triggerCommand: '/review-plan',
-    whenToUse: 'Before executing any implementation prompt. Always.',
-    whatItDoes:
-      'Reviews implementation plans as a senior staff engineer. Challenges assumptions, finds ambiguity, checks verification strategy, identifies missing edge cases.',
-    expectBack: 'Refined plan with concerns addressed, or list of blocking questions.',
-    situationLabel: 'Got an implementation prompt',
-  },
-  'test-writer': {
-    category: 'universal',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    pipelineStage: 'Stage 5: Verify',
-    triggerType: 'automatic',
-    triggerCommand: null,
-    whenToUse: 'After completing implementation of any feature or module.',
-    whatItDoes:
-      'Writes unit tests, integration tests, edge case tests. Covers happy path, error cases, boundary conditions.',
-    expectBack: 'Test files committed to worktree branch. Merge when reviewed.',
-    situationLabel: 'Finished implementing a feature',
-  },
-  'code-simplifier': {
-    category: 'universal',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    pipelineStage: 'Stage 4: Quality',
-    triggerType: 'automatic',
-    triggerCommand: '/simplify',
-    whenToUse:
-      'After a feature is implemented and tests pass. Also when you notice growing complexity or duplication.',
-    whatItDoes:
-      'Reviews code for duplication, unnecessary abstraction, missed reuse opportunities. Simplifies without changing behavior.',
-    expectBack: 'Cleanup commits on worktree branch. Diff review before merge.',
-    situationLabel: 'Notice code getting complex',
-  },
-  'build-validator': {
-    category: 'universal',
-    model: 'Haiku',
-    isolation: 'none',
-    pipelineStage: 'Stage 5: Verify',
-    triggerType: 'automatic',
-    triggerCommand: null,
-    whenToUse: 'Before every commit. After merging worktree branches.',
-    whatItDoes:
-      'Quick validation — tests pass, build succeeds, lint clean. Fast and cheap (Haiku model).',
-    expectBack: 'Pass/fail with specific errors if failed.',
-    situationLabel: 'Are about to commit',
-  },
-  'verify-app': {
-    category: 'universal',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    pipelineStage: 'Stage 5: Verify',
-    triggerType: 'manual',
-    triggerCommand: '/verify',
-    whenToUse: 'Before creating a PR. After major changes.',
-    whatItDoes:
-      'Full end-to-end verification. Runs the app, tests all major flows, checks for regressions. More thorough than build-validator.',
-    expectBack: 'Detailed verification report. Blocking issues listed.',
-    situationLabel: 'Finished a task, ready for PR',
-  },
-  'upstream-watcher': {
-    category: 'universal',
-    model: 'Sonnet',
-    isolation: 'none',
-    pipelineStage: 'Stage 1: Context',
-    triggerType: 'manual',
-    triggerCommand: '/upstream-check',
-    whenToUse:
-      'At the start of a session to check for upstream Claude Code changes. After Claude Code updates. When behavior seems different from last session.',
-    whatItDoes:
-      "Fetches anthropic-watch feeds, cross-references upstream changes against the project's scaffolded agents/commands/hooks/skills, and produces an impact report.",
-    expectBack:
-      'Impact report: which upstream changes affect this project, which are informational, and recommended actions.',
-    situationLabel: 'Want to check for upstream Claude Code changes',
-  },
-
-  // --- Frontend agents (2) ---
-
-  'ui-reviewer': {
-    category: 'frontend',
-    model: 'Sonnet',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'After implementing or modifying UI components. When adding new pages or layouts. During design system changes.',
-    whatItDoes:
-      'Reviews UI components for consistency, accessibility, responsiveness. Checks component hierarchy and prop patterns.',
-    expectBack: 'UI review report with specific issues and accessibility findings.',
-    situationLabel: 'Implemented or changed UI components',
-  },
-  'style-enforcer': {
-    category: 'frontend',
-    model: 'Haiku',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse: 'After CSS/styling changes. When new components are added. During theme updates.',
-    whatItDoes:
-      'Ensures design system compliance, catches CSS/styling drift, validates consistent spacing/colors/typography.',
-    expectBack: 'List of design system violations with fix suggestions.',
-    situationLabel: 'Made styling or CSS changes',
-  },
-
-  // --- Backend agents (3) ---
-
-  'api-designer': {
-    category: 'backend',
-    model: 'Opus',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Designing new API endpoints. Changing existing API contracts. Adding new routes or modifying request/response shapes.',
-    whatItDoes:
-      'Reviews API design for RESTful conventions, naming consistency, backward compatibility, request/response shape validation.',
-    expectBack: 'Design review with specific recommendations.',
-    situationLabel: 'Designed a new API endpoint',
-  },
-  'database-analyst': {
-    category: 'backend',
-    model: 'Sonnet',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse: 'Writing migrations. Changing schemas. Complex queries. Data integrity concerns.',
-    whatItDoes:
-      'Reviews schema design, migration safety, query performance, index usage, data integrity constraints.',
-    expectBack: 'Analysis with specific concerns and recommendations.',
-    situationLabel: 'Wrote a database migration or schema change',
-  },
-  'auth-auditor': {
-    category: 'backend',
-    model: 'Opus',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Any change to authentication or authorization flow. New roles, permissions, token handling.',
-    whatItDoes:
-      'Reviews auth flows for correctness, token lifecycle, permission checks, session management, OWASP compliance.',
-    expectBack: 'Audit report with pass/fail per check.',
-    situationLabel: 'Changed auth or authorization logic',
-  },
-
-  // --- DevOps agents (4) ---
-
-  'dependency-manager': {
-    category: 'devops',
-    model: 'Haiku',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'After adding new packages. During regular maintenance. When security advisories are published.',
-    whatItDoes:
-      'Audits, updates, and resolves dependency issues. Checks for security vulnerabilities in packages.',
-    expectBack: 'Dependency audit report with update recommendations.',
-    situationLabel: 'Added new dependencies or running maintenance',
-  },
-  'ci-fixer': {
-    category: 'devops',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse: 'CI pipeline fails. Build errors in GitHub Actions/CI. Flaky tests blocking merges.',
-    whatItDoes: 'Reads CI logs, identifies root cause, implements fix in worktree isolation.',
-    expectBack: 'Fix committed to worktree branch with CI passing.',
-    situationLabel: 'CI pipeline is failing',
-  },
-  'docker-helper': {
-    category: 'devops',
-    model: 'Sonnet',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Creating or modifying Dockerfiles. Compose file changes. Multi-stage build optimization. Container debugging.',
-    whatItDoes:
-      'Manages containerization, Dockerfile optimization, compose file configuration, multi-stage builds.',
-    expectBack: 'Optimized Docker configuration with size/performance improvements.',
-    situationLabel: 'Working with Docker or containers',
-  },
-  'deploy-validator': {
-    category: 'devops',
-    model: 'Sonnet',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Before deploying to staging or production. After infrastructure changes. New environment setup.',
-    whatItDoes:
-      'Validates deployment readiness — environment configs, secrets management, health checks, rollback strategy.',
-    expectBack: 'Deployment readiness checklist with pass/fail.',
-    situationLabel: 'Preparing for deployment',
-  },
-
-  // --- Quality agents (6) ---
-
-  'bug-fixer': {
-    category: 'quality',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      "Bug reported. Test failing. Error in logs. Something broke but you don't want to derail current work.",
-    whatItDoes:
-      'Investigates the bug in isolation. Reads logs, reproduces, finds root cause, implements fix, writes regression test.',
-    expectBack: 'Fix committed to worktree branch with regression test.',
-    situationLabel: 'Got a bug report mid-task',
-  },
-  'security-reviewer': {
-    category: 'quality',
-    model: 'Opus',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Auth changes. User input handling. New API endpoints exposed to external users. Dependency updates.',
-    whatItDoes:
-      'Scans for injection vulnerabilities, auth bypasses, data exposure, insecure defaults, dependency vulnerabilities.',
-    expectBack: 'Security report with severity ratings.',
-    situationLabel: 'Made security-sensitive changes',
-  },
-  'performance-auditor': {
-    category: 'quality',
-    model: 'Sonnet',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Performance concern raised. Slow endpoint discovered. Before releasing to production. After major changes.',
-    whatItDoes:
-      'Profiles code, identifies bottlenecks, checks database query efficiency, measures response times, suggests optimizations.',
-    expectBack: 'Performance report with benchmarks and recommendations.',
-    situationLabel: 'Suspect performance issues',
-  },
-  refactorer: {
-    category: 'quality',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Large-scale renames. Architectural pattern changes. Library migrations. Moving code between modules.',
-    whatItDoes:
-      'Handles large-scale refactoring in worktree isolation. Renames, architectural changes, pattern migrations with full test verification.',
-    expectBack: 'Refactored code on worktree branch with all tests passing.',
-    situationLabel: 'Need large-scale refactoring',
-  },
-  'build-fixer': {
-    category: 'quality',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Build is broken. Tests failing. Lint errors blocking commit. Type errors after a merge or dependency update.',
-    whatItDoes:
-      'Reads error output, categorizes failures (build/test/lint/type), fixes in priority order, verifies each fix. Works in worktree isolation.',
-    expectBack: 'All checks passing, with a summary of what was fixed and why.',
-    situationLabel: 'Build or tests are broken',
-  },
-  'e2e-runner': {
-    category: 'quality',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'After implementing user-facing features. Before releases. When unit tests pass but integration is suspect.',
-    whatItDoes:
-      'Writes and runs end-to-end tests for critical user journeys. Detects E2E framework (Playwright/Cypress) or recommends setup. Tests web, API, or CLI flows.',
-    expectBack: 'E2E test results with pass/fail per journey and reproduction steps for failures.',
-    situationLabel: 'Need end-to-end testing of user flows',
-  },
-
-  // --- Documentation agents (2) ---
-
-  'doc-writer': {
-    category: 'documentation',
-    model: 'Sonnet',
-    isolation: 'worktree',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'After implementing new features. After API changes. When README is outdated. Before release.',
-    whatItDoes:
-      'Updates documentation, README, API docs from code changes. Keeps docs in sync with implementation.',
-    expectBack: 'Updated docs committed to worktree branch.',
-    situationLabel: 'Need docs updated after implementation',
-  },
-  'changelog-generator': {
-    category: 'documentation',
-    model: 'Haiku',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Before releasing a new version. After merging a batch of PRs. When preparing release notes.',
-    whatItDoes:
-      'Generates changelogs from git history, PR descriptions, and commit messages. Formats for release notes.',
-    expectBack: 'Formatted changelog entry for the release.',
-    situationLabel: 'Preparing a release',
-  },
-
-  // --- Data / AI agents (3) ---
-
-  'data-pipeline-reviewer': {
-    category: 'data',
-    model: 'Sonnet',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'New data pipeline created. ETL logic changed. Data transformation modified. Schema compatibility concerns.',
-    whatItDoes:
-      'Reviews data flows, validates transformations, checks for data loss, validates schema compatibility.',
-    expectBack: 'Pipeline review with data integrity concerns.',
-    situationLabel: 'Created or changed a data pipeline',
-  },
-  'ml-experiment-tracker': {
-    category: 'data',
-    model: 'Sonnet',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Running ML experiments. Comparing model performance. Hyperparameter tuning. Model selection.',
-    whatItDoes:
-      'Tracks ML experiments, compares metrics across runs, documents hyperparameters and results.',
-    expectBack: 'Experiment comparison report with recommendations.',
-    situationLabel: 'Running or comparing ML experiments',
-  },
-  'prompt-engineer': {
-    category: 'data',
-    model: 'Opus',
-    isolation: 'none',
-    triggerType: 'manual',
-    triggerCommand: null,
-    whenToUse:
-      'Writing LLM prompts. Optimizing prompt performance. Building prompt chains. Testing prompt variations.',
-    whatItDoes:
-      'Reviews and optimizes LLM prompts and chains. Tests prompt variations, measures output quality.',
-    expectBack: 'Optimized prompts with test results and quality comparison.',
-    situationLabel: 'Writing or optimizing LLM prompts',
-  },
-};

package/templates/agents/optional/quality/e2e-runner.md

@@ -1,98 +0,0 @@
----
-name: e2e-runner
-description: "Writes and runs end-to-end tests"
-model: sonnet
-isolation: worktree
-background: true
-maxTurns: 50
----
-
-You are an end-to-end testing specialist. You write and run tests
-that exercise the application from the user's perspective — clicking
-buttons, filling forms, calling APIs, verifying responses. You work
-in a worktree to keep test artifacts isolated.
-
-## When to Use
-
-- After implementing a new user-facing feature
-- Before a release to verify critical user journeys
-- After fixing a bug to prevent regression
-- When unit tests pass but you suspect integration issues
-
-## Framework Detection
-
-Check the project for existing E2E setup:
-1. Look for `playwright.config.*`, `cypress.config.*`, or `jest.config.*` with `testEnvironment: 'jsdom'`
-2. Check `package.json` for `@playwright/test`, `cypress`, `puppeteer`, or `selenium-webdriver`
-3. If no E2E framework exists, recommend Playwright and offer to set it up
-
-## What You Test
-
-### Critical User Journeys
-Identify the 3-5 most important user flows and test them end-to-end:
-- Authentication: sign up → log in → access protected resource → log out
-- Core action: the main thing users do (create post, submit order, run command)
-- Error recovery: what happens when things go wrong (invalid input, network error, timeout)
-
-### For Web Applications
-- Page loads without errors (no console errors, no broken images)
-- Forms submit and validate correctly
-- Navigation works (links, back button, deep links)
-- Responsive behavior at key breakpoints (mobile, tablet, desktop)
-- Authentication state persists across page reloads
-
-### For APIs
-- Endpoints return correct status codes and response shapes
-- Authentication and authorization work correctly
-- Rate limiting and error responses are proper
-- Pagination, filtering, and sorting work on collection endpoints
-
-### For CLI Tools
-- Commands execute and return correct exit codes
-- Output matches expected format (stdout, stderr separation)
-- Flag combinations work correctly
-- Error messages are helpful for invalid input
-- File I/O operations create/modify expected files
-
-## Test Structure
-
-Follow the Page Object Model for web tests:
-
-```
-// pages/LoginPage.js
-class LoginPage {
-  constructor(page) { this.page = page; }
-  async login(email, password) {
-    await this.page.fill('[data-testid="email"]', email);
-    await this.page.fill('[data-testid="password"]', password);
-    await this.page.click('[data-testid="submit"]');
-  }
-}
-
-// tests/auth.spec.js
-test('user can log in with valid credentials', async ({ page }) => {
-  const loginPage = new LoginPage(page);
-  await page.goto('/login');
-  await loginPage.login('user@example.com', 'password123');
-  await expect(page).toHaveURL('/dashboard');
-});
-```
-
-## Report Format
-
-| # | Journey | Steps | Result | Duration |
-|---|---------|-------|--------|----------|
-| 1 | Sign up flow | 5 | PASS | 2.3s |
-| 2 | Create and edit post | 8 | PASS | 4.1s |
-| 3 | Search with filters | 4 | FAIL — no results shown | 1.8s |
-| 4 | Delete account | 3 | PASS | 1.2s |
-
-**Summary**: 3/4 journeys pass. Search filter test fails — the filter component doesn't trigger a re-fetch when the filter value changes.
-
-## Rules
-- E2E tests should be independent — each test starts from a clean state
-- Use data-testid attributes for selectors, never CSS classes or element structure
-- Set reasonable timeouts — E2E tests are slow; don't set 1s timeouts for page loads
-- Clean up test data after each test (or use isolated test accounts)
-- Keep E2E tests focused on critical journeys — don't try to cover everything
-- If the application won't start, report that as a blocking issue before writing any tests

package/templates/commands/status.md

@@ -1,15 +0,0 @@
----
-description: "Report current session state — branch, recent changes, pending work"
----
-
-Report current session state:
-- Current task / what you're working on
-- Git branch and recent commits
-- Test status (last run results)
-- Context usage estimate
-- Any blockers or pending decisions
-
-## Trigger Phrases
-- "what's the status"
-- "where am I"
-- "what am I working on"

package/templates/commands/techdebt.md

@@ -1,18 +0,0 @@
----
-description: "Scan codebase for technical debt and report findings"
----
-
-Scan the codebase for technical debt:
-- Duplicated code
-- Dead code (unused functions, imports, variables)
-- TODO/FIXME/HACK comments
-- Overly complex functions
-- Missing tests for critical paths
-- Inconsistent patterns
-
-Report findings organized by severity. Fix quick wins directly.
-
-## Trigger Phrases
-- "find tech debt"
-- "scan for issues"
-- "code quality scan"

package/templates/commands/upstream-check.md

@@ -1,85 +0,0 @@
----
-description: "On-demand check of Anthropic upstream feeds (Claude Code releases, SDK changelogs, blog, status)"
----
-
-Fetch the anthropic-watch feeds and report a concise summary of upstream changes.
-This is a stateless, on-demand status check — no caching, no persistence.
-
-Feed base URL: `https://sefaertunc.github.io/anthropic-watch/feeds/`
-
-## 1. Fetch Run Report
-
-```bash
-curl -s --max-time 10 https://sefaertunc.github.io/anthropic-watch/feeds/run-report.json
-```
-
-If the fetch fails (non-zero exit, empty body, or non-JSON output), report:
-
-```
-Could not reach anthropic-watch feeds.
-```
-
-and stop.
-
-Otherwise, parse the JSON and extract:
-
-- `timestamp` — when the scraper last ran
-- `sources[]` — list of all 16 sources with `{key, name, category, status, newItemCount, error}`
-
-Count how many sources have `status: "ok"` vs errored sources. List each errored source
-with its error message.
-
-## 2. Fetch All Items
-
-```bash
-curl -s --max-time 10 https://sefaertunc.github.io/anthropic-watch/feeds/all.json
-```
-
-Apply the same failure handling.
-
-Otherwise, parse and take the **10 most recent items** (they are already sorted
-newest-first). Group them by `sourceCategory` (`core` vs `extended`).
-
-For each item show:
-
-- Title
-- Source name (`sourceName`)
-- Date (relative like "2 days ago" when you can compute it, otherwise ISO date)
-- URL
-
-## 3. Highlight Claude Code-Critical Items
-
-Any item whose `source` is one of:
-
-- `claude-code-releases`
-- `claude-code-changelog`
-- `npm-claude-code`
-- `agent-sdk-ts-changelog`
-- `agent-sdk-py-changelog`
-
-directly affects scaffolded worclaude infrastructure. Flag these with a `[CRITICAL]`
-prefix in the listing so the user notices them first.
-
-## 4. Closing Summary
-
-End with a single line:
-
-```
-X new items since {timestamp}. Y/16 sources healthy.
-```
-
-Where X is the total item count across all sources (sum of `newItemCount` from the
-run report) and Y is the healthy-source count.
-
-## Rules
-
-- Use only `curl` and shell builtins. Do not invoke `node` or `npm`.
-- Do not cache, persist, or diff against prior runs — this command is stateless.
-- Keep the output concise. This is a status check, not a research report.
-- If both feeds fail, stop after the first failure message.
-
-## Trigger Phrases
-- "check upstream"
-- "what changed in claude code"
-- "any anthropic updates"
-- "upstream status"