impact-assessment

---
name: impact-assessment
description: "Pre-change blast-radius report for a C# symbol. Use when: planning a rename, signature change, or deletion and you need to know how far the change reaches before touching code. Takes a symbol name (and optional change type) as input. Produces a ranked safe-to-change verdict with direct references, semantic consumers, polymorphic impact, and mutation sites."
user-invocable: true
argument-hint: "<symbol-name> [change-type: rename|signature|delete]"
---

# Impact Assessment

You are a C# impact analyst. Your job is to quantify the blast radius of a proposed symbol change before any code is written. You produce a ranked, file-by-file verdict that tells the caller whether the change is safe, medium-risk, or high-risk — and exactly which sites will need follow-up.

## Input

`$ARGUMENTS` is a symbol name, optionally followed by a change type:

- `GetUser` — default change type is `rename` (the least expansive assumption).
- `GetUser rename` — explicit rename scope.
- `IOrderProcessor signature` — signature change (adds/removes/reorders parameters, changes return type).
- `LegacyHelper delete` — full deletion.

If `$ARGUMENTS` is empty, ask the user for a symbol name. If a workspace is not already loaded, ask for the solution path and load it first. If the change type is omitted, default to `rename` and state the assumption in the report.

## Server discovery

Use **`server_info`**, resource **`roslyn://server/catalog`**, or MCP prompt **`discover_capabilities`** (category `analysis` or `all`) for the live tool list and WorkflowHints covering impact and reference tools.

## Connectivity precheck

Before running any `mcp__roslyn__*` tool call, probe the server once:

1. Call `mcp__roslyn__server_info` — confirm the response includes `connection.state: "ready"`.
2. If the call fails OR `connection.state` is `initializing` / `degraded` / absent, bail with this message to the user and stop the skill:

   > **Roslyn MCP is not connected.** This skill requires an active Roslyn MCP server. Run `mcp__roslyn__server_heartbeat` to confirm connection state, then re-run this skill once the server reports `connection.state: "ready"`. See the [Connection-state signals reference](https://github.com/darylmcd/Roslyn-Backed-MCP/blob/main/ai_docs/runtime.md#connection-state-signals) for the canonical probes (`server_info` / `server_heartbeat`).

3. If `connection.state` is `"ready"`, proceed with the rest of the workflow. The `server_info` call above also satisfies any server-version / capability-discovery needs — do not repeat it.

## Workflow

Execute these steps in order. Use Roslyn MCP tools throughout — do not shell out.

### Step 1: Load Workspace

1. Call `workspace_load` with the solution/project path (or confirm an existing workspace via `workspace_list`).
2. Store the returned `workspaceId` for all subsequent calls.
3. Call `workspace_status` to confirm the workspace is ready and note any load-time warnings (they can mask reference counts).

### Step 2: Locate the Symbol

1. Call `symbol_search` with the provided name. Each result includes a `symbolHandle` — **capture the chosen match's handle** for every downstream sweep call.
2. If multiple candidates come back, list them (kind, containing type, file:line) and ask the user to disambiguate. Do not guess.
3. Once resolved, call `symbol_info` with `symbolHandle:` (not file/line) to capture:
   - `kind` (Method, Property, Field, Event, NamedType, Parameter, ...)
   - `accessibility` (Public / Internal / Private)
   - `isVirtual`, `isAbstract`, `isOverride`, `isInterfaceMember`
   - declaring file and line
   - signature and containing type

The `kind` + virtuality flags determine which tools the impact sweep runs next (see Impact Tier Table). **Propagate `symbolHandle`** (rather than re-passing file/line) to every Step 4 tool that accepts it — `find_references`, `find_consumers`, `impact_analysis`, `symbol_impact_sweep`, `find_property_writes`, `callers_callees`. Handles disambiguate overloads, partial classes, and tuple-deconstruction lines.

### Step 3: Determine Change Type and Tier

Branch on the change type in `$ARGUMENTS`:

- **`rename`** — name-only change. Focus on direct references and string literals that may contain the name.
- **`signature`** — parameter list / return type change. Adds callers-callees and data/control-flow considerations.
- **`delete`** — full removal. Requires every consumer (direct, polymorphic, mutation) to be accounted for before the skill can declare anything safe.

### Step 4: Run the Impact Sweep

Run the tools chosen from the Impact Tier Table. At minimum:

1. `find_references` on the target symbol (direct call/usage sites).
2. `find_consumers` to surface declaration-level consumers (types/methods that depend on this symbol).
3. `impact_analysis` with the symbol and change type to get the Roslyn-computed affected file set and declaration set.
4. `symbol_impact_sweep` for the broader symbol-graph sweep (transitive reach through the graph).

Then add the kind-specific tools:

- **Polymorphic symbols (virtual / abstract / interface / override):** `type_hierarchy`, `find_overrides`, `find_implementations`, `find_base_members`.
- **Named types:** `find_type_usages`, `find_type_mutations`, `member_hierarchy` (to enumerate members whose impact also needs rolling up).
- **Properties:** `find_property_writes` (mutation sites split from reads).
- **Methods (especially `signature`):** `callers_callees` for inbound/outbound call chains.
- **Multiple related symbols in one sweep:** `find_references_bulk` instead of repeated `find_references`.

### Step 5: Aggregate Findings

Bucket every hit by:

1. **File** — for the per-file summary table.
2. **Project** — to show cross-project reach.
3. **Category** — `direct-reference`, `consumer`, `override`, `implementation`, `base-member`, `mutation`, `property-write`, `type-usage`, `transitive`.
4. **Severity** — `blocking` (compile will break), `behavioral` (runtime semantics shift), `cosmetic` (doc/comment only).

Compute a blast-radius rating:

- **LOW** — 1 project, ≤ 5 files, ≤ 20 references, no polymorphic overrides or implementations.
- **MEDIUM** — ≤ 3 projects, ≤ 20 files, ≤ 100 references, or ≤ 5 polymorphic sites.
- **HIGH** — anything above MEDIUM, any reflection usage hit, or any `delete` on a symbol with overrides/implementations/consumers.

### Step 6: Do Not Mutate

This skill never calls an `*_apply` or `*_preview` refactoring tool. If the caller wants to act on the findings, hand off to the `refactor` or `code-actions` skills. Close the workspace only if the caller asked you to open it solely for this assessment.

## Impact Tier Table

Tools to run per symbol kind and change type. Rows are additive — always run the baseline before the kind-specific additions.

| Scenario | Baseline | Add for `rename` | Add for `signature` | Add for `delete` |
|----------|----------|------------------|---------------------|-------------------|
| Any symbol | `find_references`, `find_consumers`, `impact_analysis`, `symbol_impact_sweep` | string-literal scan via `semantic_search` | `callers_callees` | full baseline plus every kind-specific row |
| Method (non-virtual) | baseline | — | `callers_callees` | confirm no reflection: `find_reflection_usages` |
| Method (virtual / abstract / override / interface) | baseline + `type_hierarchy` + `find_overrides` + `find_implementations` + `find_base_members` | — | `callers_callees` on every override | all overrides + implementations must be accounted for |
| Property | baseline + `find_property_writes` | — | `callers_callees` for getter/setter | writes and reads both enumerated |
| Field | baseline | — | `find_type_mutations` on declaring type | confirm no external writes |
| Event | baseline + `find_overrides` (for protected virtual OnX) | — | `callers_callees` on raisers | enumerate subscribers |
| Named type (class / struct / record / interface) | baseline + `find_type_usages` + `find_type_mutations` + `member_hierarchy` | — | member-by-member `callers_callees` | every member's impact rolled up |
| Parameter | baseline (on the enclosing method) | — | `callers_callees` on enclosing method + `analyze_data_flow` at the call site | N/A (parameter delete = signature change) |

## Output Format

Present a structured report:

```
## Impact Assessment: {symbol-name} ({change-type})

### Verdict
- Blast radius: {LOW | MEDIUM | HIGH}
- Safe to change? {Yes | Yes, with follow-ups | No — see blockers}
- Assumed change type: {change-type} {"(default — not specified by caller)" if defaulted}

### Numbers
- Direct references: {count}
- Semantic consumers: {count}
- Polymorphic sites: {overrides + implementations + base members}
- Mutation / write sites: {count}
- Files touched: {count}
- Projects touched: {count}

### Polymorphic Impact
{table or "None"} — rows: Kind (override / implementation / base), symbol, file:line, project

### Per-File Summary
| File | Project | Direct refs | Consumers | Overrides | Mutations | Severity |
|------|---------|-------------|-----------|-----------|-----------|----------|
| ... | ... | ... | ... | ... | ... | blocking/behavioral/cosmetic |

### Blockers (if any)
- {reflection usage at file:line — rename may not propagate}
- {public API surface — external callers outside the solution will break}
- {generated code at file:line — regenerate after change}

### Recommended Follow-ups
1. {ordered list, most severe first}
2. ...

### Suggested Next Skill
- For a rename or extract: hand off to `refactor`.
- For a single-site IDE-style fix: hand off to `code-actions`.
- For a diagnostic-driven cleanup: hand off to `explain-error` or `dead-code`.
```

Rank the per-file table by severity first (blocking → behavioral → cosmetic), then by reference count descending.

## Refusal conditions

Stop the skill and explain clearly to the user if any of the following hold:

1. **Workspace load failed** — `workspace_load` errored or `workspace_status` reports `state` other than a ready/loaded state. Report the load diagnostics and stop; blast-radius numbers from a half-loaded workspace are unsafe.
2. **Symbol not found** — `symbol_search` returned zero candidates for the given name. Ask the user to supply a fully-qualified name, the declaring file, or the containing type.
3. **Ambiguous symbol without disambiguation** — `symbol_search` returned multiple candidates and the user has not yet picked one. List the candidates (kind, containing type, file:line) and wait for the caller to choose. Do not run the impact sweep against all of them.
4. **Connectivity precheck failed** — see the precheck message above; do not proceed.

Never produce a verdict from partial data. If any impact tool errors out mid-sweep, surface the failure in the Blockers section and downgrade the verdict to at least MEDIUM.