@hunter-harness/workflow-harness 0.2.42 → 0.2.43

package/harness/bundles/general/cursor/scripts/harness_service.py

@@ -1855,6 +1855,74 @@ def cmd_stop(args: argparse.Namespace) -> int:
     return 0 if result.get("ok") else 1
 
 
+def retire_stale_session(change_dir: Path) -> dict[str, Any]:
+    """Retire only Harness state whose recorded process identity is gone.
+
+    This operation never terminates a process or releases a live listener. The
+    original receipt is moved into an immutable evidence directory so a new
+    superseding session may be created safely.
+    """
+    change_dir = resolve_path(change_dir)
+    try:
+        session = load_session(change_dir)
+    except SessionCorrupt as exc:
+        return {
+            "ok": False,
+            "code": "SERVICE_SESSION_CORRUPT",
+            "action": "retire-refused",
+            "error": str(exc),
+            "unknownProcessUntouched": True,
+        }
+    if session is None:
+        return {
+            "ok": True,
+            "code": "SERVICE_SESSION_ABSENT",
+            "action": "already-retired",
+            "unknownProcessUntouched": True,
+        }
+    identity = verify_process_identity(session)
+    if identity is True:
+        return {
+            "ok": False,
+            "code": "SERVICE_PROCESS_STILL_OWNED",
+            "action": "retire-refused",
+            "unknownProcessUntouched": True,
+        }
+    if identity is None:
+        return {
+            "ok": False,
+            "code": "SERVICE_PROCESS_IDENTITY_UNVERIFIED",
+            "action": "retire-refused",
+            "unknownProcessUntouched": True,
+        }
+    source = session_path(change_dir)
+    raw_id = str(session.get("sessionId") or session.get("session_id") or "")
+    safe_id = re.sub(r"[^A-Za-z0-9._-]+", "-", raw_id).strip("-")
+    if not safe_id:
+        safe_id = sha256_text(json.dumps(session, sort_keys=True))[7:23]
+    retired_root = change_dir / "runtime" / "retired-service-sessions"
+    retired_root.mkdir(parents=True, exist_ok=True)
+    destination = retired_root / f"{safe_id}-{int(time.time() * 1000)}.json"
+    os.replace(source, destination)
+    receipt = {
+        "schemaVersion": 1,
+        "action": "retired-stale",
+        "code": "STALE_IDENTITY_RETIRED",
+        "retiredAt": now_iso(),
+        "retiredEvidence": str(destination),
+        "unknownProcessUntouched": True,
+        "sessionId": raw_id or None,
+    }
+    write_json(retired_root / f"{destination.stem}.receipt.json", receipt)
+    return {"ok": True, **receipt}
+
+
+def cmd_retire_stale(args: argparse.Namespace) -> int:
+    result = retire_stale_session(resolve_path(args.change_dir))
+    emit_json(result, as_json=bool(args.json))
+    return 0 if result.get("ok") else 1
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="harness_service.py",
@@ -1934,6 +2002,14 @@ def build_parser() -> argparse.ArgumentParser:
     p_stop.add_argument("--json", action="store_true")
     p_stop.set_defaults(func=cmd_stop)
 
+    p_retire = sub.add_parser(
+        "retire-stale",
+        help="retire stale Harness state without terminating unknown processes",
+    )
+    p_retire.add_argument("--change-dir", required=True)
+    p_retire.add_argument("--json", action="store_true")
+    p_retire.set_defaults(func=cmd_retire_stale)
+
     return parser
 
 

package/harness/bundles/general/cursor/scripts/harness_test_runner.py

@@ -37,7 +37,10 @@ DEFAULT_RESOURCE_MODULES = (
     "test_harness_integration.py",
     "test_harness_service.py",
 )
-DEFAULT_DETACHED_SERVICE_MODULES = ("test_harness_service.py",)
+DEFAULT_DETACHED_SERVICE_MODULES = (
+    "test_harness_service.py",
+    "test_harness_runtime.py",
+)
 TRUTHY_VALUES = frozenset({"1", "true", "yes", "on"})
 
 
@@ -189,16 +192,17 @@ def classify_test_lock(path: Path) -> dict[str, object]:
             "path": str(path),
             "token": payload.get("token"),
         }
-    if time.time() < float(expires):
-        return {
-            "classification": "ACTIVE",
-            "path": str(path),
-            "token": payload.get("token"),
-            "owner": owner,
-        }
+    unexpired = time.time() < float(expires)
     if not isinstance(owner, dict) or any(
         not owner.get(field) for field in ("pid", "executable", "startedAt")
     ):
+        if unexpired:
+            return {
+                "classification": "ACTIVE",
+                "path": str(path),
+                "token": payload.get("token"),
+                "owner": owner,
+            }
         return {
             "classification": "OWNER_IDENTITY_INCOMPLETE",
             "path": str(path),
@@ -207,6 +211,13 @@ def classify_test_lock(path: Path) -> dict[str, object]:
     try:
         owner_pid = int(owner["pid"])
     except (TypeError, ValueError):
+        if unexpired:
+            return {
+                "classification": "ACTIVE",
+                "path": str(path),
+                "token": payload.get("token"),
+                "owner": owner,
+            }
         return {
             "classification": "OWNER_IDENTITY_INCOMPLETE",
             "path": str(path),
@@ -219,6 +230,13 @@ def classify_test_lock(path: Path) -> dict[str, object]:
             "token": payload.get("token"),
             "owner": owner,
         }
+    if unexpired:
+        return {
+            "classification": "ACTIVE",
+            "path": str(path),
+            "token": payload.get("token"),
+            "owner": owner,
+        }
     verified = henv.hservice.verify_process_identity(
         {
             "pid": owner_pid,
@@ -244,7 +262,7 @@ def classify_test_lock(path: Path) -> dict[str, object]:
 
 
 def reap_test_lock(path: Path) -> dict[str, object]:
-    """Reap only an expired lock whose exact recorded owner is absent."""
+    """Reap only a lock whose exact recorded owner is definitely absent."""
     classification = classify_test_lock(path)
     reaped = classification.get("classification") == "RECLAIMABLE"
     if reaped:
@@ -484,6 +502,20 @@ class _WindowsBasicAccountingInformation(ctypes.Structure):
     ]
 
 
+_WINDOWS_JOB_PROCESS_ID_CAPACITY = 4096
+
+
+class _WindowsJobProcessIdList(ctypes.Structure):
+    _fields_ = [
+        ("NumberOfAssignedProcesses", ctypes.c_uint32),
+        ("NumberOfProcessIdsInList", ctypes.c_uint32),
+        (
+            "ProcessIdList",
+            ctypes.c_size_t * _WINDOWS_JOB_PROCESS_ID_CAPACITY,
+        ),
+    ]
+
+
 class _WindowsKillOnCloseJob:
     """Best-effort Windows Job Object that kills descendants when closed."""
 
@@ -491,9 +523,11 @@ class _WindowsKillOnCloseJob:
     _JOB_OBJECT_LIMIT_BREAKAWAY_OK = 0x00000800
     _JOB_OBJECT_EXTENDED_LIMIT_INFORMATION_CLASS = 9
     _JOB_OBJECT_BASIC_ACCOUNTING_INFORMATION_CLASS = 1
+    _JOB_OBJECT_BASIC_PROCESS_ID_LIST_CLASS = 3
 
-    def __init__(self) -> None:
+    def __init__(self, *, allow_breakaway: bool = False) -> None:
         self.handle: int | None = None
+        self.allow_breakaway = allow_breakaway
 
     def assign(self, process: subprocess.Popen[object]) -> bool:
         if os.name != "nt":
@@ -506,7 +540,11 @@ class _WindowsKillOnCloseJob:
         info = _WindowsExtendedLimitInformation()
         info.BasicLimitInformation.LimitFlags = (
             self._JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
-            | self._JOB_OBJECT_LIMIT_BREAKAWAY_OK
+            | (
+                self._JOB_OBJECT_LIMIT_BREAKAWAY_OK
+                if self.allow_breakaway
+                else 0
+            )
         )
         configured = kernel32.SetInformationJobObject(
             ctypes.c_void_p(handle),
@@ -535,26 +573,73 @@ class _WindowsKillOnCloseJob:
         ctypes.windll.kernel32.CloseHandle(ctypes.c_void_p(self.handle))
         self.handle = None
 
-    def terminate_and_wait(self, timeout_seconds: float = 5.0) -> None:
+    def terminate_and_wait(self, timeout_seconds: float = 5.0) -> bool:
         if self.handle is None:
-            return
+            return True
         kernel32 = ctypes.windll.kernel32
         handle = ctypes.c_void_p(self.handle)
-        kernel32.TerminateJobObject(handle, 1)
         deadline = time.monotonic() + max(0.0, timeout_seconds)
-        while time.monotonic() < deadline:
-            accounting = _WindowsBasicAccountingInformation()
-            queried = kernel32.QueryInformationJobObject(
-                handle,
-                self._JOB_OBJECT_BASIC_ACCOUNTING_INFORMATION_CLASS,
-                ctypes.byref(accounting),
-                ctypes.sizeof(accounting),
-                None,
-            )
-            if not queried or accounting.ActiveProcesses == 0:
-                break
-            time.sleep(0.02)
-        self.close()
+        process_ids = _WindowsJobProcessIdList()
+        process_list_queried = kernel32.QueryInformationJobObject(
+            handle,
+            self._JOB_OBJECT_BASIC_PROCESS_ID_LIST_CLASS,
+            ctypes.byref(process_ids),
+            ctypes.sizeof(process_ids),
+            None,
+        )
+        process_list_complete = bool(
+            process_list_queried
+            and process_ids.NumberOfAssignedProcesses
+            == process_ids.NumberOfProcessIdsInList
+        )
+        kernel32.OpenProcess.restype = ctypes.c_void_p
+        process_handles: list[int] = []
+        if process_list_complete:
+            for index in range(int(process_ids.NumberOfProcessIdsInList)):
+                process_handle = kernel32.OpenProcess(
+                    0x00100000,
+                    False,
+                    int(process_ids.ProcessIdList[index]),
+                )
+                if process_handle:
+                    process_handles.append(int(process_handle))
+                else:
+                    process_list_complete = False
+        terminated = bool(kernel32.TerminateJobObject(handle, 1))
+        handles_signaled = process_list_complete
+        try:
+            for process_handle in process_handles:
+                remaining_ms = max(
+                    0,
+                    int((deadline - time.monotonic()) * 1000),
+                )
+                if (
+                    kernel32.WaitForSingleObject(
+                        ctypes.c_void_p(process_handle),
+                        remaining_ms,
+                    )
+                    != 0
+                ):
+                    handles_signaled = False
+            accounting_drained = False
+            while time.monotonic() < deadline:
+                accounting = _WindowsBasicAccountingInformation()
+                queried = kernel32.QueryInformationJobObject(
+                    handle,
+                    self._JOB_OBJECT_BASIC_ACCOUNTING_INFORMATION_CLASS,
+                    ctypes.byref(accounting),
+                    ctypes.sizeof(accounting),
+                    None,
+                )
+                if queried and accounting.ActiveProcesses == 0:
+                    accounting_drained = True
+                    break
+                time.sleep(0.02)
+        finally:
+            for process_handle in process_handles:
+                kernel32.CloseHandle(ctypes.c_void_p(process_handle))
+            self.close()
+        return terminated and handles_signaled and accounting_drained
 
 
 class _WindowsProcessEntry(ctypes.Structure):
@@ -744,15 +829,15 @@ def _cleanup_descendants_after_success(
     process: subprocess.Popen[object],
     *,
     windows_job: _WindowsKillOnCloseJob | None,
-) -> None:
+) -> bool:
     if windows_job is not None and windows_job.handle is not None:
-        windows_job.terminate_and_wait()
-        return
+        return windows_job.terminate_and_wait()
     if os.name != "nt":
         try:
             os.killpg(process.pid, signal.SIGTERM)
         except ProcessLookupError:
             pass
+    return os.name != "nt"
 
 
 def run_managed_command(
@@ -796,8 +881,8 @@ def run_managed_command(
     try:
         process = subprocess.Popen(list(argv), **popen_kwargs)
         windows_job = (
-            _WindowsKillOnCloseJob()
-            if os.name == "nt" and not allow_detached_processes
+            _WindowsKillOnCloseJob(allow_breakaway=allow_detached_processes)
+            if os.name == "nt"
             else None
         )
         isolated = bool(windows_job and windows_job.assign(process))
@@ -832,16 +917,16 @@ def run_managed_command(
             if os.name == "nt":
                 _terminate_tracked_windows_descendants(known_windows_descendants)
             raise
+        descendants_drained = True
         if not timed_out:
-            _cleanup_descendants_after_success(process, windows_job=windows_job)
+            descendants_drained = _cleanup_descendants_after_success(
+                process,
+                windows_job=windows_job,
+            )
         if os.name == "nt":
             _update_windows_descendants(process.pid, known_windows_descendants)
             _terminate_tracked_windows_descendants(known_windows_descendants)
-            isolated = (
-                windows_snapshot_ok
-                if allow_detached_processes
-                else isolated and windows_snapshot_ok
-            )
+            isolated = isolated and windows_snapshot_ok and descendants_drained
         duration = time.monotonic() - started
         output_tail = ""
         if output_stream is not None:
@@ -1320,7 +1405,10 @@ def build_parser() -> argparse.ArgumentParser:
     exec_parser.add_argument(
         "--allow-detached-processes",
         action="store_true",
-        help="Use exact Windows PID-lineage tracking instead of a Job Object.",
+        help=(
+            "Permit explicit Windows Job breakaway while retaining ordinary "
+            "descendants and tracking escaped process lineages."
+        ),
     )
     exec_parser.set_defaults(handler=_run_exec)