Add edit_tree — tweak an existing decision tree by talking (capability gap #4)

The "build it, then change it by talking" path. edit_tree reads a stored
tree, applies a list of targeted EditOps — set_probability,
set_branch_value, set_terminal_value, rename_node, rename_branch,
set_objective — re-serializes, validates by rolling back, and returns the
new EV + optimal policy. dry_run-default; dry_run=False writes back to the
SAME sheet and re-renders.

Frozen-dataclass edits via dataclasses.replace; missing target / unknown
op raise clearly. Demo: nudging the geology probability and the sell
offer re-rolls the recommendation live (Sell EV 30 -> 50 as 'wet' rises).
38 tests incl. decision-flip, minimize, commit-same-sheet, bad-target.
ruff + mypy clean. 0.0.8 (not released).

Other capability gaps (run_evii, modelrisk distribution hand-off, more
structured analysis tools) are gated on the deployed add-in (named
ranges / new commands) or cross-server; deferred behind that.

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

Author: vosesoft

README.md

@@ -11,6 +11,7 @@ A sibling to [`modelrisk-mcp`](https://github.com/vosesoftware/modelrisk-mcp): w
 | Tool | What it does |
 |---|---|
 | `build_tree` | **Build a tree from a structured description** and write it into Excel (dry-run by default). Validates + rolls it back so you confirm the recommendation before writing. The build-from-a-prompt path. |
+| `edit_tree` | **Tweak an existing tree** — change probabilities, payoffs, labels, or the objective, then re-roll it (dry-run by default). The "tweak it by talking" path. |
 | `list_trees` | List the decision trees in a workbook with node-type counts. |
 | `get_tree` | Full structure of one tree — decision / chance / terminal nodes, branches, probabilities, values. |
 | `roll_up` | Roll the tree back to its expected values and **optimal policy** — the decision recommendation, in plain English. |

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "modelchoice-mcp"
-version = "0.0.7"
+version = "0.0.8"
 description = "An open Model Context Protocol server for Vose Software's ModelChoice decision-tree add-in for Excel."
 readme = "README.md"
 requires-python = ">=3.11"

src/modelchoice_mcp/__init__.py

@@ -1,4 +1,4 @@
 """ModelChoice MCP — an open Model Context Protocol server for Vose
 Software's ModelChoice decision-tree add-in for Excel."""
 
-__version__ = "0.0.7"
+__version__ = "0.0.8"

src/modelchoice_mcp/schemas.py

@@ -116,6 +116,30 @@ class TreeSpec(BaseModel):
     nodes: list[NodeSpec] = Field(description="All nodes in the tree.")
 
 
+class EditOp(BaseModel):
+    """A single targeted edit to an existing tree. `op` selects the
+    change; the other fields are the target/new value for that op."""
+
+    op: str = Field(
+        description=(
+            "One of: 'set_probability', 'set_branch_value', 'set_terminal_value', "
+            "'rename_node', 'rename_branch', 'set_objective'."
+        )
+    )
+    node_id: str | None = Field(default=None, description="Target node id (most ops).")
+    branch_name: str | None = Field(
+        default=None, description="Target branch/option name (branch-level ops)."
+    )
+    value: float | None = Field(
+        default=None,
+        description="New number — probability, branch cash flow, or terminal payoff.",
+    )
+    name: str | None = Field(default=None, description="New label for a rename op.")
+    maximize: bool | None = Field(
+        default=None, description="New objective for 'set_objective' (true=maximize)."
+    )
+
+
 class BuildTreeResult(BaseModel):
     """Outcome of building a tree from a spec."""
 

src/modelchoice_mcp/tools.py

@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 from typing import Annotated, Any
 
 from pydantic import Field
@@ -16,6 +17,7 @@
     AnalysisRun,
     BranchView,
     BuildTreeResult,
+    EditOp,
     EvpiResult,
     KeyValue,
     NodeDiff,
@@ -149,6 +151,122 @@ def build_tree(
     )
 
 
+def _apply_edits(tree: DecisionTree, edits: list[EditOp]) -> DecisionTree:
+    """Return a new tree with the edits applied. Frozen dataclasses are
+    rebuilt via dataclasses.replace; unknown ops or missing targets raise
+    TreeParseError."""
+    nodes = dict(tree.nodes)
+    maximize = tree.maximize
+    model_name = tree.model_name
+
+    for e in edits:
+        op = e.op.lower()
+        if op == "set_objective":
+            if e.maximize is None:
+                raise TreeParseError("set_objective needs `maximize`.")
+            maximize = e.maximize
+            continue
+
+        if not e.node_id or e.node_id not in nodes:
+            raise TreeParseError(f"edit {op!r}: no node {e.node_id!r}.")
+        node = nodes[e.node_id]
+
+        if op == "rename_node":
+            if not e.name:
+                raise TreeParseError("rename_node needs `name`.")
+            nodes[e.node_id] = dataclasses.replace(node, name=e.name)
+        elif op == "set_terminal_value":
+            if node.kind != "terminal":
+                raise TreeParseError(f"{e.node_id!r} is not a terminal node.")
+            if e.value is None:
+                raise TreeParseError("set_terminal_value needs `value`.")
+            nodes[e.node_id] = dataclasses.replace(node, value=e.value)
+        elif op in ("set_probability", "set_branch_value", "rename_branch"):
+            found = False
+            new_branches = []
+            for b in node.branches:
+                if b.name == e.branch_name:
+                    found = True
+                    if op == "set_probability":
+                        b = dataclasses.replace(b, probability=e.value)
+                    elif op == "set_branch_value":
+                        b = dataclasses.replace(b, value=e.value or 0.0)
+                    else:  # rename_branch
+                        if not e.name:
+                            raise TreeParseError("rename_branch needs `name`.")
+                        b = dataclasses.replace(b, name=e.name)
+                new_branches.append(b)
+            if not found:
+                raise TreeParseError(
+                    f"node {e.node_id!r} has no branch named {e.branch_name!r}."
+                )
+            nodes[e.node_id] = dataclasses.replace(node, branches=new_branches)
+        else:
+            raise TreeParseError(f"unknown edit op {e.op!r}.")
+
+    return dataclasses.replace(
+        tree, nodes=nodes, maximize=maximize, model_name=model_name
+    )
+
+
+@mcp.tool(
+    description=(
+        "ModelChoice: Edit an existing decision tree in place — change "
+        "probabilities, branch cash flows, terminal payoffs, node/branch "
+        "labels, or the maximize/minimize objective — then re-roll it. Pass "
+        "`edits` as a list of operations ('set_probability', 'set_branch_value', "
+        "'set_terminal_value', 'rename_node', 'rename_branch', 'set_objective'). "
+        "Reads the named tree, applies the edits, validates by rolling back, and "
+        "returns the new EV + optimal policy. dry_run=True (default) previews; "
+        "dry_run=False writes and re-renders. The 'tweak it by talking' path."
+    )
+)
+def edit_tree(
+    edits: list[EditOp],
+    tree_name: Annotated[
+        str | None, Field(description="Tree sheet name. Omit for the first tree.")
+    ] = None,
+    dry_run: bool = True,
+    workbook_name: str | None = None,
+) -> BuildTreeResult:
+    bridge = get_bridge()
+    trees = bridge.list_trees(workbook_name)
+    if tree_name is None:
+        tree_name = next(iter(trees))
+    if tree_name not in trees:
+        raise TreeParseError(f"no tree {tree_name!r}; available: {', '.join(trees)}.")
+
+    edited = _apply_edits(parse_model(trees[tree_name]), edits)
+    model_json = to_model_json(edited)
+    parsed = parse_model(model_json)
+    r = rollup(parsed)
+
+    direction = "maximize" if edited.maximize else "minimize"
+    if r.optimal_path:
+        rec = (
+            f"After edits, optimal decision ({direction} EV): take "
+            f"{' → '.join(r.optimal_path)}. Expected value {r.expected_value:,.2f}."
+        )
+    else:
+        rec = f"After edits, expected value {r.expected_value:,.2f} ({direction})."
+
+    written = False
+    if not dry_run:
+        bridge.write_tree(model_json, sheet_name=tree_name, workbook=workbook_name)
+        bridge.render_tree(tree_name, workbook_name)
+        written = True
+
+    return BuildTreeResult(
+        written=written,
+        sheet=tree_name if written else None,
+        node_count=len(parsed.nodes),
+        expected_value=r.expected_value,
+        optimal_path=r.optimal_path,
+        recommendation=rec,
+        model_json=model_json,
+    )
+
+
 def _counts(tree: DecisionTree) -> tuple[int, int, int]:
     d = sum(1 for n in tree.nodes.values() if n.kind == "decision")
     c = sum(1 for n in tree.nodes.values() if n.kind == "chance")
@@ -559,6 +677,7 @@ def read_sheet(
 
 __all__ = [
     "build_tree",
+    "edit_tree",
     "get_bridge",
     "get_tree",
     "list_trees",

tests/test_server.py

@@ -7,7 +7,7 @@
 
 
 def test_version_set() -> None:
-    assert __version__ == "0.0.7"
+    assert __version__ == "0.0.8"
 
 
 def test_server_name() -> None:

tests/test_tools.py

@@ -12,6 +12,7 @@
 from modelchoice_mcp.schemas import (
     BranchSpec,
     BuildTreeResult,
+    EditOp,
     EvpiResult,
     NodeSpec,
     RollbackVerification,
@@ -264,6 +265,60 @@ def test_build_tree_commit_writes_and_renders() -> None:
         tools.set_bridge_for_testing(None)
 
 
+def test_edit_tree_changes_payoff_and_flips_decision() -> None:
+    fake = _FakeBridge({"MC_Tree_1": _MODEL})
+    tools.set_bridge_for_testing(fake)  # type: ignore[arg-type]
+    try:
+        # Drop the 'Sell' payoff below the chance EV (-25) so Drill wins.
+        out = tools.edit_tree(
+            [EditOp(op="set_branch_value", node_id="D", branch_name="Sell", value=-30)]
+        )
+        assert isinstance(out, BuildTreeResult)
+        assert out.written is False
+        assert out.optimal_path == ["Drill"]
+        assert out.expected_value == -25.0
+    finally:
+        tools.set_bridge_for_testing(None)
+
+
+def test_edit_tree_set_objective_minimize() -> None:
+    fake = _FakeBridge({"MC_Tree_1": _MODEL})
+    tools.set_bridge_for_testing(fake)  # type: ignore[arg-type]
+    try:
+        out = tools.edit_tree([EditOp(op="set_objective", maximize=False)])
+        # Minimizing prefers the chance node (EV -25) over Sell (50).
+        assert out.expected_value == -25.0 and out.optimal_path == ["Drill"]
+    finally:
+        tools.set_bridge_for_testing(None)
+
+
+def test_edit_tree_commit_writes_same_sheet() -> None:
+    fake = _FakeBridge({"MC_Tree_1": _MODEL})
+    tools.set_bridge_for_testing(fake)  # type: ignore[arg-type]
+    try:
+        out = tools.edit_tree(
+            [EditOp(op="set_probability", node_id="C", branch_name="Wet", value=0.8)],
+            dry_run=False,
+        )
+        assert out.written is True and out.sheet == "MC_Tree_1"
+        assert fake.rendered == "MC_Tree_1"
+        # The edited probability is reflected in the written JSON.
+        assert '"probability": 0.8' in fake.written_json
+    finally:
+        tools.set_bridge_for_testing(None)
+
+
+def test_edit_tree_bad_target_raises() -> None:
+    from modelchoice_mcp.tree import TreeParseError
+
+    tools.set_bridge_for_testing(_FakeBridge({"MC_Tree_1": _MODEL}))  # type: ignore[arg-type]
+    try:
+        with pytest.raises(TreeParseError):
+            tools.edit_tree([EditOp(op="set_terminal_value", node_id="NOPE", value=1)])
+    finally:
+        tools.set_bridge_for_testing(None)
+
+
 def test_run_sensitivity(bridge: _FakeBridge) -> None:
     out = tools.run_sensitivity()
     assert bridge.last_command == "MC_SensitivityAnalysis_Auto"