@martinffx/atelier 2.0.0 → 3.0.1

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 
 - **breaking:** rename the `recon` agent to `sentinel`. Existing Atelier configuration is migrated automatically and legacy generated files are removed during the next command.
 
+## [3.0.1](https://github.com/martinffx/atelier/compare/v3.0.0...v3.0.1) (2026-07-31)
+
+
+### Bug Fixes
+
+* **marketplace:** register atelier setup skill ([41c0624](https://github.com/martinffx/atelier/commit/41c06243ba65330f9f47bf871040e657690dce28))
+
+## [3.0.0](https://github.com/martinffx/atelier/compare/v2.0.0...v3.0.0) (2026-07-31)
+
+
+### ⚠ BREAKING CHANGES
+
+* **claude:** consolidate plugins under atelier
+* **skills:** split language skills into companion repositories
+
+### Features
+
+* **claude:** consolidate plugins under atelier ([745f872](https://github.com/martinffx/atelier/commit/745f872193ac841074ddc16f788ded5c92cf9744))
+* **skills:** add atelier setup workflow ([69a7a93](https://github.com/martinffx/atelier/commit/69a7a9350c2f8e7d8a6001143cb4f4233f462117))
+* **skills:** split language skills into companion repositories ([b1fb1f7](https://github.com/martinffx/atelier/commit/b1fb1f7db942283bca5f067848c55e0dcc6c228f))
+
 ## [2.0.0](https://github.com/martinffx/atelier/compare/v1.4.0...v2.0.0) (2026-07-27)
 
 

package/README.md

@@ -2,27 +2,100 @@
 
 ![Atelier - A collaborative workshop for software development](atelier.jpg)
 
-> An atelier is the private workshop or studio where a principal master and a number of assistants, students, and apprentices can work together producing fine art or visual art released under the master's name or supervision.
->
-> [Wikipedia](https://en.wikipedia.org/wiki/Atelier)
+> A personal development toolkit for AI agents. It covers spec-driven development, code quality, and deep thinking.
 
-A personal development toolkit for AI agents. It covers spec-driven development, code quality, deep thinking, and ecosystem patterns.
+Atelier gives coding agents a disciplined way to move from an idea to reviewed, verified code without taking control away from the developer.
 
-Atelier includes skills installed with `npx skills` and a small CLI for generating agent definitions and configuration for supported harnesses.
+```bash
+npx skills add martinffx/atelier
+npx @martinffx/atelier@latest init --harness <claude|opencode|codex|cursor>
+```
 
-## Quick start
+## How Atelier works
 
-Install Atelier, then choose the harness you use. The CLI configures agents and harness-native settings for Claude Code, OpenCode, Codex, and Cursor.
+Atelier uses as much process as each request needs. Bounded work gets a concise plan in the conversation. Substantial work gets a durable spec, an implementation plan, and tracked execution. The developer approves the plan before implementation begins.
 
-```bash
-# Initialize atelier for your harness
-npx @martinffx/atelier@latest init --harness <claude|opencode|codex|cursor>
+```mermaid
+flowchart TD
+    R[Request] --> O[atelier-orchestrator]
+
+    O -->|Bounded work| IP[spec-plan: Inline Plan]
+    IP --> IA{Developer approval}
+    IA -->|Approved| I[Implement directly]
+    IA -.->|Revise| IP
+    I --> V[Validate]
+    V -.->|Issues found| I
+    IP -.->|Needs brainstorming| B
+    I -.->|Needs brainstorming| B
+
+    O -->|Substantial work| B[spec-brainstorm]
+    B --> D[design.md]
+    D --> G[oracle-grill-me]
+    G --> P[spec-plan]
+    G -.->|Refine design| D
+    P --> SA{Developer approval}
+    SA -->|Approved| J[plan.json]
+    SA -.->|Revise plan| P
+    SA -.->|Revisit design| B
+    J --> SI[spec-implement]
+    SI --> CR[code-review]
+    CR --> F[spec-finish]
+    F --> PR[code-pull-request]
+    SI -.->|Revise plan| P
+    SI -.->|Revisit design| B
+    F -.->|Issues found| SI
+```
+
+The workflow is deliberately harder to rush than an unstructured agent session. It records decisions when they need to survive the conversation, keeps implementation tied to an approved plan, and requires evidence before calling the work complete.
+
+## Grill the idea
+
+[`oracle-grill-me`](skills/oracle-grill-me/SKILL.md) interviews you one question at a time until the important decisions are explicit. It researches facts from the codebase instead of asking you to supply them, gives a recommended answer for each decision, and leaves the final choice with you.
+
+As the discussion resolves, it maintains the project's domain language and architectural decisions. Use it on a proposal, plan, migration, or design that feels settled a little too quickly.
 
-# Non-interactive mode (CI/CD)
-npx @martinffx/atelier@latest init --harness <claude|opencode|codex|cursor> --yes
+```text
+Grill me on this migration plan
 ```
 
-Your project is ready to use the spec workflow.
+## Review the code
+
+[`code-review`](skills/code-review/SKILL.md) runs a multi-agent review rather than asking one agent for a general opinion. Sentinel triages the diff, specialist reviewers examine likely failure modes in parallel, Architect checks design boundaries, and a final challenge pass removes weak or unsupported findings.
+
+```text
+rq             # Review the diff to main
+rq develop     # Review against another branch
+rs             # Work through the findings
+```
+
+It reports findings before changing code. You decide which fixes to apply.
+
+## What you get
+
+Atelier installs a focused set of skills for the full development loop:
+
+| Area | Capabilities |
+|------|--------------|
+| Spec workflow | Discovery, research, planning, implementation, validation, and finishing |
+| Thinking | Root-cause debugging, decision grilling, and domain modelling |
+| Delivery | Multi-agent review, subagent coordination, commits, handoffs, and pull requests |
+
+The CLI also configures three specialist agents for Claude Code, OpenCode, Codex, or Cursor:
+
+| Agent | Role |
+|-------|------|
+| **Sentinel** | Fast codebase reconnaissance and review triage |
+| **Oracle** | Requirements, trade-offs, and adversarial analysis |
+| **Architect** | Domain modelling, system design, and architecture review |
+
+Run `npx @martinffx/atelier@latest --help` for CLI commands and options. Each skill contains its own operating instructions and loads when its context applies.
+
+## Ecosystem
+
+Language-specific guidance lives in companion repositories:
+
+- [Python skills](https://github.com/martinffx/python-skills)
+- [TypeScript skills](https://github.com/martinffx/typescript-skills)
 
 ## Rationale and inspiration
 
@@ -42,7 +115,7 @@ Some Atelier skills have more direct lineage:
 
 | Atelier skill | Source skill | Relationship |
 |---------------|--------------|--------------|
-| [`spec-orchestrator`](skills/spec-orchestrator/SKILL.md) | Superpowers [`using-superpowers`](https://github.com/obra/superpowers/tree/main/skills/using-superpowers) | Adapted from its mandatory skill-routing discipline. |
+| [`atelier-orchestrator`](skills/atelier-orchestrator/SKILL.md) | Superpowers [`using-superpowers`](https://github.com/obra/superpowers/tree/main/skills/using-superpowers) | Adapted from its mandatory skill-routing discipline. |
 | [`spec-brainstorm`](skills/spec-brainstorm/SKILL.md) | Superpowers [`brainstorming`](https://github.com/obra/superpowers/tree/main/skills/brainstorming) | Adapted from its conversational discovery and section-by-section design approval. |
 | [`spec-plan`](skills/spec-plan/SKILL.md) | Superpowers [`writing-plans`](https://github.com/obra/superpowers/tree/main/skills/writing-plans) | Inspired by its explicit, verifiable implementation plans. |
 | [`spec-implement`](skills/spec-implement/SKILL.md) | Superpowers [`executing-plans`](https://github.com/obra/superpowers/tree/main/skills/executing-plans) and [`test-driven-development`](https://github.com/obra/superpowers/tree/main/skills/test-driven-development) | Inspired by plan-driven execution and test-first feedback loops. |
@@ -53,260 +126,28 @@ Some Atelier skills have more direct lineage:
 | [`oracle-domain-modelling`](skills/oracle-domain-modelling/SKILL.md) | Matt Pocock's [`domain-modeling`](https://github.com/mattpocock/skills/tree/main/skills/engineering/domain-modeling) | Adapted from its active domain-modelling discipline, `CONTEXT.md`, and lightweight ADRs. |
 | [`oracle-debug`](skills/oracle-debug/SKILL.md) | Superpowers [`systematic-debugging`](https://github.com/obra/superpowers/tree/main/skills/systematic-debugging) and Matt Pocock's [`diagnosing-bugs`](https://github.com/mattpocock/skills/tree/main/skills/engineering/diagnosing-bugs) | Adapted from their root-cause-first debugging workflows. |
 
-Elsewhere, [`typescript-functional-patterns`](skills/typescript-functional-patterns/SKILL.md) draws on Rastrian's [Why Reliability Demands Functional Programming, ADTs, Safety and Critical Infrastructure](https://blog.rastrian.dev/post/why-reliability-demands-functional-programming-adts-safety-and-critical-infrastructure), and [`code-commit`](skills/code-commit/SKILL.md) follows the [Conventional Commits](https://www.conventionalcommits.org/) specification.
+[`code-commit`](skills/code-commit/SKILL.md) follows the [Conventional Commits](https://www.conventionalcommits.org/) specification.
 
 Atelier adapts these ideas into an opinionated toolkit that works across harnesses. It does not claim to have invented the practices it uses.
 
-## What gets installed
-
-Atelier sets up the following:
-
-### 1. Skills (29 available)
-
-Skills are specialized knowledge modules that load when their context applies. Install them separately:
-
-```bash
-npx skills add martinffx/atelier
-```
-
-### 2. Agent personas (3 subagents)
-
-Agent definitions are generated for each supported harness with appropriate models:
-
-| Agent | Role | Claude | OpenCode | Codex | Cursor |
-|-------|------|--------|----------|-------|--------|
-| **Sentinel** | Fast codebase reconnaissance | haiku | deepseek-v4-flash | gpt-5.6-luna | composer-2.5 |
-| **Oracle** | Strategic thinking, requirements, analysis | opus | kimi-k2.6 | gpt-5.6-sol | claude-opus-4-8-high |
-| **Architect** | DDD, system design, architecture | opus | deepseek-v4-pro | gpt-5.6-sol | gpt-5.6-sol-medium |
-
-The CLI writes agents to harness-specific locations: `.claude/agents/`, `.opencode/agent/`, `.codex/agents/`, or `~/.cursor/agents/`. It uses each harness's model identifiers. Cursor's primary model and `~/.cursor/cli-config.json` remain user-managed. Atelier only creates its three global subagents.
-
-The agent personas carry a light *Matrix* theme. Sentinel takes after the Sentinels: it moves quickly through the codebase, locating what matters and reporting back. Oracle clarifies human needs and choices under uncertainty. Architect turns those requirements into structured technical designs.
-
-### 3. Task tracking (optional)
-
-The spec workflow can use **beads** for dependency-aware task tracking:
-
-```bash
-# Install beads (optional but recommended)
-npm install -g beads
-```
-
-Beads provides `bd ready` to find unblocked tasks, `bd dep add` to manage dependencies, and `bd list` to show progress. Harness-native todo systems do not provide the same dependency support.
-
-If beads is unavailable, skills use the harness's native todo system: TodoWrite for Claude Code or built-in todos for OpenCode.
-
-### 4. Configuration
-
-Single source of truth in `.atelier/config.json`:
-
-```json
-{
-  "version": "1.0.0",
-  "skills_source": "martinffx/atelier",
-  "skills_path": "~/.agents/skills",
-  "claude": {
-    "provider": "anthropic",
-    "default_model": "opusplan",
-    "agents": [
-      { "template": "sentinel", "name": "sentinel", "model": "haiku" },
-      { "template": "oracle", "name": "oracle", "model": "opus" },
-      { "template": "architect", "name": "architect", "model": "opus" }
-    ]
-  }
-}
-```
-
-## CLI commands
-
-### `init` (default)
-
-Initialize Atelier for one harness. Run the command again for each additional harness.
-
-```bash
-npx @martinffx/atelier@latest init --harness <claude|opencode|codex|cursor> [options]
-```
-
-Options:
-- `--harness <type>` - Harness type (`claude`, `opencode`, `codex`, or `cursor`)
-- `--yes` - Non-interactive mode with default models
-
-You can safely re-run `init` for the same harness. It regenerates its files and does not delete existing files unless you switch harnesses.
-
-### `update`
-
-Refresh agents and harness-native config for one harness without touching skills:
-
-```bash
-npx @martinffx/atelier@latest update --harness <claude|opencode|codex|cursor>
-```
-
-### `remove`
-
-Remove all atelier-generated files for one harness:
-
-```bash
-npx @martinffx/atelier@latest remove --harness <claude|opencode|codex|cursor>
-```
-
-Skills remain installed. Run `npx skills remove martinffx/atelier` to remove them separately.
-
-## Skills
-
-This repository includes 29 skills for agent workflows and stack-specific guidance.
-
-### Installing skills
-
-Install skills manually:
-
-```bash
-# Install all skills
-npx skills add martinffx/atelier
-
-# Install specific skills
-npx skills add martinffx/atelier --skill typescript-drizzle-orm
-npx skills add martinffx/atelier --skill python-fastapi
-npx skills add martinffx/atelier --skill spec-brainstorm
-```
-
-### Skill organization
-
-Atelier has three core skill namespaces:
-
-| Namespace | Type | Invocation | Output | Flexibility |
-|-----------|------|------------|--------|-------------|
-| `spec:` | Process | User or previous skill | Plan or artifact | Follow exactly |
-| `oracle:` | Analytical | Context-driven | Guidance | Adapt to context |
-| `code:` | Utility | User | Result | Use as needed |
-
-#### Workflow (`spec:*`)
-
-These skills guide plan-first development. Inline Plans stay in the conversation; substantial
-work uses persisted spec artifacts.
-
-- `spec-orchestrator`: select Inline Plan or Spec-backed Plan and route the workflow
-- `spec-brainstorm` → `design.md`: discovery, requirements, and architecture for substantial work
-- `spec-plan`: produce a conversational Inline Plan or persisted `plan.json`
-- `spec-implement`: execute approved Spec-backed Plans with TDD
-- `spec-finish`: validate, review, and prepare Spec-backed Plans for a PR
-
-#### Thinking (`oracle:*`)
-
-These skills provide analytical methods and reasoning patterns that adapt to the problem at hand.
-
-- `oracle-debug`: systematic debugging that finds the root cause before a fix
-- `oracle-grill-me`: Socratic review of plans, specs, decisions, and ideas until ambiguity is resolved, shared understanding is reached, and the resulting domain language and decisions are recorded
-- `oracle-domain-modelling`: build and refine the project's domain model
-
-#### Utilities (`code:*`)
-
-These skills handle discrete tasks when you invoke them.
-
-- `code-commit`: generate and validate conventional commits
-- `code-handoff`: turn a conversation into a handoff document
-- `code-pull-request`: create, comment on, and merge GitHub pull requests or GitLab merge requests
-- `code-review`: multi-agent code review with specialized reviewers
-- `code-subagents`: dispatch patterns for parallel implementation
-
-#### Stack-specific knowledge
-
-Python and TypeScript skills provide technology-specific patterns and practices. They support work across the `spec`, `oracle`, and `code` namespaces.
-
-**TypeScript (8 skills)**
-- `typescript-api-design`: REST conventions, error responses, and pagination
-- `typescript-fastify`: Fastify and TypeBox route handlers
-- `typescript-drizzle-orm`: type-safe SQL schemas and queries
-- `typescript-dynamodb-toolbox`: single-table design and GSIs
-- `typescript-functional-patterns`: ADTs, branded types, and Option/Result
-- `typescript-effect-ts`: functional effects, error handling, and resources
-- `typescript-build-tools`: Bun, Vitest, Biome, and Turborepo
-- `typescript-testing`: mocking, MSW, and snapshot testing
-
-**Python (8 skills)**
-- `python-architecture`: functional core/shell, DDD, and layered architecture
-- `python-fastapi`: Pydantic validation, dependency injection, and OpenAPI
-- `python-sqlalchemy`: ORM patterns, queries, async, and upserts
-- `python-temporal`: workflow orchestration, activities, and error handling
-- `python-modern-python`: type hints, generics, and pattern matching
-- `python-monorepo`: uv workspaces and mise task orchestration
-- `python-testing`: stub-driven TDD and pytest patterns
-- `python-build-tools`: uv, ruff, basedpyright, and pytest configuration
-
-Skills load based on their descriptions when the work calls for them. Install them once, then agents can use them as needed.
-
-## How skills work
-
-Skills load from context. For example, "create a spec for user auth" makes
-`spec-orchestrator` select the spec-backed route and invoke `spec-brainstorm`.
-
-### The planning workflow
-
-For bounded work, `spec-plan` presents a simple Inline Plan for approval, then the agent
-implements it directly. No spec artifacts, task tracking, or persisted-spec execution
-workflow is involved.
-
-The full planning workflow is:
-
-```mermaid
-graph LR
-    B[spec-brainstorm] --> D[design.md]
-    D --> G[oracle-grill-me]
-    G -->|design approved| P[spec-plan: review and approve]
-    G -.->|refine| D
-    P --> J[plan.json]
-    J --> I[spec-implement]
-    I --> F[spec-finish]
-    F --> PR[code-pull-request]
-    I -.->|revise plan| P
-    I -.->|design issue| B
-```
-
-The orchestrator chooses one route and states why:
-
-- **Inline Plan (default):** bounded, well-understood work. The plan uses `context`, `scope`,
-  `changes`, `files`, and `validation` in conversation. It creates no spec or tracker artifacts.
-- **Spec-backed Plan:** substantial work that needs discovery, architectural decisions,
-  dependency tracking, durable handoff, or explicit spec artifacts. It uses `design.md` and
-  `plan.json`.
-
-Both routes require human approval before implementation. File count and estimated duration
-alone do not make work spec-worthy, and the human can override the selected route.
-
-### When to use which skill
-
-| User says | Skill invoked |
-|------------|---------------|
-| "Create a spec for X" | spec-orchestrator → spec-brainstorm |
-| "What should we build" | spec-orchestrator selects the planning route |
-| "Write a plan" | spec-orchestrator → spec-plan (Inline by default) |
-| "Implement this" | spec-orchestrator |
-| "Review this code" | code-review |
-| "Open a PR" | code-pull-request |
-| "Merge this PR" | code-pull-request |
-| "Read PR comments" | code-pull-request |
-| "Leave a comment on the PR" | code-pull-request |
-| "Debug this" | oracle-debug |
-
 ## Development
 
-For local development with Claude Code, load skills directly with `--plugin-dir`:
+Load the repository directly in Claude Code:
 
 ```bash
 claude --plugin-dir ./atelier
 ```
 
-Restart Claude Code after making changes to reload skills.
-
-To work on the CLI itself:
+Build and test the CLI:
 
 ```bash
-# Build the CLI
 bun run build
-
-# Test locally
-bun ./dist/atelier.js init --yes
+bun test
+bun run typecheck
 ```
 
+Restart your coding harness after changing skills so it reloads their definitions.
+
 ## License
 
 MIT Copyright (c) 2026 Martin Richards

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinffx/atelier",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "description": "Personal development toolkit - spec-driven development, code quality, deep thinking, and ecosystem patterns",
   "type": "module",
   "bin": {

package/skills/{spec-orchestrator → atelier-orchestrator}/SKILL.md

@@ -1,8 +1,8 @@
 ---
-name: spec-orchestrator
+name: atelier-orchestrator
 description: >
   Skill routing and workflow orchestration. Selects Inline Plan or Spec-backed Plan, routes
-  to the correct workflow skill, and manages transitions between phases. Use when starting
+   to the correct workflow skill, and manages transitions between phases. Use when starting
   any conversation or task to determine which planning mode and skill apply.
 user-invocable: false
 ---
@@ -76,7 +76,7 @@ Do not infer substantial work from size alone. If no concrete signal applies, us
 ## Skill Routing
 
 ```
-spec-orchestrator → Select and announce planning mode
+atelier-orchestrator → Select and announce planning mode
 spec-brainstorm   → Spec-backed discovery + design → design.md
 spec-plan         → Inline Plan or Spec-backed Plan → approval
 spec-implement    → Execute approved Spec-backed Plans; track tasks

package/skills/atelier-setup/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: atelier-setup
+description: Configure a repository's generic agent guidance for Atelier's development workflow. Use only when the user explicitly invokes atelier-setup; it inspects existing repository instructions and domain-document conventions, previews an idempotent project-guidance update, and writes only after approval. It does not install Atelier, configure a harness, or scaffold empty workflow artifacts.
+user-invocable: true
+---
+
+# Atelier Setup
+
+Set up generic repository guidance that Atelier skills need without taking ownership of the
+developer's installation, harness configuration, or project structure. Explore first, present
+the proposed edit exactly, and write only after the developer approves it.
+
+## 1. Explore
+
+Read the repository before proposing any change:
+
+- Root `AGENTS.md` and `CLAUDE.md`, if present. Note whether either already has an `## Agent skills`
+  heading.
+- Root `CONTEXT.md` and `CONTEXT-MAP.md`.
+- `docs/adr/` and any context-local `docs/adr/` directories.
+- Genuine monorepo signals: a workspace manifest, or multiple independently deployable packages
+  with their own source directories.
+
+Do not create, install, configure, or modify anything during exploration.
+
+## 2. Present Findings
+
+Summarize what exists and recommend a domain-document layout:
+
+- **Single-context** is the default: domain language belongs in root `CONTEXT.md`; architectural
+  decisions belong in root `docs/adr/`.
+- **Multi-context** is appropriate only when the repository has genuinely separate bounded
+  contexts. `CONTEXT-MAP.md` belongs at the root and points to each context's `CONTEXT.md` and
+  `docs/adr/` directory.
+
+Explain that these documents remain lazy: do not create `CONTEXT.md`, `CONTEXT-MAP.md`, or an ADR
+directory until another Atelier skill has resolved terminology or made a decision worth recording.
+
+Select the instruction file to edit:
+
+1. If both files exist, ask which file should own the agent guidance; do not duplicate it.
+2. Otherwise use root `AGENTS.md` when it exists.
+3. Otherwise use root `CLAUDE.md` when it exists.
+4. If neither exists, ask which instruction file to create; do not choose on the developer's behalf.
+
+Show the developer the selected file, domain layout, and the exact `## Agent skills` block that will be
+written. Stop and wait for explicit approval.
+
+## 3. Write After Approval
+
+Add the following block to the selected instruction file:
+
+```markdown
+## Agent skills
+
+### Planning and implementation
+
+Use `atelier-orchestrator` at the start of development work. It selects an Inline Plan for bounded
+changes or a Spec-backed Plan when durable design and coordination artifacts are warranted.
+
+### Domain documentation
+
+Before working in a domain area, read root `CONTEXT-MAP.md` when present and follow it to the
+relevant context documentation. Otherwise, read root `CONTEXT.md` when present. Read relevant
+architectural decisions under `docs/adr/` and any context-specific ADR directories.
+
+If these documents do not exist, proceed silently. Create or update them only when domain
+terminology or an architectural decision has been resolved.
+```
+
+If an `## Agent skills` section already exists, update the `### Planning and implementation` and
+`### Domain documentation` subsections in place rather than appending duplicates. Preserve other
+subsections and all content outside the section, including user edits. Do not create any other
+files or directories.
+
+## 4. Report
+
+State which instruction file changed and the chosen domain-document layout. Remind the developer
+that the layout is a convention only: the first domain-modelling or architectural-decision task
+creates the relevant documents when it has substantive content.

package/skills/code-review/references/reviewers.md

@@ -673,7 +673,7 @@ prompt: |
 
   YOUR FIRST TASK - LOOK FOR RELEVANT SKILLS:
   As a Security Reviewer, look for relevant language, framework, testing, architecture, security, or tooling skills before reviewing.
-  Load relevant skills if available, such as `typescript-testing`.
+  Load relevant installed language, framework, testing, architecture, security, or tooling skills.
   If no relevant skill is available or a skill cannot be loaded, continue with this reviewer prompt.
   Failure to find or load a skill is not a review failure.
 
@@ -719,7 +719,7 @@ prompt: |
 
   YOUR FIRST TASK - LOOK FOR RELEVANT SKILLS:
   As a Correctness Reviewer, look for relevant language, framework, testing, architecture, security, or tooling skills before reviewing.
-  Load relevant skills if available, such as `typescript-testing`.
+  Load relevant installed language, framework, testing, architecture, security, or tooling skills.
   If no relevant skill is available or a skill cannot be loaded, continue with this reviewer prompt.
   Failure to find or load a skill is not a review failure.
 
@@ -755,7 +755,7 @@ prompt: |
 
   YOUR FIRST TASK - LOOK FOR RELEVANT SKILLS:
   As a PerformanceOperator Reviewer, look for relevant language, framework, testing, architecture, security, or tooling skills before reviewing.
-  Load relevant skills if available, such as `typescript-testing`.
+  Load relevant installed language, framework, testing, architecture, security, or tooling skills.
   If no relevant skill is available or a skill cannot be loaded, continue with this reviewer prompt.
   Failure to find or load a skill is not a review failure.
 

package/skills/code-review/references/rq.md

@@ -67,8 +67,8 @@ prompt: |
      - Reviewers should load relevant skills that are available.
      - If no relevant skill is available, reviewers continue with their reviewer prompt.
      - Failure to find or load a skill is not a review failure.
-     - TypeScript → typescript-testing, typescript-fastify (if fastify framework)
-     - Python → python-modern-python, python-testing, python-fastapi (if fastapi framework)
+     - TypeScript → installed TypeScript language, testing, and framework skills
+     - Python → installed Python language, testing, and framework skills
      - Rust → rust-specific skills if available
      - Go → go-specific skills if available
      
@@ -81,7 +81,7 @@ prompt: |
       "domain": "web-api|frontend|database|..."
     },
     "reviewers": ["Security", "Correctness"],
-    "skills_to_load": ["typescript-testing"]
+    "skills_to_load": ["relevant installed testing skill"]
   }
 ```
 
@@ -93,7 +93,7 @@ prompt: |
 {
   "context": { "language": "typescript", "framework": "fastify", "domain": "web-api" },
   "reviewers": ["Security", "Correctness", "PerformanceOperator"],
-  "skills_to_load": ["typescript-testing"]
+  "skills_to_load": ["relevant installed testing skill"]
 }
 ```
 
@@ -114,7 +114,7 @@ Reviewer names are prompt personas, not subagent types. Do not use `general`, `S
 Before dispatching reviewers, the detected relevant skills are passed to each reviewer as best-effort guidance:
 ```json
 {
-  "skills_to_load": ["typescript-testing"]
+  "skills_to_load": ["relevant installed testing skill"]
 }
 ```
 
@@ -263,7 +263,7 @@ prompt: |
 
   **PRE-STEP: Look for Relevant Skills**
   Before reviewing, look for relevant architecture and language architecture skills.
-  Load relevant skills if available, such as `typescript-api-design` or the language skill for this codebase.
+  Load relevant installed language, framework, testing, architecture, security, or tooling skills.
   If no relevant skill is available or a skill cannot be loaded, continue with this architect prompt.
   Failure to find or load a skill is not a review failure.
 

package/skills/spec-brainstorm/SKILL.md

@@ -5,8 +5,8 @@ description: >
   at a time, explores 2-3 approaches with trade-offs, and presents the design
   section by section for approval before writing the spec. Combines requirements
   discovery with codebase research and architecture design.
-  Use when the user explicitly requests a spec or when spec-orchestrator selects a
-  Spec-backed Plan. Ambiguous design or discovery requests route through spec-orchestrator.
+  Use when the user explicitly requests a spec or when atelier-orchestrator selects a
+  Spec-backed Plan. Ambiguous design or discovery requests route through atelier-orchestrator.
 user-invocable: true
 argument-hint: <topic or feature description>
 ---
@@ -18,7 +18,7 @@ Conversational design workshop for substantial work that produces a focused, rev
 One question at a time. Multiple approaches explored. Design approved in
 sections. Ruthless scope control. No implementation until design is approved.
 
-Run this skill only after `spec-orchestrator` selects a Spec-backed Plan or the human
+Run this skill only after `atelier-orchestrator` selects a Spec-backed Plan or the human
 explicitly requests a spec. Bounded work should go directly to `spec-plan` for an Inline
 Plan. Do not reclassify the planning mode here.
 
@@ -215,7 +215,7 @@ with acceptance criteria and priorities. If rejected: revise. If the rejection
 reveals a scope misunderstanding, loop back to Discovery (Step 2).
 
 **Batch B: Architecture** — component design, domain modeling, and layer
-boundaries. Use `python-architecture` or `typescript-api-design` as relevant to
+boundaries. Use installed language-specific architecture or API-design skills as relevant to
 your stack. Then present: component structure, domain model, where business
 logic lives, where IO lives. If rejected: revise. If the rejection undermines
 the chosen approach, offer to return to approach exploration (4a). If it
@@ -346,5 +346,5 @@ approval before continuing.
 The next step is **spec-plan** in Spec-backed mode. Do not start planning without the
 human's go-ahead. Do not write code.
 
-If planning reveals design flaws, loop back to research. See **spec-orchestrator**
+If planning reveals design flaws, loop back to research. See **atelier-orchestrator**
 for iteration patterns.

package/skills/spec-implement/SKILL.md

@@ -112,8 +112,7 @@ Update the todo status to in_progress.
 Read the task's **inputs** and **description** first.
 
 Write tests that cover the validation criteria before writing implementation.
-Invoke `typescript-testing` or `python-testing` (whichever matches the project)
-for test design patterns when needed.
+Invoke an installed language-specific testing skill when needed.
 
 ```
 1. Read task inputs and description
@@ -294,5 +293,5 @@ Offer the human their options:
 
 Don't choose for them. Present options and wait.
 
-If validation finds bugs, loop back to implement. See **spec-orchestrator**
+If validation finds bugs, loop back to implement. See **atelier-orchestrator**
 for iteration patterns.