PR Tracking Initial Release

.claude-plugin/marketplace.json

@@ -0,0 +1,15 @@
+{
+  "name": "temporal-marketplace",
+  "metadata": {
+    "description": "A marketplace of Claude Code plugins for working with Temporal (temporal.io)"
+  },
+  "owner": {
+    "name": "Temporal"
+  },
+  "plugins": [
+    {
+      "name": "temporal-developer",
+      "source": "./plugins/temporal-developer"
+    }
+  ]
+}

.claude/settings.json

@@ -0,0 +1,5 @@
+{
+  "enabledPlugins": {
+    "plugin-dev@claude-plugins-official": true
+  }
+}

.claude/skills/edit-plugin-skills/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: edit-plugin-skills
+description: This skill should be used when the user asks to "edit a skill", "update reference files", "fix a reference", "check alignment", "check correctness", "verify code examples", "update tracking", "add a new language", "edit plugin content", "modify skill references", "resume correctness verification", "check tracking status", "memory files", "run alignment checks", or mentions working on files inside plugins/ or .memory/ directories.
+version: 0.1.0
+---
+
+# Editing Plugin Skills
+
+## Overview
+
+This repository contains plugin skills with reference files organized by topic and language. Edits to these files must be tracked through two systems: **alignment checking** (structure and style) and **correctness checking** (factual accuracy). The tracking/memory documents in `.memory/` serve as shared state between sessions and agents.
+
+## Repository Structure
+
+```
+plugins/<plugin-name>/skills/<skill-name>/
+├── SKILL.md
+└── references/
+    ├── core/          # Conceptual content (language-agnostic)
+    ├── python/        # Python-specific code and guidance
+    ├── typescript/    # TypeScript-specific code and guidance
+    └── go/            # Go-specific (future)
+
+.memory/
+├── alignment_checking/   # Structure and style tracking
+│   ├── README.md
+│   └── <topic>.md        # One file per reference topic
+└── correctness_checking/ # Factual accuracy tracking
+    ├── README.md
+    └── <topic>.md        # One file per reference topic
+```
+
+**Key principle:** Concepts belong in `core/`, language-specific code belongs in language directories. Avoid duplicating conceptual content across languages.
+
+## Workflow: Editing Reference Files
+
+### Step 1: Identify What to Edit
+
+Determine the scope of the change:
+- Which reference file(s) to modify
+- Whether the change affects structure, content, or both
+- Which languages are impacted
+
+### Step 2: Read Current Memory State
+
+Before making edits, read the relevant memory files to understand current state:
+- `.memory/alignment_checking/<topic>.md` for structure/style status
+- `.memory/correctness_checking/<topic>.md` for verification status
+
+For alignment work, also read `.memory/alignment_checking/README.md` for the style target and legends. For correctness work, read `.memory/correctness_checking/README.md` for the verification workflow and status values.
+
+See `references/memory-formats.md` for detailed table formats and field descriptions.
+
+### Step 3: Make the Edit
+
+Edit the reference file(s) in `plugins/`. Complete all changes before updating memory.
+
+### Step 4: Update Memory Documents
+
+After completing edits, update the relevant memory documents. Refer to the protocol table below.
+
+| Situation | Update |
+|-----------|--------|
+| Reorganizing sections between files | alignment_checking/ |
+| Removing duplicate conceptual content | alignment_checking/ |
+| Adjusting prose style (code-first, minimal prose) | alignment_checking/ |
+| Adding a new language (e.g., Go) | Both directories |
+| Fixing incorrect code example | correctness_checking/ |
+| Receiving SDK team feedback | correctness_checking/ |
+| Verifying content against official docs | correctness_checking/ |
+| Adding new reference content | Both directories |
+
+### Step 5: Verify No Staleness
+
+Memory docs must reflect **current state**, not pending work.
+
+**Do:**
+- Complete the work first, then update the memory doc
+- Update inventory tables directly (change `✓` to `—` when removing a section)
+- Summarize completed changes in the Style Alignment section
+
+**Do not:**
+- Leave `Sections marked DEL:` or `Sections marked TODO:` lists
+- Leave `Action items:` lists with checkboxes
+- Leave any list of "things to do" that persists after completion
+
+**Correct example:**
+```markdown
+**Style alignment:** ✅ Complete. Removed OpenTelemetry (too detailed).
+```
+
+**Incorrect example:**
+```markdown
+**Action items:** ✅ All completed
+- ✅ Removed OpenTelemetry section
+```
+
+## Correctness Verification Workflow
+
+When verifying factual accuracy of code examples and statements:
+
+1. Read the section from the reference file
+2. Query documentation sources using MCP tools (see `references/memory-formats.md` for tool names and library IDs)
+3. Compare code examples against official docs
+4. Apply fixes to source file if needed
+5. Update memory table: Status, Fix Applied, Sources columns
+6. Update Detailed Notes with verification details
+
+See `references/memory-formats.md` for status values and detailed table format.
+
+**To resume correctness work:** Check the summary table in `.memory/correctness_checking/README.md`, then find the first `unchecked` or `needs fixes` section.
+
+## Alignment Checking
+
+**Style target:** Python is the reference style (code-first, minimal prose). All languages should match.
+
+When checking or adjusting alignment:
+1. Read the Section Inventory table in `.memory/alignment_checking/<topic>.md`
+2. Verify sections exist where expected (`✓`), are intentionally missing (`—`), or need review
+3. Check section ordering numbers (`Py#` / `TS#` / `Go#`) increase monotonically
+4. Review Style Compliance status per language
+
+See `references/memory-formats.md` for the complete legend and table format.
+
+## Adding a New Language
+
+When adding a new language (e.g., Go):
+1. Create `references/<language>/` directory with language-specific files
+2. Update alignment memory: add column to Section Inventory tables in each `.memory/alignment_checking/<topic>.md`
+3. Update correctness memory: add `## {Language}` section to each `.memory/correctness_checking/<topic>.md`
+4. Update summary tables in both README files
+
+## References
+
+- **`references/memory-formats.md`** — Detailed format specifications for alignment and correctness memory tables

.claude/skills/edit-plugin-skills/references/memory-formats.md

@@ -0,0 +1,110 @@
+# Tracking/Memory Document Formats
+
+Detailed format specifications for the two memory/tracking systems used in this repository.
+
+## Alignment Checking
+
+**Location:** `.memory/alignment_checking/`
+
+Each file tracks one reference topic (e.g., `patterns.md` tracks all `references/*/patterns.md` files).
+
+### Section Inventory Table
+
+```markdown
+| Section | Core | Python | Py# | TypeScript | TS# | Go | Go# |
+|---------|------|--------|-----|------------|-----|-----|-----|
+| Signals | ✓ | ✓ | 1 | ✓ | 1 | | |
+| Dynamic Handlers | — | ✓ | 2 | ✓ | 2 | | |
+```
+
+**Column meanings:**
+- `Core` / `Python` / `TypeScript` / `Go` — presence: `✓` = present, `—` = intentionally missing, empty = needs review, `TODO` = should add, `DEL` = should remove
+- `Py#` / `TS#` / `Go#` — section order number (should monotonically increase if aligned with reference)
+
+### Style Compliance Table
+
+```markdown
+| Language | Status | Notes |
+|----------|--------|-------|
+| Python | ✓ reference | Defines the target style |
+| TypeScript | ✓ aligned | Matches reference |
+| Go | — | Not started |
+```
+
+**Status values:** `✓ reference`, `✓ aligned`, `⚠️ needs work`, `—` (not started)
+
+### Status Section
+
+Document three things:
+1. **Sections needing review** — empty cells, with explanation
+2. **Intentionally missing** — why certain `—` entries exist
+3. **Order alignment** — whether language order numbers increase monotonically
+4. **Style alignment** — summary of completed style work (not TODO lists)
+
+---
+
+## Correctness Checking
+
+**Location:** `.memory/correctness_checking/`
+
+Each file tracks one reference topic, organized by language sections (`## TypeScript`, `## Python`).
+
+### Tracking Table
+
+```markdown
+| # | Section | Status | Fix Applied | Sources |
+|---|---------|--------|-------------|---------|
+| 1 | Signals | all good | | context7 sdk-typescript |
+| 2 | Dynamic Handlers | FIXED | Used setDefaultSignalHandler | context7 sdk-typescript |
+| 3 | Queries | needs fixes | | context7 sdk-typescript |
+```
+
+**Status values:**
+- `unchecked` — not yet verified
+- `all good` — verified correct, no changes needed
+- `needs fixes` — issues found but not yet corrected
+- `FIXED` — issues found and corrected
+
+**Fix Applied:** Brief description of what was changed (empty if no fix needed)
+
+**Sources:** Which documentation sources were consulted (e.g., `context7 sdk-typescript`, `temporal-docs`, `SDK team feedback`)
+
+### Detailed Notes
+
+Below each tracking table, include a subsection per row with:
+
+```markdown
+#### 1. Section Name
+**Status:** all good | needs fixes | FIXED
+
+**Verified:** (for all good)
+- Specific fact checked ✓
+
+**Issues:** (for needs fixes / FIXED)
+- Description of the problem
+- What the correct behavior should be
+
+**Before/After:** (for FIXED, include code snippets)
+
+**Source:** URL or reference
+```
+
+### Verification Sources
+
+Use these MCP tools for verification:
+- `mcp__context7__query-docs` — SDK-specific code verification (use with library IDs like `/temporalio/sdk-typescript` or `/temporalio/sdk-python`)
+- `mcp__temporal-docs__search_temporal_knowledge_sources` — conceptual verification against Temporal documentation
+
+### Summary Table (README.md)
+
+The `.memory/correctness_checking/README.md` contains a summary table:
+
+```markdown
+| File | TypeScript | Python | Go |
+|------|------------|--------|-----|
+| patterns.md | ✅ | partial | — |
+```
+
+**Legend:** `✅` = all sections verified, `partial` = some sections need fixes/unchecked, `unchecked` = not yet verified, `—` = N/A
+
+Update this table whenever a file's overall status changes.

.claude/skills/translate-skill-to/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: translate-skill-to
+description: Translates the skill to another language
+disable-model-invocation: true
+---
+
+The skill at @plugins/temporal-developer/skills/temporal-developer/ currently supports Python and TypeScript. Your task is to add
+support for $ARGUMENTS. 
+
+First, make sure that we are working off of a fresh branch for both this repo and the git submodule at plugins/temporal-developer/skills/temporal-developer. The branch should be branched from `dev`. If the user is already on a feature branch or has non-clean Git state, communicate with the user, DON'T just nuke their git state.
+
+You will then add support for $ARGUMENTS in phases:
+
+1) Create/update alignment docs for the $ARGUMENTS content, to determine * what is appropriate for $ARGUMENTS *. Many things in core/python/typescript
+  will be directly relevant for $ARGUMENTS. But somethings might not be (sandboxing, etc.). You must determine these case-by-case, using the
+  temporal docs mcp server. Expected output of this step: updated/new alignment memory docs. Do not yet write actual content / code
+  examples. Make sure not to remove/overwrite all the existing notes (Python, TypeScript, etc.) as those are important to keep. Once approved, commit it.
+
+2) Create all the code examples for $ARGUMENTS, that are specified in the alignment memory docs you just wrote. They should follow
+  stylistic guidelines that generally match the Python and TypeScript content, but obviously should be appropriate for $ARGUMENTS. You should likely use the temporal docs MCP server to lookup code samples. This step is potentially massively parallizable. When done, commit it.
+
+3) Do a detailed self-review pass for *alignment* level issues for $ARGUMENTS, compared to Python/TypeScript. Don't yet worry about correctness, just presence/lack of content, and more/less verbosity. Mistakes you likely made: a) Python had a section who's content is merely just "See ... for more info". In $ARGUMENTS you incorrectly filled that out with full content. b) Missing section/subsections. c) Slightly differently named sections for no reason. As you work through this self-review, you may find that the alignment memory docs were unclear/ambiguous. If that is the case, update them for clarity. When all done, commit this.
+
+4) Do a correctness checking pass, to look for issues. Do not yet fix any issues, just identify them and update the correctness
+  memory doc with reserach on what the appropriate fix is. This step is potentially massively parallizable. Make sure not to remove/overwrite all the existing notes (Python, TypeScript, etc.) as those are important to keep. Ask for review from user about all correctness issues and your ideas for fixes. When approved, commit this.
+
+5) Apply the correctness edits to the actual content files. This step is potentially massively parallizable. When done, commit this.
+
+6) Update all files that reference supported languages to include $ARGUMENTS:
+  - `SKILL.md` frontmatter `description` field: add trigger phrases like "Temporal $ARGUMENTS"
+  - `SKILL.md` Overview: update the list of supported languages
+  - `SKILL.md` Getting Started > Read All Relevant References: add entry for $ARGUMENTS
+  - `references/core/determinism.md` SDK Protection Mechanisms: add $ARGUMENTS entry describing its determinism enforcement approach
+  - Any other `core/` files that enumerate languages explicitly
+  When done, commit this.
+
+Do these steps one at a time, asking for human review after each step.
+
+Make sure to use the /edit-plugin-skills skill to have an understanding of how to work with the alignment and correctness memory docs.
+
+As a general rule, prefer the temporal-docs server over context7, as it is generally more accurate. Use context7 to fill in information you can't otherwise get.

.github/CODEOWNERS

@@ -0,0 +1 @@
+*       @temporalio/ai-sdk

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "plugins/temporal-developer/skills/temporal-developer"]
+	path = plugins/temporal-developer/skills/temporal-developer
+	url = https://github.com/temporalio/skill-temporal-developer

.memory/alignment_checking/README.md

@@ -0,0 +1,47 @@
+# Alignment Checking
+
+Track content alignment (do files have the right sections?) and style alignment (is prose level appropriate?) across reference files for the **temporal-developer** skill.
+
+**Skill location:** `plugins/temporal-developer/skills/temporal-developer/`
+**Reference files:** `plugins/temporal-developer/skills/temporal-developer/references/`
+
+## Style Target
+
+Python is the reference style (code-first, minimal prose). All languages should match.
+
+**Style compliance legend:**
+- `✓ reference` = defines the target style
+- `✓ aligned` = matches reference style
+- `⚠️ needs work` = has style issues to address
+- `—` = not started
+
+## Section Inventory Legend
+
+- `✓` = present
+- ` ` (empty) = missing, unknown if intentional (needs review)
+- `—` = missing, intentional (language doesn't need this)
+- `TODO` = missing, should add
+- `DEL` = present, should remove or merge
+- `Py#` / `TS#` / `Go#` = section order in file (should monotonically increase if order is aligned)
+
+## Implementation Status
+
+**Python/TypeScript:** ✅ COMPLETE (2026-02-25) — All TODO/DEL/BUG items implemented.
+
+**Go:** ✅ COMPLETE (2026-03-17) — All Go reference files created and aligned.
+
+## Files
+
+Each file in this directory tracks alignment for a corresponding reference file:
+
+- [patterns.md](./patterns.md)
+- [data-handling.md](./data-handling.md)
+- [error-handling.md](./error-handling.md)
+- [gotchas.md](./gotchas.md)
+- [observability.md](./observability.md)
+- [testing.md](./testing.md)
+- [versioning.md](./versioning.md)
+- [language.md](./language.md) — top-level `{language}.md` files (python.md, typescript.md, etc.)
+- [determinism-protection.md](./determinism-protection.md)
+- [determinism.md](./determinism.md)
+- [advanced-features.md](./advanced-features.md)