aria-code 0.114.0__tar.gz → 0.116.0__tar.gz

{aria_code-0.114.0/src/aria_code.egg-info → aria_code-0.116.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.114.0
+Version: 0.116.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -27,6 +27,7 @@ Requires-Dist: google-genai>=1.0.0
 Requires-Dist: aiohttp>=3.9.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: prompt_toolkit>=3.0.43
+Requires-Dist: Pillow>=10.4.0
 Requires-Dist: PyYAML>=6.0.2
 Requires-Dist: requests>=2.32.0
 Requires-Dist: httpx[http2]>=0.27.0
@@ -171,7 +172,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.114.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.114.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.116.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.116.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.114.0 → aria_code-0.116.0}/README.md

@@ -15,7 +15,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.114.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.114.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.116.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.116.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.114.0 → aria_code-0.116.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.114.0"
+version = "0.116.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -57,6 +57,7 @@ dependencies = [
     "aiohttp>=3.9.0",
     "rich>=13.7.0",
     "prompt_toolkit>=3.0.43",
+    "Pillow>=10.4.0",       # original mascot image; loaded only when drawing it
     "PyYAML>=6.0.2",
     "requests>=2.32.0",
     "httpx[http2]>=0.27.0",
@@ -275,6 +276,7 @@ include = ["aria_code*"]
 
 [tool.setuptools.package-data]
 "*" = ["*.yaml", "*.json", "*.md", "*.txt", "*.sh"]
+"aria_code.ui" = ["assets/*.png"]
 
 # ── Ruff linting ───────────────────────────────────────────────────────────────
 [tool.ruff]

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.114.0"
+__version__ = "0.116.0"

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/apps/cli/prompts/system_prompts.py

@@ -9,6 +9,13 @@ from __future__ import annotations
 from datetime import datetime as _dt
 
 
+def _chinese_date() -> str:
+    # Windows strftime passes format strings through the locale's code page;
+    # a Chinese literal in the format can crash import under an English locale.
+    now = _dt.now()
+    return f"{now.year:04d}年{now.month:02d}月{now.day:02d}日"
+
+
 # ── Language utilities ────────────────────────────────────────────────────────
 
 def detect_lang(text: str) -> str:
@@ -70,7 +77,7 @@ def build_response_style_rule(lang: str) -> str:
 
 def build_coding_prompt_lite(user_message: str) -> str:
     """Condensed coding system prompt for small models (<=3B parameters)."""
-    today = _dt.now().strftime("%Y年%m月%d日")
+    today = _chinese_date()
     low = user_message.lower()
     is_financial = any(k in low for k in (
         "股票", "行情", "投资", "量化", "交易", "回测", "策略", "持仓", "组合",
@@ -200,7 +207,7 @@ def build_coding_prompt_lite(user_message: str) -> str:
 
 def build_analysis_prompt_lite(user_message: str) -> str:
     """Condensed analysis prompt for small models (<=3B)."""
-    today = _dt.now().strftime("%Y年%m月%d日")
+    today = _chinese_date()
     lang = detect_lang(user_message)
     lr = LANG_RULE[lang]
     if lang == "en":
@@ -249,7 +256,7 @@ def build_finance_prompt(user_message: str = "") -> str:
     except Exception:
         _fpb = ""
 
-    today = _dt.now().strftime("%Y年%m月%d日")
+    today = _chinese_date()
     weekday = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"][_dt.now().weekday()]
     lang = detect_lang(user_message)
     lr = LANG_RULE[lang]
@@ -486,7 +493,7 @@ def build_prefetched_analysis_prompt(nano: bool = False, user_message: str = "")
     nano=True: ultra-minimal prompt for 1-3B models.
     nano=False: structured prompt for 7B+ models.
     """
-    today = _dt.now().strftime("%Y年%m月%d日")
+    today = _chinese_date()
     lang = detect_lang(user_message)
 
     if nano:

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/apps/cli/providers/llm/ollama_stream.py

@@ -547,7 +547,8 @@ async def stream_ollama(ollama_url: str, message: str, history: list,
     elif _intent == "general":
         # 纯知识/概念问题：注入日期，但不注入工具 schema
         from datetime import datetime as _dt2
-        _today_str = _dt2.now().strftime("%Y年%m月%d日")
+        _today = _dt2.now()
+        _today_str = f"{_today.year:04d}年{_today.month:02d}月{_today.day:02d}日"
         _base_prompt = (
             f"你是 Aria，Arthera 的 AI 助手。今天是 {_today_str}。\n"
             "你的能力覆盖：金融量化分析、足球/体育赛事分析与预测（含泊松算法）、编程、通用知识问答。\n\n"

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/apps/cli/providers/llm/sse_stream.py

@@ -10,6 +10,18 @@ import json
 from typing import Callable, Optional
 
 
+def _client_tool_history(history: list) -> list:
+    """Keep matching call/result IDs and never cut into a tool-result batch."""
+    from aria_code.providers.tool_messages import to_openai_tool_protocol
+    normalized = to_openai_tool_protocol(history)
+    start = max(0, len(normalized) - 20)
+    # A parallel batch may have more than 20 results. Include its assistant
+    # call message as well, rather than orphaning the results or dropping them.
+    while start > 0 and normalized[start].get("role") == "tool":
+        start -= 1
+    return normalized[start:]
+
+
 def build_chat_payload(
     message: str,
     history: list,
@@ -27,6 +39,7 @@ def build_chat_payload(
     This is deliberately pure: it gives CLI, desktop, and iOS an auditable
     parity point without forcing the local-first CLI to use cloud services.
     """
+    history = _client_tool_history(history) if local_tool_execution else history[-20:]
     payload: dict
     if use_react_gateway:
         context = dict(user_context or {})
@@ -40,7 +53,7 @@ def build_chat_payload(
             },
             "mode": mode,
             "surface": "aria_code",
-            "history": history[-20:],
+            "history": history,
             "model": {"id": model or "auto", "effort": thinking_mode or "auto"},
             "context": context,
         }
@@ -50,7 +63,7 @@ def build_chat_payload(
 
     payload = {
         "message": message,
-        "conversation_history": history[-20:],
+        "conversation_history": history,
         "model": model,
         "thinking_mode": thinking_mode,
         "stream": True,

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/apps/cli/tools/system_tools.py

@@ -186,7 +186,9 @@ def tool_run_command(
         timeout = min(params.get("timeout", 120), 300)
         use_shell = True
         argv = None
-        if decision.risk == "low":
+        # POSIX shlex strips Windows path backslashes. Keep CMD's own parsing
+        # on Windows, after the same policy and permission checks above.
+        if decision.risk == "low" and os.name != "nt":
             has_shell_meta = any(ch in command for ch in ["|", "&", ";", "<", ">", "$", "`", "\n"])
             if not has_shell_meta:
                 try:

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/doctor.py

@@ -696,6 +696,19 @@ def _iter_optional_modules() -> Iterable[tuple[str, str, str]]:
     yield "akshare", "China A-share market data", "cn"
 
 
+def sandbox_check(config: Dict[str, Any]) -> DoctorCheck:
+    """Report the actual command confinement available on this machine."""
+    from aria_code.safety.sandbox import capability
+    mode = str(config.get("permission_mode", "workspace-write"))
+    kind = "disabled" if mode == "full-access" else capability(config.get("os_sandbox"))
+    if kind == "policy-only":
+        return _check("command_sandbox", "warn", f"{mode}: command policy only; no OS filesystem/network confinement",
+                      "Install bubblewrap on Linux; Windows currently uses command policy only.")
+    if kind == "disabled":
+        return _check("command_sandbox", "skip", "OS command sandbox disabled by your settings")
+    return _check("command_sandbox", "ok", f"{mode}: {kind}; violations fail the command without an unconfined retry")
+
+
 def run_doctor(
     config: Optional[Dict[str, Any]] = None,
     *,
@@ -719,6 +732,8 @@ def run_doctor(
     if drift is not None:
         checks.append(drift)
 
+    checks.append(sandbox_check(config))
+
     if context_stats:
         _fill = float(context_stats.get("fill_ratio") or 0.0)
         _thr = float(context_stats.get("threshold") or 0.78)

aria_code-0.116.0/src/aria_code/evals/gap.py

@@ -0,0 +1,93 @@
+"""In-sample minus out-of-sample: public tasks against their private twins.
+
+A public task can end up in a model's training data, and a tuned model can
+learn the public bank instead of the skill. Either way it scores well on the
+public task and worse on a twin it has never seen: the same skill, with
+different data, numbers and wording, kept in a private repository. SWE-bench
+Pro reads leakage the same way, from the gap between its public and held-out
+splits; a quant reads overfitting from the gap between in-sample and
+out-of-sample returns.
+
+A holdout suite names each twin's public task with ``twin_of``. This pairs
+them, takes each side's pass rate over its repeats, and reports the mean gap
+(public minus twin) with a bootstrap 95% interval. An interval above zero is
+a warning that the public score overstates the skill.
+
+    python -m aria_code.evals.gap --public evals-*.json --holdout holdout.json --suites holdout/suites/*.yaml
+
+``--markdown`` prints counts and rates only, never a private task id, so the
+section can go into a public job summary.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Iterable
+
+from aria_code.training.compare import bootstrap_ci, rates
+
+
+def twins(suite_files: Iterable[Path]) -> dict[str, str]:
+    """Holdout task id -> the public task it is a twin of."""
+    import yaml
+
+    pairs = {}
+    for suite_file in suite_files:
+        doc = yaml.safe_load(Path(suite_file).read_text(encoding="utf-8")) or {}
+        pairs.update({str(t["id"]): str(t["twin_of"]) for t in doc.get("tasks") or [] if t.get("twin_of")})
+    return pairs
+
+
+def gap(public_reports: Iterable[Path], holdout_reports: Iterable[Path], pairs: dict[str, str]) -> dict:
+    public, _, _ = rates(public_reports)
+    holdout, _, _ = rates(holdout_reports)
+    rows = {h: (public[p], holdout[h]) for h, p in pairs.items() if p in public and h in holdout}
+    diffs = [pub - twin for pub, twin in rows.values()]
+    lo, hi = bootstrap_ci(diffs)
+    mean = sum(diffs) / len(diffs) if diffs else 0.0
+    return {
+        "pairs": len(rows),
+        "public_pass_rate": round(sum(p for p, _ in rows.values()) / len(rows), 4) if rows else None,
+        "twin_pass_rate": round(sum(t for _, t in rows.values()) / len(rows), 4) if rows else None,
+        "mean_gap": round(mean, 4),
+        "ci95": [round(lo, 4), round(hi, 4)],
+        "public_overstates": lo > 0,
+        "unpaired": sorted(h for h in pairs if h not in rows),
+    }
+
+
+def markdown(result: dict) -> str:
+    """The gap for a public summary: rates and the interval, no task ids."""
+    if not result["pairs"]:
+        return "### Public vs holdout\nNo twin pairs were scored on both sides.\n"
+    lo, hi = result["ci95"]
+    verdict = ("The public score overstates the skill: the interval is above 0." if result["public_overstates"]
+               else "No significant gap: the interval includes 0 or is below it.")
+    return "\n".join([
+        "### Public vs holdout",
+        f"{result['pairs']} twin pairs. Public {result['public_pass_rate']:.0%}, "
+        f"holdout {result['twin_pass_rate']:.0%}; gap {result['mean_gap']:+.0%} "
+        f"(95% CI {lo:+.0%} to {hi:+.0%}).",
+        verdict,
+        *([f"{len(result['unpaired'])} twins had no scored pair."] if result["unpaired"] else []),
+        "",
+    ])
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Gap between public tasks and their private twins.")
+    ap.add_argument("--public", nargs="+", type=Path, required=True)
+    ap.add_argument("--holdout", nargs="+", type=Path, required=True)
+    ap.add_argument("--suites", nargs="+", type=Path, required=True,
+                    help="the holdout suite YAML files (their tasks carry twin_of)")
+    ap.add_argument("--markdown", action="store_true", help="counts and rates only, safe for a public summary")
+    args = ap.parse_args(argv)
+    result = gap(args.public, args.holdout, twins(args.suites))
+    print(markdown(result) if args.markdown else json.dumps(result, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/evals/runner.py

@@ -43,9 +43,9 @@ class _TimedOut:
 
     returncode = 124
 
-    def __init__(self, seconds: int) -> None:
-        self.stderr = f"the agent was still working when the {seconds}s budget ran out"
-        self.stdout = ""
+    def __init__(self, seconds: int, stdout: str = "", stderr: str = "") -> None:
+        self.stderr = f"{stderr}\nthe agent was still working when the {seconds}s budget ran out".strip()
+        self.stdout = stdout
 
 
 class Trajectories:
@@ -148,7 +148,7 @@ def build_agent_solver(*, model: str = "", timeout: int = 900, local: bool = Fal
             if trajectories is not None:
                 trajectories.record(workspace.name, prompt, done.stdout)
             return done
-        except subprocess.TimeoutExpired:
+        except subprocess.TimeoutExpired as exc:
             # A truncated run is not a measured failure.
             #
             # I first scored this as FAIL, reasoning "it had its time and
@@ -158,7 +158,14 @@ def build_agent_solver(*, model: str = "", timeout: int = 900, local: bool = Fal
             # where back-to-back turns contend and get throttled. Scoring that
             # as FAIL blamed the model for the harness cutting it off — which
             # is precisely the confusion PASS/FAIL vs ERROR exists to prevent.
-            return _TimedOut(timeout)
+            # TimeoutExpired may carry bytes even with text=True. Keep partial
+            # tool events and diagnostics so a stalled run can be investigated.
+            def _text(value):
+                return value.decode("utf-8", errors="replace") if isinstance(value, bytes) else (value or "")
+            stdout, stderr = _text(exc.stdout), _text(exc.stderr)
+            if trajectories is not None:
+                trajectories.record(workspace.name, prompt, stdout)
+            return _TimedOut(timeout, stdout, stderr)
 
     return _solve
 

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/evals/summary.py

@@ -1,6 +1,11 @@
 """Turn eval reports into a Markdown scoreboard, and decide whether the run is healthy.
 
-    python3 -m aria_code.evals.summary evals-core.json evals-operations.json
+    python3 -m aria_code.evals.summary evals-core.json evals-operations.json [--private evals-holdout.json]
+
+Each suite's score comes with the mean per-task pass rate and its standard
+error, so two runs can be told apart from noise. A report passed after
+``--private`` (the holdout suites, kept in a private repository) is shown as
+counts only: no task ids, details or logs, because the summary is public.
 
 The suites ran in CI only with ``--check``: every fixture still starts red,
 but no model ever attempted them, so nothing measured whether Aria can fix
@@ -15,22 +20,50 @@ A task the model gets wrong is a result, not a broken build: the exit code is
 from __future__ import annotations
 
 import json
+import math
 import sys
+from collections import defaultdict
 from pathlib import Path
 
 
-def summarise(reports: list[dict], model: str = "") -> tuple[str, int]:
+def mean_sem(report: dict) -> tuple[float, float, int] | None:
+    """Mean per-task pass rate over scored attempts, its standard error, and the task count."""
+    passed: dict[str, int] = defaultdict(int)
+    scored: dict[str, int] = defaultdict(int)
+    for r in report.get("results") or []:
+        if str(r.get("outcome", "")).lower() in ("pass", "fail"):
+            scored[str(r.get("task_id"))] += 1
+            passed[str(r.get("task_id"))] += str(r.get("outcome")).lower() == "pass"
+    rates = [passed[t] / scored[t] for t in scored]
+    if not rates:
+        return None
+    mean = sum(rates) / len(rates)
+    if len(rates) < 2:
+        return mean, 0.0, 1
+    var = sum((x - mean) ** 2 for x in rates) / (len(rates) - 1)
+    return mean, math.sqrt(var / len(rates)), len(rates)
+
+
+def summarise(reports: list[dict], model: str = "", private: list[dict] | None = None) -> tuple[str, int]:
     """Markdown for the reports, and the exit code the run should have."""
     lines = [f"## Aria eval scoreboard{f' · {model}' if model else ''}", ""]
     unhealthy = 0
-    for report in reports:
+    for report in [*reports, *(private or [])]:
+        is_private = any(report is p for p in private or [])
         suite = report.get("suite", "?")
-        lines.append(f"### {suite}: {report.get('passed', 0)}/{report.get('scored', 0)} "
-                     f"({report.get('pass_rate', 0):.0%})")
+        lines.append(f"### {suite}{' (holdout)' if is_private else ''}: "
+                     f"{report.get('passed', 0)}/{report.get('scored', 0)} ({report.get('pass_rate', 0):.0%})")
+        stats = mean_sem(report)
+        if stats:
+            mean, sem, n = stats
+            lines.append(f"Mean task pass rate {mean:.0%} ± {sem:.0%} (SEM over {n} task{'s' if n != 1 else ''}).")
         extras = [f"{report[k]} {k}" for k in ("errored", "invalid") if report.get(k)]
         if extras:
             lines.append(f"Not scored: {', '.join(extras)}.")
         unhealthy += int(report.get("errored", 0)) + int(report.get("invalid", 0))
+        if is_private:
+            lines += ["Task ids, details and logs are not published for holdout suites.", ""]
+            continue
         lines += ["", "| Task | Outcome | Seconds | Detail |", "|---|---|---:|---|"]
         for result in report.get("results", []):
             detail = str(result.get("detail") or "").replace("|", "\\|")[:120]
@@ -56,17 +89,26 @@ def main(argv: list[str] | None = None) -> int:
     model = ""
     if args[:1] == ["--model"] and len(args) > 1:
         model, args = args[1], args[2:]
-    reports = []
-    for name in args:
-        path = Path(name)
-        if path.exists():
-            reports.append(json.loads(path.read_text(encoding="utf-8")))
-        else:
-            print(f"(no report at {name})", file=sys.stderr)
-    if not reports:
+    public_names, private_names = args, []
+    if "--private" in args:
+        i = args.index("--private")
+        public_names, private_names = args[:i], args[i + 1:]
+
+    def load(names: list[str]) -> list[dict]:
+        out = []
+        for name in names:
+            path = Path(name)
+            if path.exists():
+                out.append(json.loads(path.read_text(encoding="utf-8")))
+            else:
+                print(f"(no report at {name})", file=sys.stderr)
+        return out
+
+    reports, private = load(public_names), load(private_names)
+    if not reports and not private:
         print("no eval reports to summarise", file=sys.stderr)
         return 1
-    text, code = summarise(reports, model)
+    text, code = summarise(reports, model, private)
     print(text)
     return code
 

{aria_code-0.114.0 → aria_code-0.116.0}/src/aria_code/runtime/processes.py

@@ -23,6 +23,7 @@ import subprocess
 import threading
 import time
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Sequence
 
 MAX_RUNNING = 8
@@ -46,10 +47,13 @@ class _Process:
     read_upto: int = 0         # absolute position the caller has read to
     done: bool = False         # exited, and everything it printed has been read in
     changed: threading.Condition = field(default_factory=threading.Condition)
+    stop_lock: threading.Lock = field(default_factory=threading.Lock)
+    group_cleaned: bool = False
+    windows_job: object | None = None
 
     @property
     def running(self) -> bool:
-        return self.popen.poll() is None
+        return _group_running(self)
 
     def end(self) -> int:
         return self.dropped + len(self.text)
@@ -58,6 +62,60 @@ class _Process:
 _processes: dict[str, _Process] = {}
 
 
+def _group_running(proc: _Process) -> bool:
+    """The group may outlive its leader. Zombies have already stopped.
+
+    Linux CI's PID 1 may not reap orphan zombies promptly; killpg(..., 0)
+    alone therefore cannot tell whether a command is still executing.
+    """
+    if proc.group_cleaned:
+        return False
+    proc.popen.poll()  # reap our own child even while its children hold stdout
+    if os.name == "nt":
+        if proc.windows_job is not None:
+            active = proc.windows_job.running()
+            if not active:
+                proc.windows_job.close()
+                proc.group_cleaned = True
+            return active
+        return proc.popen.returncode is None
+    try:
+        os.killpg(proc.popen.pid, 0)
+    except ProcessLookupError:
+        proc.group_cleaned = True
+        return False
+    except PermissionError:
+        return True
+    if Path("/proc/self/stat").exists():
+        seen = False
+        for entry in Path("/proc").iterdir():
+            if not entry.name.isdecimal():
+                continue
+            try:
+                fields = (entry / "stat").read_text().rsplit(")", 1)[1].split()
+                if int(fields[2]) != proc.popen.pid:
+                    continue
+                seen = True
+                if fields[0] not in ("Z", "X"):
+                    return True
+            except (OSError, ValueError, IndexError):
+                continue
+        if seen:
+            proc.group_cleaned = True
+            return False
+    return True
+
+
+def _wait_group(proc: _Process, seconds: float) -> bool:
+    deadline = time.monotonic() + max(0.0, seconds)
+    while _group_running(proc):
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return False
+        time.sleep(min(0.05, remaining))
+    return True
+
+
 def _pump(proc: _Process) -> None:
     stream = proc.popen.stdout
     try:
@@ -77,6 +135,7 @@ def _pump(proc: _Process) -> None:
         pass
     finally:
         proc.popen.wait()
+        stream.close()
         with proc.changed:
             proc.done = True
             proc.changed.notify_all()
@@ -93,8 +152,21 @@ def start(argv: str | Sequence[str], *, shell: bool, cwd: str | None, label: str
         popen = subprocess.Popen(
             argv, shell=shell, cwd=cwd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT, start_new_session=True,
+            # The command must not spawn children before the Job owns it.
+            creationflags=0x4 if os.name == "nt" else 0,  # CREATE_SUSPENDED
         )
         proc = _Process(id=f"p{next(_ids)}", command=label, cwd=cwd or os.getcwd(), popen=popen)
+        if os.name == "nt":
+            from .windows_job import WindowsJob
+            try:
+                proc.windows_job = WindowsJob(popen)
+                proc.windows_job.resume(popen.pid)
+            except OSError as exc:
+                if proc.windows_job is not None:
+                    proc.windows_job.close()
+                popen.kill()
+                popen.communicate(timeout=5)
+                return {"success": False, "error": f"Cannot manage the background process tree: {exc}"}
         _processes[proc.id] = proc
     threading.Thread(target=_pump, args=(proc,), daemon=True, name=f"aria-{proc.id}").start()
     return {"success": True, "data": read(proc.id, wait=wait, until=until)["data"] | {"background": True}}
@@ -147,8 +219,8 @@ def read(process_id: str, *, wait: float = 0.0, until: str | None = None) -> dic
     data = {
         "process_id": proc.id,
         "command": proc.command,
-        "running": not proc.done,
-        "exit_code": proc.popen.returncode if proc.done else None,
+        "running": proc.running,
+        "exit_code": proc.popen.returncode,
         "output": new[-MAX_READ:],
     }
     if clipped or missed:
@@ -176,19 +248,35 @@ def stop(process_id: str, *, grace: float = 3.0) -> dict:
     proc = _get(process_id)
     if proc is None:
         return _unknown(process_id)
-    if proc.running:
-        for sig, pause in ((signal.SIGTERM, grace), (signal.SIGKILL, 2.0)):
+    error = ""
+    with proc.stop_lock:
+        if os.name == "nt" and proc.running:
             try:
-                os.killpg(proc.popen.pid, sig)
-            except (ProcessLookupError, PermissionError):
-                break
-            try:
-                proc.popen.wait(timeout=pause)
-                break
-            except subprocess.TimeoutExpired:
-                continue
+                proc.windows_job.terminate()
+                _wait_group(proc, 2.0)
+            except OSError as exc:
+                error = str(exc)
+        elif os.name != "nt":
+            for sig, pause in ((signal.SIGTERM, min(max(float(grace), 0), 30)),
+                               (signal.SIGKILL, 2.0)):
+                if not proc.running:
+                    break
+                try:
+                    os.killpg(proc.popen.pid, sig)
+                except ProcessLookupError:
+                    proc.group_cleaned = True
+                    break
+                except PermissionError as exc:
+                    error = str(exc)
+                    break
+                if _wait_group(proc, pause):
+                    break
+        if proc.popen.poll() is not None and proc.popen.stdin:
+            proc.popen.stdin.close()
     result = read(proc.id, wait=0.5)
-    result["data"]["stopped"] = True
+    result["data"]["stopped"] = not proc.running
+    if error or proc.running:
+        result.update(success=False, error=error or "The process group did not stop within the deadline.")
     return result