@pennyfarthing/core 9.0.0 → 9.1.2

package/README.md

@@ -1,6 +1,6 @@
 # Pennyfarthing
 
-**v8.1.0** | *The outer loop goes once, the inner loop goes many times.*
+**v9.1.2** | *The outer loop goes once, the inner loop goes many times.*
 
 <img src="pennyfarthing.png" alt="Pennyfarthing Logo" width="75" style="float:left; margin:10px">
 
@@ -15,9 +15,9 @@ A Claude Code agent orchestration framework built around three pillars: a flexib
 A multi-agent system with customizable BikeLane workflows for structured software development:
 
 - **19 Coordinated Agents** - SM, TEA, Dev, Reviewer, Architect, PM, and more
-- **19 BikeLane Workflows** - Phased (TDD, BDD, Trivial), Stepped (PRD, Architecture), Procedural (Brainstorming, Retrospective)
-- **45 Slash Commands** - Entry points for agent activation and workflows
-- **22 Skills** - Reusable knowledge domains (testing, code-review, jira, mermaid, etc.)
+- **24 BikeLane Workflows** - Phased (TDD, BDD, Trivial), Stepped (PRD, Architecture), Procedural (Brainstorming, Retrospective)
+- **48 Slash Commands** - Entry points for agent activation and workflows
+- **24 Skills** - Reusable knowledge domains (testing, code-review, jira, mermaid, etc.)
 - **Automatic Handoffs** - Context-aware agent transitions via subagent delegation
 
 ### 2. Personality Research
@@ -37,7 +37,7 @@ Smoothing out development processes:
 
 - **Jira Integration** - Bidirectional sync, epic auto-creation, sprint velocity
 - **Sprint Management** - Story tracking with `current-sprint.yaml`
-- **Cyclist Visual Terminal** - Rich UI with agent portraits, session stats, workflow visualization
+- **Cyclist Visual Terminal** - React UI with Dockview panels, agent portraits, tool visualization
 
 ---
 
@@ -100,7 +100,7 @@ BikeLane is the umbrella workflow system supporting three types:
 | **Dev** | Developer | Make tests pass (GREEN) |
 | **Reviewer** | Code Reviewer | Quality validation, approve/reject |
 
-Use `/workflow list` to see all 19 workflows. Use `/workflow start <name>` to begin any workflow.
+Use `/workflow list` to see all 24 workflows. Use `/workflow start <name>` to begin any workflow.
 
 ## Benchmarking & Personality Research
 
@@ -192,7 +192,16 @@ your-project/
     └── {story-id}-session.md # Active work session
 ```
 
-## What's New in v7.6
+## What's New in v9.0
+
+- **Dockview Panel System** - Draggable, floatable, splittable panels replacing hand-rolled system (ADR-0019)
+- **React UI** - Full React component architecture for Cyclist
+- **Tool Use Visualization** - Human-readable tool summaries, collapsible results, tool stacking
+- **useMarkdownParser Hook** - React hook for markdown rendering (vanilla JS migration)
+- **Bell Mode** - Queue messages while Claude works (ADR-0016)
+- **Relay Mode** - Automatic agent handoffs (ADR-0017)
+
+### Previous Highlights (v7.6-v8.x)
 
 - **BikeLane Workflow System** - Unified umbrella for Phased, Stepped, and Procedural workflows
 - **BMAD 6.0 Compatibility** - Full import support for BMAD workflows with tri-modal execution

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pennyfarthing/core",
-  "version": "9.0.0",
+  "version": "9.1.2",
   "description": "Claude Code agent framework with TDD workflow and persona system",
   "type": "module",
   "bin": {

package/packages/core/dist/cli/commands/doctor.d.ts

@@ -17,8 +17,11 @@ export declare function doctorCommand(options: DoctorOptions): Promise<void>;
  */
 export declare function checkLegacyFiles(projectRoot: string): CheckResult[];
 /**
- * Check if settings.local.json has a legacy statusline path.
- * Returns result with fix function to update to canonical path.
+ * Check if settings.local.json has statusline configured.
+ * The statusLine config is a TOP-LEVEL key (not inside hooks), with structure:
+ * { "statusLine": { "type": "command", "command": "path/to/script" } }
+ *
+ * Returns result with fix function to update to canonical path if needed.
  */
 export declare function checkLegacyStatuslinePath(projectRoot: string): CheckResult;
 export {};

package/packages/core/dist/cli/commands/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/doctor.ts"],"names":[],"mappings":"AAoBA,UAAU,aAAa;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgHzE;AA61BD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,EAAE,CA0CnE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,CAoE1E"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/doctor.ts"],"names":[],"mappings":"AAoBA,UAAU,aAAa;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAgHzE;AA+qCD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,EAAE,CA0CnE;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,CAkF1E"}

package/packages/core/dist/cli/commands/doctor.js

@@ -318,6 +318,15 @@ function checkUserFiles(projectRoot) {
         // Check benchmark permissions (needed for /benchmark, /solo subagents)
         const benchmarkCheck = checkBenchmarkPermissions(projectRoot);
         results.push(benchmarkCheck);
+        // Check PreToolUse hooks for context-circuit-breaker
+        const circuitBreakerCheck = checkContextCircuitBreaker(projectRoot, installationType);
+        results.push(circuitBreakerCheck);
+        // Check PreToolUse hooks for schema-validation
+        const schemaValidationCheck = checkSchemaValidationHook(projectRoot, installationType);
+        results.push(schemaValidationCheck);
+        // Check PostToolUse hooks for sprint-yaml-validation
+        const sprintYamlValidationCheck = checkSprintYamlValidationHook(projectRoot, installationType);
+        results.push(sprintYamlValidationCheck);
     }
     return results;
 }
@@ -499,6 +508,182 @@ function checkStopHook(projectRoot, installationType) {
         };
     }
 }
+/**
+ * Check that context-circuit-breaker hook is configured in PreToolUse
+ * This is needed to prevent context exhaustion (auto-saves session)
+ */
+function checkContextCircuitBreaker(projectRoot, installationType) {
+    const settingsPath = join(projectRoot, '.claude/settings.local.json');
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        // Check if hooks.PreToolUse exists and contains context-circuit-breaker
+        if (!settings.hooks?.PreToolUse) {
+            return {
+                name: 'settings/context-circuit-breaker',
+                status: 'warn',
+                detail: 'Missing PreToolUse hooks - context circuit breaker not configured',
+                fix: () => {
+                    addContextCircuitBreaker(projectRoot, installationType);
+                }
+            };
+        }
+        // Check if context-circuit-breaker is configured
+        const hasCircuitBreaker = settings.hooks.PreToolUse.some((entry) => {
+            if (typeof entry === 'object' && entry !== null) {
+                const hookEntry = entry;
+                return hookEntry.hooks?.some(h => h.command?.includes('context-circuit-breaker'));
+            }
+            return false;
+        });
+        if (!hasCircuitBreaker) {
+            return {
+                name: 'settings/context-circuit-breaker',
+                status: 'warn',
+                detail: 'context-circuit-breaker not configured - context exhaustion protection disabled',
+                fix: () => {
+                    addContextCircuitBreaker(projectRoot, installationType);
+                }
+            };
+        }
+        return {
+            name: 'settings/context-circuit-breaker',
+            status: 'pass',
+            detail: undefined
+        };
+    }
+    catch {
+        return {
+            name: 'settings/context-circuit-breaker',
+            status: 'warn',
+            detail: 'Could not parse settings.local.json'
+        };
+    }
+}
+/**
+ * Fix function: Add context-circuit-breaker hook to PreToolUse in settings.local.json
+ */
+function addContextCircuitBreaker(projectRoot, installationType) {
+    const settingsPath = join(projectRoot, '.claude/settings.local.json');
+    const scriptBase = getScriptBasePath(installationType);
+    const requiredHook = {
+        matcher: 'Edit|Write|Bash|Task',
+        hooks: [
+            {
+                type: 'command',
+                command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/hooks/context-circuit-breaker.sh`
+            }
+        ]
+    };
+    let settings = {};
+    if (pathExists(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            // Start fresh if parse fails
+        }
+    }
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    if (!hooks.PreToolUse) {
+        hooks.PreToolUse = [requiredHook];
+    }
+    else if (Array.isArray(hooks.PreToolUse)) {
+        // Append the required hook (circuit breaker should run last)
+        hooks.PreToolUse = [...hooks.PreToolUse, requiredHook];
+    }
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
+/**
+ * Check that schema-validation hook is configured in PreToolUse
+ * This validates XML schema for session/skill/step files on Write
+ */
+function checkSchemaValidationHook(projectRoot, installationType) {
+    const settingsPath = join(projectRoot, '.claude/settings.local.json');
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        // Check if hooks.PreToolUse exists
+        if (!settings.hooks?.PreToolUse) {
+            return {
+                name: 'settings/schema-validation',
+                status: 'warn',
+                detail: 'Missing PreToolUse hooks - schema validation not configured',
+                fix: () => {
+                    addSchemaValidationHook(projectRoot, installationType);
+                }
+            };
+        }
+        // Check if schema-validation is configured
+        const hasSchemaValidation = settings.hooks.PreToolUse.some((entry) => {
+            if (typeof entry === 'object' && entry !== null) {
+                const hookEntry = entry;
+                return hookEntry.hooks?.some(h => h.command?.includes('schema-validation'));
+            }
+            return false;
+        });
+        if (!hasSchemaValidation) {
+            return {
+                name: 'settings/schema-validation',
+                status: 'warn',
+                detail: 'schema-validation not configured - XML schema enforcement disabled',
+                fix: () => {
+                    addSchemaValidationHook(projectRoot, installationType);
+                }
+            };
+        }
+        return {
+            name: 'settings/schema-validation',
+            status: 'pass',
+            detail: undefined
+        };
+    }
+    catch {
+        return {
+            name: 'settings/schema-validation',
+            status: 'warn',
+            detail: 'Could not parse settings.local.json'
+        };
+    }
+}
+/**
+ * Fix function: Add schema-validation hook to PreToolUse in settings.local.json
+ */
+function addSchemaValidationHook(projectRoot, installationType) {
+    const settingsPath = join(projectRoot, '.claude/settings.local.json');
+    const scriptBase = getScriptBasePath(installationType);
+    const requiredHook = {
+        matcher: 'Write',
+        hooks: [
+            {
+                type: 'command',
+                command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/hooks/schema-validation.sh`
+            }
+        ]
+    };
+    let settings = {};
+    if (pathExists(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            // Start fresh if parse fails
+        }
+    }
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    if (!hooks.PreToolUse) {
+        hooks.PreToolUse = [requiredHook];
+    }
+    else if (Array.isArray(hooks.PreToolUse)) {
+        // Insert schema validation early (after pre-edit-check but before circuit breaker)
+        hooks.PreToolUse = [requiredHook, ...hooks.PreToolUse];
+    }
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
 /**
  * Check that PostToolUse hook is properly configured in settings.local.json
  * This is needed for bell mode to inject queued messages (MSSCI-12275)
@@ -588,6 +773,95 @@ function addPostToolUseHook(projectRoot, installationType) {
     }
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
 }
+/**
+ * Check that sprint-yaml-validation hook is configured in PostToolUse
+ * This validates sprint YAML files after Edit/Write to ensure Cyclist compatibility
+ */
+function checkSprintYamlValidationHook(projectRoot, installationType) {
+    const settingsPath = join(projectRoot, '.claude/settings.local.json');
+    try {
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        // Check if hooks.PostToolUse exists
+        if (!settings.hooks?.PostToolUse) {
+            return {
+                name: 'settings/sprint-yaml-validation',
+                status: 'warn',
+                detail: 'Missing PostToolUse hooks - sprint YAML validation not configured',
+                fix: () => {
+                    addSprintYamlValidationHook(projectRoot, installationType);
+                }
+            };
+        }
+        // Check if sprint-yaml-validation is configured
+        const hasSprintYamlValidation = settings.hooks.PostToolUse.some((entry) => {
+            if (typeof entry === 'object' && entry !== null) {
+                const hookEntry = entry;
+                return hookEntry.hooks?.some(h => h.command?.includes('sprint-yaml-validation'));
+            }
+            return false;
+        });
+        if (!hasSprintYamlValidation) {
+            return {
+                name: 'settings/sprint-yaml-validation',
+                status: 'warn',
+                detail: 'sprint-yaml-validation not configured - sprint YAML errors may break SprintPanel',
+                fix: () => {
+                    addSprintYamlValidationHook(projectRoot, installationType);
+                }
+            };
+        }
+        return {
+            name: 'settings/sprint-yaml-validation',
+            status: 'pass',
+            detail: undefined
+        };
+    }
+    catch {
+        return {
+            name: 'settings/sprint-yaml-validation',
+            status: 'warn',
+            detail: 'Could not parse settings.local.json'
+        };
+    }
+}
+/**
+ * Fix function: Add sprint-yaml-validation hook to PostToolUse in settings.local.json
+ * Validates sprint YAML files after Edit/Write for Cyclist SprintPanel compatibility
+ */
+function addSprintYamlValidationHook(projectRoot, installationType) {
+    const settingsPath = join(projectRoot, '.claude/settings.local.json');
+    const scriptBase = getScriptBasePath(installationType);
+    const requiredHook = {
+        matcher: 'Edit|Write',
+        hooks: [
+            {
+                type: 'command',
+                command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/hooks/sprint-yaml-validation.sh`
+            }
+        ]
+    };
+    let settings = {};
+    if (pathExists(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        }
+        catch {
+            // Start fresh if parse fails
+        }
+    }
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    if (!hooks.PostToolUse) {
+        hooks.PostToolUse = [requiredHook];
+    }
+    else if (Array.isArray(hooks.PostToolUse)) {
+        // Append the sprint YAML validation hook
+        hooks.PostToolUse = [...hooks.PostToolUse, requiredHook];
+    }
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
 /**
  * Fix function: Add Stop hook to settings.local.json
  */
@@ -753,6 +1027,15 @@ function createSettingsLocalJson(projectRoot, installationType) {
                             command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/hooks/bell-mode-hook.sh`
                         }
                     ]
+                },
+                {
+                    matcher: 'Edit|Write',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/hooks/sprint-yaml-validation.sh`
+                        }
+                    ]
                 }
             ],
             Stop: [
@@ -784,12 +1067,21 @@ function createSettingsLocalJson(projectRoot, installationType) {
                             command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/hooks/context-warning.sh`
                         }
                     ]
+                },
+                {
+                    matcher: 'Edit|Write|Bash|Task',
+                    hooks: [
+                        {
+                            type: 'command',
+                            command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/hooks/context-circuit-breaker.sh`
+                        }
+                    ]
                 }
             ]
         },
         statusLine: {
             type: 'command',
-            command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/statusline.sh`
+            command: `"$CLAUDE_PROJECT_DIR"/${scriptBase}/misc/statusline.sh`
         }
     };
     ensureDirSync(join(projectRoot, '.claude'));
@@ -821,7 +1113,11 @@ function checkHooks(projectRoot) {
     const hooks = [
         { path: `${scriptBase}/hooks/session-start.sh`, name: 'hook/session-start' },
         { path: `${scriptBase}/hooks/pre-edit-check.sh`, name: 'hook/pre-edit-check' },
-        { path: `${scriptBase}/hooks/context-warning.sh`, name: 'hook/context-warning' }
+        { path: `${scriptBase}/hooks/context-warning.sh`, name: 'hook/context-warning' },
+        { path: `${scriptBase}/hooks/context-circuit-breaker.sh`, name: 'hook/context-circuit-breaker' },
+        { path: `${scriptBase}/hooks/bell-mode-hook.sh`, name: 'hook/bell-mode' },
+        { path: `${scriptBase}/hooks/question-reflector-check.sh`, name: 'hook/question-reflector' },
+        { path: `${scriptBase}/hooks/sprint-yaml-validation.sh`, name: 'hook/sprint-yaml-validation' }
     ];
     for (const { path, name } of hooks) {
         const fullPath = join(projectRoot, path);
@@ -916,8 +1212,11 @@ export function checkLegacyFiles(projectRoot) {
     return results;
 }
 /**
- * Check if settings.local.json has a legacy statusline path.
- * Returns result with fix function to update to canonical path.
+ * Check if settings.local.json has statusline configured.
+ * The statusLine config is a TOP-LEVEL key (not inside hooks), with structure:
+ * { "statusLine": { "type": "command", "command": "path/to/script" } }
+ *
+ * Returns result with fix function to update to canonical path if needed.
  */
 export function checkLegacyStatuslinePath(projectRoot) {
     const settingsPath = join(projectRoot, '.claude/settings.local.json');
@@ -940,46 +1239,57 @@ export function checkLegacyStatuslinePath(projectRoot) {
             detail: 'Cannot parse settings.local.json'
         };
     }
-    const hooks = settings.hooks;
-    if (!hooks || !hooks.StatusLine) {
-        // No statusline hook configured
+    // statusLine is a TOP-LEVEL key, not inside hooks
+    // Format: { type: "command", command: "..." }
+    const statusLine = settings.statusLine;
+    if (!statusLine || !statusLine.command) {
+        // No statusline configured
         return {
             name: 'settings/statusline-path',
             status: 'pass',
-            detail: 'No statusline hook configured'
+            detail: 'No statusline configured'
         };
     }
-    const currentPath = hooks.StatusLine;
-    // Check if it's the canonical path
-    if (currentPath === CANONICAL_STATUSLINE_PATH) {
+    // Extract the path from the command (may have $CLAUDE_PROJECT_DIR prefix)
+    const command = statusLine.command;
+    // Match patterns like "$CLAUDE_PROJECT_DIR"/.pennyfarthing/scripts/misc/statusline.sh
+    // or plain paths like .pennyfarthing/scripts/misc/statusline.sh
+    const pathMatch = command.match(/(?:\"\$CLAUDE_PROJECT_DIR\"\/)?([^\s"]+)/);
+    const currentPath = pathMatch ? pathMatch[1] : command;
+    // Check if it contains the canonical path
+    if (currentPath.includes('misc/statusline.sh') || command.includes('misc/statusline.sh')) {
         return {
             name: 'settings/statusline-path',
             status: 'pass',
-            detail: undefined
+            detail: 'Configured'
         };
     }
     // Check if it's a known legacy path
-    if (LEGACY_STATUSLINE_PATHS.includes(currentPath)) {
+    const isLegacy = LEGACY_STATUSLINE_PATHS.some(legacyPath => currentPath.includes(legacyPath) || command.includes(legacyPath));
+    if (isLegacy) {
         // Check if proper statusline exists before offering fix
         const properStatusline = join(projectRoot, CANONICAL_STATUSLINE_PATH);
         if (pathExists(properStatusline)) {
             return {
                 name: 'settings/statusline-path',
                 status: 'warn',
-                detail: `Legacy path: ${currentPath}`,
+                detail: `Legacy path in command`,
                 fix: () => {
                     const updatedSettings = { ...settings };
-                    updatedSettings.hooks.StatusLine = CANONICAL_STATUSLINE_PATH;
+                    updatedSettings.statusLine = {
+                        type: 'command',
+                        command: `"$CLAUDE_PROJECT_DIR"/${CANONICAL_STATUSLINE_PATH}`
+                    };
                     writeFileSync(settingsPath, JSON.stringify(updatedSettings, null, 2));
                 }
             };
         }
     }
-    // Unknown path - pass (user may have custom setup)
+    // Has statusline configured (custom or valid)
     return {
         name: 'settings/statusline-path',
         status: 'pass',
-        detail: `Custom path: ${currentPath}`
+        detail: 'Configured'
     };
 }
 //# sourceMappingURL=doctor.js.map