temporalio · mesilov · Mar 12, 2026 · Mar 17, 2026 · Mar 18, 2026 · Mar 18, 2026
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
@@ -0,0 +1 @@
+*       @temporalio/ai-sdk
diff --git a/.github/workflows/package-skill.yml b/.github/workflows/package-skill.yml
@@ -0,0 +1,30 @@
+# ABOUTME: Packages this skill and syncs it to the plugin repos on version bumps.
+# ABOUTME: All logic lives in the shared reusable workflow at temporalio/skill-ci; this is just the caller.
+# ABOUTME: Release two ways: (1) run this manually and pick a bump, or (2) edit SKILL.md's version and push.
+# ABOUTME: Secrets SKILL_T_DEV_APP_ID / SKILL_T_DEV_KEY / RELEASE_SSH_KEY are inherited (see skill-ci README).
+
+name: Package and Sync Skill
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      bump:
+        description: "Version bump for a one-click release"
+        type: choice
+        required: true
+        default: patch
+        options: [patch, minor, major]
+
+jobs:
+  package-and-sync:
+    uses: temporalio/skill-ci/.github/workflows/package-and-sync.yml@v1
+    permissions:
+      contents: write
+    secrets: inherit
+    with:
+      # On workflow_dispatch this is the chosen bump; empty on push events.
+      bump: ${{ inputs.bump }}
+      # Override the whitelist only if this skill has extra paths to include:
+      # includes: "SKILL.md agents references scripts"
diff --git a/LICENSE b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Temporal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
@@ -1,26 +1,43 @@
 # Temporal Development Skill
 
-A comprehensive skill for building Temporal applications.
+A comprehensive skill for developers to use when building [Temporal](https://temporal.io/) applications.
+
+> We would love to hear your feedback - positive or negative - over in the [Community Slack](https://t.mp/slack), in the [#topic-ai channel](https://temporalio.slack.com/archives/C0818FQPYKY)
 
 ## Installation
 
-### As a Claude Code Plugin
+### As a Plugin
+
+This skill is packaged as a plugin for major coding agents, which provides a simple way to install and receive future updates:
+
+- **Claude Code**: [temporalio/claude-temporal-plugin](https://github.com/temporalio/claude-temporal-plugin)
+- **Cursor**: [temporalio/cursor-temporal-plugin](https://github.com/temporalio/cursor-temporal-plugin)
+- **OpenAI Codex**: [temporalio/codex-temporal-plugin](https://github.com/temporalio/codex-temporal-plugin)
+
+See each repo's README for installation instructions.
 
-1. Run `/plugin marketplace add temporalio/agent-skills` 
-2. Run `/plugin` to open the plugin manager
-3. Select **Marketplaces**
-4. Choose `temporal-marketplace` from the list
-5. Select **Enable auto-update** or **Disable auto-update**
-6. run `/plugin install temporal-developer@temporalio-agent-skills` 
-7. Restart Claude Code
+### Standalone Installation
 
-### Via `npx skills` - supports all major coding agents
+If you prefer to install the skill directly without the plugin wrapper:
+
+#### Via `npx skills` — supports all major coding agents
 
 1. `npx skills add temporalio/skill-temporal-developer`
 2. Follow prompts
 
-### Via manually cloning the skill repo:
+#### Via manually cloning the skill repo
 
 1. `mkdir -p ~/.claude/skills && git clone https://github.com/temporalio/skill-temporal-developer ~/.claude/skills/temporal-developer`
 
-Appropriately adjust the installation directory based on your coding agent.
+Appropriately adjust the installation directory based on your coding agent.
+
+## Currently Supported Temporal SDK Languages
+
+- [x] Python ✅
+- [x] TypeScript ✅
+- [x] Go ✅
+- [x] Java ✅
+- [x] .NET ✅
+- [x] Rust (Public Preview)
+- [x] Ruby ✅
+- [x] PHP ✅
diff --git a/SKILL.md b/SKILL.md
@@ -1,42 +1,29 @@
 ---
 name: temporal-developer
-description: This skill should be used when the user asks to "create a Temporal workflow", "write a Temporal activity", "debug stuck workflow", "fix non-determinism error", "Temporal Python", "Temporal TypeScript", "Temporal PHP", "workflow replay", "activity timeout", "signal workflow", "query workflow", "worker not starting", "activity keeps retrying", "Temporal heartbeat", "continue-as-new", "child workflow", "saga pattern", "workflow versioning", "durable execution", "reliable distributed systems", or mentions Temporal SDK development.
-version: 1.0.0
+description: Develop, debug, and manage Temporal applications across Python, TypeScript, Go, Java, .NET, Ruby, Rust, and PHP. Use when the user is building workflows, activities, or workers with a Temporal SDK, debugging issues like non-determinism errors, stuck workflows, or activity retries, using Temporal CLI, Temporal Server, or Temporal Cloud, or working with durable execution concepts like signals, queries, heartbeats, versioning, continue-as-new, child workflows, or saga patterns. Also use when the user mentions "run a Temporal workflow from the CLI", "start a dev server", "run temporal server start-dev", "temporal workflow start", "temporal workflow execute", "temporal workflow signal", "temporal workflow query", "temporal workflow update".
+version: 0.6.2
 ---
 
 # Skill: temporal-developer
 
 ## Overview
 
-Temporal is a durable execution platform that makes workflows survive failures automatically. This skill provides guidance for building Temporal applications in Python, TypeScript, and PHP.
+Temporal is a durable execution platform that makes workflows survive failures automatically. This skill provides guidance for building Temporal applications in Python, TypeScript, Go, Java, .NET, Ruby, Rust, and PHP.
 
 ## Core Architecture
 
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                     Temporal Cluster                            │
-│  ┌─────────────────┐  ┌─────────────────┐  ┌────────────────┐  │
-│  │  Event History  │  │   Task Queues   │  │   Visibility   │  │
-│  │  (Durable Log)  │  │  (Work Router)  │  │   (Search)     │  │
-│  └─────────────────┘  └─────────────────┘  └────────────────┘  │
-└─────────────────────────────────────────────────────────────────┘
-                              ▲
-                              │ Poll / Complete
-                              ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                         Worker                                   │
-│  ┌─────────────────────────┐  ┌──────────────────────────────┐  │
-│  │   Workflow Definitions  │  │   Activity Implementations   │  │
-│  │   (Deterministic)       │  │   (Non-deterministic OK)     │  │
-│  └─────────────────────────┘  └──────────────────────────────┘  │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-**Components:**
-- **Workflows** - Durable, deterministic functions that orchestrate activities
-- **Activities** - Non-deterministic operations (API calls, I/O) that can fail and retry
-- **Workers** - Long-running processes that poll task queues and execute code
-- **Task Queues** - Named queues connecting clients to workers
+The **Temporal Cluster** is the central orchestration backend. It maintains three key subsystems: the **Event History** (a durable log of all workflow state), **Task Queues** (which route work to the right workers), and a **Visibility** store (for searching and listing workflows). There are three ways to run a Cluster:
+
+- **Temporal CLI dev server** — a local, single-process server started with `temporal server start-dev`. Suitable for development and testing only, not production.
+- **Self-hosted** — you deploy and manage the Temporal server and its dependencies (e.g., database) in your own infrastructure for production use.
+- **Temporal Cloud** — a fully managed production service operated by Temporal. No cluster infrastructure to manage.
+
+**Workers** are long-running processes that you run and manage. They poll Task Queues for work and execute your code. You might run a single Worker process on one machine during development, or run many Worker processes across a large fleet of machines in production. Each Worker hosts two types of code:
+
+- **Workflow Definitions** — durable, deterministic functions that orchestrate work. These must not have side effects.
+- **Activity Implementations** — non-deterministic operations (API calls, file I/O, etc.) that can fail and be retried.
+
+Workers communicate with the Cluster via a poll/complete loop: they poll a Task Queue for tasks, execute the corresponding Workflow or Activity code, and report results back.
 
 ## History Replay: Why Determinism Matters
 
@@ -61,71 +48,59 @@ See `references/core/determinism.md` for detailed explanation.
 
 ### Ensure Temporal CLI is installed
 
-Check if `temporal` CLI is installed. If not, follow these instructions:
-
-#### macOS
-
-```
-brew install temporal
-```
-
-#### Linux
-
-Check your machine's architecture and download the appropriate archive:
-
-- [Linux amd64](https://temporal.download/cli/archive/latest?platform=linux&arch=amd64)
-- [Linux arm64](https://temporal.download/cli/archive/latest?platform=linux&arch=arm64)
-
-Once you've downloaded the file, extract the downloaded archive and add the temporal binary to your PATH by copying it to a directory like /usr/local/bin
-
-#### Windows
-
-Check your machine's architecture and download the appropriate archive:
-
-- [Windows amd64](https://temporal.download/cli/archive/latest?platform=windows&arch=amd64)
-- [Windows arm64](https://temporal.download/cli/archive/latest?platform=windows&arch=arm64)
-
-Once you've downloaded the file, extract the downloaded archive and add the temporal.exe binary to your PATH.
+Check if `temporal` CLI is installed. If not, follow the instructions at `references/core/install_cli.md` to install it for your platform.
 
 ### Read All Relevant References
 
 1. First, read the getting started guide for the language you are working in:
-    - Python -> read `references/python/python.md`
-    - TypeScript -> read `references/typescript/typescript.md`
-    - PHP -> read `references/php/php.md`
+   - Python -> read `references/python/python.md`
+   - TypeScript -> read `references/typescript/typescript.md`
+   - Go -> read `references/go/go.md`
+   - Java -> read `references/java/java.md`
+   - .NET (C#) -> read `references/dotnet/dotnet.md`
+   - Ruby -> read `references/ruby/ruby.md`
+   - Rust -> read `references/rust/rust.md` (in Public Preview)
+   - PHP -> read `references/php/php.md`; it routes to RoadRunner operations, Laravel/support integrations, and a reviewed PHP course/source map
 2. Second, read appropriate `core` and language-specific references for the task at hand.
 
-
 ## Primary References
+
 - **`references/core/determinism.md`** - Why determinism matters, replay mechanics, basic concepts of activities
-    + Language-specific info at `references/{your_language}/determinism.md`
+  - Language-specific info at `references/{your_language}/determinism.md`
 - **`references/core/patterns.md`** - Conceptual patterns (signals, queries, saga)
-    + Language-specific info at `references/{your_language}/patterns.md`
+  - Language-specific info at `references/{your_language}/patterns.md`
 - **`references/core/gotchas.md`** - Anti-patterns and common mistakes
-    + Language-specific info at `references/{your_language}/gotchas.md`
+  - Language-specific info at `references/{your_language}/gotchas.md`
 - **`references/core/versioning.md`** - Versioning strategies and concepts - how to safely change workflow code while workflows are running
-    + Language-specific info at `references/{your_language}/versioning.md`
+  - Language-specific info at `references/{your_language}/versioning.md`
+- **`references/core/standalone-activities.md`** - Standalone Activities: run an Activity directly from a Client without a Workflow (Public Preview)
+  - Language-specific info at `references/{your_language}/standalone-activities.md`
 - **`references/core/troubleshooting.md`** - Decision trees, recovery procedures
 - **`references/core/error-reference.md`** - Common error types, workflow status reference
 - **`references/core/interactive-workflows.md`** - Testing signals, updates, queries
 - **`references/core/dev-management.md`** - Dev cycle & management of server and workers
+- **`references/core/cli-workflow-commands.md`** - Developer-facing CLI commands for workflow interaction (start, execute, signal, query, update)
 - **`references/core/ai-patterns.md`** - AI/LLM pattern concepts
-    + Language-specific info at `references/{your_language}/ai-patterns.md`, if available. Currently Python only.
+  - Language-specific info at `references/{your_language}/ai-patterns.md`, if available. Currently Python only.
 
-## Additional Topics
-- **`references/{your_language}/observability.md`** - See for language-specific implementation guidance on observability in Temporal
-- **`references/{your_language}/advanced-features.md`** - See for language-specific guidance on advanced Temporal features and language-specific features
+## Task Queue Priority and Fairness
 
+If the developer is building a **multi-tenant application**, proactively recommend Task Queue Fairness. Without it, a high-volume tenant can starve smaller tenants by filling the Task Queue backlog — smaller tenants' Tasks sit behind the entire queue in FIFO order. Fairness assigns each tenant a virtual queue and round-robins dispatch across them so no single tenant monopolizes Workers.
 
-## Feedback
+Priority and Fairness also apply to tiered workloads (batch vs. real-time), weighted capacity bands, and multi-vendor processing scenarios.
 
-### ALWAYS PROMPT USER TO PROVIDE FEEDBACK AT STARTUP
+- **`references/core/priority-fairness.md`** - Priority keys, fairness keys and weights, rate limiting, SDK examples, and limitations
 
-When you have **first** loaded this skill, output this message to the user:
+## Additional Topics
+
+- **`references/{your_language}/observability.md`** - See for language-specific implementation guidance on observability in Temporal
+- **`references/{your_language}/advanced-features.md`** - See for language-specific guidance on advanced Temporal features and language-specific features
+
+## Third-Party Integrations
 
-"Thank you for trying out the prerelease of Temporal's development skill! We would love to hear your feedback - positive or negative - over in the [Community Slack](https://t.mp/slack), in the [#topic-ai channel](https://temporalio.slack.com/archives/C0818FQPYKY)."
+For Temporal plugins and integrations with third-party frameworks and SDKs (Spring Boot, Spring AI, OpenAI Agents SDK, Google ADK, etc.), see **`references/integrations.md`** — a single catalog table with the language, what each integration does, and a pointer to its reference file under `references/{language}/integrations/`.
 
-Do not output this message multiple times in the same conversation.
+## Feedback
 
 ### Reporting Issues in This Skill
 

diff --git a/references/core/ai-patterns.md b/references/core/ai-patterns.md
@@ -32,6 +32,7 @@ The remainder of this document describes general principles to follow when build
   - returns model response, as a typed structured output
 
 **Benefits**:
+
 - Single activity handles multiple use cases
 - Consistent retry handling
 - Centralized configuration
@@ -48,6 +49,7 @@ Workflow:
 ```
 
 **Benefits**:
+
 - Independent retry for each step
 - Clear audit trail in history
 - Easier testing and mocking
@@ -69,17 +71,17 @@ Workflow:
 Disable retries in LLM client libraries, let Temporal handle retries.
 
 - LLM Client Config:
-  - max_retries = 0  ← Disable client retries at the LLM client level
+  - max_retries = 0 ← Disable client retries at the LLM client level
 
 Use either the default activity retry policy, or customize it as needed for the situation.
 
 **Why**:
+
 - Temporal retries are durable (survive crashes)
 - Single retry configuration point
 - Better visibility into retry attempts
 - Consistent backoff behavior
 
-
 ### Pattern 5: Multi-Agent Orchestration
 
 Complex pipelines with multiple specialized agents:
@@ -114,6 +116,7 @@ Deep Research Example:
 | Document processing | 60-120 seconds |
 
 **Rationale**:
+
 - Reasoning models need time for complex computation
 - Web searches may hit rate limits requiring backoff
 - Fast timeouts catch stuck operations
@@ -128,7 +131,6 @@ Parse rate limit info from API responses:
 - Response Headers:
   - Retry-After: 30
   - X-RateLimit-Remaining: 0
-
 - Activity:
   - If rate limited:
     - Raise retryable error with a next retry delay
@@ -137,12 +139,14 @@ Parse rate limit info from API responses:
 ## Error Handling
 
 ### Retryable Errors
+
 - Rate limits (429)
 - Timeouts
 - Temporary server errors (500, 502, 503)
 - Network errors
 
 ### Non-Retryable Errors
+
 - Invalid API key (401)
 - Invalid input/prompt
 - Content policy violations
@@ -161,6 +165,6 @@ Parse rate limit info from API responses:
 ## Observability
 
 See `references/{your_language}/observability.md` for the language you are working in for documentation on implementing observability in Temporal. It is generally recommended to add observability for:
+
 - Token usage, via activity logging
 - any else to help track LLM usage and debug agentic flows, within moderation.
-