subtask-mcp 0.2.3__tar.gz → 0.2.6__tar.gz

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subtask-mcp
-Version: 0.2.3
+Version: 0.2.6
 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
@@ -70,7 +70,7 @@ The distribution is `subtask-mcp` (the PyPI name `subtask` is an unrelated
 project). Full guide, per client, with native commands: [docs/install.md](docs/install.md).
 
 ```sh
-uv tool install "git+https://github.com/tedin7/subtask@v0.2.3"   # or: uv tool install /path/to/checkout
+uv tool install "git+https://github.com/tedin7/subtask@v0.2.6"   # or: uv tool install /path/to/checkout
 subtask install --client all          # prints the plan for every detected client
 subtask install --client all --yes    # applies it: MCP server + skill
 subtask doctor --client all           # checks app, config entry and a real handshake

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/README.md

@@ -39,7 +39,7 @@ The distribution is `subtask-mcp` (the PyPI name `subtask` is an unrelated
 project). Full guide, per client, with native commands: [docs/install.md](docs/install.md).
 
 ```sh
-uv tool install "git+https://github.com/tedin7/subtask@v0.2.3"   # or: uv tool install /path/to/checkout
+uv tool install "git+https://github.com/tedin7/subtask@v0.2.6"   # or: uv tool install /path/to/checkout
 subtask install --client all          # prints the plan for every detected client
 subtask install --client all --yes    # applies it: MCP server + skill
 subtask doctor --client all           # checks app, config entry and a real handshake

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/subtask/__init__.py

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

subtask_mcp-0.2.6/subtask/install/claude_plugin.py

@@ -0,0 +1,134 @@
+"""Claude Code through its plugin: one server, one skill, one hook, from one place.
+
+The plugin (marketplace `subtask` in the tedin7/subtask repository) carries the
+MCP server, the skill and the timing hook. Installing it this way replaces the
+older route (a user-scope `claude mcp add` entry plus a copied skill), so the
+server is never registered twice. Everything goes through `claude plugin ...`
+commands; the only file subtask touches is its own skill copy, and only when
+the ownership record says it is ours.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from . import ownership
+from .clients import Claude, InstallError, run_native
+from .fileops import read_bytes, sha256
+from .installer import Outcome
+
+MARKETPLACE = "subtask"
+SOURCE = "tedin7/subtask"
+PLUGIN = f"subtask@{MARKETPLACE}"
+SERVER = "plugin:subtask:subtask"
+
+
+def _out(argv: list[str], timeout: float = 60) -> str:
+    try:
+        done = subprocess.run(
+            argv, capture_output=True, text=True, timeout=timeout, check=False, stdin=subprocess.DEVNULL
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        raise InstallError(f"{' '.join(argv[:3])}: {exc}") from exc
+    return done.stdout + done.stderr
+
+
+def state(c: Claude) -> dict:
+    exe = c.exe() or "claude"
+    markets = _out([exe, "plugin", "marketplace", "list"])
+    plugins = _out([exe, "plugin", "list"])
+    return {
+        "marketplace": f"❯ {MARKETPLACE}" in markets
+        or f" {MARKETPLACE}\n" in markets
+        or MARKETPLACE in markets.split(),
+        "plugin": PLUGIN in plugins,
+        "legacy_entry": c.read_entry("user"),
+        "skill": c.skill_path("user"),
+    }
+
+
+def _ours(path: Path, client: str = "claude") -> bool:
+    cur = read_bytes(path)
+    rec = ownership.get(ownership.key(client, "user", "skill", path))
+    return cur is not None and bool(rec) and rec.get("sha") == sha256(cur)
+
+
+def install(c: Claude, apply: bool, force: bool, source: str = SOURCE) -> Outcome:
+    out = Outcome(client="claude", scope="user")
+    exe = c.exe() or "claude"
+    st = state(c)
+    steps: list[list[str]] = []
+    if st["marketplace"]:
+        steps.append([exe, "plugin", "marketplace", "update", MARKETPLACE])
+    else:
+        steps.append([exe, "plugin", "marketplace", "add", source])
+    steps.append([exe, "plugin", "update" if st["plugin"] else "install", PLUGIN])
+    legacy = st["legacy_entry"]
+    if legacy:
+        target = " ".join(Claude.target(legacy) or [])
+        if "subtask-mcp" in target or force:
+            steps.append([exe, "mcp", "remove", "-s", "user", "subtask"])  # the plugin now provides it
+        else:
+            out.status = "collision"
+            out.notes.append(
+                f"a user-scope 'subtask' entry runs {target!r}; use --force to replace it with the plugin"
+            )
+            return out
+    skill: Path = st["skill"]
+    remove_skill = skill.is_file() and (_ours(skill) or force)
+    if skill.is_file() and not remove_skill:
+        out.notes.append(f"{skill} is not ours: kept (the plugin also ships the skill)")
+    out.steps = [f"run: {' '.join(s)}" for s in steps] + (
+        [f"remove: {skill} (the plugin ships it)"] if remove_skill else []
+    )
+    if not apply:
+        return out
+    try:
+        for argv in steps:
+            run_native(argv)
+        if remove_skill:
+            skill.unlink()
+            try:
+                skill.parent.rmdir()
+            except OSError:
+                pass
+            ownership.drop(ownership.key("claude", "user", "skill", skill))
+    except InstallError as exc:
+        out.status = "error"
+        out.notes.append(str(exc))
+        return out
+    out.status = "done"
+    return out
+
+
+def uninstall(c: Claude, apply: bool) -> Outcome:
+    out = Outcome(client="claude", scope="user")
+    exe = c.exe() or "claude"
+    if PLUGIN not in _out([exe, "plugin", "list"]):
+        out.status = "unchanged"
+        out.notes.append("plugin not installed")
+        return out
+    out.steps = [f"run: {exe} plugin uninstall {PLUGIN}"]
+    if apply:
+        try:
+            run_native([exe, "plugin", "uninstall", PLUGIN])
+        except InstallError as exc:
+            out.status = "error"
+            out.notes.append(str(exc))
+            return out
+        out.status = "done"
+    return out
+
+
+def doctor(c: Claude) -> dict:
+    exe = c.exe()
+    report = {"client": "claude", "scope": "user", "mode": "plugin", "present": bool(exe),
+              "version": c.version() if exe else None}  # fmt: skip
+    if not exe:
+        return {**report, "connects": False, "error": "claude not on PATH"}
+    listing = _out([exe, "mcp", "list"], timeout=120)
+    line = next((x for x in listing.splitlines() if x.startswith(SERVER)), "")
+    duplicate = any(x.startswith("subtask:") for x in listing.splitlines())
+    return {**report, "configured": bool(line), "connects": "Connected" in line and "failed" not in line.lower(),
+            "line": line.strip()[:160], "duplicate_user_entry": duplicate}  # fmt: skip

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/subtask/install/commands.py

@@ -8,6 +8,7 @@ import sys
 from pathlib import Path
 from typing import Any
 
+from . import claude_plugin
 from .clients import CLIENTS, Client, InstallError
 from .doctor import doctor
 from .installer import install, uninstall
@@ -37,6 +38,9 @@ def add_parsers(sub: argparse._SubParsersAction) -> None:
     i.add_argument(
         "--force", action="store_true", help="replace an existing 'subtask' entry that is not ours"
     )
+    for p in (i, u, d):
+        p.add_argument("--no-plugin", action="store_true",
+                       help="claude: register the server with `claude mcp add` instead of the plugin")  # fmt: skip
     i.add_argument("--command", help="server command to register (default: subtask-mcp next to this python)")
 
 
@@ -63,8 +67,14 @@ def _selected(name: str) -> tuple[list[Client], list[str]]:
 
 def run(a: argparse.Namespace) -> int:
     clients, missing = _selected(a.client)
+    use_plugin = a.scope == "user" and not getattr(a, "no_plugin", False)
     if a.cmd == "doctor":
-        reports = [doctor(c, a.scope) for c in clients]
+        reports = [
+            claude_plugin.doctor(c)
+            if use_plugin and c.name == "claude" and _plugin_mode(c)
+            else doctor(c, a.scope)
+            for c in clients
+        ]
         ok = all(r.get("connects") for r in reports) and bool(reports)
         _emit(a.json, {"action": "doctor", "clients": reports, "not_detected": missing}, _doctor_text)
         return 0 if ok else 1
@@ -80,9 +90,18 @@ def run(a: argparse.Namespace) -> int:
             results.append({"client": c.name, "scope": a.scope, "status": "skipped",
                             "steps": [], "notes": [f"{c.binary} not found on PATH; install the app first"]})  # fmt: skip
             continue
-        out = (
-            install(c, a.scope, argv, apply, a.force) if a.cmd == "install" else uninstall(c, a.scope, apply)
-        )
+        if c.name == "claude" and use_plugin:
+            out = (
+                claude_plugin.install(c, apply, a.force)
+                if a.cmd == "install"
+                else claude_plugin.uninstall(c, apply)
+            )
+        else:
+            out = (
+                install(c, a.scope, argv, apply, a.force)
+                if a.cmd == "install"
+                else uninstall(c, a.scope, apply)
+            )
         results.append(out.as_dict())
     data = {"action": a.cmd, "applied": apply, "command": argv, "clients": results, "not_detected": missing}
     _emit(a.json, data, _plan_text)
@@ -90,6 +109,13 @@ def run(a: argparse.Namespace) -> int:
     return 1 if bad else 0
 
 
+def _plugin_mode(c) -> bool:
+    try:
+        return claude_plugin.state(c)["plugin"]
+    except InstallError:
+        return False
+
+
 def _emit(as_json: bool, data: dict[str, Any], render) -> None:
     print(json.dumps(data, indent=2) if as_json else render(data))
 
@@ -111,6 +137,17 @@ def _doctor_text(d: dict[str, Any]) -> str:
     for r in d["clients"]:
         hs = r.get("handshake") or {}
         lines.append(f"[{r['client']}] app: {'yes ' + str(r['version']) if r['present'] else 'not found'}")
+        if r.get("mode") == "plugin":
+            lines.append(f"  plugin: {r.get('line') or 'not listed by claude mcp list'}")
+            lines.append(
+                f"  connects: {'yes' if r.get('connects') else 'no'}"
+                + (
+                    "  WARNING: also a separate user-scope 'subtask' entry"
+                    if r.get("duplicate_user_entry")
+                    else ""
+                )
+            )
+            continue
         lines.append(f"  config: {r.get('config')}  configured: {'yes' if r.get('configured') else 'no'}")
         if r.get("command"):
             lines.append(f"  command: {' '.join(r['command'])}  exists: {r.get('command_exists')}")

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/subtask/worker.py

@@ -147,6 +147,13 @@ def main() -> int:
                 error=None,
             )
         emit("start", f"{spec['engine']} attempt {attempt}", state="running")
+        if adapter.capabilities.paid and not rid:
+            # Started by an older server that left the booking to the worker (v0 jobs):
+            # reserve here, so the spend still counts against the monthly cap.
+            rid = f"{job_id}#w{attempt}-{os.getpid()}"
+            if ledger.reserve(rid, job_id, float(spec["max_usd"])) is None:
+                rid = None
+                raise RuntimeError(f"monthly cap {config.MONTHLY_CAP_USD} $ reached")
         if not Path(spec["cwd"]).is_dir():
             raise RuntimeError(f"working folder is gone: {spec['cwd']} (cleaned up?)")
         level = (spec.get("policy") or {}).get("effective")

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/subtask_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subtask-mcp
-Version: 0.2.3
+Version: 0.2.6
 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
@@ -70,7 +70,7 @@ The distribution is `subtask-mcp` (the PyPI name `subtask` is an unrelated
 project). Full guide, per client, with native commands: [docs/install.md](docs/install.md).
 
 ```sh
-uv tool install "git+https://github.com/tedin7/subtask@v0.2.3"   # or: uv tool install /path/to/checkout
+uv tool install "git+https://github.com/tedin7/subtask@v0.2.6"   # or: uv tool install /path/to/checkout
 subtask install --client all          # prints the plan for every detected client
 subtask install --client all --yes    # applies it: MCP server + skill
 subtask doctor --client all           # checks app, config entry and a real handshake

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/subtask_mcp.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ subtask/engines/kimi.py
 subtask/engines/opencode.py
 subtask/engines/registry.py
 subtask/install/__init__.py
+subtask/install/claude_plugin.py
 subtask/install/clients.py
 subtask/install/commands.py
 subtask/install/doctor.py

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/tests/test_concurrency.py

@@ -273,3 +273,27 @@ def test_missing_active_index_does_not_forget_running_jobs(home):
     assert sorted(admission.active()) == sorted([first, second])
     core.stop(first)
     core.stop(second)
+
+
+def test_job_started_by_an_old_server_still_books_its_spend(home, monkeypatch):
+    """v0 spec/status (no attempts, no reservation): the worker reserves and settles itself."""
+    import signal
+
+    from subtask import jobs, ledger, worker
+
+    job = "st-v0v0v0v0v0"
+    folder = jobs.job_dir(job)
+    folder.mkdir(parents=True)
+    jobs.write_json(folder / "spec.json", {"task": "x", "engine": "fake", "cwd": str(home), "max_usd": 2.0,
+                                           "max_turns": 5, "effort": "low", "created": time.time()})  # fmt: skip
+    jobs.write_json(folder / "status.json", {"state": "queued"})
+    monkeypatch.setenv("SUBTASK_FAKE_SCRIPT", 'echo \'{"say":"ok"}\'')
+    monkeypatch.setattr(sys, "argv", ["worker", job])
+    old = signal.getsignal(signal.SIGTERM)
+    try:
+        worker.main()
+    finally:
+        signal.signal(signal.SIGTERM, old)
+    assert jobs.status(job)["state"] == "done"
+    assert ledger.committed() == pytest.approx(0.25)
+    assert ledger.open_for(job) == []

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/tests/test_install.py

@@ -46,7 +46,8 @@ def env():
 
 
 def cli(e: dict, *args: str, cwd: Path | None = None) -> tuple[int, dict]:
-    proc = subprocess.run([sys.executable, "-m", "subtask.cli", *args, "--json"], env=e,
+    # These tests cover the `claude mcp add` route; plugin mode has its own tests below.
+    proc = subprocess.run([sys.executable, "-m", "subtask.cli", *args, "--json", "--no-plugin"], env=e,
                           capture_output=True, text=True, timeout=120, cwd=cwd or e["HOME"], check=False)  # fmt: skip
     return proc.returncode, json.loads(proc.stdout)
 
@@ -364,3 +365,54 @@ def test_opencode_jsonc_is_read_and_never_rewritten_with_comments(tmp_path, monk
     assert (
         clients.strip_jsonc('{"a": "http://x//y", /* c */ "b": [1,],}') == '{"a": "http://x//y",  "b": [1]}'
     )
+
+
+def test_claude_plugin_mode_replaces_the_legacy_entry_and_skill(tmp_path, monkeypatch):
+    from subtask.install import claude_plugin, clients, ownership
+    from subtask.install.fileops import sha256
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+    c = clients.CLIENTS["claude"]()
+    (tmp_path / ".claude.json").write_text(
+        json.dumps({"mcpServers": {"subtask": {"command": "/x/bin/subtask-mcp", "args": []}}})
+    )
+    skill = c.skill_path("user")
+    skill.parent.mkdir(parents=True)
+    skill.write_bytes(b"old skill")
+    ownership.put(ownership.key("claude", "user", "skill", skill), {"sha": sha256(b"old skill")})
+    ran: list[list[str]] = []
+    listings = {
+        "marketplace": "Configured marketplaces:\n\n  ❯ claude-code-lsps\n",
+        "plugin": "Installed plugins:\n",
+    }
+    monkeypatch.setattr(
+        claude_plugin,
+        "_out",
+        lambda argv, timeout=60: listings["marketplace" if "marketplace" in argv else "plugin"],
+    )
+    monkeypatch.setattr(claude_plugin, "run_native", lambda argv: ran.append(argv))
+    monkeypatch.setattr(c, "exe", lambda: "claude")
+    plan = claude_plugin.install(c, apply=False, force=False)
+    assert ran == [] and skill.is_file()  # plan only
+    out = claude_plugin.install(c, apply=True, force=False)
+    assert out.status == "done", out.notes
+    assert ran == [
+        ["claude", "plugin", "marketplace", "add", "tedin7/subtask"],
+        ["claude", "plugin", "install", "subtask@subtask"],
+        ["claude", "mcp", "remove", "-s", "user", "subtask"],
+    ]
+    assert not skill.exists() and plan.steps[-1].startswith("remove:")
+
+
+def test_claude_plugin_mode_refuses_a_foreign_entry_without_force(tmp_path, monkeypatch):
+    from subtask.install import claude_plugin, clients
+
+    monkeypatch.setenv("HOME", str(tmp_path))
+    c = clients.CLIENTS["claude"]()
+    (tmp_path / ".claude.json").write_text(
+        json.dumps({"mcpServers": {"subtask": {"command": "/other/tool"}}})
+    )
+    monkeypatch.setattr(claude_plugin, "_out", lambda argv, timeout=60: "")
+    monkeypatch.setattr(claude_plugin, "run_native", lambda argv: (_ for _ in ()).throw(AssertionError(argv)))
+    monkeypatch.setattr(c, "exe", lambda: "claude")
+    assert claude_plugin.install(c, apply=True, force=False).status == "collision"

{subtask_mcp-0.2.3 → subtask_mcp-0.2.6}/tests/test_routing_results.py

@@ -196,16 +196,23 @@ def test_doctor_reports_without_spending(home):
 
 
 def test_active_index_makes_counting_independent_of_history(home):
+    """Counting must not grow with finished jobs: compare with an empty history, not a fixed time."""
     from subtask import admission, config, jobs
 
+    def per_call() -> float:
+        t = time.perf_counter()
+        for _ in range(20):
+            admission.count()
+        return (time.perf_counter() - t) / 20
+
+    admission.count()
+    empty = per_call()
     for i in range(300):
         folder = config.JOBS / f"st-old{i:05d}"
         folder.mkdir(parents=True)
         jobs.write_json(folder / "status.json", {"state": "done"})
-    t = time.perf_counter()
-    for _ in range(20):
-        admission.count()
-    assert (time.perf_counter() - t) / 20 < 0.02  # does not scan 300 finished jobs
+    full = per_call()
+    assert full < empty * 3 + 0.005, (empty, full)  # O(history) would be ~300x
 
 
 def test_narrator_context_includes_observed_activity_not_only_intentions(home):