10 files changed, 446 insertions, 36 deletions

diff --git a/src/zencompute/runners/functionrunner.cpp b/src/zencompute/runners/functionrunner.cpp
index 4f116e7d8..67e12b84e 100644
--- a/src/zencompute/runners/functionrunner.cpp
+++ b/src/zencompute/runners/functionrunner.cpp
@@ -164,8 +164,9 @@ BaseRunnerGroup::SubmitActions(const std::vector<Ref<RunnerAction>>& Actions)
 		}
 	}
 
-	// Assign any remaining actions to runners with capacity (round-robin)
-	for (int i = 0; ActionIdx < Actions.size(); i = (i + 1) % RunnerCount)
+	// Assign any remaining actions to runners with capacity (round-robin).
+	// Cap at TotalCapacity to avoid spinning when there are more actions than runners can accept.
+	for (int i = 0; ActionIdx < Actions.size() && ActionIdx < TotalCapacity; i = (i + 1) % RunnerCount)
 	{
 		if (Capacities[i] > PerRunnerActions[i].size())
 		{
@@ -186,11 +187,12 @@ BaseRunnerGroup::SubmitActions(const std::vector<Ref<RunnerAction>>& Actions)
 		}
 	}
 
-	// Reassemble results in original action order
-	std::vector<SubmitResult> Results(Actions.size());
+	// Reassemble results in original action order.
+	// Actions beyond ActionIdx were not assigned to any runner (insufficient capacity).
+	std::vector<SubmitResult> Results(Actions.size(), SubmitResult{.IsAccepted = false, .Reason = "No capacity"});
 	std::vector<size_t>		  PerRunnerIdx(RunnerCount, 0);
 
-	for (size_t i = 0; i < Actions.size(); ++i)
+	for (size_t i = 0; i < ActionIdx; ++i)
 	{
 		size_t RunnerIdx = ActionRunnerIndex[i];
 		size_t Idx		 = PerRunnerIdx[RunnerIdx]++;
diff --git a/src/zencompute/runners/linuxrunner.cpp b/src/zencompute/runners/linuxrunner.cpp
index e79a6c90f..9055005d9 100644
--- a/src/zencompute/runners/linuxrunner.cpp
+++ b/src/zencompute/runners/linuxrunner.cpp
@@ -331,6 +331,8 @@ LinuxProcessRunner::LinuxProcessRunner(ChunkResolver&				Resolver,
 	{
 		ZEN_INFO("namespace sandboxing enabled for child processes");
 	}
+
+	StartMonitorThread();
 }
 
 SubmitResult
diff --git a/src/zencompute/runners/localrunner.cpp b/src/zencompute/runners/localrunner.cpp
index b61e0a46f..1b748c0e5 100644
--- a/src/zencompute/runners/localrunner.cpp
+++ b/src/zencompute/runners/localrunner.cpp
@@ -4,6 +4,8 @@
 
 #if ZEN_WITH_COMPUTE_SERVICES
 
+#	include "pathvalidation.h"
+
 #	include <zencore/compactbinary.h>
 #	include <zencore/compactbinarybuilder.h>
 #	include <zencore/compactbinarypackage.h>
@@ -104,8 +106,6 @@ LocalProcessRunner::LocalProcessRunner(ChunkResolver&				Resolver,
 		ZEN_INFO("Cleanup complete");
 	}
 
-	m_MonitorThread = std::thread{&LocalProcessRunner::MonitorThreadFunction, this};
-
 #	if ZEN_PLATFORM_WINDOWS
 	// Suppress any error dialogs caused by missing dependencies
 	UINT OldMode = ::SetErrorMode(0);
@@ -382,6 +382,8 @@ LocalProcessRunner::DecompressAttachmentToFile(const CbPackage&										  FromP
 	const IoHash	 ChunkHash = FileEntry["hash"sv].AsHash();
 	const uint64_t	 Size	   = FileEntry["size"sv].AsUInt64();
 
+	ValidateSandboxRelativePath(Name);
+
 	CompressedBuffer Compressed;
 
 	if (const CbAttachment* Attachment = FromPackage.FindAttachment(ChunkHash))
@@ -457,7 +459,8 @@ LocalProcessRunner::ManifestWorker(const CbPackage&										   WorkerPackage,
 
 	for (auto& It : WorkerDescription["dirs"sv])
 	{
-		std::string_view	  Name = It.AsString();
+		std::string_view Name = It.AsString();
+		ValidateSandboxRelativePath(Name);
 		std::filesystem::path DirPath{SandboxPath / std::filesystem::path(Name).make_preferred()};
 
 		// Validate dir path stays within sandbox
@@ -482,6 +485,8 @@ LocalProcessRunner::ManifestWorker(const CbPackage&										   WorkerPackage,
 	}
 
 	WriteFile(SandboxPath / "worker.zcb", WorkerDescription.GetBuffer().AsIoBuffer());
+
+	ZEN_INFO("manifested worker '{}' in '{}'", WorkerPackage.GetObjectHash(), SandboxPath);
 }
 
 CbPackage
@@ -540,6 +545,12 @@ LocalProcessRunner::GatherActionOutputs(std::filesystem::path SandboxPath)
 }
 
 void
+LocalProcessRunner::StartMonitorThread()
+{
+	m_MonitorThread = std::thread{&LocalProcessRunner::MonitorThreadFunction, this};
+}
+
+void
 LocalProcessRunner::MonitorThreadFunction()
 {
 	SetCurrentThreadName("LocalProcessRunner_Monitor");
diff --git a/src/zencompute/runners/localrunner.h b/src/zencompute/runners/localrunner.h
index b8cff6826..d6589db43 100644
--- a/src/zencompute/runners/localrunner.h
+++ b/src/zencompute/runners/localrunner.h
@@ -67,6 +67,7 @@ protected:
 	{
 		Ref<RunnerAction>	  Action;
 		void*				  ProcessHandle = nullptr;
+		int					  Pid			= 0;
 		int					  ExitCode		= 0;
 		std::filesystem::path SandboxPath;
 
@@ -83,8 +84,6 @@ protected:
 	std::filesystem::path m_SandboxPath;
 	int32_t				  m_MaxRunningActions = 64;	 // arbitrary limit for testing
 
-	// if used in conjuction with m_ResultsLock, this lock must be taken *after*
-	// m_ResultsLock to avoid deadlocks
 	RwLock										m_RunningLock;
 	std::unordered_map<int, Ref<RunningAction>> m_RunningMap;
 
@@ -95,6 +94,7 @@ protected:
 	std::thread		  m_MonitorThread;
 	std::atomic<bool> m_MonitorThreadEnabled{true};
 	Event			  m_MonitorThreadEvent;
+	void			  StartMonitorThread();
 	void			  MonitorThreadFunction();
 	virtual void	  SweepRunningActions();
 	virtual void	  CancelRunningActions();
diff --git a/src/zencompute/runners/macrunner.cpp b/src/zencompute/runners/macrunner.cpp
index 5cec90699..c2ccca9a6 100644
--- a/src/zencompute/runners/macrunner.cpp
+++ b/src/zencompute/runners/macrunner.cpp
@@ -130,6 +130,8 @@ MacProcessRunner::MacProcessRunner(ChunkResolver&				Resolver,
 	{
 		ZEN_INFO("Seatbelt sandboxing enabled for child processes");
 	}
+
+	StartMonitorThread();
 }
 
 SubmitResult
diff --git a/src/zencompute/runners/managedrunner.cpp b/src/zencompute/runners/managedrunner.cpp
new file mode 100644
index 000000000..e4a7ba388
--- /dev/null
+++ b/src/zencompute/runners/managedrunner.cpp
@@ -0,0 +1,279 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include "managedrunner.h"
+
+#if ZEN_WITH_COMPUTE_SERVICES
+
+#	include <zencore/compactbinary.h>
+#	include <zencore/compactbinarypackage.h>
+#	include <zencore/except_fmt.h>
+#	include <zencore/filesystem.h>
+#	include <zencore/fmtutils.h>
+#	include <zencore/scopeguard.h>
+#	include <zencore/timer.h>
+#	include <zencore/trace.h>
+
+ZEN_THIRD_PARTY_INCLUDES_START
+#	include <asio/io_context.hpp>
+#	include <asio/executor_work_guard.hpp>
+ZEN_THIRD_PARTY_INCLUDES_END
+
+namespace zen::compute {
+
+using namespace std::literals;
+
+ManagedProcessRunner::ManagedProcessRunner(ChunkResolver&				Resolver,
+										   const std::filesystem::path& BaseDir,
+										   DeferredDirectoryDeleter&	Deleter,
+										   WorkerThreadPool&			WorkerPool,
+										   int32_t						MaxConcurrentActions)
+: LocalProcessRunner(Resolver, BaseDir, Deleter, WorkerPool, MaxConcurrentActions)
+, m_IoContext(std::make_unique<asio::io_context>())
+, m_SubprocessManager(std::make_unique<SubprocessManager>(*m_IoContext))
+{
+	m_ProcessGroup = m_SubprocessManager->CreateGroup("compute-workers");
+
+	// Run the io_context on a small thread pool so that exit callbacks and
+	// metrics sampling are dispatched without blocking each other.
+	for (int i = 0; i < kIoThreadCount; ++i)
+	{
+		m_IoThreads.emplace_back([this, i] {
+			SetCurrentThreadName(fmt::format("mrunner_{}", i));
+
+			// work_guard keeps run() alive even when there is no pending work yet
+			auto WorkGuard = asio::make_work_guard(*m_IoContext);
+
+			m_IoContext->run();
+		});
+	}
+}
+
+ManagedProcessRunner::~ManagedProcessRunner()
+{
+	try
+	{
+		Shutdown();
+	}
+	catch (std::exception& Ex)
+	{
+		ZEN_WARN("exception during managed process runner shutdown: {}", Ex.what());
+	}
+}
+
+void
+ManagedProcessRunner::Shutdown()
+{
+	ZEN_TRACE_CPU("ManagedProcessRunner::Shutdown");
+	m_AcceptNewActions = false;
+
+	CancelRunningActions();
+
+	// Tear down the SubprocessManager before stopping the io_context so that
+	// any in-flight callbacks are drained cleanly.
+	if (m_SubprocessManager)
+	{
+		m_SubprocessManager->DestroyGroup("compute-workers");
+		m_ProcessGroup = nullptr;
+		m_SubprocessManager.reset();
+	}
+
+	if (m_IoContext)
+	{
+		m_IoContext->stop();
+	}
+
+	for (std::thread& Thread : m_IoThreads)
+	{
+		if (Thread.joinable())
+		{
+			Thread.join();
+		}
+	}
+	m_IoThreads.clear();
+}
+
+SubmitResult
+ManagedProcessRunner::SubmitAction(Ref<RunnerAction> Action)
+{
+	ZEN_TRACE_CPU("ManagedProcessRunner::SubmitAction");
+	std::optional<PreparedAction> Prepared = PrepareActionSubmission(Action);
+
+	if (!Prepared)
+	{
+		return SubmitResult{.IsAccepted = false};
+	}
+
+	CbObject WorkerDescription = Prepared->WorkerPackage.GetObject();
+
+	// Parse environment variables from worker descriptor ("KEY=VALUE" strings)
+	// into the key-value pairs expected by CreateProcOptions.
+	std::vector<std::pair<std::string, std::string>> EnvPairs;
+	for (auto& It : WorkerDescription["environment"sv])
+	{
+		std::string_view Str = It.AsString();
+		size_t			 Eq	 = Str.find('=');
+		if (Eq != std::string_view::npos)
+		{
+			EnvPairs.emplace_back(std::string(Str.substr(0, Eq)), std::string(Str.substr(Eq + 1)));
+		}
+	}
+
+	// Build command line
+	std::string_view	  ExecPath = WorkerDescription["path"sv].AsString();
+	std::filesystem::path ExePath  = Prepared->WorkerPath / std::filesystem::path(ExecPath).make_preferred();
+
+	std::string CommandLine = fmt::format("\"{}\" -Build=build.action"sv, ExePath.string());
+
+	ZEN_DEBUG("Executing (managed): '{}' (sandbox='{}')", CommandLine, Prepared->SandboxPath);
+
+	CreateProcOptions Options;
+	Options.WorkingDirectory = &Prepared->SandboxPath;
+	Options.Flags			 = CreateProcOptions::Flag_NoConsole;
+	Options.Environment		 = std::move(EnvPairs);
+
+	const int32_t ActionLsn = Prepared->ActionLsn;
+
+	ManagedProcess* Proc = nullptr;
+
+	try
+	{
+		Proc = m_ProcessGroup->Spawn(ExePath, CommandLine, Options, [this, ActionLsn](ManagedProcess& /*Process*/, int ExitCode) {
+			OnProcessExit(ActionLsn, ExitCode);
+		});
+	}
+	catch (std::exception& Ex)
+	{
+		ZEN_ERROR("Failed to spawn process for action LSN {}: {}", ActionLsn, Ex.what());
+		m_DeferredDeleter.Enqueue(ActionLsn, std::move(Prepared->SandboxPath));
+		return SubmitResult{.IsAccepted = false};
+	}
+
+	{
+		Ref<RunningAction> NewAction{new RunningAction()};
+		NewAction->Action		 = Action;
+		NewAction->ProcessHandle = static_cast<void*>(Proc);
+		NewAction->Pid			 = Proc->Pid();
+		NewAction->SandboxPath	 = std::move(Prepared->SandboxPath);
+
+		RwLock::ExclusiveLockScope _(m_RunningLock);
+		m_RunningMap[ActionLsn] = std::move(NewAction);
+	}
+
+	Action->SetActionState(RunnerAction::State::Running);
+
+	ZEN_DEBUG("Managed runner: action LSN {} -> PID {}", ActionLsn, Proc->Pid());
+
+	return SubmitResult{.IsAccepted = true};
+}
+
+void
+ManagedProcessRunner::OnProcessExit(int ActionLsn, int ExitCode)
+{
+	ZEN_TRACE_CPU("ManagedProcessRunner::OnProcessExit");
+
+	Ref<RunningAction> Running;
+
+	m_RunningLock.WithExclusiveLock([&] {
+		auto It = m_RunningMap.find(ActionLsn);
+		if (It != m_RunningMap.end())
+		{
+			Running = std::move(It->second);
+			m_RunningMap.erase(It);
+		}
+	});
+
+	if (!Running)
+	{
+		return;
+	}
+
+	ZEN_DEBUG("Managed runner: action LSN {} + PID {} exited with code " ZEN_BRIGHT_WHITE("{}"), ActionLsn, Running->Pid, ExitCode);
+
+	Running->ExitCode = ExitCode;
+
+	// Capture final CPU metrics from the managed process before it is removed.
+	auto* Proc = static_cast<ManagedProcess*>(Running->ProcessHandle);
+	if (Proc)
+	{
+		ProcessMetrics Metrics = Proc->GetLatestMetrics();
+		float		   CpuMs   = static_cast<float>(Metrics.UserTimeMs + Metrics.KernelTimeMs);
+		Running->Action->CpuSeconds.store(CpuMs / 1000.0f, std::memory_order_relaxed);
+
+		float CpuPct = Proc->GetCpuUsagePercent();
+		if (CpuPct >= 0.0f)
+		{
+			Running->Action->CpuUsagePercent.store(CpuPct, std::memory_order_relaxed);
+		}
+	}
+
+	Running->ProcessHandle = nullptr;
+
+	std::vector<Ref<RunningAction>> CompletedActions;
+	CompletedActions.push_back(std::move(Running));
+	ProcessCompletedActions(CompletedActions);
+}
+
+void
+ManagedProcessRunner::CancelRunningActions()
+{
+	ZEN_TRACE_CPU("ManagedProcessRunner::CancelRunningActions");
+
+	std::unordered_map<int, Ref<RunningAction>> RunningMap;
+	m_RunningLock.WithExclusiveLock([&] { std::swap(RunningMap, m_RunningMap); });
+
+	if (RunningMap.empty())
+	{
+		return;
+	}
+
+	ZEN_INFO("cancelling {} running actions via process group", RunningMap.size());
+
+	Stopwatch Timer;
+
+	// Kill all processes in the group atomically (TerminateJobObject on Windows,
+	// SIGTERM+SIGKILL on POSIX).
+	if (m_ProcessGroup)
+	{
+		m_ProcessGroup->KillAll();
+	}
+
+	for (auto& [Lsn, Running] : RunningMap)
+	{
+		m_DeferredDeleter.Enqueue(Running->Action->ActionLsn, std::move(Running->SandboxPath));
+		Running->Action->SetActionState(RunnerAction::State::Failed);
+	}
+
+	ZEN_INFO("DONE - cancelled {} running processes (took {})", RunningMap.size(), NiceTimeSpanMs(Timer.GetElapsedTimeMs()));
+}
+
+bool
+ManagedProcessRunner::CancelAction(int ActionLsn)
+{
+	ZEN_TRACE_CPU("ManagedProcessRunner::CancelAction");
+
+	ManagedProcess* Proc = nullptr;
+
+	m_RunningLock.WithSharedLock([&] {
+		auto It = m_RunningMap.find(ActionLsn);
+		if (It != m_RunningMap.end() && It->second->ProcessHandle != nullptr)
+		{
+			Proc = static_cast<ManagedProcess*>(It->second->ProcessHandle);
+		}
+	});
+
+	if (!Proc)
+	{
+		return false;
+	}
+
+	// Terminate the process. The exit callback will handle the rest
+	// (remove from running map, gather outputs or mark failed).
+	Proc->Terminate(222);
+
+	ZEN_DEBUG("CancelAction: initiated cancellation of LSN {}", ActionLsn);
+	return true;
+}
+
+}  // namespace zen::compute
+
+#endif
diff --git a/src/zencompute/runners/managedrunner.h b/src/zencompute/runners/managedrunner.h
new file mode 100644
index 000000000..21a44d43c
--- /dev/null
+++ b/src/zencompute/runners/managedrunner.h
@@ -0,0 +1,64 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "localrunner.h"
+
+#if ZEN_WITH_COMPUTE_SERVICES
+
+#	include <zenutil/process/subprocessmanager.h>
+
+#	include <memory>
+
+namespace asio {
+class io_context;
+}
+
+namespace zen::compute {
+
+/** Cross-platform process runner backed by SubprocessManager.
+
+	Subclasses LocalProcessRunner, reusing sandbox management, worker manifesting,
+	input/output handling, and shared action preparation. Replaces the polling-based
+	monitor thread with async exit callbacks driven by SubprocessManager, and
+	delegates CPU/memory metrics sampling to the manager's built-in round-robin
+	sampler.
+
+	A ProcessGroup (backed by a JobObject on Windows, process group on POSIX) is
+	used for bulk cancellation on shutdown.
+
+	This runner does not perform any platform-specific sandboxing (AppContainer,
+	namespaces, Seatbelt). It is intended as a simpler, cross-platform alternative
+	to the platform-specific runners for non-sandboxed workloads.
+ */
+class ManagedProcessRunner : public LocalProcessRunner
+{
+public:
+	ManagedProcessRunner(ChunkResolver&				  Resolver,
+						 const std::filesystem::path& BaseDir,
+						 DeferredDirectoryDeleter&	  Deleter,
+						 WorkerThreadPool&			  WorkerPool,
+						 int32_t					  MaxConcurrentActions = 0);
+	~ManagedProcessRunner();
+
+	void					   Shutdown() override;
+	[[nodiscard]] SubmitResult SubmitAction(Ref<RunnerAction> Action) override;
+	void					   CancelRunningActions() override;
+	bool					   CancelAction(int ActionLsn) override;
+	[[nodiscard]] bool		   IsHealthy() override { return true; }
+
+private:
+	static constexpr int kIoThreadCount = 4;
+
+	// Exit callback posted on an io_context thread.
+	void OnProcessExit(int ActionLsn, int ExitCode);
+
+	std::unique_ptr<asio::io_context>  m_IoContext;
+	std::unique_ptr<SubprocessManager> m_SubprocessManager;
+	ProcessGroup*					   m_ProcessGroup = nullptr;
+	std::vector<std::thread>		   m_IoThreads;
+};
+
+}  // namespace zen::compute
+
+#endif
diff --git a/src/zencompute/runners/windowsrunner.cpp b/src/zencompute/runners/windowsrunner.cpp
index cd4b646e9..92ee65c2d 100644
--- a/src/zencompute/runners/windowsrunner.cpp
+++ b/src/zencompute/runners/windowsrunner.cpp
@@ -21,6 +21,12 @@ ZEN_THIRD_PARTY_INCLUDES_START
 #	include <sddl.h>
 ZEN_THIRD_PARTY_INCLUDES_END
 
+// JOB_OBJECT_UILIMIT_ERRORMODE is defined in winuser.h which may be
+// excluded by WIN32_LEAN_AND_MEAN.
+#	if !defined(JOB_OBJECT_UILIMIT_ERRORMODE)
+#		define JOB_OBJECT_UILIMIT_ERRORMODE 0x00000400
+#	endif
+
 namespace zen::compute {
 
 using namespace std::literals;
@@ -34,38 +40,65 @@ WindowsProcessRunner::WindowsProcessRunner(ChunkResolver&				Resolver,
 : LocalProcessRunner(Resolver, BaseDir, Deleter, WorkerPool, MaxConcurrentActions)
 , m_Sandboxed(Sandboxed)
 {
-	if (!m_Sandboxed)
+	// Create a job object shared by all child processes. Restricting the
+	// error-mode UI prevents crash dialogs (WER / Dr. Watson) from
+	// blocking the monitor thread when a worker process terminates
+	// abnormally.
+	m_JobObject = CreateJobObjectW(nullptr, nullptr);
+	if (m_JobObject)
 	{
-		return;
+		JOBOBJECT_EXTENDED_LIMIT_INFORMATION ExtLimits{};
+		ExtLimits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION;
+		SetInformationJobObject(m_JobObject, JobObjectExtendedLimitInformation, &ExtLimits, sizeof(ExtLimits));
+
+		JOBOBJECT_BASIC_UI_RESTRICTIONS UiRestrictions{};
+		UiRestrictions.UIRestrictionsClass = JOB_OBJECT_UILIMIT_ERRORMODE;
+		SetInformationJobObject(m_JobObject, JobObjectBasicUIRestrictions, &UiRestrictions, sizeof(UiRestrictions));
+
+		// Set error mode on this process so children inherit it. The
+		// UILIMIT_ERRORMODE restriction above prevents them from clearing
+		// SEM_NOGPFAULTERRORBOX.
+		SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
 	}
 
-	// Build a unique profile name per process to avoid collisions
-	m_AppContainerName = L"zenserver-sandbox-" + std::to_wstring(GetCurrentProcessId());
+	if (m_Sandboxed)
+	{
+		// Build a unique profile name per process to avoid collisions
+		m_AppContainerName = L"zenserver-sandbox-" + std::to_wstring(GetCurrentProcessId());
 
-	// Clean up any stale profile from a previous crash
-	DeleteAppContainerProfile(m_AppContainerName.c_str());
+		// Clean up any stale profile from a previous crash
+		DeleteAppContainerProfile(m_AppContainerName.c_str());
 
-	PSID Sid = nullptr;
+		PSID Sid = nullptr;
 
-	HRESULT Hr = CreateAppContainerProfile(m_AppContainerName.c_str(),
-										   m_AppContainerName.c_str(),	// display name
-										   m_AppContainerName.c_str(),	// description
-										   nullptr,						// no capabilities
-										   0,							// capability count
-										   &Sid);
+		HRESULT Hr = CreateAppContainerProfile(m_AppContainerName.c_str(),
+											   m_AppContainerName.c_str(),	// display name
+											   m_AppContainerName.c_str(),	// description
+											   nullptr,						// no capabilities
+											   0,							// capability count
+											   &Sid);
 
-	if (FAILED(Hr))
-	{
-		throw zen::runtime_error("CreateAppContainerProfile failed: HRESULT 0x{:08X}", static_cast<uint32_t>(Hr));
-	}
+		if (FAILED(Hr))
+		{
+			throw zen::runtime_error("CreateAppContainerProfile failed: HRESULT 0x{:08X}", static_cast<uint32_t>(Hr));
+		}
 
-	m_AppContainerSid = Sid;
+		m_AppContainerSid = Sid;
+
+		ZEN_INFO("AppContainer sandboxing enabled for child processes (profile={})", WideToUtf8(m_AppContainerName));
+	}
 
-	ZEN_INFO("AppContainer sandboxing enabled for child processes (profile={})", WideToUtf8(m_AppContainerName));
+	StartMonitorThread();
 }
 
 WindowsProcessRunner::~WindowsProcessRunner()
 {
+	if (m_JobObject)
+	{
+		CloseHandle(m_JobObject);
+		m_JobObject = nullptr;
+	}
+
 	if (m_AppContainerSid)
 	{
 		FreeSid(m_AppContainerSid);
@@ -172,9 +205,9 @@ WindowsProcessRunner::SubmitAction(Ref<RunnerAction> Action)
 	LPSECURITY_ATTRIBUTES lpProcessAttributes = nullptr;
 	LPSECURITY_ATTRIBUTES lpThreadAttributes  = nullptr;
 	BOOL				  bInheritHandles	  = FALSE;
-	DWORD				  dwCreationFlags	  = DETACHED_PROCESS;
+	DWORD				  dwCreationFlags	  = CREATE_SUSPENDED | DETACHED_PROCESS;
 
-	ZEN_DEBUG("Executing: {} (sandboxed={})", WideToUtf8(CommandLine.c_str()), m_Sandboxed);
+	ZEN_DEBUG("{}: '{}' (sandbox='{}')", m_Sandboxed ? "Sandboxing" : "Executing", WideToUtf8(CommandLine.c_str()), Prepared->SandboxPath);
 
 	CommandLine.EnsureNulTerminated();
 
@@ -260,14 +293,21 @@ WindowsProcessRunner::SubmitAction(Ref<RunnerAction> Action)
 		}
 	}
 
-	CloseHandle(ProcessInformation.hThread);
+	if (m_JobObject)
+	{
+		AssignProcessToJobObject(m_JobObject, ProcessInformation.hProcess);
+	}
 
-	Ref<RunningAction> NewAction{new RunningAction()};
-	NewAction->Action		 = Action;
-	NewAction->ProcessHandle = ProcessInformation.hProcess;
-	NewAction->SandboxPath	 = std::move(Prepared->SandboxPath);
+	ResumeThread(ProcessInformation.hThread);
+	CloseHandle(ProcessInformation.hThread);
 
 	{
+		Ref<RunningAction> NewAction{new RunningAction()};
+		NewAction->Action		 = Action;
+		NewAction->ProcessHandle = ProcessInformation.hProcess;
+		NewAction->Pid			 = ProcessInformation.dwProcessId;
+		NewAction->SandboxPath	 = std::move(Prepared->SandboxPath);
+
 		RwLock::ExclusiveLockScope _(m_RunningLock);
 
 		m_RunningMap[Prepared->ActionLsn] = std::move(NewAction);
@@ -275,6 +315,8 @@ WindowsProcessRunner::SubmitAction(Ref<RunnerAction> Action)
 
 	Action->SetActionState(RunnerAction::State::Running);
 
+	ZEN_DEBUG("Local runner: action LSN {} -> PID {}", Action->ActionLsn, ProcessInformation.dwProcessId);
+
 	return SubmitResult{.IsAccepted = true};
 }
 
@@ -294,6 +336,11 @@ WindowsProcessRunner::SweepRunningActions()
 
 			if (IsSuccess && ExitCode != STILL_ACTIVE)
 			{
+				ZEN_DEBUG("Local runner: action LSN {} + PID {} exited with code " ZEN_BRIGHT_WHITE("{}"),
+						  Running->Action->ActionLsn,
+						  Running->Pid,
+						  ExitCode);
+
 				CloseHandle(Running->ProcessHandle);
 				Running->ProcessHandle = INVALID_HANDLE_VALUE;
 				Running->ExitCode	   = ExitCode;
diff --git a/src/zencompute/runners/windowsrunner.h b/src/zencompute/runners/windowsrunner.h
index 9f2385cc4..adeaf02fc 100644
--- a/src/zencompute/runners/windowsrunner.h
+++ b/src/zencompute/runners/windowsrunner.h
@@ -46,6 +46,7 @@ private:
 	bool		 m_Sandboxed	   = false;
 	PSID		 m_AppContainerSid = nullptr;
 	std::wstring m_AppContainerName;
+	HANDLE		 m_JobObject = nullptr;
 };
 
 }  // namespace zen::compute
diff --git a/src/zencompute/runners/winerunner.cpp b/src/zencompute/runners/winerunner.cpp
index 506bec73b..b4fafb467 100644
--- a/src/zencompute/runners/winerunner.cpp
+++ b/src/zencompute/runners/winerunner.cpp
@@ -36,6 +36,8 @@ WineProcessRunner::WineProcessRunner(ChunkResolver&				  Resolver,
 	sigemptyset(&Action.sa_mask);
 	Action.sa_handler = SIG_DFL;
 	sigaction(SIGCHLD, &Action, nullptr);
+
+	StartMonitorThread();
 }
 
 SubmitResult