ts-procedures 5.2.0 → 5.4.0

package/agent_config/copilot/copilot-instructions.md

@@ -0,0 +1,290 @@
+# ts-procedures Framework Reference
+
+You are assisting a developer using **ts-procedures**, a TypeScript RPC framework that creates type-safe, schema-validated procedure calls with a single function definition.
+
+## Core Flow
+
+```
+Procedures<TContext, TExtendedConfig>(builder?)
+    ↓
+Create(name, config, handler)       → Standard async procedure
+CreateStream(name, config, handler) → Streaming async generator
+    ↓
+Returns: { [name]: handler, procedure: handler, info: metadata }
+```
+
+## Imports
+
+```typescript
+// Core
+import { Procedures } from 'ts-procedures'
+import type { TLocalContext, TStreamContext, TProcedureRegistration, TStreamProcedureRegistration } from 'ts-procedures'
+
+// Errors
+import { ProcedureError, ProcedureValidationError, ProcedureYieldValidationError, ProcedureRegistrationError } from 'ts-procedures'
+
+// HTTP types
+import type { RPCConfig, RPCHttpRouteDoc, StreamHttpRouteDoc, StreamMode } from 'ts-procedures/http'
+
+// Express RPC
+import { ExpressRPCAppBuilder } from 'ts-procedures/express-rpc'
+
+// Hono RPC
+import { HonoRPCAppBuilder } from 'ts-procedures/hono-rpc'
+
+// Hono Streaming
+import { HonoStreamAppBuilder, sse } from 'ts-procedures/hono-stream'
+
+// Hono API (REST-style)
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig, APIInput } from 'ts-procedures/hono-api'
+```
+
+## Architecture Rules
+
+1. **schema.params is validated at runtime; schema.returnType is documentation only.** Never expect returnType to be validated. Use TypeScript for return type safety.
+
+2. **Use ctx.error() for business logic errors.** Never throw raw `Error` instances. `ctx.error(message, meta?)` creates `ProcedureError` with procedure name, metadata, and enhanced stack trace.
+
+3. **Pass ctx.signal to all downstream async calls.** HTTP implementations inject AbortSignal automatically. Pass it to fetch, database queries, and other async operations for cancellation support.
+
+4. **Stream handlers always have ctx.signal (guaranteed AbortSignal).** Standard handlers get it when HTTP implementations provide it. Check `signal.reason === 'stream-completed'` to distinguish normal completion from client disconnect.
+
+5. **Use TypeBox for schemas** (`import { Type } from 'typebox'`). Plain JSON Schema objects are not recognized. AJV config: `allErrors: true`, `coerceTypes: true`, `removeAdditional: true`.
+
+6. **One factory per access level.** Separate `Procedures()` factories for public, authenticated, admin contexts.
+
+7. **onCreate callback enables framework integration.** Use for route registration, OpenAPI generation, logging.
+
+8. **getProcedures() for introspection.** Returns all registered procedures with metadata.
+
+## Procedure Pattern
+
+```typescript
+import { Procedures } from 'ts-procedures'
+import { Type } from 'typebox'
+
+type AppContext = { userId: string; signal?: AbortSignal }
+
+const { Create, CreateStream } = Procedures<AppContext>()
+
+// Standard procedure
+const { GetUser } = Create(
+  'GetUser',
+  {
+    description: 'Fetch user by ID',
+    schema: {
+      params: Type.Object({ id: Type.String() }),
+      returnType: Type.Object({ id: Type.String(), name: Type.String() }),
+    },
+  },
+  async (ctx, params) => {
+    // params.id guaranteed string (AJV validated)
+    const user = await fetchUser(params.id, { signal: ctx.signal })
+    if (!user) throw ctx.error('Not found', { code: 'NOT_FOUND' })
+    return user
+  }
+)
+```
+
+## Stream Procedure Pattern
+
+```typescript
+const { StreamEvents } = CreateStream(
+  'StreamEvents',
+  {
+    schema: {
+      params: Type.Object({ channel: Type.String() }),
+      yieldType: Type.Object({ type: Type.String(), data: Type.Any() }),
+    },
+  },
+  async function* (ctx, params) {
+    // ctx.signal always present in streams
+    while (!ctx.signal.aborted) {
+      const event = await pollEvents(params.channel, { signal: ctx.signal })
+      yield event
+    }
+  }
+)
+```
+
+## Express RPC Pattern
+
+```typescript
+import { ExpressRPCAppBuilder } from 'ts-procedures/express-rpc'
+import type { RPCConfig } from 'ts-procedures/http'
+
+const RPC = Procedures<AppContext, RPCConfig>()
+
+RPC.Create('GetUser', {
+  scope: 'users', version: 1,
+  schema: { params: Type.Object({ id: Type.String() }) },
+}, async (ctx, params) => fetchUser(params.id))
+
+const app = new ExpressRPCAppBuilder({ pathPrefix: '/api' })
+  .register(RPC, async (req) => ({ userId: await authenticate(req) }))
+  .build()
+// POST /api/users/get-user/1
+```
+
+## Hono RPC Pattern
+
+```typescript
+import { HonoRPCAppBuilder } from 'ts-procedures/hono-rpc'
+
+const app = new HonoRPCAppBuilder({ pathPrefix: '/api' })
+  .register(RPC, (c) => ({ userId: c.req.header('x-user-id') }))
+  .build()
+```
+
+## Hono Streaming Pattern
+
+```typescript
+import { HonoStreamAppBuilder, sse } from 'ts-procedures/hono-stream'
+
+const StreamRPC = Procedures<AppContext, RPCConfig>()
+
+StreamRPC.CreateStream('Feed', {
+  scope: 'events', version: 1,
+  schema: { params: Type.Object({ channel: Type.String() }) },
+}, async function* (ctx, params) {
+  while (!ctx.signal.aborted) {
+    const event = await poll({ signal: ctx.signal })
+    yield sse(event, { event: 'update' })
+  }
+})
+
+const app = new HonoStreamAppBuilder({ defaultStreamMode: 'sse' })
+  .register(StreamRPC, (c) => ({ userId: c.req.header('x-user-id') }))
+  .build()
+// GET|POST /events/feed/1
+```
+
+## Hono API Pattern (REST-style)
+
+```typescript
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig } from 'ts-procedures/http'
+
+const API = Procedures<AppContext, APIConfig>()
+
+API.Create('GetUser', {
+  path: '/users/:id', method: 'get',
+  schema: {
+    input: { pathParams: Type.Object({ id: Type.String() }) },
+  },
+}, async (ctx, { pathParams }) => fetchUser(pathParams.id))
+
+API.Create('CreateUser', {
+  path: '/users', method: 'post',
+  schema: {
+    input: { body: Type.Object({ name: Type.String() }) },
+  },
+}, async (ctx, { body }) => createUser(body))
+
+const app = await new HonoAPIAppBuilder({ pathPrefix: '/api' })
+  .register(API, (c) => ({ userId: c.req.header('x-user-id') }))
+  .build()
+// GET /api/users/:id → 200, POST /api/users → 201
+```
+
+## Error Handling
+
+| Error Class | Trigger | HTTP Status |
+|-------------|---------|-------------|
+| `ProcedureValidationError` | Schema params validation failure | 400 |
+| `ProcedureError` | `ctx.error()` or unhandled handler exception | 422/500 |
+| `ProcedureYieldValidationError` | Yield validation failure (validateYields: true) | N/A (mid-stream) |
+| `ProcedureRegistrationError` | Invalid schema or duplicate name at registration | N/A (startup) |
+
+```typescript
+// In HTTP builder
+onError: (procedure, req, res, error) => {
+  if (error instanceof ProcedureValidationError) {
+    res.status(400).json({ error: error.message, details: error.errors })
+  } else if (error instanceof ProcedureError) {
+    res.status(422).json({ error: error.message, meta: error.meta })
+  } else {
+    res.status(500).json({ error: 'Internal server error' })
+  }
+}
+```
+
+## Lifecycle Hook Order
+
+### Standard RPC
+```
+onRequestStart → factoryContext() → handler() → onSuccess → onRequestEnd
+                                  → onError  → onRequestEnd
+```
+
+### Streaming
+```
+onRequestStart → factoryContext() → validation → onStreamStart → handler yields → onStreamEnd → onRequestEnd
+                                               → onPreStreamError → onRequestEnd
+                                                                  → onMidStreamError → onStreamEnd → onRequestEnd
+```
+
+## Decision Framework
+
+**Which procedure type?**
+- Single response → `Create`
+- Multiple values over time → `CreateStream`
+
+**Which schema library?**
+- **TypeBox** (`import { Type } from 'typebox'`)
+
+**Which HTTP implementation?**
+- Express → `ExpressRPCAppBuilder`
+- Hono (standard) → `HonoRPCAppBuilder`
+- Hono (streaming) → `HonoStreamAppBuilder`
+- Hono (REST-style, per-channel input) → `HonoAPIAppBuilder`
+
+**Stream mode?**
+- Browser EventSource → `'sse'` (default)
+- Simple HTTP client → `'text'` (newline-delimited JSON)
+
+## Anti-Patterns — NEVER Do These
+
+1. **Never throw raw Error** — use `ctx.error(message, meta?)`
+2. **Never expect returnType runtime validation** — it's docs only
+3. **Never put validation logic in handler** — use `schema.params`
+4. **Never ignore ctx.signal** — pass to all async calls
+5. **Never skip signal.aborted check in stream loops** — causes resource leaks
+6. **Never register Create procedures with HonoStreamAppBuilder** — they're silently ignored
+7. **Never use plain JSON Schema objects** — use TypeBox builders
+8. **Never swallow errors without re-throwing** — hides failures
+9. **Never assume extra params fields survive** — `removeAdditional: true` strips them
+10. **Never manually parse types AJV coerces** — `coerceTypes: true` handles it
+11. **Never define both schema.params and schema.input** — mutually exclusive, throws ProcedureRegistrationError
+12. **Never forget to await HonoAPIAppBuilder.build()** — it's async (resolves query parser)
+
+## Testing
+
+```typescript
+import { describe, test, expect } from 'vitest'
+import { ProcedureError, ProcedureValidationError } from 'ts-procedures'
+
+describe('GetUser', () => {
+  test('valid params', async () => {
+    const result = await GetUser(mockCtx, { id: 'user-1' })
+    expect(result.id).toBe('user-1')
+  })
+
+  test('invalid params', async () => {
+    await expect(GetUser(mockCtx, {})).rejects.toThrow(ProcedureValidationError)
+  })
+
+  test('business error', async () => {
+    await expect(GetUser(mockCtx, { id: 'missing' })).rejects.toThrow(ProcedureError)
+  })
+})
+```
+
+## HTTP Route Path Format
+
+`{pathPrefix}/{scope}/{kebab-case-name}/{version}`
+
+- `scope` can be string or string[] (joined as path segments)
+- Procedure name auto-converted to kebab-case
+- Stream routes support both GET (query params) and POST (JSON body)

package/agent_config/cursor/cursorrules

@@ -0,0 +1,290 @@
+# ts-procedures Framework Reference
+
+You are assisting a developer using **ts-procedures**, a TypeScript RPC framework that creates type-safe, schema-validated procedure calls with a single function definition.
+
+## Core Flow
+
+```
+Procedures<TContext, TExtendedConfig>(builder?)
+    ↓
+Create(name, config, handler)       → Standard async procedure
+CreateStream(name, config, handler) → Streaming async generator
+    ↓
+Returns: { [name]: handler, procedure: handler, info: metadata }
+```
+
+## Imports
+
+```typescript
+// Core
+import { Procedures } from 'ts-procedures'
+import type { TLocalContext, TStreamContext, TProcedureRegistration, TStreamProcedureRegistration } from 'ts-procedures'
+
+// Errors
+import { ProcedureError, ProcedureValidationError, ProcedureYieldValidationError, ProcedureRegistrationError } from 'ts-procedures'
+
+// HTTP types
+import type { RPCConfig, RPCHttpRouteDoc, StreamHttpRouteDoc, StreamMode } from 'ts-procedures/http'
+
+// Express RPC
+import { ExpressRPCAppBuilder } from 'ts-procedures/express-rpc'
+
+// Hono RPC
+import { HonoRPCAppBuilder } from 'ts-procedures/hono-rpc'
+
+// Hono Streaming
+import { HonoStreamAppBuilder, sse } from 'ts-procedures/hono-stream'
+
+// Hono API (REST-style)
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig, APIInput } from 'ts-procedures/hono-api'
+```
+
+## Architecture Rules
+
+1. **schema.params is validated at runtime; schema.returnType is documentation only.** Never expect returnType to be validated. Use TypeScript for return type safety.
+
+2. **Use ctx.error() for business logic errors.** Never throw raw `Error` instances. `ctx.error(message, meta?)` creates `ProcedureError` with procedure name, metadata, and enhanced stack trace.
+
+3. **Pass ctx.signal to all downstream async calls.** HTTP implementations inject AbortSignal automatically. Pass it to fetch, database queries, and other async operations for cancellation support.
+
+4. **Stream handlers always have ctx.signal (guaranteed AbortSignal).** Standard handlers get it when HTTP implementations provide it. Check `signal.reason === 'stream-completed'` to distinguish normal completion from client disconnect.
+
+5. **Use TypeBox for schemas** (`import { Type } from 'typebox'`). Plain JSON Schema objects are not recognized. AJV config: `allErrors: true`, `coerceTypes: true`, `removeAdditional: true`.
+
+6. **One factory per access level.** Separate `Procedures()` factories for public, authenticated, admin contexts.
+
+7. **onCreate callback enables framework integration.** Use for route registration, OpenAPI generation, logging.
+
+8. **getProcedures() for introspection.** Returns all registered procedures with metadata.
+
+## Procedure Pattern
+
+```typescript
+import { Procedures } from 'ts-procedures'
+import { Type } from 'typebox'
+
+type AppContext = { userId: string; signal?: AbortSignal }
+
+const { Create, CreateStream } = Procedures<AppContext>()
+
+// Standard procedure
+const { GetUser } = Create(
+  'GetUser',
+  {
+    description: 'Fetch user by ID',
+    schema: {
+      params: Type.Object({ id: Type.String() }),
+      returnType: Type.Object({ id: Type.String(), name: Type.String() }),
+    },
+  },
+  async (ctx, params) => {
+    // params.id guaranteed string (AJV validated)
+    const user = await fetchUser(params.id, { signal: ctx.signal })
+    if (!user) throw ctx.error('Not found', { code: 'NOT_FOUND' })
+    return user
+  }
+)
+```
+
+## Stream Procedure Pattern
+
+```typescript
+const { StreamEvents } = CreateStream(
+  'StreamEvents',
+  {
+    schema: {
+      params: Type.Object({ channel: Type.String() }),
+      yieldType: Type.Object({ type: Type.String(), data: Type.Any() }),
+    },
+  },
+  async function* (ctx, params) {
+    // ctx.signal always present in streams
+    while (!ctx.signal.aborted) {
+      const event = await pollEvents(params.channel, { signal: ctx.signal })
+      yield event
+    }
+  }
+)
+```
+
+## Express RPC Pattern
+
+```typescript
+import { ExpressRPCAppBuilder } from 'ts-procedures/express-rpc'
+import type { RPCConfig } from 'ts-procedures/http'
+
+const RPC = Procedures<AppContext, RPCConfig>()
+
+RPC.Create('GetUser', {
+  scope: 'users', version: 1,
+  schema: { params: Type.Object({ id: Type.String() }) },
+}, async (ctx, params) => fetchUser(params.id))
+
+const app = new ExpressRPCAppBuilder({ pathPrefix: '/api' })
+  .register(RPC, async (req) => ({ userId: await authenticate(req) }))
+  .build()
+// POST /api/users/get-user/1
+```
+
+## Hono RPC Pattern
+
+```typescript
+import { HonoRPCAppBuilder } from 'ts-procedures/hono-rpc'
+
+const app = new HonoRPCAppBuilder({ pathPrefix: '/api' })
+  .register(RPC, (c) => ({ userId: c.req.header('x-user-id') }))
+  .build()
+```
+
+## Hono Streaming Pattern
+
+```typescript
+import { HonoStreamAppBuilder, sse } from 'ts-procedures/hono-stream'
+
+const StreamRPC = Procedures<AppContext, RPCConfig>()
+
+StreamRPC.CreateStream('Feed', {
+  scope: 'events', version: 1,
+  schema: { params: Type.Object({ channel: Type.String() }) },
+}, async function* (ctx, params) {
+  while (!ctx.signal.aborted) {
+    const event = await poll({ signal: ctx.signal })
+    yield sse(event, { event: 'update' })
+  }
+})
+
+const app = new HonoStreamAppBuilder({ defaultStreamMode: 'sse' })
+  .register(StreamRPC, (c) => ({ userId: c.req.header('x-user-id') }))
+  .build()
+// GET|POST /events/feed/1
+```
+
+## Hono API Pattern (REST-style)
+
+```typescript
+import { HonoAPIAppBuilder } from 'ts-procedures/hono-api'
+import type { APIConfig } from 'ts-procedures/http'
+
+const API = Procedures<AppContext, APIConfig>()
+
+API.Create('GetUser', {
+  path: '/users/:id', method: 'get',
+  schema: {
+    input: { pathParams: Type.Object({ id: Type.String() }) },
+  },
+}, async (ctx, { pathParams }) => fetchUser(pathParams.id))
+
+API.Create('CreateUser', {
+  path: '/users', method: 'post',
+  schema: {
+    input: { body: Type.Object({ name: Type.String() }) },
+  },
+}, async (ctx, { body }) => createUser(body))
+
+const app = await new HonoAPIAppBuilder({ pathPrefix: '/api' })
+  .register(API, (c) => ({ userId: c.req.header('x-user-id') }))
+  .build()
+// GET /api/users/:id → 200, POST /api/users → 201
+```
+
+## Error Handling
+
+| Error Class | Trigger | HTTP Status |
+|-------------|---------|-------------|
+| `ProcedureValidationError` | Schema params validation failure | 400 |
+| `ProcedureError` | `ctx.error()` or unhandled handler exception | 422/500 |
+| `ProcedureYieldValidationError` | Yield validation failure (validateYields: true) | N/A (mid-stream) |
+| `ProcedureRegistrationError` | Invalid schema or duplicate name at registration | N/A (startup) |
+
+```typescript
+// In HTTP builder
+onError: (procedure, req, res, error) => {
+  if (error instanceof ProcedureValidationError) {
+    res.status(400).json({ error: error.message, details: error.errors })
+  } else if (error instanceof ProcedureError) {
+    res.status(422).json({ error: error.message, meta: error.meta })
+  } else {
+    res.status(500).json({ error: 'Internal server error' })
+  }
+}
+```
+
+## Lifecycle Hook Order
+
+### Standard RPC
+```
+onRequestStart → factoryContext() → handler() → onSuccess → onRequestEnd
+                                  → onError  → onRequestEnd
+```
+
+### Streaming
+```
+onRequestStart → factoryContext() → validation → onStreamStart → handler yields → onStreamEnd → onRequestEnd
+                                               → onPreStreamError → onRequestEnd
+                                                                  → onMidStreamError → onStreamEnd → onRequestEnd
+```
+
+## Decision Framework
+
+**Which procedure type?**
+- Single response → `Create`
+- Multiple values over time → `CreateStream`
+
+**Which schema library?**
+- **TypeBox** (`import { Type } from 'typebox'`)
+
+**Which HTTP implementation?**
+- Express → `ExpressRPCAppBuilder`
+- Hono (standard) → `HonoRPCAppBuilder`
+- Hono (streaming) → `HonoStreamAppBuilder`
+- Hono (REST-style, per-channel input) → `HonoAPIAppBuilder`
+
+**Stream mode?**
+- Browser EventSource → `'sse'` (default)
+- Simple HTTP client → `'text'` (newline-delimited JSON)
+
+## Anti-Patterns — NEVER Do These
+
+1. **Never throw raw Error** — use `ctx.error(message, meta?)`
+2. **Never expect returnType runtime validation** — it's docs only
+3. **Never put validation logic in handler** — use `schema.params`
+4. **Never ignore ctx.signal** — pass to all async calls
+5. **Never skip signal.aborted check in stream loops** — causes resource leaks
+6. **Never register Create procedures with HonoStreamAppBuilder** — they're silently ignored
+7. **Never use plain JSON Schema objects** — use TypeBox builders
+8. **Never swallow errors without re-throwing** — hides failures
+9. **Never assume extra params fields survive** — `removeAdditional: true` strips them
+10. **Never manually parse types AJV coerces** — `coerceTypes: true` handles it
+11. **Never define both schema.params and schema.input** — mutually exclusive, throws ProcedureRegistrationError
+12. **Never forget to await HonoAPIAppBuilder.build()** — it's async (resolves query parser)
+
+## Testing
+
+```typescript
+import { describe, test, expect } from 'vitest'
+import { ProcedureError, ProcedureValidationError } from 'ts-procedures'
+
+describe('GetUser', () => {
+  test('valid params', async () => {
+    const result = await GetUser(mockCtx, { id: 'user-1' })
+    expect(result.id).toBe('user-1')
+  })
+
+  test('invalid params', async () => {
+    await expect(GetUser(mockCtx, {})).rejects.toThrow(ProcedureValidationError)
+  })
+
+  test('business error', async () => {
+    await expect(GetUser(mockCtx, { id: 'missing' })).rejects.toThrow(ProcedureError)
+  })
+})
+```
+
+## HTTP Route Path Format
+
+`{pathPrefix}/{scope}/{kebab-case-name}/{version}`
+
+- `scope` can be string or string[] (joined as path segments)
+- Procedure name auto-converted to kebab-case
+- Stream routes support both GET (query params) and POST (JSON body)

package/agent_config/lib/install-claude.mjs

@@ -0,0 +1,109 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } 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 });
+  }
+}
+
+/**
+ * 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
+ *
+ * @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');
+
+  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 guideBody = stripFrontmatter(guideSkill)
+    // Remove the "Supporting Files" section — replaced by "Detailed Reference" below
+    .replace(/\n## Supporting Files[\s\S]*$/, '');
+
+  const rulesContent = autoHeader + guideBody + `
+
+## Detailed Reference
+
+For complete API details, patterns, and anti-patterns, read the files in:
+\`node_modules/ts-procedures/agent_config/claude-code/skills/guide/\`
+
+- \`api-reference.md\` — Full API reference for Procedures, Create, CreateStream, errors, schema, HTTP implementations
+- \`patterns.md\` — Prescribed patterns with code examples
+- \`anti-patterns.md\` — Common mistakes to avoid with fixes
+`;
+
+  writeFileSync(join(rulesDir, 'ts-procedures.md'), rulesContent, 'utf-8');
+  files.push('.claude/rules/ts-procedures.md');
+
+  // 2. Scaffold command
+  const scaffoldSkill = readFileSync(join(SKILLS_DIR, 'scaffold', 'SKILL.md'), 'utf-8');
+  const scaffoldBody = stripFrontmatter(scaffoldSkill)
+    .replace(
+      'Read the template file from `templates/<type>.md` in this skill directory.',
+      'Read the template file from `node_modules/ts-procedures/agent_config/claude-code/skills/scaffold/templates/<type>.md`.'
+    );
+
+  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 reviewBody = stripFrontmatter(reviewSkill)
+    .replaceAll(
+      '`checklist.md`',
+      '`node_modules/ts-procedures/agent_config/claude-code/skills/review/checklist.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');
+
+  return { files };
+}