@sassoftware/sas-score-mcp-serverjs 0.4.1-20 → 0.4.1-22

package/cli.js

@@ -23,6 +23,7 @@ import readCerts from './src/toolHelpers/readCerts.js';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import os from 'os';
+import setupSkills from './src/setupSkills.js';
 import { parseArgs } from "node:util";
 
 import NodeCache from 'node-cache';
@@ -213,11 +214,21 @@ if (args.values.version) {
 // the -client indicates the current mcp client 
 console.error(`[Note] MCP client set to: ${process.env.CLIENT}`);
 
+
 let client = process.env.CLIENT;
+if (client !== 'none') {
+  console.error(`[Note] Setting up skills for client: ${client}...`);
+  setupSkills(client);
+} else {
+  console.error(`[Note] No client specified, skipping skill setup...`);
+}
+
+
+/*
 if (client !== 'none') {
   let destdir = '.' + client;
   let skillsDest = join(os.homedir(), destdir,'skills');
-  const skillsSrc = join(__dirname, 'skills');
+  const skillsSrc = join(__dirname, '.github');
   if (!fs.existsSync(skillsSrc)) {
     console.error('No skills directory found in this package.');
     process.exit(1);
@@ -244,6 +255,7 @@ if (client !== 'none') {
 
   }
 }
+  */
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "0.4.1-20",
+  "version": "0.4.1-22",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",
@@ -42,9 +42,8 @@
     "cli.js",
     "openApi.json",
     "openApi.yaml",
-    "skills",
     "scripts",
-    ".claude"
+    ".github"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",

package/scripts/setup-skills.js

@@ -1,78 +1,32 @@
 #!/usr/bin/env node
-
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { parseArgs } from "node:util";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Recursive copy function
-function copyRecursiveSync(src, dest) {
-  const stat = fs.statSync(src);
-  
-  if (stat.isDirectory()) {
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-    const files = fs.readdirSync(src);
-    files.forEach(file => {
-      copyRecursiveSync(path.join(src, file), path.join(dest, file));
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Paths
+let client = (process.env.CLIENTNAME == null) ? '.github' : `.${process.env.CLIENTNAME.toLowerCase()}`;
+const source = path.join(__dirname, `.skills`);
+const destination = path.join(process.cwd(), client);
+console.error(`📁 Copying ${source} to ${destination}...`);
+function copyFolderSync(from, to) {
+    if (!fs.existsSync(from)) return;
+    if (!fs.existsSync(to)) fs.mkdirSync(to, { recursive: true });
+    console.error(`📁 Copying folder: ${from} to ${to}`);
+    fs.readdirSync(from).forEach(element => {
+        const fromPath = path.join(from, element);
+        const toPath = path.join(to, element);
+        if (fs.lstatSync(fromPath).isFile()) {
+            fs.copyFileSync(fromPath, toPath);
+        } else if (fs.lstatSync(fromPath).isDirectory()) {
+            copyFolderSync(fromPath, toPath);
+        }
     });
-  } else {
-    fs.copyFileSync(src, dest);
-  }
-}
-
-// Get folder name from command line arguments or environment variable
-const args = parseArgs({
-  options: {
-    'skills-folder': {
-      type: 'string',
-      short: 'f',
-      description: 'Skills folder name'
-    }
-  }});
-
-let folderName = args.values['skills-folder'] || process.env.SKILLS_FOLDER_NAME;
-if (folderName == null) {
-  folderName = '.github';
-}
-folderName = folderName + '/skills';
-// If no folder name provided, show usage
-if (!folderName) {
-  console.error('Usage:');
-  console.error('  npm run setup-skills -f <folder-name>');
-  console.error('  or set SKILLS_FOLDER_NAME environment variable');
-  console.error('\nExample:');
-  console.error('  npm run setup-skills -f my-skills-folder');
-  process.exit(0);
-}
-console.error(`Setting up skills in folder: ${folderName}`);
-// Resolve paths
-const skillsSourcePath = path.join(__dirname, '../skills');
-const targetPath = path.join(process.cwd(), folderName);
-
-// Check if skills folder exists
-if (!fs.existsSync(skillsSourcePath)) {
-  console.error(`Error: Skills folder not found at ${skillsSourcePath}`);
-  process.exit(1);
 }
 
 try {
-  // Create target directory if it doesn't exist
-  if (!fs.existsSync(targetPath)) {
-    fs.mkdirSync(targetPath, { recursive: true });
-    console.error(`✓ Created folder: ${targetPath}`);
-  } else {
-    console.error(`✓ Folder already exists: ${targetPath}`);
-  }
-
-  // Copy skills folder contents to target
-  copyRecursiveSync(skillsSourcePath, targetPath);
-  console.error(`✓ Successfully copied skills to: ${targetPath}`);
-} catch (error) {
-  console.error('Error during setup:', error.message);
-  process.exit(1);
+    copyFolderSync(source, destination);
+    console.error(`✅ Success: ${destination} folder is now in your project root.`);
+} catch (err) {
+    console.error('❌ Error copying files:', err.message);
 }
+process.exit(0);

package/src/setupSkills.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+function setupSkills(clientName) {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    // Paths
+    let client = (clientName == null) ? '.github' : `.${clientName.toLowerCase()}`;
+    const source = path.join(__dirname, `../.skills`); 
+    const destination = path.join(os.homedir(), client);
+    console.error(`📁 Copying ${source} to ${destination}...`);
+    function copyFolderSync(from, to) {
+        if (!fs.existsSync(from)) return;
+        if (!fs.existsSync(to)) fs.mkdirSync(to, { recursive: true });
+        console.error(`📁 Copying folder: ${from} to ${to}`);
+        fs.readdirSync(from).forEach(element => {
+            console.error(`📁 Processing: ${element}`);
+            const fromPath = path.join(from, element);
+            const toPath = path.join(to, element);
+            if (fs.lstatSync(fromPath).isFile()) {
+                fs.copyFileSync(fromPath, toPath);
+            } else if (fs.lstatSync(fromPath).isDirectory()) {
+                copyFolderSync(fromPath, toPath);
+            }
+        });
+    }
+
+    try {
+        copyFolderSync(source, destination);
+        console.error(`✅ Success: ${destination} folder is now in your project root.`);
+    } catch (err) {
+        console.error('❌ Error copying files:', err.message);
+    }
+}
+export default setupSkills;

package/src/toolSet/findModel.js

@@ -9,7 +9,7 @@ import _listModels from '../toolHelpers/_listModels.js';
 
 function findModel(_appContext) {
   let description = `
-find-model — locate a specific model deployed to MAS (Model Aggregation Service).
+find-model — locate a specific MAS model deployed to MAS server 
 
 USE when: find model, does model exist, is model deployed, lookup model, verify model exists
 DO NOT USE for: list models (use list-models), model info/variables (use model-info), score model (use model-score), find table/job/lib (use respective tools), scr models (use scr-info/scr-score)

package/src/toolSet/findTable.js

@@ -47,8 +47,8 @@ Returns { tables: [] } if not found; { tables: [name, ...] } if found. Never hal
     name: 'find-table',
     description: description,
     inputSchema: z.object({
-      name: z.string(),
       lib: z.string(),
+      name: z.string(),
       server: z.string() 
     }),
     

package/src/toolSet/modelScore.js

@@ -10,7 +10,7 @@ const log = debug('tools');
 
 function modelScore(_appContext) {
   let description = `
-model-score — score data using a deployed model on MAS.
+mas-score — score data using a deployed model on MAS.
 
 USE when: score with model, predict using model, batch scoring, model predictions
 DO NOT USE for: find model, model metadata, list models, run programs/jobs, query tables
@@ -40,7 +40,7 @@ Returns predictions, probabilities, scores merged with input data. Returns error
 
  
   let spec = {
-    name: 'model-score',
+    name: 'mas-score',
     description: description,
     inputSchema:z.object({
       model: z.string(),

package/src/toolSet/runJob.js

@@ -9,9 +9,9 @@ import _jobSubmit from '../toolHelpers/_jobSubmit.js';
 function runJob(_appContext) {
  
   let description = `
-run-job — execute a deployed SAS Viya job.
+run-job — score with a deployed SAS Viya job.
 
-USE when: run job, execute job, run with parameters
+USE when: score with job, run job, execute job
 DO NOT USE for: arbitrary SAS code (use run-sas-program), macros (use run-macro), list/find jobs
 
 PARAMETERS

package/src/toolSet/runJobdef.js

@@ -10,9 +10,9 @@ function runJobdef(_appContext) {
   // JSON object for LLM/tooling
  
   let description = `
-run-jobdef — execute a SAS Viya job definition.
+run-jobdef — score with a deployed SAS Viya job definition.
 
-USE when: run jobdef, execute jobdef, run with parameters
+USE when: score with jobdef, run jobdef, execute jobdef
 DO NOT USE for: arbitrary SAS code (use run-sas-program), macros (use run-macro), list/find jobdefs
 
 PARAMETERS

package/.claude/mcp-tool-description-optimizer/SKILL.md

@@ -1,129 +0,0 @@
----
-name: mcp-tool-description-optimizer
-description: >
-  Optimize MCP (Model Context Protocol) tool descriptions for token efficiency and LLM routing accuracy.
-  Use this skill whenever a user shares a raw, verbose, or poorly structured MCP tool description and wants
-  it improved, rewritten, or reviewed. Trigger on phrases like: "optimize this tool description",
-  "rewrite my MCP tool description", "make this tool description more efficient", "clean up my tool spec",
-  "improve how Claude picks my tool", or when a user pastes a JavaScript/TypeScript tool description string
-  and asks for help with it. Also trigger when the user mentions token efficiency, tool routing,
-  or LLM disambiguation in the context of MCP servers.
----
-
-# MCP Tool Description Optimizer
-
-Rewrites verbose or poorly structured MCP tool descriptions into compact, signal-rich versions that
-improve LLM tool selection accuracy while reducing token usage.
-
-## Why this matters
-
-Claude and other LLMs select MCP tools based entirely on the `description` field. Descriptions that are
-too long, redundant, or badly structured waste context tokens and reduce routing precision.
-A well-optimized description:
-- States what the tool does and when to use it upfront
-- Eliminates redundancy (same info repeated across sections)
-- Uses a compact, scannable format (labeled blocks, not nested markdown)
-- Includes clear negative examples to prevent mis-routing
-- Keeps parameters terse — name, type, default, one-line purpose
-
----
-
-## Optimization Process
-
-### Step 1 — Analyze the input description
-
-Before rewriting, identify these problems in the original:
-
-| Problem | Example |
-|---|---|
-| **Redundancy** | Trigger phrases listed in 3+ places |
-| **Filler sections** | "Rationale", "Behavior Summary", "Response Contract" with no routing signal |
-| **Orphaned syntax** | Arrows (`→`) or bullets with no target |
-| **Overlong examples** | Long prose examples when one-liners suffice |
-| **Heavy markdown** | `##` headers for every minor point |
-| **Duplicated parameter docs** | Same param described in both a table and prose |
-
-Call out 2–4 of the most impactful issues before writing the new version.
-
-### Step 2 — Rewrite using the standard template
-
-Use this exact block structure for the output. Omit blocks that don't apply.
-
-```
-<tool-name> — <one-line purpose>.
-
-USE when: <comma-separated user intents or trigger phrases>
-DO NOT USE for: <comma-separated anti-patterns with → redirect where applicable>
-
-PARAMETERS
-- <name>: <type> (default: <val>) — <one-line purpose>
-...
-
-ROUTING RULES
-- "<trigger phrase>" → { param: value }
-- "<trigger phrase>" → { param: value }
-- <ambiguous case> → <ask for clarification | default behavior>
-
-EXAMPLES
-- "<user utterance>" → { param: value, ... }
-- "<user utterance>" → { param: value, ... }
-
-NEGATIVE EXAMPLES (do not route here)
-- "<user utterance>" → <correct tool>
-
-PAGINATION (include only if tool is paginated)
-If returned count === limit → hint: next start = start + limit.
-If start > 1 and result empty → note paging may exceed available items.
-
-ERRORS
-<One or two lines: return structure, hallucination policy>
-```
-
-### Step 3 — Apply these rules consistently
-
-**USE/DO NOT USE block**
-- Write as comma-separated inline list, not a bullet list
-- DO NOT USE entries should name the redirect tool in parentheses where known
-
-**ROUTING RULES block**
-- One rule per line; quote the trigger phrase; use `→ { }` for param mapping
-- Consolidate synonyms on one line: `"cas libs / cas libraries / in cas" → { server: 'cas' }`
-- List the default/fallback rule last
-
-**PARAMETERS block**
-- One line per param: `- name: type (default: val) — purpose`
-- Skip obvious params (e.g. don't explain what `limit` means if it's standard pagination)
-
-**EXAMPLES block**
-- Each example fits on one line
-- For "next page" examples, include the prior call's state inline: `"next" (prev: start:1, limit:10) → { start: 11, limit: 10 }`
-
-**NEGATIVE EXAMPLES block**
-- Only include when mis-routing is a real risk
-- Format: `"<utterance>" → <correct-tool-name>`
-
-**Tone**
-- Imperative, terse. No filler words ("Please note that...", "It is important to...")
-- Never include a "Rationale" or "Behavior Summary" section — if behavior matters, encode it as a rule
-
-### Step 4 — Validate before returning
-
-Check the rewritten description against this list:
-
-- [ ] No trigger phrase appears in more than one block
-- [ ] No orphaned `→` arrows or dangling bullets
-- [ ] Parameter defaults are stated explicitly
-- [ ] Negative examples cover the tool's most common mis-routing risks
-- [ ] Total length is ≤ 50% of the original (target: 30–40% reduction)
-
----
-
-## Output format
-
-Always return:
-
-1. **Analysis** — 2–4 bullet points naming the key issues found in the original
-2. **Rewritten description** — inside a JavaScript code block (matching the user's original code style)
-3. **Change summary** — a short table or bullet list of what changed and why
-
-See `references/examples.md` for before/after examples of real tool descriptions.

package/.claude/mcp-tool-description-optimizer/references/examples.md

@@ -1,123 +0,0 @@
-# Before / After Examples
-
-## Example 1 — list-libraries (SAS Viya MCP)
-
-### BEFORE (~620 tokens)
-
-```
-## list-libraries — enumerate CAS or SAS libraries
-
-LLM Invocation Guidance (critical)
-Use THIS tool when the user asks for: "list libs", "list libraries", "show cas libs", "show sas libs",
-"what libraries are available", "list caslib(s)", "enumerate libraries", "libraries in cas", "libraries in sas".
-DO NOT use this tool when the user asks for: tables inside a specific library (choose listTables),
-columns/metadata of a table, job/program execution, models, or scoring.
-
-Trigger Phrase → Parameter Mapping
-- "cas libs" / "in cas" / "cas libraries" → { server: 'cas' }
-- "sas libs" / "in sas" / "base sas libraries" → { server: 'sas' }
-- "all libs" / "all libs" -> {server: 'all'}
-→ { server: 'all' }
-- "next" (after prior call) → { start: previous.start + previous.limit }
-- "first 20 cas libs" → { server: 'cas', limit: 20 }
-- If server unspecified: default to all.
-
-Parameters
-- server (cas|sas|all, default 'all')
-- limit (integer > 0, default 10)
-- start (1-based offset, default 1)
-- where (optional filter expression, default '')
-
-Response Contract
-Return JSON-like structure from helper; consumers may extract an array of library objects/names.
-If number of returned items === limit supply a pagination hint: start = start + limit.
-
-Behavior Summary
-- Pure listing; no side effects.
-- If ambiguous short request like "list" or "libs" and no prior context: assume { server: 'cas' }.
-- If user explicitly asks for ALL (e.g. "all cas libs") and count likely large, honor limit=50 unless
-  user supplies a value; include note about paging.
-
-Disambiguation Rules
-- If user mentions a singular library name plus desire for tables ("list tables in SASHELP") choose
-  listTables (not this tool).
-- If user mixes "tables" and "libraries" ask for clarification unless clearly about libraries.
-
-Examples
-- "list libraries" → { server: 'all', start:1, limit:10 }
-- "list libs" → { server: 'all', start:1, limit:10 }
-- "list sas libs" → { server: 'sas' }
-- "list cas libraries" → { server: 'cas' }
-- "show me 25 cas libraries" → { server:'cas', limit:25 }
-- "next" (after prior call {start:1,limit:10}) → { start:11, limit:10 }
-- "filter cas libs" (no criterion) → ask: "Provide a filter or continue without one?"
-
-Negative Examples (do not route here)
-- "list tables in public" (route to list-tables)
-- "list models, list tables, list jobs, list jobdef and similar request"
-- "describe library" (likely list-tables or table-info depending on follow-up)
-- "run program to make a lib" (run-sas-program tool)
-
-Error Handling
-- On backend error: return structured error with message field; do not hallucinate libraries.
-- Empty result set → return empty list plus (if start>1) a hint that paging may have exceeded available items.
-
-Rationale
-Concise, signal-rich description increases probability this spec is selected for generic library
-enumeration intents.
-```
-
-### AFTER (~210 tokens)
-
-```
-list-libraries — enumerate CAS or SAS libraries.
-
-USE when: list/show/enumerate libraries, caslibs, sas libs, available libraries
-DO NOT USE for: listing tables in a library (→ list-tables), column/table metadata, job execution, models, scoring
-
-PARAMETERS
-- server: 'cas' | 'sas' | 'all' (default: 'all')
-- limit: integer > 0 (default: 10)
-- start: 1-based offset (default: 1)
-- where: optional filter expression (default: '')
-
-ROUTING RULES
-- "cas libs / cas libraries / in cas"          → { server: 'cas' }
-- "sas libs / sas libraries / in sas"          → { server: 'sas' }
-- "all libs / all libraries"                   → { server: 'all' }
-- "all cas libs" with no limit given           → { server: 'cas', limit: 50 } + paging note
-- "next" after prior call (start:S, limit:L)   → { start: S + L, limit: L }
-- "filter cas libs" with no filter given       → ask: "What filter expression should I apply?"
-- server unspecified / ambiguous "list"/"libs" → { server: 'cas' }
-
-EXAMPLES
-- "list libraries"                → { server: 'all', start: 1, limit: 10 }
-- "list cas libraries"            → { server: 'cas', start: 1, limit: 10 }
-- "show me 25 sas libs"           → { server: 'sas', limit: 25, start: 1 }
-- "next" (prev: start:1,limit:10) → { server: <same>, start: 11, limit: 10 }
-
-NEGATIVE EXAMPLES (do not route here)
-- "list tables in SASHELP"        → list-tables
-- "list models / jobs / jobdefs"  → respective tools
-- "run a program to create a lib" → run-sas-program
-
-PAGINATION
-If returned count === limit → hint: next start = start + limit.
-If start > 1 and result empty → note paging may exceed available items.
-
-ERRORS
-Return structured error with message field. Never hallucinate library names.
-```
-
-**Token reduction: ~66%**
-
----
-
-## Key patterns illustrated
-
-- Trigger phrases consolidated from 3 blocks → 1 ROUTING RULES block
-- "Rationale", "Behavior Summary", "Response Contract" sections eliminated
-- Orphaned `→ { server: 'all' }` arrow removed
-- Parameter defaults made explicit inline
-- Examples trimmed to one line each
-- Negative examples now name the redirect tool explicitly

package/.claude/sas-find-library-smart/SKILL.md

@@ -1,154 +0,0 @@
----
-name: sas-find-library-smart
-description: >
-  Find a SAS Viya library (libref or caslib) with intelligent server detection. Automatically checks 
-  CAS first, then SAS if not found. Use this skill when the user needs to verify a library exists,
-  before accessing tables within it. Trigger phrases include: "find library", "does library exist",
-  "check if library", "locate library", "is there a library named", "verify library", or any request 
-  to confirm a library's availability across servers.
----
-
-# Smart Library Lookup (Find Library)
-
-Intelligently locates a SAS Viya library by checking CAS first, then SAS if the library is not found 
-in CAS. Provides the user with clear information about library availability and location.
-
-**If the user specifies the server explicitly** (e.g., "find library Public in cas"):
-- Use the specified server: `server: "cas"` or `server: "sas"`
-- Proceed directly to finding the library
-
-**If the server is NOT specified:**
-1. **First attempt**: Check CAS (`server: "cas"`)
-2. **If not found in CAS**: Check SAS with uppercase library name (`server: "sas"`)
-3. **If not found in either**:
-   - Inform user: *"The library '<lib>' was not found in CAS or SAS servers. Please verify the library name."*
-   - Suggest: *"Would you like to list available libraries?"* (suggest `sas-score-list-libraries`)
-4. **If found**:
-   - Inform user which server contains the library: *"Found library '<lib>' in CAS"* or *"Found library '<lib>' in SAS"*
-   - Offer next steps: *"Would you like to list tables in this library?"* (suggest `sas-score-list-tables`)
-
----
-
-## Using sas-score-find-library
-
-**When:**
-- User wants to verify a library exists
-- User needs to determine which server contains a library
-- User wants to check library availability before accessing it
-- User wants to explore available libraries (before querying)
-
-**How:**
-```
-sas-score-find-library({
-  name: "libraryname",          // required
-  server: "cas" or "sas"        // optional; determined by server check if not specified
-})
-```
-
-**Rules:**
-- Always determine the correct server first (cas → sas → neither)
-- **For SAS server: always uppercase the library name** (e.g., "public" → "PUBLIC")
-- If library name is missing, ask: *"Which library name would you like to find?"*
-- Return the server where the library was found
-- If not found in either server, clearly inform the user and offer to list available libraries
-- Do not proceed with table access until library existence is confirmed
-
----
-
-## Smart server detection logic
-
-```
-IF server specified by user
-  → IF server is "sas"
-      → uppercase lib
-  → use that server, call sas-score-find-library
-ELSE
-  → TRY sas-score-find-library(lib, server="cas")
-    IF library found
-      → success, inform user: library found in CAS
-    ELSE
-      → uppercase lib
-      → TRY sas-score-find-library(lib.toUpperCase(), server="sas")
-        IF library found
-          → success, inform user: library found in SAS
-        ELSE
-          → inform user library not found in either server
-          → offer to list available libraries
-```
-
----
-
-## Common patterns
-
-**Pattern 1 — Find library, server unspecified**
-> "Find library Public"
-
-1. Try CAS: `sas-score-find-library({ name: "Public", server: "cas" })`
-2. If not found, try SAS with uppercase: `sas-score-find-library({ name: "PUBLIC", server: "sas" })`
-3. If found in CAS → *"Found library 'Public' in CAS. Would you like to list tables in it?"*
-4. If found in SAS → *"Found library 'PUBLIC' in SAS. Would you like to list tables in it?"*
-5. If not found → *"The library 'Public' was not found in CAS or SAS. Would you like to list available libraries?"*
-
-**Pattern 2 — Find library with explicit server (CAS)**
-> "Find library MyData in cas"
-
-1. Skip server detection
-2. Call: `sas-score-find-library({ name: "MyData", server: "cas" })`
-3. Result → *"Found library 'MyData' in CAS"* or *"Library 'MyData' not found in CAS"*
-
-**Pattern 3 — Find library with explicit server (SAS)**
-> "Does library SASHELP exist in sas"
-
-1. Skip server detection
-2. Uppercase lib: `sas-score-find-library({ name: "SASHELP", server: "sas" })`
-3. Result → *"Found library 'SASHELP' in SAS"* or *"Library 'SASHELP' not found in SAS"*
-
-**Pattern 4 — Library not found, offer next steps**
-> "Check if library staging exists"
-
-1. Try CAS: `sas-score-find-library({ name: "staging", server: "cas" })` → not found
-2. Try SAS: `sas-score-find-library({ name: "STAGING", server: "sas" })` → not found
-3. Respond:
-   - *"The library 'staging' was not found in CAS or SAS."*
-   - *"Would you like to:"*
-     - *"List all available libraries? (use `sas-score-list-libraries`))"*
-     - *"Check a different library name?"*
-
-**Pattern 5 — Library found, follow-up action**
-> "Verify library samples exists"
-
-1. Try CAS: `sas-score-find-library({ name: "samples", server: "cas" })` → found
-2. Respond:
-   - *"Found library 'samples' in CAS."*
-   - *"Would you like to list tables in this library? (use `sas-score-list-tables`))"*
-
----
-
-## Output presentation
-
-**When library is found:**
-```
-✓ Found library '<lib>' in <SERVER>
-
-Would you like to:
-• List tables in this library (use sas-list-tables-smart skill)
-• Read data from a specific table (use sas-read-strategy skill)
-```
-
-**When library is not found:**
-```
-✗ Library '<lib>' not found in either CAS or SAS
-
-Suggestions:
-• Check the spelling of the library name
-• List available libraries (use list-libraries tool)
-• Try a different library name
-```
-
----
-
-## Integration with other skills
-
-- **After finding library → List tables**: Use `sas-list-tables-smart` skill to browse available tables
-- **After finding library → Read data**: Use `sas-read-strategy` skill to retrieve data from tables
-- **Library not found → Explore**: Use `sas-score-list-libraries` tool to see all available libraries