@sassoftware/sas-score-mcp-serverjs 1.0.1-9 → 1.1.1

package/.skills/skills/find-library-server/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: find-library-server
+description: >
+  Verify that a SAS Viya library exists and determine which server (CAS or SAS) hosts it.
+  Always checks CAS first, then SAS. Returns the confirmed library name and server.
+  Use whenever you need to confirm a library exists before listing tables or performing any library-scoped operation.
+---
+
+# Find Library Server
+
+**Purpose**: Verify a library exists and determine whether it lives in CAS or SAS.
+
+**Tool**: `sas-score-find-library({ name, server })`
+
+---
+
+## Workflow
+
+1. Call `sas-score-find-library({ name: "<lib>", server: "cas" })`
+   - ✅ Found → return `{ lib: "<lib>", server: "cas" }`
+   - ❌ Not found → go to step 2
+
+2. Call `sas-score-find-library({ name: "<LIB_UPPERCASED>", server: "sas" })`
+   - ✅ Found → return `{ lib: "<LIB_UPPERCASED>", server: "sas" }`
+   - ❌ Not found → library does not exist; **stop** and report not found to the user
+
+---
+
+## Known Library Hints (skip searching if known)
+
+Use these to skip the two-step search when the server is already deterministic:
+
+| Library (case-insensitive) | Server |
+|---|---|
+| Casuser, Formats, ModelPerformanceData, Models, Public, Samples, SystemData | `"cas"` (check CAS only) |
+| MAPS, MAPSGFK, MAPSSAS, SASDQREF, SASHELP, SASUSER, WORK | `"sas"` (check SAS only, uppercase lib) |
+| Unknown | Try CAS first; if not found, try SAS with uppercased lib |
+
+---
+
+## Output
+
+Always return the confirmed resolved values to the caller:
+
+| Field | Value |
+|---|---|
+| `lib` | Confirmed library name (may be uppercased for SAS) |
+| `server` | `"cas"` or `"sas"` |
+
+---
+
+## Error Handling
+
+- Not found in either server → confirm spelling with the user and offer to list available libraries.
+- Do **not** fall back to listing libraries as a substitute for verification — they serve different purposes.
+
+---
+
+## Important Constraints
+
+- **Never use `list-*` tools for library verification** — use only `sas-score-find-library`.
+- This skill verifies libraries only. To verify a table, use `sas-score-find-table` directly (it validates the library implicitly).

package/.skills/skills/find-resources/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: find-resources
+description: >
+  Unified resource verification skill. Use the appropriate find tool before any execution.
+  Determines server for tables (CAS vs SAS). Never use list tools for verifying or finding specific resources; list tools are for discovery and exploration only.
+---
+
+**GATE** Do not use list-* tools for verification — those are for explicit user list requests only. Always use the specific find-* tool to verify existence of a resource before attempting to use it.
+
+# Unified Resource Finding Strategy
+
+Use this strategy to verify that a resource exists before executing any action.
+Never use `list-*` tools for verification — those are for explicit user browse requests only.
+
+## Dotted `a.b` Resource Reference Parsing
+
+Parse any `a.b` notation before choosing a find tool:
+
+| `b` value | Resource type | Find tool |
+|---|---|---|
+| `mas` | MAS model | `sas-score-find-mas`, name=`a` |
+| `job` | Job model | `sas-score-find-job`, name=`a` |
+| `jobdef` | JobDef model | `sas-score-find-jobdef`, name=`a` |
+| `scr` | SCR model | no find tool — ask user for URL |
+| `cas` | CAS model | `sas-score-find-table({ name: name, server: 'cas' })` |
+| **anything else** | **Table** | `sas-score-find-table`, lib=`a`, table=`b` |
+
+## Find Library
+
+**Workflow**
+
+Use skill `find-library-server` to verify library existence and determine server. 
+
+## Find Table
+
+**workflow** 
+
+Step 1. Use find-library-server skill to verify the library exists and in which server:
+   - ✅ Found → return go to Step 2 
+   - ❌ Not found → library does not exist; **stop** and report not found to the user
+
+Step 2. Use sas-score-find-table tool with the library and server from step 1: `sas-score-find-table({ lib: "<lib>", name: "<TABLE_NAME>", server: <server })`
+   - ✅ Found → return success with confirmed lib, table, and server
+   - ❌ Not found → table does not exist; **stop** and report not found to the user
+
+---
+ 
+
+## Find Model of type MAS, Job, Jobdef, SCR, cas
+
+**Workflow** 
+
+Step 1. Strip any suffix (`.mas`, `.job`, `.jobdef`, `.scr`) before lookup — use the base name only.
+
+| Type | Tool |
+|---|---|
+| MAS (default when type unspecified) | `sas-score-find-mas({ name })` |
+| Job | `sas-score-find-job({ name })` |
+| JobDef | `sas-score-find-jobdef({ name })` |
+| SCR | `sas-score-find-scr({ name })` |
+| cas | `sas-score-find-table({ name: name, server: 'cas' })` |
+
+## Error Handling
+
+- Not found → confirm spelling, library name, and server with user.
+- Resource type unclear → ask: MAS, Job, JobDef, or SCR?

package/.skills/skills/list-library/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: list-library
+description: >
+  List SAS Viya libraries. Calls sas-score-list-libraries with the appropriate server parameter.
+  Use only when the user explicitly wants to browse or enumerate libraries, not to verify a specific library exists.
+  User must specify server (CAS or SAS) in their request to trigger this skill; 
+---
+
+# List Libraries
+
+**Trigger**: 
+- "list libraries in cas",
+-  "show all libraries in cas", 
+- "list libraries in sas",
+-  "enumerate libraries in sas",
+-  "what libraries are available in cas", 
+- "what libraries are available in sas".
+
+**GATE**
+
+Do not use this skill when the request is to verify whether a specific resource exists — use find-resources skill for that.
+
+**Tool**
+Use `sas-score-list-libraries` tool with the appropriate server parameter based on user input. -> sas-score-list-libraries({ server: "cas" }) or sas-score-list-libraries({ server: "sas" })  
+
+## Pagination
+
+For the first page pass `start=1` and `limit=10`. For subsequent pages compute `start = previous_start + limit`.
+- If returned count equals `limit`: hint that more items are available and offer a next page.
+- If returned count is less than `limit`: inform the user that all results have been returned.

package/.skills/skills/list-mas-job-jobdef/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: list-mas-job-jobdef
+description: >
+  List MAS models, Jobs, or JobDefs in SAS Viya. Routes to the correct list tool based on resource type.
+  Use only when the user explicitly wants to browse or enumerate models, jobs, or jobdefs.
+---
+
+# List MAS Models, Jobs, and JobDefs
+
+**Trigger**: user says "list models", "show all jobs", "browse jobdefs", "enumerate MAS models", etc.
+
+**Do not use this skill for libraries or tables** — use the `list-library` or `list-tables` skills for those.
+
+## Workflow
+
+| Resource | List Tool | Notes |
+|---|---|---|
+| MAS Models | `sas-score-list-mas` | Default when model type is unspecified |
+| Jobs | `sas-score-list-jobs` | |
+| JobDefs | `sas-score-list-jobdefs` | |
+| SCR Models | *(no list tool)* | Explain no list tool exists; ask user for a specific SCR URL |
+
+Call the appropriate tool directly with pagination parameters and return results.
+
+If the user asks to list SCR Models, explain that no list tool is available for SCR Models and ask the user to provide a specific SCR URL instead.
+
+## Pagination
+
+For the first page pass `start=1` and `limit=10`. For subsequent pages compute `start = previous_start + limit`.
+- If returned count equals `limit`: hint that more items are available and offer a next page.
+- If returned count is less than `limit`: inform the user that all results have been returned.

package/.skills/skills/list-tables/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: list-tables
+description: >
+  List tables in a SAS Viya library. Always verifies the library exists and determines its server
+  (CAS or SAS) before listing. Never calls sas-score-list-tables without first completing library verification.
+---
+
+# List Tables in a Library
+
+**Trigger**: user says "list tables in \<lib\>", "show tables in \<lib\>", "what tables are in \<lib\>", etc.
+
+> **Example prompt**: "list tables in Public"
+
+**GATE**
+Always follow the workflow steps in order. Do not skip the library and server verification step.
+
+---
+
+## Workflow
+1. Use find-library-server skill to determine if library exists and which server it is on.
+   - ✅ Found → call `sas-score-list-tables({ lib: <confirmed_lib>, server: <confirmed_server> })` with the confirmed values
+    - ❌ Not found → **stop** and report not found to the user, offering to list available libraries if appropriate
+
+---
+
+## Pagination
+
+For the first page pass `start=1` and `limit=10`. For subsequent pages compute `start = previous_start + limit`.
+- If returned count equals `limit`: hint that more items are available and offer a next page.
+- If returned count is less than `limit`: inform the user that all results have been returned.

package/.skills/skills/read-strategy/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: read-strategy
+description: >
+  Strategy for reading data from CAS or SAS tables. Determines which read tool to use (raw reads vs analytical queries).
+---
+
+# Read Table Strategy
+
+## Mandatory two-step sequence — never skip or reorder
+
+**Step 1 and Step 2 are required for every read request. Step 2 must never run before Step 1 succeeds.**
+
+---
+
+### Step 1 — Verify the table exists and resolve its server (REQUIRED)
+
+**GATE**: 
+
+Do not check for the existence of the library separately. Follow the workflow below. The sas-score-find-table tool will check for the existence of the table in the specified library and server, which implicitly verifies the library as well.
+  
+## Workflow to read a table
+
+### Step 1 — Verify the table exists and resolve its server (REQUIRED)
+1. Call `sas-score-find-table({ lib, name: table, server: "cas" })`
+   - ✅ Found → confirmed `lib` = lib as given, confirmed `server` = `"cas"` → go to Step 2
+   - ❌ Not found → call `sas-score-find-table({ lib: lib.toUpperCase(), name: table, server: "sas" })`
+     - ✅ Found → confirmed `lib` = uppercased lib, confirmed `server` = `"sas"` → go to Step 2
+     - ❌ Not found in either → **stop**. Tell the user the table was not found.
+
+
+### Step 2 — Read the table
+
+Use the confirmed `lib` and `server` from Step 1. Never guess or default the server.
+
+**Use `sas-score-read-table`** for all row reads, including filtered reads with a WHERE clause.
+**Use `sas-score-sas-query`** only when the request requires SQL aggregation (COUNT, SUM, AVG, MIN, MAX), GROUP BY, JOIN, or computed columns. A WHERE clause alone is not a reason to use sas-query.
+
+## Read Table (`sas-score-read-table`)
+
+**When**: raw rows, filtered rows, browsing — anything that is not an aggregation or join.
+
+**Parsing row count from user input**:
+
+| User says | start | limit |
+|---|---|---|
+| "first N rows/records" | 1 | N |
+| "top N rows" | 1 | N |
+| "N rows" / "N records" | 1 | N |
+| "rows N to M" | N | M−N+1 |
+| "starting from row N" | N | 10 |
+| (not specified) | 1 | 10 |
+
+> "first" always means start at row 1 and return N rows. It is never a row offset.
+
+**Dotted format**: `"lib.table"` → `lib: "lib"`, `table: "table"` (split on first dot).
+
+**Parameters**: `lib`, `table`, `server` (confirmed from Step 1 — required), `start`, `limit`, `where`
+
+## SQL Query (`sas-score-sas-query`)
+
+**When**: COUNT/SUM/AVG/MIN/MAX, GROUP BY, JOIN across tables, or computed columns.
+
+**NOT for**: simple filtered reads — use read-table with `where` instead.
+
+**Parameters**: `table` (as `"lib.table"`), `query`, `sql`
+
+## Decision
+
+```
+Does the request need aggregation (COUNT/SUM/AVG/GROUP BY) or a JOIN?
+  YES → sas-score-sas-query
+  NO  → sas-score-read-table  (pass filter in `where` parameter if needed)
+```
+
+## Table Name Format
+
+- CAS: `Public.customers`, `Caslib.table`
+- SAS: `SASHELP.cars`, `LIBREF.table` (uppercase libref)
+- Dotted input `"x.y"` → lib=`x`, table=`y`
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Table not found | Verify with find-resources first |
+| Empty result | Ask user to adjust WHERE clause |
+| Column not found | Ask user to verify column name (case-sensitive) |

package/.skills/skills/request-routing/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: request-routing
+description: >
+  Route SAS Viya requests for finding resources,reading tables, running queries,
+  scoring MAS/job/jobdef/SCR/cas models, listing resources, and describing metadata.
+  Use when the task involves choosing the correct SAS Viya tool or deciding whether
+  to verify, read, query, score, list, or describe a resource.
+---
+
+# Request Routing — Canonical SKILL
+
+Purpose: single source-of-truth for routing SAS Viya actions (read, query, score, describe, list).
+
+## Dotted Resource Reference Parsing — `a.b` Notation
+
+When any resource reference appears in the form `a.b`, parse `b` to determine the resource type:
+
+| `b` value | Resource type | Parsed as |
+|---|---|---|
+| `mas` | MAS model | name = `a` |
+| `job` | Job model | name = `a` |
+| `jobdef` | JobDef model | name = `a` |
+| `scr` | SCR model | name = `a` |
+| `cas` | CAS model in a cas table| name = `a` |
+| **anything else** | **Table** | lib = `a`, table = `b` |
+
+**Rule**: if `b` is not one of `{mas, job, jobdef, scr, sas, casl}`, treat `a.b` as a table reference where `a` is the library name and `b` is the table name.
+
+**Examples**:
+- `Public.customers` → table, lib=`Public`, table=`customers`
+- `SASHELP.cars` → table, lib=`SASHELP`, table=`cars`
+- `churnRisk.mas` → MAS model, name=`churnRisk`
+- `simplejob.job` → Job model, name=`simplejob`
+- `myScorer.jobdef` → JobDef model, name=`myScorer`
+- `loanModel.scr` → SCR model, name=`loanModel`
+
+Quick workflow
+- Verify — confirm resources exist (use find-*).
+- Execute — run the mapped execution tool (read, query, score, describe, list).
+- Format — return results and append a short Strategy Summary.
+
+**Important Reminder**: If the category is "Find resource" do not use the list-* rules below, use the specific find-* tool for that resource type. The list-* tools are for discovery when the user does not have a specific resource in mind.
+
+Classification
+| Category | Triggers | Primary Action | Primary Tool(s) |
+|---|---|---|---|
+| Find resource | "find", "does X exist", "locate", "verify" | Verify resource | `sas-score-find-library`, `sas-score-find-table`, `sas-score-find-mas`, `sas-score-find-job`, `sas-score-find-jobdef` |
+| Read / Query | "read", "show rows", "how many", "count", "average", "query" | Read / aggregate | `sas-score-read-table`, `sas-score-sas-query` |
+| Score | "score", "predict", "run model" | Score inputs | `sas-score-mas-score`, `sas-score-scr-score`, `sas-score-job-score`, `sas-score-jobdef-score`, `sas-score-program-score`, `sas-score-cas-program-score` |
+| List / Discover | "list", "show all", "browse" | List resources | Use **list-library** skill for libraries, **list-tables** skill for tables in a library, **list-mas-job-jobdef** skill for models/jobs/jobdefs |
+| Describe | "describe", "what inputs", "metadata" | Return metadata | `sas-score-*-describe` (mas/job/jobdef/scr/table) |
+
+Verification rules
+- Always verify resources using the appropriate `find-*` tool before executing actions
+
+Execution rules
+- Execute only after verification; choose the execution tool per the Execute mapping section.
+- Scoring flows:
+  - Inline scenario: verify model → call scoring tool.
+  - Table rows: verify model + table → read rows → map columns to model inputs → score → merge predictions with rows.
+- Read/query flows:
+  - Use `sas-score-read-table` for **all** row reads, including those with a WHERE filter. A filter condition is not a reason to use sas-query.
+  - Use `sas-score-sas-query` **only** when the request requires SQL aggregation (COUNT, SUM, AVG, MIN, MAX), GROUP BY, JOIN across tables, or computed columns.
+  - When mapping between table columns and model inputs is ambiguous, ask the user for explicit mapping.
+
+Defaults & exceptions
+- Default model type: MAS unless the user specifies otherwise.
+- Skip `find-*` verification for SCR models; SCR endpoints may be scored directly.
+- If server determination is ambiguous, prompt the user for clarification.
+- Pagination: always pass `start=1` and `limit=10` when calling any tool that accepts these parameters, unless the user specifies different values. Never omit them and rely on tool-level defaults.
+
+Execute mapping (concise)
+- Read rows (including WHERE filter): `sas-score-read-table` (lib, table, server, where)
+- SQL aggregation/join only: `sas-score-sas-query` (lib.table, query, sql)
+- MAS scoring: `sas-score-mas-score` (mas, scenario)
+- Job scoring: `sas-score-job-score` (name, scenario)
+- JobDef scoring: `sas-score-jobdef-score` (name, scenario)
+- SCR scoring: `sas-score-scr-score` (name, scenario)
+- Program scoring: `sas-score-program-score` (src, scenario, folder, output, limit)
+- CAS Program scoring: `sas-score-cas-program-score` (src, scenario, folder, output, limit)
+- Describe: `sas-score-*-describe` (mas/job/jobdef/scr/table)
+
+Combined Read + Score (short)
+1. Verify: find table (server) and find the model (mas,job,jobdef,scr). If table/model not found, ask user to clarify resource and server.  
+2. Read: fetch rows (read-table or sas-query).
+3. Map: ensure table columns match model inputs; ask for mapping if needed.
+4. Score: call the appropriate scoring tool.
+5. Merge: attach predictions to rows and return.
+
+Strategy Summary (append to responses)
+---
+**Strategy Summary:**
+- **Classification**: [Find / Read / Score / List / Describe]
+- **Verification**: [Resources verified / skipped]
+- **Tool(s)**: [Primary tool(s) invoked]
+- **Decision**: [Server chosen, model type, mapping]
+- **Next steps**: [Follow-ups or clarifications]
+---
+
+Error handling (short)
+- Resource not found → ask for exact resource name and server (for tables).
+- Column/input mismatch → request mapping from user.
+- Empty result → ask to relax filters or confirm criteria.
+- Execution error → return tool error verbatim.
+
+Examples (minimal)
+- Read: "read customers in Public" → find Public (CAS) → read-table → return rows.
+- Score inline: "score a=1,b=2 with job simplejob" → find job → job-score → return merged result.
+- Score table: "score Public.customers with model risk" → find table (CAS) & model (MAS) → read rows → score → return merged.
+
+Notes: Keep this SKILL as the canonical, compact router; agent wrappers should be short and reference this document for details and examples.
+

package/.skills/skills/score-cas/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: score-cas
+description: >
+  Scoring workflow for CAS (Cloud Analytic Services) programs and CAS model tables.
+  Use when the model suffix is .casl, or when the user references a CAS model table
+  (casmodel), or when running inline CASL/CAS program src code.
+  Handles both inline scenario scoring and table row scoring.
+---
+
+# Score CAS Program / CAS Model
+
+## When to use this skill
+- Model type is `.casl` (CAS Program — inline src code)
+- User references a CAS model table (`casmodel` in `lib.table` form, with optional `name`)
+- User says "run cas program", "execute casl", "score cas model"
+
+## Model Forms
+
+The tool `sas-score-cas-program-score` accepts two mutually exclusive model forms:
+
+| Form | Params | When to use |
+|---|---|---|
+| Inline src code | `src` (required), no `casmodel` | User provides CASL code directly |
+| CAS model table | `casmodel` (required), `name` (optional) | User references a persisted CAS model table |
+
+> If both `src` and `casmodel` are provided, `casmodel` takes precedence.
+
+## Tool
+
+| Type | Verify | Score |
+|---|---|---|
+| CAS Program (inline) | *(no pre-check)* | `sas-score-cas-program-score` |
+| CAS Model (table) | *(no pre-check)* | `sas-score-cas-program-score` |
+
+## Inline Src Code Scoring
+
+Score CASL source code directly (no casmodel):
+
+```
+sas-score-cas-program-score({ src, scenario, output, limit })
+```
+
+- `src` — CASL/CAS program code to execute verbatim
+- `scenario` — input parameters as string (`"x=1, y=2"`) or object (`{ x: 1, y: 2 }`)
+- `output` — optional CAS table name to return in response
+- `limit` — max rows to return (default 100)
+
+## CAS Model Table Scoring
+
+Score using a persisted CAS model table:
+
+```
+sas-score-cas-program-score({ casmodel, name, scenario, output, limit })
+```
+
+- `casmodel` — CAS model table in `lib.table` form (e.g., `mylib.mymodel`)
+- `name` — optional model name if different from the table name
+- `scenario` — input parameters
+- `output` / `limit` — same as above
+
+## Routing Examples
+
+| User says | Params |
+|---|---|
+| "run cas program `action echo`" | `{ src: "action echo" }` |
+| "execute casl `action simple.summary` with table=a.b" | `{ src: "action simple.summary", scenario: { table: "a.b" } }` |
+| "score cas model `mylib.abc` with x=1, y=2" | `{ casmodel: "mylib.abc", scenario: "x=1, y=2" }` |
+| "score cas model `mylib.abc` using model name `mymodel`" | `{ casmodel: "mylib.abc", name: "mymodel", scenario: ... }` |
+
+## Table Row Scoring
+
+**Parsing row count:**
+
+| User says | start | limit |
+|---|---|---|
+| "score the first N rows from lib.table" | 1 | N |
+| "score N rows from lib.table" | 1 | N |
+| (count not specified) | 1 | 10 |
+
+**Flow:**
+1. Read table → use read-strategy skill
+2. Score each row — tool accepts a single row; loop over rows calling the tool for each
+3. Return rows with predictions appended
+4. Cap batch at 10 rows by default; ask user before proceeding with larger batches
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| CAS session cannot be created | Report CAS connectivity issue to user |
+| `src` not provided and `casmodel` not provided | Ask user for src code or casmodel table |
+| CAS model table not found | Confirm `casmodel` value with user |
+| Table not found (row scoring) | Confirm table name and library |
+| Empty table | Ask user to adjust filter or confirm criteria |
+| Scoring failure | Return tool error verbatim |

package/.skills/skills/score-job-jobdef/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: score-job-jobdef
+description: >
+  Scoring workflow for Job (.job) and JobDef (.jobdef) model types.
+  Use when the model suffix is .job or .jobdef.
+  Handles both inline scenario scoring and table row scoring.
+---
+
+# Score Job / JobDef
+
+## When to use this skill
+- Model type is `.job`
+- Model type is `.jobdef`
+
+## Tools
+
+| Type | Verify | Score |
+|---|---|---|
+| Job | `sas-score-find-job` | `sas-score-job-score` |
+| JobDef | `sas-score-find-jobdef` | `sas-score-jobdef-score` |
+
+## Inline Scenario Scoring
+
+**Job:**
+1. Verify: `sas-score-find-job({ name })`
+2. Score: `sas-score-job-score({ name, scenario })`
+
+**JobDef:**
+1. Verify: `sas-score-find-jobdef({ name })`
+2. Score: `sas-score-jobdef-score({ name, scenario })`
+
+## Table Row Scoring
+
+**Parsing row count:**
+
+| User says | start | limit |
+|---|---|---|
+| "score the first N rows from lib.table" | 1 | N |
+| "score N rows from lib.table" | 1 | N |
+| (count not specified) | 1 | 10 |
+
+**Flow:**
+1. Find model →
+   - if job use `sas-score-find-job` to find the Job model
+   - if jobdef use `sas-score-find-jobdef` to find the JobDef model
+2. Read table → use read-strategy skill
+3. Score each row — tools accept a single row; loop over rows calling the tool for each
+4. Return rows with predictions appended
+5. Cap batch at 10 rows by default; ask user before proceeding with larger batches
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Job / JobDef not found | Confirm name with user |
+| Table not found | Confirm table name and library |
+| Empty table | Ask user to adjust filter or confirm criteria |
+| Scoring failure | Return tool error verbatim |

package/.skills/skills/score-mas-scr/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: score-mas-scr
+description: >
+  Scoring workflow for MAS (Micro Analytic Score) and SCR (Score Code Runtime) models.
+  Use when the model type is .mas or .scr, or when no suffix is given (default is MAS).
+  Handles both inline scenario scoring and table row scoring.
+---
+
+# Score MAS / SCR
+
+## When to use this skill
+- Model type is `.mas` (default when no suffix given)
+- Model type is `.scr`
+
+## Tools
+
+| Type | Verify | Score |
+|---|---|---|
+| MAS | `sas-score-find-mas` | `sas-score-mas-score` |
+| SCR | `sas-score-find-scr` | `sas-score-scr-score` |
+
+## Inline Scenario Scoring
+
+**MAS:**
+1. Verify: `sas-score-find-mas({ model })`
+2. Score: `sas-score-mas-score({ model, scenario })`
+
+**SCR:**
+1. Verify: `sas-score-find-scr({ model })`
+2. Score: `sas-score-scr-score({ model, scenario })`
+
+## Table Row Scoring
+
+**Parsing row count:**
+
+| User says | start | limit |
+|---|---|---|
+| "score the first N rows from lib.table" | 1 | N |
+| "score N rows from lib.table" | 1 | N |
+| (count not specified) | 1 | 10 |
+
+**Flow:**
+1. Find model → 
+   - if mas use `sas-score-find-mas` to find the MAS model
+   - if scr use `sas-score-find-scr` to find the SCR model
+2. Read table → use read-strategy skill
+3. Score each row — tools accept a single row; loop over rows calling the tool for each
+4. Return rows with predictions appended
+5. Cap batch at 10 rows by default; ask user before proceeding with larger batches
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| MAS model not found | Confirm model name with user |
+| Table not found | Confirm table name and library |
+| Empty table | Ask user to adjust filter or confirm criteria |
+| Scoring failure | Return tool error verbatim |