windows-development-sandbox 1.7.0 → 1.10.0

package/dist/guest/governor/decide.js

@@ -0,0 +1,211 @@
+/** Programs that compile or link: they may be slowed down and, as the last resort, paused for a few seconds. */
+const COMPILERS = new Set([
+    'rustc',
+    'clippy-driver',
+    'rustdoc',
+    'cc1',
+    'cc1plus',
+    'cc1obj',
+    'collect2',
+    'gcc',
+    'g++',
+    'c++',
+    'cc',
+    'clang',
+    'clang++',
+    'clang-cl',
+    'cl',
+    'link',
+    'lld',
+    'lld-link',
+    'ld',
+    'ld.lld',
+    'as',
+    'tsc',
+    'javac',
+]);
+/** Build tools and workers: slowed down but never paused (a node process may be a dev server or an agent). */
+const BUILD_TOOLS = new Set([
+    'node',
+    'dotnet',
+    'msbuild',
+    'vbcscompiler',
+    'ninja',
+    'make',
+    'mingw32-make',
+    'cmake',
+    'cargo',
+    'go',
+    'java',
+    'gradle',
+    'python',
+]);
+/** Never touched: the agents themselves, shells, terminals, this tool's own programs, Windows. */
+const NEVER = new Set([
+    'claude',
+    'codex',
+    'gemini',
+    'opencode',
+    'aider',
+    'cursor-agent',
+    'cmd',
+    'powershell',
+    'pwsh',
+    'bash',
+    'sh',
+    'zsh',
+    'git',
+    'conhost',
+    'openconsole',
+    'windowsterminal',
+    'wt',
+    'ptyhost',
+    'memgov',
+    'sandboxtools',
+    'sbx-db',
+    'explorer',
+    'csrss',
+    'wininit',
+    'winlogon',
+    'services',
+    'svchost',
+    'lsass',
+    'system',
+    'smss',
+    'dwm',
+]);
+const key = (name) => name.toLowerCase().replace(/\.exe$/, '');
+export const isNeverTouched = (name) => NEVER.has(key(name));
+export const canLower = (name) => !isNeverTouched(name) && (COMPILERS.has(key(name)) || BUILD_TOOLS.has(key(name)));
+/** The heavy ones the concurrency cap counts (drivers like gcc and collect2 only wait for these). */
+const HEAVY = new Set([
+    'rustc',
+    'clippy-driver',
+    'rustdoc',
+    'cc1',
+    'cc1plus',
+    'clang',
+    'clang++',
+    'clang-cl',
+    'cl',
+    'link',
+    'lld',
+    'lld-link',
+    'ld',
+    'ld.lld',
+]);
+export const isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
+export const canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
+export const INITIAL_STATE = {
+    pressure: false,
+    calm: 0,
+    samples: 0,
+    lowered: {},
+    pausedUntil: 0,
+    nextPauseAt: 0,
+    hostUntil: 0,
+};
+/** How long a held compiler waits before it gets a turn again (the governor repeats the hold while over the cap). */
+export const HOLD_MS = 3000;
+export const PAUSE_MS = 5000;
+const PAUSE_COOLDOWN_MS = 10000;
+/** Samples under pressure before programs go from below-normal to idle, and before one is paused. */
+const IDLE_AFTER = 3;
+const PAUSE_AFTER = 4;
+/** Only a program this big is worth pausing. */
+const PAUSE_MIN_MB = 300;
+/**
+ * One step. `gentle` (vGPU on): compilers start below normal even without pressure. Programs go back to their normal
+ * priority only when pressure ends (several calm samples in a row).
+ */
+export function decide(prev, sample, nowMs, thresholds, profile, maxCompilers = null) {
+    const ramFree = (sample.ramAvailMb / Math.max(1, sample.ramTotalMb)) * 100;
+    const commit = ((sample.commitLimitMb - sample.commitAvailMb) / Math.max(1, sample.commitLimitMb)) * 100;
+    const pcLow = nowMs < prev.hostUntil;
+    const low = ramFree < thresholds.enterAvailablePercent || commit > thresholds.enterCommitPercent || pcLow;
+    const recovered = ramFree > thresholds.exitAvailablePercent && commit < thresholds.exitCommitPercent && !pcLow;
+    let pressure = prev.pressure;
+    let calm = prev.calm;
+    let samples = prev.samples;
+    if (low) {
+        pressure = true;
+        calm = 0;
+        samples = prev.samples + 1;
+    }
+    else if (prev.pressure) {
+        calm = recovered ? prev.calm + 1 : 0;
+        if (calm >= thresholds.calmSamples) {
+            pressure = false;
+            calm = 0;
+            samples = 0;
+        }
+    }
+    const actions = [];
+    const present = new Set(sample.procs.map((p) => p.pid));
+    const lowered = {};
+    for (const [pid, to] of Object.entries(prev.lowered))
+        if (present.has(Number(pid)))
+            lowered[Number(pid)] = to;
+    if (pressure) {
+        const target = samples > IDLE_AFTER ? 'idle' : 'below';
+        for (const p of sample.procs) {
+            if (!canLower(p.name) || lowered[p.pid] === target)
+                continue;
+            // Already as low as asked (or lower): only remember it.
+            if (p.prio !== target && !(target === 'below' && p.prio === 'idle'))
+                actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: target });
+            lowered[p.pid] = target;
+        }
+    }
+    else {
+        for (const p of sample.procs) {
+            if (!canLower(p.name))
+                continue;
+            // Where a program rests when nothing is wrong: compilers below normal in the gentle profile.
+            const base = profile === 'gentle' && canPause(p.name) ? 'below' : 'normal';
+            const was = lowered[p.pid];
+            if (prev.pressure && was !== undefined && was !== base) {
+                if (p.prio !== base)
+                    actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: base });
+                if (base === 'normal')
+                    delete lowered[p.pid];
+                else
+                    lowered[p.pid] = base;
+            }
+            else if (!prev.pressure && base === 'below' && was === undefined) {
+                if (p.prio === 'normal')
+                    actions.push({ kind: 'priority', pid: p.pid, name: p.name, to: 'below' });
+                lowered[p.pid] = 'below';
+            }
+        }
+    }
+    let pausedUntil = prev.pausedUntil;
+    let nextPauseAt = prev.nextPauseAt;
+    if (pressure && samples >= PAUSE_AFTER && nowMs >= prev.nextPauseAt && nowMs >= prev.pausedUntil) {
+        const victim = [...sample.procs]
+            .filter((p) => canPause(p.name) && p.mb >= PAUSE_MIN_MB)
+            .sort((a, b) => b.mb - a.mb)[0];
+        if (victim) {
+            actions.push({ kind: 'pause', pid: victim.pid, name: victim.name, ms: PAUSE_MS });
+            pausedUntil = nowMs + PAUSE_MS;
+            nextPauseAt = pausedUntil + PAUSE_COOLDOWN_MS;
+        }
+    }
+    // Concurrency cap (vGPU profile): the oldest N heavy compilers run, the newer ones wait a few seconds at a time.
+    if (maxCompilers !== null) {
+        const heavy = sample.procs
+            .filter((p) => isHeavyCompiler(p.name) &&
+            !(nowMs < pausedUntil && actions.some((a) => a.kind === 'pause' && a.pid === p.pid)))
+            .sort((a, b) => a.pid - b.pid);
+        for (const p of heavy.slice(Math.max(1, maxCompilers)))
+            actions.push({ kind: 'hold', pid: p.pid, name: p.name, ms: HOLD_MS });
+    }
+    const level = nowMs < pausedUntil ? 'suspending' : pressure ? 'throttled' : 'ok';
+    return {
+        state: { pressure, calm, samples, lowered, pausedUntil, nextPauseAt, hostUntil: prev.hostUntil },
+        actions,
+        level,
+        ramFreePercent: Math.round(ramFree),
+        commitPercent: Math.round(commit),
+    };
+}

package/dist/guest/governor/governor.d.ts

@@ -0,0 +1,45 @@
+import type { PressureStatus } from '../../shared/channel/schema.js';
+import { type LoadProfile } from '../../shared/memory/index.js';
+import { type GovernorState, type MemSample } from './decide.js';
+/** What the governor needs from Windows (injectable: the tests use a fake). */
+export interface GovernorPort {
+    setPriority(pid: number, to: 'idle' | 'below' | 'normal'): void;
+    pause(pid: number, ms: number): void;
+}
+/** Everything a step changes outside the decision, behind injectable functions. */
+export interface GovernorDeps {
+    readonly port: GovernorPort;
+    readonly profile: LoadProfile;
+    /** At most this many heavy compilers run at once (null = no cap). */
+    readonly maxCompilers?: number | null;
+    readonly now: () => number;
+    /** A line in the memory log. */
+    readonly logLine: (line: string) => void;
+    /** run\pressure.json. */
+    readonly saveStatus: (status: PressureStatus) => void;
+}
+/** The governor's logic over a port: feed it samples; the host's "slow down" requests go to hostPressure. */
+export declare class GovernorCore {
+    private readonly deps;
+    private state;
+    private lastAction;
+    private lastWrite;
+    private lastWriteAt;
+    private pausedName;
+    private pausedPid;
+    private held;
+    constructor(deps: GovernorDeps);
+    hostPressure(seconds: number, reason: string): void;
+    get current(): GovernorState;
+    onSample(sample: MemSample): void;
+    private apply;
+}
+/** The daemon's governor: on unless sandbox.pressureResponse is off. */
+export declare class Governor {
+    private core;
+    describe(): string;
+    start(): void;
+    /** The host's watchdog: this PC is low for a while. */
+    hostPressure(seconds: number, reason: string): void;
+}
+export declare const governor: Governor;

package/dist/guest/governor/governor.js

@@ -0,0 +1,230 @@
+// The memory governor: samples the sandbox's memory every 2 seconds (memgov.exe, sandbox/csharp/MemGov.cs) and, when it
+// runs low, slows the heaviest build programs the agents started down and, as a last resort, pauses the biggest
+// compiler for a few seconds (decide.ts). What it does goes to the memory log and run\pressure.json, for the host.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { z } from 'zod';
+import { now } from '../../shared/channel/run-dir.js';
+import { writeJsonAtomic } from '../../shared/io/json.js';
+import { GUEST_THRESHOLDS, maxCompilers } from '../../shared/memory/index.js';
+import { ensureCompiled } from '../runtime/csc.js';
+import { dataDir } from '../runtime/paths.js';
+import { warn } from '../runtime/log.js';
+import { run } from '../runtime/paths.js';
+import { session } from '../runtime/session.js';
+import { errMsg } from '../../core/util/errors.js';
+import { decide, INITIAL_STATE } from './decide.js';
+const SampleSchema = z.object({
+    ramTotalMb: z.number(),
+    ramAvailMb: z.number(),
+    commitLimitMb: z.number(),
+    commitAvailMb: z.number(),
+    procs: z
+        .array(z.object({
+        pid: z.number().int(),
+        name: z.string().max(128),
+        mb: z.number(),
+        prio: z.enum(['idle', 'below', 'normal']).catch('normal'),
+    }))
+        .max(1024),
+});
+/** The governor's logic over a port: feed it samples; the host's "slow down" requests go to hostPressure. */
+export class GovernorCore {
+    deps;
+    state = INITIAL_STATE;
+    lastAction = '';
+    lastWrite = '';
+    lastWriteAt = 0;
+    pausedName = '';
+    pausedPid = 0;
+    held = new Set();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    hostPressure(seconds, reason) {
+        const until = this.deps.now() + seconds * 1000;
+        if (until > this.state.hostUntil) {
+            if (this.state.hostUntil <= this.deps.now())
+                this.deps.logLine('governor: this PC is low (' + reason + '); slowing builds down');
+            this.state = { ...this.state, hostUntil: until };
+        }
+    }
+    get current() {
+        return this.state;
+    }
+    onSample(sample) {
+        const nowMs = this.deps.now();
+        const before = this.state.pressure;
+        const seen = new Set(sample.procs.map((p) => p.pid));
+        for (const pid of this.held)
+            if (!seen.has(pid))
+                this.held.delete(pid);
+        const d = decide(this.state, sample, nowMs, GUEST_THRESHOLDS[this.deps.profile], this.deps.profile, this.deps.maxCompilers ?? null);
+        this.state = d.state;
+        for (const action of d.actions)
+            this.apply(action);
+        if (d.state.pressure !== before)
+            this.deps.logLine(d.state.pressure
+                ? 'governor: memory is low (' +
+                    d.ramFreePercent +
+                    '% RAM free, commit ' +
+                    d.commitPercent +
+                    '% used): slowing builds down'
+                : 'governor: memory is fine again: builds back to normal');
+        const paused = nowMs < d.state.pausedUntil && this.pausedPid
+            ? [{ name: this.pausedName, pid: this.pausedPid, seconds: Math.ceil((d.state.pausedUntil - nowMs) / 1000) }]
+            : [];
+        const status = {
+            level: d.level,
+            profile: this.deps.profile,
+            ramFreePercent: Math.max(0, Math.min(100, d.ramFreePercent)),
+            commitPercent: Math.max(0, Math.min(100, d.commitPercent)),
+            lowered: Object.keys(d.state.lowered).length,
+            paused,
+            pcLow: nowMs < d.state.hostUntil,
+            lastAction: this.lastAction,
+            updatedAt: now(),
+        };
+        // Written when something changed, else once a minute (the host reads it, never polls it hard).
+        const shape = JSON.stringify({ ...status, updatedAt: '', paused: paused.map((p) => p.pid) });
+        if (shape !== this.lastWrite || nowMs - this.lastWriteAt > 60000) {
+            this.lastWrite = shape;
+            this.lastWriteAt = nowMs;
+            this.deps.saveStatus(status);
+        }
+    }
+    apply(action) {
+        try {
+            if (action.kind === 'hold') {
+                this.deps.port.pause(action.pid, action.ms);
+                if (!this.held.has(action.pid)) {
+                    this.held.add(action.pid);
+                    this.lastAction = 'holding ' + action.name + ' (' + action.pid + ') until another compiler ends';
+                    this.deps.logLine('governor: ' + this.lastAction);
+                }
+                return;
+            }
+            if (action.kind === 'priority') {
+                this.deps.port.setPriority(action.pid, action.to);
+                this.lastAction = action.name + ' (' + action.pid + ') priority ' + action.to;
+            }
+            else {
+                this.deps.port.pause(action.pid, action.ms);
+                this.pausedName = action.name;
+                this.pausedPid = action.pid;
+                this.lastAction = 'paused ' + action.name + ' (' + action.pid + ') for ' + action.ms / 1000 + ' s';
+                this.deps.logLine('governor: ' + this.lastAction);
+                return;
+            }
+            this.deps.logLine('governor: ' + this.lastAction);
+        }
+        catch (e) {
+            warn('governor: ' + errMsg(e));
+        }
+    }
+}
+/** memgov.exe as a child process: samples come out of its stdout, commands go into its stdin. */
+class MemGovProcess {
+    onSample;
+    child = null;
+    constructor(onSample) {
+        this.onSample = onSample;
+    }
+    start() {
+        try {
+            const child = spawn(ensureCompiled('memgov'), ['serve', '--interval', '2'], {
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+            });
+            this.child = child;
+            createInterface({ input: child.stdout }).on('line', (line) => {
+                try {
+                    this.onSample(SampleSchema.parse(JSON.parse(line)));
+                }
+                catch (e) {
+                    warn('governor: bad sample: ' + errMsg(e));
+                }
+            });
+            child.stdin.on('error', () => undefined);
+            child.once('exit', () => {
+                this.child = null;
+                // It ends only when something is wrong: try again in a while.
+                setTimeout(() => this.start(), 30000).unref();
+            });
+        }
+        catch (e) {
+            warn('governor: could not start memgov.exe (no memory governor): ' + errMsg(e));
+        }
+    }
+    setPriority(pid, to) {
+        this.child?.stdin?.write('priority ' + pid + ' ' + to + '\n');
+    }
+    pause(pid, ms) {
+        this.child?.stdin?.write('suspend ' + pid + ' ' + ms + '\n');
+    }
+}
+/** The newest memory log SandboxTools writes, to add the governor's lines to it. */
+function appendToMemoryLog(line) {
+    try {
+        const logs = path.join(dataDir, 'logs');
+        const newest = fs
+            .readdirSync(logs)
+            .filter((f) => /^memory-\d{8}-\d{6}\.log$/.test(f))
+            .sort()
+            .pop();
+        if (!newest)
+            return;
+        const t = new Date();
+        const stamp = [t.getHours(), t.getMinutes(), t.getSeconds()].map((n) => String(n).padStart(2, '0')).join(':');
+        fs.appendFileSync(path.join(logs, newest), stamp + ' | ' + line + '\r\n');
+    }
+    catch {
+        // The log is for people; a missing or locked one never matters.
+    }
+}
+/** The daemon's governor: on unless sandbox.pressureResponse is off. */
+export class Governor {
+    core = null;
+    describe() {
+        const profile = session.loadProfile === 'gentle' ? 'gentle' : 'normal';
+        const t = GUEST_THRESHOLDS[profile];
+        return session.pressureResponse === false
+            ? 'off (sandbox.pressureResponse)'
+            : profile +
+                ' profile: slows builds down below ' +
+                t.enterAvailablePercent +
+                '% free RAM or above ' +
+                t.enterCommitPercent +
+                '% commit';
+    }
+    start() {
+        if (session.pressureResponse === false)
+            return;
+        const profile = session.loadProfile === 'gentle' ? 'gentle' : 'normal';
+        const proc = new MemGovProcess((s) => this.core?.onSample(s));
+        this.core = new GovernorCore({
+            port: proc,
+            profile,
+            maxCompilers: maxCompilers(os.cpus().length, profile),
+            now: () => Date.now(),
+            logLine: appendToMemoryLog,
+            saveStatus: (status) => {
+                try {
+                    writeJsonAtomic(run.pressureFile, status);
+                }
+                catch (e) {
+                    warn('governor: could not write its status: ' + errMsg(e));
+                }
+            },
+        });
+        proc.start();
+    }
+    /** The host's watchdog: this PC is low for a while. */
+    hostPressure(seconds, reason) {
+        this.core?.hostPressure(seconds, reason);
+    }
+}
+export const governor = new Governor();

package/dist/guest/governor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decide.js';
+export * from './governor.js';

package/dist/guest/governor/index.js

@@ -0,0 +1,2 @@
+export * from './decide.js';
+export * from './governor.js';

package/dist/guest/network/firewall.d.ts

@@ -1,5 +1,6 @@
 /** What the agent's manifest says about the LAN. */
 export type LanState = 'blocked' | 'open' | 'offline';
+export declare function networkProblems(): readonly string[];
 export declare function run(commands: string[][]): void;
 /**
  * Applies the LAN block. Internet is checked first; if it works before the rules but not after, the rules (not the

package/dist/guest/network/firewall.js

@@ -4,14 +4,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { relayPort, withBlockedHosts } from '../../shared/network/policy.js';
-import { buildFirewallCommands, ipv4DnsServers, isIPv4, parseDefaultGateways, parseDnsServers, } from '../../shared/network/firewall-rules.js';
+import { attachRuleCommands, buildFirewallCommands, hasShortName, ipv4DnsServers, isIPv4, parseDefaultGateways, parseDnsServers, } from '../../shared/network/firewall-rules.js';
 import { SYSTEM } from '../../shared/system.js';
 import { scriptArgs } from '../../shared/scripts.js';
 import { dryRun, isWin } from '../runtime/paths.js';
 import { log, warn } from '../runtime/log.js';
 import { session } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-const ATTACH_RULE = 'AgentSandbox-Attach';
 const netsh = (args) => {
     const r = spawnSync(SYSTEM.netsh(), args, { encoding: 'utf8', windowsHide: true });
     return { status: r.status, out: (r.stdout ?? '') + (r.stderr ?? '') };
@@ -51,24 +50,49 @@ const waitForInternet = async (seconds) => {
     }
     return false;
 };
-/** Inbound rule for ptyhost only, and only from the sandbox's own subnet (where the host's Hyper-V adapter is). */
-const attachRule = (ptyHostExe) => [
-    ['advfirewall', 'firewall', 'delete', 'rule', 'name=' + ATTACH_RULE],
-    [
-        'advfirewall',
-        'firewall',
-        'add',
-        'rule',
-        'name=' + ATTACH_RULE,
-        'dir=in',
-        'action=allow',
-        'enable=yes',
-        'profile=any',
-        'protocol=tcp',
-        'remoteip=LocalSubnet',
-        'program=' + ptyHostExe,
-    ],
-];
+/** Protections that could not be put in place this boot (shown in the boot summary and the log, never silent). */
+const problems = [];
+export function networkProblems() {
+    return problems;
+}
+/** netsh needs the long form of a path: the sandbox's TEMP is an 8.3 short path (WDAGUT~1). */
+const longPath = (file) => {
+    if (!hasShortName(file))
+        return file;
+    try {
+        return fs.realpathSync.native(file);
+    }
+    catch {
+        return file;
+    }
+};
+/**
+ * The inbound rule for ptyhost (the attach channel). A rule that cannot be added is a missing protection, so it is
+ * tried again a few times and then reported loudly instead of being skipped.
+ */
+async function applyAttachRule(ptyHostExe) {
+    if (!session.attach.enabled)
+        return;
+    if (!ptyHostExe) {
+        problems.push('attach: the session host was not built, so the firewall rule for it was not created');
+        warn(problems[problems.length - 1]);
+        return;
+    }
+    let last = '';
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            run(attachRuleCommands(longPath(ptyHostExe)));
+            return;
+        }
+        catch (e) {
+            last = errMsg(e);
+            if (attempt < 3)
+                await new Promise((r) => setTimeout(r, 1000));
+        }
+    }
+    problems.push('attach: the firewall rule for the session host could not be created (' + last + ')');
+    warn('PROTECTION MISSING: ' + problems[problems.length - 1]);
+}
 export function run(commands) {
     for (const c of commands) {
         const r = netsh(c);
@@ -89,10 +113,11 @@ export async function applyNetworkPolicy(ptyHostExe) {
     const block = session.network.blockPrivateRanges;
     const exempt = block ? discoverExemptIps() : [];
     const lanRules = block ? buildFirewallCommands(exempt) : [];
+    const forwardRules = forwardRule();
     const commands = [
         ...lanRules,
-        ...(ptyHostExe && session.attach.enabled ? attachRule(ptyHostExe) : []),
-        ...forwardRule(),
+        ...(ptyHostExe && session.attach.enabled ? attachRuleCommands(ptyHostExe) : []),
+        ...forwardRules,
     ];
     if (isWin && !dryRun) {
         try {
@@ -122,7 +147,24 @@ export async function applyNetworkPolicy(ptyHostExe) {
     if (commands.length === 0)
         return 'open';
     const online = block ? await waitForInternet(30) : true;
-    run(commands);
+    // Each group on its own: one failing must not skip the others (or the internet check below).
+    const failures = [];
+    try {
+        run(lanRules);
+    }
+    catch (e) {
+        failures.push(errMsg(e));
+    }
+    await applyAttachRule(ptyHostExe);
+    try {
+        run(forwardRules);
+    }
+    catch (e) {
+        problems.push('forwardPorts: the firewall rule for the relays could not be created (' + errMsg(e) + ')');
+        warn('PROTECTION MISSING: ' + problems[problems.length - 1]);
+    }
+    if (failures.length)
+        throw new Error(failures[0]);
     if (!block)
         return 'open';
     if (online && !(await waitForInternet(15))) {

package/dist/guest/runtime/csc.d.ts

@@ -7,6 +7,7 @@ declare const SOURCES: {
     readonly cargoshim: "CargoShim.cs";
     readonly linkgate: "LinkGate.cs";
     readonly pathsync: "PathSync.cs";
+    readonly memgov: "MemGov.cs";
 };
 export type Helper = keyof typeof SOURCES;
 /** %TEMP%\agent-sandbox\<name>-<hash>.exe, compiled from this launch's source the first time it is needed. */

package/dist/guest/runtime/csc.js

@@ -20,6 +20,7 @@ const SOURCES = {
     cargoshim: 'CargoShim.cs',
     linkgate: 'LinkGate.cs',
     pathsync: 'PathSync.cs',
+    memgov: 'MemGov.cs',
 };
 function sourceOf(name) {
     return path.join(launchDir, 'sandbox', 'csharp', SOURCES[name]);