artifacts

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/add_batch_e_results.py

@@ -0,0 +1,163 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+
+INSERT = (b'\n\ndef derive_code_path_result(target: str, max_depth: int = 5) -> Result[str]:\n'
+          b' """Recursively traces the execution path of a specific function or method."""\n'
+          b' from src.file_cache import ASTParser\n'
+          b' parser = ASTParser("python")\n'
+          b' found_path, found_code = None, None\n'
+          b' parts = target.split(".")\n'
+          b' symbol_name = parts[-1]\n'
+          b' if len(parts) > 1:\n'
+          b'  possible_file = Path(*parts[:-1]).with_suffix(".py")\n'
+          b'  if possible_file.exists(): found_path = str(possible_file)\n'
+          b' if not found_path:\n'
+          b'  for root in ["src", "simulation"]:\n'
+          b'   for p in Path(root).rglob("*.py"):\n'
+          b'    if not _is_allowed(p): continue\n'
+          b'    code = p.read_text(encoding="utf-8")\n'
+          b'    if f"def {symbol_name}" in code or f"class {symbol_name}" in code:\n'
+          b'     try:\n'
+          b'      tree = ast.parse(code)\n'
+          b'      if _get_symbol_node(tree, symbol_name):\n'
+          b'       found_path, found_code = str(p), code\n'
+          b'       break\n'
+          b'     except Exception: continue\n'
+          b'   if found_path: break\n'
+          b' if not found_path:\n'
+          b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"could not find definition for \\"{target}\\"", source="mcp.derive_code_path_result")])\n'
+          b' if not found_code: found_code = Path(found_path).read_text(encoding="utf-8")\n'
+          b' visited, output = set(), [f"Code Path for: {target}", "=" * (11 + len(target)), ""]\n'
+          b' def trace(name, path, code, depth, indent):\n'
+          b'  if depth > max_depth or (name, path) in visited: return\n'
+          b'  visited.add((name, path))\n'
+          b'  defn = parser.get_definition(code, name, path=path)\n'
+          b'  if defn.startswith("ERROR:"):\n'
+          b'   output.append(f"{indent}[!] {name} (Definition not found in {path})")\n'
+          b'   return\n'
+          b'  output.append(f"{indent}-> {name} ({path})")\n'
+          b'  try:\n'
+          b'   node = ast.parse(defn)\n'
+          b'   calls = []\n'
+          b'   for n in ast.walk(node):\n'
+          b'    if isinstance(n, ast.Call):\n'
+          b'     if isinstance(n.func, ast.Name): calls.append(n.func.id)\n'
+          b'     elif isinstance(n.func, ast.Attribute): calls.append(n.func.attr)\n'
+          b'   for call in sorted(set(calls)):\n'
+          b'    if call in ("print", "len", "str", "int", "list", "dict", "set", "range", "enumerate", "isinstance", "getattr", "setattr", "hasattr"): continue\n'
+          b'    c_path, c_code = None, None\n'
+          b'    full_tree = ast.parse(code)\n'
+          b'    if _get_symbol_node(full_tree, call): c_path, c_code = path, code\n'
+          b'    else:\n'
+          b'     for r in ["src", "simulation"]:\n'
+          b'      for p in Path(r).rglob("*.py"):\n'
+          b'       if not _is_allowed(p): continue\n'
+          b'       f_code = p.read_text(encoding="utf-8")\n'
+          b'       if f"def {call}" in f_code:\n'
+          b'        c_path, c_code = str(p), f_code\n'
+          b'        break\n'
+          b'      if c_path: break\n'
+          b'    if c_path: trace(call, c_path, c_code, depth + 1, indent + "  ")\n'
+          b'  except Exception as e: output.append(f"{indent}  [!] Error parsing calls for {name}: {e}")\n'
+          b' trace(symbol_name, found_path, found_code, 0, "")\n'
+          b' return Result(data="\\n".join(output))\n'
+          b'\n'
+          b'def get_tree_result(path: str, max_depth: int = 2) -> Result[str]:\n'
+          b' """Returns a directory structure up to a max depth."""\n'
+          b' p, err = _resolve_and_check_result(path)\n'
+          b' if not p.ok:\n'
+          b'  return Result(data="", errors=p.errors)\n'
+          b' p_obj = p.data\n'
+          b' if isinstance(p_obj, NilPath):\n'
+          b'  return Result(data="", errors=p.errors)\n'
+          b' if not p_obj.is_dir():\n'
+          b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a directory: {path}", source="mcp.get_tree_result")])\n'
+          b' m_depth = max_depth\n'
+          b' def _build_tree(dir_path: Path, current_depth: int, prefix: str = "") -> list[str]:\n'
+          b'  if current_depth > m_depth: return []\n'
+          b'  lines = []\n'
+          b'  try:\n'
+          b'   entries = sorted(dir_path.iterdir(), key=lambda e: (e.is_file(), e.name.lower()))\n'
+          b'  except PermissionError:\n'
+          b'   return []\n'
+          b'  entries = [e for e in entries if not e.name.startswith(chr(46)) and e.name not in (chr(95)*2 + chr(112) + chr(121) + chr(99) + chr(97) + chr(99) + chr(104) + chr(101) + chr(95)*2,) and e.name not in (chr(118) + chr(101) + chr(110) + chr(118), chr(101) + chr(110) + chr(118)) and e.name != "history.toml" and not e.name.endswith("_history.toml")]\n'
+          b'  for i, entry in enumerate(entries):\n'
+          b'   is_last = (i == len(entries) - 1)\n'
+          b'   connector = "\u2514\u2500\u2500 " if is_last else "\u251c\u2500\u2500 "\n'
+          b'   if entry.is_dir():\n'
+          b'    lines.append(f"{prefix}{connector}{entry.name}/")\n'
+          b'    extension = "    " if is_last else "\u2502   "\n'
+          b'    lines.extend(_build_tree(entry, current_depth + 1, prefix + extension))\n'
+          b'   else:\n'
+          b'    lines.append(f"{prefix}{connector}{entry.name}")\n'
+          b'  return lines\n'
+          b' try:\n'
+          b'  tree_lines = [f"{p_obj.name}/"] + _build_tree(p_obj, 1)\n'
+          b'  return Result(data="\\n".join(tree_lines))\n'
+          b' except Exception as e:\n'
+          b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.get_tree_result", original=e)])\n'
+          b'\n'
+          b'def web_search_result(query: str) -> Result[str]:\n'
+          b' """Search the web using DuckDuckGo HTML and return top results."""\n'
+          b' url = "https://html.duckduckgo.com/html/?q=" + urllib.parse.quote(query)\n'
+          b' req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"})\n'
+          b' try:\n'
+          b'  with urllib.request.urlopen(req, timeout=10) as resp:\n'
+          b'   html = resp.read().decode("utf-8", errors="ignore")\n'
+          b'  parser = _DDGParser()\n'
+          b'  parser.feed(html)\n'
+          b'  if not parser.results:\n'
+          b'   return Result(data=f"No results found for \\"{query}\\"")\n'
+          b'  lines = [f"Search Results for \\"{query}\\":"]\n'
+          b'  for i, r in enumerate(parser.results[:5], 1):\n'
+          b'   lines.append(f"{i}. {r[chr(116) + chr(105) + chr(116) + chr(108) + chr(101)]}\\nURL: {r[chr(108) + chr(105) + chr(110) + chr(107)]}\\nSnippet: {r[chr(115) + chr(110) + chr(105) + chr(112) + chr(112) + chr(101) + chr(116)]}\\n")\n'
+          b'  return Result(data="\\n".join(lines))\n'
+          b' except Exception as e:\n'
+          b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.web_search_result", original=e)])\n'
+          b'\n'
+          b'def fetch_url_result(url: str) -> Result[str]:\n'
+          b' """Fetch a URL and return its text content (stripped of HTML tags)."""\n'
+          b' if url.startswith("//duckduckgo.com/l/?uddg="):\n'
+          b'  split_uddg = url.split("uddg=")\n'
+          b'  if len(split_uddg) > 1:\n'
+          b'   url = urllib.parse.unquote(split_uddg[1].split("&")[0])\n'
+          b' if not url.startswith("http"):\n'
+          b'  url = "https://" + url\n'
+          b' req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"})\n'
+          b' try:\n'
+          b'  with urllib.request.urlopen(req, timeout=10) as resp:\n'
+          b'   html = resp.read().decode("utf-8", errors="ignore")\n'
+          b'  parser = _TextExtractor()\n'
+          b'  parser.feed(html)\n'
+          b'  full_text = " ".join(parser.text)\n'
+          b'  full_text = _re.sub(r"\\s+", " ", full_text)\n'
+          b'  if not full_text.strip():\n'
+          b'   return Result(data=f"FETCH OK: No readable text extracted from {url}. The page might be empty, JavaScript-heavy, or blocked.")\n'
+          b'  if len(full_text) > 40000:\n'
+          b'   return Result(data=full_text[:40000] + "\\n... (content truncated)")\n'
+          b'  return Result(data=full_text)\n'
+          b' except Exception as e:\n'
+          b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.fetch_url_result", original=e)])\n'
+          b'\n'
+          b'def get_ui_performance_result() -> Result[str]:\n'
+          b' """Returns current UI performance metrics (FPS, Frame Time, CPU, Input Lag)."""\n'
+          b' if perf_monitor_callback is None:\n'
+          b'  return Result(data="INFO: UI Performance monitor is not available (headless/CLI mode). This tool is only functional when the Manual Slop GUI is running.")\n'
+          b' try:\n'
+          b'  metrics = perf_monitor_callback()\n'
+          b'  metric_str = str(metrics)\n'
+          b'  for char in chr(123) + chr(125) + chr(39):\n'
+          b'   metric_str = metric_str.replace(char, "")\n'
+          b'  return Result(data=f"UI Performance Snapshot:\\n{metric_str}")\n'
+          b' except Exception as e:\n'
+          b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=f"Failed to retrieve UI performance: {str(e)}", source="mcp.get_ui_performance_result", original=e)])\n'
+          b'#endregion: Result Variants')
+
+# Insert before "#endregion: Result Variants"
+END_REGION = b"#endregion: Result Variants"
+assert END_REGION in raw
+new_raw = raw.replace(END_REGION, INSERT, 1)
+assert new_raw != raw
+p.write_bytes(new_raw)
+print(f"Added 5 _result variants to Result Variants region")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/append_heuristic_e_tests.py

@@ -0,0 +1,92 @@
+"""Append Phase 9 redo heuristic E regression tests."""
+
+PHASE_9_REDO_TESTS = '''
+
+# ============ Phase 9 redo: Heuristic E regression tests (TIER1_REVIEW) ============
+
+def test_heuristic_e_narrow_return_errorinfo_is_compliant():
+ """Phase 9 redo: narrow except + return ErrorInfo(...) is a true drain.
+
+ Per TIER1_REVIEW_phase9_dilemma_20260620: a narrow except body that
+ returns a structured ErrorInfo carries the original exception and is
+ the function's contract. This is NOT sliming (the error context is
+ preserved in `original=e`).
+ """
+ src = (
+  "def _classify_anthropic_error(exc, source):\\n"
+  " try:\\n"
+  "  err_data = exc.response.json()\\n"
+  " except (ValueError, AttributeError) as e:\\n"
+  "  return ErrorInfo(kind=ErrorKind.UNKNOWN, message=str(e), source=source, original=e)\\n"
+ )
+ visitor = _make_visitor(src, "_classify_anthropic_error")
+ try_node = _find_handler(visitor)
+ handler = try_node.handlers[0]
+ category, hint = visitor._classify_except(handler, try_node)
+ assert category == "INTERNAL_COMPLIANT", (
+  f"Heuristic E regression: narrow except + return ErrorInfo(...) "
+  f"should be INTERNAL_COMPLIANT (structured error carrier); got {category}. Hint: {hint}"
+ )
+
+
+def test_heuristic_e_narrow_dict_error_true_assign_is_compliant():
+ """Phase 9 redo: narrow except + dict[error] = True is a true drain (in-band flag).
+
+ Per TIER1_REVIEW: `except (NarrowType) as e: item["error"] = True`
+ is a structured error carrier. The caller is expected to inspect the
+ `error` flag (per-site decision documented in track notes; the audit
+ does NOT verify caller reads the flag).
+ """
+ src = (
+  "def _reread_file_items(file_items):\\n"
+  " try:\\n"
+  "  content = p.read_text()\\n"
+  "  new_item = {**item, 'content': content}\\n"
+  " except (OSError, UnicodeDecodeError) as e:\\n"
+  "  err_item = {**item, 'content': f'ERROR: {e}'}\\n"
+  "  err_item['error'] = True\\n"
+  "  refreshed.append(err_item)\\n"
+ )
+ visitor = _make_visitor(src, "_reread_file_items")
+ try_node = _find_handler(visitor)
+ handler = try_node.handlers[0]
+ category, hint = visitor._classify_except(handler, try_node)
+ assert category == "INTERNAL_COMPLIANT", (
+  f"Heuristic E regression: narrow except + dict['error'] = True "
+  f"should be INTERNAL_COMPLIANT (in-band error flag carrier); got {category}. Hint: {hint}"
+ )
+
+
+def test_heuristic_e_empty_default_args_is_NOT_compliant():
+ """Phase 9 redo: narrow except + args = {} is NOT a drain (sliming).
+
+ Per TIER1_REVIEW: the empty-default pattern loses error context. The
+ caller cannot distinguish success from failure. Heuristic E
+ explicitly does NOT match this pattern (this test is a regression
+ guard against future "helpful" heuristic additions that would
+ laundering this sliming pattern).
+ """
+ src = (
+  "def _execute_tool_calls_concurrently(calls):\\n"
+  " for fc in calls:\\n"
+  "  try:\\n"
+  "   args = json.loads(tool_args_str)\\n"
+  "  except (ValueError, TypeError):\\n"
+  "   args = {}\\n"
+ )
+ visitor = _make_visitor(src, "_execute_tool_calls_concurrently")
+ try_node = _find_handler(visitor)
+ handler = try_node.handlers[0]
+ category, hint = visitor._classify_except(handler, try_node)
+ # The site is narrow + non-broad but the body is empty-default.
+ # Heuristic E should NOT classify as COMPLIANT. May be INTERNAL_BROAD_CATCH
+ # (no drain) or UNCLEAR. NOT INTERNAL_COMPLIANT.
+ assert category != "INTERNAL_COMPLIANT", (
+  f"Heuristic E regression: narrow except + args = {{}} (empty default) "
+  f"must NOT be classified as INTERNAL_COMPLIANT (sliming per TIER1_REVIEW). "
+  f"Got {category} which would laundering the pattern. Hint: {hint}"
+ )
+'''
+with open("tests/test_audit_heuristics.py", "a", encoding="utf-8", newline="") as f:
+    f.write(PHASE_9_REDO_TESTS)
+print("Appended 3 Heuristic E regression tests")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/append_phase8_tests.py

@@ -0,0 +1,37 @@
+"""Append Phase 8 tests to existing test file."""
+
+# Phase 8 tests (3) - mcp_client silent-swallow + UNCLEAR + nested BC cleanup
+PHASE_8_TESTS = '''
+
+# ============ Phase 8 tests (3) ============
+
+def test_phase8_mcp_client_silent_swallow_zero():
+ """Phase 8 CRITICAL anti-sliming phase: mcp_client INTERNAL_SILENT_SWALLOW = 0."""
+ data = _audit_live()
+ files = {f["filename"]: f for f in data["files"]}
+ findings = files["src\\\\mcp_client.py"]["findings"]
+ ss = sum(1 for f in findings if f["category"] == "INTERNAL_SILENT_SWALLOW")
+ assert ss == 0, f"expected mcp_client SS=0 after Phase 8, got {ss}"
+
+
+def test_phase8_mcp_client_total_migration_target_zero():
+ """After Phase 8, mcp_client should have 0 migration-target sites (BC + SS + UNCLEAR)."""
+ data = _audit_live()
+ files = {f["filename"]: f for f in data["files"]}
+ findings = files["src\\\\mcp_client.py"]["findings"]
+ mig_cats = {"INTERNAL_BROAD_CATCH", "INTERNAL_SILENT_SWALLOW", "UNCLEAR"}
+ total = sum(1 for f in findings if f["category"] in mig_cats)
+ assert total == 0, f"expected mcp_client migration-target=0 after Phase 8, got {total}"
+
+
+def test_phase8_modules_import_cleanly():
+ """Verify mcp_client imports after Phase 8 anti-sliming migrations."""
+ import src.mcp_client
+ # New _result variants from Phase 8 are inside py_find_usages_result and
+ # derive_code_path_result; these are integration tests, not attribute tests.
+ assert hasattr(src.mcp_client, "py_find_usages_result")
+ assert hasattr(src.mcp_client, "derive_code_path_result")
+'''
+with open("tests/test_baseline_result.py", "a", encoding="utf-8", newline="") as f:
+    f.write(PHASE_8_TESTS)
+print("Appended Phase 8 tests")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/append_phase9_redo_tests.py

@@ -0,0 +1,37 @@
+"""Append Phase 9 redo invariant tests to test_baseline_result.py."""
+
+PHASE_9_REDO_TESTS = '''
+
+# ============ Phase 9 redo tests (TIER1_REVIEW, 4 sites) ============
+
+def test_phase9_redo_ai_client_unclear_zero():
+ """After Phase 9 redo per TIER1_REVIEW:
+   - L332, L355 refactored to return ErrorInfo (BOUNDARY_CONVERSION)
+   - L394, L716, L723, L994 migrated to Result[T]
+   UNCLEAR should be 0.
+ """
+ data = _audit_live()
+ files = {f["filename"]: f for f in data["files"]}
+ findings = files["src\\\\ai_client.py"]["findings"]
+ unclear = sum(1 for f in findings if f["category"] == "UNCLEAR")
+ assert unclear == 0, f"expected ai_client UNCLEAR=0 after Phase 9 redo, got {unclear}"
+
+
+def test_phase9_redo_new_helpers_exist():
+ """The new _result helpers added in Phase 9 redo must exist on ai_client."""
+ import src.ai_client
+ assert hasattr(src.ai_client, "_set_minimax_provider_result")
+ assert hasattr(src.ai_client, "_parse_tool_args_result")
+ assert hasattr(src.ai_client, "_reread_file_items_result")
+
+
+def test_phase9_redo_modules_import_cleanly():
+ """Verify ai_client imports after Phase 9 redo migrations."""
+ import src.ai_client
+ # The legacy string-returning functions should still exist for backward compat.
+ assert callable(getattr(src.ai_client, "set_provider", None))
+ assert callable(getattr(src.ai_client, "_reread_file_items", None))
+'''
+with open("tests/test_baseline_result.py", "a", encoding="utf-8", newline="") as f:
+    f.write(PHASE_9_REDO_TESTS)
+print("Appended Phase 9 redo tests")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/append_phase9_tests.py

@@ -0,0 +1,35 @@
+"""Append Phase 9 tests to existing test file."""
+
+PHASE_9_TESTS = '''
+
+# ============ Phase 9 tests (3) ============
+
+def test_phase9_ai_client_broad_catch_decreased():
+ """After Phase 9 Batch A (8 BC sites migrated), ai_client BC <= 9 (17 - 8)."""
+ data = _audit_live()
+ files = {f["filename"]: f for f in data["files"]}
+ findings = files["src\\\\ai_client.py"]["findings"]
+ bc = sum(1 for f in findings if f["category"] == "INTERNAL_BROAD_CATCH")
+ assert bc <= 9, f"expected ai_client BC<=9 after Phase 9, got {bc}"
+
+
+def test_phase9_ai_client_silent_swallow_count():
+ """After Phase 9, ai_client INTERNAL_SILENT_SWALLOW count is recorded for Phase 11."""
+ data = _audit_live()
+ files = {f["filename"]: f for f in data["files"]}
+ findings = files["src\\\\ai_client.py"]["findings"]
+ ss = sum(1 for f in findings if f["category"] == "INTERNAL_SILENT_SWALLOW")
+ # Some sites moved from BC to SS via exception narrowing; record for Phase 11.
+ assert ss >= 0, f"ss count check (informational): {ss}"
+
+
+def test_phase9_modules_import_cleanly():
+ """Verify ai_client imports after Batch A migrations."""
+ import src.ai_client
+ assert hasattr(src.ai_client, "_classify_deepseek_error")
+ assert hasattr(src.ai_client, "_classify_minimax_error")
+ assert hasattr(src.ai_client, "set_provider")
+'''
+with open("tests/test_baseline_result.py", "a", encoding="utf-8", newline="") as f:
+    f.write(PHASE_9_TESTS)
+print("Appended Phase 9 tests")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/audit_ai_state.py

@@ -0,0 +1,23 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\ai_client.py'
+findings = files[key]['findings']
+from collections import Counter
+cats = Counter(x['category'] for x in findings)
+print('ai_client current state:')
+for c, n in sorted(cats.items()):
+    print(f'  {c}: {n}')
+print()
+# Show the SS sites
+print('INTERNAL_SILENT_SWALLOW sites:')
+for f in findings:
+    if f['category'] == 'INTERNAL_SILENT_SWALLOW':
+        print(f"  L{f['line']} ctx={f.get('context', '?')!r}")
+# Show BC sites
+print()
+print('INTERNAL_BROAD_CATCH sites:')
+for f in findings:
+    if f['category'] == 'INTERNAL_BROAD_CATCH':
+        print(f"  L{f['line']} ctx={f.get('context', '?')!r}")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/audit_summary.py

@@ -0,0 +1,14 @@
+"""Audit summary per file (Phase 10 final check)."""
+import json
+import subprocess
+from collections import Counter
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if f['filename'].endswith(('mcp_client.py', 'ai_client.py', 'rag_engine.py')):
+        cats = Counter(x['category'] for x in f['findings'])
+        print(f"{f['filename']}: {dict(cats)}")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/check_6_sites.py

@@ -0,0 +1,9 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\ai_client.py'
+findings = files[key]['findings']
+for f in findings:
+    if f['line'] in (332, 355, 394, 716, 723, 994):
+        print('L' + str(f['line']) + ' ' + f['category'] + ' ctx=' + repr(f.get('context', '?')))

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/check_after_heuristic.py

@@ -0,0 +1,16 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\ai_client.py'
+findings = files[key]['findings']
+from collections import Counter
+cats = Counter(x['category'] for x in findings)
+print('ai_client categories after heuristic add:')
+for c, n in sorted(cats.items()):
+    print(f'  ' + c + ': ' + str(n))
+# Show L332, L355 details
+print()
+for f in findings:
+    if f['line'] in (332, 355, 394, 716, 723, 994):
+        print('L' + str(f['line']) + ' ' + f['category'] + ' ctx=' + repr(f.get('context', '?')))

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/check_all_ai.py

@@ -0,0 +1,16 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\ai_client.py'
+findings = files[key]['findings']
+print('All ai_client migration-target sites:')
+for f in findings:
+    if f['category'] in ('INTERNAL_BROAD_CATCH', 'INTERNAL_SILENT_SWALLOW', 'UNCLEAR', 'INTERNAL_RETHROW', 'INTERNAL_OPTIONAL_RETURN'):
+        print('  L' + str(f['line']) + ' ' + f['category'] + ' ctx=' + repr(f.get('context', '?')))
+print()
+from collections import Counter
+cats = Counter(x['category'] for x in findings)
+print('Total:')
+for c, n in sorted(cats.items()):
+    print('  ' + c + ': ' + str(n))

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/check_bc_now.py

@@ -0,0 +1,10 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\mcp_client.py'
+findings = files[key]['findings']
+bc_sites = sorted([f for f in findings if f['category'] == 'INTERNAL_BROAD_CATCH'], key=lambda x: x['line'])
+print('Current mcp_client BC sites:', len(bc_sites))
+for i, s in enumerate(bc_sites, 1):
+    print(f'  {i:2d}. L{s["line"]:5d}  ctx={s.get("context", "?")!r}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/check_get_tree.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+idx = raw.find(b'def get_tree(path: str, max_depth: int = 2) -> str:')
+end_marker = raw.find(b'ERROR generating tree', idx)
+block = raw[idx:end_marker+200]
+print('Has except Exception:', b'except Exception' in block)
+# Print the last part of the block
+import sys
+sys.stdout.reconfigure(encoding='utf-8')
+print(block[-500:].decode('utf-8', errors='replace'))

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/check_get_tree_state.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+new_str = b'def get_tree(path: str, max_depth: int = 2) -> str:\r\n """Returns a directory structure up to a max depth.\r\n\r\n Thin wrapper over get_tree_result'
+print('get_tree migrated:', new_str in raw)
+idx = raw.find(b'def get_tree(path: str, max_depth: int = 2) -> str:')
+end_idx = raw.find(b'class _DDGParser', idx)
+block = raw[idx:end_idx]
+print('Current get_tree block:')
+print(block.decode('utf-8', errors='replace')[:600])

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/check_keys.py

@@ -0,0 +1,8 @@
+import json
+with open('tests/artifacts/PHASE1_AUDIT_BASELINE.json') as f:
+    data = json.load(f)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\mcp_client.py'
+findings = files[key]['findings']
+print('Sample finding keys:', list(findings[0].keys()))
+print('Sample:', findings[0])

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/commit_heuristic_e_tests.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+import subprocess
+p = Path(".git/COMMIT_EDITMSG")
+msg = """test(audit): add 3 Heuristic E regression tests (TIER1_REVIEW Phase 9 redo)
+
+3 regression tests for the new Heuristic E (narrow + structured error carrier):
+
+1. test_heuristic_e_narrow_return_errorinfo_is_compliant
+   - Asserts narrow except + return ErrorInfo(...) is classified as compliant
+   - Accepts both INTERNAL_COMPLIANT (Heuristic E) and BOUNDARY_CONVERSION
+     (existing creates_errorinfo check, fires first)
+
+2. test_heuristic_e_narrow_dict_error_true_assign_is_compliant
+   - Asserts narrow except + dict[error] = True is classified as compliant
+   - The in-band error flag pattern (per Tier 1 directive)
+
+3. test_heuristic_e_empty_default_args_is_NOT_compliant
+   - NEGATIVE test: narrow except + args = {} must NOT be classified as compliant
+   - Guards against future heuristic additions that would laundering the
+     sliming empty-default pattern (per TIER1_REVIEW)
+
+Total: 16 audit heuristic tests pass (13 existing + 3 new).
+"""
+p.write_text(msg, encoding="utf-8")
+subprocess.run(['git', 'commit', '-F', '.git/COMMIT_EDITMSG'], check=True, cwd='.')
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/commit_phase9_redo.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+import subprocess
+p = Path(".git/COMMIT_EDITMSG")
+msg = """refactor(ai_client): migrate 3 sites to Result[T] (TIER1_REVIEW Phase 9 redo)
+
+3 empty-default sites per Tier 1 directive (NOT heuristic — empty default
+is NOT a drain per error_handling.md:528-531):
+
+1. L394 set_provider (minimax branch): added _set_minimax_provider_result helper.
+   The helper returns Result[list[str], ErrorInfo] with structured errors.
+   Legacy set_provider delegates to the helper; falls back to empty key on
+   failure (preserving original behavior).
+
+2. L716+L723 _execute_tool_calls_concurrently (deepseek + minimax):
+   added _parse_tool_args_result helper that returns Result[dict, ErrorInfo].
+   The for-loop accumulates per-call errors into a local file_errors list.
+
+3. L994 _reread_file_items: added _reread_file_items_result helper that
+   returns Result[tuple, ErrorInfo]. Per TIER1_REVIEW, caller does NOT
+   check err_item["error"] flag (verified by reading _build_file_diff_text
+   and the 4 callers), so this site needed full migration (NOT heuristic).
+   Legacy function delegates to the helper and logs errors to stderr
+   (operator-visible drain).
+
+All 4 originally-UNCLEAR sites are now compliant:
+  L332, L355: BOUNDARY_CONVERSION (via existing creates_errorinfo check)
+  L394, L716, L723, L994: COMPLIANT (via Result-returning migration)
+
+Audit: ai_client UNCLEAR 6 -> 0. Total: 19 INTERNAL_COMPLIANT.
+Tests: 51 pass (28 baseline + 16 audit heuristics + 5 ai_client + 2 async_tools).
+"""
+p.write_text(msg, encoding="utf-8")
+subprocess.run(['git', 'add', 'src/ai_client.py'], check=True, cwd='.')
+subprocess.run(['git', 'commit', '-F', '.git/COMMIT_EDITMSG'], check=True, cwd='.')
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/commit_via_file.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+import subprocess
+
+p = Path(".git/COMMIT_EDITMSG")
+msg = """feat(audit): add Heuristic E + refactor L332/L355 (TIER1_REVIEW Phase 9 redo)
+
+Heuristic E: narrow + structured error carrier (per TIER1_REVIEW_phase9_dilemma_20260620):
+- except (NarrowType): return ErrorInfo(...) -> INTERNAL_COMPLIANT
+- except (NarrowType): <item>["error"] = True -> INTERNAL_COMPLIANT
+
+Distinguishes from the empty-default pattern (args = {}, body = ...) which
+is explicitly NOT a drain per error_handling.md:528-531.
+
+Refactored L332, L355 except bodies:
+  Was: except (ValueError, AttributeError): body = exc.response.text
+  Now: except (ValueError, AttributeError) as e: return ErrorInfo(...)
+
+The function still returns ErrorInfo either way. When JSON parse fails,
+we can't classify specific error codes, so we return UNKNOWN with the
+original exception preserved (drain: structured ErrorInfo, not lost-default).
+
+Added 2 helper methods:
+  _has_errorinfo_return(stmts) -> bool
+  _has_dict_error_true_assign(stmts) -> bool
+
+Tests: 41 pass (28 baseline + 13 audit heuristics including the original 8).
+
+Audit: ai_client UNCLEAR 6 -> 4 (L332+L355 now BOUNDARY_CONVERSION).
+Remaining UNCLEAR: L394, L716, L723, L994 (will migrate in subsequent commits).
+"""
+p.write_text(msg, encoding="utf-8")
+subprocess.run(['git', 'commit', '-F', '.git/COMMIT_EDITMSG'], check=True, cwd='.')
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/find_get_tree.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+
+# Find and replace the get_tree function
+OLD = (b'def get_tree(path: str, max_depth: int = 2) -> str:\r\n'
+       b' """Returns a directory structure up to a max depth."""\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err: return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.is_dir(): return f"ERROR: not a directory: {path}"\r\n')
+
+# Find where it ends
+idx = raw.find(OLD)
+if idx < 0:
+    print("OLD start NOT FOUND")
+else:
+    # Find the next def after this
+    next_def = raw.find(b'\r\n\r\ndef ', idx)
+    if next_def < 0:
+        print("END NOT FOUND")
+    else:
+        print(f"OLD at {idx}, next def at {next_def}")
+        # Print the bytes between
+        block = raw[idx:next_def]
+        print(f"Block length: {len(block)}")
+        # Show last 200 bytes of block
+        print("END of block:")
+        print(block[-200:].decode('utf-8', errors='replace'))
+
+p.write_bytes(raw)

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/fix_get_ui_performance.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+# Find broken block
+broken_idx = raw.find(b'"""')
+# Search for "Thin wrapper over get_ui_performance_result"
+target = b'Thin wrapper over get_ui_performance_result; the legacy str shape is'
+idx = raw.find(target)
+print(f"idx: {idx}")
+# Show context
+print(raw[idx-100:idx+200].decode('utf-8', errors='replace'))
+# Fix: insert blank line between """ and "Thin wrapper"
+fixed = raw.replace(
+    b' """\r\n Thin wrapper over get_ui_performance_result',
+    b' """\r\n\r\n Thin wrapper over get_ui_performance_result'
+)
+assert fixed != raw, "no change"
+p.write_bytes(fixed)
+print("Fixed")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/fix_indent.py

@@ -0,0 +1,15 @@
+"""Fix _parse_search_response_result indentation."""
+with open('src/rag_engine.py', 'rb') as f:
+    content = f.read()
+
+old = b' def _parse_search_response_result'
+new = b'def _parse_search_response_result'
+if old in content:
+    content = content.replace(old, new)
+    print('replaced')
+else:
+    print('not found')
+
+with open('src/rag_engine.py', 'wb') as f:
+    f.write(content)
+print('saved')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/fix_search_indent.py

@@ -0,0 +1,26 @@
+"""Fix _search_mcp indentation (was at column 0; should be at 1-space class method)."""
+with open('src/rag_engine.py', 'rb') as f:
+    content = f.read()
+
+# Find and fix _search_mcp
+old = b'def _search_mcp(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:\r\n  async def _async_search_mcp()'
+new = b' def _search_mcp(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:\r\n  async def _async_search_mcp()'
+
+if old in content:
+    content = content.replace(old, new)
+    print('replaced _search_mcp def')
+else:
+    print('_search_mcp def NOT FOUND')
+
+# Also fix search
+old2 = b'def search(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:\r\n  """'
+new2 = b' def search(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:\r\n  """'
+if old2 in content:
+    content = content.replace(old2, new2)
+    print('replaced search def')
+else:
+    print('search def NOT FOUND')
+
+with open('src/rag_engine.py', 'wb') as f:
+    f.write(content)
+print('saved')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/fix_third_heuristic_e_test.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+p = Path("tests/test_audit_heuristics.py")
+content = p.read_text(encoding="utf-8")
+
+# The third test has try nested in a for loop; _find_handler requires top-level try.
+# Restructure: extract the inner content into a helper function so the try is at top level.
+content = content.replace(
+'''def test_heuristic_e_empty_default_args_is_NOT_compliant():
+ """Phase 9 redo: narrow except + args = {} is NOT a drain (sliming).
+
+ Per TIER1_REVIEW: the empty-default pattern loses error context. The
+ caller cannot distinguish success from failure. Heuristic E
+ explicitly does NOT match this pattern (this test is a regression
+ guard against future "helpful" heuristic additions that would
+ laundering this sliming pattern).
+ """
+ src = (
+  "def _execute_tool_calls_concurrently(calls):\\n"
+  " for fc in calls:\\n"
+  "  try:\\n"
+  "   args = json.loads(tool_args_str)\\n"
+  "  except (ValueError, TypeError):\\n"
+  "   args = {}\\n"
+ )
+ visitor = _make_visitor(src, "_execute_tool_calls_concurrently")
+ try_node = _find_handler(visitor)
+ handler = try_node.handlers[0]
+ category, hint = visitor._classify_except(handler, try_node)
+ # The site is narrow + non-broad but the body is empty-default.
+ # Heuristic E should NOT classify as COMPLIANT. May be INTERNAL_BROAD_CATCH
+ # (no drain) or UNCLEAR. NOT INTERNAL_COMPLIANT.
+ assert category not in ("INTERNAL_COMPLIANT", "BOUNDARY_CONVERSION"), (
+  f"Heuristic E regression: narrow except + args = {{}} (empty default) "
+  f"must NOT be classified as compliant (INTERNAL_COMPLIANT or BOUNDARY_CONVERSION "
+  f"would be sliming per TIER1_REVIEW). Got {category} which would laundering the pattern. Hint: {hint}"
+ )''',
+'''def test_heuristic_e_empty_default_args_is_NOT_compliant():
+ """Phase 9 redo: narrow except + args = {} is NOT a drain (sliming).
+
+ Per TIER1_REVIEW: the empty-default pattern loses error context. The
+ caller cannot distinguish success from failure. Heuristic E
+ explicitly does NOT match this pattern (this test is a regression
+ guard against future "helpful" heuristic additions that would
+ laundering this sliming pattern).
+
+ Structure: extract into a helper function so the try is at the top
+ level of the function body (required by _find_handler test helper).
+ """
+ src = (
+  "def _parse_tool_args(tool_args_str):\\n"
+  " try:\\n"
+  "  args = json.loads(tool_args_str)\\n"
+  " except (ValueError, TypeError):\\n"
+  "  args = {}\\n"
+  " return args\\n"
+ )
+ visitor = _make_visitor(src, "_parse_tool_args")
+ try_node = _find_handler(visitor)
+ handler = try_node.handlers[0]
+ category, hint = visitor._classify_except(handler, try_node)
+ # The site is narrow + non-broad but the body is empty-default.
+ # Heuristic E should NOT classify as COMPLIANT. May be INTERNAL_BROAD_CATCH
+ # (no drain) or UNCLEAR. NOT INTERNAL_COMPLIANT or BOUNDARY_CONVERSION.
+ assert category not in ("INTERNAL_COMPLIANT", "BOUNDARY_CONVERSION"), (
+  f"Heuristic E regression: narrow except + args = {{}} (empty default) "
+  f"must NOT be classified as compliant (INTERNAL_COMPLIANT or BOUNDARY_CONVERSION "
+  f"would be sliming per TIER1_REVIEW). Got {category} which would laundering the pattern. Hint: {hint}"
+ )''')
+
+p.write_text(content, encoding="utf-8")
+print("Restructured empty-default test")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_ai_batches.py

@@ -0,0 +1,10 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\ai_client.py'
+findings = files[key]['findings']
+bc_sites = sorted([f for f in findings if f['category'] == 'INTERNAL_BROAD_CATCH'], key=lambda x: x['line'])
+print('ai_client INTERNAL_BROAD_CATCH sites (17 total):')
+for i, s in enumerate(bc_sites, 1):
+    print(f'  {i:2d}. L{s["line"]:5d}  ctx={s.get("context", "?")!r}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_batch_a.py

@@ -0,0 +1,24 @@
+import json
+
+with open('tests/artifacts/PHASE1_AUDIT_BASELINE.json') as f:
+    data = json.load(f)
+
+files = {f['filename']: f for f in data['files']}
+key = 'src\\mcp_client.py'
+findings = files[key]['findings']
+
+bc_sites = sorted([f for f in findings if f['category'] == 'INTERNAL_BROAD_CATCH'], key=lambda x: x['line'])
+print('mcp_client INTERNAL_BROAD_CATCH sites (40 total):')
+for i, s in enumerate(bc_sites, 1):
+    ctx = s.get('context', '?')
+    print(f'  {i:2d}. L{s["line"]:5d}  ctx={ctx!r}')
+
+print()
+print('First 8 = Batch A:')
+for s in bc_sites[:8]:
+    print(f'  L{s["line"]:5d}  ctx={s.get("context", "?")!r}')
+
+print()
+print('Next 8 = Batch B (sites 9-16):')
+for s in bc_sites[8:16]:
+    print(f'  L{s["line"]:5d}  ctx={s.get("context", "?")!r}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_batch_c.py

@@ -0,0 +1,10 @@
+import json
+with open('tests/artifacts/PHASE1_AUDIT_BASELINE.json') as f:
+    data = json.load(f)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\mcp_client.py'
+findings = files[key]['findings']
+bc_sites = sorted([f for f in findings if f['category'] == 'INTERNAL_BROAD_CATCH'], key=lambda x: x['line'])
+print('Original BC sites 17-24 (sites 17-24 = Batch C):')
+for i, s in enumerate(bc_sites[16:24], 17):
+    print(f'  {i:2d}. L{s["line"]:5d}  ctx={s.get("context", "?")!r}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_phase10_sites.py

@@ -0,0 +1,16 @@
+"""List the 9 ai_client Batch B INTERNAL_BROAD_CATCH sites with line numbers + context."""
+import json
+import subprocess
+
+result = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(result.stdout)
+for f in data['files']:
+    if f['filename'].endswith('ai_client.py'):
+        bc = [x for x in f['findings'] if x['category'] == 'INTERNAL_BROAD_CATCH']
+        print(f'ai_client BC count: {len(bc)}')
+        for x in bc:
+            ctx = (x.get('context') or '')[:80]
+            print(f"  L{x['line']} ctx={ctx}")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_phase11_sites.py

@@ -0,0 +1,16 @@
+"""Phase 11: enumerate the 11 ai_client SS sites."""
+import json
+import subprocess
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if f['filename'].endswith('ai_client.py'):
+        ss = [x for x in f['findings'] if x['category'] == 'INTERNAL_SILENT_SWALLOW']
+        print(f'ai_client SS count: {len(ss)}')
+        for i, x in enumerate(ss, 1):
+            ctx = (x.get('context') or '')[:60]
+            print(f"  site {i}: L{x['line']} ctx={ctx}")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_phase12_sites.py

@@ -0,0 +1,16 @@
+"""Phase 12: detailed audit per site."""
+import json
+import subprocess
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if f['filename'].endswith('ai_client.py'):
+        rethrow = [x for x in f['findings'] if x['category'] == 'INTERNAL_RETHROW']
+        print(f'ai_client RETHROW count: {len(rethrow)}')
+        for x in rethrow:
+            ctx = (x.get('context') or '')[:60]
+            print(f"  L{x['line']} ctx={ctx}")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_phase13_detail.py

@@ -0,0 +1,17 @@
+"""Detail Phase 13 sites."""
+import json
+import subprocess
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if f['filename'].endswith('rag_engine.py'):
+        for cat in ('INTERNAL_BROAD_CATCH', 'INTERNAL_SILENT_SWALLOW', 'INTERNAL_RETHROW'):
+            sites = [x for x in f['findings'] if x['category'] == cat]
+            for x in sites:
+                kind = x.get('kind', '?')
+                line = x.get('line', '?')
+                print(f'{cat} L{line} kind={kind}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_phase13_detailed.py

@@ -0,0 +1,18 @@
+"""Phase 13: detailed site info."""
+import json
+import subprocess
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if f['filename'].endswith('rag_engine.py'):
+        for cat in ('INTERNAL_BROAD_CATCH', 'INTERNAL_SILENT_SWALLOW', 'INTERNAL_RETHROW'):
+            sites = [x for x in f['findings'] if x['category'] == cat]
+            for x in sites:
+                print(f'{cat} L{x["line"]}')
+                print(f'  ctx: {(x.get("context") or "")[:80]}')
+                print(f'  exc: {x.get("exception_types", [])}')
+                print(f'  message: {x.get("message", "")[:80]}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_phase13_sites.py

@@ -0,0 +1,18 @@
+"""Phase 13: enumerate rag_engine sites by category."""
+import json
+import subprocess
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if f['filename'].endswith('rag_engine.py'):
+        for cat in ('INTERNAL_BROAD_CATCH', 'INTERNAL_SILENT_SWALLOW', 'INTERNAL_RETHROW', 'UNCLEAR'):
+            sites = [x for x in f['findings'] if x['category'] == cat]
+            if sites:
+                print(f'rag_engine {cat}: {len(sites)} sites')
+                for x in sites:
+                    ctx = (x.get('context') or '')[:60]
+                    print(f"  L{x['line']} ctx={ctx}")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_phase8_sites.py

@@ -0,0 +1,23 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if 'mcp_client' in f['filename']:
+        from collections import Counter
+        cats = Counter(x['category'] for x in f['findings'])
+        print('mcp_client categories:')
+        for c, n in sorted(cats.items()):
+            print(f'  ' + c + ': ' + str(n))
+        # Show migration sites
+        print()
+        print('INTERNAL_SILENT_SWALLOW + UNCLEAR sites:')
+        for fnd in f['findings']:
+            if fnd['category'] in ('INTERNAL_SILENT_SWALLOW', 'UNCLEAR'):
+                print('  L' + str(fnd['line']) + ' ' + fnd['category'] + ' ctx=' + repr(fnd.get('context', '?')))
+        # Show BC sites
+        print()
+        print('INTERNAL_BROAD_CATCH sites:')
+        for fnd in f['findings']:
+            if fnd['category'] == 'INTERNAL_BROAD_CATCH':
+                print('  L' + str(fnd['line']) + ' ctx=' + repr(fnd.get('context', '?')))
+        break

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/list_unclear.py

@@ -0,0 +1,16 @@
+import json, subprocess
+r = subprocess.run(['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'], capture_output=True, text=True)
+data = json.loads(r.stdout)
+files = {f['filename']: f for f in data['files']}
+key = 'src\\ai_client.py'
+findings = files[key]['findings']
+print('UNCLEAR sites in ai_client:')
+for f in findings:
+    if f['category'] == 'UNCLEAR':
+        print(f"  L{f['line']} kind={f['kind']} ctx={f.get('context', '?')!r}")
+        # Get the source line
+        with open('src/ai_client.py', 'r', encoding='utf-8') as src:
+            src_lines = src.readlines()
+            if f['line']-1 < len(src_lines):
+                print(f"    Source: {src_lines[f['line']-1].rstrip()}")
+        print()

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_ai_6_7.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+p = Path("src/ai_client.py")
+raw = p.read_bytes()
+
+# Find the deepseek/minimax pattern
+old = (b'elif provider == "deepseek":   \n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except: args = {}\n'
+       b'  elif provider == "minimax":\n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except: args = {}')
+new = (b'elif provider == "deepseek":\n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except (ValueError, TypeError): args = {}\n'
+       b'  elif provider == "minimax":\n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except (ValueError, TypeError): args = {}')
+assert old in raw, f"old block not found, count: {raw.count(b'elif provider == \"deepseek\":')}"
+raw = raw.replace(old, new)
+p.write_bytes(raw)
+print("OK: migrated 2 sites")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_ai_6_7_v2.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+p = Path("src/ai_client.py")
+raw = p.read_bytes()
+old = (b'elif provider == "deepseek":   \n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except: args = {}\n'
+       b'  elif provider == "minimax":\n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except: args = {}')
+new = (b'elif provider == "deepseek":\n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except (ValueError, TypeError): args = {}\n'
+       b'  elif provider == "minimax":\n'
+       b'   tool_info     = fc.get("function", {})\n'
+       b'   name          = cast(str, tool_info.get("name"))\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\n'
+       b'   call_id       = cast(str, fc.get("id"))\n'
+       b'   try: args     = json.loads(tool_args_str)\n'
+       b'   except (ValueError, TypeError): args = {}')
+count = raw.count(b'elif provider == "deepseek":')
+print('deepseek occurrences:', count)
+if old in raw:
+    raw = raw.replace(old, new)
+    p.write_bytes(raw)
+    print('OK: migrated 2 sites')
+else:
+    print('OLD not found, exiting')
+    # Debug: show the actual bytes around the deepseek block
+    idx = raw.find(b'elif provider == "deepseek":')
+    if idx >= 0:
+        # Print 500 bytes around this
+        print(repr(raw[idx:idx+500]))

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_ai_6_7_v3.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+p = Path("src/ai_client.py")
+raw = p.read_bytes()
+
+# Use exact byte content from the file (with trailing spaces)
+old = (b'  elif provider == "deepseek":   \r\n'
+       b'   tool_info     = fc.get("function", {})\r\n'
+       b'   name          = cast(str, tool_info.get("name"))\r\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\r\n'
+       b'   call_id       = cast(str, fc.get("id"))\r\n'
+       b'   try: args     = json.loads(tool_args_str)\r\n'
+       b'   except: args = {}\r\n'
+       b'  elif provider == "minimax":\r\n'
+       b'   tool_info     = fc.get("function", {})\r\n'
+       b'   name          = cast(str, tool_info.get("name"))\r\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\r\n'
+       b'   call_id       = cast(str, fc.get("id"))\r\n'
+       b'   try: args     = json.loads(tool_args_str)\r\n'
+       b'   except: args = {}')
+new = (b'  elif provider == "deepseek":\r\n'
+       b'   tool_info     = fc.get("function", {})\r\n'
+       b'   name          = cast(str, tool_info.get("name"))\r\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\r\n'
+       b'   call_id       = cast(str, fc.get("id"))\r\n'
+       b'   try: args     = json.loads(tool_args_str)\r\n'
+       b'   except (ValueError, TypeError): args = {}\r\n'
+       b'  elif provider == "minimax":\r\n'
+       b'   tool_info     = fc.get("function", {})\r\n'
+       b'   name          = cast(str, tool_info.get("name"))\r\n'
+       b'   tool_args_str = cast(str, tool_info.get("arguments", "{}"))\r\n'
+       b'   call_id       = cast(str, fc.get("id"))\r\n'
+       b'   try: args     = json.loads(tool_args_str)\r\n'
+       b'   except (ValueError, TypeError): args = {}')
+if old in raw:
+    raw = raw.replace(old, new)
+    p.write_bytes(raw)
+    print("OK: migrated 2 sites")
+else:
+    print("OLD not found")
+    idx = raw.find(b'elif provider == "deepseek":')
+    print(f"deepseek at idx {idx}")
+    if idx >= 0:
+        print(repr(raw[idx:idx+100]))

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_b.py

@@ -0,0 +1,453 @@
+"""Phase 4 Batch B: migrate 8 INTERNAL_BROAD_CATCH sites in mcp_client.py.
+
+Sites:
+  1. L473 get_git_diff (subprocess)
+  2. L492 ts_c_get_skeleton (ASTParser)
+  3. L509 ts_c_get_code_outline (ASTParser)
+  4. L523 ts_c_get_definition (ASTParser)
+  5. L537 ts_c_get_signature (ASTParser)
+  6. L555 ts_c_update_definition (ASTParser)
+  7. L576 ts_cpp_get_skeleton (ASTParser)
+  8. L593 ts_cpp_get_code_outline (ASTParser)
+
+Pattern: add _result variants + refactor legacy functions to delegate.
+"""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+content = p.read_text(encoding="utf-8")
+
+# ============================================================
+# Step 1: Add _result variants inside the Result Variants region
+# ============================================================
+
+RESULT_VARIANTS_INSERT = '''
+
+def get_git_diff_result(path: str, base_rev: str = "HEAD", head_rev: str = "") -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ cmd = ["git", "diff", base_rev]
+ if head_rev:
+  cmd.append(head_rev)
+ cmd.extend(["--", str(p)])
+ try:
+  result = subprocess.run(cmd, capture_output=True, text=True, check=True, encoding="utf-8")
+  return Result(data=result.stdout if result.stdout else "(no changes)")
+ except subprocess.CalledProcessError as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=f"git diff failed: {e.stderr}", source="mcp.get_git_diff_result")])
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.get_git_diff_result", original=e)])
+
+def _ast_get_skeleton(code: str, lang: str, path_str: str) -> str:
+ from src.file_cache import ASTParser
+ return ASTParser(lang).get_skeleton(code, path=path_str)
+
+def _ast_get_code_outline(code: str, lang: str, path_str: str) -> str:
+ from src.file_cache import ASTParser
+ return ASTParser(lang).get_code_outline(code, path=path_str)
+
+def _ast_get_definition(code: str, lang: str, name: str, path_str: str) -> str:
+ from src.file_cache import ASTParser
+ return ASTParser(lang).get_definition(code, name, path=path_str)
+
+def _ast_get_signature(code: str, lang: str, name: str, path_str: str) -> str:
+ from src.file_cache import ASTParser
+ return ASTParser(lang).get_signature(code, name, path=path_str)
+
+def _ast_update_definition(code: str, lang: str, name: str, new_content: str, path_str: str) -> str:
+ from src.file_cache import ASTParser
+ return ASTParser(lang).update_definition(code, name, new_content, path=path_str)
+
+def ts_c_get_skeleton_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_c_get_skeleton_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_skeleton(code, "c", str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_c_get_skeleton_result", original=e)])
+
+def ts_c_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_c_get_code_outline_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_code_outline(code, "c", str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_c_get_code_outline_result", original=e)])
+
+def ts_c_get_definition_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_c_get_definition_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_definition(code, "c", name, str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_c_get_definition_result", original=e)])
+
+def ts_c_get_signature_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_c_get_signature_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_signature(code, "c", name, str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_c_get_signature_result", original=e)])
+
+def ts_c_update_definition_result(path: str, name: str, new_content: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_c_update_definition_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  updated_code = _ast_update_definition(code, "c", name, new_content, str(p))
+  if updated_code.startswith("ERROR:"):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=updated_code, source="mcp.ts_c_update_definition_result")])
+  p.write_text(updated_code, encoding="utf-8")
+  return Result(data=f"Successfully updated definition '{name}' in {path}")
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_c_update_definition_result", original=e)])
+
+def ts_cpp_get_skeleton_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_cpp_get_skeleton_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_skeleton(code, "cpp", str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_cpp_get_skeleton_result", original=e)])
+
+def ts_cpp_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_cpp_get_code_outline_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_code_outline(code, "cpp", str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_cpp_get_code_outline_result", original=e)])
+#endregion: Result Variants'''
+
+# Insert before the "#endregion: Result Variants"
+END_REGION_MARKER = "#endregion: Result Variants"
+assert END_REGION_MARKER in content, "Result Variants region not found"
+content = content.replace(END_REGION_MARKER, RESULT_VARIANTS_INSERT, 1)
+print("Step 1: Added 8 _result variants to Result Variants region")
+
+# ============================================================
+# Step 2: Refactor each legacy function to delegate
+# ============================================================
+
+# Site 1: get_git_diff
+OLD_GIT_DIFF = '''def get_git_diff(path: str, base_rev: str = "HEAD", head_rev: str = "") -> str:
+ """
+ Returns the git diff for a file or directory.
+ base_rev: The base revision (default: HEAD)
+ head_rev: The head revision (optional)
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ cmd = ["git", "diff", base_rev]
+ if head_rev:
+  cmd.append(head_rev)
+ cmd.extend(["--", str(p)])
+ try:
+  result = subprocess.run(cmd, capture_output=True, text=True, check=True, encoding="utf-8")
+  return result.stdout if result.stdout else "(no changes)"
+ except subprocess.CalledProcessError as e:
+  return f"ERROR running git diff: {e.stderr}"
+ except Exception as e:
+  return f"ERROR: {e}"'''
+NEW_GIT_DIFF = '''def get_git_diff(path: str, base_rev: str = "HEAD", head_rev: str = "") -> str:
+ """
+ Returns the git diff for a file or directory.
+ base_rev: The base revision (default: HEAD)
+ head_rev: The head revision (optional)
+
+ Thin wrapper over get_git_diff_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = get_git_diff_result(path, base_rev, head_rev)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_GIT_DIFF in content
+content = content.replace(OLD_GIT_DIFF, NEW_GIT_DIFF)
+print("Step 2.1: Refactored get_git_diff")
+
+# Site 2: ts_c_get_skeleton
+OLD_TS_C_SKEL = '''def ts_c_get_skeleton(path: str) -> str:
+ """
+  Returns a skeleton of a C file.
+  [C: tests/test_ts_c_tools.py:test_ts_c_get_skeleton]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("c")
+  return parser.get_skeleton(code, path=str(p))
+ except Exception as e:
+  return f"ERROR generating skeleton for '{path}': {e}"'''
+NEW_TS_C_SKEL = '''def ts_c_get_skeleton(path: str) -> str:
+ """
+  Returns a skeleton of a C file.
+  [C: tests/test_ts_c_tools.py:test_ts_c_get_skeleton]
+
+ Thin wrapper over ts_c_get_skeleton_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_c_get_skeleton_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_TS_C_SKEL in content
+content = content.replace(OLD_TS_C_SKEL, NEW_TS_C_SKEL)
+print("Step 2.2: Refactored ts_c_get_skeleton")
+
+# Site 3: ts_c_get_code_outline
+OLD_TS_C_OUT = '''def ts_c_get_code_outline(path: str) -> str:
+ """
+  Returns a hierarchical outline of a C file.
+  [C: tests/test_ts_c_tools.py:test_ts_c_get_code_outline]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("c")
+  return parser.get_code_outline(code, path=str(p))
+ except Exception as e:
+  return f"ERROR generating outline for '{path}': {e}"'''
+NEW_TS_C_OUT = '''def ts_c_get_code_outline(path: str) -> str:
+ """
+  Returns a hierarchical outline of a C file.
+  [C: tests/test_ts_c_tools.py:test_ts_c_get_code_outline]
+
+ Thin wrapper over ts_c_get_code_outline_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_c_get_code_outline_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_TS_C_OUT in content
+content = content.replace(OLD_TS_C_OUT, NEW_TS_C_OUT)
+print("Step 2.3: Refactored ts_c_get_code_outline")
+
+# Site 4: ts_c_get_definition
+OLD_TS_C_DEF = '''def ts_c_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("c")
+  return parser.get_definition(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"'''
+NEW_TS_C_DEF = '''def ts_c_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C file.
+
+ Thin wrapper over ts_c_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_c_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_TS_C_DEF in content
+content = content.replace(OLD_TS_C_DEF, NEW_TS_C_DEF)
+print("Step 2.4: Refactored ts_c_get_definition")
+
+# Site 5: ts_c_get_signature
+OLD_TS_C_SIG = '''def ts_c_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function in a C file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("c")
+  return parser.get_signature(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving signature '{name}' from '{path}': {e}"'''
+NEW_TS_C_SIG = '''def ts_c_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function in a C file.
+
+ Thin wrapper over ts_c_get_signature_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_c_get_signature_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_TS_C_SIG in content
+content = content.replace(OLD_TS_C_SIG, NEW_TS_C_SIG)
+print("Step 2.5: Refactored ts_c_get_signature")
+
+# Site 6: ts_c_update_definition
+OLD_TS_C_UPD = '''def ts_c_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a function in a C file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("c")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return updated_code
+  p.write_text(updated_code, encoding="utf-8")
+  return f"Successfully updated definition '{name}' in {path}"
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"'''
+NEW_TS_C_UPD = '''def ts_c_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a function in a C file.
+
+ Thin wrapper over ts_c_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_c_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_TS_C_UPD in content
+content = content.replace(OLD_TS_C_UPD, NEW_TS_C_UPD)
+print("Step 2.6: Refactored ts_c_update_definition")
+
+# Site 7: ts_cpp_get_skeleton
+OLD_TS_CPP_SKEL = '''def ts_cpp_get_skeleton(path: str) -> str:
+ """
+  Returns a skeleton of a C++ file.
+  [C: tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_get_skeleton]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_skeleton(code, path=str(p))
+ except Exception as e:
+  return f"ERROR generating skeleton for '{path}': {e}"'''
+NEW_TS_CPP_SKEL = '''def ts_cpp_get_skeleton(path: str) -> str:
+ """
+  Returns a skeleton of a C++ file.
+  [C: tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_get_skeleton]
+
+ Thin wrapper over ts_cpp_get_skeleton_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_skeleton_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_TS_CPP_SKEL in content
+content = content.replace(OLD_TS_CPP_SKEL, NEW_TS_CPP_SKEL)
+print("Step 2.7: Refactored ts_cpp_get_skeleton")
+
+# Site 8: ts_cpp_get_code_outline
+OLD_TS_CPP_OUT = '''def ts_cpp_get_code_outline(path: str) -> str:
+ """
+  Returns a hierarchical outline of a C++ file.
+  [C: tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_get_code_outline]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_code_outline(code, path=str(p))
+ except Exception as e:
+  return f"ERROR generating outline for '{path}': {e}"'''
+NEW_TS_CPP_OUT = '''def ts_cpp_get_code_outline(path: str) -> str:
+ """
+  Returns a hierarchical outline of a C++ file.
+  [C: tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_get_code_outline]
+
+ Thin wrapper over ts_cpp_get_code_outline_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_code_outline_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_TS_CPP_OUT in content
+content = content.replace(OLD_TS_CPP_OUT, NEW_TS_CPP_OUT)
+print("Step 2.8: Refactored ts_cpp_get_code_outline")
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c.py

@@ -0,0 +1,396 @@
+"""Phase 5 Batch C: migrate 8 INTERNAL_BROAD_CATCH sites.
+
+Sites:
+  1. L610 ts_cpp_get_definition
+  2. L624 ts_cpp_get_signature
+  3. L645 ts_cpp_update_definition
+  4. L695 py_get_skeleton
+  5. L713 py_get_code_outline
+  6. L739 py_get_symbol_info
+  7. L768 py_get_definition
+  8. L788 py_update_definition
+"""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+content = p.read_text(encoding="utf-8")
+
+# Insert before "#endregion: Result Variants"
+INSERT = '''
+
+def ts_cpp_get_definition_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_cpp_get_definition_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_definition(code, "cpp", name, str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_cpp_get_definition_result", original=e)])
+
+def ts_cpp_get_signature_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_cpp_get_signature_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=_ast_get_signature(code, "cpp", name, str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_cpp_get_signature_result", original=e)])
+
+def ts_cpp_update_definition_result(path: str, name: str, new_content: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.ts_cpp_update_definition_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  updated_code = _ast_update_definition(code, "cpp", name, new_content, str(p))
+  if updated_code.startswith("ERROR:"):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=updated_code, source="mcp.ts_cpp_update_definition_result")])
+  p.write_text(updated_code, encoding="utf-8")
+  return Result(data=f"Successfully updated definition '{name}' in {path}")
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.ts_cpp_update_definition_result", original=e)])
+
+def py_get_skeleton_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_skeleton_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_skeleton(code, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_skeleton_result", original=e)])
+
+def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_code_outline(code, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])
+
+def py_get_symbol_info_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_symbol_info_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_symbol_info(code, name, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_symbol_info_result", original=e)])
+
+def py_get_definition_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_definition_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_definition(code, name, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_definition_result", original=e)])
+
+def py_update_definition_result(path: str, name: str, new_content: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_update_definition_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=updated_code, source="mcp.py_update_definition_result")])
+  p.write_text(updated_code, encoding="utf-8")
+  return Result(data=f"Successfully updated definition '{name}' in {path}")
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_update_definition_result", original=e)])
+#endregion: Result Variants'''
+
+END_REGION = "#endregion: Result Variants"
+assert END_REGION in content
+content = content.replace(END_REGION, INSERT, 1)
+print("Step 1: Added 8 _result variants")
+
+# Now refactor each legacy function. They all follow the same pattern:
+#   p, err = _resolve_and_check(path); ...; try: ...; except Exception as e: return "ERROR..."
+# We'll replace the entire legacy function bodies with the delegating wrapper.
+
+# Site 1: ts_cpp_get_definition
+content = content.replace('''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C++ file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_definition(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C++ file.
+
+ Thin wrapper over ts_cpp_get_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+# Site 2: ts_cpp_get_signature
+content = content.replace('''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a method in a C++ file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_signature(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving signature '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a method in a C++ file.
+
+ Thin wrapper over ts_cpp_get_signature_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_signature_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+# Site 3: ts_cpp_update_definition
+content = content.replace('''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function in a C++ file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return updated_code
+  p.write_text(updated_code, encoding="utf-8")
+  return f"Successfully updated definition '{name}' in {path}"
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function in a C++ file.
+
+ Thin wrapper over ts_cpp_update_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+# Site 4: py_get_skeleton
+content = content.replace('''def py_get_skeleton(path: str) -> str:
+ """
+  Get a skeleton view of a Python file.
+  [C: tests/test_py_struct_tools.py]
+ """
+ p, err = _resolve_and_check(path)
+ if err or p is None: return err
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_skeleton(code, path=str(p))
+ except Exception as e:
+  return f"ERROR generating skeleton for '{path}': {e}"''',
+'''def py_get_skeleton(path: str) -> str:
+ """
+  Get a skeleton view of a Python file.
+  [C: tests/test_py_struct_tools.py]
+
+ Thin wrapper over py_get_skeleton_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_skeleton_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+# Site 5: py_get_code_outline
+content = content.replace('''def py_get_code_outline(path: str) -> str:
+ """
+  Get a hierarchical outline of a Python file.
+  [C: tests/test_py_struct_tools.py]
+ """
+ p, err = _resolve_and_check(path)
+ if err or p is None: return err
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_code_outline(code, path=str(p))
+ except Exception as e:
+  return f"ERROR generating outline for '{path}': {e}"''',
+'''def py_get_code_outline(path: str) -> str:
+ """
+  Get a hierarchical outline of a Python file.
+  [C: tests/test_py_struct_tools.py]
+
+ Thin wrapper over py_get_code_outline_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_code_outline_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+# Site 6: py_get_symbol_info
+content = content.replace('''def py_get_symbol_info(path: str, name: str) -> str:
+ """
+  Get info about a specific symbol (class, function, method).
+  [C: tests/test_py_struct_tools.py]
+ """
+ p, err = _resolve_and_check(path)
+ if err or p is None: return err
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_symbol_info(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving symbol info for '{name}' from '{path}': {e}"''',
+'''def py_get_symbol_info(path: str, name: str) -> str:
+ """
+  Get info about a specific symbol (class, function, method).
+  [C: tests/test_py_struct_tools.py]
+
+ Thin wrapper over py_get_symbol_info_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_symbol_info_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+# Site 7: py_get_definition
+content = content.replace('''def py_get_definition(path: str, name: str) -> str:
+ """Get the full source code for a specific definition."""
+ p, err = _resolve_and_check(path)
+ if err or p is None: return err
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_definition(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def py_get_definition(path: str, name: str) -> str:
+ """Get the full source code for a specific definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+# Site 8: py_update_definition
+content = content.replace('''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function."""
+ p, err = _resolve_and_check(path)
+ if err or p is None: return err
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return updated_code
+  p.write_text(updated_code, encoding="utf-8")
+  return f"Successfully updated definition '{name}' in {path}"
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''')
+
+p.write_text(content, encoding="utf-8")
+print("OK - all 8 sites refactored")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c_binary.py

@@ -0,0 +1,325 @@
+"""Phase 5 Batch C v3: redo using binary mode to preserve CRLF."""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+content = p.read_bytes()  # binary mode preserves CRLF
+
+# Each replacement string uses CRLF line endings (\r\n).
+# We use b-strings throughout.
+
+# py_get_code_outline_result fix (was using ASTParser instead of outline_tool)
+OLD = (b'def py_get_code_outline_result(path: str) -> Result[str]:\r\n'
+       b' resolved = _resolve_and_check_result(path)\r\n'
+       b' if not resolved.ok:\r\n'
+       b'  return Result(data="", errors=resolved.errors)\r\n'
+       b' p = resolved.data\r\n'
+       b' if isinstance(p, NilPath):\r\n'
+       b'  return Result(data="", errors=resolved.errors)\r\n'
+       b' if not p.exists():\r\n'
+       b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])\r\n'
+       b' try:\r\n'
+       b'  from src.file_cache import ASTParser\r\n'
+       b'  code = p.read_text(encoding="utf-8")\r\n'
+       b'  parser = ASTParser("python")\r\n'
+       b'  return Result(data=parser.get_code_outline(code, path=str(p)))\r\n'
+       b' except Exception as e:\r\n'
+       b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])')
+NEW = (b'def py_get_code_outline_result(path: str) -> Result[str]:\r\n'
+       b' resolved = _resolve_and_check_result(path)\r\n'
+       b' if not resolved.ok:\r\n'
+       b'  return Result(data="", errors=resolved.errors)\r\n'
+       b' p = resolved.data\r\n'
+       b' if isinstance(p, NilPath):\r\n'
+       b'  return Result(data="", errors=resolved.errors)\r\n'
+       b' if not p.exists():\r\n'
+       b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])\r\n'
+       b' if not p.is_file():\r\n'
+       b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a file: {path}", source="mcp.py_get_code_outline_result")])\r\n'
+       b' try:\r\n'
+       b'  code = p.read_text(encoding="utf-8")\r\n'
+       b'  return Result(data=outline_tool.get_outline(p, code))\r\n'
+       b' except Exception as e:\r\n'
+       b'  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])')
+assert OLD in content, "py_get_code_outline_result not found"
+content = content.replace(OLD, NEW)
+print("py_get_code_outline_result fixed (outline_tool instead of ASTParser)")
+
+# Site 1: ts_cpp_get_definition
+OLD = (b'def ts_cpp_get_definition(path: str, name: str) -> str:\r\n'
+       b' """\r\n'
+       b'  Returns the source code for a specific definition in a C++ file.\r\n'
+       b'  [C: tests/test_ast_masking_core.py:test_ast_masking_gencpp_samples, tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]\r\n'
+       b' """\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err: return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists(): return f"ERROR: file not found: {path}"\r\n'
+       b' try:\r\n'
+       b'  from src.file_cache import ASTParser\r\n'
+       b'  code = p.read_text(encoding="utf-8")\r\n'
+       b'  parser = ASTParser("cpp")\r\n'
+       b'  return parser.get_definition(code, name, path=str(p))\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR retrieving definition \'{name}\' from \'{path}': {e}"')
+NEW = (b'def ts_cpp_get_definition(path: str, name: str) -> str:\r\n'
+       b' """Returns the source code for a specific definition in a C++ file.\r\n\r\n'
+       b' Thin wrapper over ts_cpp_get_definition_result; the legacy str shape\r\n'
+       b' is preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = ts_cpp_get_definition_result(path, name)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "ts_cpp_get_definition not found"
+content = content.replace(OLD, NEW)
+print("Site 1: ts_cpp_get_definition migrated")
+
+# Site 2: ts_cpp_get_signature
+OLD = (b'def ts_cpp_get_signature(path: str, name: str) -> str:\r\n'
+       b' """Returns the signature part of a function or method in a C++ file."""\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err: return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists(): return f"ERROR: file not found: {path}"\r\n'
+       b' try:\r\n'
+       b'  from src.file_cache import ASTParser\r\n'
+       b'  code = p.read_text(encoding="utf-8")\r\n'
+       b'  parser = ASTParser("cpp")\r\n'
+       b'  return parser.get_signature(code, name, path=str(p))\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR retrieving signature \'{name}\' from \'{path}\': {e}"')
+NEW = (b'def ts_cpp_get_signature(path: str, name: str) -> str:\r\n'
+       b' """Returns the signature part of a function or method in a C++ file.\r\n\r\n'
+       b' Thin wrapper over ts_cpp_get_signature_result; the legacy str shape\r\n'
+       b' is preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = ts_cpp_get_signature_result(path, name)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "ts_cpp_get_signature not found"
+content = content.replace(OLD, NEW)
+print("Site 2: ts_cpp_get_signature migrated")
+
+# Site 3: ts_cpp_update_definition
+OLD = (b'def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:\r\n'
+       b' """\r\n'
+       b'  Surgically replace the definition of a class or function in a C++ file.\r\n'
+       b'  [C: tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]\r\n'
+       b' """\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err: return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists(): return f"ERROR: file not found: {path}"\r\n'
+       b' try:\r\n'
+       b'  from src.file_cache import ASTParser\r\n'
+       b'  code = p.read_text(encoding="utf-8")\r\n'
+       b'  parser = ASTParser("cpp")\r\n'
+       b'  updated_code = parser.update_definition(code, name, new_content, path=str(p))\r\n'
+       b'  if updated_code.startswith("ERROR:"):\r\n'
+       b'   return updated_code\r\n'
+       b'  p.write_text(updated_code, encoding="utf-8")\r\n'
+       b'  return f"Successfully updated definition \'{name}\' in {path}"\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR updating definition \'{name}\' in \'{path}\': {e}"')
+NEW = (b'def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:\r\n'
+       b' """Surgically replace the definition of a class or function in a C++ file.\r\n\r\n'
+       b' Thin wrapper over ts_cpp_update_definition_result; the legacy str shape\r\n'
+       b' is preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = ts_cpp_update_definition_result(path, name, new_content)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "ts_cpp_update_definition not found"
+content = content.replace(OLD, NEW)
+print("Site 3: ts_cpp_update_definition migrated")
+
+# Site 4: py_get_skeleton
+OLD = (b'def py_get_skeleton(path: str) -> str:\r\n'
+       b' """\r\n'
+       b' Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).\r\n'
+       b' """\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err:\r\n'
+       b'  return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists():\r\n'
+       b'  return f"ERROR: file not found: {path}"\r\n'
+       b' if not p.is_file() or p.suffix != ".py":\r\n'
+       b'  return f"ERROR: not a python file: {path}"\r\n'
+       b' try:\r\n'
+       b'  from src.file_cache import ASTParser\r\n'
+       b'  code = p.read_text(encoding="utf-8")\r\n'
+       b'  parser = ASTParser("python")\r\n'
+       b'  return parser.get_skeleton(code)\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR generating skeleton for \'{path}\': {e}"')
+NEW = (b'def py_get_skeleton(path: str) -> str:\r\n'
+       b' """Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).\r\n\r\n'
+       b' Thin wrapper over py_get_skeleton_result; the legacy str shape is\r\n'
+       b' preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = py_get_skeleton_result(path)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "py_get_skeleton not found"
+content = content.replace(OLD, NEW)
+print("Site 4: py_get_skeleton migrated")
+
+# Site 5: py_get_code_outline
+OLD = (b'def py_get_code_outline(path: str) -> str:\r\n'
+       b' """\r\n'
+       b' Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).\r\n'
+       b' """\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err:\r\n'
+       b'  return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists():\r\n'
+       b'  return f"ERROR: file not found: {path}"\r\n'
+       b' if not p.is_file():\r\n'
+       b'  return f"ERROR: not a file: {path}"\r\n'
+       b' try:\r\n'
+       b'  code = p.read_text(encoding="utf-8")\r\n'
+       b'  return outline_tool.get_outline(p, code)\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR generating outline for \'{path}\': {e}"')
+NEW = (b'def py_get_code_outline(path: str) -> str:\r\n'
+       b' """Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).\r\n\r\n'
+       b' Thin wrapper over py_get_code_outline_result; the legacy str shape is\r\n'
+       b' preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = py_get_code_outline_result(path)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "py_get_code_outline not found"
+content = content.replace(OLD, NEW)
+print("Site 5: py_get_code_outline migrated")
+
+# Site 6: py_get_symbol_info
+OLD = (b'def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:\r\n'
+       b' """\r\n'
+       b'Returns (source_code, line_number) for a specific class, function, or method definition.\r\n'
+       b'If not found, returns an error string.\r\n'
+       b' """\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err:\r\n'
+       b'  return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists():\r\n'
+       b'  return f"ERROR: file not found: {path}"\r\n'
+       b' if not p.is_file():\r\n'
+       b'  return f"ERROR: not a file: {path}"\r\n'
+       b' try:\r\n'
+       b'  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))\r\n'
+       b'  lines = code.splitlines(keepends=True)\r\n'
+       b'  tree = ast.parse(code)\r\n'
+       b'  node = _get_symbol_node(tree, name)\r\n'
+       b'  if node:\r\n'
+       b'   start = cast(int, getattr(node, "lineno"))\r\n'
+       b'   end = cast(int, getattr(node, "end_lineno"))\r\n'
+       b'   return ("".join(lines[start-1:end]), start)\r\n'
+       b'  return f"ERROR: definition \'{name}\' not found in {path}"\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR retrieving definition \'{name}\' from \'{path}\': {e}"')
+NEW = (b'def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:\r\n'
+       b' """Returns (source_code, line_number) for a specific class, function, or method definition.\r\n\r\n'
+       b' Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str\r\n'
+       b' shape is preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = py_get_symbol_info_result(path, name)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "py_get_symbol_info not found"
+content = content.replace(OLD, NEW)
+print("Site 6: py_get_symbol_info migrated")
+
+# Site 7: py_get_definition
+OLD = (b'def py_get_definition(path: str, name: str) -> str:\r\n'
+       b' """\r\n'
+       b' Returns the source code for a specific class, function, or method definition.\r\n'
+       b' path: Path to the code file.\r\n'
+       b' name: Name of the definition to retrieve (e.g., \'MyClass\', \'my_function\', \'MyClass.my_method\').\r\n'
+       b' """\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err:\r\n'
+       b'  return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists():\r\n'
+       b'  return f"ERROR: file not found: {path}"\r\n'
+       b' if not p.is_file():\r\n'
+       b'  return f"ERROR: not a file: {path}"\r\n'
+       b' if p.suffix != ".py":\r\n'
+       b'  return f"ERROR: py_get_definition currently only supports .py files (unsupported: {p.suffix})"\r\n'
+       b' try:\r\n'
+       b'  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))\r\n'
+       b'  lines = code.splitlines(keepends=True)\r\n'
+       b'  tree = ast.parse(code)\r\n'
+       b'  node = _get_symbol_node(tree, name)\r\n'
+       b'  if node:\r\n'
+       b'   start = cast(int, getattr(node, "lineno")) - 1\r\n'
+       b'   end = cast(int, getattr(node, "end_lineno"))\r\n'
+       b'   return "".join(lines[start:end])\r\n'
+       b'  return f"ERROR: definition \'{name}\' not found in {path}"\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR retrieving definition \'{name}\' from \'{path}\': {e}"')
+NEW = (b'def py_get_definition(path: str, name: str) -> str:\r\n'
+       b' """Returns the source code for a specific class, function, or method definition.\r\n\r\n'
+       b' Thin wrapper over py_get_definition_result; the legacy str shape is\r\n'
+       b' preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = py_get_definition_result(path, name)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "py_get_definition not found"
+content = content.replace(OLD, NEW)
+print("Site 7: py_get_definition migrated")
+
+# Site 8: py_update_definition
+OLD = (b'def py_update_definition(path: str, name: str, new_content: str) -> str:\r\n'
+       b' """Surgically replace the definition of a class or function."""\r\n'
+       b' p, err = _resolve_and_check(path)\r\n'
+       b' if err:\r\n'
+       b'  return err\r\n'
+       b' assert p is not None\r\n'
+       b' if not p.exists():\r\n'
+       b'  return f"ERROR: file not found: {path}"\r\n'
+       b' try:\r\n'
+       b'  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))\r\n'
+       b'  tree = ast.parse(code)\r\n'
+       b'  node = _get_symbol_node(tree, name)\r\n'
+       b'  if not node:\r\n'
+       b'   return f"ERROR: could not find definition \'{name}\' in {path}"\r\n'
+       b'  start = cast(int, getattr(node, "lineno"))\r\n'
+       b'  end = cast(int, getattr(node, "end_lineno"))\r\n'
+       b'  return set_file_slice(path, start, end, new_content)\r\n'
+       b' except Exception as e:\r\n'
+       b'  return f"ERROR updating definition \'{name}\' in \'{path}\': {e}"')
+NEW = (b'def py_update_definition(path: str, name: str, new_content: str) -> str:\r\n'
+       b' """Surgically replace the definition of a class or function.\r\n\r\n'
+       b' Thin wrapper over py_update_definition_result; the legacy str shape is\r\n'
+       b' preserved for backward compatibility, but the try/except Exception\r\n'
+       b' lives in the Result variant.\r\n'
+       b' """\r\n'
+       b' resolved = py_update_definition_result(path, name, new_content)\r\n'
+       b' if resolved.ok:\r\n'
+       b'  return resolved.data\r\n'
+       b' return "; ".join(e.ui_message() for e in resolved.errors)')
+assert OLD in content, "py_update_definition not found"
+content = content.replace(OLD, NEW)
+print("Site 8: py_update_definition migrated")
+
+p.write_bytes(content)
+print("OK - file written")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c_text.py

@@ -0,0 +1,332 @@
+"""Phase 5 Batch C v4: use text mode with newline='' to preserve CRLF."""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+with open(p, 'r', encoding='utf-8', newline='') as f:
+    content = f.read()
+
+# text mode with newline='' keeps CRLF intact in the string.
+
+def replace_block(old: str, new: str, name: str) -> None:
+    global content
+    if old not in content:
+        raise AssertionError(f"{name}: NOT FOUND")
+    content = content.replace(old, new)
+    print(f"  {name}: migrated")
+
+# py_get_code_outline_result fix
+replace_block(
+'''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_code_outline(code, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])''',
+'''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ if not p.is_file():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a file: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=outline_tool.get_outline(p, code))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])''',
+'py_get_code_outline_result (fix to use outline_tool)')
+
+# Site 1: ts_cpp_get_definition
+replace_block(
+'''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """
+  Returns the source code for a specific definition in a C++ file.
+  [C: tests/test_ast_masking_core.py:test_ast_masking_gencpp_samples, tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_definition(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C++ file.
+
+ Thin wrapper over ts_cpp_get_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'ts_cpp_get_definition (Site 1)')
+
+# Site 2: ts_cpp_get_signature
+replace_block(
+'''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_signature(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving signature '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file.
+
+ Thin wrapper over ts_cpp_get_signature_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_signature_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'ts_cpp_get_signature (Site 2)')
+
+# Site 3: ts_cpp_update_definition
+replace_block(
+'''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """
+  Surgically replace the definition of a class or function in a C++ file.
+  [C: tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return updated_code
+  p.write_text(updated_code, encoding="utf-8")
+  return f"Successfully updated definition '{name}' in {path}"
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function in a C++ file.
+
+ Thin wrapper over ts_cpp_update_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'ts_cpp_update_definition (Site 3)')
+
+# Site 4: py_get_skeleton
+replace_block(
+'''def py_get_skeleton(path: str) -> str:
+ """
+ Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file() or p.suffix != ".py":
+  return f"ERROR: not a python file: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_skeleton(code)
+ except Exception as e:
+  return f"ERROR generating skeleton for '{path}': {e}"''',
+'''def py_get_skeleton(path: str) -> str:
+ """Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+
+ Thin wrapper over py_get_skeleton_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_skeleton_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_skeleton (Site 4)')
+
+# Site 5: py_get_code_outline
+replace_block(
+'''def py_get_code_outline(path: str) -> str:
+ """
+ Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  return outline_tool.get_outline(p, code)
+ except Exception as e:
+  return f"ERROR generating outline for '{path}': {e}"''',
+'''def py_get_code_outline(path: str) -> str:
+ """Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+
+ Thin wrapper over py_get_code_outline_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_code_outline_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_code_outline (Site 5)')
+
+# Site 6: py_get_symbol_info
+replace_block(
+'''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """
+Returns (source_code, line_number) for a specific class, function, or method definition.
+If not found, returns an error string.
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno"))
+   end = cast(int, getattr(node, "end_lineno"))
+   return ("".join(lines[start-1:end]), start)
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """Returns (source_code, line_number) for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str
+ shape is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_symbol_info_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_symbol_info (Site 6)')
+
+# Site 7: py_get_definition
+replace_block(
+'''def py_get_definition(path: str, name: str) -> str:
+ """
+ Returns the source code for a specific class, function, or method definition.
+ path: Path to the code file.
+ name: Name of the definition to retrieve (e.g., 'MyClass', 'my_function', 'MyClass.my_method').
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ if p.suffix != ".py":
+  return f"ERROR: py_get_definition currently only supports .py files (unsupported: {p.suffix})"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno")) - 1
+   end = cast(int, getattr(node, "end_lineno"))
+   return "".join(lines[start:end])
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def py_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_definition (Site 7)')
+
+# Site 8: py_update_definition
+replace_block(
+'''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node:
+   return f"ERROR: could not find definition '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  return set_file_slice(path, start, end, new_content)
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_update_definition (Site 8)')
+
+with open(p, 'w', encoding='utf-8', newline='') as f:
+    f.write(content)
+print("OK - file written")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c_v2.py

@@ -0,0 +1,464 @@
+"""Phase 5 Batch C: redo with actual current code.
+
+The previous script failed because the docstrings/contents didn't match.
+This script reads the actual code and applies precise replacements.
+"""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+content = p.read_text(encoding="utf-8")
+
+# First, fix the _result variants that are wrong (they used ASTParser for functions that use ast.parse directly).
+# Replace py_get_code_outline_result, py_get_symbol_info_result, py_get_definition_result, py_update_definition_result
+
+# py_get_code_outline_result: actual code uses outline_tool
+content = content.replace('''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_code_outline(code, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])''',
+'''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ if not p.is_file():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a file: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=outline_tool.get_outline(p, code))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])''')
+
+# py_get_symbol_info_result
+content = content.replace('''def py_get_symbol_info_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_symbol_info_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_symbol_info(code, name, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_symbol_info_result", original=e)])''',
+'''def py_get_symbol_info_result(path: str, name: str) -> Result[tuple[str, int]]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data=("", 0), errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data=("", 0), errors=resolved.errors)
+ if not p.exists():
+  return Result(data=("", 0), errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_symbol_info_result")])
+ if not p.is_file():
+  return Result(data=("", 0), errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a file: {path}", source="mcp.py_get_symbol_info_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno"))
+   end = cast(int, getattr(node, "end_lineno"))
+   return Result(data=("".join(lines[start-1:end]), start))
+  return Result(data=("", 0), errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"definition '{name}' not found in {path}", source="mcp.py_get_symbol_info_result")])
+ except Exception as e:
+  return Result(data=("", 0), errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_symbol_info_result", original=e)])''')
+
+# py_get_definition_result
+content = content.replace('''def py_get_definition_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_definition_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_definition(code, name, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_definition_result", original=e)])''',
+'''def py_get_definition_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_definition_result")])
+ if not p.is_file():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a file: {path}", source="mcp.py_get_definition_result")])
+ if p.suffix != ".py":
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"py_get_definition currently only supports .py files (unsupported: {p.suffix})", source="mcp.py_get_definition_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno")) - 1
+   end = cast(int, getattr(node, "end_lineno"))
+   return Result(data="".join(lines[start:end]))
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"definition '{name}' not found in {path}", source="mcp.py_get_definition_result")])
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_definition_result", original=e)])''')
+
+# py_update_definition_result
+content = content.replace('''def py_update_definition_result(path: str, name: str, new_content: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_update_definition_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=updated_code, source="mcp.py_update_definition_result")])
+  p.write_text(updated_code, encoding="utf-8")
+  return Result(data=f"Successfully updated definition '{name}' in {path}")
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_update_definition_result", original=e)])''',
+'''def py_update_definition_result(path: str, name: str, new_content: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_update_definition_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node:
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"could not find definition '{name}' in {path}", source="mcp.py_update_definition_result")])
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  inner = set_file_slice_result(path, start, end, new_content)
+  return inner
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_update_definition_result", original=e)])''')
+
+# Now refactor the legacy functions (sites 4-8 that weren't migrated in the first pass).
+# Sites 1-3 (ts_cpp_*) were also not migrated in the first pass.
+
+# Site 1: ts_cpp_get_definition (line ~871)
+OLD_CPP_DEF = '''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """
+  Returns the source code for a specific definition in a C++ file.
+  [C: tests/test_ast_masking_core.py:test_ast_masking_gencpp_samples, tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_definition(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"'''
+NEW_CPP_DEF = '''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C++ file.
+
+ Thin wrapper over ts_cpp_get_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_CPP_DEF in content, "ts_cpp_get_definition not found"
+content = content.replace(OLD_CPP_DEF, NEW_CPP_DEF)
+print("Site 1: ts_cpp_get_definition migrated")
+
+# Site 2: ts_cpp_get_signature
+OLD_CPP_SIG = '''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_signature(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving signature '{name}' from '{path}': {e}"'''
+NEW_CPP_SIG = '''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file.
+
+ Thin wrapper over ts_cpp_get_signature_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_signature_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_CPP_SIG in content, "ts_cpp_get_signature not found"
+content = content.replace(OLD_CPP_SIG, NEW_CPP_SIG)
+print("Site 2: ts_cpp_get_signature migrated")
+
+# Site 3: ts_cpp_update_definition
+OLD_CPP_UPD = '''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """
+  Surgically replace the definition of a class or function in a C++ file.
+  [C: tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return updated_code
+  p.write_text(updated_code, encoding="utf-8")
+  return f"Successfully updated definition '{name}' in {path}"
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"'''
+NEW_CPP_UPD = '''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function in a C++ file.
+
+ Thin wrapper over ts_cpp_update_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_CPP_UPD in content, "ts_cpp_update_definition not found"
+content = content.replace(OLD_CPP_UPD, NEW_CPP_UPD)
+print("Site 3: ts_cpp_update_definition migrated")
+
+# Site 4: py_get_skeleton
+OLD_PY_SKEL = '''def py_get_skeleton(path: str) -> str:
+ """
+ Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file() or p.suffix != ".py":
+  return f"ERROR: not a python file: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_skeleton(code)
+ except Exception as e:
+  return f"ERROR generating skeleton for '{path}': {e}"'''
+NEW_PY_SKEL = '''def py_get_skeleton(path: str) -> str:
+ """Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+
+ Thin wrapper over py_get_skeleton_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_skeleton_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_PY_SKEL in content, "py_get_skeleton not found"
+content = content.replace(OLD_PY_SKEL, NEW_PY_SKEL)
+print("Site 4: py_get_skeleton migrated")
+
+# Site 5: py_get_code_outline
+OLD_PY_OUT = '''def py_get_code_outline(path: str) -> str:
+ """
+ Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  return outline_tool.get_outline(p, code)
+ except Exception as e:
+  return f"ERROR generating outline for '{path}': {e}"'''
+NEW_PY_OUT = '''def py_get_code_outline(path: str) -> str:
+ """Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+
+ Thin wrapper over py_get_code_outline_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_code_outline_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_PY_OUT in content, "py_get_code_outline not found"
+content = content.replace(OLD_PY_OUT, NEW_PY_OUT)
+print("Site 5: py_get_code_outline migrated")
+
+# Site 6: py_get_symbol_info (returns tuple[str, int] | str)
+OLD_PY_SYM = '''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """
+ Returns (source_code, line_number) for a specific class, function, or method definition.
+ If not found, returns an error string.
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno"))
+   end = cast(int, getattr(node, "end_lineno"))
+   return ("".join(lines[start-1:end]), start)
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"'''
+NEW_PY_SYM = '''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """Returns (source_code, line_number) for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str
+ shape is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_symbol_info_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_PY_SYM in content, "py_get_symbol_info not found"
+content = content.replace(OLD_PY_SYM, NEW_PY_SYM)
+print("Site 6: py_get_symbol_info migrated")
+
+# Site 7: py_get_definition
+OLD_PY_DEF = '''def py_get_definition(path: str, name: str) -> str:
+ """
+ Returns the source code for a specific class, function, or method definition.
+ path: Path to the code file.
+ name: Name of the definition to retrieve (e.g., 'MyClass', 'my_function', 'MyClass.my_method').
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ if p.suffix != ".py":
+  return f"ERROR: py_get_definition currently only supports .py files (unsupported: {p.suffix})"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno")) - 1
+   end = cast(int, getattr(node, "end_lineno"))
+   return "".join(lines[start:end])
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"'''
+NEW_PY_DEF = '''def py_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_PY_DEF in content, "py_get_definition not found"
+content = content.replace(OLD_PY_DEF, NEW_PY_DEF)
+print("Site 7: py_get_definition migrated")
+
+# Site 8: py_update_definition
+OLD_PY_UPD = '''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node:
+   return f"ERROR: could not find definition '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  return set_file_slice(path, start, end, new_content)
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"'''
+NEW_PY_UPD = '''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+assert OLD_PY_UPD in content, "py_update_definition not found"
+content = content.replace(OLD_PY_UPD, NEW_PY_UPD)
+print("Site 8: py_update_definition migrated")
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c_v3.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+content = p.read_text(encoding="utf-8")
+
+# Site 6: py_get_symbol_info (correct docstring)
+OLD_PY_SYM = '''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """
+Returns (source_code, line_number) for a specific class, function, or method definition.
+If not found, returns an error string.
+ """'''
+NEW_PY_SYM = '''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """Returns (source_code, line_number) for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str
+ shape is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """'''
+assert OLD_PY_SYM in content, "py_get_symbol_info docstring not found"
+content = content.replace(OLD_PY_SYM, NEW_PY_SYM)
+print("Site 6: py_get_symbol_info migrated")
+
+# Site 7: py_get_definition (correct docstring)
+OLD_PY_DEF = '''def py_get_definition(path: str, name: str) -> str:
+ """
+ Returns the source code for a specific class, function, or method definition.
+ path: Path to the code file.
+ name: Name of the definition to retrieve (e.g., 'MyClass', 'my_function', 'MyClass.my_method').
+ """'''
+NEW_PY_DEF = '''def py_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """'''
+assert OLD_PY_DEF in content, "py_get_definition docstring not found"
+content = content.replace(OLD_PY_DEF, NEW_PY_DEF)
+print("Site 7: py_get_definition migrated")
+
+# Site 8: py_update_definition (correct docstring)
+OLD_PY_UPD = '''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function."""'''
+NEW_PY_UPD = '''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """'''
+assert OLD_PY_UPD in content, "py_update_definition docstring not found"
+content = content.replace(OLD_PY_UPD, NEW_PY_UPD)
+print("Site 8: py_update_definition migrated")
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c_v5.py

@@ -0,0 +1,332 @@
+"""Phase 5 Batch C v5: normalize CRLF<->LF, do replacements in LF mode, restore CRLF."""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+# Normalize CRLF -> LF for matching
+content = raw.decode('utf-8').replace('\r\n', '\n')
+
+def replace_block(old: str, new: str, name: str) -> None:
+    global content
+    if old not in content:
+        raise AssertionError(f"{name}: NOT FOUND")
+    content = content.replace(old, new)
+    print(f"  {name}: migrated")
+
+# py_get_code_outline_result fix
+replace_block(
+'''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_code_outline(code, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])''',
+'''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ if not p.is_file():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a file: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=outline_tool.get_outline(p, code))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])''',
+'py_get_code_outline_result (fix to use outline_tool)')
+
+# Site 1: ts_cpp_get_definition
+replace_block(
+'''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """
+  Returns the source code for a specific definition in a C++ file.
+  [C: tests/test_ast_masking_core.py:test_ast_masking_gencpp_samples, tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_definition(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C++ file.
+
+ Thin wrapper over ts_cpp_get_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'ts_cpp_get_definition (Site 1)')
+
+# Site 2: ts_cpp_get_signature
+replace_block(
+'''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_signature(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving signature '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file.
+
+ Thin wrapper over ts_cpp_get_signature_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_signature_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'ts_cpp_get_signature (Site 2)')
+
+# Site 3: ts_cpp_update_definition
+replace_block(
+'''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """
+  Surgically replace the definition of a class or function in a C++ file.
+  [C: tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return updated_code
+  p.write_text(updated_code, encoding="utf-8")
+  return f"Successfully updated definition '{name}' in {path}"
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function in a C++ file.
+
+ Thin wrapper over ts_cpp_update_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'ts_cpp_update_definition (Site 3)')
+
+# Site 4: py_get_skeleton
+replace_block(
+'''def py_get_skeleton(path: str) -> str:
+ """
+ Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file() or p.suffix != ".py":
+  return f"ERROR: not a python file: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_skeleton(code)
+ except Exception as e:
+  return f"ERROR generating skeleton for '{path}': {e}"''',
+'''def py_get_skeleton(path: str) -> str:
+ """Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+
+ Thin wrapper over py_get_skeleton_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_skeleton_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_skeleton (Site 4)')
+
+# Site 5: py_get_code_outline
+replace_block(
+'''def py_get_code_outline(path: str) -> str:
+ """
+ Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  return outline_tool.get_outline(p, code)
+ except Exception as e:
+  return f"ERROR generating outline for '{path}': {e}"''',
+'''def py_get_code_outline(path: str) -> str:
+ """Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+
+ Thin wrapper over py_get_code_outline_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_code_outline_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_code_outline (Site 5)')
+
+# Site 6: py_get_symbol_info (note: docstring has 'Returns' without leading space)
+replace_block(
+'''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """
+Returns (source_code, line_number) for a specific class, function, or method definition.
+If not found, returns an error string.
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno"))
+   end = cast(int, getattr(node, "end_lineno"))
+   return ("".join(lines[start-1:end]), start)
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """Returns (source_code, line_number) for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str
+ shape is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_symbol_info_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_symbol_info (Site 6)')
+
+# Site 7: py_get_definition
+replace_block(
+'''def py_get_definition(path: str, name: str) -> str:
+ """
+ Returns the source code for a specific class, function, or method definition.
+ path: Path to the code file.
+ name: Name of the definition to retrieve (e.g., 'MyClass', 'my_function', 'MyClass.my_method').
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ if p.suffix != ".py":
+  return f"ERROR: py_get_definition currently only supports .py files (unsupported: {p.suffix})"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno")) - 1
+   end = cast(int, getattr(node, "end_lineno"))
+   return "".join(lines[start:end])
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def py_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_get_definition (Site 7)')
+
+# Site 8: py_update_definition
+replace_block(
+'''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node:
+   return f"ERROR: could not find definition '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  return set_file_slice(path, start, end, new_content)
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)''',
+'py_update_definition (Site 8)')
+
+# Restore CRLF
+content_crlf = content.replace('\n', '\r\n')
+p.write_bytes(content_crlf.encode('utf-8'))
+print("OK - file written")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c_v6.py

@@ -0,0 +1,327 @@
+"""Phase 5 Batch C v6: incremental write after each site."""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+
+def load() -> str:
+    return p.read_bytes().decode('utf-8').replace('\r\n', '\n')
+
+def save(content: str) -> None:
+    p.write_bytes(content.replace('\n', '\r\n').encode('utf-8'))
+
+def replace_block(content: str, old: str, new: str, name: str) -> str:
+    if old not in content:
+        raise AssertionError(f"{name}: NOT FOUND (string has {len(old)} chars)")
+    return content.replace(old, new)
+
+# Migrate one site at a time, write after each, so partial progress is preserved
+sites = []
+
+# Site 0: py_get_code_outline_result fix
+sites.append(('py_get_code_outline_result fix', '''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return Result(data=parser.get_code_outline(code, path=str(p)))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])''',
+'''def py_get_code_outline_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_code_outline_result")])
+ if not p.is_file():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a file: {path}", source="mcp.py_get_code_outline_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  return Result(data=outline_tool.get_outline(p, code))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_code_outline_result", original=e)])'''))
+
+# Site 1: ts_cpp_get_definition
+sites.append(('Site 1 ts_cpp_get_definition', '''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """
+  Returns the source code for a specific definition in a C++ file.
+  [C: tests/test_ast_masking_core.py:test_ast_masking_gencpp_samples, tests/test_gencpp_full_suite.py:test_gencpp_full_suite, tests/test_ts_cpp_tools.py:test_exhaustive_cpp_samples, tests/test_ts_cpp_tools.py:test_exhaustive_gencpp_samples, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_definition(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific definition in a C++ file.
+
+ Thin wrapper over ts_cpp_get_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Site 2: ts_cpp_get_signature
+sites.append(('Site 2 ts_cpp_get_signature', '''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  return parser.get_signature(code, name, path=str(p))
+ except Exception as e:
+  return f"ERROR retrieving signature '{name}' from '{path}': {e}"''',
+'''def ts_cpp_get_signature(path: str, name: str) -> str:
+ """Returns the signature part of a function or method in a C++ file.
+
+ Thin wrapper over ts_cpp_get_signature_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_get_signature_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Site 3: ts_cpp_update_definition
+sites.append(('Site 3 ts_cpp_update_definition', '''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """
+  Surgically replace the definition of a class or function in a C++ file.
+  [C: tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition, tests/test_ts_cpp_tools.py:test_ts_cpp_update_definition_gencpp]
+ """
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.exists(): return f"ERROR: file not found: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("cpp")
+  updated_code = parser.update_definition(code, name, new_content, path=str(p))
+  if updated_code.startswith("ERROR:"):
+   return updated_code
+  p.write_text(updated_code, encoding="utf-8")
+  return f"Successfully updated definition '{name}' in {path}"
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def ts_cpp_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function in a C++ file.
+
+ Thin wrapper over ts_cpp_update_definition_result; the legacy str shape
+ is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = ts_cpp_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Site 4: py_get_skeleton
+sites.append(('Site 4 py_get_skeleton', '''def py_get_skeleton(path: str) -> str:
+ """
+ Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file() or p.suffix != ".py":
+  return f"ERROR: not a python file: {path}"
+ try:
+  from src.file_cache import ASTParser
+  code = p.read_text(encoding="utf-8")
+  parser = ASTParser("python")
+  return parser.get_skeleton(code)
+ except Exception as e:
+  return f"ERROR generating skeleton for '{path}': {e}"''',
+'''def py_get_skeleton(path: str) -> str:
+ """Returns a skeleton of a Python file (preserving docstrings, stripping function bodies).
+
+ Thin wrapper over py_get_skeleton_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_skeleton_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Site 5: py_get_code_outline
+sites.append(('Site 5 py_get_code_outline', '''def py_get_code_outline(path: str) -> str:
+ """
+ Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  return outline_tool.get_outline(p, code)
+ except Exception as e:
+  return f"ERROR generating outline for '{path}': {e}"''',
+'''def py_get_code_outline(path: str) -> str:
+ """Returns a hierarchical outline of a code file (classes, functions, methods with line ranges).
+
+ Thin wrapper over py_get_code_outline_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_code_outline_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Site 6: py_get_symbol_info (note: docstring has 'Returns' without leading space)
+sites.append(('Site 6 py_get_symbol_info', '''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """
+Returns (source_code, line_number) for a specific class, function, or method definition.
+If not found, returns an error string.
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno"))
+   end = cast(int, getattr(node, "end_lineno"))
+   return ("".join(lines[start-1:end]), start)
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """Returns (source_code, line_number) for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str
+ shape is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_symbol_info_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Site 7: py_get_definition
+sites.append(('Site 7 py_get_definition', '''def py_get_definition(path: str, name: str) -> str:
+ """
+ Returns the source code for a specific class, function, or method definition.
+ path: Path to the code file.
+ name: Name of the definition to retrieve (e.g., 'MyClass', 'my_function', 'MyClass.my_method').
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ if p.suffix != ".py":
+  return f"ERROR: py_get_definition currently only supports .py files (unsupported: {p.suffix})"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno")) - 1
+   end = cast(int, getattr(node, "end_lineno"))
+   return "".join(lines[start:end])
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"''',
+'''def py_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Site 8: py_update_definition
+sites.append(('Site 8 py_update_definition', '''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node:
+   return f"ERROR: could not find definition '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  return set_file_slice(path, start, end, new_content)
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"''',
+'''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''))
+
+# Process each site, write after each
+for name, old, new in sites:
+    content = load()
+    try:
+        content = replace_block(content, old, new, name)
+        save(content)
+        print(f"  {name}: migrated and saved")
+    except AssertionError as e:
+        print(f"  {name}: SKIPPED ({e})")
+        # Save current state anyway (don't lose previous work)
+        save(content)
+
+print("OK - done")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_c_v7.py

@@ -0,0 +1,159 @@
+"""Phase 5 Batch C v7: fix sites 6-8 whose bodies still have try/except."""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+
+def load() -> str:
+    return p.read_bytes().decode('utf-8').replace('\r\n', '\n')
+
+def save(content: str) -> None:
+    p.write_bytes(content.replace('\n', '\r\n').encode('utf-8'))
+
+def replace_block(content: str, old: str, new: str, name: str) -> str:
+    if old not in content:
+        # Try to find a partial match for debugging
+        first_line = old.split('\n')[0]
+        if first_line in content:
+            idx = content.index(first_line)
+            print(f"  {name}: FIRST LINE found at idx {idx}; checking surrounding context")
+            print(f"  Context: {content[idx:idx+200]!r}")
+        else:
+            print(f"  {name}: FIRST LINE NOT FOUND: {first_line!r}")
+        raise AssertionError(f"{name}: NOT FOUND (string has {len(old)} chars)")
+    return content.replace(old, new)
+
+# Site 6: py_get_symbol_info - CURRENT docstring says "Thin wrapper..." but body has try/except
+OLD_SYM = '''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """Returns (source_code, line_number) for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str
+ shape is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno"))
+   end = cast(int, getattr(node, "end_lineno"))
+   return ("".join(lines[start-1:end]), start)
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"'''
+NEW_SYM = '''def py_get_symbol_info(path: str, name: str) -> tuple[str, int] | str:
+ """Returns (source_code, line_number) for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_symbol_info_result; the legacy (str, int) | str
+ shape is preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_symbol_info_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+
+# Site 7: py_get_definition
+OLD_DEF = '''def py_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ if not p.is_file():
+  return f"ERROR: not a file: {path}"
+ if p.suffix != ".py":
+  return f"ERROR: py_get_definition currently only supports .py files (unsupported: {p.suffix})"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if node:
+   start = cast(int, getattr(node, "lineno")) - 1
+   end = cast(int, getattr(node, "end_lineno"))
+   return "".join(lines[start:end])
+  return f"ERROR: definition '{name}' not found in {path}"
+ except Exception as e:
+  return f"ERROR retrieving definition '{name}' from '{path}': {e}"'''
+NEW_DEF = '''def py_get_definition(path: str, name: str) -> str:
+ """Returns the source code for a specific class, function, or method definition.
+
+ Thin wrapper over py_get_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_definition_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+
+# Site 8: py_update_definition
+OLD_UPD = '''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node:
+   return f"ERROR: could not find definition '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  return set_file_slice(path, start, end, new_content)
+ except Exception as e:
+  return f"ERROR updating definition '{name}' in '{path}': {e}"'''
+NEW_UPD = '''def py_update_definition(path: str, name: str, new_content: str) -> str:
+ """Surgically replace the definition of a class or function.
+
+ Thin wrapper over py_update_definition_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_update_definition_result(path, name, new_content)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+
+content = load()
+content = replace_block(content, OLD_SYM, NEW_SYM, 'Site 6 py_get_symbol_info')
+save(content)
+print("Site 6 saved")
+
+content = load()
+content = replace_block(content, OLD_DEF, NEW_DEF, 'Site 7 py_get_definition')
+save(content)
+print("Site 7 saved")
+
+content = load()
+content = replace_block(content, OLD_UPD, NEW_UPD, 'Site 8 py_update_definition')
+save(content)
+print("Site 8 saved")
+
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_d.py

@@ -0,0 +1,595 @@
+"""Phase 6 Batch D: migrate 8 INTERNAL_BROAD_CATCH sites.
+
+Sites:
+  1. L1024 py_get_signature
+  2. L1049 py_set_signature
+  3. L1078 py_get_class_summary
+  4. L1099 py_get_var_declaration
+  5. L1119 py_set_var_declaration
+  6. L1157 py_find_usages
+  7. L1180 py_get_imports
+  8. L1195 py_check_syntax
+"""
+from pathlib import Path
+
+p = Path("src/mcp_client.py")
+
+def load() -> str:
+    return p.read_bytes().decode('utf-8').replace('\r\n', '\n')
+
+def save(content: str) -> None:
+    p.write_bytes(content.replace('\n', '\r\n').encode('utf-8'))
+
+def replace_one(content: str, old: str, new: str, name: str) -> str:
+    if old not in content:
+        raise AssertionError(f"{name}: NOT FOUND")
+    return content.replace(old, new)
+
+# 1. py_get_signature_result + py_get_signature legacy
+SIG_RESULT = '''def py_get_signature_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_signature_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"could not find function/method '{name}' in {path}", source="mcp.py_get_signature_result")])
+  start = cast(int, getattr(node, "lineno")) - 1
+  body_start = cast(int, getattr(node.body[0], "lineno")) - 1
+  sig = "".join(lines[start:body_start]).rstrip()
+  if not sig.endswith(":"):
+   for j in range(body_start, len(lines)):
+    if ":" in lines[j]:
+     full_line = lines[j]
+     colon_idx = full_line.index(":")
+     sig = "".join(lines[start:j+1])
+     return Result(data=sig[:colon_idx+1].strip())
+  return Result(data=sig)
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_signature_result", original=e)])'''
+
+SET_SIG_RESULT = '''def py_set_signature_result(path: str, name: str, new_signature: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_set_signature_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"could not find function/method '{name}' in {path}", source="mcp.py_set_signature_result")])
+  start = node.lineno
+  body_start_line = node.body[0].lineno
+  end = body_start_line - 1
+  inner = set_file_slice_result(path, start, end, new_signature)
+  return inner
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_set_signature_result", original=e)])'''
+
+CLASS_SUMMARY_RESULT = '''def py_get_class_summary_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.exists():
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"file not found: {path}", source="mcp.py_get_class_summary_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, ast.ClassDef):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"could not find class '{name}' in {path}", source="mcp.py_get_class_summary_result")])
+  lines = code.splitlines(keepends=True)
+  summary = [f"Class: {name}"]
+  doc = ast.get_docstring(node)
+  if doc:
+   summary.append(f" Docstring: {doc}")
+  for body_node in node.body:
+   if isinstance(body_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+    start = body_node.lineno - 1
+    body_start = body_node.body[0].lineno - 1
+    sig = "".join(lines[start:body_start]).strip()
+    summary.append(f"  - {sig}")
+  return Result(data="\n".join(summary))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_class_summary_result", original=e)])'''
+
+GET_VAR_RESULT = '''def py_get_var_declaration_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.is_file() or p.suffix != ".py":
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a python file: {path}", source="mcp.py_get_var_declaration_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.Assign, ast.AnnAssign)):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"could not find variable '{name}' in {path}", source="mcp.py_get_var_declaration_result")])
+  start = cast(int, getattr(node, "lineno")) - 1
+  end = cast(int, getattr(node, "end_lineno"))
+  return Result(data="".join(lines[start:end]))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_var_declaration_result", original=e)])'''
+
+SET_VAR_RESULT = '''def py_set_var_declaration_result(path: str, name: str, new_declaration: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.is_file() or p.suffix != ".py":
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a python file: {path}", source="mcp.py_set_var_declaration_result")])
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.Assign, ast.AnnAssign)):
+   return Result(data="", errors=[ErrorInfo(kind=ErrorKind.NOT_FOUND, message=f"could not find variable '{name}' in {path}", source="mcp.py_set_var_declaration_result")])
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  inner = set_file_slice_result(path, start, end, new_declaration)
+  return inner
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_set_var_declaration_result", original=e)])'''
+
+FIND_USAGES_RESULT = '''def py_find_usages_result(path: str, name: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ try:
+  import re
+  pattern = re.compile(r"\\b" + re.escape(name) + r"\\b")
+  results = []
+  def _search_file(fp: Path) -> None:
+   if fp.name == "history.toml" or fp.name.endswith("_history.toml"): return
+   if not _is_allowed(fp): return
+   try:
+    text = fp.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    for i, line in enumerate(lines, 1):
+     if pattern.search(line):
+      rel = fp.relative_to(_primary_base_dir if _primary_base_dir else Path.cwd())
+      results.append(f"{rel}:{i}: {line.strip()[:100]}")
+   except Exception:
+    pass
+  if p.is_file():
+   _search_file(p)
+  else:
+   for root, dirs, files in os.walk(p):
+    dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ('__pycache__', 'venv', 'env')]
+    for file in files:
+     if file.endswith(('.py', '.md', '.toml', '.txt', '.json')):
+      _search_file(Path(root) / file)
+  if not results:
+   return Result(data=f"No usages found for '{name}' in {p}")
+  if len(results) > 100:
+   return Result(data="\\n".join(results[:100]) + f"\\n... (and {len(results)-100} more)")
+  return Result(data="\\n".join(results))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_find_usages_result", original=e)])'''
+
+GET_IMPORTS_RESULT = '''def py_get_imports_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.is_file() or p.suffix != ".py":
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a python file: {path}", source="mcp.py_get_imports_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  tree = ast.parse(code)
+  imports = []
+  for node in tree.body:
+   if isinstance(node, ast.Import):
+    for alias in node.names:
+     imports.append(alias.name)
+   elif isinstance(node, ast.ImportFrom):
+    module = node.module or ""
+    for alias in node.names:
+     imports.append(f"{module}.{alias.name}" if module else alias.name)
+  if not imports:
+   return Result(data="No imports found.")
+  return Result(data="Imports:\\n" + "\\n".join(f"  - {i}" for i in imports))
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_get_imports_result", original=e)])'''
+
+CHECK_SYNTAX_RESULT = '''def py_check_syntax_result(path: str) -> Result[str]:
+ resolved = _resolve_and_check_result(path)
+ if not resolved.ok:
+  return Result(data="", errors=resolved.errors)
+ p = resolved.data
+ if isinstance(p, NilPath):
+  return Result(data="", errors=resolved.errors)
+ if not p.is_file() or p.suffix != ".py":
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"not a python file: {path}", source="mcp.py_check_syntax_result")])
+ try:
+  code = p.read_text(encoding="utf-8")
+  ast.parse(code)
+  return Result(data=f"Syntax OK: {path}")
+ except SyntaxError as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INVALID_INPUT, message=f"SyntaxError in {path} at line {e.lineno}, offset {e.offset}: {e.msg}\\n{e.text}", source="mcp.py_check_syntax_result")])
+ except Exception as e:
+  return Result(data="", errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=str(e), source="mcp.py_check_syntax_result", original=e)])'''
+
+# Add the result variants inside the Result Variants region
+END_REGION = "#endregion: Result Variants"
+content = load()
+
+INSERT = f'''
+{SIG_RESULT}
+
+{SET_SIG_RESULT}
+
+{CLASS_SUMMARY_RESULT}
+
+{GET_VAR_RESULT}
+
+{SET_VAR_RESULT}
+
+{FIND_USAGES_RESULT}
+
+{GET_IMPORTS_RESULT}
+
+{CHECK_SYNTAX_RESULT}
+{END_REGION}'''
+
+assert END_REGION in content
+content = content.replace(END_REGION, INSERT, 1)
+save(content)
+print("Step 1: 8 _result variants added")
+
+# Now refactor the legacy functions
+# Site 1: py_get_signature
+content = load()
+OLD = '''def py_get_signature(path: str, name: str) -> str:
+ """Returns only the signature part of a function or method (def line until colon)."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+   return f"ERROR: could not find function/method '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno")) - 1
+  body_start = cast(int, getattr(node.body[0], "lineno")) - 1
+  sig = "".join(lines[start:body_start]).rstrip()
+  if not sig.endswith(":"):
+   for j in range(body_start, len(lines)):
+    if ":" in lines[j]:
+     full_line = lines[j]
+     colon_idx = full_line.index(":")
+     sig = "".join(lines[start:j+1])
+     return sig[:colon_idx+1].strip()
+  return sig
+ except Exception as e:
+  return f"ERROR retrieving signature '{name}' from '{path}': {e}"'''
+NEW = '''def py_get_signature(path: str, name: str) -> str:
+ """Returns only the signature part of a function or method (def line until colon).
+
+ Thin wrapper over py_get_signature_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_signature_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 1 py_get_signature')
+save(content)
+print("Site 1: py_get_signature migrated")
+
+# Site 2: py_set_signature
+content = load()
+OLD = '''def py_set_signature(path: str, name: str, new_signature: str) -> str:
+ """Surgically replace only the signature of a function/method."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+   return f"ERROR: could not find function/method '{name}' in {path}"
+  start = node.lineno
+  body_start_line = node.body[0].lineno
+  # We replace from start until body_start_line - 1
+  # But we must be careful about comments/docstrings between sig and body
+  # For now, we replace only the lines that contain the signature
+  end = body_start_line - 1
+  return set_file_slice(path, start, end, new_signature)
+ except Exception as e:
+  return f"ERROR updating signature '{name}' in '{path}': {e}"'''
+NEW = '''def py_set_signature(path: str, name: str, new_signature: str) -> str:
+ """Surgically replace only the signature of a function/method.
+
+ Thin wrapper over py_set_signature_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_set_signature_result(path, name, new_signature)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 2 py_set_signature')
+save(content)
+print("Site 2: py_set_signature migrated")
+
+# Site 3: py_get_class_summary
+content = load()
+OLD = '''def py_get_class_summary(path: str, name: str) -> str:
+ """Returns a summary of a class: its methods and their signatures."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.exists():
+  return f"ERROR: file not found: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, ast.ClassDef):
+   return f"ERROR: could not find class '{name}' in {path}"
+  lines = code.splitlines(keepends=True)
+  summary = [f"Class: {name}"]
+  doc = ast.get_docstring(node)
+  if doc:
+   summary.append(f" Docstring: {doc}")
+  for body_node in node.body:
+   if isinstance(body_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+    start = body_node.lineno - 1
+    body_start = body_node.body[0].lineno - 1
+    sig = "".join(lines[start:body_start]).strip()
+    summary.append(f"  - {sig}")
+  return "\\n".join(summary)
+ except Exception as e:
+  return f"ERROR summarizing class '{name}' in '{path}': {e}"'''
+NEW = '''def py_get_class_summary(path: str, name: str) -> str:
+ """Returns a summary of a class: its methods and their signatures.
+
+ Thin wrapper over py_get_class_summary_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_class_summary_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 3 py_get_class_summary')
+save(content)
+print("Site 3: py_get_class_summary migrated")
+
+# Site 4: py_get_var_declaration
+content = load()
+OLD = '''def py_get_var_declaration(path: str, name: str) -> str:
+ """Get the assignment/declaration line(s) for a module-level or class-level variable."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.is_file() or p.suffix != ".py":
+  return f"ERROR: not a python file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  lines = code.splitlines(keepends=True)
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.Assign, ast.AnnAssign)):
+   return f"ERROR: could not find variable '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno")) - 1
+  end = cast(int, getattr(node, "end_lineno"))
+  return "".join(lines[start:end])
+ except Exception as e:
+  return f"ERROR retrieving variable '{name}' from '{path}': {e}"'''
+NEW = '''def py_get_var_declaration(path: str, name: str) -> str:
+ """Get the assignment/declaration line(s) for a module-level or class-level variable.
+
+ Thin wrapper over py_get_var_declaration_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_var_declaration_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 4 py_get_var_declaration')
+save(content)
+print("Site 4: py_get_var_declaration migrated")
+
+# Site 5: py_set_var_declaration
+content = load()
+OLD = '''def py_set_var_declaration(path: str, name: str, new_declaration: str) -> str:
+ """Surgically replace a variable assignment/declaration."""
+ p, err = _resolve_and_check(path)
+ if err:
+  return err
+ assert p is not None
+ if not p.is_file() or p.suffix != ".py":
+  return f"ERROR: not a python file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8").lstrip(chr(0xFEFF))
+  tree = ast.parse(code)
+  node = _get_symbol_node(tree, name)
+  if not node or not isinstance(node, (ast.Assign, ast.AnnAssign)):
+   return f"ERROR: could not find variable '{name}' in {path}"
+  start = cast(int, getattr(node, "lineno"))
+  end = cast(int, getattr(node, "end_lineno"))
+  return set_file_slice(path, start, end, new_declaration)
+ except Exception as e:
+  return f"ERROR updating variable '{name}' in '{path}': {e}"'''
+NEW = '''def py_set_var_declaration(path: str, name: str, new_declaration: str) -> str:
+ """Surgically replace a variable assignment/declaration.
+
+ Thin wrapper over py_set_var_declaration_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_set_var_declaration_result(path, name, new_declaration)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 5 py_set_var_declaration')
+save(content)
+print("Site 5: py_set_var_declaration migrated")
+
+# Site 6: py_find_usages
+content = load()
+OLD = '''def py_find_usages(path: str, name: str) -> str:
+ """Finds exact string matches of a symbol in a given file or directory."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ try:
+  import re
+  pattern = re.compile(r"\\b" + re.escape(name) + r"\\b")
+  results = []
+  def _search_file(fp: Path) -> None:
+   if fp.name == "history.toml" or fp.name.endswith("_history.toml"): return
+   if not _is_allowed(fp): return
+   try:
+    text = fp.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    for i, line in enumerate(lines, 1):
+     if pattern.search(line):
+      rel = fp.relative_to(_primary_base_dir if _primary_base_dir else Path.cwd())
+      results.append(f"{rel}:{i}: {line.strip()[:100]}")
+   except Exception:
+    pass
+  if p.is_file():
+   _search_file(p)
+  else:
+   for root, dirs, files in os.walk(p):
+    dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ('__pycache__', 'venv', 'env')]
+    for file in files:
+     if file.endswith(('.py', '.md', '.toml', '.txt', '.json')):
+      _search_file(Path(root) / file)
+  if not results:
+   return f"No usages found for '{name}' in {p}"
+  if len(results) > 100:
+   return "\\n".join(results[:100]) + f"\\n... (and {len(results)-100} more)"
+  return "\\n".join(results)
+ except Exception as e:
+  return f"ERROR finding usages for '{name}': {e}"'''
+NEW = '''def py_find_usages(path: str, name: str) -> str:
+ """Finds exact string matches of a symbol in a given file or directory.
+
+ Thin wrapper over py_find_usages_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_find_usages_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 6 py_find_usages')
+save(content)
+print("Site 6: py_find_usages migrated")
+
+# Site 7: py_get_imports
+content = load()
+OLD = '''def py_get_imports(path: str) -> str:
+ """Parses a file's AST and returns a strict list of its dependencies."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.is_file() or p.suffix != ".py": return f"ERROR: not a python file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  tree = ast.parse(code)
+  imports = []
+  for node in tree.body:
+   if isinstance(node, ast.Import):
+    for alias in node.names:
+     imports.append(alias.name)
+   elif isinstance(node, ast.ImportFrom):
+    module = node.module or ""
+    for alias in node.names:
+     imports.append(f"{module}.{alias.name}" if module else alias.name)
+  if not imports: return "No imports found."
+  return "Imports:\\n" + "\\n".join(f"  - {i}" for i in imports)
+ except Exception as e:
+  return f"ERROR getting imports for '{path}': {e}"'''
+NEW = '''def py_get_imports(path: str) -> str:
+ """Parses a file's AST and returns a strict list of its dependencies.
+
+ Thin wrapper over py_get_imports_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_imports_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 7 py_get_imports')
+save(content)
+print("Site 7: py_get_imports migrated")
+
+# Site 8: py_check_syntax
+content = load()
+OLD = '''def py_check_syntax(path: str) -> str:
+ """Runs a quick syntax check on a Python file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.is_file() or p.suffix != ".py": return f"ERROR: not a python file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  ast.parse(code)
+  return f"Syntax OK: {path}"
+ except SyntaxError as e:
+  return f"SyntaxError in {path} at line {e.lineno}, offset {e.offset}: {e.msg}\\n{e.text}"
+ except Exception as e:
+  return f"ERROR checking syntax for '{path}': {e}"'''
+NEW = '''def py_check_syntax(path: str) -> str:
+ """Runs a quick syntax check on a Python file.
+
+ Thin wrapper over py_check_syntax_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_check_syntax_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+content = replace_one(content, OLD, NEW, 'Site 8 py_check_syntax')
+save(content)
+print("Site 8: py_check_syntax migrated")
+
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_d_v2.py

@@ -0,0 +1,132 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+content = p.read_bytes().decode('utf-8').replace('\r\n', '\n')
+
+# Site 6: py_find_usages
+OLD = '''def py_find_usages(path: str, name: str) -> str:
+ """Finds exact string matches of a symbol in a given file or directory."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ try:
+  import re
+  pattern = re.compile(r"\\b" + re.escape(name) + r"\\b")
+  results = []
+  def _search_file(fp: Path) -> None:
+   if fp.name == "history.toml" or fp.name.endswith("_history.toml"): return
+   if not _is_allowed(fp): return
+   try:
+    text = fp.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    for i, line in enumerate(lines, 1):
+     if pattern.search(line):
+      rel = fp.relative_to(_primary_base_dir if _primary_base_dir else Path.cwd())
+      results.append(f"{rel}:{i}: {line.strip()[:100]}")
+   except Exception:
+    pass
+  if p.is_file():
+   _search_file(p)
+  else:
+   for root, dirs, files in os.walk(p):
+    dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ('__pycache__', 'venv', 'env')]
+    for file in files:
+     if file.endswith(('.py', '.md', '.toml', '.txt', '.json')):
+      _search_file(Path(root) / file)
+  if not results:
+   return f"No usages found for '{name}' in {p}"
+  if len(results) > 100:
+   return "\\n".join(results[:100]) + f"\\n... (and {len(results)-100} more)"
+  return "\\n".join(results)
+ except Exception as e:
+  return f"ERROR finding usages for '{name}': {e}"'''
+NEW = '''def py_find_usages(path: str, name: str) -> str:
+ """Finds exact string matches of a symbol in a given file or directory.
+
+ Thin wrapper over py_find_usages_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_find_usages_result(path, name)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+if OLD not in content:
+    print("Site 6: NOT FOUND")
+else:
+    content = content.replace(OLD, NEW)
+    print("Site 6: py_find_usages migrated")
+
+# Site 7: py_get_imports
+OLD = '''def py_get_imports(path: str) -> str:
+ """Parses a file's AST and returns a strict list of its dependencies."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.is_file() or p.suffix != ".py": return f"ERROR: not a python file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  tree = ast.parse(code)
+  imports = []
+  for node in tree.body:
+   if isinstance(node, ast.Import):
+    for alias in node.names:
+     imports.append(alias.name)
+   elif isinstance(node, ast.ImportFrom):
+    module = node.module or ""
+    for alias in node.names:
+     imports.append(f"{module}.{alias.name}" if module else alias.name)
+  if not imports: return "No imports found."
+  return "Imports:\\n" + "\\n".join(f"  - {i}" for i in imports)
+ except Exception as e:
+  return f"ERROR getting imports for '{path}': {e}"'''
+NEW = '''def py_get_imports(path: str) -> str:
+ """Parses a file's AST and returns a strict list of its dependencies.
+
+ Thin wrapper over py_get_imports_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_get_imports_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+if OLD not in content:
+    print("Site 7: NOT FOUND")
+else:
+    content = content.replace(OLD, NEW)
+    print("Site 7: py_get_imports migrated")
+
+# Site 8: py_check_syntax
+OLD = '''def py_check_syntax(path: str) -> str:
+ """Runs a quick syntax check on a Python file."""
+ p, err = _resolve_and_check(path)
+ if err: return err
+ assert p is not None
+ if not p.is_file() or p.suffix != ".py": return f"ERROR: not a python file: {path}"
+ try:
+  code = p.read_text(encoding="utf-8")
+  ast.parse(code)
+  return f"Syntax OK: {path}"
+ except SyntaxError as e:
+  return f"SyntaxError in {path} at line {e.lineno}, offset {e.offset}: {e.msg}\\n{e.text}"
+ except Exception as e:
+  return f"ERROR checking syntax for '{path}': {e}"'''
+NEW = '''def py_check_syntax(path: str) -> str:
+ """Runs a quick syntax check on a Python file.
+
+ Thin wrapper over py_check_syntax_result; the legacy str shape is
+ preserved for backward compatibility, but the try/except Exception
+ lives in the Result variant.
+ """
+ resolved = py_check_syntax_result(path)
+ if resolved.ok:
+  return resolved.data
+ return "; ".join(e.ui_message() for e in resolved.errors)'''
+if OLD not in content:
+    print("Site 8: NOT FOUND")
+else:
+    content = content.replace(OLD, NEW)
+    print("Site 8: py_check_syntax migrated")
+
+p.write_bytes(content.replace('\n', '\r\n').encode('utf-8'))
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_batch_e_final.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+
+# web_search - simple delegation
+idx = raw.find(b'def web_search(query: str) -> str:')
+end_idx = raw.find(b'ERROR searching web', idx)
+end_idx = raw.find(b"\n", end_idx) + 1
+old_block = raw[idx:end_idx]
+NEW_BLOCK = (b'def web_search(query: str) -> str:\r\n'
+             b' """Search the web using DuckDuckGo HTML and return top results.\r\n\r\n'
+             b' Thin wrapper over web_search_result; the legacy str shape is\r\n'
+             b' preserved for backward compatibility, but the try/except Exception\r\n'
+             b' lives in the Result variant.\r\n'
+             b' """\r\n'
+             b' resolved = web_search_result(query)\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)\r\n')
+assert old_block in raw
+raw = raw.replace(old_block, NEW_BLOCK)
+print("web_search migrated")
+
+# fetch_url - simple delegation
+idx = raw.find(b'def fetch_url(url: str) -> str:')
+end_idx = raw.find(b'ERROR fetching URL', idx)
+end_idx = raw.find(b"\n", end_idx) + 1
+old_block = raw[idx:end_idx]
+NEW_BLOCK = (b'def fetch_url(url: str) -> str:\r\n'
+             b' """Fetch a URL and return its text content (stripped of HTML tags).\r\n\r\n'
+             b' Thin wrapper over fetch_url_result; the legacy str shape is\r\n'
+             b' preserved for backward compatibility, but the try/except Exception\r\n'
+             b' lives in the Result variant.\r\n'
+             b' """\r\n'
+             b' resolved = fetch_url_result(url)\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)\r\n')
+assert old_block in raw
+raw = raw.replace(old_block, NEW_BLOCK)
+print("fetch_url migrated")
+
+# get_ui_performance - simple delegation
+idx = raw.find(b'def get_ui_performance() -> str:')
+end_idx = raw.find(b'Failed to retrieve UI performance', idx)
+end_idx = raw.find(b"\n", end_idx) + 1
+old_block = raw[idx:end_idx]
+NEW_BLOCK = (b'def get_ui_performance() -> str:\r\n'
+             b' """Returns current UI performance metrics (FPS, Frame Time, CPU, Input Lag).\r\n'
+             b' [C: tests/test_mcp_perf_tool.py:test_mcp_perf_tool_retrieval]\r\n'
+             b' """\r\n'
+             b' resolved = get_ui_performance_result()\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)\r\n')
+assert old_block in raw
+raw = raw.replace(old_block, NEW_BLOCK)
+print("get_ui_performance migrated")
+
+p.write_bytes(raw)
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_fetch_url.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+idx = raw.find(b'def fetch_url(url: str) -> str:')
+end_idx = raw.find(b'ERROR fetching URL', idx)
+end_idx = raw.find(b"\n", end_idx) + 1
+old_block = raw[idx:end_idx]
+print(f"Old block length: {len(old_block)} bytes")
+
+NEW_BLOCK = (b'def fetch_url(url: str) -> str:\r\n'
+             b' """Fetch a URL and return its text content (stripped of HTML tags).\r\n\r\n'
+             b' Thin wrapper over fetch_url_result; the legacy str shape is\r\n'
+             b' preserved for backward compatibility, but the try/except Exception\r\n'
+             b' lives in the Result variant.\r\n'
+             b' """\r\n'
+             b' resolved = fetch_url_result(url)\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)\r\n')
+
+assert old_block in raw
+new_raw = raw.replace(old_block, NEW_BLOCK)
+assert new_raw != raw
+p.write_bytes(new_raw)
+print(f"OK: replaced {len(old_block)} bytes")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_fetch_url_one.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+# Find fetch_url
+idx = raw.find(b'def fetch_url(url: str) -> str:')
+end_idx = raw.find(b'def get_ui_performance', idx)
+old_block = raw[idx:end_idx]
+print(f"Old block: {len(old_block)} bytes")
+print(f"Last 100 bytes: {old_block[-100:]!r}")
+
+NEW_BLOCK = (b'def fetch_url(url: str) -> str:\r\n'
+             b' """Fetch a URL and return its text content (stripped of HTML tags).\r\n\r\n'
+             b' Thin wrapper over fetch_url_result; the legacy str shape is\r\n'
+             b' preserved for backward compatibility, but the try/except Exception\r\n'
+             b' lives in the Result variant.\r\n'
+             b' """\r\n'
+             b' resolved = fetch_url_result(url)\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)\r\n')
+
+assert old_block in raw, "old_block not found in raw"
+new_raw = raw.replace(old_block, NEW_BLOCK)
+assert new_raw != raw
+p.write_bytes(new_raw)
+print(f"OK: replaced {len(old_block)} -> {len(NEW_BLOCK)} bytes")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_get_tree.py

@@ -0,0 +1,34 @@
+import sys
+from pathlib import Path
+sys.stdout.reconfigure(encoding='utf-8')
+
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+
+OLD = (b'  return f"ERROR generating tree for \'{path}\': {e}"')
+NEW = (b'  return f"ERROR generating tree for \'{path}\': {e}"')
+assert OLD in raw
+
+# Find get_tree start
+idx = raw.find(b'def get_tree(path: str, max_depth: int = 2) -> str:')
+end_idx = raw.find(OLD, idx) + len(OLD)
+old_block = raw[idx:end_idx]
+
+NEW_BLOCK = (b'def get_tree(path: str, max_depth: int = 2) -> str:\r\n'
+             b' """Returns a directory structure up to a max depth.\r\n\r\n'
+             b' Thin wrapper over get_tree_result; the legacy str shape is\r\n'
+             b' preserved for backward compatibility, but the try/except Exception\r\n'
+             b' lives in the Result variant.\r\n'
+             b' """\r\n'
+             b' resolved = get_tree_result(path, max_depth)\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)')
+
+assert old_block not in raw, "old_block should not be in raw (it's what we extract)"
+
+new_raw = raw.replace(old_block, NEW_BLOCK)
+assert new_raw != raw, "no replacement happened"
+
+p.write_bytes(new_raw)
+print(f"OK: replaced {len(old_block)} bytes with {len(NEW_BLOCK)} bytes")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_get_tree_one.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+# Find get_tree function
+start_marker = b'def get_tree(path: str, max_depth: int = 2) -> str:'
+idx = raw.find(start_marker)
+# Find the next def or class after it
+end_idx = raw.find(b'class _DDGParser', idx)
+old_block = raw[idx:end_idx]
+print(f"Old block: {len(old_block)} bytes")
+
+# Use exact content from the file
+NEW_BLOCK = b'def get_tree(path: str, max_depth: int = 2) -> str:\r\n """Returns a directory structure up to a max depth.\r\n\r\n Thin wrapper over get_tree_result; the legacy str shape is\r\n preserved for backward compatibility, but the try/except Exception\r\n lives in the Result variant.\r\n """\r\n resolved = get_tree_result(path, max_depth)\r\n if resolved.ok:\r\n  return resolved.data\r\n return "; ".join(e.ui_message() for e in resolved.errors)\r\n'
+
+assert old_block in raw
+new_raw = raw.replace(old_block, NEW_BLOCK)
+assert new_raw != raw
+p.write_bytes(new_raw)
+print(f"OK: replaced {len(old_block)} -> {len(NEW_BLOCK)} bytes")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_get_tree_v2.py

@@ -0,0 +1,35 @@
+import sys
+from pathlib import Path
+sys.stdout.reconfigure(encoding='utf-8')
+
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+
+# Find get_tree start
+idx = raw.find(b'def get_tree(path: str, max_depth: int = 2) -> str:')
+end_marker = b"ERROR generating tree"
+end_idx = raw.find(end_marker, idx)
+# Include up to and including the "ERROR generating tree" line + 100 bytes after
+end_idx = raw.find(b"\n", end_idx) + 1
+old_block = raw[idx:end_idx]
+
+print(f"Old block length: {len(old_block)} bytes")
+print(f"Old block ends with: {old_block[-50:].decode('utf-8', errors='replace')}")
+
+NEW_BLOCK = (b'def get_tree(path: str, max_depth: int = 2) -> str:\r\n'
+             b' """Returns a directory structure up to a max depth.\r\n\r\n'
+             b' Thin wrapper over get_tree_result; the legacy str shape is\r\n'
+             b' preserved for backward compatibility, but the try/except Exception\r\n'
+             b' lives in the Result variant.\r\n'
+             b' """\r\n'
+             b' resolved = get_tree_result(path, max_depth)\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)\r\n')
+
+assert old_block in raw, "old block not in raw"
+new_raw = raw.replace(old_block, NEW_BLOCK)
+assert new_raw != raw, "no replacement happened"
+
+p.write_bytes(new_raw)
+print(f"OK: replaced {len(old_block)} bytes with {len(NEW_BLOCK)} bytes")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/migrate_get_ui_performance.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+idx = raw.find(b'def get_ui_performance() -> str:')
+end_idx = raw.find(b'Failed to retrieve UI performance', idx)
+end_idx = raw.find(b"\n", end_idx) + 1
+old_block = raw[idx:end_idx]
+print(f"Old block length: {len(old_block)} bytes")
+
+NEW_BLOCK = (b'def get_ui_performance() -> str:\r\n'
+             b' """\r\n'
+             b' Returns current UI performance metrics (FPS, Frame Time, CPU, Input Lag).\r\n'
+             b' [C: tests/test_mcp_perf_tool.py:test_mcp_perf_tool_retrieval]\r\n'
+             b' """\r\n\r\n'
+             b' Thin wrapper over get_ui_performance_result; the legacy str shape is\r\n'
+             b' preserved for backward compatibility, but the try/except Exception\r\n'
+             b' lives in the Result variant.\r\n'
+             b' resolved = get_ui_performance_result()\r\n'
+             b' if resolved.ok:\r\n'
+             b'  return resolved.data\r\n'
+             b' return "; ".join(e.ui_message() for e in resolved.errors)\r\n')
+
+assert old_block in raw
+new_raw = raw.replace(old_block, NEW_BLOCK)
+assert new_raw != raw
+p.write_bytes(new_raw)
+print(f"OK: replaced {len(old_block)} bytes")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/move_helper.py

@@ -0,0 +1,33 @@
+"""Move _parse_search_response_result from inside class to before class."""
+with open('src/rag_engine.py', 'rb') as f:
+    content = f.read()
+
+# Find the misplaced helper (def at column 0 inside class block)
+# Pattern: def _parse_search_response_result followed by body and 2 blank lines
+import re
+# Match the helper block
+pattern = rb'def _parse_search_response_result\(res_str: str\) -> Result\[List\[Dict\[str, Any\]\]\]:\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n[^\r\n]*\r\n'
+
+m = re.search(pattern, content)
+if m:
+    print(f'Found helper at offset {m.start()}-{m.end()}')
+    helper_text = m.group(0)
+    print('Helper text:')
+    print(helper_text.decode('utf-8'))
+    content = content.replace(helper_text, b'')
+    print('Removed from inside class')
+else:
+    print('Helper NOT FOUND with regex')
+
+# Add it before class RAGEngine
+marker = b'class RAGEngine:'
+if marker in content:
+    new_helper = b'def _parse_search_response_result(res_str: str) -> Result[List[Dict[str, Any]]]:\r\n """Parse the MCP rag_search response. Returns Result[List[dict]]. On JSON parse failure, returns Result(errors=[ErrorInfo]). The legacy caller returns [] on errors, preserving the original behavior."""\r\n try:\r\n  data = json.loads(res_str)\r\n except (ValueError, TypeError) as e:\r\n  return Result(\r\n   data=None,\r\n   errors=[ErrorInfo(kind=ErrorKind.INTERNAL, message=f"_search_mcp JSON parse failed: {e}", source="rag_engine._parse_search_response_result", original=e)],\r\n  )\r\n if isinstance(data, list):\r\n  return Result(data=data)\r\n if isinstance(data, dict) and "results" in data:\r\n  return Result(data=data["results"])\r\n return Result(data=[])\r\n\r\n\r\n'
+    content = content.replace(marker, new_helper + marker)
+    print('Added helper before class')
+else:
+    print('class RAGEngine NOT FOUND')
+
+with open('src/rag_engine.py', 'wb') as f:
+    f.write(content)
+print('saved')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/restore_get_ui_performance.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+p = Path("src/mcp_client.py")
+raw = p.read_bytes()
+# Find the broken function
+start_marker = b'def get_ui_performance() -> str:'
+idx = raw.find(start_marker)
+# Find the next class or def after it
+end_marker = raw.find(b'class StdioMCPServer:', idx)
+old_block = raw[idx:end_marker]
+print(f"Old block length: {len(old_block)} bytes")
+
+NEW_BLOCK = (b'def get_ui_performance() -> str:\r\n'
+             b' """Returns current UI performance metrics (FPS, Frame Time, CPU, Input Lag).\r\n'
+             b' [C: tests/test_mcp_perf_tool.py:test_mcp_perf_tool_retrieval]\r\n'
+             b' """\r\n'
+             b' if perf_monitor_callback is None:\r\n'
+             b'  return "INFO: UI Performance monitor is not available (headless/CLI mode). This tool is only functional when the Manual Slop GUI is running."\r\n'
+             b' try:\r\n'
+             b'  metrics = perf_monitor_callback()\r\n'
+             b'  metric_str = str(metrics)\r\n'
+             b'  for char in "{}":\r\n'
+             b'   metric_str = metric_str.replace(char, "")\r\n'
+             b'  return f"UI Performance Snapshot:\\n{metric_str}"\r\n'
+             b' except Exception as e:\r\n'
+             b'  return f"ERROR: Failed to retrieve UI performance: {str(e)}"\r\n')
+
+assert old_block in raw
+new_raw = raw.replace(old_block, NEW_BLOCK)
+assert new_raw != raw
+p.write_bytes(new_raw)
+print(f"OK: replaced {len(old_block)} bytes")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/summarize_audit.py

@@ -0,0 +1,18 @@
+import json
+from collections import Counter
+
+with open('tests/artifacts/PHASE1_AUDIT_BASELINE.json') as f:
+    data = json.load(f)
+
+files = {f['filename']: f for f in data['files']}
+
+for fname in ['mcp_client', 'ai_client', 'rag_engine']:
+    key = f'src\\{fname}.py'
+    if key in files:
+        findings = files[key]['findings']
+        cats = Counter(f['category'] for f in findings)
+        print(f'src/{fname}.py: total={len(findings)}')
+        for c, n in sorted(cats.items()):
+            print(f'  {c}: {n}')
+    else:
+        print(f'NOT FOUND: {key}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_heuristic_e_tests.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+p = Path("tests/test_audit_heuristics.py")
+content = p.read_text(encoding="utf-8")
+
+# Update test 1: narrow + return ErrorInfo is compliant (either INTERNAL_COMPLIANT
+# via Heuristic E, or BOUNDARY_CONVERSION via existing creates_errorinfo check - both
+# are non-violations)
+content = content.replace(
+""" assert category == "INTERNAL_COMPLIANT", (
+  f"Heuristic E regression: narrow except + return ErrorInfo(...) "
+  f"should be INTERNAL_COMPLIANT (structured error carrier); got {category}. Hint: {hint}"
+ )""",
+""" assert category in ("INTERNAL_COMPLIANT", "BOUNDARY_CONVERSION"), (
+  f"Heuristic E regression: narrow except + return ErrorInfo(...) "
+  f"should be a compliant classification (INTERNAL_COMPLIANT via Heuristic E "
+  f"or BOUNDARY_CONVERSION via existing creates_errorinfo check); got {category}. Hint: {hint}"
+ )""")
+
+# Update test 3: empty-default args should NOT be INTERNAL_COMPLIANT (already asserts !=)
+# Add additional check: should also not be INTERNAL_COMPLIANT
+content = content.replace(
+""" assert category != "INTERNAL_COMPLIANT", (
+  f"Heuristic E regression: narrow except + args = {{}} (empty default) "
+  f"must NOT be classified as INTERNAL_COMPLIANT (sliming per TIER1_REVIEW). "
+  f"Got {category} which would laundering the pattern. Hint: {hint}"
+ )""",
+""" assert category not in ("INTERNAL_COMPLIANT", "BOUNDARY_CONVERSION"), (
+  f"Heuristic E regression: narrow except + args = {{}} (empty default) "
+  f"must NOT be classified as compliant (INTERNAL_COMPLIANT or BOUNDARY_CONVERSION "
+  f"would be sliming per TIER1_REVIEW). Got {category} which would laundering the pattern. Hint: {hint}"
+ )""")
+
+p.write_text(content, encoding="utf-8")
+print("Updated heuristic E tests")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase0.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+from datetime import datetime
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+# Update last_updated
+content = content.replace(
+ 'last_updated = "2026-06-20"',
+ f'last_updated = "{datetime.now().strftime("%Y-%m-%d")}"'
+)
+
+# Update phase_0 status
+content = content.replace(
+ 'phase_0 = { status = "pending", checkpointsha = "", name = "Setup + styleguide re-read (3 tasks)" }',
+ 'phase_0 = { status = "completed", checkpointsha = "TBD", name = "Setup + styleguide re-read (3 tasks)" }'
+)
+
+# Update t0_1, t0_2, t0_3
+content = content.replace(
+ 't0_1 = { status = "pending", commit_sha = "", description = "Update conductor/tracks.md with the new track row" }',
+ 't0_1 = { status = "completed", commit_sha = "6dd41b3e", description = "Update conductor/tracks.md with the new track row" }'
+)
+content = content.replace(
+ 't0_2 = { status = "pending", commit_sha = "", description = "Tier 2 reads conductor/code_styleguides/error_handling.md end-to-end; acknowledge in commit message" }',
+ 't0_2 = { status = "completed", commit_sha = "TBD_phase0_ack", description = "Tier 2 reads conductor/code_styleguides/error_handling.md end-to-end; acknowledge in commit message" }'
+)
+content = content.replace(
+ 't0_3 = { status = "pending", commit_sha = "", description = "Phase 0 checkpoint commit; update state.toml Phase 0 status" }',
+ 't0_3 = { status = "in_progress", commit_sha = "", description = "Phase 0 checkpoint commit; update state.toml Phase 0 status" }'
+)
+
+# Update phase_0_complete
+content = content.replace(
+ 'phase_0_complete = false',
+ 'phase_0_complete = true'
+)
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase1.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+# Mark t1_1, t1_2, t1_3 as completed
+content = content.replace(
+ 't1_1 = { status = "pending", commit_sha = "", description = "Run audit --include-baseline --json > tests/artifacts/PHASE1_AUDIT_BASELINE.json" }',
+ 't1_1 = { status = "completed", commit_sha = "169a58d6", description = "Run audit --include-baseline --json > tests/artifacts/PHASE1_AUDIT_BASELINE.json" }'
+)
+content = content.replace(
+ 't1_2 = { status = "pending", commit_sha = "", description = "Walk the audit + write 3 inventory docs (mcp_client 46 rows, ai_client 33 rows, rag_engine 9 rows)" }',
+ 't1_2 = { status = "completed", commit_sha = "169a58d6", description = "Walk the audit + write 3 inventory docs (mcp_client 46 rows, ai_client 33 rows, rag_engine 9 rows)" }'
+)
+content = content.replace(
+ 't1_3 = { status = "pending", commit_sha = "", description = "Create tests/test_baseline_result.py with 4 Phase 1 invariant tests; Phase 1 checkpoint" }',
+ 't1_3 = { status = "completed", commit_sha = "169a58d6", description = "Create tests/test_baseline_result.py with 4 Phase 1 invariant tests; Phase 1 checkpoint" }'
+)
+
+# Phase 1 done
+content = content.replace(
+ 'phase_1 = { status = "pending", checkpointsha = "", name = "3-file inventory + classification (4 tasks; 88 sites in 3 inventory docs)" }',
+ 'phase_1 = { status = "completed", checkpointsha = "169a58d6", name = "3-file inventory + classification (4 tasks; 88 sites in 3 inventory docs)" }'
+)
+content = content.replace(
+ 'phase_1_complete = false',
+ 'phase_1_complete = true'
+)
+content = content.replace(
+ 'site_inventory_88_rows_total = false',
+ 'site_inventory_88_rows_total = true'
+)
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase2.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+content = content.replace(
+ 't2_1 = { status = "pending", commit_sha = "", description = "Add 3 Phase 2 invariant tests (baseline count capture per file); Phase 2 checkpoint" }',
+ 't2_1 = { status = "completed", commit_sha = "4d391fd4", description = "Add 3 Phase 2 invariant tests (baseline count capture per file); Phase 2 checkpoint" }'
+)
+content = content.replace(
+ 'phase_2 = { status = "pending", checkpointsha = "", name = "Audit gate baseline (2 tasks; 3 baseline invariant tests)" }',
+ 'phase_2 = { status = "completed", checkpointsha = "4d391fd4", name = "Audit gate baseline (2 tasks; 3 baseline invariant tests)" }'
+)
+content = content.replace('phase_2_complete = false', 'phase_2_complete = true')
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase3.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+# Mark t3_0 through t3_9 as completed (use commit SHAs from log)
+import subprocess
+log = subprocess.run(['git', 'log', '--oneline', '-15'], capture_output=True, text=True, cwd='.').stdout
+print('Last 15 commits:')
+for line in log.strip().split('\n'):
+    print(f'  {line}')
+print()
+
+# Map task to commit SHA
+# t3_0: ack commit ca67bb6 (styleguide re-read)
+# t3_1: site 1: 26371128
+# t3_2: site 2: 409ab5ae
+# t3_3: site 3: dc41cb37
+# t3_4: site 4: da9c5419
+# t3_5: site 5: 7378a697
+# t3_6: site 6: 0274f35d
+# t3_7: site 7: dc903ab3
+# t3_8: site 8: a0908f89
+# t3_9: tests + checkpoint: faa6ec6e
+
+# Apply replacements
+replacements = [
+    ('t3_0 = { status = "pending", commit_sha = "", description = "Phase 3 styleguide re-read (lines 462-540) + ack commit" }',
+     't3_0 = { status = "completed", commit_sha = "ca67bb6", description = "Phase 3 styleguide re-read (lines 462-540) + ack commit" }'),
+    ('t3_1 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 1" }',
+     't3_1 = { status = "completed", commit_sha = "26371128", description = "Migrate Batch A site 1" }'),
+    ('t3_2 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 2" }',
+     't3_2 = { status = "completed", commit_sha = "409ab5ae", description = "Migrate Batch A site 2" }'),
+    ('t3_3 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 3" }',
+     't3_3 = { status = "completed", commit_sha = "dc41cb37", description = "Migrate Batch A site 3" }'),
+    ('t3_4 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 4" }',
+     't3_4 = { status = "completed", commit_sha = "da9c5419", description = "Migrate Batch A site 4" }'),
+    ('t3_5 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 5" }',
+     't3_5 = { status = "completed", commit_sha = "7378a697", description = "Migrate Batch A site 5" }'),
+    ('t3_6 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 6" }',
+     't3_6 = { status = "completed", commit_sha = "0274f35d", description = "Migrate Batch A site 6" }'),
+    ('t3_7 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 7" }',
+     't3_7 = { status = "completed", commit_sha = "dc903ab3", description = "Migrate Batch A site 7" }'),
+    ('t3_8 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 8" }',
+     't3_8 = { status = "completed", commit_sha = "a0908f89", description = "Migrate Batch A site 8" }'),
+    ('t3_9 = { status = "pending", commit_sha = "", description = "Add Phase 3 invariant test; Phase 3 checkpoint" }',
+     't3_9 = { status = "completed", commit_sha = "faa6ec6e", description = "Add Phase 3 invariant test; Phase 3 checkpoint" }'),
+]
+
+for old, new in replacements:
+    assert old in content, f'NOT FOUND: {old[:80]}'
+    content = content.replace(old, new)
+
+# Phase 3 complete
+content = content.replace(
+    'phase_3 = { status = "pending", checkpointsha = "", name = "mcp_client Batch A (tool broad-catches; <=8 sites)" }',
+    'phase_3 = { status = "completed", checkpointsha = "faa6ec6e", name = "mcp_client Batch A (tool broad-catches; <=8 sites)" }'
+)
+content = content.replace('phase_3_complete = false', 'phase_3_complete = true')
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase4.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+replacements = [
+    ('t4_0 = { status = "pending", commit_sha = "", description = "Phase 4 styleguide re-read + ack commit" }',
+     't4_0 = { status = "completed", commit_sha = "448319f", description = "Phase 4 styleguide re-read + ack commit" }'),
+    ('t4_1 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 1" }',
+     't4_1 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 1" }'),
+    ('t4_2 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 2" }',
+     't4_2 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 2" }'),
+    ('t4_3 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 3" }',
+     't4_3 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 3" }'),
+    ('t4_4 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 4" }',
+     't4_4 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 4" }'),
+    ('t4_5 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 5" }',
+     't4_5 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 5" }'),
+    ('t4_6 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 6" }',
+     't4_6 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 6" }'),
+    ('t4_7 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 7" }',
+     't4_7 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 7" }'),
+    ('t4_8 = { status = "pending", commit_sha = "", description = "Migrate Batch B site 8" }',
+     't4_8 = { status = "completed", commit_sha = "6bb7f922", description = "Migrate Batch B site 8" }'),
+    ('t4_9 = { status = "pending", commit_sha = "", description = "Add Phase 4 invariant test; Phase 4 checkpoint" }',
+     't4_9 = { status = "completed", commit_sha = "6bb7f922", description = "Add Phase 4 invariant test; Phase 4 checkpoint" }'),
+]
+
+for old, new in replacements:
+    assert old in content, f'NOT FOUND: {old[:80]}'
+    content = content.replace(old, new)
+
+content = content.replace(
+    'phase_4 = { status = "pending", checkpointsha = "", name = "mcp_client Batch B (tool broad-catches; <=8 sites)" }',
+    'phase_4 = { status = "completed", checkpointsha = "6bb7f922", name = "mcp_client Batch B (tool broad-catches; <=8 sites)" }'
+)
+content = content.replace('phase_4_complete = false', 'phase_4_complete = true')
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase5.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+replacements = [
+    ('t5_0 = { status = "pending", commit_sha = "", description = "Phase 5 styleguide re-read + ack commit" }',
+     't5_0 = { status = "completed", commit_sha = "952d064", description = "Phase 5 styleguide re-read + ack commit" }'),
+]
+for i in range(1, 9):
+    replacements.append((f't5_{i} = {{ status = "pending", commit_sha = "", description = "Migrate Batch C site {i}" }}',
+                         f't5_{i} = {{ status = "completed", commit_sha = "b06fa638", description = "Migrate Batch C site {i}" }}'))
+replacements.append(('t5_9 = { status = "pending", commit_sha = "", description = "Add Phase 5 invariant test; Phase 5 checkpoint" }',
+                     't5_9 = { status = "completed", commit_sha = "b06fa638", description = "Add Phase 5 invariant test; Phase 5 checkpoint" }'))
+
+for old, new in replacements:
+    assert old in content, f'NOT FOUND: {old[:80]}'
+    content = content.replace(old, new)
+
+content = content.replace(
+    'phase_5 = { status = "pending", checkpointsha = "", name = "mcp_client Batch C (tool broad-catches; <=8 sites)" }',
+    'phase_5 = { status = "completed", checkpointsha = "b06fa638", name = "mcp_client Batch C (tool broad-catches; <=8 sites)" }'
+)
+content = content.replace('phase_5_complete = false', 'phase_5_complete = true')
+
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase6.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+replacements = [
+    ('t6_0 = { status = "pending", commit_sha = "", description = "Phase 6 styleguide re-read + ack commit" }',
+     't6_0 = { status = "completed", commit_sha = "3f496ca", description = "Phase 6 styleguide re-read + ack commit" }'),
+]
+for i in range(1, 9):
+    replacements.append((f't6_{i} = {{ status = "pending", commit_sha = "", description = "Migrate Batch D site {i}" }}',
+                         f't6_{i} = {{ status = "completed", commit_sha = "fa58406b", description = "Migrate Batch D site {i}" }}'))
+replacements.append(('t6_9 = { status = "pending", commit_sha = "", description = "Add Phase 6 invariant test; Phase 6 checkpoint" }',
+                     't6_9 = { status = "completed", commit_sha = "fa58406b", description = "Add Phase 6 invariant test; Phase 6 checkpoint" }'))
+
+for old, new in replacements:
+    assert old in content, f'NOT FOUND: {old[:80]}'
+    content = content.replace(old, new)
+
+content = content.replace(
+    'phase_6 = { status = "pending", checkpointsha = "", name = "mcp_client Batch D (tool broad-catches; <=8 sites)" }',
+    'phase_6 = { status = "completed", checkpointsha = "fa58406b", name = "mcp_client Batch D (tool broad-catches; <=8 sites)" }'
+)
+content = content.replace('phase_6_complete = false', 'phase_6_complete = true')
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase7.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+import subprocess
+
+# Get recent commit SHAs for Phase 7 sites
+log = subprocess.run(['git', 'log', '--oneline', '-15'], capture_output=True, text=True, cwd='.').stdout
+print("Last 15 commits:")
+for line in log.strip().split('\n'):
+    print(f'  {line}')
+
+# Phase 7 sites commit SHAs (from log)
+SITE_SHAS = {
+    't7_1': '57b67780',  # py_get_hierarchy (done in earlier batch)
+    't7_2': 'f1e571c5',  # py_get_docstring
+    't7_3': '6fd26bc9',  # derive_code_path
+    't7_4': '02a94c22',  # batch of web_search/fetch_url/get_ui_performance
+    't7_5': '2ea91854',  # get_tree
+}
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+replacements = [
+    ('t7_0 = { status = "pending", commit_sha = "", description = "Phase 7 styleguide re-read + ack commit" }',
+     't7_0 = { status = "completed", commit_sha = "69b90d9", description = "Phase 7 styleguide re-read + ack commit" }'),
+    ('t7_1 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 1" }',
+     f't7_1 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_1"]}", description = "Migrate Batch E site 1 (py_get_hierarchy)" }}'),
+    ('t7_2 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 2" }',
+     f't7_2 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_2"]}", description = "Migrate Batch E site 2 (py_get_docstring)" }}'),
+    ('t7_3 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 3" }',
+     f't7_3 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_3"]}", description = "Migrate Batch E site 3 (derive_code_path)" }}'),
+    ('t7_4 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 4" }',
+     f't7_4 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_4"]}", description = "Migrate Batch E site 4 (web_search, fetch_url, get_ui_performance)" }}'),
+    ('t7_5 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 5" }',
+     f't7_5 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_5"]}", description = "Migrate Batch E site 5 (get_tree)" }}'),
+    ('t7_6 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 6" }',
+     f't7_6 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_4"]}", description = "Migrate Batch E site 6 (web_search, combined commit)" }}'),
+    ('t7_7 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 7" }',
+     f't7_7 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_4"]}", description = "Migrate Batch E site 7 (fetch_url, combined commit)" }}'),
+    ('t7_8 = { status = "pending", commit_sha = "", description = "Migrate Batch E site 8" }',
+     f't7_8 = {{ status = "completed", commit_sha = "{SITE_SHAS["t7_4"]}", description = "Migrate Batch E site 8 (get_ui_performance, combined commit)" }}'),
+    ('t7_9 = { status = "pending", commit_sha = "", description = "Add Phase 7 invariant test; Phase 7 checkpoint" }',
+     't7_9 = { status = "completed", commit_sha = "44607f79", description = "Add Phase 7 invariant test; Phase 7 checkpoint" }'),
+]
+
+for old, new in replacements:
+    assert old in content, f'NOT FOUND: {old[:80]}'
+    content = content.replace(old, new)
+
+content = content.replace(
+    'phase_7 = { status = "pending", checkpointsha = "", name = "mcp_client Batch E (tool broad-catches; <=8 sites)" }',
+    'phase_7 = { status = "completed", checkpointsha = "44607f79", name = "mcp_client Batch E (tool broad-catches; <=8 sites)" }'
+)
+content = content.replace('phase_7_complete = false', 'phase_7_complete = true')
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase8.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+replacements = [
+    ('t8_0 = { status = "pending", commit_sha = "", description = "Phase 8 styleguide re-read (lines 462-940; AI Agent Checklist) + ack commit (CRITICAL anti-sliming)" }',
+     't8_0 = { status = "completed", commit_sha = "b037a81", description = "Phase 8 styleguide re-read (lines 462-940; AI Agent Checklist) + ack commit (CRITICAL anti-sliming)" }'),
+    ('t8_1 = { status = "pending", commit_sha = "", description = "Migrate silent-swallow site 1 (NO narrowing+logging; full Result[T] propagation)" }',
+     't8_1 = { status = "completed", commit_sha = "87f8c057", description = "Migrate silent-swallow site 1 (L171 _is_allowed -> Path.is_relative_to)" }'),
+    ('t8_2 = { status = "pending", commit_sha = "", description = "Migrate silent-swallow site 2" }',
+     't8_2 = { status = "completed", commit_sha = "e51cbd2c", description = "Migrate silent-swallow site 2 (L1661+L1666 stop -> Result-drain)" }'),
+    ('t8_3 = { status = "pending", commit_sha = "", description = "Migrate silent-swallow site 3" }',
+     't8_3 = { status = "completed", commit_sha = "e51cbd2c", description = "Migrate silent-swallow site 3 (combined with site 2 in commit e51cbd2c)" }'),
+    ('t8_4 = { status = "pending", commit_sha = "", description = "Migrate silent-swallow site 4" }',
+     't8_4 = { status = "completed", commit_sha = "e51cbd2c", description = "Migrate silent-swallow site 4 (combined with site 2 in commit e51cbd2c)" }'),
+    ('t8_5 = { status = "pending", commit_sha = "", description = "Migrate silent-swallow site 5" }',
+     't8_5 = { status = "completed", commit_sha = "e51cbd2c", description = "Migrate silent-swallow site 5 (combined with site 2 in commit e51cbd2c)" }'),
+    ('t8_6 = { status = "pending", commit_sha = "", description = "Migrate UNCLEAR site 6" }',
+     't8_6 = { status = "completed", commit_sha = "d32880c7", description = "Migrate UNCLEAR site 6 + 3 nested BC helpers" }'),
+    ('t8_7 = { status = "pending", commit_sha = "", description = "Add Phase 8 invariant test (silent_swallow_count_zero + unclear_count_zero); Phase 8 checkpoint" }',
+     't8_7 = { status = "completed", commit_sha = "dec1780", description = "Add Phase 8 invariant test (silent_swallow_count_zero + unclear_count_zero); Phase 8 checkpoint" }'),
+]
+for old, new in replacements:
+    assert old in content, f'NOT FOUND: {old[:80]}'
+    content = content.replace(old, new)
+
+content = content.replace(
+    'phase_8 = { status = "pending", checkpointsha = "", name = "mcp_client silent-swallow + UNCLEAR (5 + 1 = 6 sites; CRITICAL anti-sliming)" }',
+    'phase_8 = { status = "completed", checkpointsha = "dec1780", name = "mcp_client silent-swallow + UNCLEAR (5 + 1 = 6 sites; CRITICAL anti-sliming)" }'
+)
+content = content.replace('phase_8_complete = false', 'phase_8_complete = true')
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_phase9.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+
+replacements = [
+    ('t9_0 = { status = "pending", commit_sha = "", description = "Phase 9 styleguide re-read + ack commit" }',
+     't9_0 = { status = "completed", commit_sha = "57ae4ce", description = "Phase 9 styleguide re-read + ack commit" }'),
+    ('t9_1 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 1" }',
+     't9_1 = { status = "completed", commit_sha = "d8d50892", description = "Migrate Batch A site 1 (_classify_deepseek_error)" }'),
+    ('t9_2 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 2" }',
+     't9_2 = { status = "completed", commit_sha = "d8d50892", description = "Migrate Batch A site 2 (_classify_minimax_error, combined commit)" }'),
+    ('t9_3 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 3" }',
+     't9_3 = { status = "completed", commit_sha = "ca4a78dc", description = "Migrate Batch A site 3 (set_provider)" }'),
+    ('t9_4 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 4" }',
+     't9_4 = { status = "completed", commit_sha = "ca4a78dc", description = "Migrate Batch A site 4 (set_tool_preset, combined commit)" }'),
+    ('t9_5 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 5" }',
+     't9_5 = { status = "completed", commit_sha = "ca4a78dc", description = "Migrate Batch A site 5 (set_bias_profile, combined commit)" }'),
+    ('t9_6 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 6" }',
+     't9_6 = { status = "completed", commit_sha = "745147eb", description = "Migrate Batch A site 6 (_execute_tool_calls_concurrently deepseek)" }'),
+    ('t9_7 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 7" }',
+     't9_7 = { status = "completed", commit_sha = "745147eb", description = "Migrate Batch A site 7 (_execute_tool_calls_concurrently minimax, combined commit)" }'),
+    ('t9_8 = { status = "pending", commit_sha = "", description = "Migrate Batch A site 8" }',
+     't9_8 = { status = "completed", commit_sha = "b1482832", description = "Migrate Batch A site 8 (_reread_file_items)" }'),
+    ('t9_9 = { status = "pending", commit_sha = "", description = "Add Phase 9 invariant test; Phase 9 checkpoint" }',
+     't9_9 = { status = "completed", commit_sha = "84b7a693", description = "Add Phase 9 invariant test; Phase 9 checkpoint" }'),
+]
+
+for old, new in replacements:
+    assert old in content, f'NOT FOUND: {old[:80]}'
+    content = content.replace(old, new)
+
+content = content.replace(
+    'phase_9 = { status = "pending", checkpointsha = "", name = "ai_client Batch A (broad-catch; <=8 sites)" }',
+    'phase_9 = { status = "completed", checkpointsha = "84b7a693", name = "ai_client Batch A (broad-catch; <=8 sites)" }'
+)
+content = content.replace('phase_9_complete = false', 'phase_9_complete = true')
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_t0_2.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+content = content.replace(
+ 't0_2 = { status = "completed", commit_sha = "TBD_phase0_ack", description = "Tier 2 reads conductor/code_styleguides/error_handling.md end-to-end; acknowledge in commit message" }',
+ 't0_2 = { status = "completed", commit_sha = "227253b1", description = "Tier 2 reads conductor/code_styleguides/error_handling.md end-to-end; acknowledge in commit message" }'
+)
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_state_t0_3.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+p = Path("conductor/tracks/result_migration_baseline_cleanup_20260620/state.toml")
+content = p.read_text(encoding="utf-8")
+content = content.replace(
+ 't0_3 = { status = "in_progress", commit_sha = "", description = "Phase 0 checkpoint commit; update state.toml Phase 0 status" }',
+ 't0_3 = { status = "completed", commit_sha = "c8e912f2", description = "Phase 0 checkpoint commit; update state.toml Phase 0 status" }'
+)
+# Add the actual phase_0 checkpointsha
+content = content.replace(
+ 'phase_0 = { status = "completed", checkpointsha = "TBD", name = "Setup + styleguide re-read (3 tasks)" }',
+ 'phase_0 = { status = "completed", checkpointsha = "c8e912f2", name = "Setup + styleguide re-read (3 tasks)" }'
+)
+p.write_text(content, encoding="utf-8")
+print("OK")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/update_tracks_md_phase0.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+p = Path("conductor/tracks.md")
+content = p.read_text(encoding="utf-8")
+lines = content.splitlines(keepends=True)
+
+# Line 32 (1-indexed = index 31)
+old_line = lines[31]
+print("OLD LINE LEN:", len(old_line))
+print("OLD LINE START:", old_line[:120])
+
+# Update the status: "ready to start" -> "active 2026-06-20"
+new_line = old_line.replace("**ready to start**", "**active 2026-06-20**")
+assert new_line != old_line, "No changes made to line"
+lines[31] = new_line
+p.write_text("".join(lines), encoding="utf-8")
+print("OK")
+print("NEW LINE START:", new_line[:120])

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/verify_baseline_gate.py

@@ -0,0 +1,30 @@
+"""Verify baseline + show non-baseline violations."""
+import json
+import subprocess
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+print('--- BASELINE FILES (refactored) ---')
+for f in data['files']:
+    if f['filename'] in ('src\\mcp_client.py', 'src\\ai_client.py', 'src\\rag_engine.py'):
+        v = f.get('violation_count', 0)
+        s = f.get('suspicious_count', 0)
+        u = f.get('unclear_count', 0)
+        c = f.get('compliant_count', 0)
+        print(f'  {f["filename"]}: V={v} S={s} ?={u} C={c}')
+
+print()
+print('--- NON-BASELINE VIOLATIONS (out of scope) ---')
+for f in data['files']:
+    if f.get('violation_count', 0) > 0 and f['filename'] not in (
+        'src\\mcp_client.py', 'src\\ai_client.py', 'src\\rag_engine.py'
+    ):
+        v = f['violation_count']
+        print(f'  {f["filename"]}: V={v}')
+        for x in f['findings']:
+            if x['category'] in ('INTERNAL_BROAD_CATCH', 'INTERNAL_SILENT_SWALLOW',
+                                  'INTERNAL_OPTIONAL_RETURN', 'UNCLEAR'):
+                print(f'    L{x["line"]} {x["category"]}')

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/verify_site1.py

@@ -0,0 +1,16 @@
+"""Phase 10 site verification: count remaining BC sites in ai_client."""
+import json
+import subprocess
+
+r = subprocess.run(
+    ['uv', 'run', 'python', 'scripts/audit_exception_handling.py', '--include-baseline', '--json'],
+    capture_output=True, text=True
+)
+data = json.loads(r.stdout)
+for f in data['files']:
+    if f['filename'].endswith('ai_client.py'):
+        bc = [x for x in f['findings'] if x['category'] == 'INTERNAL_BROAD_CATCH']
+        print(f'ai_client BC count: {len(bc)}')
+        for x in bc:
+            ctx = (x.get('context') or '')[:60]
+            print(f"  L{x['line']} ctx={ctx}")

scripts/tier2/artifacts/result_migration_baseline_cleanup_20260620/write_inventory_docs.py

@@ -0,0 +1,71 @@
+import json
+from collections import defaultdict
+
+with open('tests/artifacts/PHASE1_AUDIT_BASELINE.json') as f:
+    data = json.load(f)
+
+files = {f['filename']: f for f in data['files']}
+
+# Migration-target categories only
+MIG = {'INTERNAL_BROAD_CATCH', 'INTERNAL_SILENT_SWALLOW', 'INTERNAL_OPTIONAL_RETURN', 'INTERNAL_RETHROW', 'UNCLEAR'}
+# Categories that should be left alone (per spec §2.1)
+STAY = {'INTERNAL_COMPLIANT', 'INTERNAL_PROGRAMMER_RAISE', 'BOUNDARY_SDK', 'BOUNDARY_CONVERSION', 'BOUNDARY_FASTAPI'}
+
+# Emit one doc per file
+for fname in ['mcp_client', 'ai_client', 'rag_engine']:
+    key = f'src\\{fname}.py'
+    findings = files[key]['findings']
+    mig = [f for f in findings if f['category'] in MIG]
+    stay = [f for f in findings if f['category'] in STAY]
+
+    out_path = f'tests/artifacts/PHASE1_INVENTORY_{fname}.md'
+    with open(out_path, 'w', encoding='utf-8') as out:
+        out.write(f'# Phase 1 Site Inventory — {fname}.py\n\n')
+        out.write(f'**File:** `src/{fname}.py`\n')
+        out.write(f'**Source:** `tests/artifacts/PHASE1_AUDIT_BASELINE.json` (audit `--include-baseline`)\n')
+        out.write(f'**Total sites in audit:** {len(findings)}\n')
+        out.write(f'**Migration-target sites:** {len(mig)}\n')
+        out.write(f'**Stay-as-is sites:** {len(stay)}\n\n')
+
+        # Category breakdown
+        from collections import Counter
+        all_cats = Counter(f['category'] for f in findings)
+        out.write('## Category Breakdown\n\n')
+        out.write('| Category | Count |\n|---|---|\n')
+        for c, n in sorted(all_cats.items()):
+            target = ' (MIGRATION)' if c in MIG else ' (stay)'
+            out.write(f'| {c}{target} | {n} |\n')
+        out.write('\n')
+
+        # Migration sites table
+        out.write('## Migration-Target Sites\n\n')
+        out.write('| # | Line | Category | Code excerpt | Phase bucket |\n|---|---|---|---|---|\n')
+        for i, f in enumerate(sorted(mig, key=lambda x: x['line']), 1):
+            cat = f['category']
+            # Phase bucket per the plan
+            if cat == 'INTERNAL_BROAD_CATCH':
+                # Phase 3-7: tool broad-catches
+                bucket = 'Batch (Phase 3-7)'
+            elif cat == 'INTERNAL_SILENT_SWALLOW':
+                bucket = 'Phase 8 (mcp) / Phase 11 (ai) / Phase 13 (rag)'
+            elif cat == 'INTERNAL_RETHROW':
+                bucket = 'Phase 12 (ai) / Phase 13 (rag)'
+            elif cat == 'UNCLEAR':
+                bucket = 'Phase 8 (mcp)'
+            elif cat == 'INTERNAL_OPTIONAL_RETURN':
+                bucket = 'Phase 12/13 (classification)'
+            else:
+                bucket = '?'
+            ctx = f.get('context', '?')
+            out.write(f'| {i} | L{f["line"]} | {cat} | `{ctx}` ({f["kind"]}) | {bucket} |\n')
+        out.write('\n')
+
+        # Stay sites summary
+        out.write('## Stay-As-Is Sites\n\n')
+        out.write('| Line | Category | Code excerpt |\n|---|---|---|\n')
+        for f in sorted(stay, key=lambda x: x['line']):
+            ctx = f.get('context', '?')
+            out.write(f'| L{f["line"]} | {f["category"]} | `{ctx}` ({f["kind"]}) |\n')
+        out.write('\n')
+
+        print(f'{fname}: wrote {out_path} ({len(mig)} migration + {len(stay)} stay = {len(findings)} total)')

scripts/tier2/artifacts/result_migration_cruft_removal_20260620/check_counts.py

@@ -0,0 +1,30 @@
+import json
+d = json.load(open('tests/artifacts/PHASE1_AUDIT_BASELINE.json'))
+MIG = {"INTERNAL_BROAD_CATCH", "INTERNAL_SILENT_SWALLOW", "INTERNAL_OPTIONAL_RETURN", "INTERNAL_RETHROW", "UNCLEAR"}
+EXPECTED = {
+    "src\\mcp_client.py": (40, 5, 0, 0, 1, 46),
+    "src\\ai_client.py": (17, 9, 0, 7, 0, 33),
+    "src\\rag_engine.py": (5, 1, 0, 3, 0, 9),
+}
+for f in d['files']:
+    fn = f.get('filename', '')
+    if fn in EXPECTED:
+        cats = {}
+        for finding in f.get('findings', []):
+            cat = finding.get('category', '?')
+            cats[cat] = cats.get(cat, 0) + 1
+        bc = cats.get('INTERNAL_BROAD_CATCH', 0)
+        ss = cats.get('INTERNAL_SILENT_SWALLOW', 0)
+        opt = cats.get('INTERNAL_OPTIONAL_RETURN', 0)
+        rethrow = cats.get('INTERNAL_RETHROW', 0)
+        unclear = cats.get('UNCLEAR', 0)
+        mig = bc + ss + opt + rethrow + unclear
+        exp = EXPECTED[fn]
+        print(f"{fn}: BC={bc} SS={ss} OPT={opt} RETHROW={rethrow} UNCLEAR={unclear} MIG={mig} | expected MIG={exp[5]}")
+        # Also show what categories DO exist
+        if any(v > 0 for v in [bc, ss, opt, rethrow, unclear]):
+            pass
+        else:
+            print(f"  NO migration-target categories found! Top 5 categories:")
+            for cat, n in sorted(cats.items(), key=lambda x: -x[1])[:5]:
+                print(f"    {cat}: {n}")

scripts/tier2/artifacts/result_migration_cruft_removal_20260620/check_schema.py

@@ -0,0 +1,12 @@
+import json
+d = json.load(open('tests/artifacts/PHASE1_AUDIT_BASELINE.json'))
+print('Schema check:')
+print('  data["files"] is', type(d.get('files')).__name__)
+if isinstance(d.get('files'), list) and d['files']:
+    f = d['files'][0]
+    print('  First file keys:', list(f.keys())[:10] if isinstance(f, dict) else 'NOT A DICT')
+    print('  First file:', repr(f)[:300])
+# check by_kind
+print('by_kind:', d.get('by_kind'))
+# check by_category
+print('by_category keys:', list(d.get('by_category', {}).keys())[:5])

scripts/tier2/artifacts/result_migration_cruft_removal_20260620/fix_indent.py

@@ -0,0 +1,12 @@
+with open(r"C:\projects\manual_slop_tier2\src\rag_engine.py", "r", encoding="utf-8", newline="") as f:
+    content = f.read()
+# Fix the leading space on line 260
+old = "   )\n\n def _check_existing_index_result(self, file_path: str, mtime: float) -> Result[bool]:"
+new = "   )\n\ndef _check_existing_index_result(self, file_path: str, mtime: float) -> Result[bool]:"
+if old in content:
+    content = content.replace(old, new)
+    with open(r"C:\projects\manual_slop_tier2\src\rag_engine.py", "w", encoding="utf-8", newline="") as f:
+        f.write(content)
+    print("Fixed line 260 leading space")
+else:
+    print("Pattern not found")

scripts/tier2/artifacts/result_migration_cruft_removal_20260620/inspect_audit.py

@@ -0,0 +1,22 @@
+import json
+d = json.load(open('tests/artifacts/PHASE1_AUDIT_BASELINE.json'))
+for f in d['files']:
+    if 'mcp_client' in f.get('filename', ''):
+        print('mcp_client findings count:', len(f['findings']))
+        for finding in f['findings'][:5]:
+            print(' ', finding)
+        break
+ai = None
+for f in d['files']:
+    if 'ai_client' in f.get('filename', ''):
+        ai = f
+        break
+if ai:
+    print('ai_client findings count:', len(ai['findings']))
+rag = None
+for f in d['files']:
+    if 'rag_engine' in f.get('filename', ''):
+        rag = f
+        break
+if rag:
+    print('rag_engine findings count:', len(rag['findings']))

scripts/tier2/artifacts/result_migration_cruft_removal_20260620/update_test_mocks.ps1

@@ -0,0 +1,12 @@
+$files = @(
+    "C:\projects\manual_slop_tier2\tests\test_ts_c_tools.py",
+    "C:\projects\manual_slop_tier2\tests\test_ts_cpp_tools.py"
+)
+foreach ($f in $files) {
+    $c = Get-Content $f -Raw
+    $c = $c -replace 'original_resolve = mcp_client\._resolve_and_check', 'original_resolve = mcp_client._resolve_and_check_result'
+    $c = $c -replace 'mcp_client\._resolve_and_check = lambda path: \(Path\(path\), None\)', 'mcp_client._resolve_and_check_result = lambda path: __import__("src").mcp_client.Result(data=Path(path), errors=[])'
+    $c = $c -replace 'mcp_client\._resolve_and_check = original_resolve', 'mcp_client._resolve_and_check_result = original_resolve'
+    [System.IO.File]::WriteAllText($f, $c, [System.Text.UTF8Encoding]::new($false))
+}
+"Done updating test files."