/context-load-java-temporal

allowed-tools: Task, WebFetch, Read, Bash(fd:*), Bash(rg:*), Bash(jq:*), Bash(gdate:*), Bash(mvn:*), Bash(gradle:*)
name: "Context Load Java Temporal"
description: "Load comprehensive Java Temporal workflow documentation with project-specific optimization"
author: "wcygan"
tags: ["context","java"]
version: "1.0.0"
created_at: "2025-07-14T00:00:00Z"
updated_at: "2025-07-14T00:00:00Z"

Context

• Session ID: !`gdate +%s%N`
• Current directory: !`pwd`
• Java projects: !`fd "(pom\.xml|build\.gradle|build\.gradle\.kts)" . | head -5 || echo "No Java projects found"`
• Temporal usage: !`rg "temporal|workflow|activity" . --type java | wc -l | tr -d ' ' || echo "0"`
• Spring Boot presence: !`rg "@SpringBootApplication|spring-boot" . --type java --type xml | wc -l | tr -d ' ' || echo "0"`
• Dependency management: !`fd "(pom\.xml|build\.gradle)" . -x rg "temporal" {} \; | head -3 || echo "No Temporal dependencies found"`
• Test files: !`fd ".*Test\.java$" . | wc -l | tr -d ' ' || echo "0"`
• Technology stack: !`fd "(deno\.json|package\.json|Cargo\.toml)" . | head -3 || echo "Java-focused project"`
• Git status: !`git status --porcelain | head -3 || echo "Not a git repository"`

Your Task

STEP 1: Initialize context loading session

• CREATE session state file: `/tmp/java-temporal-context-$SESSION_ID.json`
• SET initial state:

  {
    "sessionId": "$SESSION_ID",
    "phase": "discovery",
    "context_sources": [],
    "loaded_topics": [],
    "project_specific_focus": [],
    "documentation_cache": {},
    "temporal_features_detected": []
  }

STEP 2: Project analysis and documentation prioritization

• ANALYZE project structure from Context section
• DETERMINE specific Temporal features and patterns in use
• IDENTIFY documentation priorities based on project needs

Think deeply about optimal Temporal workflow documentation strategies for this specific project context.

IF Java projects with Temporal usage found:

• FOCUS on project-specific workflow patterns and activity implementations
• PRIORITIZE relevant testing strategies and deployment contexts
• INCLUDE performance optimization and monitoring contexts

ELSE:

• LOAD foundational Temporal concepts and getting-started guides
• EMPHASIZE workflow design principles and best practices
• INCLUDE project setup and Spring Boot integration patterns

STEP 3: Parallel documentation loading with sub-agent delegation

TRY:

• LAUNCH 7 parallel sub-agents for simultaneous documentation loading
• EACH sub-agent processes one priority documentation source
• SAVE loaded context to session state from all agents
• SYNTHESIZE findings from parallel execution

**Parallel Sub-Agent Documentation Loading:**

LAUNCH parallel sub-agents to load comprehensive Temporal documentation:

• **Agent 1: Core Concepts**: Load foundational Temporal concepts from `https://docs.temporal.io/concepts`
• Focus: Durable execution model, workflow lifecycle, task queues, signals, queries
• Extract: Mental models and architectural patterns

• **Agent 2: Java SDK Guide**: Load Java implementation patterns from `https://docs.temporal.io/dev-guide/java`
• Focus: Workflow definition, activity implementation, worker configuration
• Extract: Code examples and configuration patterns

• **Agent 3: Testing Strategies**: Load testing methodologies from `https://docs.temporal.io/dev-guide/java/testing`
• Focus: TestWorkflowEnvironment, time manipulation, mock activities, test determinism
• Extract: Testing patterns and time-skipping techniques

• **Agent 4: Java Samples**: Load real-world examples from `https://github.com/temporalio/samples-java`
• Focus: Production-ready workflow implementations and patterns
• Extract: Complete example applications and integration patterns

• **Agent 5: Spring Integration**: Load Spring Boot patterns from `https://docs.temporal.io/dev-guide/java/foundations#dependency-injection`
• Focus: Application configuration, dependency injection, bean management, lifecycle
• Extract: Production deployment and configuration patterns

• **Agent 6: Production Operations**: Load operational guidance from `https://docs.temporal.io/production-deployment`
• Focus: Deployment, monitoring, observability, scaling, metrics, alerting
• Extract: Operational best practices and troubleshooting procedures

• **Agent 7: Versioning & Migration**: Load evolution strategies from `https://docs.temporal.io/dev-guide/java/versioning`
• Focus: Versioning strategies, backward compatibility, migration, breaking changes
• Extract: Versioning patterns and rollback procedures

**Sub-Agent Coordination:**

• Each sub-agent executes independently with WebFetch tool
• Results aggregated in session state under respective functional areas
• Parallel execution provides 5-7x performance improvement over sequential loading
• Failed agents report to session state without blocking others

CATCH (documentation_fetch_failed):

• LOG failed sources to session state
• CONTINUE with available documentation
• PROVIDE manual context loading instructions
• SAVE fallback documentation references

STEP 4: Context organization and project-specific synthesis

• ORGANIZE loaded context by functional area:
• Workflow design and implementation patterns
• Activity definition and execution strategies
• Signal and query handling mechanisms
• Testing methodologies and time manipulation
• Worker configuration and scaling patterns
• Error handling and retry policies
• Versioning and migration strategies
• Monitoring and observability integration
• Spring Boot integration and dependency injection
• Production deployment and operations

Think harder about advanced Temporal workflow patterns and their applicability to the detected project structure.

• SYNTHESIZE project-specific guidance:
• Integration with existing Java application architecture
• Migration strategies from synchronous to workflow-based processing
• Testing strategies for complex busi