subtask-mcp 0.3.1__tar.gz → 0.4.4__tar.gz

{subtask_mcp-0.3.1/subtask_mcp.egg-info → subtask_mcp-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subtask-mcp
-Version: 0.3.1
+Version: 0.4.4
 Summary: Background sub-agents for Claude Code, Codex, Kimi and OpenCode, over MCP or CLI, with a spend cap
 License: MIT
 Project-URL: Homepage, https://github.com/tedin7/subtask
@@ -111,9 +111,11 @@ redaction is a second layer, not a guarantee. See [SECURITY.md](SECURITY.md).
 
 | tool | what it does |
 |---|---|
-| `start(task, kind, repo, cwd, files, readonly, engine, max_usd, effort, base, max_turns, policy, verify, isolation, max_retries, adversarial, context_refs, auto_repomap, tier)` | start one job (see below) |
-| `start_many(tasks)` | start several; partial success is listed per item. Items with `id` and `depends_on` form a group (`grp-…`) run as a DAG without extra turns |
+| `start(task, kind, repo, cwd, files, readonly, engine, max_usd, effort, base, max_turns, policy, verify, isolation, max_retries, adversarial, context_refs, auto_repomap, tier, invariants, allowed_paths, symbol_scope, oracle_cmd)` | start one job (see below) |
+| `start_many(tasks)` | start several; partial success is listed per item. Items with `id` and `depends_on` form a group (`grp-…`) run as a DAG without extra turns; `foreach=<parent id>` makes one copy per item of the parent's `.subtask/fanout.json` (at most 8), and dependents wait for every copy; `after="any"` starts when one parent succeeded |
 | `integrate(ids, action="apply", auto_resolve=False)` | worktree jobs back: `diff`, `apply` (all or nothing, uncommitted), `discard`; `auto_resolve` starts a reconciliation job on conflict |
+| `consensus(prompt, engines, verify_cmd, isolation="worktree")` | 2 to 4 engines solve it blind in their own worktrees, then one job compares their diffs as anonymous patches and writes one solution, checked by `verify_cmd` and the invariants; returns a group id |
+| `bisect(good_ref, bad_ref, test_cmd, parallelism=4, auto_fix=False)` | first commit that makes `test_cmd` fail, testing up to `parallelism` (max 8) commits per round in temporary worktrees; returns the commit, author and diff; `auto_fix` starts a verified fix job |
 | `map_reduce(glob_pattern, prompt_template, batch_size=5, concurrency=3, verify_cmd, isolation="worktree")` | one job per batch of files (`{{files}}` in the template), at most `concurrency` at a time; returns a group id |
 | `wait(ids, timeout=300, mode="all", since=None, stall_timeout=None)` | block until they end (`any`: the first; `first_success`: the first done and verified, the others are stopped); returns early on a stalled job; progress notifications while waiting; `since` cursor for clients without progress |
 | `steer(id, action, instruction=None)` | `hint` (queued, sent as a reply when the attempt ends), `abort`, `retry` (fresh job with the instruction) |
@@ -133,6 +135,16 @@ Options of `start`:
   Builder's worktree and run with `verify`.
 - `context_refs`: `file:PATH[:A-B]`, `git:diff[:REF]`, `subtask:ID:summary|diff`, resolved before start.
   `auto_repomap=True` adds tracked files with their top-level symbols (cached per HEAD).
+- `invariants` (default `["no_test_deletion", "no_suppression"]`, `[]` turns them off): before `verify` counts,
+  test functions may not decrease, no new skip/xfail markers, no new `# type: ignore`, `# noqa` or
+  `# pragma: no cover`. A violation is a failed check with the reason, so a retry sees it.
+- `allowed_paths`: files changed outside these paths are put back and the revert is committed.
+- `symbol_scope=["path.py::name", ...]`: only those top-level functions or classes may change in those
+  files. `integrate` then merges several jobs' edits to one Python file symbol by symbol; overlaps,
+  import or constant changes, and symbols changed on the target meanwhile are a conflict, never a guess.
+- `oracle_cmd`: after a passing `verify`, runs the command on the job's base and on its result at the same
+  time and reports whether exit code and stdout match, plus `duration_ms_before`, `duration_ms_after`,
+  `speedup_pct`.
 - `tier`: `fast` (effort low), `deep` (effort high, kind hard), `free_only`. Past 75% of the monthly cap,
   `auto` and `balanced` go to free engines and the reply carries `budget_warning`.
 

{subtask_mcp-0.3.1 → subtask_mcp-0.4.4}/README.md

@@ -80,9 +80,11 @@ redaction is a second layer, not a guarantee. See [SECURITY.md](SECURITY.md).
 
 | tool | what it does |
 |---|---|
-| `start(task, kind, repo, cwd, files, readonly, engine, max_usd, effort, base, max_turns, policy, verify, isolation, max_retries, adversarial, context_refs, auto_repomap, tier)` | start one job (see below) |
-| `start_many(tasks)` | start several; partial success is listed per item. Items with `id` and `depends_on` form a group (`grp-…`) run as a DAG without extra turns |
+| `start(task, kind, repo, cwd, files, readonly, engine, max_usd, effort, base, max_turns, policy, verify, isolation, max_retries, adversarial, context_refs, auto_repomap, tier, invariants, allowed_paths, symbol_scope, oracle_cmd)` | start one job (see below) |
+| `start_many(tasks)` | start several; partial success is listed per item. Items with `id` and `depends_on` form a group (`grp-…`) run as a DAG without extra turns; `foreach=<parent id>` makes one copy per item of the parent's `.subtask/fanout.json` (at most 8), and dependents wait for every copy; `after="any"` starts when one parent succeeded |
 | `integrate(ids, action="apply", auto_resolve=False)` | worktree jobs back: `diff`, `apply` (all or nothing, uncommitted), `discard`; `auto_resolve` starts a reconciliation job on conflict |
+| `consensus(prompt, engines, verify_cmd, isolation="worktree")` | 2 to 4 engines solve it blind in their own worktrees, then one job compares their diffs as anonymous patches and writes one solution, checked by `verify_cmd` and the invariants; returns a group id |
+| `bisect(good_ref, bad_ref, test_cmd, parallelism=4, auto_fix=False)` | first commit that makes `test_cmd` fail, testing up to `parallelism` (max 8) commits per round in temporary worktrees; returns the commit, author and diff; `auto_fix` starts a verified fix job |
 | `map_reduce(glob_pattern, prompt_template, batch_size=5, concurrency=3, verify_cmd, isolation="worktree")` | one job per batch of files (`{{files}}` in the template), at most `concurrency` at a time; returns a group id |
 | `wait(ids, timeout=300, mode="all", since=None, stall_timeout=None)` | block until they end (`any`: the first; `first_success`: the first done and verified, the others are stopped); returns early on a stalled job; progress notifications while waiting; `since` cursor for clients without progress |
 | `steer(id, action, instruction=None)` | `hint` (queued, sent as a reply when the attempt ends), `abort`, `retry` (fresh job with the instruction) |
@@ -102,6 +104,16 @@ Options of `start`:
   Builder's worktree and run with `verify`.
 - `context_refs`: `file:PATH[:A-B]`, `git:diff[:REF]`, `subtask:ID:summary|diff`, resolved before start.
   `auto_repomap=True` adds tracked files with their top-level symbols (cached per HEAD).
+- `invariants` (default `["no_test_deletion", "no_suppression"]`, `[]` turns them off): before `verify` counts,
+  test functions may not decrease, no new skip/xfail markers, no new `# type: ignore`, `# noqa` or
+  `# pragma: no cover`. A violation is a failed check with the reason, so a retry sees it.
+- `allowed_paths`: files changed outside these paths are put back and the revert is committed.
+- `symbol_scope=["path.py::name", ...]`: only those top-level functions or classes may change in those
+  files. `integrate` then merges several jobs' edits to one Python file symbol by symbol; overlaps,
+  import or constant changes, and symbols changed on the target meanwhile are a conflict, never a guess.
+- `oracle_cmd`: after a passing `verify`, runs the command on the job's base and on its result at the same
+  time and reports whether exit code and stdout match, plus `duration_ms_before`, `duration_ms_after`,
+  `speedup_pct`.
 - `tier`: `fast` (effort low), `deep` (effort high, kind hard), `free_only`. Past 75% of the monthly cap,
   `auto` and `balanced` go to free engines and the reply carries `budget_warning`.
 

{subtask_mcp-0.3.1 → subtask_mcp-0.4.4}/subtask/__init__.py

@@ -1,3 +1,3 @@
 """subtask: background sub-agents for coding agents."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.4"

subtask_mcp-0.4.4/subtask/ast_merge.py

@@ -0,0 +1,124 @@
+"""Merge Python files by top-level symbol instead of by line.
+
+Each job's change to a file is read as a set of replaced, added or removed
+top-level functions and classes. When the jobs' sets do not overlap, and none
+of them changes module-level statements (imports, constants), the symbols are
+grafted onto the base text one by one. Anything else is a conflict: nothing is
+guessed.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+
+MODULE = "<module>"
+DEFS = (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+
+
+class Conflict(Exception):
+    pass
+
+
+def _lines(text: str) -> list[str]:
+    """Lines as ast counts them: only \\n ends a line (splitlines also splits on form feeds)."""
+    if re.search(r"\r(?!\n)", text):
+        raise SyntaxError("lone carriage return")
+    return re.findall(r"[^\n]*\n|[^\n]+$", text)
+
+
+def _main_guard(tree: ast.Module) -> int | None:
+    """First line of a top-level `if __name__ == "__main__":`, where new symbols must go before."""
+    for node in tree.body:
+        test = getattr(node, "test", None)
+        is_compare = isinstance(node, ast.If) and isinstance(test, ast.Compare)
+        if is_compare and isinstance(test.left, ast.Name) and test.left.id == "__name__":
+            return node.lineno
+    return None
+
+
+def _parts(text: str) -> tuple[dict[str, tuple[int, int, str]], list[str]]:
+    """{name: (first line, last line, source)} for top-level defs, and everything else.
+
+    A second def with the same name is keyed name#2. Everything outside the defs (statements,
+    comments) is kept as non-blank text, so a change there is a module-level change.
+    """
+    tree = ast.parse(text)
+    lines = _lines(text)
+    defs: dict[str, tuple[int, int, str]] = {}
+    taken = [False] * (len(lines) + 1)
+    for node in tree.body:
+        if not isinstance(node, DEFS):
+            continue
+        start = min([node.lineno] + [d.lineno for d in node.decorator_list])
+        end = node.end_lineno or node.lineno
+        name, n = node.name, 1
+        while name in defs:
+            n += 1
+            name = f"{node.name}#{n}"
+        defs[name] = (start, end, "".join(lines[start - 1 : end]))
+        for i in range(start, end + 1):
+            taken[i] = True
+    other = [line.strip() for i, line in enumerate(lines, 1) if not taken[i] and line.strip()]
+    return defs, other
+
+
+def changed_symbols(old: str, new: str) -> set[str]:
+    """Top-level names whose source differs; MODULE when other statements differ. Raises SyntaxError."""
+    old_defs, old_other = _parts(old) if old else ({}, [])
+    new_defs, new_other = _parts(new) if new else ({}, [])
+    names = {
+        n
+        for n in old_defs.keys() | new_defs.keys()
+        if (old_defs.get(n) or (0, 0, ""))[2] != (new_defs.get(n) or (0, 0, ""))[2]
+    }
+    if old_other != new_other:
+        names.add(MODULE)
+    return names
+
+
+def graft(base: str, versions: list[tuple[str, str, str]]) -> str:
+    """Apply each (job id, its base text, its new text) symbol by symbol onto base. Raises Conflict."""
+    try:
+        base_defs, _ = _parts(base)
+    except SyntaxError as exc:
+        raise Conflict(f"base is not valid Python ({exc.msg})") from exc
+    owner: dict[str, str] = {}
+    edits: list[tuple[str, str | None]] = []  # (name, new source or None for removed)
+    for job_id, old, text in versions:
+        try:
+            new_defs, _ = _parts(text)
+            old_defs, _ = _parts(old) if old else ({}, [])
+            names = changed_symbols(old, text)
+        except SyntaxError as exc:
+            raise Conflict(f"{job_id}: not valid Python ({exc.msg})") from exc
+        if MODULE in names:
+            raise Conflict(f"{job_id} changes module-level statements (imports or constants)")
+        for name in names:
+            if name in owner:
+                raise Conflict(f"{owner[name]} and {job_id} both change {name}")
+            owner[name] = job_id
+            if (base_defs.get(name) or (0, 0, ""))[2] != (old_defs.get(name) or (0, 0, ""))[2]:
+                raise Conflict(f"{name} changed on the target too since {job_id} started")
+            edits.append((name, new_defs[name][2] if name in new_defs else None))
+    lines = _lines(base)
+    added = "".join(
+        source.rstrip("\n") + "\n\n\n"
+        for _, source in sorted(e for e in edits if e[0] not in base_defs)
+        if source
+    )
+    guard = _main_guard(ast.parse(base))
+    # (first line, last line, new text); applied bottom-up so earlier line numbers stay valid
+    ops = [(base_defs[n][0], base_defs[n][1], src or "") for n, src in edits if n in base_defs]
+    if added and guard is not None:  # before the main block, which may call them
+        ops.append((guard, guard - 1, added))
+    for start, end, src in sorted(ops, key=lambda o: (-o[0], -o[1])):
+        lines[start - 1 : end] = [src] if src else []
+    text = "".join(lines)
+    if added and guard is None:
+        text = text.rstrip("\n") + "\n\n\n" + added.rstrip("\n") + "\n"
+    try:
+        ast.parse(text)
+    except SyntaxError as exc:
+        raise Conflict(f"merged file is not valid Python ({exc.msg})") from exc
+    return text

subtask_mcp-0.4.4/subtask/bisect_tool.py

@@ -0,0 +1,141 @@
+"""K-ary parallel bisect: test up to K commits at once to find the first one that breaks a check.
+
+The commits between good (passes) and bad (fails) are taken in first-parent
+order. Each round tests K evenly spaced commits in temporary worktrees, at the
+same time, and keeps the interval between the last pass and the first failure.
+Rounds needed: about log_(K+1) of the commit count. Worktrees are always removed.
+"""
+
+from __future__ import annotations
+
+import secrets
+import shutil
+import subprocess
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from . import config, jobs
+
+TIMEOUT_S = 900
+MAX_COMMITS = 5000
+MAX_DIFF = 12000
+
+
+def _git(repo: str, *args: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["git", "-C", repo, *args], capture_output=True, text=True, timeout=120, check=False
+    )
+
+
+def _passes(repo: str, commit: str, cmd: str) -> bool:
+    scratch = str(config.HOME / "bisect" / secrets.token_hex(4))
+    try:
+        if _git(repo, "worktree", "add", "-q", "--detach", scratch, commit).returncode != 0:
+            raise RuntimeError(f"worktree for {commit[:9]} not created")
+        try:
+            done = subprocess.run(
+                ["sh", "-c", cmd], cwd=scratch, capture_output=True, timeout=TIMEOUT_S, check=False,
+                stdin=subprocess.DEVNULL,
+            )  # fmt: skip
+            return done.returncode == 0
+        except subprocess.TimeoutExpired:
+            return False
+    finally:
+        _git(repo, "worktree", "remove", "--force", scratch)
+        shutil.rmtree(scratch, ignore_errors=True)
+
+
+def _note(run: str, **fields) -> None:
+    """Progress a client panel can show while the bisect runs (subtask board)."""
+    path = config.HOME / "bisect-runs" / f"{run}.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists():  # keep the folder small: the 20 newest runs
+        for stale in sorted(path.parent.glob("*.json"), key=lambda p: p.stat().st_mtime)[:-19]:
+            stale.unlink(missing_ok=True)
+    old = jobs.read_json(path) if path.is_file() else {}
+    jobs.write_json(path, {**old, **fields, "updated": time.time()})
+
+
+def recent(limit: int = 3, max_age_s: float = 86400) -> list[dict]:
+    folder = config.HOME / "bisect-runs"
+    if not folder.is_dir():
+        return []
+    rows = [
+        jobs.read_json(p)
+        for p in sorted(folder.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+    ]
+    return [r for r in rows if time.time() - float(r.get("updated") or 0) < max_age_s][:limit]
+
+
+def find(repo: str, good: str, bad: str, cmd: str, parallelism: int = 4) -> dict:
+    """{'commit', 'rounds', 'tested'} or {'error'}."""
+    resolved = []
+    for ref in (good, bad):
+        if ref.startswith("-"):
+            return {"error": f"invalid ref: {ref}"}
+        done = _git(repo, "rev-parse", "--verify", "--end-of-options", ref + "^{commit}")
+        if done.returncode != 0:
+            return {"error": f"unknown ref: {ref}"}
+        resolved.append(done.stdout.strip())
+    good_sha, bad_sha = resolved
+    if _git(repo, "merge-base", "--is-ancestor", good_sha, bad_sha).returncode != 0:
+        return {"error": "good_ref is not an ancestor of bad_ref"}
+    commits = _git(repo, "rev-list", "--first-parent", "--reverse", f"{good_sha}..{bad_sha}").stdout.split()
+    if not commits or len(commits) > MAX_COMMITS:
+        return {"error": f"{len(commits)} commits between good and bad (1 to {MAX_COMMITS} allowed)"}
+    k = max(1, min(int(parallelism), 8))
+    run = "bis-" + secrets.token_hex(4)
+    _note(run, id=run, test_cmd=cmd, candidates=len(commits), round=0, tested=0, state="running")
+    try:
+        return _search(repo, commits, cmd, k, run)
+    except (RuntimeError, OSError, subprocess.SubprocessError) as exc:
+        _note(run, state="failed", error=str(exc)[:200])
+        return {"error": f"bisect stopped: {exc}"}
+
+
+def _search(repo: str, commits: list[str], cmd: str, k: int, run: str) -> dict:
+    lo, hi = -1, len(commits) - 1  # commits[lo] passes (-1 = good), commits[hi] fails (bad)
+    rounds, tested = 0, 0
+    with ThreadPoolExecutor(k) as pool:
+        confirmed = False  # bad_ref itself is tested in the first round
+        while hi - lo > 1 or not confirmed:
+            span = hi - lo - 1
+            picks = sorted({lo + 1 + (span * (i + 1)) // (k + 1) for i in range(min(k, span))})
+            if not confirmed:
+                picks = sorted(set(picks) | {hi})
+            results = dict(zip(picks, pool.map(lambda i: _passes(repo, commits[i], cmd), picks)))
+            if not confirmed:
+                confirmed = True
+                if results[hi]:
+                    _note(run, state="failed", error="test_cmd passes on bad_ref")
+                    return {"error": "test_cmd passes on bad_ref: nothing to find"}
+            rounds, tested = rounds + 1, tested + len(picks)
+            _note(run, round=rounds, tested=tested, left=max(hi - lo - 1, 0))
+            for i in picks:  # the interval ends at the first failing pick
+                if results[i]:
+                    lo = i
+                else:
+                    hi = i
+                    break
+    _note(run, state="done", commit=commits[hi], round=rounds, tested=tested, left=0)
+    return {"commit": commits[hi], "rounds": rounds, "tested": tested, "candidates": len(commits)}
+
+
+def report(repo: str, found: dict) -> str:
+    if found.get("error"):
+        return found["error"]
+    sha = found["commit"]
+    meta = _git(repo, "show", "-s", "--format=%H%n%an <%ae>%n%ad%n%s", sha).stdout.strip()
+    diff = _git(repo, "show", "--stat", "--patch", "--format=", sha).stdout
+    diff = diff[:MAX_DIFF] + ("\n… diff cut" if len(diff) > MAX_DIFF else "")
+    head = (
+        f"first bad commit: {meta}\n"
+        f"{found['candidates']} candidates, {found['tested']} tested in {found['rounds']} parallel rounds"
+    )
+    return head + "\n\n" + diff
+
+
+FIX_TASK = (
+    "Commit {sha} made `{cmd}` fail. Fix the regression without undoing what that commit was for. "
+    "Run the check, commit, and finish with a ## Summary.\n\nThe commit:\n{diff}"
+)

{subtask_mcp-0.3.1 → subtask_mcp-0.4.4}/subtask/cli.py

@@ -117,6 +117,9 @@ def main() -> int:
         from . import stephook
 
         return stephook.main()
+    if a.cmd == "install-skill":
+        print("\n".join(install_commands.install_skill(a.dest, a.client)))
+        return 0
     if a.cmd in ("install", "uninstall") or (a.cmd == "doctor" and a.client):
         return install_commands.run(a)
 

{subtask_mcp-0.3.1 → subtask_mcp-0.4.4}/subtask/core.py

@@ -97,6 +97,10 @@ def start(
     context_refs: list[str] | None = None,
     auto_repomap: bool = False,
     tier: str = "auto",
+    invariants: list[str] | None = None,
+    allowed_paths: list[str] | None = None,
+    symbol_scope: list[str] | None = None,
+    oracle_cmd: str | None = None,
     _breaker: str | None = None,
     _group: str | None = None,
 ) -> str:
@@ -112,6 +116,17 @@ def start(
         return "max_retries needs verify"
     if tier not in TIERS:
         return "tier must be " + "|".join(TIERS)
+    from . import invariants as inv
+
+    problem = inv.validate(invariants, allowed_paths, symbol_scope)
+    if problem:
+        return problem
+    if oracle_cmd is not None and not (isinstance(oracle_cmd, str) and oracle_cmd.strip()):
+        return "oracle_cmd must be a non-empty command"
+    if oracle_cmd and not (repo or isolation == "worktree") or oracle_cmd and readonly:
+        return "oracle_cmd needs a worktree (repo or isolation=worktree)"
+    if (allowed_paths or symbol_scope) and not (repo or isolation == "worktree"):
+        return "allowed_paths and symbol_scope need a worktree (repo or isolation=worktree)"
     tier, budget_warning = _degrade(tier)
     if tier == "fast" and effort == "medium":
         effort = "low"
@@ -147,7 +162,9 @@ def start(
         breaker = broke.split()[0]
         built = start(
             task, engine, repo, None, base, False, max_usd, max_turns, effort, model, sandbox, kind,
-            files, policy, verify, untrusted, progress, max_retries=max_retries, _breaker=breaker, _group=_group,
+            files, policy, verify, untrusted, progress, max_retries=max_retries, invariants=invariants,
+            allowed_paths=allowed_paths, symbol_scope=symbol_scope, oracle_cmd=oracle_cmd, _breaker=breaker,
+            _group=_group,
         )  # fmt: skip
         if "already running" in built:  # no slot now: a group starts the Builder when one frees
             from . import groups
@@ -156,7 +173,8 @@ def start(
                 "task": task, "engine": engine, "repo": repo, "base": base, "max_usd": max_usd,
                 "max_turns": max_turns, "effort": effort, "model": model, "kind": kind, "files": files,
                 "policy": policy, "verify": verify, "untrusted": untrusted, "max_retries": max_retries,
-                "_breaker": breaker,
+                "invariants": invariants, "allowed_paths": allowed_paths, "symbol_scope": symbol_scope,
+                "oracle_cmd": oracle_cmd, "_breaker": breaker,
             }])  # fmt: skip
             return f"breaker {broke}\nbuilder queued in {queued.split()[0]}"
         if " started " not in built:
@@ -220,6 +238,12 @@ def start(
             except subprocess.CalledProcessError as exc:
                 raise _Compensate(f"worktree not created: {exc.stderr.strip()[:200]}") from exc
             task += f"\n\nYou work in an isolated git worktree on branch {branch}. Commit your work there; never push."
+            if allowed_paths:
+                task += "\nChange only these paths; anything else is reverted: " + ", ".join(allowed_paths)
+            if symbol_scope:
+                task += "\nIn those Python files change only these top-level symbols: " + ", ".join(
+                    symbol_scope
+                )
         else:
             workdir = str(Path(cwd or repo or os.getcwd()).resolve())
             if not Path(workdir).is_dir():
@@ -243,6 +267,10 @@ def start(
             "policy": {**wanted, "effective": effective, "why": why},
             "verify": verify,
             "max_retries": max_retries,
+            "invariants": inv.DEFAULT if invariants is None else invariants,
+            "allowed_paths": allowed_paths,
+            "symbol_scope": symbol_scope,
+            "oracle_cmd": oracle_cmd,
             "breaker": _breaker,
             "port": _free_port() if branch else None,
             "group": _group,
@@ -559,7 +587,8 @@ def wait(
 
         for group_id in group_ids:
             groups.cancel(group_id, f"cancelled: first_success {winner}")
-        losers = [j for j in job_ids if j != winner and j not in ended]
+        job_ids, _ = _expand(asked)  # a group job started while we looked is a loser too
+        losers = [j for j in job_ids if j != winner and jobs.status(j).get("state") not in jobs.FINAL]
         for job_id in losers:
             jobs.stop(job_id)
         head = f"first success: {winner}" + (f" · stopped {', '.join(losers)}" if losers else "")
@@ -571,6 +600,83 @@ def wait(
     return ("no job succeeded\n\n" + out) if mode == "first_success" else out
 
 
+def bisect(
+    good_ref: str,
+    bad_ref: str,
+    test_cmd: str,
+    parallelism: int = 4,
+    auto_fix: bool = False,
+    repo: str | None = None,
+    engine: str = "auto",
+    max_usd: float | None = None,
+) -> str:
+    """Find the first commit between good_ref and bad_ref that makes test_cmd fail."""
+    from . import bisect_tool
+
+    if not (isinstance(test_cmd, str) and test_cmd.strip()):
+        return "test_cmd must be a non-empty command"
+    if isinstance(parallelism, bool) or not isinstance(parallelism, int) or not 1 <= parallelism <= 8:
+        return "parallelism must be between 1 and 8"
+    root = _repo_of(str(Path(repo or os.getcwd()).resolve()))
+    if not root:
+        return "bisect needs a git repository"
+    found = bisect_tool.find(root, good_ref, bad_ref, test_cmd, parallelism)
+    text = bisect_tool.report(root, found)
+    if found.get("error") or not auto_fix:
+        return text
+    diff = text.split("\n\n", 1)[-1]
+    task = bisect_tool.FIX_TASK.format(sha=found["commit"][:12], cmd=test_cmd, diff=diff)
+    out = start(task, engine, root, base="HEAD", max_usd=max_usd, verify=test_cmd, max_retries=1)
+    return text[:2000] + f"\n\nfix job: {out}"
+
+
+CONSENSUS_TASK = (
+    "Several engines solved the task below independently, each on its own branch. Their results are "
+    "attached as Patch A, Patch B, ... (summary and diff). Compare them, keep the strongest ideas, drop "
+    "the bugs of each, and write ONE solution in your worktree. Do not merge the branches. Commit, run "
+    "the checks, and finish with a ## Summary saying what you took from which patch.\n\nTask:\n"
+)
+
+
+def consensus(
+    prompt: str,
+    engines: list[str],
+    verify_cmd: str | None = None,
+    isolation: str = "worktree",
+    repo: str | None = None,
+    cwd: str | None = None,
+    max_usd: float | None = None,
+    synth_engine: str = "auto",
+) -> str:
+    """Round 1: every engine works blind in its own worktree. Round 2: one job merges the best."""
+    if isolation != "worktree":
+        return "consensus needs isolation=worktree"
+    if not isinstance(engines, list) or not 2 <= len(engines) <= 4 or len(set(engines)) != len(engines):
+        return "engines must list 2 to 4 different engines"
+    unknown = [e for e in engines if registry.get(e) is None]
+    if unknown:
+        return f"unknown engine: {', '.join(unknown)}"
+    if not (isinstance(prompt, str) and prompt.strip()):
+        return "prompt must be a non-empty string"
+    root = _repo_of(str(Path(repo or cwd or os.getcwd()).resolve()))
+    if not root:
+        return "consensus needs a git repository"
+    base = {"repo": root, "max_usd": max_usd, "verify": verify_cmd}
+    rounds = [{"id": f"r{i + 1}", "task": prompt, "engine": e, **base} for i, e in enumerate(engines)]
+    refs = []
+    for i in range(len(engines)):
+        refs += [f"subtask:r{i + 1}:summary", f"subtask:r{i + 1}:diff"]
+    labels = ", ".join(f"Patch {chr(65 + i)} = subtask:r{i + 1}:diff" for i in range(len(engines)))
+    synth = {
+        "id": "synthesis", "depends_on": [r["id"] for r in rounds], "after": "any", "engine": synth_engine,
+        "task": CONSENSUS_TASK + prompt + f"\n\n({labels}; the engine names are hidden on purpose.)",
+        "context_refs": refs, **base,
+    }  # fmt: skip
+    from . import groups
+
+    return groups.create(rounds + [synth], label="consensus")
+
+
 def start_many(tasks: list[dict], progress=None) -> str:
     """Start several jobs in one call; each dict takes start()'s arguments.
 
@@ -635,6 +741,12 @@ def result(job_id: str, full: bool = False, evidence: bool = False, _count: bool
         except subprocess.CalledProcessError:
             pass
     verification = st.get("verification")
+    if verification and verification.get("oracle"):
+        from . import oracle
+
+        head += "\n" + oracle.line(verification["oracle"])
+    if verification and verification.get("invariants"):
+        head += "\ninvariants violated: " + "; ".join(verification["invariants"][:5])
     if verification:
         code = verification.get("exit_code")
         head += (
@@ -933,6 +1045,16 @@ def steps(limit: int = 10) -> str:
     return "\n".join(f"{r['ts']} {Path(r['repo']).name}: {r['title']} ({r['path']})" for r in rows)
 
 
+def _oracle_short(report: dict | None) -> dict | None:
+    if not report:
+        return None
+    if report.get("error"):
+        return {"error": report["error"]}
+    return {"output_match": bool(report.get("output_match") and report.get("exit_match")),
+            "speedup_pct": report.get("speedup_pct"), "ms_before": report.get("duration_ms_before"),
+            "ms_after": report.get("duration_ms_after")}  # fmt: skip
+
+
 def board_data(limit: int = 10) -> dict:
     """What a client panel shows: active groups with their queue, recent jobs, verify and budget."""
     from . import groups
@@ -947,7 +1069,8 @@ def board_data(limit: int = 10) -> dict:
                 "id": path.stem, "kind": g.get("kind"), "label": g.get("label"),
                 "summary": groups.summary(path.stem),
                 "tasks": [{"alias": t["alias"], "state": t["state"], "job": t.get("job"),
-                           "depends_on": t.get("depends_on", []), "why": t.get("why", "")} for t in tasks],
+                           "depends_on": t.get("depends_on", []), "why": t.get("why", ""),
+                           "expanded_from": t.get("expanded_from")} for t in tasks],
             })  # fmt: skip
     job_rows = []
     for job_id in jobs.all_jobs()[:limit]:
@@ -963,11 +1086,16 @@ def board_data(limit: int = 10) -> dict:
             "retrying": verifier.pending(st), "rolled_back_to": st.get("rolled_back_to"),
             "stalled": watchdog.check(job_id, st), "started": sp.get("created"),
             "budget_warning": sp.get("budget_warning"),
+            "invariants": v.get("invariants") or [], "reverted": v.get("reverted") or [],
+            "oracle": _oracle_short(v.get("oracle")),
         })  # fmt: skip
+    from . import bisect_tool
+
     spent = ledger.committed()
     return {
         "groups": group_rows,
         "jobs": job_rows,
+        "bisects": bisect_tool.recent(),
         "budget": {"cap_usd": config.MONTHLY_CAP_USD, "committed_usd": round(spent, 2),
                    "left_usd": round(config.MONTHLY_CAP_USD - spent, 2)},
     }  # fmt: skip
@@ -980,8 +1108,9 @@ def board(limit: int = 10) -> str:
         lines.append(f"{g['id']} {g['kind']} {g['label'] or ''} · {g['summary']}".replace("  ", " "))
         for t in g["tasks"]:
             deps = f" ← {', '.join(t['depends_on'])}" if t["depends_on"] else ""
+            fan = f" (from {t['expanded_from']})" if t.get("expanded_from") else ""
             lines.append(
-                f"  {t['alias']}: {t['job'] or t['state']}{deps}{' · ' + t['why'] if t['why'] else ''}"
+                f"  {t['alias']}{fan}: {t['job'] or t['state']}{deps}{' · ' + t['why'] if t['why'] else ''}"
             )
     for j in data["jobs"]:
         bits = [j["state"], j["engine"] or "?"]
@@ -993,7 +1122,21 @@ def board(limit: int = 10) -> str:
             bits.append(f"rolled back to {j['rolled_back_to']}")
         if j["stalled"]:
             bits.append(f"STALLED {j['stalled']}")
+        if j["invariants"]:
+            bits.append(f"INVARIANT {j['invariants'][0][:60]}")
+        if j["reverted"]:
+            bits.append(f"reverted {len(j['reverted'])} file(s) outside allowed_paths")
+        o = j["oracle"]
+        if o:
+            same = "error" if o.get("error") else "same output" if o["output_match"] else "OUTPUT DIFFERS"
+            pct = o.get("speedup_pct")
+            bits.append(f"oracle {same}" + ("" if pct is None else f" {pct:+.0f}%"))
         lines.append(f"{j['id']} " + " · ".join(bits))
+    for b in data["bisects"]:
+        found = f" → {b['commit'][:9]}" if b.get("commit") else ""
+        lines.append(
+            f"{b['id']} bisect {b['state']} · round {b['round']} · {b['tested']}/{b['candidates']} tested{found}"
+        )
     b = data["budget"]
     lines.append(f"budget: {b['left_usd']:.2f}$ left of {b['cap_usd']:.0f}$")
     return "\n".join(lines)

{subtask_mcp-0.3.1 → subtask_mcp-0.4.4}/subtask/fastserver.py

@@ -132,6 +132,16 @@ def _call(name: str, args: dict, call: Call) -> str:
         from . import integrate
 
         return integrate.integrate(args["ids"], args.get("action", "apply"), args.get("auto_resolve", False))
+    if name == "consensus":
+        known = {"prompt", "engines", "verify_cmd", "isolation", "repo", "max_usd"}
+        if set(args) - known:
+            raise TypeError(f"unexpected argument(s): {', '.join(sorted(set(args) - known))}")
+        return core.consensus(**args)
+    if name == "bisect":
+        known = {"good_ref", "bad_ref", "test_cmd", "parallelism", "auto_fix", "repo"}
+        if set(args) - known:
+            raise TypeError(f"unexpected argument(s): {', '.join(sorted(set(args) - known))}")
+        return core.bisect(**args)
     if name == "inspect":
         return core.inspect(args["id"], args.get("tail", 80), args.get("grep"))
     if name == "steer":
@@ -155,7 +165,7 @@ def _call(name: str, args: dict, call: Call) -> str:
 START_ARGS = {
     "task", "kind", "repo", "cwd", "files", "readonly", "engine", "max_usd", "effort",
     "base", "max_turns", "policy", "verify", "isolation", "max_retries", "adversarial",
-    "context_refs", "auto_repomap", "tier",
+    "context_refs", "auto_repomap", "tier", "invariants", "allowed_paths", "symbol_scope", "oracle_cmd",
 }  # fmt: skip