@sassoftware/sas-score-mcp-serverjs 1.0.0 → 1.0.1-10

package/{.skills/agents/sas-viya-scoring-expert.md → .agents/sas-score-mcp-serverjs-agent.md}

@@ -1,5 +1,5 @@
 ---
-name: SAS Viya Scoring Expert
+name: sas-score-mcp-serverjs-agent
 description: Specialized SAS and Viya agent that classifies requests, selects the right SAS skill, and uses MCP tools safely for jobs, CAS data, libraries, models, scoring, and content workflows.
 ---
 

package/{.skills → .instructions}/copilot-instructions.md

@@ -5,6 +5,14 @@ This repository builds and maintains a SAS-focused agent experience on top of an
 The MCP server exposes SAS and Viya capabilities such as jobs, code artifacts, CAS server resources, SAS server resources, MAS models, score/scoring assets, and related metadata.
 Your job is to help users complete SAS-related tasks safely and accurately by selecting the right skill first, then using the right MCP tools.
 
+## Available Agents
+
+This repository includes specialized agents for SAS-focused workflows:
+
+- **sas-score-mcp-serverjs-agent** — Specialized for SAS Viya scoring tasks. Classifies requests, selects the right SAS skill, and uses MCP tools safely for jobs, CAS data, libraries, models, scoring, and content workflows.
+- **Explore** — General codebase exploration and Q&A agent. Use for discovering code patterns, reading documentation, or quick exploratory questions.
+
+You can invoke these agents using the subagent feature. Type `/subagent` followed by your request or choose an agent from the dropdown when available.
 
 ## Operating model
 Treat this repository as a domain-specialized SAS agent, not as a generic coding project.
@@ -98,8 +106,32 @@ Never make up SAS assets, job names, model identifiers, or CAS resources.
 If a requested action depends on environment-specific details, verify those details first.
 Prefer inspection and discovery over assumption.
 
+---
+# Read TableWorkflow Enforcement (MANDATORY)
+
+For any request to read, fetch, or query a table (e.g., score a=1 with model abc", read maps.india", "get rows from lib.table", "show data from ..."), you MUST follow this workflow:
+
+Step 1. **Always use the sas-find-resource-strategy**
+
+- For tables:
+	- Use the `sas-find-resource-strategy` skill to locate the table and determine which server (CAS or SAS) contains it.
+	- Do not assume the server or skip this step, even if the library or table is commonly found in one server.
+	- If the table exists in both, ask the user which server to use.
+	- If the table is not found, inform the user and do not attempt to read.
+
+Step 2. **Only after confirming the table location:**
+	- Use the correct `sas-score-read-table` or `sas-score-sas-query` tool, specifying the server explicitly.
+
+3. **If you see a direct read-table/tool call without a prior find step:**
+	- Correct the workflow and restart from the find resource step.
+
+This workflow is mandatory for all table read requests. If you are unsure, always perform the find resource step before reading.
+
+See also: `./enforce-find-resource-strategy.md` for details and examples.
+
 ---
 
+
 # Available Skills
 
 This repository provides specialized skills for SAS-focused workflows. Load the relevant skill for the user's request before using MCP tools.
@@ -111,6 +143,22 @@ This repository provides specialized skills for SAS-focused workflows. Load the
 
 **Trigger phrases:** "find my model", "run scoring", "open the table", or any ambiguous request using domain terms.
 
+## sas-find-resource-strategy
+**Purpose:** Unified find-only strategy to verify existence of libraries, tables, models, jobs, and jobdefs using find tools.
+
+**Use when:** User asks to find, verify, check existence of, or locate a resource.
+
+**Trigger phrases:** "find library", "find table", "find model", "find job", "find jobdef", "does X exist".
+
+## sas-list-resource-strategy
+**Purpose:** Unified list strategy to list libraries, tables, models, jobs, and jobdefs with normalized pagination.
+
+**Use when:** User asks to list, show, browse, or enumerate resources.
+
+**Rule:** Always pass non-null `start` and `limit`; default to `start: 1` and `limit: 10` when not provided.
+
+**Trigger phrases:** "list libraries", "list tables", "list models", "list jobs", "list jobdefs", "show resources".
+
 ## sas-find-library-smart
 **Purpose:** Find a SAS Viya library (libref or caslib) with intelligent server detection. Automatically checks CAS first, then SAS if not found.
 
@@ -130,18 +178,24 @@ This repository provides specialized skills for SAS-focused workflows. Load the
 
 **Use when:** User wants to fetch records from a SAS/CAS table.
 
+**Pre-check:** Use `sas-find-resource-strategy` to verify library/table existence first.
+
 **Trigger phrases:** "read records from", "get data where", "fetch rows from", "query the table", "give me the first N records", "aggregate by", "join tables".
 
-## sas-read-and-score
+## sas-read-and-score-strategy
 **Purpose:** Guide the full read → score workflow in SAS Viya: reading records from a table and then scoring them with a MAS model.
 
 **Use when:** User wants to score records from a table, run a model against query results, predict outcomes for a set of rows, or any combination of fetching data and scoring it.
 
+**Pre-check:** Use `sas-find-resource-strategy` to verify library/table/model resources first.
+
 **Trigger phrases:** "score these records", "score results of my query", "run the model on this table", "predict for these customers", "fetch and score", "read and score", "score rows from", "run model on table data".
 
-## sas-score-workflow
+## sas-score-workflow-strategy
 **Purpose:** Mandatory routing logic for all scoring requests. Extracts model.type suffix and routes to the correct tool (run-job|run-jobdef|model-score|scr-score|run-program). Handles both MAS models and alternative scoring engines.
 
 **Use when:** User requests scoring with a model name that may require routing to different execution engines.
 
+**Pre-check:** Use `sas-find-resource-strategy` to verify model/job/jobdef resources before execution.
+
 **Trigger phrases:** "score with model X.job", "score X.jobdef scenario", "score with model X.mas", "score with model X.scr", any request with "score" + model name containing a dot (.) + type suffix.

package/.instructions/enforce-find-resource-strategy.md

@@ -0,0 +1,35 @@
+# Enforce Find Resource Strategy for Table Reads
+
+## Table Read Workflow (Strict)
+
+When handling any request to read, fetch, or query a table (e.g., "read maps.india", "get rows from lib.table", "show data from ..."), you MUST:
+
+1. **Always use the find resource strategy first:**
+   - Use the `sas-find-resource-strategy` skill to locate the table and determine which server (CAS or SAS) contains it.
+   - Do not assume the server or skip this step, even if the library or table is commonly found in one server.
+   - If the table exists in both, ask the user which server to use.
+   - If the table is not found, inform the user and do not attempt to read.
+
+2. **Only after confirming the table location:**
+   - Use the correct `sas-score-read-table` or `sas-score-sas-query` tool, specifying the server explicitly.
+
+3. **If you see a direct read-table/tool call without a prior find step:**
+   - Correct the workflow and restart from the find resource step.
+
+## Example (Correct)
+- User: "read maps.india"
+- Agent:
+  1. Use `sas-find-resource-strategy` to check for `maps.india` in CAS, then SAS.
+  2. If found in SAS only, call `sas-score-read-table` with `server: 'sas'`.
+
+## Example (Incorrect)
+- User: "read maps.india"
+- Agent: Calls `sas-score-read-table` with no server or with default server without checking table location first.
+
+## Enforcement
+- This workflow is mandatory for all table read requests.
+- If you are unsure, always perform the find resource step before reading.
+
+---
+
+Add this section to your always-on agent instructions or as a dedicated enforcement section for table read workflows.

package/.skills/{skills/sas-find-library-smart → sas-find-library-smart}/SKILL.md

@@ -13,6 +13,8 @@ description: >
 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.
 
+> Primary strategy: use `sas-find-resource-strategy` for all resource existence checks.
+
 **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
@@ -22,7 +24,7 @@ in CAS. Provides the user with clear information about library availability and
 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`)
+  - Ask for corrected library name or explicit server context
 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`)
@@ -50,8 +52,9 @@ sas-score-find-library({
 - **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
+- If not found in either server, clearly inform the user and request corrected name or server context
 - Do not proceed with table access until library existence is confirmed
+- Do not use list tools to find whether a library exists
 
 ---
 
@@ -73,7 +76,7 @@ ELSE
           → success, inform user: library found in SAS
         ELSE
           → inform user library not found in either server
-          → offer to list available libraries
+          → ask for corrected name or explicit server
 ```
 
 ---
@@ -87,7 +90,7 @@ ELSE
 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?"*
+5. If not found -> *"The library 'Public' was not found in CAS or SAS. Please confirm the name or specify a server."*
 
 **Pattern 2 — Find library with explicit server (CAS)**
 > "Find library MyData in cas"
@@ -110,9 +113,7 @@ ELSE
 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?"*
+  - *"Please confirm the library name or specify the server (CAS or SAS)."*
 
 **Pattern 5 — Library found, follow-up action**
 > "Verify library samples exists"
@@ -141,7 +142,7 @@ Would you like to:
 
 Suggestions:
 • Check the spelling of the library name
-• List available libraries (use list-libraries tool)
+• Specify the intended server (CAS or SAS)
 • Try a different library name
 ```
 
@@ -149,6 +150,6 @@ Suggestions:
 
 ## Integration with other skills
 
+- **Primary find strategy**: Use `sas-find-resource-strategy` for existence checks
 - **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

package/.skills/sas-find-resource-strategy/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: sas-find-resource-strategy
+description: >
+  Unified strategy for finding SAS Viya resources using find tools only. Supports library, table,
+  model, job, and jobdef lookup with server-aware behavior for CAS/SAS resources. Use this skill
+  whenever the task is to verify whether a resource exists.
+---
+
+# SAS Find Resource Strategy
+
+Use this skill to verify resource existence without using list tools.
+
+## Scope
+
+Supported resource types:
+- library
+- table
+- model
+- job
+- jobdef
+
+## Mandatory rule
+
+- Use the sas-find-resource strategy to check for the existence of a resource before attempting to read or use it. This ensures that follow-up actions are based on accurate information about resource availability.
+- Do not use list tools to find a resource.
+
+## Tool mapping
+
+- Library -> `sas-score-find-library`
+- Table -> `sas-score-find-table`
+- Model -> `sas-score-find-model`
+- Job -> `sas-score-find-job`
+- Jobdef -> `sas-score-find-jobdef`
+
+## Strategy by resource type
+
+### Find library
+
+If server is provided:
+- CAS: `sas-score-find-library({ name: "<lib>", server: "cas" })`
+- SAS: uppercase first, then `sas-score-find-library({ name: "<LIB>", server: "sas" })`
+
+If server is not provided:
+1. Check CAS first - `sas-score-find-library({ name: "<lib>", server: "cas" })`
+2. If not found, check SAS with uppercase library name - `sas-score-find-library({ name: "<LIB>", server: "sas" })`
+3. Report where found, or report not found in either.
+
+### Find table
+
+Required inputs:
+- library name
+- table name
+
+If server is provided:
+- CAS: `sas-score-find-table({ lib: "<lib>", name: "<table>", server: "cas" })`
+- SAS: uppercase library first, then `sas-score-find-table({ lib: "<LIB>", name: "<table>", server: "sas" })`
+
+If server is not provided:
+1. Check CAS first - `sas-score-find-table({ lib: "<lib>", name: "<table>", server: "cas" })`
+2. If not found, check SAS (uppercase library) - `sas-score-find-table({ lib: "<LIB>", name: "<table>", server: "sas" })`
+3. If found in both, report both and ask user which server to use for follow-up reads.
+
+### Find model
+
+Use:
+- `sas-score-find-model({ name: "<model>" })`
+
+If a model type suffix is provided (for example `.mas`, `.job`, `.jobdef`, `.scr`):
+- For MAS model discovery, strip suffix and look up base name with `sas-score-find-model`.
+- For `.job` and `.jobdef`, use job and jobdef find tools instead of model find.
+
+### Find job
+
+Use:
+- `sas-score-find-job({ name: "<job>" })`
+
+### Find jobdef
+
+Use:
+- `sas-score-find-jobdef({ name: "<jobdef>" })`
+
+## Clarifying prompts
+
+Ask one focused question if required fields are missing:
+- Library missing for table lookup: "Which library contains the table?"
+- Table name missing: "Which table name should I check?"
+- Resource type ambiguous: "Do you want me to find a library, table, model, job, or jobdef?"
+
+## Output format
+
+For found resources:
+- Confirm exact resource name returned by the tool.
+- Confirm server when applicable (CAS/SAS).
+
+For not found resources:
+- State that the resource was not found.
+- Ask for corrected name or server context.
+
+## Examples
+
+- "find library Samples" -> CAS first, then SAS fallback using uppercase.
+- "find table costchange in Samples" -> CAS first, then SAS fallback using uppercase library.
+- "find model breastcancer" -> `sas-score-find-model`.
+- "find job simplejob" -> `sas-score-find-job`.
+- "find jobdef daily_run" -> `sas-score-find-jobdef`.

package/.skills/sas-list-resource-strategy/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: sas-list-resource-strategy
+description: >
+  Unified strategy for listing SAS Viya resources using list tools. Supports libraries,
+  tables, models, jobs, and jobdefs. Always normalize pagination so start and limit are
+  never null: default start=1 and limit=10 when not provided.
+---
+
+# SAS List Resource Strategy
+
+Use this skill to list resources with consistent pagination defaults.
+
+## Scope
+
+Supported resource types:
+- library
+- table
+- model
+- job
+- jobdef
+
+## Mandatory pagination rule
+
+For every list operation:
+- `start` must never be null
+- `limit` must never be null
+- If `start` is missing or null, set `start: 1`
+- If `limit` is missing or null, set `limit: 10`
+
+Normalization pattern:
+```
+start = (start == null) ? 1 : start
+limit = (limit == null) ? 10 : limit
+```
+
+## Tool mapping
+
+- Library -> `sas-score-list-libraries`
+- Table -> `sas-score-list-table`
+- Model -> `sas-score-list-models`
+- Job -> `sas-score-list-jobs`
+- Jobdef -> `sas-score-list-jobdefs`
+
+## Strategy by resource type
+
+### List libraries
+
+Use:
+```
+sas-score-list-libraries({
+  server: "all" | "cas" | "sas",  // optional based on user intent
+  start: 1,
+  limit: 10
+})
+```
+
+If user provides server, honor it. If not, use default server behavior.
+
+### List tables
+
+Required input:
+- library name (`lib`)
+
+Use:
+```
+sas-score-list-tables({
+  lib: "libraryname",
+  server: "cas" | "sas",  // optional if strategy/tool supports detection
+  start: 1,
+  limit: 10
+})
+```
+
+If `lib` is missing, ask: "Which library should I list tables from?"
+
+### List models
+
+Use:
+```
+sas-score-list-models({
+  start: 1,
+  limit: 10
+})
+```
+
+### List jobs
+
+Use:
+```
+sas-score-list-jobs({
+  start: 1,
+  limit: 10
+})
+```
+
+### List jobdefs
+
+Use:
+```
+sas-score-list-jobdefs({
+  start: 1,
+  limit: 10
+})
+```
+
+## Clarifying prompts
+
+Ask one focused question if required context is missing:
+- Resource type unclear: "Do you want libraries, tables, models, jobs, or jobdefs?"
+- Listing tables without library: "Which library should I list tables from?"
+
+## Output and paging
+
+- Return the listed resources from the selected tool.
+- If result count equals `limit`, suggest next page with `start + limit`.
+- Keep using normalized pagination defaults unless user overrides.
+
+## Examples
+
+- "list jobs" -> `sas-score-list-jobs({ start: 1, limit: 10 })`
+- "list models" -> `sas-score-list-models({ start: 1, limit: 10 })`
+- "list jobdefs" -> `sas-score-list-jobdefs({ start: 1, limit: 10 })`
+- "list tables in Public" -> `sas-score-list-tables({ lib: "Public", start: 1, limit: 10 })`
+- "next jobs" after `{ start: 1, limit: 10 }` -> `sas-score-list-jobs({ start: 11, limit: 10 })`

package/.skills/{skills/sas-list-tables-smart → sas-list-tables-smart}/SKILL.md

@@ -13,7 +13,7 @@ description: >
 Intelligently enumerates tables in a SAS Viya library, automatically determining the correct server
 when not explicitly specified.
 
-> **Pre-flight check**: Before listing tables, verify the library exists using the `sas-find-library-smart` skill.
+> **Pre-flight check**: Before listing tables, verify the library and table context using the `sas-find-resource-strategy` skill.
 > This ensures consistent server detection across all data operations.
 
 **If the user specifies the server explicitly** (e.g., "list tables in Public in cas"):
@@ -25,7 +25,7 @@ when not explicitly specified.
 2. **If no tables found in CAS**: Check SAS (`server: "sas"`)
 3. **If no tables found in either**:
    - Inform user: *"The library '<lib>' was not found in CAS or SAS. Please verify the library name is correct."*
-   - Ask: *"Would you like to list available libraries?"* (suggest `sas-score-list-libraries`)
+  - Ask for corrected library name or explicit server context
 
 ---
 
@@ -54,6 +54,7 @@ sas-score-list-tables({
 - If returned table count equals the limit, suggest pagination: *"There may be more tables. Use `start: {next_offset}` to see more."*
 - If no tables are found despite library existing, report: *"No tables found in {lib} on {server} server."*
 - Return table names only; do not fetch table metadata unless explicitly requested
+- Do not use list tools to determine whether a specific resource exists
 
 ---
 
@@ -123,5 +124,5 @@ ELSE
 | Empty result on first server | Automatically check second server |
 | User specifies invalid server | Return error; ask user to clarify: `"cas"` or `"sas"` |
 | Missing library name | Ask: *"Which library should I list tables from?"* |
-| Library verification needed | Use `sas-find-library-smart` skill to verify library exists first |
+| Library verification needed | Use `sas-find-resource-strategy` to verify the library exists first |
 

package/.skills/{skills/sas-read-and-score → sas-read-and-score-strategy}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: sas-read-and-score
+name: sas-read-and-score-strategy
 description: >
   Guide the full read → score workflow in SAS Viya: reading records from a table and then scoring
   them with a MAS model (using sas-score-model-score). Use this skill whenever the user wants to score records
@@ -20,9 +20,10 @@ with a deployed MAS model.
 ## Pre-flight verification
 
 **Before attempting to read or score table data:**
-1. **Verify library exists**: Use `sas-find-library-smart` to check the library in CAS first, then SAS if needed
-2. **Verify table exists**: Use `sas-score-find-table` to confirm the table is in the library
-3. **Confirm server location**: Ensure you know which server (CAS or SAS) contains the data
+1. **Verify library exists**: Use `sas-find-resource-strategy` for library lookup (CAS first, then SAS if needed)
+2. **Verify table exists**: Use `sas-find-resource-strategy` for table lookup in the selected library/server
+3. **Verify model exists**: Use `sas-find-resource-strategy` for model lookup before scoring
+4. **Confirm server location**: Ensure you know which server (CAS or SAS) contains the data
 
 This ensures consistent behavior with other data access operations.
 
@@ -85,6 +86,7 @@ If the user specifies a model name that's new/unknown:
 - Always validate table/library existence before attempting to read
 - Always check model exists before invoking `sas-score-model-score`
 - Match table columns to model input variables; warn on mismatch
+- Use find tools only for resource existence checks; do not use list tools to find resources
 - If multiple records: score batch if possible; fall back to row-by-row
 - Merge predictions with original data using row index or key column
 - Present results as table with original columns + new prediction columns
@@ -106,6 +108,6 @@ If the user specifies a model name that's new/unknown:
 
 ## Integration with other skills
 
-- **Before this workflow**: Use `sas-find-library-smart` to verify the library exists
+- **Before this workflow**: Use `sas-find-resource-strategy` to verify library/table/model resources exist
 - **For data retrieval**: Use `sas-read-strategy` to choose the right read tool (read-table vs sas-query)
-- **For scoring**: Use `sas-score-workflow` for advanced scoring options beyond MAS models
+- **For scoring**: Use `sas-score-workflow-strategy` for advanced scoring options beyond MAS models

package/.skills/{skills/sas-read-strategy → sas-read-strategy}/SKILL.md

@@ -15,15 +15,11 @@ of the data operation. Determines which server contains the data and which retri
 
 ## Determine the server location
 
-Before retrieving data, verify the library and determine which server(s) contain the table:
+Before retrieving data, locate the specific table first and determine which server(s) contain it:
 
-**Step 1: Verify library existence**
-- Use `sas-find-library-smart` skill to check the library in CAS first, then SAS if needed
-- This establishes the correct server and uppercase convention for SAS libraries
-- Informs the user which server contains the library
-
-**Step 2: Locate the specific table**
-- Use `sas-score-find-table` to check if the table exists in the library
+**Step 1: Locate the specific table (table-first)**
+- Use `sas-find-resource-strategy` to check if the table exists in CAS first, then SAS if needed
+- Do not perform a separate library-first lookup; table lookup already handles server-aware discovery
 - Possible outcomes:
   - If table exists **only in CAS** → set `server: "cas"`
   - If table exists **only in SAS** → set `server: "sas"`
@@ -58,19 +54,21 @@ Ask yourself: does the user already have the data in hand?
 sas-score-read-table({
   table: "tablename",
   lib: "libraryname",
-  server: "cas" or "sas",  // determined from sas-score-find-table check
+  server: "cas" or "sas",  // determined from table-first lookup via sas-find-resource-strategy
   limit: N,        // default 10, adjust based on user request
   where: "..."     // optional SQL WHERE clause
 })
 ```
 
 **Rules:**
-- Always determine the server first using `sas-score-find-table`
+- Always determine the server first using `sas-find-resource-strategy`
 - Keep batch size ≤ 50 rows unless the user explicitly requests more
 - If table name is missing, ask: *"Which table should I read from? (format: lib.tablename)"*
 - If library is missing, ask: *"Which library contains the table?"*
+- Prefer table-first lookup (CAS first, then SAS) instead of a separate library lookup step
 - If table exists in both servers, ask user which to use
 - Return raw column values; do not transform or aggregate
+- Do not use list tools to determine whether a resource exists
 
 ---
 
@@ -91,7 +89,7 @@ sas-query({
 ```
 
 **Rules:**
-- Check which server(s) contain the table using `sas-score-find-table` first
+- Check which server(s) contain the table using `sas-find-resource-strategy` first
 - If table exists in both CAS and SAS, ask user which to query from
 - Parse the user's natural language question into a PROC SQL SELECT statement
 - Ensure SELECT statement is valid SQL syntax
@@ -129,7 +127,7 @@ sas-query({
 
 | Problem | Action |
 |---|---|
-| Library not found | Use `sas-find-library-smart` skill to verify the library exists |
+| Library missing or unclear | Ask the user which library contains the table |
 | Table not found in either server | Inform user and suggest checking the table name |
 | Table exists in both CAS and SAS | Ask: *"The table exists in both servers. Which would you prefer: CAS or SAS?"* |
 | Table exists only in one server | Use that server automatically in your request |
@@ -141,8 +139,8 @@ sas-query({
 
 ## Integration with other skills
 
-- **Before this skill**: Use `sas-find-library-smart` to verify and locate the library
-- **After this skill**: Use `sas-read-and-score` to score the retrieved data
+- **Before this skill**: Use `sas-find-resource-strategy` for table-first resource lookup
+- **After this skill**: Use `sas-read-and-score-strategy` to score the retrieved data
 
 ---
 

package/.skills/{skills/sas-request-classifier → sas-request-classifier}/SKILL.md

@@ -29,11 +29,13 @@ Map the user request to the most likely SAS domain and hand off to the correct d
 
 ## Classification targets
 Classify the request into one or more of these categories:
+- Resource existence lookup (library/table/model/job/jobdef) -> Route to **sas-find-resource-strategy**
+- Resource listing (library/table/model/job/jobdef) -> Route to **sas-list-resource-strategy**
 - Reading or querying tables → Route to **sas-read-strategy**
-- CAS resource, caslib, or table discovery → Route to **sas-find-library-smart** or **sas-list-tables-smart**
-- SAS data, libref, or table discovery → Route to **sas-find-library-smart** or **sas-list-tables-smart**
-- Score model or scoring artifact → Route to **sas-score-workflow**
-- Read data and score together → Route to **sas-read-and-score**
+- CAS resource, SAS resource, caslib, or table discovery → Route to **sas-find-library-smart** 
+- SAS data, libref, or table discovery → Route to **sas-find-library-smart** 
+- Score model or scoring artifact → Route to **sas-score-workflow-strategy**
+- Read data and score together → Route to **sas-read-and-score-strategy**
 - SAS job or flow execution
 - SAS code or program analysis
 - General content or metadata lookup
@@ -45,21 +47,24 @@ Classify the request into one or more of these categories:
 3. Decide the most likely SAS domain and matching skill.
 4. If confidence is low, ask one focused clarifying question.
 5. If confidence is high, load and use the relevant skill:
+   - **sas-find-resource-strategy** — Unified find-only strategy for library/table/model/job/jobdef
+   - **sas-list-resource-strategy** — Unified list strategy for library/table/model/job/jobdef with non-null pagination defaults
    - **sas-find-library-smart** — Find CAS or SAS libraries
    - **sas-list-tables-smart** — Browse tables in a library
    - **sas-read-strategy** — Choose read-table vs. sas-query for data retrieval
-   - **sas-read-and-score** — Combine data reading with model scoring
-   - **sas-score-workflow** — Route scoring requests to correct execution engine
+   - **sas-read-and-score-strategy** — Combine data reading with model scoring
+   - **sas-score-workflow-strategy** — Route scoring requests to correct execution engine
 6. Only after classification and skill guidance, use MCP tools.
 
 ## Disambiguation hints
 - "Run" often implies job execution, but may also mean scoring or model invocation. Check for "score" or "model" context.
 - "Model" may refer to MAS models, SAS jobs, jobdefs, or SCR models. Look for context or type suffix (e.g., `.job`, `.mas`, `.scr`).
 - "Score" may refer to model scoring or job execution. Look for model name or context.
-- "Table" usually suggests CAS, but confirm library name and server context.
-- "Find", "list", "browse" — starts as discovery. Route to sas-find-library-smart or sas-list-tables-smart.
+- "Table" usually suggests CAS or SAS but confirm library name and server context.
+- "Find" — resource lookup. Route to sas-find-resource-strategy.
+- "List" or "browse" — resource exploration. Route to sas-list-resource-strategy.
 - "Read", "query", "fetch" — data retrieval. Route to sas-read-strategy.
-- "Predict", "score records", "run model on data" — combined workflow. Route to sas-read-and-score or sas-score-workflow.
+- "Predict", "score records", "run model on data" — combined workflow. Route to sas-read-and-score-strategy  or sas-score-workflow-strategy.
 
 ## Output
 When you finish classification, state: