drydock-cli 2.8.28__tar.gz → 2.8.30__tar.gz

drydock_cli-2.8.30/.auto_release.lock

@@ -0,0 +1 @@
+1646006

{drydock_cli-2.8.28 → drydock_cli-2.8.30}/CLAUDE.md

@@ -719,7 +719,7 @@ while real users see loops and hangs.
 **How it works:**
 - Drives the real `drydock` TUI via pexpect (no headless mode)
 - Sends a vague user-style prompt ("review the PRD and build the package")
-- Polls the live `~/.vibe/logs/session/session_<id>/messages.jsonl` in parallel
+- Polls the live `~/.drydock/logs/session/session_<id>/messages.jsonl` in parallel (legacy sessions at `~/.vibe/logs/session/` are still read for back-compat)
 - Watches for write loops, search_replace cascades, hallucinated-tool hangs
 - Types simulated `STOP` interrupts when loops are detected, then tracks
   whether the model OBEYS them

{drydock_cli-2.8.28 → drydock_cli-2.8.30}/HLE_PRD.md

@@ -6,6 +6,40 @@ the dominant cause of thinking-stalls. Deep Noir sidecar wiring (M1-M4)
 is in tree; M1 end-to-end GPU smoke pending after the transformers 5.x
 apply_chat_template fix (f02aa4b).
 
+## Symbolic-math tool stack shipped (2026-05-14)
+
+Major shipping push 2026-05-14: built four new sympy-backed built-in
+tools to give the model offload paths for the symbolic work it
+systematically gets wrong from prior. Pattern: same as `math` for
+arithmetic — wrap a reliable library, sandbox the inputs, expose the
+ops the model would otherwise have to "reason about." 52 new
+operations total.
+
+| Tool | Ops | Use case |
+|------|-----|----------|
+| `logic` | 12 | propositional logic — contrapositive, De Morgan, equivalence, truth tables, Modus Ponens, satisfiability, CNF/DNF |
+| `algebra` | 13 | symbolic math — solve / simplify / expand / factor / diff / integrate / limit / series / evaluate / trigsimp |
+| `number_theory` | 16 | primes / divisors / gcd / totient / Möbius / modular inverse / mod_pow / CRT |
+| `set` | 11 | discrete math — union / intersection / power set / Cartesian product / cardinality / subset |
+
+Each tool sandboxed with AST-level validation (no imports, no
+attribute access, no dunder, no eval/exec), max-expression-length
+caps, and per-tool result caps (e.g. power_set refuses |A|>10,
+product refuses |A|·|B|>1000).
+
+All four wired into `gemma4.md` system prompt with HLE-shape →
+op mapping. The first hourly babysitter tick after these land
+(02:45+ UTC) is the first batch where the model can use them; the
+22h trailing tool_usage_report will measure whether the lift is real.
+
+Why this matters for HLE: Math sits at 3/102 = 2.9% lifetime, the
+worst category. The dominant failure mode (per the day's session
+traces) is `empty:no_final_answer` — the model engages, calls
+retrieve, then web_searches, then runs out of 481s without producing
+a FINAL ANSWER. Offloading the actual symbolic work to sympy lets
+the model spend its turn budget on planning + extraction instead of
+re-deriving algebra in plain English (which it gets wrong).
+
 ## HLE was retrieving against the WRONG corpus (fixed edb61c9)
 
 Trace from a Q3 session 2026-05-14: a local-field-theory HLE Math

{drydock_cli-2.8.28 → drydock_cli-2.8.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.28
+Version: 2.8.30
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.8.28 → drydock_cli-2.8.30}/drydock/core/agent_loop.py

@@ -809,7 +809,10 @@ class AgentLoop:
                 int(os.environ.get("DRYDOCK_WRAP_UP_WARN_AT", 30))))
             STOP_NOW_WARN_AT = int(getattr(self, "_admiral_stop_now_warn_at",
                 int(os.environ.get("DRYDOCK_STOP_NOW_WARN_AT", 60))))
+            STOP_NOW_TIME_SEC = int(os.environ.get("DRYDOCK_STOP_NOW_TIME_SEC", "0"))
             _prompt_start = time.perf_counter()
+            _time_stop_injected = False
+            _time_stop_escalated = False
             logger.warning("[TIMING] entering conversation while loop")
             while not should_break_loop:
                 # Drain any user messages typed while the agent was working.
@@ -846,6 +849,36 @@ class AgentLoop:
                         stopped_by_middleware=True,
                     )
                     return
+                # Time-based STOP_NOW: fires when wall-clock exceeds
+                # DRYDOCK_STOP_NOW_TIME_SEC regardless of turn count.
+                # Helps HLE batches where per-turn latency is 60-160s
+                # and the turn-based STOP_NOW fires too late or not at all.
+                if (STOP_NOW_TIME_SEC > 0
+                        and not _time_stop_injected
+                        and _elapsed > STOP_NOW_TIME_SEC):
+                    _time_stop_injected = True
+                    _stop_suffix = os.environ.get("DRYDOCK_STOP_NOW_SUFFIX", "")
+                    self._inject_system_note(
+                        f"Time limit reached: {int(_elapsed)}s elapsed on "
+                        "this single request. STOP NOW. Emit a final text "
+                        "response summarizing what you have or your best "
+                        "guess."
+                        + (f" {_stop_suffix}" if _stop_suffix else "")
+                    )
+                elif (STOP_NOW_TIME_SEC > 0
+                        and _time_stop_injected
+                        and not _time_stop_escalated
+                        and _elapsed > STOP_NOW_TIME_SEC + 60):
+                    # Model made another tool call after the first STOP_NOW.
+                    # Escalate: one more forceful injection, then let it run out.
+                    _time_stop_escalated = True
+                    _stop_suffix = os.environ.get("DRYDOCK_STOP_NOW_SUFFIX", "")
+                    self._inject_system_note(
+                        f"URGENT: {int(_elapsed)}s elapsed. Do NOT call any more tools. "
+                        "Emit a plain text response RIGHT NOW with your best answer. "
+                        "If uncertain, still write an answer."
+                        + (f" {_stop_suffix}" if _stop_suffix else "")
+                    )
                 if tool_turns == WRAP_UP_WARN_AT:
                     self._inject_system_note(
                         f"You have used {tool_turns} tool calls on this "

{drydock_cli-2.8.28 → drydock_cli-2.8.30}/drydock/core/llm/backend/generic.py

@@ -193,6 +193,15 @@ class OpenAIAdapter(APIAdapter):
         # Enable thinking for models that support it (Gemma 4)
         if thinking and thinking not in ("off", ""):
             payload["chat_template_kwargs"] = {"enable_thinking": True}
+            # Cap thinking length (llama.cpp). Prevents runaway thinking stalls
+            # on hard HLE questions (model can think >480s without this).
+            # Set DRYDOCK_THINKING_BUDGET_TOKENS=8000 in HLE batch launches.
+            _budget = os.environ.get("DRYDOCK_THINKING_BUDGET_TOKENS")
+            if _budget:
+                try:
+                    payload["thinking_budget_tokens"] = int(_budget)
+                except ValueError:
+                    pass
 
         if enable_streaming:
             payload["stream"] = True

{drydock_cli-2.8.28 → drydock_cli-2.8.30}/drydock/core/prompts/gemma4.md

@@ -4,7 +4,7 @@ ACT IMMEDIATELY. Your FIRST response must be a tool call — not text. Do NOT ex
 
 When answering a direct factual or math question (not writing code), you MUST write visible text — never produce a response with only thinking tokens and no visible content. End your response with "FINAL ANSWER: <your answer>" on its own line so the judge can extract it. Even if you are uncertain, always attempt an answer and write "FINAL ANSWER: <best guess>" — an empty response scores 0 regardless of how good your reasoning was.
 
-Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify.
+Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify, logic, algebra, number_theory, set, linear_algebra, stats, units, chemistry.
 
 CURIOSITY — default posture is "investigate, then assert" (SOVEREIGN_PRD §5.7):
 - If the user message names a thing you don't have context for (paper title,
@@ -109,6 +109,119 @@ check and returns pass/fail. `verify(criterion="tests pass",
 command="pytest -q", expect="passed", expect_mode="contains")` instead
 of inspecting the bash output yourself.
 
+USE THE logic TOOL when you need to apply propositional logic — checking
+equivalences, contrapositives, De Morgan, truth tables, Modus Ponens.
+Small models get implication direction wrong and miss negations under
+nested AND/OR. Examples:
+  logic(op="contrapositive", expression="p >> q")   → ¬q → ¬p
+  logic(op="equivalent", expression="p >> q", expression2="~q >> ~p")
+  logic(op="negate", expression="p & q & r")        → De Morgan'd negation
+  logic(op="truth_table", expression="(p | q) & ~p")
+  logic(op="modus_ponens", expression="p", expression2="p >> q")  → q
+Use INSTEAD of reasoning about logic in your head when answering HLE-style
+prove/show-that/iff questions or when refactoring boolean conditions.
+Syntax: `&` AND, `|` OR, `~` NOT, `>>` IMPLIES, `Equivalent(p, q)` IFF.
+
+When the question contains these shapes, reach for these ops:
+- "show that A iff B" / "A is necessary and sufficient for B"
+    → logic(op="equivalent", expression="<A>", expression2="<B>")
+- "prove A → B by contrapositive"
+    → logic(op="contrapositive", expression="<A> >> <B>") then prove the result
+- "show A → B is always true" / "is this a tautology?"
+    → logic(op="tautology", expression="<A> >> <B>")
+- "is there any case where <expr> holds?"
+    → logic(op="satisfiable", expression="<expr>") (returns a witness)
+- "simplify ~(A & B & C)" or "what's NOT (A or B)?"
+    → logic(op="negate", expression="<expr>")  (auto-applies De Morgan)
+- "given premises P and (P → Q), what follows?"
+    → logic(op="modus_ponens", expression="<P>", expression2="<P> >> <Q>")
+
+USE THE algebra TOOL for symbolic math — solve equations, differentiate,
+integrate, take limits, simplify, expand, factor, Taylor series. Small
+models get sign errors, drop terms in expansions, and integrate by parts
+incorrectly. Sympy doesn't. Examples:
+  algebra(op="solve", expression="x**2 - 4", variable="x")   → [-2, 2]
+  algebra(op="diff", expression="sin(x)*cos(x)", variable="x")
+  algebra(op="integrate", expression="x**2", variable="x", a="0", b="1")
+  algebra(op="limit", expression="sin(x)/x", variable="x", value="0") → 1
+  algebra(op="series", expression="exp(x)", variable="x", value="0", order=4)
+  algebra(op="evaluate", expression="x**2 + 1", variable="x", value="3") → 10
+  algebra(op="trigsimp", expression="sin(x)**2 + cos(x)**2")  → 1
+Use INSTEAD of doing CAS work in your head. Free variables auto-bind to
+symbols. Constants: pi, E, oo (infinity), I. Functions: sin/cos/tan,
+log/exp/sqrt, factorial, binomial, gamma, Rational(p,q).
+
+USE THE number_theory TOOL for primes/divisors/gcd/modular arithmetic.
+Don't guess whether 1000003 is prime — call it. Examples:
+  number_theory(op="is_prime", n="2**31 - 1")           → True
+  number_theory(op="factor", n="360")                   → {2:3, 3:2, 5:1}
+  number_theory(op="totient", n="12")                   → 4
+  number_theory(op="gcd", a="48", b="18")               → 6
+  number_theory(op="mod_pow", b="2", e="100", m="7")    → 2  (2^100 mod 7)
+  number_theory(op="mod_inverse", a="3", m="7")         → 5  (3^-1 mod 7)
+  number_theory(op="crt", remainders="2,3,2", moduli="3,5,7")  → x ≡ 23 (mod 105)
+Integer args parse expressions — n="factorial(20)" works. Use INSTEAD
+of doing factorial/Fermat-test/Euclidean-algorithm by hand.
+
+USE THE set TOOL for discrete-math set questions. Inputs are
+comma-separated literals (ints, 'quoted strings', or barewords as
+strings). Examples:
+  set(op="union", a="1,2,3", b="3,4,5")            → {1,2,3,4,5}
+  set(op="intersection", a="1,2,3,4", b="3,4,5,6") → {3,4}
+  set(op="is_subset", a="1,2", b="1,2,3")          → True
+  set(op="cardinality", a="1,2,2,3")               → 3 (dedupes)
+  set(op="power_set", a="1,2,3")                   → 8 subsets
+  set(op="size_of_product", a="1,2,3", b="x,y,z,w") → 12
+Use INSTEAD of manually enumerating subsets or checking containment.
+
+USE THE linear_algebra TOOL for matrix problems. Syntax: rows separated
+by ';', entries by ','. Max 8×8. Symbolic entries OK.
+  linear_algebra(op="determinant", matrix="1,2;3,4")  → -2
+  linear_algebra(op="inverse", matrix="1,2;3,4")      → [[-2,1],[3/2,-1/2]]
+  linear_algebra(op="eigenvals", matrix="2,1;0,3")    → {2:1, 3:1}
+  linear_algebra(op="multiply", matrix="1,2;3,4", matrix2="5,6;7,8")
+  linear_algebra(op="solve_linear", matrix="1,1;1,-1", vector="5;1") → x=3, y=2
+  linear_algebra(op="power", matrix="1,1;0,1", n="5")  → [[1,5],[0,1]]
+Use INSTEAD of doing matrix multiplication / Cramer's rule by hand.
+
+USE THE stats TOOL for distributions, hypothesis tests, descriptive
+stats. Backed by scipy.stats. Supported dists: normal, t, chi2, f,
+binomial, poisson, exponential, uniform, beta, gamma.
+  stats(op="describe", data="1,2,3,4,5")          → n=5 mean=3 stdev=1.58 ...
+  stats(op="cdf", dist="normal", params="0,1", x="1.96")  → 0.975 (Φ(1.96))
+  stats(op="ppf", dist="normal", params="0,1", q="0.975") → 1.96 (inverse)
+  stats(op="binomial", n="10", k="3", p="0.5")    → P(X=3) for Bin(10, 0.5)
+  stats(op="poisson", k="2", lam="3")             → P(X=2) for Poisson(3)
+  stats(op="z_test", x_bar="105", mu0="100", sigma="15", n="30")
+  stats(op="t_test", data="4.8,5.1,4.9,5.0", mu0="5")
+  stats(op="correlation", data="1,2,3,4", data2="2,4,6,8")  → r, p
+  stats(op="ci_mean", data="10,11,12,13,14")      → 95% CI
+Use INSTEAD of looking up z-table values or computing pmf by hand.
+
+USE THE units TOOL for physics unit conversion and dimensional analysis.
+Unit names work as identifiers: m, km, mile, ft, s, hour, kg, g, N,
+J, W, V, A, Pa, atm, mol, K, etc.
+  units(op="convert", expression="60*mile/hour", to_unit="meter/second")
+  units(op="evaluate", expression="Rational(1,2)*kg*(3*m/s)**2") → KE
+  units(op="consistent", expression="joule", expression2="newton*meter") → True
+  units(op="dimension", expression="watt")        → power (= energy/time)
+  units(op="to_si", expression="1*atmosphere")    → 101325 Pa as base SI
+Use INSTEAD of remembering conversion factors / doing dimensional
+algebra in your head. The `consistent` op is great for sanity-checking
+a physics formula (does your derived expression have the right
+dimensions?).
+
+USE THE chemistry TOOL for periodic-table lookups, molar mass, mole
+conversions, percent composition, empirical formulas. Formula syntax
+is standard chemistry notation with nested parens (H2O, Ca(OH)2,
+Fe2(SO4)3, C6H12O6). Examples:
+  chemistry(op="element", name="Na")                → Na (Z=11, 22.99 g/mol)
+  chemistry(op="molar_mass", formula="C6H12O6")     → 180.156 g/mol
+  chemistry(op="moles_from_grams", formula="H2O", grams="18") → 0.999 mol
+  chemistry(op="percent_composition", formula="H2O")  → H=11.19%  O=88.81%
+  chemistry(op="empirical_formula", percents="C=40, H=6.7, O=53.3") → CH2O
+Use INSTEAD of looking up atomic weights / doing stoichiometry by hand.
+
 Rules:
 - Create files immediately. Do not plan or discuss — write code.
 - Use absolute imports for Python packages

drydock_cli-2.8.30/drydock/core/tools/builtins/algebra_tool.py

@@ -0,0 +1,406 @@
+"""Algebra tool — symbolic math (CAS) via sympy.
+
+Companion to math_tool (arithmetic) and logic_tool (propositional logic).
+This one handles the CAS operations that come up in HLE Math but that
+the model gets wrong from prior alone: solving equations, integrating,
+differentiating, simplifying, expanding, factoring, computing limits,
+and generating Taylor series.
+
+Sandbox: same shape as logic_tool — Python expressions, sympy
+namespace, no imports/attribute access/dunder anything.
+
+Operations (`op=`):
+
+  solve(equation, var)       — solve eq=0 (or `lhs == rhs`) for var
+  simplify(expression)       — sympy.simplify
+  expand(expression)         — expand products
+  factor(expression)         — factor polynomial
+  diff(expression, var)      — d/dvar of expression
+  integrate(expr, var, a, b) — integrate; pass a,b for definite, omit for indefinite
+  limit(expression, var, point) — limit as var → point
+  series(expression, var, point, n) — Taylor series to order n
+  evaluate(expression, var, value) — substitute and simplify
+  collect(expression, var)   — collect powers of var
+  apart(expression)          — partial fraction decomposition
+  together(expression)       — combine fractions
+  trigsimp(expression)       — trig-specific simplification
+
+Expression syntax: Python-style with sympy symbols.
+  - Variables: any name (x, y, n, theta, ...) auto-becomes Symbol
+  - Constants: pi, E, oo (infinity), I, nan
+  - Functions: sin, cos, tan, log, exp, sqrt, Abs, factorial, ...
+  - Operators: + - * / ** (no integer division - use Rational for fractions)
+
+Read-only, side-effect free, ALWAYS permission.
+"""
+from __future__ import annotations
+
+import ast as _ast
+import re
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, final
+
+from pydantic import BaseModel, Field
+
+from drydock.core.tools.base import (
+    BaseTool,
+    BaseToolConfig,
+    BaseToolState,
+    InvokeContext,
+    ToolError,
+    ToolPermission,
+)
+from drydock.core.tools.ui import (
+    ToolCallDisplay,
+    ToolResultDisplay,
+    ToolUIData,
+)
+from drydock.core.types import ToolStreamEvent
+
+if TYPE_CHECKING:
+    from drydock.core.types import ToolResultEvent
+
+
+AlgebraOp = Literal[
+    "solve",
+    "simplify",
+    "expand",
+    "factor",
+    "diff",
+    "integrate",
+    "limit",
+    "series",
+    "evaluate",
+    "collect",
+    "apart",
+    "together",
+    "trigsimp",
+]
+
+
+_OP_HELP = (
+    "Operation: solve | simplify | expand | factor | diff | integrate | "
+    "limit | series | evaluate | collect | apart | together | trigsimp. "
+    "See the tool docstring for what each one expects."
+)
+
+
+class AlgebraArgs(BaseModel):
+    op: AlgebraOp = Field(description=_OP_HELP)
+    expression: str = Field(
+        description=(
+            "Symbolic expression. Python-style: `x**2 + 2*x + 1` or "
+            "`sin(theta)/cos(theta)` or `log(x) - 1`. Variables become "
+            "sympy Symbols automatically. Constants: pi, E, oo, I. "
+            "Functions: sin, cos, tan, asin, log, exp, sqrt, factorial, "
+            "binomial(n,k), Rational(p,q), Abs."
+        )
+    )
+    variable: str = Field(
+        default="x",
+        description=(
+            "Free variable name (default 'x'). Used by solve/diff/"
+            "integrate/limit/series/evaluate/collect."
+        ),
+    )
+    value: str = Field(
+        default="",
+        description=(
+            "For `evaluate`: the value to substitute (e.g. '2', 'pi/4', "
+            "'sqrt(3)'). For `limit`: the point to approach (e.g. 'oo', "
+            "'0', '1'). For `series`: the expansion point (default 0)."
+        ),
+    )
+    a: str = Field(
+        default="",
+        description=(
+            "Lower bound for definite integration. If empty, integrate "
+            "indefinitely. Format: any sympy expression like '0', 'pi/2'."
+        ),
+    )
+    b: str = Field(
+        default="",
+        description="Upper bound for definite integration. Required if `a` set.",
+    )
+    order: int = Field(
+        default=6,
+        ge=1,
+        le=20,
+        description="Order for `series` expansion (default 6).",
+    )
+
+
+class AlgebraResult(BaseModel):
+    ok: bool
+    op: str = ""
+    result: str = ""
+    result_type: str = ""
+    error: str = ""
+
+
+class AlgebraConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+
+
+# ── Expression parser ─────────────────────────────────────────────────
+
+_BAD_PATTERNS = (
+    "__", "import", "exec", "eval", "open",
+    "globals", "locals", "getattr", "setattr",
+)
+_ALLOWED_NAMES: dict[str, Any] = {}
+
+
+def _safe_globals() -> dict[str, Any]:
+    global _ALLOWED_NAMES
+    if _ALLOWED_NAMES:
+        return _ALLOWED_NAMES
+    import sympy
+    _ALLOWED_NAMES = {
+        "__builtins__": {},
+        # Core symbols & constants
+        "Symbol": sympy.Symbol,
+        "Rational": sympy.Rational,
+        "Integer": sympy.Integer,
+        "Float": sympy.Float,
+        "pi": sympy.pi, "E": sympy.E, "oo": sympy.oo,
+        "I": sympy.I, "nan": sympy.nan,
+        # Functions
+        "sin": sympy.sin, "cos": sympy.cos, "tan": sympy.tan,
+        "asin": sympy.asin, "acos": sympy.acos, "atan": sympy.atan,
+        "sinh": sympy.sinh, "cosh": sympy.cosh, "tanh": sympy.tanh,
+        "log": sympy.log, "ln": sympy.log, "exp": sympy.exp,
+        "sqrt": sympy.sqrt, "Abs": sympy.Abs,
+        "factorial": sympy.factorial, "binomial": sympy.binomial,
+        "floor": sympy.floor, "ceiling": sympy.ceiling,
+        "gamma": sympy.gamma, "erf": sympy.erf,
+        "Sum": sympy.Sum, "Product": sympy.Product,
+        # Constructors that come up
+        "Eq": sympy.Eq, "Ne": sympy.Ne, "Lt": sympy.Lt, "Gt": sympy.Gt,
+        "Le": sympy.Le, "Ge": sympy.Ge,
+        "Matrix": sympy.Matrix,
+    }
+    return _ALLOWED_NAMES
+
+
+def _validate(expr: str) -> None:
+    if not expr or not expr.strip():
+        raise ToolError("expression is empty")
+    if len(expr) > 4000:
+        raise ToolError("expression too long (>4000 chars)")
+    lower = expr.lower()
+    for bad in _BAD_PATTERNS:
+        if bad in lower:
+            raise ToolError(f"forbidden token in expression: {bad!r}")
+
+
+def _parse(expr: str):
+    _validate(expr)
+    import sympy
+    try:
+        tree = _ast.parse(expr, mode="eval")
+    except SyntaxError as e:
+        raise ToolError(f"SyntaxError: {e.msg} at column {e.offset or '?'}") from e
+    safe_g = dict(_safe_globals())
+    for node in _ast.walk(tree):
+        if isinstance(node, _ast.Attribute):
+            raise ToolError("attribute access not permitted")
+        if isinstance(node, _ast.Call):
+            fn = getattr(node.func, "id", None)
+            if fn is None or fn not in safe_g:
+                raise ToolError(
+                    f"unknown function {fn!r} (whitelist: "
+                    f"{sorted(k for k in safe_g if k != '__builtins__')[:20]}...)"
+                )
+        if isinstance(node, _ast.Name):
+            n = node.id
+            if n not in safe_g:
+                safe_g[n] = sympy.Symbol(n)
+    try:
+        return eval(  # noqa: S307 — whitelisted namespace
+            compile(tree, "<algebra>", "eval"), safe_g, {}
+        )
+    except (SyntaxError, ValueError, TypeError) as e:
+        raise ToolError(f"{type(e).__name__}: {e}") from e
+
+
+def _sym(name: str):
+    import sympy
+    if not name or not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name):
+        raise ToolError(f"bad variable name {name!r}")
+    return sympy.Symbol(name)
+
+
+# ── Op implementations ───────────────────────────────────────────────
+
+def _op_solve(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    e = _parse(args.expression)
+    v = _sym(args.variable)
+    # Accept either an equation (Eq) or an expression (assumed = 0)
+    if not isinstance(e, sympy.Equality):
+        e = sympy.Eq(e, 0)
+    sol = sympy.solve(e, v)
+    return (str(sol), "list" if isinstance(sol, list) else "expr")
+
+
+def _op_simplify(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.simplify(_parse(args.expression))), "expr")
+
+
+def _op_expand(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.expand(_parse(args.expression))), "expr")
+
+
+def _op_factor(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.factor(_parse(args.expression))), "expr")
+
+
+def _op_diff(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.diff(_parse(args.expression), _sym(args.variable))), "expr")
+
+
+def _op_integrate(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    expr = _parse(args.expression)
+    v = _sym(args.variable)
+    if args.a and args.b:
+        a_ = _parse(args.a) if args.a else 0
+        b_ = _parse(args.b) if args.b else 0
+        return (str(sympy.integrate(expr, (v, a_, b_))), "expr")
+    if args.a or args.b:
+        raise ToolError("integrate needs BOTH `a` and `b` for definite integration, or neither for indefinite")
+    return (str(sympy.integrate(expr, v)), "expr")
+
+
+def _op_limit(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    if not args.value:
+        raise ToolError("limit needs `value=` for the point to approach")
+    point = _parse(args.value)
+    return (str(sympy.limit(_parse(args.expression), _sym(args.variable), point)), "expr")
+
+
+def _op_series(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    point = _parse(args.value) if args.value else 0
+    return (
+        str(sympy.series(_parse(args.expression), _sym(args.variable), point, args.order).removeO()),
+        "expr",
+    )
+
+
+def _op_evaluate(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    if not args.value:
+        raise ToolError("evaluate needs `value=` to substitute")
+    expr = _parse(args.expression)
+    val = _parse(args.value)
+    return (str(sympy.simplify(expr.subs(_sym(args.variable), val))), "expr")
+
+
+def _op_collect(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.collect(_parse(args.expression), _sym(args.variable))), "expr")
+
+
+def _op_apart(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.apart(_parse(args.expression), _sym(args.variable))), "expr")
+
+
+def _op_together(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.together(_parse(args.expression))), "expr")
+
+
+def _op_trigsimp(args: AlgebraArgs) -> tuple[str, str]:
+    import sympy
+    return (str(sympy.trigsimp(_parse(args.expression))), "expr")
+
+
+_DISPATCH = {
+    "solve":     _op_solve,
+    "simplify":  _op_simplify,
+    "expand":    _op_expand,
+    "factor":    _op_factor,
+    "diff":      _op_diff,
+    "integrate": _op_integrate,
+    "limit":     _op_limit,
+    "series":    _op_series,
+    "evaluate":  _op_evaluate,
+    "collect":   _op_collect,
+    "apart":     _op_apart,
+    "together":  _op_together,
+    "trigsimp":  _op_trigsimp,
+}
+
+
+class Algebra(
+    BaseTool[AlgebraArgs, AlgebraResult, AlgebraConfig, BaseToolState],
+    ToolUIData[AlgebraArgs, AlgebraResult],
+):
+    description: ClassVar[str] = (
+        "Symbolic algebra via sympy — solve equations, simplify, expand, "
+        "factor, differentiate, integrate, take limits, generate Taylor "
+        "series, substitute values. Use INSTEAD of doing CAS work in "
+        "your head when the answer needs to be exact. Variables auto-bind "
+        "to sympy Symbols, so `x**2 - 4` and `sin(theta)/cos(theta)` "
+        "just work. Functions available: sin/cos/tan, log/exp/sqrt, "
+        "factorial, binomial, gamma, erf, Sum/Product. Constants: pi, "
+        "E, oo (infinity), I, Rational(p,q). Sandboxed — no imports."
+    )
+
+    @classmethod
+    def format_call_display(cls, args: AlgebraArgs) -> ToolCallDisplay:
+        e = args.expression.strip()
+        if len(e) > 40:
+            e = e[:37] + "..."
+        return ToolCallDisplay(summary=f"algebra[{args.op}]: {e}")
+
+    @classmethod
+    def get_result_display(cls, event: "ToolResultEvent") -> ToolResultDisplay:
+        if isinstance(event.result, AlgebraResult):
+            if not event.result.ok:
+                return ToolResultDisplay(
+                    success=False, message=f"algebra: {event.result.error[:80]}"
+                )
+            preview = event.result.result
+            if len(preview) > 80:
+                preview = preview[:77] + "..."
+            return ToolResultDisplay(success=True, message=f"= {preview}")
+        return ToolResultDisplay(success=True, message="algebra complete")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Computing symbolically"
+
+    def resolve_permission(self, args: AlgebraArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: AlgebraArgs, ctx: "InvokeContext | None" = None
+    ) -> AsyncGenerator["ToolStreamEvent | AlgebraResult", None]:
+        handler = _DISPATCH.get(args.op)
+        if handler is None:
+            yield AlgebraResult(
+                ok=False, op=args.op,
+                error=f"unknown op {args.op!r}. Allowed: {list(_DISPATCH)}",
+            )
+            return
+        try:
+            value, rtype = handler(args)
+        except ToolError as e:
+            yield AlgebraResult(ok=False, op=args.op, error=str(e))
+            return
+        except Exception as e:  # noqa: BLE001 — surface to model
+            yield AlgebraResult(
+                ok=False, op=args.op, error=f"{type(e).__name__}: {e}"
+            )
+            return
+        yield AlgebraResult(ok=True, op=args.op, result=value, result_type=rtype)