Release v0.3.0-alpha.31: expression-based VoseOutput names

Bug #32, surfaced by Vose's own Inputs Outputs.xlsx sample which
declares its output as VoseOutput("Total net revenue from "&B8&"
to "&B23,"$k"). The name is an Excel expression — the runtime
value (e.g. "Total net revenue from 2020 to 2027") only exists
after Excel evaluates the formula.

Our name_parser was treating the leading literal as a full literal
name. The bridge then:
- Passed the partial prefix to the XLL — never matched the cell
- Post-condition looked it up in the .vmrs — never found it
- Raised SimulationFailedError claiming post-phase crashed when
  in fact the only issue was name resolution

Fix:
- New ExpressionName type for first-args that prove to be
  expressions (literal followed by &, +, etc. rather than , or ))
- Parser detects via what follows the closing quote
- _resolve_vose_name returns the partial prefix with a …
  ellipsis marker so list_modelrisk_outputs still surfaces the
  cell — just signals "dynamic name" instead of dropping it
- Post-condition verification filters out …-marked names rather
  than false-positively failing

Doesn't make the dynamic-name output actually register in the
.vmrs — that's a deeper investigation requiring expression
evaluation. This release is the honesty improvement: don't claim
failure when the sim ran fine.

408 tests pass (+4).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: vosesoft

CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to ModelRisk MCP. Follows [Keep a Changelog](https://keepach
 
 ## [Unreleased]
 
+## [0.3.0-alpha.31] — 2026-05-22
+
+### Fixed
+
+- **Bug #32 — expression-based VoseInput/VoseOutput names false-positive-failed post-condition verification.** Vose's own `Inputs Outputs.xlsx` sample declares its output as `VoseOutput("Total net revenue from "&B8&" to "&B23,"$k")` — the name is an Excel expression, not a static literal. The runtime-evaluated name (e.g. `"Total net revenue from 2020 to 2027"`) is only knowable after Excel computes the formula at simulation time. Our `name_parser` was returning the literal prefix as a `LiteralName` (since it stopped at the closing quote), so:
+  - The bridge's `expected_output_names` contained the partial prefix.
+  - `run_simulation` passed it to the XLL, which couldn't match it against the actual VoseOutput cell.
+  - Post-condition verification looked it up in the produced .vmrs, didn't find it, and raised `SimulationFailedError` — claiming the sim's post-phase had crashed when in fact the only issue was the name-resolution mismatch.
+
+  Fix:
+  - New `ExpressionName` type in `name_parser.py` for first-args that turn out to be expressions (literal followed by `&`, `+`, etc., rather than a closing `,` or `)`).
+  - The parser detects this by checking what follows the closing quote.
+  - `_resolve_vose_name` returns the partial prefix marked with a `…` ellipsis so `list_modelrisk_outputs` still surfaces the cell with an informational name (`"Total net revenue from …"`) instead of dropping it.
+  - Post-condition verification filters out `…`-marked names — we can't statically verify them, so we don't try, rather than failing loudly.
+
+### Why this matters
+
+Workbooks that build output names from cell content are a real pattern (year-range labels, scenario-specific outputs, anything dynamic). Before alpha.31 every one of those workbooks looked broken to the bridge. The deeper fix — actually evaluating the Excel expression to get the runtime name and registering THAT with the XLL — is a separate larger investigation; this release is the honesty improvement: don't claim failure when the sim ran fine.
+
+### Tests
+
+408 unit tests pass (+4 in `test_name_parser.py::TestExpressionForm` covering the Vose-sample literal-concat-cellref case, simple `"prefix"&A1`, two-arg literal-with-units, and whitespace tolerance around the closing quote).
+
 ## [0.3.0-alpha.30] — 2026-05-22
 
 ### Fixed

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "modelrisk-mcp"
-version = "0.3.0a30"
+version = "0.3.0a31"
 description = "Open MCP server bridging Anthropic Claude (and any MCP-compatible client) with the ModelRisk Excel add-in."
 readme = "README.md"
 requires-python = ">=3.11"

server.json

@@ -3,12 +3,12 @@
   "name": "io.github.vosesoftware/modelrisk-mcp",
   "title": "ModelRisk",
   "description": "Read, build, fit, and run Monte Carlo risk models in Excel through Vose Software's ModelRisk.",
-  "version": "0.3.0a30",
+  "version": "0.3.0a31",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "modelrisk-mcp",
-      "version": "0.3.0a30",
+      "version": "0.3.0a31",
       "transport": {
         "type": "stdio"
       }

src/modelrisk_mcp/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.0a30"
+__version__ = "0.3.0a31"

src/modelrisk_mcp/bridge/modelrisk.py

@@ -24,6 +24,7 @@
 from modelrisk_mcp.bridge.excel import ExcelBridge
 from modelrisk_mcp.bridge.mrservice import MrServiceBridge
 from modelrisk_mcp.bridge.name_parser import (
+    ExpressionName,
     LiteralName,
     extract_vose_first_arg,
 )
@@ -175,17 +176,22 @@ def run_simulation(
         # Pin the produced file so the existing reader tools find it.
         self._results.set_active_vmrs(result.vmrs_path)
 
-        # Post-condition verification — see _verify_simulation_post_conditions
-        # for the full criteria. If the .vmrs doesn't contain any of the
-        # expected output names, raise. On raise, attempt to restore the
-        # workbook to deterministic state (bug #21) so the user isn't
-        # left with VoseOutput cells stuck on sample values. The restore
-        # is best-effort; if it fails too, the original SimulationFailed
-        # propagates regardless.
-        if expected_output_names:
+        # Post-condition verification. Only check names we can
+        # statically resolve — bug #32 (alpha.31): ExpressionName
+        # outputs like `VoseOutput("prefix "&B8&" suffix")` have
+        # their actual runtime name computed by Excel at simulation
+        # time, so the scanner's partial prefix can't be looked up
+        # in the .vmrs. Including those in the check would
+        # false-positively claim every such workbook failed.
+        verifiable_names = [
+            n for n in expected_output_names
+            if n and not n.endswith("…")  # "…" marker for dynamic
+            and n != "<dynamic name>"
+        ]
+        if verifiable_names:
             try:
                 self._verify_simulation_post_conditions(
-                    result.vmrs_path, expected_output_names,
+                    result.vmrs_path, verifiable_names,
                 )
             except SimulationFailedError:
                 try:
@@ -323,21 +329,29 @@ def _resolve_vose_name(
     ) -> str | None:
         """Extract and resolve a Vose wrapper's name argument.
 
-        Handles both forms:
-          - `VoseInput("WidgetCost")`  → returns "WidgetCost"
-          - `VoseInput(A5)`             → reads A5 and returns its value
-          - `VoseInput(Sheet2!A5)`      → reads Sheet2!A5 and returns its value
+        Handles all three forms:
+          - `VoseInput("WidgetCost")`         → "WidgetCost"
+          - `VoseInput(A5)`                   → reads A5
+          - `VoseInput("prefix "&B8)`         → returns the static
+            prefix (post-alpha.31 ExpressionName). The runtime-
+            computed name is unknown but at least the user sees
+            "Total net revenue from " in `list_outputs` instead of
+            the cell disappearing entirely.
 
         Returns None if the wrapper isn't present, the form is
         unrecognized, or the referenced cell is empty / unreadable.
-        Conservative on purpose — we'd rather skip a cell than
-        confidently mis-attribute a name.
         """
         arg = extract_vose_first_arg(formula, wrapper)
         if arg is None:
             return None
         if isinstance(arg, LiteralName):
             return _unescape_excel_string(arg.name)
+        if isinstance(arg, ExpressionName):
+            # Show the partial prefix so the user knows the cell exists
+            # and roughly what it's called. Marker syntax `prefix…`
+            # makes it obvious this is a dynamic name, not a literal.
+            prefix = _unescape_excel_string(arg.static_prefix).rstrip()
+            return f"{prefix}…" if prefix else "<dynamic name>"
         # CellRefName — read the target cell to get the actual name.
         target_sheet = arg.sheet or same_sheet
         try:

src/modelrisk_mcp/bridge/name_parser.py

@@ -55,6 +55,31 @@ class CellRefName:
     cell: str   # A1-style, e.g. "A5" or "AB12"
 
 
+@dataclass(frozen=True)
+class ExpressionName:
+    """The wrapper's first arg was an Excel expression (e.g.
+    `"prefix"&B8&" suffix"` or `CONCAT(B8, B23)` or any arithmetic).
+    The runtime-evaluated name is only knowable after Excel computes
+    the formula — typically only ModelRisk's XLL sees the final
+    string.
+
+    `static_prefix` is whatever literal-string portion we could
+    extract from the start of the expression. Useful for display
+    ("we see the name starts with X"), but MUST NOT be used as the
+    canonical name when comparing against the simulation's .vmrs
+    output registry — the actual name will be longer or different.
+
+    Bug #32 (alpha.31): without this type the parser silently
+    returned a partial-LiteralName for expression-based wrappers
+    like Vose's own sample `VoseOutput("Total net revenue from "
+    &B8&" to "&B23,"$k")`. The bridge then asked MRService to look
+    up the partial name, which never matched the runtime-evaluated
+    name, and `run_simulation`'s post-condition verification
+    false-positively claimed the sim failed."""
+
+    static_prefix: str  # informational only; not a usable lookup key
+
+
 # Matches a cell reference at the start of a string. Captures:
 #   group "sheet"  — sheet name (without quotes), optional
 #   group "col"    — column letters
@@ -81,7 +106,7 @@ class CellRefName:
 
 def extract_vose_first_arg(
     formula: str, wrapper: str,
-) -> LiteralName | CellRefName | None:
+) -> LiteralName | CellRefName | ExpressionName | None:
     """Extract and classify the first argument of a Vose wrapper call.
 
     `wrapper` is the function name without the opening paren, e.g.
@@ -103,7 +128,7 @@ def extract_vose_first_arg(
     if start >= len(formula):
         return None
 
-    # Case 1: string literal
+    # Case 1: string literal (possibly the start of an expression).
     if formula[start] == '"':
         i = start + 1
         buf: list[str] = []
@@ -115,8 +140,20 @@ def extract_vose_first_arg(
                     buf.append('"')
                     i += 2
                     continue
-                # End of string literal
-                return LiteralName(name="".join(buf))
+                # End of string literal at position i. Now check what
+                # follows: a `,` or `)` (possibly after whitespace)
+                # means the literal IS the whole first argument. A
+                # `&`, `+`, or any other operator means the literal
+                # was just the start of an expression — bug #32
+                # surfaced by Vose's own `Inputs Outputs.xlsx` sample
+                # which uses `VoseOutput("prefix "&B8&" suffix",...)`.
+                j = i + 1
+                while j < len(formula) and formula[j] in " \t":
+                    j += 1
+                if j < len(formula) and formula[j] in ",)":
+                    return LiteralName(name="".join(buf))
+                # Expression — return the partial prefix as informational.
+                return ExpressionName(static_prefix="".join(buf))
             buf.append(ch)
             i += 1
         return None  # unterminated string literal
@@ -154,4 +191,9 @@ def extract_vose_first_arg(
     return None
 
 
-__all__ = ["CellRefName", "LiteralName", "extract_vose_first_arg"]
+__all__ = [
+    "CellRefName",
+    "ExpressionName",
+    "LiteralName",
+    "extract_vose_first_arg",
+]

tests/unit/test_name_parser.py

@@ -13,6 +13,7 @@
 
 from modelrisk_mcp.bridge.name_parser import (
     CellRefName,
+    ExpressionName,
     LiteralName,
     extract_vose_first_arg,
 )
@@ -178,4 +179,51 @@ def test_wrapper_inside_other_function(self) -> None:
         assert result.name == "X"
 
 
+# ----------------------------------------------------------------------
+# Expression form — bug #32, surfaced by Vose's own Inputs Outputs sample
+# ----------------------------------------------------------------------
+
+
+class TestExpressionForm:
+    """Vose's `Inputs Outputs.xlsx` has outputs declared as expressions:
+    `VoseOutput("Total net revenue from "&B8&" to "&B23,"$k")`. The
+    parser must recognise these as expression-form (not literal) so
+    downstream code knows not to use the partial prefix as a lookup
+    key against the .vmrs's runtime-evaluated name."""
+
+    def test_literal_concat_cellref_is_expression(self) -> None:
+        result = extract_vose_first_arg(
+            '=VoseOutput("Total net revenue from "&B8&" to "&B23,"$k")',
+            "VoseOutput",
+        )
+        assert isinstance(result, ExpressionName)
+        assert result.static_prefix == "Total net revenue from "
+
+    def test_literal_concat_simple(self) -> None:
+        result = extract_vose_first_arg(
+            '=VoseInput("prefix"&A1)', "VoseInput",
+        )
+        assert isinstance(result, ExpressionName)
+        assert result.static_prefix == "prefix"
+
+    def test_literal_with_units_arg_is_still_literal(self) -> None:
+        """`VoseOutput("name", "$k")` is two args, first is a clean
+        literal — NOT an expression. Make sure the comma-vs-ampersand
+        distinction is sharp."""
+        result = extract_vose_first_arg(
+            '=VoseOutput("RealName","$k")', "VoseOutput",
+        )
+        assert isinstance(result, LiteralName)
+        assert result.name == "RealName"
+
+    def test_literal_with_trailing_whitespace_before_close(self) -> None:
+        """Whitespace between the closing quote and the comma/paren
+        must still classify as literal."""
+        result = extract_vose_first_arg(
+            '=VoseOutput("OK"   , "$k")', "VoseOutput",
+        )
+        assert isinstance(result, LiteralName)
+        assert result.name == "OK"
+
+
 _ = pytest

tests/unit/test_server_boot.py

@@ -5,7 +5,7 @@
 
 
 def test_version_is_set() -> None:
-    assert __version__ == "0.3.0a30"
+    assert __version__ == "0.3.0a31"
 
 
 def test_server_name() -> None: