@pennyfarthing/core 9.2.0 → 9.4.0

package/pennyfarthing-dist/scripts/hooks/question_reflector_check.py

@@ -1,499 +0,0 @@
-#!/usr/bin/env python3
-"""
-reflector_check.py - CYCLIST reflector marker enforcement hook
-
-Story: MSSCI-12393 (questions), extended for all markers
-
-EVERY turn end MUST have a CYCLIST reflector marker. This ensures:
-- Cyclist UI can render appropriate buttons/actions
-- User always has opportunity to intervene
-- Workflow handoffs are never silently dropped
-
-Valid markers (any one required):
-  <!-- CYCLIST:HANDOFF:/agent -->        - Workflow handoff to next agent
-  <!-- CYCLIST:CONTEXT_CLEAR:/agent -->  - Handoff with context clear (TirePump)
-  <!-- CYCLIST:QUESTION:yesno -->        - Yes/no question
-  <!-- CYCLIST:QUESTION:open -->         - Open-ended question
-  <!-- CYCLIST:CHOICES:opt1,opt2,opt3 --> - Multiple choice
-  <!-- CYCLIST:CONTINUE -->              - Status update, user can continue or redirect
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import sys
-from pathlib import Path
-from typing import Any
-
-# =============================================================================
-# Constants
-# =============================================================================
-
-# Marker patterns - ALL valid CYCLIST markers
-QUESTION_MARKER_PATTERN = re.compile(r'<!--\s*CYCLIST:QUESTION:(yesno|open)\s*-->', re.IGNORECASE)
-CHOICES_MARKER_PATTERN = re.compile(r'<!--\s*CYCLIST:CHOICES:[^>]+\s*-->', re.IGNORECASE)
-HANDOFF_MARKER_PATTERN = re.compile(r'<!--\s*CYCLIST:HANDOFF:/\w+\s*-->', re.IGNORECASE)
-CONTEXT_CLEAR_MARKER_PATTERN = re.compile(r'<!--\s*CYCLIST:CONTEXT_CLEAR:/\w+\s*-->', re.IGNORECASE)
-CONTINUE_MARKER_PATTERN = re.compile(r'<!--\s*CYCLIST:CONTINUE\s*-->', re.IGNORECASE)
-
-# Question patterns - direct (with ?)
-# Match: end of line, followed by space+capital (new sentence), or followed by newline
-DIRECT_QUESTION_PATTERN = re.compile(r'\?(\s*$|\s+[A-Z]|\s*\n)')
-
-# Rhetorical patterns to exclude
-RHETORICAL_PATTERNS = re.compile(r'\b(the question (was|is)|asked whether|wondering if)\b', re.IGNORECASE)
-
-# Implicit question patterns
-IMPLICIT_PATTERNS = [
-    re.compile(r'\bwould you like\b', re.IGNORECASE),
-    re.compile(r'\bshould I\b', re.IGNORECASE),
-    re.compile(r'\bdo you want\b', re.IGNORECASE),
-    re.compile(r'\blet me know if\b', re.IGNORECASE),
-    re.compile(r'\bwhat do you (think|prefer)\b', re.IGNORECASE),
-    re.compile(r'\byour (preference|thoughts)\b', re.IGNORECASE),
-    re.compile(r'\bcould you (clarify|confirm|specify)\b', re.IGNORECASE),
-    re.compile(r'\bwhich (option|approach)\b', re.IGNORECASE),
-    re.compile(r'\bready to proceed\b', re.IGNORECASE),
-]
-
-# Choice offering patterns
-CHOICE_PATTERNS = [
-    re.compile(r'\boption [A-D]\b', re.IGNORECASE),
-    re.compile(r'\bchoice [0-9]\b', re.IGNORECASE),
-    re.compile(r'\bwe could (either|do)\b', re.IGNORECASE),
-    re.compile(r'\balternatively\b', re.IGNORECASE),
-    re.compile(r'\bor would you prefer\b', re.IGNORECASE),
-    re.compile(r'\bpick one\b', re.IGNORECASE),
-    re.compile(r'\bchoose between\b', re.IGNORECASE),
-]
-
-# Handoff phrase patterns - SM saying they'll hand off but not actually doing it
-HANDOFF_PHRASE_PATTERNS = [
-    re.compile(r'\bhanding (off )?to\b', re.IGNORECASE),
-    re.compile(r'\bpassing to\b', re.IGNORECASE),
-    re.compile(r'\bhand(ing)? this (off )?to\b', re.IGNORECASE),
-    re.compile(r'\b(Naomi|Amos|Avasarala|Holden|Alex|Drummer) (will|can)\b', re.IGNORECASE),
-    re.compile(r'\bfor (the )?(GREEN|RED|REVIEW) phase\b', re.IGNORECASE),
-    re.compile(r'\bspawning .* agent\b', re.IGNORECASE),
-]
-
-# Task tool invocation pattern in transcript
-TASK_TOOL_PATTERN = re.compile(r'"tool_name":\s*"Task"', re.IGNORECASE)
-
-
-# =============================================================================
-# Helper Functions
-# =============================================================================
-
-def strip_code_blocks(text: str) -> str:
-    """Strip fenced code blocks from text to avoid false positives.
-
-    Args:
-        text: The text to process
-
-    Returns:
-        Text with code blocks removed
-    """
-    # Remove fenced code blocks (```...```)
-    result = re.sub(r'```[\s\S]*?```', '', text)
-    # Remove inline code (`...`)
-    result = re.sub(r'`[^`]+`', '', result)
-    return result
-
-
-# =============================================================================
-# Exported Functions
-# =============================================================================
-
-def should_skip_enforcement(config: dict[str, Any]) -> bool:
-    """Check if enforcement should be skipped based on config.
-
-    Args:
-        config: The config object with workflow settings
-
-    Returns:
-        True if enforcement should be skipped
-    """
-    # Skip enforcement in CLI mode - markers are only needed for Cyclist UI
-    # Cyclist sets CYCLIST=1 in the environment when spawning Claude
-    if os.environ.get('CYCLIST') != '1':
-        return True
-
-    # In Cyclist mode, never skip enforcement - markers must always be emitted.
-    # relay_mode only controls whether Cyclist auto-executes markers
-    # vs showing buttons to the user.
-    return False
-
-
-def detect_question(message: str) -> dict[str, Any]:
-    """Detect if a message contains a question.
-
-    Args:
-        message: The message to check
-
-    Returns:
-        Detection result with 'detected' bool and 'type' string
-    """
-    # Strip code blocks first
-    clean_message = strip_code_blocks(message)
-
-    # Check for rhetorical patterns - if found, not a real question
-    if RHETORICAL_PATTERNS.search(clean_message):
-        return {'detected': False, 'type': ''}
-
-    # Check for direct questions (with ?)
-    if DIRECT_QUESTION_PATTERN.search(clean_message):
-        return {'detected': True, 'type': 'direct'}
-
-    # Check for implicit questions
-    for pattern in IMPLICIT_PATTERNS:
-        if pattern.search(clean_message):
-            return {'detected': True, 'type': 'implicit'}
-
-    # Check for choice offerings
-    for pattern in CHOICE_PATTERNS:
-        if pattern.search(clean_message):
-            return {'detected': True, 'type': 'choices'}
-
-    return {'detected': False, 'type': ''}
-
-
-def detect_handoff_phrase(message: str) -> bool:
-    """Detect if a message contains handoff language (promising to hand off).
-
-    Args:
-        message: The message to check
-
-    Returns:
-        True if handoff language detected
-    """
-    # Strip code blocks first
-    clean_message = strip_code_blocks(message)
-
-    for pattern in HANDOFF_PHRASE_PATTERNS:
-        if pattern.search(clean_message):
-            return True
-    return False
-
-
-def has_task_tool_in_turn(transcript: list[dict[str, Any]]) -> bool:
-    """Check if the current turn includes a Task tool invocation.
-
-    Args:
-        transcript: Array of message objects
-
-    Returns:
-        True if Task tool was used in the current turn
-    """
-    # Find messages in the current turn (after the last user message)
-    current_turn_start = -1
-    for i, entry in enumerate(transcript):
-        msg = entry.get('message', entry)
-        if msg.get('role') == 'user':
-            current_turn_start = i
-
-    if current_turn_start < 0:
-        return False
-
-    # Check all entries after last user message for Task tool
-    for entry in transcript[current_turn_start:]:
-        msg = entry.get('message', entry)
-        if msg.get('role') == 'assistant':
-            content = msg.get('content', [])
-            if isinstance(content, list):
-                for block in content:
-                    if block.get('type') == 'tool_use' and block.get('name') == 'Task':
-                        return True
-    return False
-
-
-def has_reflector_marker(message: str) -> bool:
-    """Check if a message has ANY valid CYCLIST reflector marker.
-
-    Args:
-        message: The message to check
-
-    Returns:
-        True if any marker is present
-    """
-    return bool(
-        QUESTION_MARKER_PATTERN.search(message) or
-        CHOICES_MARKER_PATTERN.search(message) or
-        HANDOFF_MARKER_PATTERN.search(message) or
-        CONTEXT_CLEAR_MARKER_PATTERN.search(message) or
-        CONTINUE_MARKER_PATTERN.search(message)
-    )
-
-
-def extract_last_assistant_message(transcript: list[dict[str, Any]]) -> str:
-    """Extract the last assistant message from a transcript.
-
-    Args:
-        transcript: Array of message objects
-
-    Returns:
-        The last assistant message content
-    """
-    # Find the last assistant message (reverse order)
-    # Claude Code transcript format wraps messages: { message: { role, content }, type, ... }
-    for entry in reversed(transcript):
-        # Support both wrapped format (Claude Code JSONL) and direct format (tests)
-        msg = entry.get('message', entry)
-        if msg.get('role') == 'assistant':
-            content = msg.get('content', '')
-            # Handle content as string or array
-            if isinstance(content, str):
-                return content
-            if isinstance(content, list):
-                # Extract text from text blocks, skip tool_use blocks
-                return ''.join(
-                    block.get('text', '')
-                    for block in content
-                    if block.get('type') == 'text'
-                )
-            return ''
-    return ''
-
-
-def build_block_reason(question_type: str, handoff_without_task: bool = False) -> str:
-    """Build the block reason message.
-
-    Provides actionable guidance so Claude can emit JUST the marker
-    on retry rather than regenerating the entire response.
-
-    Args:
-        question_type: The type of question detected (or empty for general)
-        handoff_without_task: True if handoff language detected but no Task tool used
-
-    Returns:
-        The reason message with suggested marker
-    """
-    # Special case: handoff language without Task tool
-    if handoff_without_task:
-        return (
-            'HANDOFF COMPLIANCE VIOLATION: You said you would hand off but did NOT use the Task tool.\n\n'
-            'SM Protocol: Task tool FIRST, narration SECOND.\n\n'
-            'Either:\n'
-            '1. Actually spawn the agent now using the Task tool, OR\n'
-            '2. If you completed the work yourself, remove handoff language and add <!-- CYCLIST:CONTINUE -->'
-        )
-
-    # Key insight: Tell Claude to ONLY emit the marker, not regenerate everything
-    reason = 'Missing CYCLIST marker. Your response content is fine - just APPEND the marker.\n\n'
-
-    if question_type:
-        # Specific question type detected - suggest exact marker
-        if question_type == 'direct':
-            reason += 'Detected: direct question (?)\n'
-            reason += 'APPEND THIS: <!-- CYCLIST:QUESTION:open -->\n'
-            reason += '(Use yesno if it\'s a yes/no question)'
-        elif question_type == 'implicit':
-            reason += 'Detected: implicit question (would you like, should I, etc.)\n'
-            reason += 'APPEND THIS: <!-- CYCLIST:QUESTION:yesno -->'
-        elif question_type == 'choices':
-            reason += 'Detected: choice offering\n'
-            reason += 'APPEND THIS: <!-- CYCLIST:CHOICES:option1,option2 -->\n'
-            reason += '(Replace option1,option2 with actual choices)'
-    else:
-        # No question detected - suggest CONTINUE marker
-        reason += 'No question detected - this looks like a status update.\n'
-        reason += 'APPEND THIS: <!-- CYCLIST:CONTINUE -->\n\n'
-        reason += 'Other markers if needed:\n'
-        reason += '  <!-- CYCLIST:HANDOFF:/agent --> - workflow handoff\n'
-        reason += '  <!-- CYCLIST:QUESTION:yesno --> - yes/no question\n'
-        reason += '  <!-- CYCLIST:QUESTION:open --> - open question'
-
-    return reason
-
-
-def check_question_reflector(
-    input_data: dict[str, Any],
-    config: dict[str, Any],
-    last_message: str,
-    transcript: list[dict[str, Any]] | None = None
-) -> dict[str, Any]:
-    """Main check for Stop hook - validates ALL turns have reflector markers.
-
-    Also enforces handoff compliance: if handoff language detected without
-    Task tool usage, blocks the turn.
-
-    Args:
-        input_data: Hook input with transcript_path, stop_hook_active
-        config: Config with workflow settings
-        last_message: The last assistant message (pre-extracted for testing)
-        transcript: Full transcript for checking Task tool usage
-
-    Returns:
-        { 'ok': True } or { 'decision': 'block', 'reason': str }
-    """
-    # Prevent infinite loops
-    if input_data.get('stop_hook_active'):
-        return {'ok': True}
-
-    # Skip enforcement in relay/turbo mode
-    if should_skip_enforcement(config):
-        return {'ok': True}
-
-    # If no message, allow (edge case - shouldn't happen)
-    if not last_message:
-        return {'ok': True}
-
-    # If ANY marker present, allow
-    if has_reflector_marker(last_message):
-        return {'ok': True}
-
-    # HANDOFF COMPLIANCE CHECK:
-    # If handoff language detected but no Task tool was used, block
-    if detect_handoff_phrase(last_message):
-        has_task = transcript and has_task_tool_in_turn(transcript)
-        if not has_task:
-            return {
-                'decision': 'block',
-                'reason': build_block_reason('', handoff_without_task=True),
-            }
-
-    # No marker found - block
-    # Check if it's a question to give more specific guidance
-    detection = detect_question(last_message)
-    return {
-        'decision': 'block',
-        'reason': build_block_reason(detection['type'] if detection['detected'] else ''),
-    }
-
-
-def check_ask_user_question(
-    input_data: dict[str, Any],
-    config: dict[str, Any],
-    recent_output: str = ''
-) -> dict[str, Any]:
-    """Check for AskUserQuestion PreToolUse hook.
-
-    Args:
-        input_data: Hook input with tool_name, tool_input
-        config: Config with workflow settings
-        recent_output: Recent assistant output to check for marker
-
-    Returns:
-        { 'ok': True } or { 'decision': 'block', 'reason': str }
-    """
-    # Skip enforcement in relay/turbo mode
-    if should_skip_enforcement(config):
-        return {'ok': True}
-
-    # If marker present in recent output, allow
-    if recent_output and has_reflector_marker(recent_output):
-        return {'ok': True}
-
-    # Block - AskUserQuestion requires a marker
-    return {
-        'decision': 'block',
-        'reason': 'AskUserQuestion tool requires a CYCLIST marker. Add <!-- CYCLIST:QUESTION:yesno -->, <!-- CYCLIST:QUESTION:open -->, or <!-- CYCLIST:CHOICES:... --> before using this tool.',
-    }
-
-
-# =============================================================================
-# CLI Entry Point (for bash wrapper)
-# =============================================================================
-
-def load_config(project_dir: str) -> dict[str, Any]:
-    """Load config from .pennyfarthing/config.local.yaml.
-
-    Args:
-        project_dir: The project directory
-
-    Returns:
-        The config object
-    """
-    try:
-        config_path = Path(project_dir) / '.pennyfarthing' / 'config.local.yaml'
-        content = config_path.read_text()
-        # Simple YAML parsing for the fields we need
-        config: dict[str, Any] = {'workflow': {}}
-
-        # Extract permission_mode
-        mode_match = re.search(r'permission_mode:\s*(\w+)', content)
-        if mode_match:
-            config['workflow']['permission_mode'] = mode_match.group(1)
-
-        # Extract relay_mode
-        relay_match = re.search(r'relay_mode:\s*(true|false)', content)
-        if relay_match:
-            config['workflow']['relay_mode'] = relay_match.group(1) == 'true'
-
-        return config
-    except Exception:
-        # Default config if file doesn't exist
-        return {'workflow': {'permission_mode': 'manual'}}
-
-
-def read_transcript(transcript_path: str) -> tuple[str, list[dict[str, Any]]]:
-    """Read transcript and extract last assistant message.
-
-    Args:
-        transcript_path: Path to JSONL transcript
-
-    Returns:
-        Tuple of (last assistant message, full transcript)
-    """
-    try:
-        content = Path(transcript_path).read_text()
-        lines = [line for line in content.strip().split('\n') if line]
-
-        # Parse JSONL and build transcript array
-        transcript: list[dict[str, Any]] = []
-        for line in lines:
-            try:
-                transcript.append(json.loads(line))
-            except json.JSONDecodeError:
-                # Skip malformed lines
-                pass
-
-        return extract_last_assistant_message(transcript), transcript
-    except Exception:
-        return '', []
-
-
-def main() -> None:
-    """Main CLI entry point."""
-    # Read input from stdin
-    input_data_str = sys.stdin.read()
-
-    try:
-        input_data = json.loads(input_data_str)
-    except json.JSONDecodeError:
-        # Invalid input - allow to prevent breaking
-        print(json.dumps({'ok': True}))
-        sys.exit(0)
-
-    # Determine project directory
-    project_dir = os.environ.get('CLAUDE_PROJECT_DIR', os.getcwd())
-
-    # Load config
-    config = load_config(project_dir)
-
-    # Determine hook type based on input
-    if input_data.get('tool_name') == 'AskUserQuestion':
-        # PreToolUse hook for AskUserQuestion
-        # For PreToolUse, we'd need the recent output - for now, just check config
-        result = check_ask_user_question(input_data, config, '')
-        print(json.dumps(result))
-    else:
-        # Stop hook
-        transcript_path = input_data.get('transcript_path', '')
-        last_message, transcript = read_transcript(transcript_path) if transcript_path else ('', [])
-        result = check_question_reflector(input_data, config, last_message, transcript)
-        print(json.dumps(result))
-
-    sys.exit(0)
-
-
-if __name__ == '__main__':
-    try:
-        main()
-    except Exception as err:
-        print(str(err), file=sys.stderr)
-        # On error, allow to prevent breaking
-        print(json.dumps({'ok': True}))
-        sys.exit(0)

package/pennyfarthing-dist/scripts/hooks/schema-validation.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env zsh
-# Schema Validation Hook
-# Validates XML schema for session, skill, and workflow step files on Write operations
-# Called by Claude Code PreToolUse hook
-#
-# Input: JSON via stdin with tool_name, tool_input
-# Output: JSON with decision (allow/deny)
-
-set -euo pipefail
-
-# Find script directory (zsh compatible)
-SCRIPT_DIR="${0:A:h}"
-source "$SCRIPT_DIR/../lib/find-root.sh"
-
-# Set PYTHONPATH for pennyfarthing_scripts
-PENNYFARTHING_SCRIPTS=""
-if [[ -d "$PROJECT_ROOT/pennyfarthing" ]]; then
-    # Dogfooding: framework inlined in orchestrator
-    PENNYFARTHING_SCRIPTS="$PROJECT_ROOT/pennyfarthing"
-elif [[ -d "$PROJECT_ROOT/node_modules/@pennyfarthing/core" ]]; then
-    # Normal install
-    PENNYFARTHING_SCRIPTS="$PROJECT_ROOT/node_modules/@pennyfarthing/core"
-fi
-
-if [[ -n "$PENNYFARTHING_SCRIPTS" ]]; then
-    export PYTHONPATH="$PENNYFARTHING_SCRIPTS:${PYTHONPATH:-}"
-fi
-
-# Run Python validation hook
-python3 -m pennyfarthing_scripts.schema_validation_hook

package/pennyfarthing-dist/scripts/hooks/session-start.sh

@@ -1,97 +0,0 @@
-#!/usr/bin/env zsh
-# Session start hook: Initialize environment for Claude Code session
-# Called by Claude Code when a new session starts
-#
-# Uses CLAUDE_ENV_FILE to persist environment variables for the session.
-# Projects using pennyfarthing can add their own hooks for project-specific vars.
-#
-# Also validates previous session checkpoint to detect cross-session state changes.
-
-set -euo pipefail
-
-# Load shared functions
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-source "$SCRIPT_DIR/../lib/checkpoint.sh"
-
-# Read input from stdin (contains session_id, source, cwd, etc.)
-input=$(cat)
-session_id=$(echo "$input" | jq -r '.session_id // "unknown"')
-source_type=$(echo "$input" | jq -r '.source // "unknown"')
-
-# Ensure .session directory exists
-mkdir -p "$CLAUDE_PROJECT_DIR/.session"
-mkdir -p "$CLAUDE_PROJECT_DIR/.session/agents"
-
-# Note: Agent cleanup is handled by agent-session.sh (7-day TTL) to preserve multi-session state
-# DO NOT clear .session/agents/* here - it breaks parallel sessions
-
-# Create session log entry
-echo "$(date -Iseconds) | Session $source_type: $session_id" >> "$CLAUDE_PROJECT_DIR/.session/session-log.txt"
-
-# Validate previous session checkpoint (cross-session continuity)
-validate_checkpoint() {
-    local prev_state
-    prev_state=$(checkpoint_restore "session_state")
-
-    if [[ -z "$prev_state" ]]; then
-        # No previous checkpoint - fresh start
-        return 0
-    fi
-
-    # Parse checkpoint data (format: key=value;key=value;...)
-    local prev_sha prev_agent prev_story prev_phase prev_session
-    prev_sha=$(echo "$prev_state" | tr ';' '\n' | grep '^sha=' | cut -d= -f2)
-    prev_agent=$(echo "$prev_state" | tr ';' '\n' | grep '^agent=' | cut -d= -f2)
-    prev_story=$(echo "$prev_state" | tr ';' '\n' | grep '^story=' | cut -d= -f2)
-    prev_phase=$(echo "$prev_state" | tr ';' '\n' | grep '^phase=' | cut -d= -f2)
-    prev_session=$(echo "$prev_state" | tr ';' '\n' | grep '^session=' | cut -d= -f2)
-
-    # Get current git SHA
-    local current_sha=""
-    if command -v git &>/dev/null && git rev-parse --git-dir &>/dev/null; then
-        current_sha=$(git rev-parse --short HEAD 2>/dev/null || echo "")
-    fi
-
-    # Compare git state
-    if [[ -n "$prev_sha" && -n "$current_sha" && "$prev_sha" != "$current_sha" ]]; then
-        # Git state changed between sessions - write warning to session log
-        local warning="CROSS_SESSION_DRIFT: Git changed since last session (was: $prev_sha, now: $current_sha)"
-        if [[ -n "$prev_story" ]]; then
-            warning="$warning | Story: $prev_story"
-        fi
-        if [[ -n "$prev_agent" ]]; then
-            warning="$warning | Agent: $prev_agent"
-        fi
-        echo "$(date -Iseconds) | $warning" >> "$CLAUDE_PROJECT_DIR/.session/session-log.txt"
-
-        # Also write to a dedicated drift log for easy scanning
-        echo "$(date -Iseconds) | prev_sha=$prev_sha | current_sha=$current_sha | story=$prev_story | agent=$prev_agent | phase=$prev_phase" >> "$CLAUDE_PROJECT_DIR/.session/drift-log.txt"
-    fi
-}
-
-# Run checkpoint validation (don't fail if it errors)
-validate_checkpoint 2>/dev/null || true
-
-# Write environment variables to CLAUDE_ENV_FILE (persists for session)
-if [ -n "${CLAUDE_ENV_FILE:-}" ]; then
-    cat >> "$CLAUDE_ENV_FILE" << EOF
-# Pennyfarthing core environment
-export PROJECT_ROOT="$CLAUDE_PROJECT_DIR"
-export SESSION_ID="$session_id"
-EOF
-
-    # Auto-configure OTEL if Cyclist is running (Story 20-1)
-    PORT_FILE="$CLAUDE_PROJECT_DIR/.cyclist-port"
-    if [[ -f "$PORT_FILE" ]]; then
-        CYCLIST_PORT=$(cat "$PORT_FILE" 2>/dev/null)
-        if [[ "$CYCLIST_PORT" =~ ^[0-9]+$ ]]; then
-            cat >> "$CLAUDE_ENV_FILE" << EOF
-# OTEL auto-configuration for Cyclist (Story 20-1)
-export OTEL_EXPORTER_OTLP_PROTOCOL="http/json"
-export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:$CYCLIST_PORT"
-EOF
-        fi
-    fi
-fi
-
-exit 0

package/pennyfarthing-dist/scripts/hooks/session-stop.sh

@@ -1,65 +0,0 @@
-#!/usr/bin/env zsh
-# Session stop hook: Save checkpoint for cross-session continuity
-# Called by Claude Code when a session ends
-#
-# Writes session state to checkpoint:
-#   - Active agent (from .session/agents/)
-#   - Current story (from .session/*-session.md)
-#   - Workflow phase (from session file)
-#   - Git SHA (current HEAD)
-#   - Session ID
-#
-# Next session can validate this against current git state.
-
-set -euo pipefail
-
-# Load shared functions
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-
-# Determine project root (directory containing .claude)
-PROJECT_ROOT="$SCRIPT_DIR"
-while [[ ! -d "$PROJECT_ROOT/.pennyfarthing" ]] && [[ "$PROJECT_ROOT" != "/" ]]; do
-    PROJECT_ROOT="$(dirname "$PROJECT_ROOT")"
-done
-
-source "$SCRIPT_DIR/../lib/checkpoint.sh"
-
-# Read input from stdin (contains session_id, source, etc.)
-input=$(cat)
-session_id=$(echo "$input" | jq -r '.session_id // "unknown"')
-
-# Get current agent for this session
-agent=""
-agent_file="$PROJECT_ROOT/.session/agents/$session_id"
-if [[ -f "$agent_file" ]]; then
-    agent=$(cat "$agent_file")
-fi
-
-# Find active story from session files
-story=""
-phase=""
-session_file=$(find "$PROJECT_ROOT/.session" -maxdepth 1 -name "*-session.md" -type f 2>/dev/null | head -1)
-if [[ -n "$session_file" && -f "$session_file" ]]; then
-    # Extract story ID from filename (e.g., 8-3-session.md -> 8-3)
-    story=$(basename "$session_file" | sed 's/-session\.md$//')
-
-    # Extract phase from session file (look for "Phase:" line)
-    phase=$(grep -i "^- Phase:" "$session_file" 2>/dev/null | head -1 | sed 's/.*Phase:[[:space:]]*//' | cut -d' ' -f1 || echo "")
-fi
-
-# Get current git SHA
-git_sha=""
-if command -v git &>/dev/null && git rev-parse --git-dir &>/dev/null; then
-    git_sha=$(git rev-parse --short HEAD 2>/dev/null || echo "")
-fi
-
-# Build checkpoint data (semicolon-separated key=value pairs)
-checkpoint_data="agent=${agent};story=${story};phase=${phase};sha=${git_sha};session=${session_id}"
-
-# Save checkpoint
-checkpoint_save "session_state" "$checkpoint_data"
-
-# Log session end
-echo "$(date -Iseconds) | Session end: $session_id (agent=$agent, story=$story)" >> "$PROJECT_ROOT/.session/session-log.txt"
-
-exit 0