jettypod 4.4.0 → 4.4.1

package/docs/DECISIONS.md

@@ -6,61 +6,13 @@ This document records key decisions made during project discovery and epic plann
 
 ## Epic-Level Decisions
 
-### Epic #237: Real-time Collaboration
+### Epic #2: Standalone Chore Workflow System
 
-**Architecture:** WebSockets with Socket.io
+**Architecture:** Two-tier skill structure (chore-planning → chore-mode)
 
-*Rationale:* Bidirectional communication needed, Socket.io provides automatic fallbacks and reconnection
+*Rationale:* Two-tier skill structure chosen to mirror existing feature workflow patterns. Separates planning concerns (scope, criteria, impact) from execution concerns (guidance, verification). Type-dependent test analysis balances thoroughness with pragmatism.
 
-*Date:* 10/29/2025
-
-**State Management:** Redux Toolkit
-
-*Rationale:* Need centralized state for connection status across multiple components
-
-*Date:* 10/29/2025
-
-**Error Handling:** Exponential backoff with jitter for reconnection
-
-*Rationale:* Prevents thundering herd when server recovers, jitter distributes reconnection attempts evenly
-
-*Date:* 10/31/2025
-
-**Testing Strategy:** Integration tests with mock Socket.io server
-
-*Rationale:* Allows testing reconnection logic and state synchronization without real server dependency
-
-*Date:* 10/31/2025
-
----
-
-### Epic #238: Real-time System
-
-**Architecture:** WebSockets
-
-*Rationale:* Real-time bidirectional communication required
-
-*Date:* 10/29/2025
-
----
-
-### Epic #242: Epic Needs Discovery
-
-**Architecture:** GraphQL API
-
-*Rationale:* Flexible querying and strong typing needed for complex data requirements
-
-*Date:* 10/29/2025
-
----
-
-### Epic #1840: Multiple AI Coding Assistant Instances
-
-**Concurrent Merge Architecture:** Database-backed merge queue with rebase-first strategy and smart conflict resolution
-
-*Rationale:* Multiple Claude Code instances need coordinated access to main branch. Using database as coordination point provides simple, reliable serialization without complex distributed locking. Rebase-first strategy ensures linear history and makes conflicts easier to reason about. Smart conflict resolution (auto-resolve trivial, LLM-assist complex) enables autonomous operation while escalating truly ambiguous cases. Graceful degradation ensures system never enters unrecoverable state.
-
-*Date:* 11/14/2025
+*Date:* 11/25/2025
 
 ---
 

package/lib/chore-classifier.js

@@ -0,0 +1,232 @@
+/**
+ * Chore Classifier
+ *
+ * Classifies chore type from title/description using keyword matching.
+ * Maps to the 4 chore types defined in chore-taxonomy.js
+ */
+
+const { CHORE_TYPES, isValidChoreType } = require('./chore-taxonomy');
+
+// Keywords that indicate each chore type
+const TYPE_KEYWORDS = {
+  [CHORE_TYPES.REFACTOR]: [
+    'refactor',
+    'restructure',
+    'reorganize',
+    'extract',
+    'inline',
+    'rename',
+    'move',
+    'split',
+    'consolidate',
+    'simplify',
+    'decouple',
+    'modularize'
+  ],
+  [CHORE_TYPES.DEPENDENCY]: [
+    'update',
+    'upgrade',
+    'bump',
+    'migrate',
+    'dependency',
+    'dependencies',
+    'package',
+    'library',
+    'framework',
+    'version',
+    'security patch',
+    'vulnerability',
+    'npm',
+    'yarn',
+    'lodash',
+    'react',
+    'node'
+  ],
+  [CHORE_TYPES.CLEANUP]: [
+    'cleanup',
+    'clean up',
+    'remove',
+    'delete',
+    'deprecate',
+    'dead code',
+    'unused',
+    'legacy',
+    'obsolete',
+    'prune',
+    'trim'
+  ],
+  [CHORE_TYPES.TOOLING]: [
+    'tooling',
+    'ci',
+    'cd',
+    'pipeline',
+    'build',
+    'lint',
+    'eslint',
+    'prettier',
+    'config',
+    'configuration',
+    'script',
+    'automation',
+    'github action',
+    'workflow',
+    'jest',
+    'test setup'
+  ]
+};
+
+/**
+ * Normalize and validate input text
+ * @param {string} title - The chore title
+ * @param {string} [description] - Optional description
+ * @returns {string} - Normalized text for classification
+ * @throws {Error} - If title is invalid
+ */
+function normalizeInput(title, description = '') {
+  // Validate title
+  if (title === null || title === undefined) {
+    throw new Error('Chore title is required for classification');
+  }
+  if (typeof title !== 'string') {
+    throw new Error(`Chore title must be a string, got ${typeof title}`);
+  }
+
+  const trimmedTitle = title.trim();
+  if (trimmedTitle.length === 0) {
+    throw new Error('Chore title cannot be empty or whitespace only');
+  }
+
+  // Normalize description (coerce to string if not)
+  const normalizedDesc = description != null ? String(description).trim() : '';
+
+  return `${trimmedTitle} ${normalizedDesc}`.toLowerCase();
+}
+
+/**
+ * Escape special regex characters in a string
+ * @param {string} str - String to escape
+ * @returns {string} - Escaped string safe for regex
+ */
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Calculate scores for all chore types
+ * @param {string} text - Normalized text to analyze
+ * @returns {Object} - Scores for each type
+ */
+function calculateScores(text) {
+  const scores = {};
+  for (const [type, keywords] of Object.entries(TYPE_KEYWORDS)) {
+    scores[type] = 0;
+    for (const keyword of keywords) {
+      if (text.includes(keyword.toLowerCase())) {
+        // Exact word match scores higher (escape special chars for safety)
+        const escapedKeyword = escapeRegex(keyword);
+        const wordBoundaryRegex = new RegExp(`\\b${escapedKeyword}\\b`, 'i');
+        if (wordBoundaryRegex.test(text)) {
+          scores[type] += 2;
+        } else {
+          scores[type] += 1;
+        }
+      }
+    }
+  }
+  return scores;
+}
+
+/**
+ * Find the winning type from scores
+ * @param {Object} scores - Scores for each type
+ * @returns {Object} - { type: string, score: number }
+ */
+function findWinningType(scores) {
+  let maxScore = 0;
+  let classifiedType = CHORE_TYPES.REFACTOR; // Default fallback
+
+  for (const [type, score] of Object.entries(scores)) {
+    if (score > maxScore) {
+      maxScore = score;
+      classifiedType = type;
+    }
+  }
+
+  return { type: classifiedType, score: maxScore };
+}
+
+/**
+ * Classify a chore based on its title (and optionally description)
+ * @param {string} title - The chore title
+ * @param {string} [description] - Optional description for additional context
+ * @returns {string} - One of the 4 chore types
+ * @throws {Error} - If title is invalid
+ */
+function classifyChoreType(title, description = '') {
+  const text = normalizeInput(title, description);
+  const scores = calculateScores(text);
+  const { type } = findWinningType(scores);
+  return type;
+}
+
+/**
+ * Determine confidence level based on score
+ * @param {number} score - The classification score
+ * @returns {string} - 'high', 'medium', or 'low'
+ */
+function getConfidenceLevel(score) {
+  if (score >= 4) return 'high';
+  if (score >= 2) return 'medium';
+  return 'low';
+}
+
+/**
+ * Get confidence level for a classification
+ * @param {string} title - The chore title
+ * @param {string} [description] - Optional description
+ * @returns {object} - { type: string, confidence: 'high'|'medium'|'low', score: number }
+ * @throws {Error} - If title is invalid
+ */
+function classifyWithConfidence(title, description = '') {
+  const text = normalizeInput(title, description);
+  const scores = calculateScores(text);
+  const { type, score } = findWinningType(scores);
+  const confidence = getConfidenceLevel(score);
+
+  return { type, confidence, score };
+}
+
+/**
+ * Get detailed classification with all type scores
+ * Useful for debugging or when needing transparency in classification
+ * @param {string} title - The chore title
+ * @param {string} [description] - Optional description
+ * @returns {object} - { type, confidence, score, allScores }
+ * @throws {Error} - If title is invalid
+ */
+function classifyWithDetails(title, description = '') {
+  const text = normalizeInput(title, description);
+  const scores = calculateScores(text);
+  const { type, score } = findWinningType(scores);
+  const confidence = getConfidenceLevel(score);
+
+  return {
+    type,
+    confidence,
+    score,
+    allScores: scores
+  };
+}
+
+module.exports = {
+  classifyChoreType,
+  classifyWithConfidence,
+  classifyWithDetails,
+  TYPE_KEYWORDS,
+  // Expose helpers for testing
+  normalizeInput,
+  escapeRegex,
+  calculateScores,
+  findWinningType,
+  getConfidenceLevel
+};

package/lib/chore-taxonomy.js

@@ -0,0 +1,172 @@
+/**
+ * Chore Type Taxonomy
+ * Defines the 4 chore types and their workflow guidance for the chore-planning and chore-mode skills.
+ */
+
+/**
+ * Chore types
+ * @constant {Object}
+ */
+const CHORE_TYPES = Object.freeze({
+  REFACTOR: 'refactor',
+  DEPENDENCY: 'dependency',
+  CLEANUP: 'cleanup',
+  TOOLING: 'tooling'
+});
+
+/**
+ * Valid chore type values as array
+ * @constant {Array<string>}
+ */
+const VALID_CHORE_TYPES = Object.freeze(Object.values(CHORE_TYPES));
+
+/**
+ * Guidance for each chore type
+ * @constant {Object}
+ */
+const CHORE_TYPE_GUIDANCE = Object.freeze({
+  [CHORE_TYPES.REFACTOR]: {
+    scope: [
+      'Define clear boundaries - what code is being restructured',
+      'Identify all callers/dependents of code being changed',
+      'Ensure behavior remains unchanged (refactor, not rewrite)',
+      'Consider breaking into smaller refactors if scope is large'
+    ],
+    verification: [
+      'All existing tests pass without modification',
+      'No new functionality added (that requires new tests)',
+      'Code review confirms behavior preservation',
+      'Performance is not degraded'
+    ],
+    testHandling: {
+      required: true,
+      approach: 'Run all tests for affected modules before and after. Update test file paths/imports if moved. Do NOT change test assertions - if tests fail, the refactor broke behavior.'
+    }
+  },
+  [CHORE_TYPES.DEPENDENCY]: {
+    scope: [
+      'Identify which packages are being updated',
+      'Check changelogs for breaking changes',
+      'Note any deprecated APIs that need migration',
+      'Consider update strategy: one at a time vs batch'
+    ],
+    verification: [
+      'All tests pass after update',
+      'Application builds successfully',
+      'No new deprecation warnings (or documented)',
+      'Security vulnerabilities addressed (if security update)'
+    ],
+    testHandling: {
+      required: false,
+      approach: 'Run full test suite to catch regressions. No new tests needed unless migrating to new API patterns. Document any test changes needed due to library API changes.'
+    }
+  },
+  [CHORE_TYPES.CLEANUP]: {
+    scope: [
+      'Define what is being cleaned (dead code, unused files, etc.)',
+      'Verify code is actually unused (grep for references)',
+      'Set clear boundaries to avoid scope creep',
+      'Consider impact on git history/blame'
+    ],
+    verification: [
+      'All tests still pass',
+      'No broken imports or references',
+      'Application runs correctly',
+      'Removed code was actually unused'
+    ],
+    testHandling: {
+      required: false,
+      approach: 'Run existing tests to ensure nothing breaks. Remove tests only if they test deleted code. No new tests needed for cleanup work.'
+    }
+  },
+  [CHORE_TYPES.TOOLING]: {
+    scope: [
+      'Define what tooling is being changed (CI, build, dev environment)',
+      'Document current behavior before changes',
+      'Consider impact on team workflows',
+      'Plan rollback strategy if changes cause issues'
+    ],
+    verification: [
+      'CI pipeline passes',
+      'Build completes successfully',
+      'Dev environment works for all team members',
+      'No regression in build times or developer experience'
+    ],
+    testHandling: {
+      required: false,
+      approach: 'Verify tooling changes work via manual testing or CI runs. Add integration tests only if tooling is complex. Focus on verification over unit testing for infrastructure.'
+    }
+  }
+});
+
+/**
+ * Normalize a chore type string (lowercase, trimmed)
+ * @param {string} type - Type to normalize
+ * @returns {string|null} Normalized type or null if input is invalid
+ */
+function normalizeChoreType(type) {
+  if (type === null || type === undefined) {
+    return null;
+  }
+  if (typeof type !== 'string') {
+    return null;
+  }
+  return type.toLowerCase().trim();
+}
+
+/**
+ * Check if a chore type is valid (case-insensitive)
+ * @param {string} type - Type to validate
+ * @returns {boolean} True if type is valid
+ */
+function isValidChoreType(type) {
+  const normalized = normalizeChoreType(type);
+  if (normalized === null) {
+    return false;
+  }
+  return VALID_CHORE_TYPES.includes(normalized);
+}
+
+/**
+ * Get guidance for a chore type
+ * @param {string} type - Chore type (case-insensitive)
+ * @returns {Object} Guidance object with scope, verification, and testHandling
+ * @throws {Error} If type is null, undefined, or invalid
+ */
+function getGuidance(type) {
+  if (type === null || type === undefined) {
+    throw new Error(
+      'Chore type is required. Valid types: refactor, dependency, cleanup, tooling'
+    );
+  }
+
+  const normalized = normalizeChoreType(type);
+
+  if (!normalized || !VALID_CHORE_TYPES.includes(normalized)) {
+    throw new Error(
+      `Invalid chore type: "${type}". Valid types: refactor, dependency, cleanup, tooling`
+    );
+  }
+
+  return CHORE_TYPE_GUIDANCE[normalized];
+}
+
+/**
+ * Get all chore types
+ * @returns {Array<string>} Array of valid chore types
+ */
+function getChoreTypes() {
+  return [...VALID_CHORE_TYPES];
+}
+
+module.exports = {
+  CHORE_TYPES,
+  VALID_CHORE_TYPES,
+  CHORE_TYPE_GUIDANCE,
+  normalizeChoreType,
+  isValidChoreType,
+  getGuidance,
+  getChoreTypes,
+  // Alias for step definitions
+  types: CHORE_TYPES
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.0",
+  "version": "4.4.1",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {

package/skills-templates/chore-mode/SKILL.md

@@ -0,0 +1,396 @@
+---
+name: chore-mode
+description: Guide implementation of standalone chores with type-appropriate guidance, verification steps, and test handling. Receives enriched context from chore-planning and executes with iteration until verification passes.
+---
+
+# Chore Mode Skill
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  Standalone Chore Execution                                         │
+│                                                                      │
+│  chore-planning → [CHORE MODE] → Done                               │
+│                    ▲▲▲▲▲▲▲▲▲▲▲                                      │
+│                    YOU ARE HERE                                      │
+│                                                                      │
+│  Chores are focused tasks - no speed/stable/production progression. │
+│  Execute once with type-appropriate verification, then done.        │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+Guides Claude Code through chore execution with type-specific guidance, test handling, and verification criteria from the chore taxonomy.
+
+## Instructions
+
+When this skill is activated, you are executing a standalone chore. The chore-planning skill has already classified the type and built enriched context. Follow this structured approach:
+
+### Overview
+
+**Chore Mode Goal:** Execute the chore according to type-specific guidance and verify completion using taxonomy criteria.
+
+**Key Principles:**
+- **Type-aware execution** - Different chore types have different test handling and verification
+- **Guided verification** - Use taxonomy verification checklist, not arbitrary checks
+- **Iteration with limits** - Max 5 iterations to achieve verification
+- **No mode progression** - Chores don't have speed/stable/production phases
+
+**Chore Types Quick Reference:**
+
+| Type | Test Handling | Key Constraint |
+|------|---------------|----------------|
+| refactor | Affected tests only | Do NOT modify test assertions |
+| dependency | Full test suite | Check for deprecation warnings |
+| cleanup | Affected tests | Verify code is actually unused |
+| tooling | CI/manual verification | Focus on verification over unit tests |
+
+---
+
+## Implementation Steps
+
+### Step 1: Receive and Display Context
+
+**Your task:** Acknowledge the context passed from chore-planning.
+
+You will receive:
+- `choreContext.chore` - Chore ID, title, description
+- `choreContext.classification` - Type and confidence
+- `choreContext.guidance` - Scope, verification, testHandling from taxonomy
+- `choreContext.implementationPlan` - Files to modify, affected tests
+
+**Display:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔧 Chore Mode: [Chore Title]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Type: [TYPE] (confidence: [high/medium/low])
+Chore ID: #[id]
+
+Implementation Plan:
+• Files to modify: [list from context]
+• Affected tests: [list from context]
+```
+
+**Move to Step 2 automatically.**
+
+### Step 2: Create Worktree
+
+**Your task:** Create an isolated worktree for this chore.
+
+```bash
+jettypod work start [chore-id]
+```
+
+This creates a worktree at `.jettypod-work/[id]-[title-slug]` and switches to a new branch.
+
+**Display:**
+
+```
+📁 Worktree created: .jettypod-work/[id]-[title-slug]
+Branch: chore-[id]-[title-slug]
+```
+
+**Move to Step 3 automatically.**
+
+### Step 3: Establish Test Baseline
+
+**Your task:** Run tests to establish baseline before making changes.
+
+**Test handling varies by type:**
+
+**For REFACTOR:**
+```bash
+# Run only affected module tests
+npm test -- [affected-test-patterns]
+```
+
+**For DEPENDENCY:**
+```bash
+# Run full test suite
+npm test
+```
+
+**For CLEANUP:**
+```bash
+# Run affected tests
+npm test -- [affected-test-patterns]
+```
+
+**For TOOLING:**
+```bash
+# Run CI pipeline or specific verification
+# (may not have unit tests)
+```
+
+**Display:**
+
+```
+🧪 Establishing test baseline...
+
+Baseline Result:
+  Tests: [X] passing / [Y] total
+  Execution time: [Z]s
+
+✅ Baseline established - all tests passing
+```
+
+**CRITICAL:** If baseline tests fail, STOP. Fix existing failures before proceeding with chore work.
+
+**Move to Step 4 automatically.**
+
+### Step 4: Display Type-Specific Guidance
+
+**Your task:** Display warnings and constraints based on chore type.
+
+**Load guidance from taxonomy:**
+
+```javascript
+const { getGuidance } = require('./lib/chore-taxonomy');
+const guidance = getGuidance('[chore-type]');
+```
+
+**Display type-specific warnings:**
+
+**For REFACTOR:**
+```
+⚠️  REFACTOR CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• All existing tests MUST pass WITHOUT modification
+• If tests fail, the refactor broke behavior - FIX THE CODE, not the tests
+• No new functionality - this is restructuring only
+• Behavior must be preserved exactly
+```
+
+**For DEPENDENCY:**
+```
+⚠️  DEPENDENCY CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Run FULL test suite to catch regressions
+• Check for deprecation warnings after update
+• Review changelog for breaking changes
+• Update code if API changed
+```
+
+**For CLEANUP:**
+```
+⚠️  CLEANUP CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• VERIFY code is actually unused before deleting
+• Search for all references (grep for function names)
+• Remove tests ONLY if they test deleted code
+• Check for dynamic references (string-based imports)
+```
+
+**For TOOLING:**
+```
+⚠️  TOOLING CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Verify via CI run or manual testing
+• Focus on verification over unit testing
+• Document current behavior before changes
+• Plan rollback strategy
+```
+
+**Move to Step 5 automatically.**
+
+### Step 5: Execute with Iteration
+
+**Your task:** Make changes and iterate until tests pass. Max 5 iterations.
+
+```
+━━━ Iteration [N]/5 ━━━
+
+✍️  Making changes...
+[Describe what you're changing]
+
+🧪 Running tests...
+```
+
+**On each iteration:**
+1. Make focused changes based on implementation plan
+2. Run appropriate tests (type-dependent)
+3. Check results
+
+**Display progress:**
+
+```
+📊 Progress: [X]/[Y] tests passing
+
+✅ Newly passing:
+  • [test name]
+
+❌ Still failing:
+  • [test name]: [brief error]
+
+🔧 Next: [what you'll fix]
+```
+
+**Exit conditions:**
+- ✅ All tests pass → Move to Step 6
+- ❌ Max iterations reached → Display failure, ask user for guidance
+
+**On max iterations:**
+
+```
+⚠️  Maximum iterations (5) reached
+
+Final Progress: [X]/[Y] tests passing
+
+Still failing:
+  • [test name]: [error]
+
+Options:
+1. Review implementation approach
+2. Break into smaller changes
+3. Get user guidance
+
+What would you like to do?
+```
+
+**STOP and wait for user input if max iterations reached.**
+
+### Step 6: Run Verification Checklist
+
+**Your task:** Run through type-specific verification criteria from taxonomy.
+
+**Load verification from taxonomy:**
+
+```javascript
+const { getGuidance } = require('./lib/chore-taxonomy');
+const guidance = getGuidance('[chore-type]');
+// guidance.verification contains the checklist
+```
+
+**Display and verify each item:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 Verification Checklist
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+[✅/❌] All existing tests pass without modification
+[✅/❌] No new functionality added
+[✅/❌] Code review confirms behavior preservation
+[✅/❌] Performance is not degraded
+```
+
+**Verification methods:**
+- **Tests pass**: Run `npm test` and check exit code
+- **No new functionality**: Review diff for new features
+- **Behavior preservation**: Compare before/after behavior
+- **Performance**: Run benchmarks if applicable
+
+**If any verification fails:**
+
+```
+❌ Verification failed:
+  • [failed item]: [reason]
+
+Returning to iteration loop...
+```
+
+Go back to Step 5 to fix issues.
+
+**If all verification passes → Move to Step 7.**
+
+### Step 7: Complete and Merge
+
+**Your task:** Commit changes and merge to main.
+
+```bash
+# Stage and commit
+git add .
+git commit -m "chore: [brief description]"
+git push
+
+# Merge to main (auto-marks chore done)
+jettypod work merge
+```
+
+**Display:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Chore Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Type: [TYPE]
+Iterations: [N]/5
+Tests: [X]/[Y] passing
+
+Verification:
+✅ All existing tests pass without modification
+✅ No new functionality added
+✅ Code review confirms behavior preservation
+✅ Performance is not degraded
+
+Merged to main. Chore #[id] marked done.
+```
+
+**End skill.**
+
+---
+
+## Error Handling
+
+### Baseline Tests Fail
+```
+❌ Cannot proceed - baseline tests failing
+
+[X] tests failing before chore work started.
+Fix existing test failures before proceeding.
+
+Failing tests:
+  • [test name]: [error]
+```
+
+### Verification Loop
+If verification fails repeatedly (3+ times on same item):
+```
+⚠️  Verification stuck on: [item]
+
+This has failed [N] times. Options:
+1. Review the implementation approach
+2. Check if this verification is applicable
+3. Ask user for guidance
+```
+
+### Worktree Issues
+```
+❌ Worktree creation failed
+
+Error: [message]
+
+Try:
+  jettypod work cleanup
+  jettypod work start [chore-id]
+```
+
+---
+
+## Type Reference
+
+### REFACTOR
+- **Goal:** Restructure code without changing behavior
+- **Tests:** Affected modules only
+- **Key rule:** NEVER modify test assertions
+- **Verification:** Tests pass, behavior unchanged
+
+### DEPENDENCY
+- **Goal:** Update packages safely
+- **Tests:** Full suite
+- **Key rule:** Check changelogs for breaking changes
+- **Verification:** Tests pass, no deprecation warnings
+
+### CLEANUP
+- **Goal:** Remove unused code
+- **Tests:** Affected modules
+- **Key rule:** Verify code is actually unused
+- **Verification:** No broken references, tests pass
+
+### TOOLING
+- **Goal:** Improve build/CI/dev tools
+- **Tests:** CI pipeline or manual
+- **Key rule:** Plan rollback strategy
+- **Verification:** CI passes, workflows work

package/skills-templates/chore-mode/verification.js

@@ -0,0 +1,255 @@
+/**
+ * Type-specific verification runner for chore-mode skill
+ * Runs verification checklist from chore taxonomy based on chore type
+ */
+
+const { getGuidance, CHORE_TYPES } = require('../../../lib/chore-taxonomy');
+
+/**
+ * Create a verification check result
+ *
+ * @param {string} description - What is being verified
+ * @param {boolean} passed - Whether the check passed
+ * @param {string} [details] - Additional details or failure reason
+ * @returns {{description: string, passed: boolean, details?: string}}
+ */
+function createCheck(description, passed, details = null) {
+  const check = { description, passed };
+  if (details) check.details = details;
+  return check;
+}
+
+/**
+ * Run all verification checks for a chore type
+ *
+ * @param {string} type - Chore type (refactor, dependency, cleanup, tooling)
+ * @param {object} context - Context about the chore execution
+ * @param {object} context.testResult - Test execution result
+ * @param {boolean} context.testResult.passed - Whether tests passed
+ * @param {number} context.testResult.total - Total tests run
+ * @param {boolean} [context.testsModified] - Whether test assertions were changed
+ * @param {boolean} [context.newFunctionalityAdded] - Whether new features were added
+ * @param {string[]} [context.deprecationWarnings] - Any deprecation warnings found
+ * @param {boolean} [context.unusedCodeVerified] - Whether code was verified unused
+ * @param {boolean} [context.ciPassed] - Whether CI pipeline passed
+ * @returns {{passed: boolean, checks: Array<{description: string, passed: boolean, details?: string}>}}
+ */
+function runVerificationChecklist(type, context = {}) {
+  const guidance = getGuidance(type);
+  const checks = [];
+  let allPassed = true;
+
+  // Run type-specific verification based on taxonomy criteria
+  switch (type) {
+    case CHORE_TYPES.REFACTOR:
+      checks.push(...runRefactorChecks(guidance, context));
+      break;
+
+    case CHORE_TYPES.DEPENDENCY:
+      checks.push(...runDependencyChecks(guidance, context));
+      break;
+
+    case CHORE_TYPES.CLEANUP:
+      checks.push(...runCleanupChecks(guidance, context));
+      break;
+
+    case CHORE_TYPES.TOOLING:
+      checks.push(...runToolingChecks(guidance, context));
+      break;
+
+    default:
+      checks.push(createCheck(
+        'Valid chore type',
+        false,
+        `Unknown type: ${type}`
+      ));
+  }
+
+  // Calculate overall pass/fail
+  allPassed = checks.every(check => check.passed);
+
+  return {
+    passed: allPassed,
+    checks
+  };
+}
+
+/**
+ * Run refactor-specific verification checks
+ */
+function runRefactorChecks(guidance, context) {
+  const checks = [];
+
+  // "All existing tests pass without modification"
+  checks.push(createCheck(
+    'All existing tests pass without modification',
+    context.testResult?.passed === true,
+    context.testResult?.passed ? null : 'Tests failed - refactor may have broken behavior'
+  ));
+
+  // Check if tests were modified (should NOT be)
+  checks.push(createCheck(
+    'No test assertions modified',
+    context.testsModified !== true,
+    context.testsModified ? 'Test assertions were changed - this violates refactor rules' : null
+  ));
+
+  // "No new functionality added"
+  checks.push(createCheck(
+    'No new functionality added',
+    context.newFunctionalityAdded !== true,
+    context.newFunctionalityAdded ? 'New functionality detected - this should be a feature, not a refactor' : null
+  ));
+
+  // "Performance is not degraded" - assumed pass unless context indicates otherwise
+  checks.push(createCheck(
+    'Performance not degraded',
+    context.performanceDegraded !== true,
+    context.performanceDegraded ? 'Performance regression detected' : null
+  ));
+
+  return checks;
+}
+
+/**
+ * Run dependency-specific verification checks
+ */
+function runDependencyChecks(guidance, context) {
+  const checks = [];
+
+  // "All tests pass after update"
+  checks.push(createCheck(
+    'All tests pass after update',
+    context.testResult?.passed === true,
+    context.testResult?.passed ? null : 'Tests failed after dependency update'
+  ));
+
+  // "Application builds successfully" - assumed from test pass
+  checks.push(createCheck(
+    'Application builds successfully',
+    context.buildPassed !== false,
+    context.buildPassed === false ? 'Build failed' : null
+  ));
+
+  // "No new deprecation warnings"
+  const hasDeprecations = context.deprecationWarnings && context.deprecationWarnings.length > 0;
+  checks.push(createCheck(
+    'No new deprecation warnings (or documented)',
+    !hasDeprecations || context.deprecationsDocumented === true,
+    hasDeprecations && !context.deprecationsDocumented
+      ? `Found ${context.deprecationWarnings.length} deprecation warnings`
+      : null
+  ));
+
+  return checks;
+}
+
+/**
+ * Run cleanup-specific verification checks
+ */
+function runCleanupChecks(guidance, context) {
+  const checks = [];
+
+  // "All tests still pass"
+  checks.push(createCheck(
+    'All tests still pass',
+    context.testResult?.passed === true,
+    context.testResult?.passed ? null : 'Tests failed after cleanup'
+  ));
+
+  // "No broken imports or references"
+  checks.push(createCheck(
+    'No broken imports or references',
+    context.brokenReferences !== true,
+    context.brokenReferences ? 'Broken references found' : null
+  ));
+
+  // "Removed code was actually unused"
+  checks.push(createCheck(
+    'Removed code was verified unused',
+    context.unusedCodeVerified === true,
+    context.unusedCodeVerified ? null : 'Code usage was not verified before removal'
+  ));
+
+  return checks;
+}
+
+/**
+ * Run tooling-specific verification checks
+ */
+function runToolingChecks(guidance, context) {
+  const checks = [];
+
+  // "CI pipeline passes"
+  checks.push(createCheck(
+    'CI pipeline passes',
+    context.ciPassed === true,
+    context.ciPassed ? null : 'CI not verified or failed'
+  ));
+
+  // "Build completes successfully"
+  checks.push(createCheck(
+    'Build completes successfully',
+    context.buildPassed !== false,
+    context.buildPassed === false ? 'Build failed' : null
+  ));
+
+  // "No regression in build times or developer experience"
+  checks.push(createCheck(
+    'No regression in build times/DX',
+    context.dxRegression !== true,
+    context.dxRegression ? 'Developer experience regression detected' : null
+  ));
+
+  return checks;
+}
+
+/**
+ * Format verification results for display
+ *
+ * @param {{passed: boolean, checks: Array}} result - Verification result
+ * @returns {string} Formatted string for display
+ */
+function formatVerificationResult(result) {
+  const lines = [];
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  lines.push('🔍 Verification Checklist');
+  lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  lines.push('');
+
+  for (const check of result.checks) {
+    const icon = check.passed ? '✅' : '❌';
+    lines.push(`${icon} ${check.description}`);
+    if (check.details) {
+      lines.push(`   └─ ${check.details}`);
+    }
+  }
+
+  lines.push('');
+  if (result.passed) {
+    lines.push('✅ All verification checks passed');
+  } else {
+    const failedCount = result.checks.filter(c => !c.passed).length;
+    lines.push(`❌ ${failedCount} verification check(s) failed`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Get verification criteria from taxonomy for display
+ *
+ * @param {string} type - Chore type
+ * @returns {string[]} Array of verification criteria strings
+ */
+function getVerificationCriteria(type) {
+  const guidance = getGuidance(type);
+  return guidance.verification || [];
+}
+
+module.exports = {
+  runVerificationChecklist,
+  formatVerificationResult,
+  getVerificationCriteria,
+  createCheck
+};

package/skills-templates/chore-planning/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: chore-planning
+description: Guide standalone chore planning with automatic type classification, taxonomy guidance loading, and routing to chore-mode for execution. Use when user starts a standalone chore (chore with no parent feature), mentions planning a chore, or says "help me with this chore".
+---
+
+# Chore Planning Skill
+
+Guides Claude through standalone chore planning including automatic type classification, loading type-specific guidance from the taxonomy, building enriched context, and routing to chore-mode for execution.
+
+## Instructions
+
+When this skill is activated, you are helping plan a standalone chore (one without a parent feature). Follow this structured approach:
+
+### Step 1: Understand the Chore Context
+
+You'll receive context about:
+- Chore title and description
+- Project context
+- No parent feature (standalone chores don't have features)
+
+Display:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔧 Planning Standalone Chore
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Chore:** [Title]
+**Description:** [Description if provided]
+
+Analyzing chore type...
+```
+
+### Step 2: Classify Chore Type
+
+**CRITICAL:** Use the chore-classifier to determine the chore type automatically.
+
+**Execute this code:**
+
+```javascript
+const { classifyChoreType, classifyWithConfidence } = require('./lib/chore-classifier');
+
+const choreTitle = '[chore title]';
+const choreDescription = '[chore description or empty string]';
+
+const classification = classifyWithConfidence(choreTitle, choreDescription);
+console.log('Classification:', JSON.stringify(classification, null, 2));
+```
+
+Display the classification result:
+
+```
+**Type Classification:** [type] (confidence: [high/medium/low])
+```
+
+**If confidence is low:**
+```
+⚠️ Low confidence classification. The chore might be:
+- [type] - because [reason based on keywords found]
+- [alternative type] - if [alternative interpretation]
+
+Proceeding with [type]. Let me know if this should be different.
+```
+
+### Step 3: Load Taxonomy Guidance
+
+**Execute this code to load type-specific guidance:**
+
+```javascript
+const { getGuidance } = require('./lib/chore-taxonomy');
+
+const guidance = getGuidance('[classified-type]');
+console.log('Guidance:', JSON.stringify(guidance, null, 2));
+```
+
+Display the guidance:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📋 [Type] Chore Guidance
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Scope Considerations:**
+[List each scope item from guidance]
+
+**Verification Criteria:**
+[List each verification item from guidance]
+
+**Test Handling:**
+- Tests required: [yes/no]
+- Approach: [testHandling.approach]
+```
+
+### Step 4: Build Enriched Context
+
+Combine all information into a structured context object:
+
+```javascript
+const choreContext = {
+  chore: {
+    id: [chore-id],
+    title: '[title]',
+    description: '[description]',
+    type: 'chore',
+    parent_id: null  // standalone
+  },
+  classification: {
+    type: '[classified-type]',
+    confidence: '[high/medium/low]'
+  },
+  guidance: {
+    scope: [...],
+    verification: [...],
+    testHandling: {
+      required: true/false,
+      approach: '...'
+    }
+  }
+};
+```
+
+### Step 5: Analyze Codebase Impact
+
+Based on the chore type and guidance, analyze what needs to be done:
+
+**For REFACTOR chores:**
+- Identify the code being restructured
+- Find all callers/dependents
+- List affected test files
+
+**For DEPENDENCY chores:**
+- Check current version
+- Review changelog for breaking changes
+- Identify affected code
+
+**For CLEANUP chores:**
+- Find all references to code being removed
+- Verify nothing depends on it
+- List files to modify
+
+**For TOOLING chores:**
+- Check current tool configuration
+- Identify affected workflows
+- Review CI/CD impacts
+
+Display analysis:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 Impact Analysis
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Files to modify:**
+[List of files]
+
+**Tests to run:**
+[List of test files/patterns]
+
+**Verification steps:**
+[Specific steps based on guidance]
+```
+
+### Step 6: Create Implementation Plan
+
+Based on the analysis, create a focused plan:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📝 Implementation Plan
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+**Step 1:** [First action]
+**Step 2:** [Second action]
+...
+
+**Verification:**
+1. [First check from guidance]
+2. [Second check from guidance]
+...
+
+Ready to proceed?
+```
+
+### Step 7: Route to Chore Mode
+
+**WAIT for user confirmation.**
+
+When user confirms (responds with "yes", "proceed", "let's go", etc.):
+
+**Invoke the chore-mode skill using the Skill tool:**
+
+```
+Use the Skill tool with skill: "chore-mode"
+```
+
+The chore-mode skill will:
+1. Create a worktree for the chore
+2. Execute the implementation plan
+3. Run verification steps
+4. Merge when complete
+
+**End chore-planning skill after invoking chore-mode.**
+
+## Key Principles
+
+1. **Automatic classification** - AI determines chore type from title/description
+2. **Taxonomy-driven guidance** - Load specific guidance for each chore type
+3. **Context enrichment** - Build complete context before execution
+4. **Impact analysis** - Understand what the chore affects
+5. **Verification-focused** - Use type-specific verification criteria
+6. **Seamless handoff** - Route to chore-mode with full context
+
+## Chore Type Quick Reference
+
+| Type | Keywords | Test Handling |
+|------|----------|---------------|
+| refactor | refactor, restructure, extract, rename | Run all tests, don't modify assertions |
+| dependency | update, upgrade, bump, migrate | Run full suite, check for deprecations |
+| cleanup | remove, delete, unused, legacy | Verify no references, run affected tests |
+| tooling | ci, build, lint, config | Run affected pipelines |
+
+## Validation
+
+Before routing to chore-mode, ensure:
+- [ ] Chore type classified
+- [ ] Taxonomy guidance loaded
+- [ ] Impact analysis complete
+- [ ] Implementation plan created
+- [ ] User confirmed ready to proceed

package/skills-templates/epic-planning/SKILL.md

@@ -159,13 +159,21 @@ Once features are defined and architectural decision is made (if needed):
 
 #### Step 6A: Create Features
 
-Use the Bash tool to create each feature:
+**CRITICAL:** You MUST pass the `--parent=<epic-id>` flag with the actual numeric epic ID. Without this, features won't appear under the epic in the backlog tree.
+
+Use the Bash tool to create each feature. Replace `<EPIC_ID>` with the actual epic ID number:
 
 ```javascript
-// For each feature, use Bash tool to execute:
-node jettypod.js work create feature "[Feature 1]" "[Description]" --parent=[epic-id]
-node jettypod.js work create feature "[Feature 2]" "[Description]" --parent=[epic-id]
-// etc.
+// CORRECT - uses actual numeric epic ID:
+node jettypod.js work create feature "Live cursor tracking" "Track cursor positions in real-time" --parent=5
+
+// WRONG - missing parent flag (feature won't be under epic):
+node jettypod.js work create feature "Live cursor tracking" "Track cursor positions in real-time"
+```
+
+For each feature, execute:
+```bash
+node jettypod.js work create feature "<Title>" "<Description>" --parent=<EPIC_ID>
 ```
 
 Display to user as you create each one:

package/skills-templates/feature-planning/SKILL.md

@@ -331,11 +331,16 @@ node jettypod.js work implement [feature-id] \
 
 **CRITICAL: NOW create the chores.** The feature has transitioned to implementation mode, so chore creation will succeed.
 
-For each chore that the user confirmed in Step 7, use the Bash tool to create it:
+**IMPORTANT:** You MUST pass `--parent=<FEATURE_ID>` with the actual numeric feature ID. Without this, chores won't be linked to the feature.
+
+For each chore that the user confirmed in Step 7, use the Bash tool to create it. Replace `<FEATURE_ID>` with the actual feature ID number:
 
 ```bash
-# Use Bash tool to execute for each chore:
-node jettypod.js work create chore "[Chore title]" "[Chore description with all the implementation guidance]" --parent=[feature-id]
+# CORRECT - uses actual numeric feature ID:
+node jettypod.js work create chore "Implement cursor position broadcast" "Broadcast cursor positions..." --parent=12
+
+# WRONG - missing parent flag (chore won't be linked to feature):
+node jettypod.js work create chore "Implement cursor position broadcast" "Broadcast cursor positions..."
 ```
 
 **Build the description from your Step 7 proposal:**