@pennyfarthing/core 7.6.1 → 7.8.0

package/pennyfarthing-dist/scripts/hooks/pre-commit.sh

@@ -1,8 +1,10 @@
 #!/bin/bash
-# pre-commit.sh - Git hook to enforce branch protection
+# pre-commit.sh - Git hook to enforce branch protection and agent validation
 #
-# Prevents direct commits to protected branches (main, develop).
-# Exception: sprint/ folder commits allowed on develop for administrative tracking.
+# Checks:
+# 1. Prevents direct commits to protected branches (main, develop)
+#    Exception: sprint/ folder commits allowed on develop
+# 2. Validates agent files when pennyfarthing-dist/agents/*.md is modified
 #
 # Installation:
 #   Installed to .git/hooks/pre-commit by pennyfarthing init or doctor --fix
@@ -10,6 +12,19 @@
 
 set -uo pipefail
 
+# Find project root
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# Handle both direct execution and symlink from .git/hooks
+if [[ "$SCRIPT_DIR" == *".git/hooks"* ]]; then
+    PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+else
+    PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+fi
+
+# =============================================================================
+# Check 1: Branch Protection
+# =============================================================================
+
 BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
 PROTECTED_BRANCHES="^(main|develop)$"
 
@@ -21,30 +36,72 @@ if [[ $BRANCH =~ $PROTECTED_BRANCHES ]]; then
 
         # If all staged files are in sprint/, allow the commit
         if [ -z "$NON_SPRINT_FILES" ] && [ -n "$STAGED_FILES" ]; then
-            exit 0
+            # Continue to agent validation check
+            :
+        else
+            echo ""
+            echo "COMMIT BLOCKED"
+            echo ""
+            echo "You are trying to commit directly to: $BRANCH"
+            echo "This violates the git workflow rules."
+            echo ""
+            echo "Protected branches: main, develop"
+            echo ""
+            echo "What to do:"
+            echo "1. Create a feature branch:"
+            echo "   git checkout -b <type>/<epic-story>-<description>"
+            echo ""
+            echo "2. Example:"
+            echo "   git checkout -b feat/8-2-add-authentication"
+            echo ""
+            echo "3. Then commit your changes on the feature branch"
+            echo ""
+            echo "Exception: Sprint tracking files (sprint/*) can be committed to develop"
+            echo ""
+            exit 1
         fi
+    else
+        echo ""
+        echo "COMMIT BLOCKED - Cannot commit directly to $BRANCH"
+        echo ""
+        exit 1
     fi
+fi
 
+# =============================================================================
+# Check 2: Agent File Validation
+# =============================================================================
+
+STAGED_FILES=$(git diff --cached --name-only 2>/dev/null || true)
+AGENT_FILES=$(echo "$STAGED_FILES" | grep "^pennyfarthing-dist/agents/.*\.md$" || true)
+
+if [[ -n "$AGENT_FILES" ]]; then
+    echo "Agent files staged for commit:"
+    echo "$AGENT_FILES" | sed 's/^/  /'
     echo ""
-    echo "COMMIT BLOCKED"
-    echo ""
-    echo "You are trying to commit directly to: $BRANCH"
-    echo "This violates the git workflow rules."
-    echo ""
-    echo "Protected branches: main, develop"
-    echo ""
-    echo "What to do:"
-    echo "1. Create a feature branch:"
-    echo "   git checkout -b <type>/<epic-story>-<description>"
-    echo ""
-    echo "2. Example:"
-    echo "   git checkout -b feat/8-2-add-authentication"
-    echo ""
-    echo "3. Then commit your changes on the feature branch"
-    echo ""
-    echo "Exception: Sprint tracking files (sprint/*) can be committed to develop"
-    echo ""
-    exit 1
+
+    VALIDATOR="$PROJECT_ROOT/pennyfarthing-dist/scripts/validation/validate-agent-schema.sh"
+
+    if [[ -x "$VALIDATOR" ]]; then
+        echo "Running agent schema validation..."
+        echo ""
+
+        if ! "$VALIDATOR"; then
+            echo ""
+            echo "COMMIT BLOCKED - Agent validation failed"
+            echo ""
+            echo "Fix the validation errors above and try again."
+            echo "Run 'just validate-agents -v' for detailed output."
+            echo ""
+            exit 1
+        fi
+
+        echo ""
+        echo "✓ Agent validation passed"
+    else
+        echo "Warning: Agent validator not found at $VALIDATOR"
+        echo "Skipping agent validation."
+    fi
 fi
 
 exit 0

package/pennyfarthing-dist/scripts/hooks/question-reflector-check.sh

@@ -2,8 +2,8 @@
 #
 # Question Reflector Enforcement Hook (Stop hook / PreToolUse hook)
 #
-# Thin wrapper that delegates to question-reflector-check.mjs for the actual logic.
-# This allows the hook to be written in JavaScript for easier testing and maintenance.
+# Thin wrapper that delegates to question_reflector_check.py for the actual logic.
+# This allows the hook to be written in Python for easier testing and maintenance.
 #
 # Input (stdin): JSON with transcript_path, stop_hook_active, etc.
 # Output (stdout): JSON decision to allow or block
@@ -16,5 +16,5 @@ set -euo pipefail
 # Get the directory where this script lives
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-# Delegate to JavaScript implementation
-exec node "$SCRIPT_DIR/question-reflector-check.mjs"
+# Delegate to Python implementation
+exec python3 "$SCRIPT_DIR/question_reflector_check.py"

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

@@ -0,0 +1,499 @@
+#!/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/session-stop.sh

@@ -15,6 +15,13 @@ 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/.claude" ]] && [[ "$PROJECT_ROOT" != "/" ]]; do
+    PROJECT_ROOT="$(dirname "$PROJECT_ROOT")"
+done
+
 source "$SCRIPT_DIR/../lib/checkpoint.sh"
 
 # Read input from stdin (contains session_id, source, etc.)