aria-code 0.115.0__tar.gz → 0.117.0__tar.gz

{aria_code-0.115.0/src/aria_code.egg-info → aria_code-0.117.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.115.0
+Version: 0.117.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.115.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.115.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.117.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.117.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.115.0 → aria_code-0.117.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.115.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.115.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.117.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.117.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.115.0 → aria_code-0.117.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.115.0"
+version = "0.117.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.115.0 → aria_code-0.117.0}/src/aria_code/_version.py

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

{aria_code-0.115.0 → aria_code-0.117.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.115.0 → aria_code-0.117.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.115.0 → aria_code-0.117.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.115.0 → aria_code-0.117.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.115.0 → aria_code-0.117.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.115.0 → aria_code-0.117.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.115.0 → aria_code-0.117.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
 
 

{aria_code-0.115.0 → aria_code-0.117.0}/src/aria_code/runtime/subagent.py

@@ -114,6 +114,7 @@ def restore_tasks() -> int:
     explicit interrupted task rather than silently disappearing.
     """
     restored = 0
+    interrupted = []
     for record in _ledger().restore():
         task_id = str(record.get("task_id") or "").strip()
         if not task_id or task_id in _TASKS:
@@ -141,8 +142,16 @@ def restore_tasks() -> int:
             handoff=dict(record.get("handoff") or {}),
         )
         _TASKS[task_id] = task
-        _persist(task)
+        if status == "interrupted" and record.get("status") == "running":
+            interrupted.append(task.snapshot())
         restored += 1
+    if interrupted:
+        # Completed/queued records have not changed. Persist all interrupted
+        # records together; per-task upserts made restoration quadratic.
+        try:
+            _ledger().upsert_many(interrupted)
+        except Exception:
+            pass  # Persistence failure must not discard restored live state.
     return restored
 
 

{aria_code-0.115.0 → aria_code-0.117.0}/src/aria_code/runtime/task_ledger.py

@@ -69,18 +69,32 @@ class TaskLedger:
                 os.unlink(temp_name)
 
     def upsert(self, record: Mapping[str, Any]) -> None:
-        task_id = str(record.get("task_id") or "").strip()
-        if not task_id:
-            raise ValueError("Task record requires task_id")
-        records = self.load()
-        snapshot = dict(record)
-        snapshot["updated_at"] = time.time()
-        result = str(snapshot.get("result") or "")
-        if len(result) > MAX_RESULT_CHARS:
-            snapshot["result"] = result[:MAX_RESULT_CHARS] + "\n…[truncated in task ledger]"
-            snapshot["result_truncated"] = True
-        records[task_id] = snapshot
-        self.save(records)
+        self.upsert_many((record,))
+
+    def upsert_many(self, records: Iterable[Mapping[str, Any]]) -> None:
+        """Persist a batch with one read and one atomic replacement.
+
+        Validate the entire batch before touching disk. Restoring interrupted
+        tasks at startup must not rewrite the full ledger for every task.
+        """
+        snapshots = {}
+        updated_at = time.time()
+        for record in records:
+            task_id = str(record.get("task_id") or "").strip()
+            if not task_id:
+                raise ValueError("Task record requires task_id")
+            snapshot = dict(record)
+            snapshot["updated_at"] = updated_at
+            result = str(snapshot.get("result") or "")
+            if len(result) > MAX_RESULT_CHARS:
+                snapshot["result"] = result[:MAX_RESULT_CHARS] + "\n…[truncated in task ledger]"
+                snapshot["result_truncated"] = True
+            snapshots[task_id] = snapshot
+        if not snapshots:
+            return
+        stored = self.load()
+        stored.update(snapshots)
+        self.save(stored)
 
     def restore(self) -> Iterable[dict[str, Any]]:
         return self.load().values()

aria_code-0.117.0/src/aria_code/runtime/windows_job.py

@@ -0,0 +1,115 @@
+"""Keep a Windows background command's descendants in one owned Job Object.
+
+Lazy-imported only on Windows. Closing the last handle kills descendants,
+including those still running after the command's original parent exited.
+This manages lifetime; it is not a filesystem/network sandbox.
+"""
+from __future__ import annotations
+
+import ctypes as c
+from ctypes import wintypes as w
+
+
+class _Limits(c.Structure):
+    _fields_ = [("process_time", c.c_longlong), ("job_time", c.c_longlong),
+                ("flags", w.DWORD), ("min_working", c.c_size_t), ("max_working", c.c_size_t),
+                ("active_limit", w.DWORD), ("affinity", c.c_size_t),
+                ("priority", w.DWORD), ("scheduling", w.DWORD)]
+
+
+class _IOCounters(c.Structure):
+    _fields_ = [(name, c.c_ulonglong) for name in ("read_ops", "write_ops", "other_ops",
+                                                 "read_bytes", "write_bytes", "other_bytes")]
+
+
+class _ExtendedLimits(c.Structure):
+    _fields_ = [("basic", _Limits), ("io", _IOCounters), ("process_memory", c.c_size_t),
+                ("job_memory", c.c_size_t), ("peak_process_memory", c.c_size_t),
+                ("peak_job_memory", c.c_size_t)]
+
+
+class _Accounting(c.Structure):
+    _fields_ = [(name, c.c_longlong) for name in ("user_time", "kernel_time", "period_user", "period_kernel")]
+    _fields_ += [(name, w.DWORD) for name in ("page_faults", "total", "active", "terminated")]
+
+
+class _ThreadEntry(c.Structure):
+    _fields_ = [("size", w.DWORD), ("usage", w.DWORD), ("thread_id", w.DWORD),
+                ("owner_pid", w.DWORD), ("priority", w.LONG), ("delta", w.LONG), ("flags", w.DWORD)]
+
+
+class WindowsJob:
+    def __init__(self, popen):
+        self.api = c.WinDLL("kernel32", use_last_error=True)
+        signatures = {
+            "CreateJobObjectW": ([c.c_void_p, w.LPCWSTR], w.HANDLE),
+            "SetInformationJobObject": ([w.HANDLE, c.c_int, c.c_void_p, w.DWORD], w.BOOL),
+            "AssignProcessToJobObject": ([w.HANDLE, w.HANDLE], w.BOOL),
+            "QueryInformationJobObject": ([w.HANDLE, c.c_int, c.c_void_p, w.DWORD, c.c_void_p], w.BOOL),
+            "TerminateJobObject": ([w.HANDLE, w.UINT], w.BOOL),
+            "CloseHandle": ([w.HANDLE], w.BOOL),
+            "CreateToolhelp32Snapshot": ([w.DWORD, w.DWORD], w.HANDLE),
+            "Thread32First": ([w.HANDLE, c.POINTER(_ThreadEntry)], w.BOOL),
+            "Thread32Next": ([w.HANDLE, c.POINTER(_ThreadEntry)], w.BOOL),
+            "OpenThread": ([w.DWORD, w.BOOL, w.DWORD], w.HANDLE),
+            "ResumeThread": ([w.HANDLE], w.DWORD),
+        }
+        for name, (args, result) in signatures.items():
+            fn = getattr(self.api, name)
+            fn.argtypes, fn.restype = args, result
+        self.handle = self.api.CreateJobObjectW(None, None)
+        if not self.handle:
+            raise c.WinError(c.get_last_error())
+        try:
+            limits = _ExtendedLimits()
+            limits.basic.flags = 0x2000  # JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+            if not self.api.SetInformationJobObject(self.handle, 9, c.byref(limits), c.sizeof(limits)):
+                raise c.WinError(c.get_last_error())
+            if not self.api.AssignProcessToJobObject(self.handle, int(popen._handle)):
+                raise c.WinError(c.get_last_error())
+        except BaseException:
+            self.close()
+            raise
+
+    def resume(self, pid: int) -> None:
+        # Popen closes CreateProcess's thread handle. Find the sole suspended
+        # initial thread using the documented Toolhelp API, then resume it.
+        snapshot = self.api.CreateToolhelp32Snapshot(0x4, 0)  # TH32CS_SNAPTHREAD
+        if snapshot == c.c_void_p(-1).value:
+            raise c.WinError(c.get_last_error())
+        try:
+            entry = _ThreadEntry()
+            entry.size = c.sizeof(entry)
+            more = self.api.Thread32First(snapshot, c.byref(entry))
+            while more:
+                if entry.owner_pid == pid:
+                    thread = self.api.OpenThread(0x2, False, entry.thread_id)  # THREAD_SUSPEND_RESUME
+                    if not thread:
+                        raise c.WinError(c.get_last_error())
+                    try:
+                        if self.api.ResumeThread(thread) == 0xFFFFFFFF:
+                            raise c.WinError(c.get_last_error())
+                        return
+                    finally:
+                        self.api.CloseHandle(thread)
+                more = self.api.Thread32Next(snapshot, c.byref(entry))
+            raise OSError("Cannot find the background command's suspended thread")
+        finally:
+            self.api.CloseHandle(snapshot)
+
+    def running(self) -> bool:
+        if not self.handle:
+            return False
+        info = _Accounting()
+        if not self.api.QueryInformationJobObject(self.handle, 1, c.byref(info), c.sizeof(info), None):
+            raise c.WinError(c.get_last_error())
+        return bool(info.active)
+
+    def terminate(self) -> None:
+        if self.handle and not self.api.TerminateJobObject(self.handle, 1):
+            raise c.WinError(c.get_last_error())
+
+    def close(self) -> None:
+        if self.handle:
+            self.api.CloseHandle(self.handle)
+            self.handle = None