@ema.co/mcp-toolkit 2026.1.25 → 2026.1.26-3

package/docs/DEBUG-ANALYSIS-unused-category-type-mismatch.md

@@ -0,0 +1,481 @@
+# MCP Toolkit Debug Analysis: Unused Category & Type Mismatch Issues
+
+**Date:** 2026-01-25  
+**Context:** Debugging session for persona "EX - SKYE Self-Service AI Assistant"  
+**Persona ID:** `8ed79612-a8be-4c13-8736-daf5e4b0db96` (original), `2c5b7b2c-fee9-409f-8c87-d264fd4f27cd` (clone)
+
+---
+
+## Executive Summary
+
+During workflow analysis and modification of a two-stage categorizer workflow, we discovered:
+
+1. **False Positive Bug**: The `unused_category` detection incorrectly attributes categories from one categorizer to another
+2. **NLU Misinterpretation**: The `modify` handler interprets "rewire input X" as "remove nodes referencing X"
+3. **Type Mismatch Guidance Gap**: No clear fix path for `TEXT_WITH_SOURCES` → `DOCUMENT` type mismatches
+
+---
+
+## Issue 1: Unused Category False Positive
+
+### Symptom
+
+The analyzer reports:
+```
+Category "Employment Verification" is defined in User Verification but has NO HANDLER
+Category "Business Visa" is defined in User Verification but has NO HANDLER
+```
+
+But in reality:
+- **User Verification** (`chat_categorizermys4rq`) only has: `Fallback`, `ID Verified`
+- **Categorize Conversations** (`chat_categorizeraoh3e8`) has: `Fallback`, `Employment Verification`, `Business Visa`
+
+### Root Cause
+
+**File:** `src/sdk/knowledge.ts`, lines 2968-2976
+
+```typescript
+// Find the enumType for this categorizer
+const enumTypeName = categorizer.id + "_enumType";
+const enumType = enumTypes.find(e => {
+  const name = e.name as Record<string, unknown> | undefined;
+  const innerName = name?.name as Record<string, unknown> | undefined;
+  const nameStr = String(innerName?.name ?? name?.name ?? "");
+  return nameStr.includes(categorizer.id) || nameStr.includes("enumType");  // BUG HERE
+});
+```
+
+**The Bug:**
+- The condition `nameStr.includes("enumType")` is a fallback that matches ANY enumType
+- When processing categorizer A, if the first condition fails, it grabs the FIRST enumType in the array (which might belong to categorizer B)
+- This causes categories from enumType B to be attributed to categorizer A
+
+**Evidence from workflow:**
+```
+enumTypes[0] = chat_categorizeraoh3e8_enumType_8vok (Employment Verification, Business Visa, Fallback)
+enumTypes[1] = chat_categorizermys4rq_enumType_f4k7 (Fallback, ID Verified)
+```
+
+When processing `chat_categorizermys4rq`, if the ID matching fails, the fallback `includes("enumType")` matches `enumTypes[0]` instead of `enumTypes[1]`.
+
+### Fix Required
+
+```typescript
+// BEFORE (buggy)
+const enumType = enumTypes.find(e => {
+  const nameStr = extractEnumTypeName(e);
+  return nameStr.includes(categorizer.id) || nameStr.includes("enumType");  // Too loose!
+});
+
+// AFTER (correct)
+const enumType = enumTypes.find(e => {
+  const nameStr = extractEnumTypeName(e);
+  // Only match if the enumType name contains this specific categorizer's ID
+  return nameStr.includes(categorizer.id);
+});
+
+// BETTER (robust) - Use the typeArguments reference
+const categorizerAction = actions.find(a => a.name === categorizer.id);
+const typeArgs = categorizerAction?.typeArguments as Record<string, unknown> | undefined;
+const categoriesTypeArg = typeArgs?.categories as Record<string, unknown> | undefined;
+const enumTypeRef = categoriesTypeArg?.enumType as Record<string, unknown> | undefined;
+const enumTypeName = extractEnumTypeName({ name: enumTypeRef?.name });
+
+const enumType = enumTypes.find(e => {
+  const name = extractEnumTypeName(e);
+  return name === enumTypeName;
+});
+```
+
+### Test Case to Add
+
+```typescript
+// test/knowledge.test.ts
+describe("detectUnusedCategories", () => {
+  it("should correctly associate enumTypes with their categorizers in multi-categorizer workflows", () => {
+    const workflow = {
+      actions: [
+        { name: "chat_categorizermys4rq", /* User Verification */ },
+        { name: "chat_categorizeraoh3e8", /* Document Router */ },
+      ],
+      enumTypes: [
+        { 
+          name: { name: { name: "chat_categorizeraoh3e8_enumType_8vok" } },
+          options: [
+            { name: "Fallback" },
+            { name: "Employment Verification" },  // Has handler
+            { name: "Business Visa" },            // Has handler
+          ]
+        },
+        {
+          name: { name: { name: "chat_categorizermys4rq_enumType_f4k7" } },
+          options: [
+            { name: "Fallback" },    // Has handler
+            { name: "ID Verified" }, // Has handler (triggers second categorizer)
+          ]
+        }
+      ]
+    };
+    
+    const issues = detectWorkflowIssues(workflow);
+    
+    // Should NOT report unused_category for Employment Verification or Business Visa
+    // on chat_categorizermys4rq (User Verification)
+    const falsePositives = issues.filter(i => 
+      i.type === "unused_category" && 
+      i.node === "chat_categorizermys4rq" &&
+      (i.category === "Employment Verification" || i.category === "Business Visa")
+    );
+    
+    expect(falsePositives).toHaveLength(0);
+  });
+});
+```
+
+---
+
+## Issue 2: NLU Misinterpretation in Modify Handler
+
+### Symptom
+
+Request: "rewire document_instructions input on EX - Hitachi Business Visa Letter Generation to use json_mapper5d37cx.output_json"
+
+Result: Removes the entire `EX - Hitachi Business Visa Letter Generation` node instead of rewiring its input.
+
+### Root Cause
+
+**File:** `src/mcp/handlers/workflow/modify.ts`, lines 545-607
+
+The `analyzeModificationRequest` function has aggressive node removal logic:
+
+```typescript
+// REMOVAL
+if (lowerInput.includes("remove") || lowerInput.includes("delete") || 
+    lowerInput.includes("clean up") || lowerInput.includes("orphan")) {
+  intent = "remove nodes";
+  
+  // ... but then it also matches node names mentioned in ANY context:
+  if (operations.length === 0) {
+    const nodeNames = actions.map(a => String(a.name || "")).filter(n => n.length > 0);
+    const foundNodes = nodeNames.filter(nodeName => 
+      input.toLowerCase().includes(nodeName.toLowerCase())  // BUG: Too aggressive
+    );
+    if (foundNodes.length > 0) {
+      operations.push({
+        type: "remove",
+        description: `Remove node(s): ${foundNodes.join(", ")}`,
+        target_nodes: foundNodes,
+      });
+    }
+  }
+}
+```
+
+The problem: When the input mentions node names in a "rewire" context, the removal detection still picks them up if no other operation is detected first.
+
+### Fix Required
+
+1. **Add explicit rewire detection before removal**:
+
+```typescript
+// REWIRING (check BEFORE removal)
+if (lowerInput.includes("rewire") || 
+    (lowerInput.includes("input") && lowerInput.includes("use")) ||
+    lowerInput.includes("change") && lowerInput.includes("to use")) {
+  intent = "rewire connections";
+  
+  // Parse: "rewire X.input to use Y.output"
+  const rewireMatch = input.match(
+    /rewire\s+(?:the\s+)?(\w+)[\s.]+(\w+)\s+(?:input\s+)?(?:to\s+)?use\s+(\w+)\.(\w+)/i
+  );
+  
+  if (rewireMatch) {
+    operations.push({
+      type: "rewire",
+      description: `Rewire ${rewireMatch[1]}.${rewireMatch[2]} to use ${rewireMatch[3]}.${rewireMatch[4]}`,
+      target: rewireMatch[1],
+      input_name: rewireMatch[2],
+      source: rewireMatch[3],
+      output_name: rewireMatch[4],
+    });
+  }
+}
+```
+
+2. **Guard removal detection against rewire context**:
+
+```typescript
+// Only do name-based removal if NOT in a rewire context
+const isRewireContext = lowerInput.includes("rewire") || 
+                        lowerInput.includes("to use") ||
+                        lowerInput.includes("instead of");
+
+if (!isRewireContext && operations.length === 0) {
+  // ... existing name-based removal logic
+}
+```
+
+3. **Implement actual input rewiring in applyWorkflowModifications**:
+
+```typescript
+case "rewire": {
+  const targetNodeName = op.target;
+  const inputName = op.input_name;
+  const sourceName = op.source;
+  const outputName = op.output_name;
+  
+  const targetNode = actions.find(a => 
+    String(a.name || "").toLowerCase().includes(targetNodeName.toLowerCase())
+  );
+  
+  if (targetNode && targetNode.inputs) {
+    const inputs = targetNode.inputs as Record<string, unknown>;
+    
+    // Find the input to rewire
+    const inputKey = Object.keys(inputs).find(k => 
+      k.toLowerCase().includes(inputName.toLowerCase())
+    );
+    
+    if (inputKey) {
+      // Rewire the input
+      inputs[inputKey] = {
+        actionOutput: {
+          actionName: sourceName,
+          output: outputName,
+        },
+        autoDetectedBinding: false,
+      };
+      
+      nodesModified.push(String(targetNode.name));
+      connectionsChanged.push(`${targetNode.name}.${inputKey} ← ${sourceName}.${outputName}`);
+      changesApplied.push(`Rewired ${targetNode.name}.${inputKey} to use ${sourceName}.${outputName}`);
+    } else {
+      changesApplied.push(`Input "${inputName}" not found on "${targetNode.name}" - available: ${Object.keys(inputs).join(", ")}`);
+    }
+  }
+  break;
+}
+```
+
+---
+
+## Issue 3: Type Mismatch Guidance Gap
+
+### Symptom
+
+The analyzer correctly detects:
+```
+Type mismatch: WELL_KNOWN_TYPE_TEXT_WITH_SOURCES → WELL_KNOWN_TYPE_DOCUMENT
+```
+
+But provides no actionable fix:
+```
+# Either:
+# 1. Use an intermediate conversion node
+# 2. Connect to a named_inputs_* (accepts ANY type)
+# 3. Use a different source output that matches the expected type
+```
+
+### Root Cause
+
+**File:** `src/sdk/validation-rules.ts` - No rule for `TEXT_WITH_SOURCES` → `DOCUMENT` conversion
+
+**File:** `src/sdk/knowledge.ts` - `suggestWorkflowFixes` returns generic guidance for type mismatches
+
+### Fix Required
+
+1. **Add type coercion guidance to validation-rules.ts**:
+
+```typescript
+export interface TypeCoercionRule {
+  sourceType: string;
+  targetType: string;
+  severity: "critical" | "warning" | "info";
+  workarounds: Array<{
+    method: string;
+    description: string;
+    example?: string;
+  }>;
+}
+
+export const TYPE_COERCION_RULES: TypeCoercionRule[] = [
+  {
+    sourceType: "WELL_KNOWN_TYPE_TEXT_WITH_SOURCES",
+    targetType: "WELL_KNOWN_TYPE_DOCUMENT",
+    severity: "warning",  // Not critical - often works via runtime coercion
+    workarounds: [
+      {
+        method: "named_inputs",
+        description: "Pass via named_inputs which accepts any type",
+        example: `inputs: {
+  named_inputs: {
+    namedInputs: [{
+      name: "document_content",
+      binding: { actionOutput: { actionName: "source", output: "text_with_sources" } }
+    }]
+  }
+}`
+      },
+      {
+        method: "call_llm_intermediary",
+        description: "Use call_llm to format content, then pass to document generator",
+        example: "call_llm (formats content) → generate_document"
+      },
+      {
+        method: "accept_runtime_coercion",
+        description: "Ema's runtime often handles type coercion automatically. Test before fixing.",
+      }
+    ]
+  },
+  // ... other type coercion rules
+];
+```
+
+2. **Improve suggestWorkflowFixes for type_mismatch**:
+
+```typescript
+case "type_mismatch": {
+  const coercionRule = TYPE_COERCION_RULES.find(r =>
+    issue.got?.includes(r.sourceType) && issue.expected?.includes(r.targetType)
+  );
+  
+  if (coercionRule) {
+    fix = {
+      issue_type: issue.type,
+      description: `Fix type mismatch: ${issue.source} → ${issue.target}`,
+      severity: coercionRule.severity,
+      workarounds: coercionRule.workarounds,
+      note: coercionRule.severity === "warning" 
+        ? "This may work at runtime due to automatic type coercion. Test before refactoring."
+        : undefined,
+    };
+  } else {
+    fix = { /* existing generic fix */ };
+  }
+  break;
+}
+```
+
+---
+
+## Issue 4: Incomplete Input Source Rules for Persona Actions
+
+### Symptom
+
+When calling external AI Employees (persona actions) like `44ac6ec7-f46f-4f63-9f0f-b16a5ca349c3`, the analyzer doesn't understand their input requirements.
+
+### Root Cause
+
+**File:** `src/sdk/validation-rules.ts` - `INPUT_SOURCE_RULES` only covers internal action types, not persona actions.
+
+### Fix Required
+
+1. **Add dynamic input rule fetching for persona actions**:
+
+```typescript
+// In knowledge.ts detectWorkflowIssues
+async function getInputRulesForPersonaAction(
+  personaId: string, 
+  client: EmaClient
+): Promise<InputSourceRule[]> {
+  // Fetch the persona's workflow to understand its inputs
+  const persona = await client.getPersonaById(personaId);
+  if (!persona?.workflow_def) return [];
+  
+  // Extract workflow input schema
+  const workflowInputs = persona.workflow_def.workflowInputs;
+  
+  // Generate rules based on input types
+  return Object.entries(workflowInputs).map(([inputName, inputDef]) => ({
+    actionPattern: personaId,
+    input: inputName,
+    expectedType: inputDef.type,
+    // ...
+  }));
+}
+```
+
+2. **Cache persona action schemas**:
+
+```typescript
+// src/sdk/persona-action-cache.ts
+export class PersonaActionCache {
+  private cache = new Map<string, PersonaInputSchema>();
+  
+  async getInputSchema(personaId: string, client: EmaClient): Promise<PersonaInputSchema | null> {
+    if (this.cache.has(personaId)) {
+      return this.cache.get(personaId)!;
+    }
+    
+    // Fetch and cache
+    const schema = await fetchPersonaInputSchema(personaId, client);
+    if (schema) {
+      this.cache.set(personaId, schema);
+    }
+    return schema;
+  }
+}
+```
+
+---
+
+## Summary of Required Changes
+
+### High Priority (Bug Fixes)
+
+| File | Issue | Fix |
+|------|-------|-----|
+| `src/sdk/knowledge.ts:2968-2976` | enumType matching too loose | Use exact ID matching or typeArguments reference |
+| `src/mcp/handlers/workflow/modify.ts:545-607` | Remove detection too aggressive | Add rewire context guard |
+
+### Medium Priority (Feature Gaps)
+
+| File | Issue | Fix |
+|------|-------|-----|
+| `src/sdk/validation-rules.ts` | No type coercion rules | Add `TYPE_COERCION_RULES` |
+| `src/sdk/knowledge.ts` | Generic type mismatch fixes | Specific workarounds per type pair |
+| `src/mcp/handlers/workflow/modify.ts` | No input rewiring implementation | Add `rewire` case to `applyWorkflowModifications` |
+
+### Low Priority (Documentation/Knowledge)
+
+| Area | Issue | Fix |
+|------|-------|-----|
+| `ema://rules/input-sources` | Missing persona action guidance | Document `named_inputs` pattern for persona actions |
+| `ema://rules/anti-patterns` | No type mismatch pattern | Add `type-coercion-workarounds` pattern |
+| Ema MCP Expert skill | Doesn't mention type coercion | Update skill with type mismatch guidance |
+
+---
+
+## Test Scenarios to Add
+
+1. **Multi-categorizer enumType association** - Verify correct enumType ↔ categorizer pairing
+2. **Rewire intent parsing** - Verify "rewire X to use Y" is not interpreted as "remove X and Y"
+3. **Type mismatch severity** - Verify TEXT_WITH_SOURCES → DOCUMENT is warning, not critical
+4. **Persona action input validation** - Verify external AIE inputs are validated correctly
+
+---
+
+## Reproduction Steps
+
+To reproduce these issues:
+
+```bash
+# 1. Analyze the original persona
+persona(method="analyze", id="8ed79612-a8be-4c13-8736-daf5e4b0db96", env="demo")
+
+# 2. Observe false positive unused_category issues
+
+# 3. Try to fix with modify
+persona(method="update", id="...", input="rewire document_instructions to use json_mapper.output_json", preview=true)
+
+# 4. Observe nodes being removed instead of rewired
+```
+
+---
+
+## References
+
+- Original persona: `8ed79612-a8be-4c13-8736-daf5e4b0db96`
+- Cloned persona: `2c5b7b2c-fee9-409f-8c87-d264fd4f27cd`
+- Environment: demo
+- MCP Toolkit version: 0.0.0-dev

package/docs/TODO-fix-analyzer-and-modify.md

@@ -0,0 +1,182 @@
+# TODO: Fix Analyzer and Modify Handler Issues
+
+**Created:** 2026-01-25  
+**Status:** MOSTLY RESOLVED (2026-01-25)
+**Context:** Debug session for SKYE Self-Service AI Assistant
+
+> **UPDATE 2026-01-25**: The modify handler was completely refactored to remove
+> ALL hardcoded NL parsing. See `.ctx/plans/2026-01-25-remove-hardcoded-logic.md`.
+> Items 1-4 were addressed as part of the refactor (NL parsing removed entirely).
+
+---
+
+## Critical Bugs (Fix Immediately)
+
+### 1. [x] Fix enumType ↔ Categorizer Association Bug ✅ FIXED
+
+**File:** `src/sdk/knowledge.ts`  
+**Line:** ~2968-2976  
+**Function:** `detectUnusedCategories`
+
+**Problem:** The `enumTypes.find()` fallback `|| nameStr.includes("enumType")` matches ANY enumType, causing categories from categorizer B to be attributed to categorizer A.
+
+**Fix:**
+```typescript
+// Replace this:
+return nameStr.includes(categorizer.id) || nameStr.includes("enumType");
+
+// With this:
+return nameStr.includes(categorizer.id);
+
+// Or better - use typeArguments reference:
+const categorizerAction = actions.find(a => a.name === categorizer.id);
+const enumTypeRef = categorizerAction?.typeArguments?.categories?.enumType?.name?.name?.name;
+const enumType = enumTypes.find(e => extractEnumTypeName(e) === enumTypeRef);
+```
+
+**Test:** Add test for multi-categorizer workflows with distinct enumTypes.
+
+---
+
+### 2. [x] Fix Modify Handler Rewire vs Remove Confusion ✅ RESOLVED
+
+**Status:** RESOLVED via architecture change.
+
+**Resolution:** The entire NL-parsing approach was removed. The modify handler
+now accepts STRUCTURED OPERATIONS from the Agent, not natural language.
+
+The Agent (LLM) builds operations like:
+```typescript
+{
+  type: "rewire",
+  rewire: {
+    target_node: "downstream_node",
+    target_input: "query",
+    source_node: "upstream_node",
+    source_output: "response",
+  }
+}
+```
+
+No regex parsing needed - the LLM naturally understands user intent.
+
+---
+
+## Medium Priority (Feature Gaps)
+
+### 3. [ ] Add Type Coercion Rules and Guidance
+
+**File:** `src/sdk/validation-rules.ts`
+
+**Status:** Still applicable. Consider adding for validation feedback.
+
+---
+
+### 4. [x] Implement Rewire Operation in applyWorkflowModifications ✅ DONE
+
+**Status:** IMPLEMENTED in `src/mcp/handlers/workflow/modify.ts`
+
+The `executeRewire()` function handles structured rewire operations:
+```typescript
+const result = await handleWorkflowModify(args, client);
+// With operations: [{ type: "rewire", rewire: { target_node, target_input, source_node, source_output } }]
+```
+
+---
+
+### 5. [ ] Improve Type Mismatch Fix Suggestions
+
+**File:** `src/sdk/knowledge.ts`  
+**Function:** `suggestWorkflowFixes`
+
+**Update type_mismatch case to use TYPE_COERCION_RULES:**
+```typescript
+case "type_mismatch": {
+  const rule = TYPE_COERCION_RULES.find(r =>
+    issue.got?.includes(r.sourceType) && issue.expected?.includes(r.targetType)
+  );
+  
+  fix = rule ? {
+    issue_type: issue.type,
+    severity: rule.severity,
+    workarounds: rule.workarounds,
+    note: rule.severity === "warning" ? "May work at runtime - test first" : undefined,
+  } : { /* existing generic fix */ };
+  break;
+}
+```
+
+---
+
+## Low Priority (Documentation)
+
+### 6. [ ] Update ema://rules/anti-patterns Resource
+
+**File:** `src/mcp/resources.ts` or generated resource
+
+**Add pattern:**
+```json
+{
+  "id": "type-mismatch-persona-action",
+  "name": "Type Mismatch with Persona Actions",
+  "pattern": "Connecting TEXT_WITH_SOURCES output to persona action's DOCUMENT input",
+  "problem": "Persona actions have specific input type requirements",
+  "solution": "Use named_inputs which accepts any type, or test runtime coercion",
+  "severity": "warning"
+}
+```
+
+---
+
+### 7. [ ] Update Ema MCP Expert Skill
+
+**File:** `skills/ema-mcp-expert/SKILL.md` (generated)
+
+**Add troubleshooting entry:**
+```markdown
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| Type mismatch with persona action | Persona expects different type | Use named_inputs or test runtime |
+| Unused category false positive | Multi-categorizer enumType bug | Verify actual enumType associations |
+```
+
+---
+
+### 8. [ ] Add Input Source Rule for Persona Actions
+
+**File:** `src/sdk/validation-rules.ts`
+
+**Add guidance:**
+```typescript
+{
+  actionPattern: "persona_action",  // Generic pattern for all persona actions
+  recommended: "named_inputs for flexible type handling",
+  avoid: ["direct document_instructions without type validation"],
+  reason: "Persona actions have specific workflow input schemas. Use named_inputs for flexibility.",
+  severity: "info",
+  fix: "Pass data via named_inputs: { namedInputs: [{ name: '...', binding: {...} }] }",
+}
+```
+
+---
+
+## Testing Checklist
+
+- [ ] Unit test: Multi-categorizer enumType association
+- [ ] Unit test: Rewire intent parsing (should NOT trigger removal)
+- [ ] Unit test: Type mismatch severity levels
+- [ ] Integration test: Clone + modify workflow without false positives
+- [ ] E2E test: SKYE workflow analysis returns 0 critical false positives
+
+---
+
+## Files Modified
+
+| File | Changes |
+|------|---------|
+| `src/sdk/knowledge.ts` | Fix enumType matching, improve type mismatch fixes |
+| `src/sdk/validation-rules.ts` | Add TYPE_COERCION_RULES |
+| `src/mcp/handlers/workflow/modify.ts` | Add rewire detection and implementation |
+| `src/mcp/resources.ts` | Update anti-patterns resource |
+| `test/knowledge.test.ts` | Add multi-categorizer tests |
+| `test/handlers/workflow/modify.test.ts` | Add rewire tests |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ema.co/mcp-toolkit",
-  "version": "2026.1.25",
+  "version": "2026.1.26-3",
   "description": "Ema AI Employee toolkit - MCP server, CLI, and SDK for managing AI Employees across environments",
   "type": "module",
   "main": "dist/index.js",
@@ -52,18 +52,23 @@
     "lint:unused": "knip",
     "precommit": "npm run typecheck && npm run test",
     "prepare": "husky",
-    "prepublishOnly": "npm run build && npm run test",
+    "check:publish": "tsx scripts/check-publish-content.ts",
+    "prepublishOnly": "npm run build && npm run test && npm run check:publish",
     "generate:types": "tsx scripts/generate-types.ts",
     "generate:api-client": "npx @hey-api/openapi-ts -i src/sdk/generated/openapi.json -o src/sdk/generated/api-client -c @hey-api/client-fetch",
     "generate:protos": "buf generate ../ema-repos/protos --template buf.gen.yaml",
     "generate:proto-fields": "tsx scripts/generate-proto-fields.ts",
     "generate:action-schema": "tsx scripts/generate-action-schema.ts",
-    "generate:all": "npm run generate:protos && npm run generate:api-client",
+    "generate:skill": "tsx scripts/generate-skill.ts",
+    "generate:skill:check": "tsx scripts/generate-skill.ts --check",
+    "generate:templates": "tsx scripts/generate-templates.ts",
+    "generate:templates:check": "tsx scripts/generate-templates.ts --check",
+    "generate:all": "npm run generate:protos && npm run generate:api-client && npm run generate:templates && npm run generate:skill",
     "check:contracts": "tsx scripts/check-api-contracts.ts",
     "check:schema-sync": "tsx scripts/check-schema-handler-sync.ts",
     "check:prompt-refs": "tsx scripts/check-prompt-refs.ts",
     "check:action-aliases": "tsx scripts/check-action-aliases.ts",
-    "check:all": "npm run check:contracts && npm run check:schema-sync && npm run check:prompt-refs && npm run check:action-aliases",
+    "check:all": "npm run check:contracts && npm run check:schema-sync && npm run check:prompt-refs && npm run check:action-aliases && npm run generate:skill:check",
     "release:check": "tsx scripts/check-release-need.ts"
   },
   "repository": {