ts-procedures 5.10.0 → 5.12.0

package/agent_config/bin/postinstall.mjs

@@ -64,19 +64,19 @@ function updateMarkedFile(targetPath, sourceRelativePath) {
 
 // ─── Auto-update ──────────────────────────────────────────
 
-const rulesFile = join(projectRoot, '.claude', 'rules', 'ts-procedures.md');
+const claudeSkillDir = join(projectRoot, '.claude', 'skills', 'ts-procedures');
 const cursorFile = join(projectRoot, '.cursorrules');
 const copilotFile = join(projectRoot, '.github', 'copilot-instructions.md');
 
 // Check if any target was previously set up
-const hasAnySetup = existsSync(rulesFile) || existsSync(cursorFile) || existsSync(copilotFile);
+const hasAnySetup = existsSync(claudeSkillDir) || existsSync(cursorFile) || existsSync(copilotFile);
 
 if (hasAnySetup) {
   try {
     const updated = [];
 
     // Auto-update Claude Code files
-    if (existsSync(rulesFile)) {
+    if (existsSync(claudeSkillDir)) {
       const { installClaude } = await import('../lib/install-claude.mjs');
       installClaude(projectRoot);
       updated.push('Claude Code');

package/agent_config/bin/setup.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
@@ -23,7 +23,7 @@ function printUsage() {
 Usage: npx ts-procedures-setup [targets...] [options]
 
 Targets:
-  claude     Install Claude Code rules and commands into .claude/
+  claude     Install Claude Code skills and architect agent into .claude/
   cursor     Copy ts-procedures rules to .cursorrules
   copilot    Copy ts-procedures instructions to .github/copilot-instructions.md
   all        Set up all targets (default)
@@ -89,12 +89,24 @@ function isFileOutdated(targetPath, expectedContent) {
 
 function setupClaude({ dryRun, check } = {}) {
   if (dryRun) {
-    const claudeFiles = [
-      '.claude/rules/ts-procedures.md',
-      '.claude/commands/ts-procedures-scaffold.md',
-      '.claude/commands/ts-procedures-review.md',
-      '.claude/agents/ts-procedures-architect.md',
-    ];
+    // Mirror install-claude.mjs: copy every file under each source skill dir, plus the agent.
+    const claudeFiles = [];
+    const skillsSrc = join(AGENT_CONFIG_DIR, 'claude-code', 'skills');
+    for (const skill of ['ts-procedures', 'ts-procedures-review', 'ts-procedures-scaffold']) {
+      const walk = (dir, prefix) => {
+        for (const entry of readdirSync(dir)) {
+          const full = join(dir, entry);
+          if (statSync(full).isDirectory()) {
+            walk(full, `${prefix}/${entry}`);
+          } else {
+            claudeFiles.push(`${prefix}/${entry}`);
+          }
+        }
+      };
+      walk(join(skillsSrc, skill), `.claude/skills/${skill}`);
+    }
+    claudeFiles.push('.claude/agents/ts-procedures-architect.md');
+
     console.log('\n  Claude Code (dry run)');
     console.log('  ─────────────────────');
     for (const f of claudeFiles) {
@@ -116,9 +128,8 @@ function setupClaude({ dryRun, check } = {}) {
     console.log(`    ${f}`);
   }
   console.log('');
-  console.log('  Commands:  /project:ts-procedures-scaffold, /project:ts-procedures-review');
-  console.log('  Agent:     ts-procedures-architect (architecture planning)');
-  console.log('  Reference: Auto-loaded via .claude/rules/ts-procedures.md\n');
+  console.log('  Skills:  ts-procedures, ts-procedures-scaffold, ts-procedures-review');
+  console.log('  Agent:   ts-procedures-architect (architecture planning)\n');
   return false;
 }
 

package/agent_config/claude-code/agents/ts-procedures-architect.md

@@ -4,14 +4,14 @@ description: "Architecture planning agent for ts-procedures RPC applications. Us
 model: sonnet
 disallowedTools: Write, Edit
 skills:
-  - guide
+  - ts-procedures
 color: blue
 effort: high
 ---
 
 You are an architecture planning agent for applications built with **ts-procedures**, a TypeScript RPC framework that creates type-safe, schema-validated procedure calls. You help developers plan APIs by deciding procedure structure, schema design, context shape, and HTTP integration strategy.
 
-The full ts-procedures framework reference is preloaded via the guide skill — use it for API details, schema rules, error classes, and HTTP builder specifics.
+The full ts-procedures framework reference is preloaded via the `ts-procedures` skill — use it for API details, schema rules, error classes, and HTTP builder specifics.
 
 ## Your Process
 

package/agent_config/claude-code/skills/{guide → ts-procedures}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: guide
+name: ts-procedures
 description: "TypeScript RPC framework reference for ts-procedures — schema validation, error handling, HTTP builders, streaming, and code generation. Use when writing, reviewing, or debugging procedures, configuring HTTP builders, or designing schemas."
 user-invocable: false
 ---

package/agent_config/claude-code/skills/{guide → ts-procedures}/api-reference.md

@@ -719,7 +719,7 @@ function createClient<TScopes>(config: {
 
 - `config.adapter` — Transport adapter implementing `ClientAdapter`. Use `createFetchAdapter()` for fetch-based transport.
 - `config.basePath` — Base URL prepended to all request paths (e.g., `'http://localhost:3000'`).
-- `config.scopes` — Factory function that receives a raw `ClientInstance` and returns the typed scope object. Typically the generated `createScopeBindings` export (or `create${ServiceName}Bindings` with `--service-name`).
+- `config.scopes` — Factory function that receives a raw `ClientInstance` and returns the typed scope object. The generated `create${ServiceName}Bindings` export (defaults to `createApiBindings`; pass `--service-name <Name>` to rename).
 - `config.hooks` — Optional global hooks applied to every call. Can be overridden per call.
 
 ### Return Value
@@ -739,12 +739,12 @@ interface ClientHooks {
 
 ```typescript
 import { createClient, createFetchAdapter } from 'ts-procedures/client'
-import { createScopeBindings } from './generated/api'
+import { createApiBindings, Api } from './generated/api'
 
 const client = createClient({
   adapter: createFetchAdapter(),
   basePath: 'http://localhost:3000',
-  scopes: createScopeBindings,
+  scopes: createApiBindings,
   hooks: {
     onBeforeRequest(ctx) {
       ctx.request.headers = { ...ctx.request.headers, Authorization: `Bearer ${getToken()}` }
@@ -754,6 +754,8 @@ const client = createClient({
 })
 
 const user = await client.users.GetUser({ pathParams: { id: '123' } })
+
+// Reach types via the namespace: Api.Users.GetUser.Params, Api.Errors.ProcedureError
 ```
 
 ---
@@ -835,14 +837,15 @@ async function generateClient(options: {
 | `--depluralize` | Singularize array item type names (ignored with `--no-namespace-types`) |
 | `--array-item-naming <value>` | Postfix for array item type names (ignored with `--no-namespace-types`) |
 | `--uncountable-words <list>` | Comma-separated words to skip singularization (ignored with `--no-namespace-types`) |
-| `--service-name <name>` | Customize generated identifiers for multi-service apps (e.g., `Auth` → `createAuthBindings`) |
+| `--service-name <name>` | Names the service namespace and binding factory (e.g., `Auth` → `export namespace Auth { ... }` + `createAuthBindings`). Also prefixes `${Name}Errors` and `${Name}ProcedureErrorUnion` in `_errors.ts`. **Default: `Api`.** |
 
 ### Generated Output
 
 - One `.ts` file per scope (e.g., `users.ts`, `events.ts`)
-- A root `index.ts` exporting `createScopeBindings` (or `create${ServiceName}Bindings` with `--service-name`)
+- A root `index.ts` that imports each scope as a namespace (`import * as users from './users'`), exports a `create${ServiceName}Bindings` factory (defaults to `createApiBindings`), and — when namespace mode is on — wraps every scope namespace in an outer `export namespace ${ServiceName} { ... }` block (defaults to `Api`). Errors are folded in as `${ServiceName}.Errors`.
+- No `export *` re-exports — consumers reach types via `${ServiceName}.<Scope>.<Route>.Params` etc.
 - Each scope file exports fully-typed callable functions and TypeScript types
-- By default, types are wrapped in `export namespace Scope { export namespace Route { ... } }` (disable with `--no-namespace-types`)
+- By default, types are wrapped in `export namespace Scope { export namespace Route { ... } }` (disable with `--no-namespace-types`; this also disables the outer service namespace in `index.ts`)
 
 ### Example
 
@@ -890,9 +893,9 @@ interface TypedStream<TYield, TReturn> extends AsyncIterable<TYield> {
 
 ```typescript
 import { createClient, createFetchAdapter } from 'ts-procedures/client'
-import { createScopeBindings } from './generated/api'
+import { createApiBindings } from './generated/api'
 
-const client = createClient({ adapter: createFetchAdapter(), basePath: '...', scopes: createScopeBindings })
+const client = createClient({ adapter: createFetchAdapter(), basePath: '...', scopes: createApiBindings })
 
 const stream = client.events.WatchNotifications({ filter: 'all' })
 

package/agent_config/claude-code/skills/{guide → ts-procedures}/patterns.md

@@ -791,12 +791,13 @@ app.get('/docs', (c) => c.json(docs.toJSON()))
 
 ```typescript
 import { createClient, createFetchAdapter } from 'ts-procedures/client'
-import { createScopeBindings } from './generated/api'
+import { createApiBindings, Api } from './generated/api'
+// With --service-name <Name>: import { create<Name>Bindings, <Name> } from './generated/api'
 
 const client = createClient({
   adapter: createFetchAdapter(),
   basePath: 'http://localhost:3000',
-  scopes: createScopeBindings,
+  scopes: createApiBindings,
   hooks: {
     onBeforeRequest(ctx) {
       ctx.request.headers = {
@@ -815,6 +816,11 @@ const client = createClient({
 
 // Fully typed — params and response inferred from server schemas
 const user = await client.users.GetUser({ pathParams: { id: '123' } })
+
+// Reach types via the service namespace:
+//   Api.Users.GetUser.Params
+//   Api.Users.GetUser.Response
+//   Api.Errors.ProcedureError
 ```
 
 ---

package/agent_config/claude-code/skills/{review → ts-procedures-review}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: review
+name: ts-procedures-review
 description: "Review ts-procedures code for pattern adherence, schema correctness, error handling, and signal propagation."
 argument-hint: "<path>"
 allowed-tools: Read Grep Glob
@@ -16,7 +16,7 @@ Parse `$ARGUMENTS` as a file or directory path. If a directory, review all `.ts`
 1. Read the target file(s).
 2. Identify ts-procedures imports (`ts-procedures`, `ts-procedures/express-rpc`, `ts-procedures/hono-rpc`, `ts-procedures/hono-stream`, `ts-procedures/hono-api`, `ts-procedures/http`, `ts-procedures/http-docs`) to determine file types.
 3. Check each file against the categorized checklist in [checklist.md](checklist.md).
-4. For detailed code examples of each violation pattern, reference [anti-patterns.md](../guide/anti-patterns.md) — it shows 20 common mistakes with before/after code fixes and severity ratings.
+4. For detailed code examples of each violation pattern, reference [anti-patterns.md](../ts-procedures/anti-patterns.md) — it shows 20 common mistakes with before/after code fixes and severity ratings.
 5. Output findings grouped by severity.
 
 ## Output Format
@@ -45,4 +45,4 @@ After individual findings, provide:
 ## Reference
 
 See [checklist.md](checklist.md) for the complete categorized checklist by file type.
-See [anti-patterns.md](../guide/anti-patterns.md) for detailed code examples of each violation.
+See [anti-patterns.md](../ts-procedures/anti-patterns.md) for detailed code examples of each violation.

package/agent_config/claude-code/skills/{scaffold → ts-procedures-scaffold}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: scaffold
+name: ts-procedures-scaffold
 description: "Generate ts-procedures implementations with correct patterns — procedures, streams, Express RPC, Hono RPC, Hono streaming, REST APIs, and client setup."
 argument-hint: "<type> <Name>"
 allowed-tools: Read Write
@@ -19,7 +19,7 @@ If either argument is missing, ask the user for `<type>` and `<Name>`.
    - `{{Name}}` — PascalCase as given (e.g., `UserProfile`)
    - `{{name}}` — camelCase (e.g., `userProfile`)
    - For URL scopes and file paths, use kebab-case (e.g., `user-profile`)
-4. Read the template file from `${CLAUDE_SKILL_DIR}/templates/$0.md`.
+4. Read the template file from `templates/$0.md` (relative to this skill directory).
 5. Replace all `{{Name}}` and `{{name}}` placeholders with the appropriate variants.
 6. Generate the implementation file(s) following the template exactly.
 7. Also generate a colocated test file following ts-procedures test conventions.

package/agent_config/claude-code/skills/{scaffold → ts-procedures-scaffold}/templates/client.md

@@ -4,15 +4,15 @@
 
 ```typescript
 import { createClient, createFetchAdapter } from 'ts-procedures/client'
-import { createScopeBindings } from './generated/api'
-// With --service-name: import { create{{Name}}Bindings } from './generated/api'
+import { createApiBindings, Api } from './generated/api'
+// With --service-name {{Name}}: import { create{{Name}}Bindings, {{Name}} } from './generated/api'
 
 // Create the typed client
 export const {{name}}Client = createClient({
   adapter: createFetchAdapter(),
   basePath: 'http://localhost:3000', // TODO: configure base URL
-  scopes: createScopeBindings,
-  // With --service-name: scopes: create{{Name}}Bindings,
+  scopes: createApiBindings,
+  // With --service-name {{Name}}: scopes: create{{Name}}Bindings,
   hooks: {
     onBeforeRequest(ctx) {
       // TODO: add auth headers, request IDs, etc.

package/agent_config/copilot/copilot-instructions.md

@@ -320,8 +320,8 @@ npx ts-procedures-codegen --url http://localhost:3000/docs --out ./src/generated
 #                  --config ./codegen.config.json --service-name Auth
 ```
 
-Generates one `.ts` file per scope plus a root `index.ts` exporting `createScopeBindings` (or `create${ServiceName}Bindings` with `--service-name`).
-By default, types are wrapped in nested TS namespaces (`Scope.Route.Params`), JSDoc comments are emitted, and output is self-contained (no runtime dependency on `ts-procedures`). Use `--no-namespace-types` to revert to flat type names (`RouteParams`).
+Generates one `.ts` file per scope plus a root `index.ts` that imports each scope as a namespace and exports a `create${ServiceName}Bindings` factory (defaults to `createApiBindings`; pass `--service-name <Name>` to rename). When namespace mode is on (the default), `index.ts` also wraps every scope namespace in an outer `export namespace ${ServiceName} { ... }` block so types are reachable as `Api.Users.GetUser.Params`, `Api.Errors.ProcedureError`, etc. The errors file (`_errors.ts`) emits `${ServiceName}Errors` and `${ServiceName}ProcedureErrorUnion` (defaults: `ApiErrors`, `ApiProcedureErrorUnion`).
+By default, types are wrapped in nested TS namespaces (`Scope.Route.Params`), JSDoc comments are emitted, and output is self-contained (no runtime dependency on `ts-procedures`). Use `--no-namespace-types` to revert to flat type names (`RouteParams`); this also disables the outer service namespace in `index.ts` and skips importing `_errors` from there.
 Note: ajsc formatting options (`--enum-style enum`, `--depluralize`, etc.) only take effect in namespace mode (the default). They are ignored with `--no-namespace-types`.
 Supports config file: `ts-procedures-codegen.config.json` (auto-loaded from CWD) or `--config <path>`.
 
@@ -329,12 +329,13 @@ Supports config file: `ts-procedures-codegen.config.json` (auto-loaded from CWD)
 
 ```typescript
 import { createClient, createFetchAdapter } from 'ts-procedures/client'
-import { createScopeBindings } from './generated/api'
+import { createApiBindings, Api } from './generated/api'
+// With --service-name <Name>: import { create<Name>Bindings, <Name> } from './generated/api'
 
 const client = createClient({
   adapter: createFetchAdapter(),
   basePath: 'http://localhost:3000',
-  scopes: createScopeBindings,
+  scopes: createApiBindings,
   hooks: {
     onBeforeRequest(ctx) {
       ctx.request.headers = { ...ctx.request.headers, Authorization: `Bearer ${getToken()}` }
@@ -346,7 +347,7 @@ const client = createClient({
   },
 })
 
-// Fully typed — params and response inferred from server schemas
+// Fully typed — params and response inferred from server schemas; type aliases live under Api.<Scope>.<Route>.
 const user = await client.users.GetUser({ pathParams: { id: '123' } })
 
 // Per-call hook override

package/agent_config/cursor/cursorrules

@@ -320,8 +320,8 @@ npx ts-procedures-codegen --url http://localhost:3000/docs --out ./src/generated
 #                  --config ./codegen.config.json --service-name Auth
 ```
 
-Generates one `.ts` file per scope plus a root `index.ts` exporting `createScopeBindings` (or `create${ServiceName}Bindings` with `--service-name`).
-By default, types are wrapped in nested TS namespaces (`Scope.Route.Params`), JSDoc comments are emitted, and output is self-contained (no runtime dependency on `ts-procedures`). Use `--no-namespace-types` to revert to flat type names (`RouteParams`).
+Generates one `.ts` file per scope plus a root `index.ts` that imports each scope as a namespace and exports a `create${ServiceName}Bindings` factory (defaults to `createApiBindings`; pass `--service-name <Name>` to rename). When namespace mode is on (the default), `index.ts` also wraps every scope namespace in an outer `export namespace ${ServiceName} { ... }` block so types are reachable as `Api.Users.GetUser.Params`, `Api.Errors.ProcedureError`, etc. The errors file (`_errors.ts`) emits `${ServiceName}Errors` and `${ServiceName}ProcedureErrorUnion` (defaults: `ApiErrors`, `ApiProcedureErrorUnion`).
+By default, types are wrapped in nested TS namespaces (`Scope.Route.Params`), JSDoc comments are emitted, and output is self-contained (no runtime dependency on `ts-procedures`). Use `--no-namespace-types` to revert to flat type names (`RouteParams`); this also disables the outer service namespace in `index.ts` and skips importing `_errors` from there.
 Note: ajsc formatting options (`--enum-style enum`, `--depluralize`, etc.) only take effect in namespace mode (the default). They are ignored with `--no-namespace-types`.
 Supports config file: `ts-procedures-codegen.config.json` (auto-loaded from CWD) or `--config <path>`.
 
@@ -329,12 +329,13 @@ Supports config file: `ts-procedures-codegen.config.json` (auto-loaded from CWD)
 
 ```typescript
 import { createClient, createFetchAdapter } from 'ts-procedures/client'
-import { createScopeBindings } from './generated/api'
+import { createApiBindings, Api } from './generated/api'
+// With --service-name <Name>: import { create<Name>Bindings, <Name> } from './generated/api'
 
 const client = createClient({
   adapter: createFetchAdapter(),
   basePath: 'http://localhost:3000',
-  scopes: createScopeBindings,
+  scopes: createApiBindings,
   hooks: {
     onBeforeRequest(ctx) {
       ctx.request.headers = { ...ctx.request.headers, Authorization: `Bearer ${getToken()}` }
@@ -346,7 +347,7 @@ const client = createClient({
   },
 })
 
-// Fully typed — params and response inferred from server schemas
+// Fully typed — params and response inferred from server schemas; type aliases live under Api.<Scope>.<Route>.
 const user = await client.users.GetUser({ pathParams: { id: '123' } })
 
 // Per-call hook override

package/agent_config/lib/install-claude.mjs

@@ -1,109 +1,57 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { cpSync, mkdirSync, readdirSync, statSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const SKILLS_DIR = join(__dirname, '..', 'claude-code', 'skills');
-const AGENTS_DIR = join(__dirname, '..', 'claude-code', 'agents');
-
-function getPackageVersion() {
-  try {
-    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8'));
-    return pkg.version || 'unknown';
-  } catch {
-    return 'unknown';
-  }
-}
-
-function makeAutoHeader() {
-  const version = getPackageVersion();
-  return `<!-- Auto-generated by ts-procedures@${version}. Updated on npm install/update. Do not edit. -->\n\n`;
-}
-
-function stripFrontmatter(content) {
-  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
-  return match ? match[1].trim() : content.trim();
-}
-
-function ensureDir(dir) {
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+const SOURCE_DIR = join(__dirname, '..', 'claude-code');
+
+const SKILL_NAMES = ['ts-procedures', 'ts-procedures-review', 'ts-procedures-scaffold'];
+const AGENT_FILES = ['ts-procedures-architect.md'];
+
+function listFilesRecursive(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      for (const nested of listFilesRecursive(full)) out.push(join(entry, nested));
+    } else {
+      out.push(entry);
+    }
   }
+  return out;
 }
 
 /**
  * Install Claude Code integration files into a project's .claude/ directory.
  *
  * Creates:
- *   .claude/rules/ts-procedures.md            — Framework reference (always loaded in context)
- *   .claude/commands/ts-procedures-scaffold.md — Scaffold command (/project:ts-procedures-scaffold)
- *   .claude/commands/ts-procedures-review.md   — Review command (/project:ts-procedures-review)
- *   .claude/agents/ts-procedures-architect.md  — Architecture planning agent
+ *   .claude/skills/ts-procedures/            — Framework reference skill
+ *   .claude/skills/ts-procedures-scaffold/   — Scaffold skill (templates included)
+ *   .claude/skills/ts-procedures-review/     — Review skill
+ *   .claude/agents/ts-procedures-architect.md — Architecture planning agent
  *
  * @param {string} projectRoot — Absolute path to the consuming project's root
  * @returns {{ files: string[] }} — List of created/updated file paths (relative to projectRoot)
  */
 export function installClaude(projectRoot) {
   const claudeDir = join(projectRoot, '.claude');
-  const rulesDir = join(claudeDir, 'rules');
-  const commandsDir = join(claudeDir, 'commands');
-  const agentsDir = join(claudeDir, 'agents');
+  const skillsDest = join(claudeDir, 'skills');
+  const agentsDest = join(claudeDir, 'agents');
+  mkdirSync(skillsDest, { recursive: true });
+  mkdirSync(agentsDest, { recursive: true });
 
-  ensureDir(rulesDir);
-  ensureDir(commandsDir);
-  ensureDir(agentsDir);
-
-  const autoHeader = makeAutoHeader();
   const files = [];
-
-  // 1. Rules file — framework reference (always loaded in context)
-  const guideSkill = readFileSync(join(SKILLS_DIR, 'guide', 'SKILL.md'), 'utf-8');
-  const guideBasePath = 'node_modules/ts-procedures/agent_config/claude-code/skills/guide';
-  const guideBody = stripFrontmatter(guideSkill)
-    // Replace relative markdown links with node_modules paths
-    .replace(/\[patterns\.md\]\(patterns\.md\)/g, `\`${guideBasePath}/patterns.md\``)
-    .replace(/\[anti-patterns\.md\]\(anti-patterns\.md\)/g, `\`${guideBasePath}/anti-patterns.md\``)
-    .replace(/\[api-reference\.md\]\(api-reference\.md\)/g, `\`${guideBasePath}/api-reference.md\``)
-    // Replace the Workflow section — skill cross-references don't apply outside the plugin
-    .replace(/\n## Workflow[\s\S]*$/, '');
-
-  writeFileSync(join(rulesDir, 'ts-procedures.md'), autoHeader + guideBody, 'utf-8');
-  files.push('.claude/rules/ts-procedures.md');
-
-  // 2. Scaffold command
-  const scaffoldSkill = readFileSync(join(SKILLS_DIR, 'scaffold', 'SKILL.md'), 'utf-8');
-  const scaffoldBasePath = 'node_modules/ts-procedures/agent_config/claude-code/skills/scaffold';
-  const scaffoldBody = stripFrontmatter(scaffoldSkill)
-    // Replace ${CLAUDE_SKILL_DIR} template path with node_modules path
-    .replace(
-      '`${CLAUDE_SKILL_DIR}/templates/$0.md`',
-      `\`${scaffoldBasePath}/templates/$0.md\``
-    )
-    // Replace Workflow section — skill cross-references don't apply outside the plugin
-    .replace(/\n## Workflow[\s\S]*$/, '');
-
-  writeFileSync(join(commandsDir, 'ts-procedures-scaffold.md'), autoHeader + scaffoldBody, 'utf-8');
-  files.push('.claude/commands/ts-procedures-scaffold.md');
-
-  // 3. Review command
-  const reviewSkill = readFileSync(join(SKILLS_DIR, 'review', 'SKILL.md'), 'utf-8');
-  const reviewBasePath = 'node_modules/ts-procedures/agent_config/claude-code/skills/review';
-  const reviewBody = stripFrontmatter(reviewSkill)
-    // Replace relative markdown links with node_modules paths
-    .replace(/\[checklist\.md\]\(checklist\.md\)/g, `\`${reviewBasePath}/checklist.md\``)
-    .replace(
-      /\[anti-patterns\.md\]\(\.\.\/guide\/anti-patterns\.md\)/g,
-      `\`${guideBasePath}/anti-patterns.md\``
-    );
-
-  writeFileSync(join(commandsDir, 'ts-procedures-review.md'), autoHeader + reviewBody, 'utf-8');
-  files.push('.claude/commands/ts-procedures-review.md');
-
-  // 4. Architect agent
-  const architectAgent = readFileSync(join(AGENTS_DIR, 'ts-procedures-architect.md'), 'utf-8');
-  writeFileSync(join(agentsDir, 'ts-procedures-architect.md'), autoHeader + architectAgent, 'utf-8');
-  files.push('.claude/agents/ts-procedures-architect.md');
-
+  for (const skill of SKILL_NAMES) {
+    const src = join(SOURCE_DIR, 'skills', skill);
+    cpSync(src, join(skillsDest, skill), { recursive: true, force: true });
+    for (const rel of listFilesRecursive(src)) {
+      files.push(`.claude/skills/${skill}/${rel}`);
+    }
+  }
+  for (const agent of AGENT_FILES) {
+    cpSync(join(SOURCE_DIR, 'agents', agent), join(agentsDest, agent), { force: true });
+    files.push(`.claude/agents/${agent}`);
+  }
   return { files };
 }

package/build/codegen/e2e.test.js

@@ -239,35 +239,35 @@ describe('E2E: generateClient full pipeline', () => {
         expect(yieldTypeBody).not.toContain('retry');
     });
     // ── index.ts ───────────────────────────────────────────────────────────────
-    it('index.ts contains createScopeBindings', async () => {
+    it('index.ts contains the default Api bindings factory', async () => {
         tmpDir = makeTmpDir();
         await generateClient({ envelope, outDir: tmpDir });
         const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8');
-        expect(content).toContain('createScopeBindings');
+        expect(content).toContain('createApiBindings');
     });
-    it('index.ts re-exports from users scope', async () => {
+    it('index.ts imports the users scope as a namespace', async () => {
         tmpDir = makeTmpDir();
         await generateClient({ envelope, outDir: tmpDir });
         const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8');
-        expect(content).toContain("from './users'");
+        expect(content).toContain("import * as users from './users'");
     });
-    it('index.ts re-exports from events scope', async () => {
+    it('index.ts imports the events scope as a namespace', async () => {
         tmpDir = makeTmpDir();
         await generateClient({ envelope, outDir: tmpDir });
         const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8');
-        expect(content).toContain("from './events'");
+        expect(content).toContain("import * as events from './events'");
     });
-    it('index.ts imports and uses bindUsersScope', async () => {
+    it('index.ts uses bindUsersScope through the namespace', async () => {
         tmpDir = makeTmpDir();
         await generateClient({ envelope, outDir: tmpDir });
         const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8');
-        expect(content).toContain('bindUsersScope');
+        expect(content).toContain('users.bindUsersScope(client)');
     });
-    it('index.ts imports and uses bindEventsScope', async () => {
+    it('index.ts uses bindEventsScope through the namespace', async () => {
         tmpDir = makeTmpDir();
         await generateClient({ envelope, outDir: tmpDir });
         const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8');
-        expect(content).toContain('bindEventsScope');
+        expect(content).toContain('events.bindEventsScope(client)');
     });
     // ── _errors.ts ─────────────────────────────────────────────────────────────
     it('_errors.ts file exists when envelope has errors with schemas', async () => {
@@ -281,19 +281,26 @@ describe('E2E: generateClient full pipeline', () => {
         const content = readFileSync(join(tmpDir, '_errors.ts'), 'utf-8');
         expect(content).toContain('export type ProcedureError =');
     });
-    it('_errors.ts contains ProcedureErrorUnion', async () => {
+    it('_errors.ts contains the service-prefixed ProcedureErrorUnion', async () => {
         tmpDir = makeTmpDir();
         await generateClient({ envelope, outDir: tmpDir });
         const content = readFileSync(join(tmpDir, '_errors.ts'), 'utf-8');
-        expect(content).toContain('export type ProcedureErrorUnion =');
+        expect(content).toContain('export type ApiProcedureErrorUnion =');
         expect(content).toContain('ProcedureError');
         expect(content).toContain('ProcedureValidationError');
     });
-    it('index.ts re-exports from _errors when errors are present', async () => {
+    it('index.ts does not import _errors when namespaceTypes is off', async () => {
         tmpDir = makeTmpDir();
         await generateClient({ envelope, outDir: tmpDir });
         const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8');
-        expect(content).toContain("export * from './_errors'");
+        expect(content).not.toContain("from './_errors'");
+    });
+    it('index.ts folds errors into the service namespace when namespaceTypes is on', async () => {
+        tmpDir = makeTmpDir();
+        await generateClient({ envelope, outDir: tmpDir, namespaceTypes: true });
+        const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8');
+        expect(content).toContain("import * as _errorsModule from './_errors'");
+        expect(content).toContain('export import Errors = _errorsModule.ApiErrors');
     });
     it('_errors.ts is not generated when no errors have schemas', async () => {
         tmpDir = makeTmpDir();