@muggleai/works 5.7.0 → 5.8.1

package/dist/{chunk-LTULYOOW.js → chunk-5PYK7DWB.js}

@@ -331,9 +331,24 @@ async function startStdioServer(server) {
   process.on("SIGINT", () => shutdown("SIGINT"));
   watchForParentDeath(shutdown);
 }
+var PARENT_POLL_INTERVAL_MS = 3e4;
 function watchForParentDeath(shutdown) {
   process.stdin.on("end", () => shutdown("stdin-end"));
   process.stdin.on("close", () => shutdown("stdin-close"));
+  const parentPid = process.ppid;
+  if (!parentPid || parentPid <= 1) return;
+  const timer = setInterval(() => {
+    if (!parentIsAlive(parentPid)) shutdown("parent-gone");
+  }, PARENT_POLL_INTERVAL_MS);
+  timer.unref();
+}
+function parentIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
 }
 
 // src/cli/pr-section/render.ts

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-LTULYOOW.js';
+import { runCli } from './chunk-5PYK7DWB.js';
 import './chunk-LVUJ4E62.js';
 
 // src/cli/main.ts

package/dist/index.js

@@ -1,2 +1,2 @@
-export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-LTULYOOW.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-5PYK7DWB.js';
 export { createChildLogger, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, src_exports as shared } from './chunk-LVUJ4E62.js';

package/dist/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Run real-browser end-to-end (E2E) acceptance tests on your web app from any AI coding agent. Generate test scripts from plain English, replay them on localhost, capture screenshots, and validate user flows like signup, checkout, and dashboards. Works across Claude Code, Cursor, Codex, and Windsurf.",
-  "version": "5.6.0",
+  "version": "5.8.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "muggle",
   "displayName": "Muggle AI",
   "description": "Ship quality products with AI-powered end-to-end (E2E) acceptance testing that validates your web app like a real user — from Claude Code and Cursor to PR.",
-  "version": "5.6.0",
+  "version": "5.8.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/agents/test-prepare-runner.md

@@ -0,0 +1,47 @@
+---
+name: test-prepare-runner
+description: "Executes a fully-resolved Muggle Test prepare plan — detects what's listening, verifies env files, fresh-installs stale deps, starts approved services, smoke-tests, and returns the readiness table. Dispatched by the muggle-test-prepare skill after all user decisions are resolved; carries the opus pin so execution never runs below its reliability floor on a cheaper session model."
+model: opus
+---
+
+# Test Prepare Runner
+
+You bring a local dev stack to verified readiness for E2E testing: detect what's already listening, verify env files, install stale dependencies, start approved services, smoke-test them, and report the readiness table. Every decision — which services, their directories, start commands and approvals, scope, exclusions, the dev-server URL — arrives resolved in the dispatch prompt from the muggle-test-prepare skill. You have no channel to the user: when the plan is missing a decision you need, return one `needs-input:` line naming it and stop — the dispatching skill resolves it (asking the user if needed) and re-dispatches.
+
+## Input contract
+
+The dispatch prompt carries the resolved prepare plan:
+
+- `services[]` — name, dir, start command, expected port, `external` flag, approval already granted.
+- `testingScope` and `excludedServices[]` (with reasons).
+- The recorded dev-server URL (from the `autoSelectLocalHost` resolution) — never invent or default a host/port; a framework default like `:3000` is not a fallback.
+- Resolved gate values the stages read (`autoRebase` outcome already applied or explicitly skipped upstream).
+
+## Stages
+
+Run these stage files from the skill, in order, exactly as written — they are the single source of truth for each stage's procedure:
+
+1. [`../skills/muggle-test-prepare/steps/check-running.md`](../skills/muggle-test-prepare/steps/check-running.md)
+2. [`../skills/muggle-test-prepare/steps/env-file.md`](../skills/muggle-test-prepare/steps/env-file.md)
+3. [`../skills/muggle-test-prepare/steps/start-commands.md`](../skills/muggle-test-prepare/steps/start-commands.md)
+4. [`../skills/muggle-test-prepare/steps/fresh-install.md`](../skills/muggle-test-prepare/steps/fresh-install.md)
+5. [`../skills/muggle-test-prepare/steps/start-services.md`](../skills/muggle-test-prepare/steps/start-services.md)
+6. [`../skills/muggle-test-prepare/steps/smoke-test.md`](../skills/muggle-test-prepare/steps/smoke-test.md)
+7. [`../skills/muggle-test-prepare/steps/readiness-report.md`](../skills/muggle-test-prepare/steps/readiness-report.md)
+
+Where a stage file offers the user a choice, take the branch the plan resolved; where the plan doesn't cover it, return `needs-input:` — never guess, never start anything unapproved.
+
+## PID tracking
+
+Track every launched process in `/tmp/muggle-test-prepare.json` exactly per the skill's schema (`session_started`, `testing_scope`, `excluded_services`, `services[]` with pid/port/log). Processes the user started independently stay `external: true` and are never killed. Prune dead PIDs silently.
+
+## Output contract
+
+Return the readiness-report table verbatim as your report, prefixed by one line: `READY` (all services green), `DEGRADED: <which service, why>` (something is up but failed its smoke test after the clean-restart loop), or `needs-input: <decision>`. The dispatcher relays this to its caller — other skills gate on it, so a wrong `READY` is expensive; when in doubt between READY and DEGRADED, pick DEGRADED and say why. `needs-input:` is only for a decision the plan failed to resolve (a missing URL, an unapproved start, an unknown directory) — a service that stays broken after the loop is `DEGRADED` with the diagnosis, never `needs-input:`, even when no further automated fix exists. Repairing the app's own source code is out of scope entirely: a source-level bug surfaced by the smoke test is a `DEGRADED` diagnosis to report, not a decision to escalate.
+
+## Guardrails
+
+- Privacy boundary as the skill defines it: file contents only inside directories the plan names; never traverse upward past one level.
+- Port-listening is never enough — smoke-test (HTTP + body sniff + log tail) is mandatory before the report.
+- Clean Restart is the first fix in the smoke-test loop; fresh-install notifies, doesn't ask.
+- Never leave an orphan process untracked; never kill an `external` one.

package/dist/plugin/agents/visual-walkthrough-builder.md

@@ -0,0 +1,58 @@
+---
+name: visual-walkthrough-builder
+description: "Renders the Muggle Test E2E visual walkthrough for a PR — assembles the E2eReport, runs `muggle build-pr-section`, and either posts to the PR (Mode A) or returns the rendered block to the dispatcher (Modes B/C). Dispatched by the muggle-pr-visual-walkthrough skill; carries its sonnet pin so the render runs on sonnet regardless of the session model."
+model: sonnet
+---
+
+# Visual Walkthrough Builder
+
+You render and (in Mode A) post the Muggle Test E2E visual walkthrough. The dispatching skill has already resolved the mode, the PR, and user consent. You have no channel to the user: if an input you need is missing, return a single `needs-input:` line naming it and stop — the dispatching skill resolves it and re-dispatches.
+
+## Input contract
+
+The dispatch prompt carries:
+
+- `mode` — `post` (Mode A), `render-for-new-pr` (Mode B), or `embed` (Mode C).
+- `prNumber` + repo — Mode A only, already verified to exist.
+- The `E2eReport` JSON inline, **or** the run identifiers (`projectId`, per-test `runId`/`testCaseId` list) to assemble it from.
+
+When assembling from identifiers, follow [`../skills/muggle-pr-visual-walkthrough/e2e-report-assembly.md`](../skills/muggle-pr-visual-walkthrough/e2e-report-assembly.md). The `E2eReport` schema, required fields, and the inconclusive rule live there and in the CLI's Zod schema (`src/cli/pr-section/types.ts`) — a run that couldn't produce pass/fail is `inconclusive` with a `reason`, never dropped.
+
+## Render
+
+Pipe the report to the CLI; it writes `{"body": "...", "comment": "..." | null}`:
+
+```bash
+echo "$REPORT_JSON" | muggle build-pr-section > /tmp/muggle-pr-section.json
+```
+
+- Non-zero exit → surface the CLI's stderr verbatim; do not swallow or retry blindly.
+- `comment` is non-null only in the overflow case; the CLI owns fit-vs-overflow.
+
+## Deliver
+
+**Mode A (`post`)** — post `body` as a PR comment, then `comment` only if non-null. Append the Muggle Works signature to each posted body per [`../skills/_shared/vcs/post-signature.md`](../skills/_shared/vcs/post-signature.md) — this post is the walkthrough's own, so the command it names is `/muggle-pr-visual-walkthrough`:
+
+```bash
+sig='🤖 _Posted by `/muggle-pr-visual-walkthrough` · [Muggle Works](https://github.com/multiplex-ai/muggle-ai-works)_'
+{ jq -r '.body' /tmp/muggle-pr-section.json; printf '\n\n%s\n' "$sig"; } | gh pr comment <prNumber> --body-file -
+{ jq -r '.comment' /tmp/muggle-pr-section.json; printf '\n\n%s\n' "$sig"; } | gh pr comment <prNumber> --body-file -   # skip when null
+```
+
+Report back: PR URL + whether an overflow comment was posted.
+
+**Modes B/C (`render-for-new-pr` / `embed`)** — do not post, do not touch `gh`. Return the CLI output verbatim as your report:
+
+```
+body:
+<body>
+comment:
+<comment or null>
+```
+
+## Guardrails
+
+- Never hand-write or modify the walkthrough markdown — the CLI is the single source of truth. No custom tables, no added "Verdict" lines, no `Tested on:`/`Project:` footers; the CLI computes the verdict and emits per-test dashboard links.
+- Never invent report fields — missing `projectId`, `viewUrl`, or `screenshotUrl` → `needs-input:`, never a placeholder.
+- Never post the overflow comment when `comment` is null.
+- Never create a PR, never choose a mode — both belong to the dispatcher.

package/dist/plugin/hooks/README.md

@@ -31,7 +31,7 @@ Each guardrail is a thin bash wrapper in `../scripts/` registered in `hooks.json
 | Hook event | Wrapper | Strength | Condition | Preference | Effect |
 | :--------- | :------ | :------- | :-------- | :--------- | :----- |
 | `PostToolUse` (Bash) | `guardrail-pr-opened.sh` | advise | a `gh pr create`/`gh pr ready` just succeeded | `autoWatchPR` | start a `muggle-pr-followup` watcher on the new PR |
-| `PostToolUse` (Bash + muggle execute/replay MCP tools) | `guardrail-record-tests.sh` | record | a unit-test command passed, an E2E run happened, or an `echo "MUGGLE_E2E_SKIP: <reason>"` marker declared E2E un-runnable | — | set `unitTestsGreen` / `e2eRun` / `e2eSkipped` session state |
+| `PostToolUse` (Bash + muggle execute/replay/skill-emit MCP tools) | `guardrail-record-tests.sh` | record | a unit-test command passed, an E2E run happened (execute/replay call, or the muggle-test skill's own telemetry emit — which registers a clean SKIP verdict too), or an `echo "MUGGLE_E2E_SKIP: <reason>"` marker declared E2E un-runnable | — | set `unitTestsGreen` / `e2eRun` / `e2eSkipped` session state |
 | `PostToolUse` (Bash + Monitor) | `guardrail-pr-terminal.sh` | advise | a PR just went terminal — a `gh pr merge`/`gh pr close` success line or the watch monitor's `TERMINAL pr=N` exit line (never bare `"state":"MERGED"` metadata) | — | record `terminalPending`, direct the post-merge handoff: finalize the watcher slot, tear down per `autoCleanup`, offer next options via AskUserQuestion |
 | `PostToolUse` (AskUserQuestion) | `guardrail-offer-ran.sh` | record | a next-options offer ran while a terminal PR was pending | — | clear `terminalPending` — the only exit for the post-merge Stop gate |
 | `PreToolUse` (Bash) | `guardrail-report-format.sh` | **enforce** | a `gh pr comment\|create\|edit` body reads like an E2E report but lacks the `build-pr-section` sentinel | — | **deny** — render via `muggle build-pr-section` instead |
@@ -43,4 +43,13 @@ Each guardrail is a thin bash wrapper in `../scripts/` registered in `hooks.json
 
 `SessionStart` (`scripts/reconcile-stale-watchers.sh`) — a standalone advisory, not part of the `guardrails.mjs` decision tree above.
 
-`muggle-pr-followup` watchers are session-only `/loop` crons; they die on session end and the 7-day `/loop` expiry, leaving open PRs with no live poller. The skill's [`reconcile`](../skills/muggle-pr-followup/reconcile.md) procedure recovers them — finalizes slots whose PR went terminal, sweeps orphan crons, re-arms silently-stopped open watchers — but re-arming needs the `CronCreate` tool, which a shell hook can't call. So this hook nudges rather than acts: it scans `~/.muggle-ai/muggle-do/sessions/*/` for open slots (a `prs.json` with no `result.md`) and, **only when one or more exist**, injects `additionalContext` telling the agent to run `/muggle:muggle-pr-followup reconcile`. Zero open slots → it emits nothing. A pure directory scan (no `gh`, no writes), so it's cheap enough for every session start.
+`muggle-pr-followup` watchers are session-only (a monitor or `/loop` cron); they die with their session, leaving open PRs with no live poller. This is by design — a review is addressed only inside a session that carries the context to address it. The skill's [`reconcile`](../skills/muggle-pr-followup/reconcile.md) procedure recovers them at the next session start — finalizes slots whose PR went terminal, sweeps orphan crons, re-arms silently-stopped open watchers — but re-arming needs Claude tools a shell hook can't call. So this hook nudges rather than acts: it scans `~/.muggle-ai/muggle-do/sessions/*/` for open slots (a `prs.json` with no `result.md`) and, **only when one or more exist**, injects `additionalContext` telling the agent to run `/muggle:muggle-pr-followup reconcile`. Zero open slots → it emits nothing. A pure directory scan (no `gh`, no writes), so it's cheap enough for every session start.
+
+## Session-start state GC
+
+`SessionStart` (`scripts/gc-state.sh`) — prunes ephemeral state that nothing else garbage-collects, so it doesn't grow without bound (the per-session guardrails files and finalized watcher slots otherwise accumulate one-per-session forever). Collection is keyed on **inactivity, never creation age**, so state a long-lived session still relies on is never deleted out from under it:
+
+- `~/.muggle-ai/guardrails/*.json` (one per session) is pruned only after 14 days of **no activity**. An in-use session keeps rewriting its file (`guardrails.mjs` on every guarded tool call) and this hook refreshes it on every resume, so its mtime tracks last activity — a session that runs for months stays live indefinitely, and only one that has genuinely gone quiet for the whole window (i.e. ended) is collected.
+- Finalized watcher slots (`result.md` present) are pruned 30 days after finalize; their `followup.log` is forensic-only. An **open** slot — a PR watched for any length of time — has no `result.md` and is never touched.
+
+Both windows are overridable (`MUGGLE_GUARDRAILS_TTL_DAYS`, `MUGGLE_SLOT_TTL_DAYS`). TTL-gated to once per day via a `~/.cache/muggle/state-gc-checked` marker (the current-session refresh runs every start regardless); silent and best-effort, never blocks session start. Never touches an open slot or the current session's own state.

package/dist/plugin/hooks/hooks.json

@@ -15,6 +15,12 @@
             "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/reconcile-stale-watchers.sh\"",
             "async": false,
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/scripts/gc-state.sh\"",
+            "async": false,
+            "timeout": 10
           }
         ]
       }
@@ -57,7 +63,7 @@
         ]
       },
       {
-        "matcher": "mcp__.*muggle.*(execute|replay)",
+        "matcher": "mcp__.*muggle.*(execute|replay|telemetry-skill-emit)",
         "hooks": [
           {
             "type": "command",

package/dist/plugin/scripts/gc-state.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+
+set -uo pipefail
+
+# Prune ephemeral muggle state that nothing else garbage-collects, so it does not
+# grow without bound (observed: hundreds of dead per-session files). Runs from a
+# SessionStart hook, TTL-gated to once/day unless MUGGLE_STATE_GC_FORCE=1. Silent
+# and best-effort: it never blocks session start and never prints context.
+#
+# Collection is keyed on INACTIVITY, never creation age, so a session that lasts
+# months is never collected while it is still in use:
+#
+#   guardrails/<session>.json   one per Claude session. An in-use session keeps
+#       rewriting it (guardrails.mjs on every guarded tool call) and refreshes it
+#       on resume (below), so its mtime tracks last activity — only a session gone
+#       quiet for the whole window is collected, and by then it has ended.
+#   muggle-do/sessions/<slug>/  a PR-follow-up slot. Pruned only once finalized
+#       (result.md present — the terminal marker); an OPEN slot, a PR watched for
+#       any length of time, has no result.md and is never touched.
+#
+# Age tests use `find -mmin/-mtime` (portable across GNU and BSD) rather than
+# `date -r`, whose file-mtime meaning is GNU-only.
+
+home="${HOME}"
+guardrails_dir="${home}/.muggle-ai/guardrails"
+sessions_dir="${home}/.muggle-ai/muggle-do/sessions"
+marker_dir="${home}/.cache/muggle"
+marker="${marker_dir}/state-gc-checked"
+guardrails_ttl_days="${MUGGLE_GUARDRAILS_TTL_DAYS:-14}"
+slot_ttl_days="${MUGGLE_SLOT_TTL_DAYS:-30}"
+
+# Refresh this session's own guardrails file before anything else, every start
+# (not behind the daily gate — a resume on an already-swept day must still mark
+# the session live). This is what makes a long-lived or resumed session immune to
+# the inactivity sweep, whatever its age. Filename sanitization mirrors
+# guardrails.mjs fileFor().
+session_id=$(cat 2>/dev/null | sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -1)
+if [ -n "${session_id}" ]; then
+    safe_id="${session_id//[^A-Za-z0-9_-]/_}"
+    [ -f "${guardrails_dir}/${safe_id}.json" ] && touch "${guardrails_dir}/${safe_id}.json" 2>/dev/null || true
+fi
+
+# TTL gate: skip when the marker exists and is younger than 24h (1440 min).
+if [ -z "${MUGGLE_STATE_GC_FORCE:-}" ] && [ -f "$marker" ] \
+    && [ -z "$(find "$marker" -mmin +1440 2>/dev/null)" ]; then
+    exit 0
+fi
+
+if [ -d "$guardrails_dir" ]; then
+    find "$guardrails_dir" -maxdepth 1 -type f -name '*.json' \
+        -mtime "+${guardrails_ttl_days}" -delete 2>/dev/null || true
+fi
+
+if [ -d "$sessions_dir" ]; then
+    for slot in "$sessions_dir"/*/; do
+        [ -d "$slot" ] || continue
+        [ -f "${slot}result.md" ] || continue
+        if [ -n "$(find "${slot}result.md" -mtime "+${slot_ttl_days}" 2>/dev/null)" ]; then
+            rm -rf "$slot" 2>/dev/null || true
+        fi
+    done
+fi
+
+mkdir -p "$marker_dir" 2>/dev/null || true
+touch "$marker" 2>/dev/null || true
+exit 0

package/dist/plugin/scripts/guard-run-job-object.ps1

@@ -0,0 +1,256 @@
+# Windows backend for guard-run. Callers never invoke this file: the portable
+# entry point is guard-run.mjs (plain node, runs everywhere), which probes the
+# platform and dispatches to one backend — this Job Object shim on win32,
+# systemd scope / prlimit on linux, ulimit + process group on darwin. So skill
+# instructions stay OS-agnostic by referencing guard-run.mjs only; PowerShell
+# exists solely inside this win32 backend. guard-run.mjs invokes it as:
+#
+#   powershell -File guard-run-job-object.ps1 <limit> <kill|persist> <launcherPid> <base64CommandLine>
+#
+# The child is created CREATE_SUSPENDED, assigned to a fresh Job Object, then
+# resumed — so it and every descendant are inside the job from their first
+# instruction. JOB_OBJECT_LIMIT_ACTIVE_PROCESS makes the process past the limit
+# fail at creation in the kernel (nothing to clean up), which is what stops a
+# fork storm: a sweeper that reacts after enumeration always loses that race.
+#
+# kill mode adds JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE — this shim holds the only
+# job handle, so when it exits or is killed the kernel destroys the entire tree
+# — and watches the launcher: if the node launcher dies first, the shim
+# terminates the job so orphans are impossible. persist mode (guard-run
+# --service) keeps only the cap; the tree may outlive the launcher.
+
+$ErrorActionPreference = "Stop"
+
+if ($args.Count -ne 4) {
+    [Console]::Error.WriteLine("usage: guard-run-job-object.ps1 <limit> <kill|persist> <launcherPid> <base64CommandLine>")
+    exit 2
+}
+
+$activeProcessLimit = 0
+if (-not [int]::TryParse($args[0], [ref]$activeProcessLimit) -or $activeProcessLimit -lt 1) {
+    [Console]::Error.WriteLine("guard-run-job-object: limit must be a positive integer")
+    exit 2
+}
+if ($args[1] -notin @("kill", "persist")) {
+    [Console]::Error.WriteLine("guard-run-job-object: mode must be 'kill' or 'persist'")
+    exit 2
+}
+$killOnClose = $args[1] -eq "kill"
+$launcherPid = 0
+if (-not [int]::TryParse($args[2], [ref]$launcherPid)) {
+    [Console]::Error.WriteLine("guard-run-job-object: launcherPid must be an integer")
+    exit 2
+}
+try {
+    $commandLine = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($args[3]))
+} catch {
+    [Console]::Error.WriteLine("guard-run-job-object: command line is not valid base64")
+    exit 2
+}
+
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace MuggleGuardRun
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct JOBOBJECT_BASIC_LIMIT_INFORMATION
+    {
+        public long PerProcessUserTimeLimit;
+        public long PerJobUserTimeLimit;
+        public uint LimitFlags;
+        public UIntPtr MinimumWorkingSetSize;
+        public UIntPtr MaximumWorkingSetSize;
+        public uint ActiveProcessLimit;
+        public UIntPtr Affinity;
+        public uint PriorityClass;
+        public uint SchedulingClass;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct IO_COUNTERS
+    {
+        public ulong ReadOperationCount;
+        public ulong WriteOperationCount;
+        public ulong OtherOperationCount;
+        public ulong ReadTransferCount;
+        public ulong WriteTransferCount;
+        public ulong OtherTransferCount;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
+    {
+        public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+        public IO_COUNTERS IoInfo;
+        public UIntPtr ProcessMemoryLimit;
+        public UIntPtr JobMemoryLimit;
+        public UIntPtr PeakProcessMemoryUsed;
+        public UIntPtr PeakJobMemoryUsed;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    public struct STARTUPINFO
+    {
+        public uint cb;
+        public string lpReserved;
+        public string lpDesktop;
+        public string lpTitle;
+        public uint dwX;
+        public uint dwY;
+        public uint dwXSize;
+        public uint dwYSize;
+        public uint dwXCountChars;
+        public uint dwYCountChars;
+        public uint dwFillAttribute;
+        public uint dwFlags;
+        public ushort wShowWindow;
+        public ushort cbReserved2;
+        public IntPtr lpReserved2;
+        public IntPtr hStdInput;
+        public IntPtr hStdOutput;
+        public IntPtr hStdError;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct PROCESS_INFORMATION
+    {
+        public IntPtr hProcess;
+        public IntPtr hThread;
+        public uint dwProcessId;
+        public uint dwThreadId;
+    }
+
+    public static class JobObjectLauncher
+    {
+        const uint JOB_OBJECT_LIMIT_ACTIVE_PROCESS = 0x00000008;
+        const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+        const int JobObjectExtendedLimitInformation = 9;
+        const uint CREATE_SUSPENDED = 0x00000004;
+        const uint SYNCHRONIZE = 0x00100000;
+        const uint INFINITE = 0xFFFFFFFF;
+        const uint WAIT_OBJECT_0 = 0;
+        const int LAUNCHER_DEATH_EXIT_CODE = 137;
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        static extern IntPtr CreateJobObject(IntPtr lpJobAttributes, string lpName);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern bool SetInformationJobObject(IntPtr hJob, int jobObjectInfoClass,
+            ref JOBOBJECT_EXTENDED_LIMIT_INFORMATION lpJobObjectInfo, uint cbJobObjectInfoLength);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern bool TerminateJobObject(IntPtr hJob, uint uExitCode);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        static extern bool CreateProcess(string lpApplicationName, StringBuilder lpCommandLine,
+            IntPtr lpProcessAttributes, IntPtr lpThreadAttributes, bool bInheritHandles,
+            uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory,
+            ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern uint ResumeThread(IntPtr hThread);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern bool TerminateProcess(IntPtr hProcess, uint uExitCode);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern uint WaitForMultipleObjects(uint nCount, IntPtr[] lpHandles, bool bWaitAll,
+            uint dwMilliseconds);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern bool GetExitCodeProcess(IntPtr hProcess, out uint lpExitCode);
+
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, uint dwProcessId);
+
+        static Exception LastError(string operation)
+        {
+            return new Exception(operation + " failed (Win32 error " +
+                Marshal.GetLastWin32Error() + ")");
+        }
+
+        public static int Run(string commandLine, int activeProcessLimit, bool killOnClose,
+            int launcherPid)
+        {
+            IntPtr job = CreateJobObject(IntPtr.Zero, null);
+            if (job == IntPtr.Zero) throw LastError("CreateJobObject");
+
+            JOBOBJECT_EXTENDED_LIMIT_INFORMATION limits =
+                new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
+            limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_ACTIVE_PROCESS
+                | (killOnClose ? JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE : 0);
+            limits.BasicLimitInformation.ActiveProcessLimit = (uint)activeProcessLimit;
+            uint limitsSize = (uint)Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION));
+            if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, ref limits,
+                limitsSize))
+            {
+                throw LastError("SetInformationJobObject");
+            }
+
+            STARTUPINFO startupInfo = new STARTUPINFO();
+            startupInfo.cb = (uint)Marshal.SizeOf(typeof(STARTUPINFO));
+            PROCESS_INFORMATION processInfo;
+            StringBuilder mutableCommandLine = new StringBuilder(commandLine);
+            if (!CreateProcess(null, mutableCommandLine, IntPtr.Zero, IntPtr.Zero, true,
+                CREATE_SUSPENDED, IntPtr.Zero, null, ref startupInfo, out processInfo))
+            {
+                throw LastError("CreateProcess for [" + commandLine + "]");
+            }
+            if (!AssignProcessToJobObject(job, processInfo.hProcess))
+            {
+                TerminateProcess(processInfo.hProcess, 1);
+                throw LastError("AssignProcessToJobObject");
+            }
+            ResumeThread(processInfo.hThread);
+
+            if (killOnClose)
+            {
+                IntPtr launcher = OpenProcess(SYNCHRONIZE, false, (uint)launcherPid);
+                if (launcher == IntPtr.Zero)
+                {
+                    // Launcher already gone: the tree is orphaned at birth — reap it.
+                    TerminateJobObject(job, LAUNCHER_DEATH_EXIT_CODE);
+                    return LAUNCHER_DEATH_EXIT_CODE;
+                }
+                IntPtr[] handles = new IntPtr[] { processInfo.hProcess, launcher };
+                uint signaled = WaitForMultipleObjects(2, handles, false, INFINITE);
+                if (signaled == WAIT_OBJECT_0 + 1)
+                {
+                    TerminateJobObject(job, LAUNCHER_DEATH_EXIT_CODE);
+                    return LAUNCHER_DEATH_EXIT_CODE;
+                }
+            }
+            else
+            {
+                WaitForSingleObject(processInfo.hProcess, INFINITE);
+            }
+
+            uint exitCode;
+            if (!GetExitCodeProcess(processInfo.hProcess, out exitCode))
+            {
+                throw LastError("GetExitCodeProcess");
+            }
+            // The job handle is deliberately never closed here: in kill mode this
+            // process's death is what closes it, and that close is the kernel's
+            // cue to destroy any stragglers.
+            return (int)exitCode;
+        }
+    }
+}
+'@
+
+try {
+    exit ([MuggleGuardRun.JobObjectLauncher]::Run($commandLine, $activeProcessLimit, $killOnClose, $launcherPid))
+} catch {
+    [Console]::Error.WriteLine("guard-run-job-object: $($_.Exception.Message)")
+    exit 1
+}