windows-development-sandbox 1.18.3 → 1.20.0

package/dist/runtime/view.js

@@ -5756,6 +5756,7 @@ var SYSTEM = {
   cmd: () => system32("cmd.exe"),
   powershell: () => system32("WindowsPowerShell\\v1.0\\powershell.exe"),
   tasklist: () => system32("tasklist.exe"),
+  taskkill: () => system32("taskkill.exe"),
   whoami: () => system32("whoami.exe"),
   icacls: () => system32("icacls.exe"),
   tar: () => system32("tar.exe"),
@@ -25954,6 +25955,22 @@ var DatabasesSchema = external_exports.strictObject({
   })
 });
 
+// src/core/schema/codex.ts
+var CodexSchema = external_exports.strictObject({
+  sandboxMode: external_exports.enum(["danger-full-access", "workspace-write", "read-only"]).describe(
+    "Codex's own sandbox. Inside Windows Sandbox Codex's own sandbox only slows it down (it re-grants file permissions over your profile at every boot), so the default is danger-full-access: Windows Sandbox is the sandbox."
+  ),
+  approvalPolicy: external_exports.enum(["never", "on-request", "on-failure", "untrusted"]).describe('When Codex asks before it runs a command. "never" with danger-full-access starts it with no questions.'),
+  model: external_exports.string().max(100).regex(/^[A-Za-z0-9._:/-]*$/, "letters, digits and . _ : / - only").describe("The model Codex uses. Empty = Codex's own default."),
+  reasoningEffort: external_exports.enum(["default", "minimal", "low", "medium", "high", "xhigh"]).describe(`How hard Codex thinks. "default" = Codex's own default.`),
+  windowsSandbox: external_exports.enum(["off", "unelevated", "elevated"]).describe(
+    `Codex's Windows sandbox mode in its config.toml. "off" removes the setting so Codex does not set up its sandbox users and firewall rules at every boot.`
+  ),
+  mcpLoginsInFile: external_exports.boolean().describe(
+    `Keep the sign-ins of Codex's MCP servers in a file in the saved Codex folder (mcp_oauth_credentials_store = "file"), so they survive between sandboxes. A value you set in config.toml is kept.`
+  )
+});
+
 // src/core/schema/harness.ts
 var SubfolderSchema = external_exports.string().regex(/^(?!.*(^|[\\/])\.\.([\\/]|$))[A-Za-z0-9._ -]+([\\/][A-Za-z0-9._ -]+)*$/, "a plain relative folder");
 var HarnessHomeSchema = external_exports.strictObject({
@@ -26266,6 +26283,9 @@ var ToolchainsSchema = external_exports.strictObject({
     keepInstallFiles: external_exports.boolean().describe(
       "Keep an offline copy of the Visual Studio install files in tools\\visualstudio (~10 GB, made once), so later boots install without downloading them again. Skipped while that disk has too little room."
     ),
+    visualStudio: external_exports.enum(["full", "autosdk"]).describe(
+      `"full": install Visual Studio Community (the engine finds it through the Setup API; ~10 GB, redone every boot). "autosdk" (experimental): skip Visual Studio and build an Unreal AutoSDK tree from the portable MSVC in tools\\unreal\\autosdk (kept between sandboxes); UnrealBuildTool finds MSVC through AutoSDK, but the editor's Visual Studio integration is not available. Needs toolchains.msvc (turned on for you).`
+    ),
     persistEngines: external_exports.boolean().describe(
       "Engines the Epic Games Launcher installs go to tools\\unreal\\engines (kept between sandboxes, 40-60 GB each) and are registered with the launcher again every boot. Off: they go on the sandbox disk and are lost when it closes. Engines installed on this PC can be mapped instead (pcInstalls.unrealEngines)."
     ),
@@ -27722,6 +27742,7 @@ var ConfigSchema = external_exports.strictObject({
   apps: AppsSchema,
   claudeProfile: ClaudeProfileSchema,
   harnesses: external_exports.record(NameSchema, HarnessSchema).describe("Agents that can run in the sandbox."),
+  codex: CodexSchema,
   hooks: external_exports.strictObject({ failFast: external_exports.boolean().describe("Stop when a hook script fails.") }),
   projects: ProjectsSchema.describe(
     "Several projects in one sandbox: folders of projects mapped at every start, and adding folders while it runs."
@@ -27923,7 +27944,8 @@ var HeartbeatSchema = external_exports.object({
   topProcesses: external_exports.array(external_exports.object({ name: Text(64), privateMb: external_exports.number().int().min(0).max(1e7) })).max(5),
   /** The disk queue this PC last reported while asking the sandbox to slow down. */
   diskQueueReported: external_exports.number().min(0).max(1e5).optional(),
-  phase: external_exports.enum(["ready", "working"])
+  /** "ending": the sandbox is shutting down in order (idle shutdown, sandbox stop, Windows shutting down). */
+  phase: external_exports.enum(["ready", "working", "ending"])
 });
 var GuestResponseSchema = external_exports.object({
   id: IdSchema,
@@ -27964,6 +27986,8 @@ var ProjectStatusSchema = external_exports.object({
 var VpnStatusSchema = external_exports.object({
   state: external_exports.enum(["off", "starting", "up", "failed"]),
   message: Text(2e3),
+  /** Why it failed, when it did: `auth` (login refused), `unreachable`, `driver`, `timeout` or `other`. */
+  code: external_exports.enum(["auth", "unreachable", "driver", "timeout", "other"]).optional(),
   killSwitch: external_exports.boolean(),
   /** A direct connection was tried after the kill switch was applied: false = it still got out. */
   killSwitchHeld: external_exports.boolean().optional(),

package/dist/selftest/agent-commands.test.js

@@ -1,14 +1,18 @@
-// Agent commands (Beta): which agents get a forwarding command, what the files contain, and that "off" changes nothing.
+// Agent commands: which agents get a forwarding command, what the files contain, and that "off" changes nothing.
 // Everything happens in the test's temp folder with a made-up PATH; your real PATH is never read or written.
 import fs from 'node:fs';
 import path from 'node:path';
 import { DEFAULTS } from '../core/config/index.js';
 import { agentCommands, commandsDir, realAgent } from '../host/agent-commands/index.js';
 import { forwardingCmd, forwardingSh } from '../host/agent-commands/index.js';
-import { reconcileAgentCommands } from '../host/agent-commands/index.js';
+import { forwardTarget, reconcileAgentCommands } from '../host/agent-commands/index.js';
+import { agentCommandsSection } from '../app/features/agent-commands/agent-commands.def.js';
+import { applyAgentCommandsChange } from '../app/features/settings/settings.run.js';
+import { fakeIO } from '../app/kernel/index.js';
+import { runDefinition } from '../app/registry.js';
 export const agentCommandsSuite = {
     name: 'agent-commands',
-    title: 'agent commands (Beta): claude, codex ... forwarded into a hidden sandbox',
+    title: 'agent commands: claude, codex ... forwarded into a hidden sandbox',
     run: async (t) => {
         const storage = t.at('agent-cmd-storage');
         const npmDir = t.at('agent-cmd-npm');
@@ -33,19 +37,53 @@ export const agentCommandsSuite = {
         t.check(!agentCommands(on, storage, unsafeDir).some((a) => a.command === 'aider'), 'an agent in a folder whose path has % or ^ (which cmd.exe would expand) is left alone');
         t.section('the forwarding files');
         const claude = { harness: 'claude', command: 'claude', real: path.join(localBin, 'claude.exe') };
-        const cmd = forwardingCmd(claude, 'C:\\node\\node.exe', 'C:\\tool\\dist\\bin\\sandbox.js');
+        const direct = { node: 'C:\\node\\node.exe', entry: 'C:\\tool\\dist\\bin\\sandbox.js' };
+        const cmd = forwardingCmd(claude, direct);
         t.check(cmd.includes('"C:\\node\\node.exe" "C:\\tool\\dist\\bin\\sandbox.js" launch --harness claude --headless --terminal -- %*') &&
             cmd.includes('if "%SANDBOX_AGENT_DIRECT%"=="1" goto direct') &&
             cmd.includes('call "' + claude.real + '" %*'), 'the .cmd starts the agent in a hidden sandbox attached to this terminal, unless SANDBOX_AGENT_DIRECT=1 (real agent)');
-        const sh = forwardingSh({ ...claude, real: "C:\\Users\\me\\it's\\claude.exe" }, 'C:\\node\\node.exe', 'C:\\tool\\sandbox.js');
+        t.check(cmd.includes('if not exist "C:\\node\\node.exe" goto direct') &&
+            cmd.includes('if not exist "C:\\tool\\dist\\bin\\sandbox.js" goto direct') &&
+            cmd.indexOf('if not exist') < cmd.indexOf('launch --harness'), 'the .cmd runs the real agent when the tool was uninstalled or moved, instead of failing');
+        const managed = forwardTarget('C:\\tool\\versions\\1.0\\package', 'C:\\tool', 'C:\\node\\node.exe');
+        const viaLauncher = forwardingCmd(claude, managed);
+        t.check(managed.launcher === 'C:\\tool\\bin\\sandbox.cmd' &&
+            forwardTarget('C:\\src\\repo', null, 'C:\\node\\node.exe').launcher === undefined &&
+            viaLauncher.includes('call "C:\\tool\\bin\\sandbox.cmd" launch --harness claude --headless --terminal -- %*') &&
+            !viaLauncher.includes('versions') &&
+            forwardingSh(claude, managed).includes("[ -f '/c/tool/bin/sandbox' ] || exec "), 'under a managed install the files call its launcher (it survives updates), else node and the entry file');
+        const sh = forwardingSh({ ...claude, real: "C:\\Users\\me\\it's\\claude.exe" }, {
+            node: 'C:\\node\\node.exe',
+            entry: 'C:\\tool\\sandbox.js',
+        });
         t.check(sh.startsWith('#!/bin/sh') &&
             sh.includes("exec '/c/node/node.exe' '/c/tool/sandbox.js' launch --harness claude --headless --terminal -- \"$@\"") &&
             sh.includes("'/c/Users/me/it'\\''s/claude.exe'"), 'Git Bash gets a shell script with POSIX paths, quoted safely');
         t.section('off changes nothing');
         // Off with nothing set up: nothing to do, no PATH edit (which would be refused during the self-test anyway).
         const fresh = t.at('agent-cmd-fresh');
-        const off = reconcileAgentCommands(DEFAULTS, fresh, 'C:\\node\\node.exe', 'C:\\tool\\sandbox.js');
+        const target = { node: 'C:\\node\\node.exe', entry: 'C:\\tool\\sandbox.js' };
+        const off = reconcileAgentCommands(DEFAULTS, fresh, target);
         t.equal({ on: off.on, changed: off.changed, wrote: fs.existsSync(commandsDir(fresh)) }, { on: false, changed: false, wrote: false }, 'off (the default) writes nothing and leaves your PATH alone');
-        await t.throws(() => reconcileAgentCommands(on, t.at('agent-cmd-on'), 'C:\\node\\node.exe', 'C:\\tool\\sandbox.js'), /self-test|PATH/i, 'turning it on edits your PATH, which the self-test refuses (it never changes this PC)');
+        await t.throws(() => reconcileAgentCommands(on, t.at('agent-cmd-on'), target), /self-test|PATH/i, 'turning it on edits your PATH, which the self-test refuses (it never changes this PC)');
+        t.section('every surface');
+        await t.throws(() => runDefinition('agentCommands.on', {}, {}, fakeIO().io), /self-test|PATH|inside the sandbox/i, 'agentCommands.on refuses in the self-test (it would change this PC)');
+        const reconciled = [];
+        const fakeService = { reconcile: (c) => reconciled.push(c) };
+        const ctx = { loaded: { configPath: undefined } };
+        applyAgentCommandsChange(ctx, 'user', 'agentCommands.enabled', fakeService);
+        applyAgentCommandsChange(ctx, 'user', 'defaultHarness', fakeService);
+        applyAgentCommandsChange(ctx, 'project', 'agentCommands.enabled', fakeService);
+        t.equal(reconciled.length, 1, 'changing agentCommands.* in your settings (any surface) brings this PC in line');
+        const section = agentCommandsSection({
+            enabled: false,
+            dir: 'C:\\x',
+            found: [{ command: 'claude', harness: 'claude', real: 'C:\\r\\claude.exe' }],
+        });
+        const toggle = section.items?.[0].primary;
+        t.check(section.items?.map((i) => i.id).join() === 'agentCommands,agentCommand:claude' &&
+            toggle?.kind === 'operation' &&
+            toggle.op === 'agentCommands.on' &&
+            !JSON.stringify(section).includes('sandbox agent-commands'), 'the Agents page offers the switch as an action and lists each agent found, naming no command');
     },
 };

package/dist/selftest/agent-paths.test.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { DEFAULTS, mergeConfig, validateConfig } from '../core/config/index.js';
 import { isWin } from '../core/util/index.js';
 import { SYSTEM } from '../shared/system.js';
-import { agentCommand, agentShims, bootResetPaths, codexConfigWithoutSandbox, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, shimText, } from '../guest/agents/agent-files.js';
+import { agentCommand, agentShims, bootResetPaths, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, shimText, } from '../guest/agents/agent-files.js';
 import { appendMissing, expandVars, isPinnedNodeDir, parseRegPath, pathKey, planPath, rebuildPath, splitPath, } from '../guest/setup/path-plan.js';
 import { withReloadEnvironment } from '../host/tools/index.js';
 import { HarnessSchema } from '../core/schema/index.js';
@@ -59,17 +59,6 @@ export const agentPathsSuite = {
         ], "codex's DPAPI-sealed sandbox users and setup marker are removed at boot (CryptUnprotectData otherwise)");
         t.check(HarnessSchema.safeParse({ ...DEFAULTS.harnesses.codex, bootReset: ['..\\login'] }).success === false &&
             HarnessSchema.safeParse({ ...DEFAULTS.harnesses.codex, bootReset: ['C:\\Windows'] }).success === false, 'bootReset takes only plain paths below the agent state folder');
-        t.section('codex without its own command sandbox');
-        const userToml = '[tui]\nscreen_reader_detection_done = true\n\n[windows]\nsandbox = "elevated"\n';
-        const off = codexConfigWithoutSandbox(userToml) ?? '';
-        t.check(off.split('\n').find((l) => !l.startsWith('#')) === 'sandbox_mode = "danger-full-access"' &&
-            off.endsWith(userToml), 'sandbox_mode goes above the first table, the rest of the file is kept');
-        t.check(codexConfigWithoutSandbox('') === off.slice(0, off.indexOf('\n\n') + 1), 'a missing config.toml gets just the setting');
-        t.equal([
-            codexConfigWithoutSandbox(off),
-            codexConfigWithoutSandbox('model = "o3"\nsandbox_mode = "workspace-write"\n[windows]\n'),
-        ], [null, null], 'a sandbox_mode already set (by the sandbox or by the user) is left alone');
-        t.check(codexConfigWithoutSandbox('[profiles.x]\nsandbox_mode = "read-only"\n') !== null, 'a sandbox_mode inside a table does not count as the top-level one');
         t.section('PATH planner');
         const present = new Set(['c:\\a', 'c:\\b', 'c:\\c\\d', 'c:\\nvm\\v24.1.0']);
         const exists = (f) => present.has(pathKey(f));

package/dist/selftest/agent-settings.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const agentSettingsSuite: Suite;

package/dist/selftest/agent-settings.test.js

@@ -0,0 +1,94 @@
+// Codex settings (launch flags, config.toml), the Claude environment editor and the one Anthropic key pattern.
+import fs from 'node:fs';
+import { DEFAULTS } from '../core/config/index.js';
+import { CodexSchema } from '../core/schema/index.js';
+import { agentEnv, agentsEnvSet } from '../app/features/agents/index.js';
+import { agentsOptions } from '../cli/menu/pages/agents-page.js';
+import { fakeIO } from '../app/kernel/index.js';
+import { runDefinition } from '../app/registry.js';
+import { agentArguments, agentShims, codexArguments, codexConfigOwned, shimText } from '../guest/agents/agent-files.js';
+import { ANTHROPIC_KEY_PATTERN, anthropicKeyProblem } from '../shared/accounts/index.js';
+import { CLAUDE_ENV, ENV_GROUPS } from '../app/features/agents/claude-env.def.js';
+const CODEX = DEFAULTS.codex;
+export const agentSettingsSuite = {
+    name: 'agent-settings',
+    title: 'Codex settings, Claude environment editor, Anthropic key pattern',
+    run: async (t) => {
+        t.section('codex launch flags');
+        t.equal(codexArguments(CODEX), ['--dangerously-bypass-approvals-and-sandbox'], 'full access + never = the bypass flag');
+        t.equal(codexArguments({ ...CODEX, sandboxMode: 'workspace-write', approvalPolicy: 'on-request' }), ['--sandbox', 'workspace-write', '--ask-for-approval', 'on-request'], 'another mode gets explicit flags');
+        t.equal(codexArguments({ ...CODEX, sandboxMode: 'danger-full-access', approvalPolicy: 'on-failure' }), ['--sandbox', 'danger-full-access', '--ask-for-approval', 'on-failure'], 'the bypass flag is only for full access with no questions');
+        t.equal(codexArguments({ ...CODEX, model: 'gpt-5', reasoningEffort: 'high' }).slice(1), ['-c', 'model="gpt-5"', '-c', 'model_reasoning_effort="high"'], 'model and reasoning effort follow as -c overrides');
+        t.check(CodexSchema.safeParse({ ...CODEX, model: 'x"; evil' }).success === false, 'a model name cannot carry quotes');
+        const codex = DEFAULTS.harnesses.codex;
+        t.equal(agentArguments('codex', codex, CODEX), [...codex.arguments, '--dangerously-bypass-approvals-and-sandbox'], "codex's launch arguments carry the flags");
+        t.equal(agentArguments('claude', DEFAULTS.harnesses.claude, CODEX), [...DEFAULTS.harnesses.claude.arguments], 'other agents do not');
+        const shim = agentShims('C:\\AgentData\\tools', DEFAULTS.harnesses, { codex: codexArguments(CODEX) }).find((s) => s.name === 'codex');
+        const text = shim ? shimText(shim, { node: 'node.exe', script: 'agent.js' }) : '';
+        t.includes(text, '"%SBX_REAL%" --dangerously-bypass-approvals-and-sandbox %*', 'the codex.cmd shim adds the flags');
+        t.excludes(shimText(agentShims('C:\\AgentData\\tools', DEFAULTS.harnesses).find((s) => s.name === 'codex'), { node: 'node.exe', script: 'agent.js' }), 'dangerously', 'a shim without flags passes only %*');
+        t.section('codex config.toml');
+        const old = '# Set by the sandbox: x\nsandbox_mode = "danger-full-access"\n\n[tui]\nscreen_reader_detection_done = true\n\n[windows]\nsandbox = "elevated"\n';
+        const owned = codexConfigOwned(old, CODEX);
+        t.check(!owned.includes('sandbox_mode') && !owned.includes('Set by the sandbox') && !owned.includes('sandbox = '), 'the old sandbox_mode lines and [windows] sandbox are removed', owned);
+        t.check(owned.includes('mcp_oauth_credentials_store = "file"') &&
+            owned.includes('[tui]\nscreen_reader_detection_done = true\n') &&
+            owned.includes('[windows]'), 'MCP logins go to a file; every other line stays', owned);
+        t.equal(codexConfigOwned(owned, CODEX), owned, 'running it again changes nothing');
+        t.includes(codexConfigOwned(old, { ...CODEX, windowsSandbox: 'unelevated' }), '[windows]\nsandbox = "unelevated"', 'a Windows sandbox mode is written when asked for');
+        t.includes(codexConfigOwned('mcp_oauth_credentials_store = "keyring"\n', CODEX), 'mcp_oauth_credentials_store = "keyring"', "a user's own mcp_oauth_credentials_store is kept");
+        t.equal(codexConfigOwned('', { ...CODEX, mcpLoginsInFile: false }), '', 'an empty file stays empty when nothing is owned');
+        t.section('Anthropic key pattern');
+        const body = 'a'.repeat(60);
+        t.check(ANTHROPIC_KEY_PATTERN.test('sk-ant-usr01-' + body) && ANTHROPIC_KEY_PATTERN.test('sk-ant-api03-' + body), 'sk-ant-api03- and sk-ant-usr01- keys are accepted');
+        t.check(!ANTHROPIC_KEY_PATTERN.test('sk-ant-usr1-x') && anthropicKeyProblem('sk-ant-usr1-x') !== null, 'a short or malformed key is refused');
+        t.check(anthropicKeyProblem('sk-ant-usr01-' + body) === null, 'no problem for a user-workspace key');
+        t.section('Claude environment catalogue');
+        const names = CLAUDE_ENV.map((s) => s.name);
+        t.check(new Set(names).size === names.length, 'names are unique');
+        t.check(names.every((n) => /^[A-Z][A-Z0-9_]+$/.test(n)) && CLAUDE_ENV.every((s) => ENV_GROUPS.includes(s.group)), 'names and groups are valid');
+        t.check(names.includes('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS'), 'the subagent limit is there');
+        t.section('Claude environment operations');
+        const configPath = t.at('agent-env', 'config.json');
+        t.write(configPath, '{}\n');
+        const ctx = {
+            packageRoot: t.dir('agent-env', 'package'),
+            options: {},
+            loaded: { config: structuredClone(DEFAULTS), configPath, base: t.temp },
+            storageRoot: t.dir('agent-env', 'storage'),
+            dataPath: t.dir('agent-env', 'storage', 'data', 'o'),
+        };
+        const io = fakeIO([]).io;
+        const set = (name, value) => runDefinition(agentsEnvSet.id, ctx, { agent: 'claude', name, value }, io);
+        const read = async () => (await runDefinition(agentEnv.id, ctx, { agent: 'claude' }, io));
+        await set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', '40');
+        let row = (await read()).rows.find((r) => r.name === 'CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS');
+        t.check(row?.set === true && row.value === '40', 'a number is saved and read back');
+        t.includes(fs.readFileSync(configPath, 'utf8'), '"CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS": "40"', 'it is in the settings file');
+        await t.throws(() => set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', 'many'), 'whole number', 'a word is refused for a number');
+        await t.throws(() => set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', '0'), 'Use a number', 'zero is refused');
+        await set('CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS', null);
+        row = (await read()).rows.find((r) => r.name === 'CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS');
+        t.check(row?.set === false, 'an empty value removes it');
+        await t.throws(() => set('ANTHROPIC_API_KEY', 'sk-ant-usr1-x'), 'API key', 'the environment editor refuses a bad key');
+        const key = 'sk-ant-usr01-' + 'k'.repeat(60);
+        await set('ANTHROPIC_API_KEY', key);
+        const shown = JSON.stringify(await read());
+        t.check(!shown.includes(key.slice(13)), 'a secret value is never returned');
+        t.check((await read()).rows.find((r) => r.name === 'ANTHROPIC_API_KEY')?.set === true, 'but it says it is set');
+        const env = await read();
+        const menu = agentsOptions({
+            folder: 'C:/code',
+            defaultAgent: 'claude',
+            agents: [{ name: 'claude', ready: true }],
+            last: undefined,
+            attach: false,
+            window: 'config',
+            hostAgents: [],
+            claudeEnv: env,
+        });
+        t.check(menu.categories?.some((c) => c.id === 'env') === true &&
+            menu.items.some((i) => i.label === 'Subagents at once' || i.label === 'API key'), 'the menu has a Claude environment tab with the variables');
+        await t.throws(() => set('bad name', '1'), '', 'a bad variable name is refused');
+    },
+};

package/dist/selftest/app.test.js

@@ -282,6 +282,7 @@ export const appSuite = {
                 t.check(ops(sample).every((op) => known.has(op)), view.id + ': the page offers only operations its view declares');
         }
         t.section('agents');
+        const noCommands = { enabled: false, dir: 'C:/x', found: [] };
         const agentsSample = agentsPage({
             folder: 'C:\\code\\api',
             defaultAgent: 'claude',
@@ -289,7 +290,7 @@ export const appSuite = {
                 { name: 'codex', ready: false, isDefault: false, removable: true },
                 { name: 'claude', ready: true, isDefault: true, removable: false },
             ],
-        });
+        }, noCommands);
         const agentItems = agentsSample.sections[0].items ?? [];
         const agentKeys = (id) => (agentItems.find((i) => i.id === id)?.actions ?? [])
             .flatMap((a) => (a.kind === 'operation' && a.key ? [a.key] : []))

package/dist/selftest/cli.test.js

@@ -158,6 +158,10 @@ export const cliSuite = {
         });
         multi.handle(key('space'));
         t.equal(multi.handle(key('return')), { done: { kind: 'multi', values: ['a', 'b'] } }, 'list screen: space ticks several');
+        const pasted = new TextScreen({ path: ['T'], label: 'Secret', masked: true });
+        pasted.handle(key('', '\u001b[200~abc\r\n\u001b[201~'));
+        pasted.handle(key('', '[200~d[201~'));
+        t.equal(pasted.handle(key('return')), { done: 'abcd' }, 'text field: the markers around pasted text are dropped');
         const typed = new TextScreen({ path: ['T'], label: 'Port', validate: (v) => (Number(v) > 0 ? true : 'a number') });
         typed.handle(key('x', 'x'));
         const refused = typed.handle(key('return'));

package/dist/selftest/heavy-load.test.js

@@ -10,9 +10,12 @@ import { SYSTEM } from '../shared/system.js';
 import { GuestRequestSchema, PressureStatusSchema } from '../shared/channel/index.js';
 import { compilersAllowed, DIAL_CALM_SAMPLES, DIAL_STEPS, HOST_THRESHOLDS, buildJobs, cargoJobs, linkSlotsFor, usableCpus, effectiveCpuLimit, gentleCpuLimit, maxCompilers, chooseTargetDir, } from '../shared/memory/index.js';
 import { HeartbeatSchema } from '../shared/channel/index.js';
-import { heartbeatLine, lastEndOf } from '../host/life/index.js';
+import { heartbeatLine, lastEndOf, vanishedCause, stopWarning } from '../host/life/index.js';
 import { cappedMemoryMb, decideMemory, memoryNote, residentCapMb, residentNote, resolveMemoryMb, } from '../host/launch/index.js';
 import { vgpuWarning, GENTLE_NOTE } from '../host/launch/risk-notes.js';
+import { judgeSandbox } from '../host/health/index.js';
+import { cleanUpLeftovers, cleanupQuestion, killArgs } from '../host/sandbox/index.js';
+import { parseTasklist } from '../host/sharing/index.js';
 import { bugcheckCode, cpuPercentBetween, explainStop, findDumps, findingLines, freezeLine, hostPressure, lowReason, severeHost, pageFileRisk, parseHostMemory, crashReportText, watchdogStep, WATCHDOG_START, } from '../host/life/index.js';
 // The pure governor files only: governor.ts loads the guest runtime (session.json), which exists only in a sandbox.
 import { canLower, canPause, decide, INITIAL_STATE, isLinker, linkerSlots, ROTATE_MS, } from '../guest/governor/decide.js';
@@ -252,12 +255,79 @@ export const heavyLoadSuite = {
         t.check(!HeartbeatSchema.safeParse({ ...beat, topProcesses: Array.from({ length: 6 }, () => beat.topProcesses[0]) })
             .success &&
             !HeartbeatSchema.safeParse({ ...beat, topProcesses: [{ name: 'x'.repeat(500), privateMb: 1 }] }).success, 'an oversize heartbeat is refused');
-        t.check(heartbeatLine({ ...beat, topProcesses: [{ name: 'ab', privateMb: 5 }] }).includes('') === false, 'guest text in the heartbeat line goes through safeText');
+        t.check(heartbeatLine({ ...beat, topProcesses: [{ name: 'a\u0007b', privateMb: 5 }] }).includes('\u0007') === false, 'guest text in the heartbeat line goes through safeText');
         const life = { started: '2026-11-02T20:45:00.000Z', lastSeen: '2026-11-02T21:31:30.000Z', keepAwake: false };
         t.check((lastEndOf(life, beat, false)?.text ?? '').includes('disks were overloaded') &&
             lastEndOf(life, beat, true) === null &&
             lastEndOf(null, beat, false) === null &&
             lastEndOf({ ...life, ended: { at: life.lastSeen, cause: null } }, beat, false) === null, 'last end: an unexpected end names the disks; running, no record or a normal close say nothing');
+        t.section('Windows Sandbox programs left behind by a dead sandbox');
+        const list = [
+            '"explorer.exe","1200","Console","1","90,000 K"',
+            '"WindowsSandboxClient.exe","4100","Console","1","30,000 K"',
+            '"WindowsSandboxRemoteSession.exe","4200","Console","1","40,000 K"',
+            '"vmwp.exe","4300","Services","0","50,000 K"',
+            '"WindowsSandboxServer.exe","4400","Console","2","30,000 K"',
+        ].join('\n');
+        const baseFacts = {
+            rows: parseTasklist(list),
+            mySession: 1,
+            heartbeatAgeMs: null,
+            lifeEnded: false,
+            startedAgeMs: 3_600_000,
+            answers: null,
+        };
+        const judged = (patch) => judgeSandbox({ ...baseFacts, ...patch });
+        t.check(judged({ rows: parseTasklist('"explorer.exe","1200","Console","1","1 K"') }).state === 'none', 'no Windows Sandbox program: none');
+        t.check(judged({ heartbeatAgeMs: 10_000 }).state === 'running' &&
+            judged({ answers: true, lifeEnded: true }).state === 'running', 'a fresh heartbeat, or a ping answered: the sandbox is ours and running');
+        t.check(judged({ startedAgeMs: 60_000 }).state === 'starting', 'started a minute ago, no heartbeat yet: starting');
+        const leftoverJudged = judged({ lifeEnded: true });
+        t.check(leftoverJudged.state === 'leftover' &&
+            leftoverJudged.pids.join() === '4100,4200' &&
+            leftoverJudged.images.join() === 'WindowsSandboxClient.exe,WindowsSandboxRemoteSession.exe', 'the watcher saw it end but the programs remain: leftover; only this session, only the user programs (not vmwp.exe, not session 2)', leftoverJudged.pids.join());
+        t.check(judged({ heartbeatAgeMs: 600_000 }).state === 'leftover', 'a heartbeat that stopped ten minutes ago: leftover');
+        t.check(judged({ heartbeatAgeMs: 100_000 }).state === 'running', 'a heartbeat 100 seconds old is not yet "gone"');
+        t.check(judged({}).state === 'running', 'no heartbeat at all (an older sandbox) and no end: treated as running, never ended');
+        t.check(judged({ mySession: null, lifeEnded: true }).state === 'foreign' &&
+            judged({ mySession: 3, lifeEnded: true }).pids.length === 0, "another session's sandbox is never touched");
+        t.check(killArgs([4100, 4200, 0, 2, -5, 1.5]).join(' ') === '/F /PID 4100 /PID 4200' &&
+            cleanupQuestion(leftoverJudged).lines.join(' ').includes('Nothing else'), 'taskkill gets only real process ids; the question names what is closed');
+        const run = async (facts, answers, over = {}) => {
+            const did = [];
+            let n = 0;
+            let asked = 0;
+            const outcome = await cleanUpLeftovers({
+                facts: () => Promise.resolve(facts[Math.min(n++, facts.length - 1)]),
+                end: (pids) => {
+                    did.push('end ' + pids.join(','));
+                    return true;
+                },
+                restartService: () => {
+                    did.push('service');
+                    return true;
+                },
+                confirm: () => Promise.resolve(answers[asked++] ?? false),
+                say: (line) => did.push('say ' + line),
+                ...over,
+            });
+            return { outcome, did };
+        };
+        const noneLeft = { ...baseFacts, rows: [] };
+        const asked = await run([{ ...baseFacts, lifeEnded: true }, noneLeft], [true]);
+        t.check(asked.outcome === 'cleaned' && asked.did[0] === 'end 4100,4200' && !asked.did.includes('service'), 'leftover, yes: they are closed and nothing else happens');
+        const declinedRun = await run([{ ...baseFacts, lifeEnded: true }], [false]);
+        t.check(declinedRun.outcome === 'declined' && declinedRun.did.length === 0, 'leftover, no: nothing is closed');
+        const live = await run([{ ...baseFacts, heartbeatAgeMs: 5000 }], [true]);
+        t.check(live.outcome === 'alive' && !live.did.some((d) => d.startsWith('end')), 'a sandbox that is alive is never closed, whatever the answer');
+        t.check((await run([noneLeft], [true])).outcome === 'nothing', 'nothing left: nothing to do');
+        const stuck = { ...baseFacts, lifeEnded: true };
+        const serviceYes = await run([stuck, stuck], [true, true]);
+        t.check(serviceYes.outcome === 'service-restarted' && serviceYes.did.includes('service'), 'programs that will not go: asks, then restarts the service (elevated)');
+        const serviceNo = await run([stuck, stuck], [true, false]);
+        t.check(serviceNo.outcome === 'declined' && !serviceNo.did.includes('service'), 'the service is only restarted when you say yes');
+        const forced = await run([stuck, noneLeft], [true], { alsoService: true });
+        t.check(forced.outcome === 'service-restarted', 'asked to restart the service as well: it does, without a second question');
         t.section('the governor over a port (fake Windows)');
         const calls = [];
         const port = {
@@ -403,6 +473,53 @@ export const heavyLoadSuite = {
         t.check(pageFileRisk(pc({ pageFile: 'fixed', commitLimitMb: 90000, commitAvailableMb: 80000 }), 20000) === null, 'a fixed but large one is fine');
         t.section('the crash report');
         const ev = (id, provider, at, process = '') => ({ id, provider, at, process });
+        t.section('a sandbox that vanishes');
+        const kindOf = (events) => explainStop(events)?.kind ?? 'none';
+        t.check(kindOf([
+            ev(4101, 'Display', '2026-11-02T21:31:00Z', 'Display driver nvlddmkm stopped responding and has successfully recovered.'),
+        ]) === 'gpu' && explainStop([ev(4101, 'Display', '2026-11-02T21:31:00Z')]).text.includes('graphics driver'), 'Display 4101: the graphics driver reset (gpu)');
+        t.check(kindOf([
+            ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'Fault bucket 1, type 5' + ' Event Name: LiveKernelEvent' + ' P1: 141' + ' P2: ffff'),
+        ]) === 'gpu' &&
+            kindOf([
+                ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'Event Name: LiveKernelEvent P1: 1a8 P2: 0'),
+            ]) === 'gpu' &&
+            kindOf([
+                ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'Event Name: LiveKernelEvent P1: 999 P2: 0'),
+            ]) === 'none', 'LiveKernelEvent 117, 141 and 1a8 are GPU resets; other codes are not a cause');
+        t.check(explainStop([ev(1000, 'Application Error', '2026-11-02T21:31:00Z', 'Faulting application name: vmwp.exe')])
+            ?.kind === 'hyperv' &&
+            kindOf([ev(1001, 'Windows Error Reporting', '2026-11-02T21:31:00Z', 'vmmemWindowsSandbox crashed')]) ===
+                'hyperv' &&
+            kindOf([ev(1000, 'Application Error', '2026-11-02T21:31:00Z', 'Faulting application name: notepad.exe')]) ===
+                'none', 'a crash report of vmwp.exe or vmmem is a cause; another program is not');
+        t.check(kindOf([ev(12010, 'Microsoft-Windows-Hyper-V-VmSwitch', '2026-11-02T21:31:00Z')]) === 'hyperv' &&
+            kindOf([ev(40001, 'Microsoft-Windows-Hyper-V-Worker', '2026-11-02T21:31:00Z')]) === 'none' &&
+            kindOf([ev(18590, 'Microsoft-Windows-Hyper-V-Worker', '2026-11-02T21:31:00Z', 'ErrorCode0: 0x50')]) ===
+                'sandboxCrash', 'Hyper-V worker, switch and compute errors are a cause; the sandbox crashing inside is still its own kind');
+        const started = '2026-11-02T20:45:00.000Z';
+        const endMs = Date.parse('2026-11-02T21:32:00.000Z');
+        const working = {
+            at: '2026-11-02T21:31:50.000Z',
+            uptimeS: 2800,
+            ramFreePct: 60,
+            commitPct: 30,
+            step: 0,
+            hostStep: 0,
+            topProcesses: [],
+            phase: 'working',
+        };
+        t.check(vanishedCause(working, started, false, endMs)?.kind === 'vanished', 'busy, fresh heartbeat, no word of leaving: vanished');
+        t.check(vanishedCause({ ...working, phase: 'ending' }, started, false, endMs) === null &&
+            vanishedCause(working, started, true, endMs) === null &&
+            vanishedCause(null, started, false, endMs) === null, 'an orderly end, a stop on purpose, or no heartbeat is not a vanishing');
+        t.check(vanishedCause({ ...working, phase: 'ready' }, started, false, endMs) === null &&
+            vanishedCause({ ...working, phase: 'ready', step: 2 }, started, false, endMs)?.kind === 'vanished', 'an idle sandbox (window closed by hand) is on purpose; one that was slowing builds down is not');
+        t.check(vanishedCause({ ...working, at: '2026-11-02T21:20:00.000Z' }, started, false, endMs) === null &&
+            vanishedCause({ ...working, at: '2026-11-01T21:31:50.000Z' }, started, false, endMs) === null, 'a stale heartbeat, or one from an earlier run, says nothing about this end');
+        const gone = vanishedCause(working, started, false, endMs);
+        const warning = stopWarning({ started, lastSeen: '2026-11-02T21:31:30.000Z', keepAwake: false, ended: { at: gone.at, cause: gone } }, () => null);
+        t.check((warning ?? '').includes('ended suddenly') && (warning ?? '').includes('vGPU'), 'the next launch warns about a vanished sandbox, and says what usually causes it');
         t.check(bugcheckCode('BugcheckCode 209') === '0xD1' && bugcheckCode('BugcheckCode 0') === null, 'Kernel-Power 41 stop code');
         const cause = explainStop([ev(41, 'Microsoft-Windows-Kernel-Power', '2026-10-15T20:53:47Z', 'BugcheckCode 0')]);
         t.check(cause?.kind === 'crash' && cause.text.includes('freeze'), 'no stop code: a freeze, crash or power cut');

package/dist/selftest/index.js

@@ -28,6 +28,7 @@ import { channelSuite } from './channel.test.js';
 import { heavyLoadSuite } from './heavy-load.test.js';
 import { cliSuite } from './cli.test.js';
 import { agentPathsSuite } from './agent-paths.test.js';
+import { agentSettingsSuite } from './agent-settings.test.js';
 import { cmdlineSuite } from './cmdline.test.js';
 import { configSuite } from './config.test.js';
 import { migrateSuite } from './migrate.test.js';
@@ -140,6 +141,7 @@ export const SUITES = [
     personalizationSuite,
     cmdlineSuite,
     agentPathsSuite,
+    agentSettingsSuite,
     setupSuite,
     dataSuite,
     repairSuite,

package/dist/selftest/menu.test.js

@@ -243,8 +243,8 @@ export const menuSuite = {
             agentList.categories?.map((c) => c.id),
         ], [
             ['repeat', 'agent:codex', 'agent:claude', 'add'],
-            ['start', 'options'],
-        ], 'Agents: Repeat last, the default agent first, the others, then Add an agent; no "On this PC" while it is empty');
+            ['start', 'options', 'host'],
+        ], 'Agents: Repeat last, the default agent first, the others, then Add an agent; "On this PC" always holds the agent commands switch');
         t.check(agentList.items
             .filter((i) => i.category === 'options')
             .map((i) => i.value)
@@ -580,7 +580,9 @@ export const menuSuite = {
             keyFor('x', 'agent:mine') &&
             !keyFor('x', 'agent:codex') &&
             typeof actionList.actions === 'function' &&
-            actionList.actions('start').length === 2 &&
+            actionList.actions('start').length === 3 &&
+            keyFor('e', 'agent:claude') &&
+            !keyFor('e', 'agent:codex') &&
             actionList.actions('options').length === 0, 'Make default shows on any other agent, Remove only on one you added; neither on built-in agents or other rows');
         const agentsFile = ConfigFile.user(t.at('agents-actions', 'config.json'));
         t.write(agentsFile.file, '{\n  // mine\n  "defaultHarness": "claude"\n}\n');

package/dist/selftest/pc-installs.test.js

@@ -11,6 +11,7 @@ import { LocalOverridesSchema } from '../core/schema/index.js';
 import { discoverPcInstalls } from '../host/pc-installs/index.js';
 import { generateSandbox } from '../host/launch/index.js';
 import { isValidGuestPath, PC_INSTALLS_GUEST } from '../shared/paths/index.js';
+import { NOT_READY } from '../shared/readiness.js';
 const PC = { localAppData: '', appData: '', programData: '' };
 export const pcInstallsSuite = {
     name: 'pc-installs',
@@ -70,6 +71,9 @@ export const pcInstallsSuite = {
         t.check(session.pcInstalls?.items.map((i) => i.id).join() === '480,UE_5.4' &&
             !JSON.stringify(session.pcInstalls).includes(game), 'session.json lists them by their place in the sandbox only');
         t.section('detection of the new toolchains');
+        // These toolchains are hidden until written (NOT_READY); their detection rules are tested as if they were ready.
+        const hidden = [...NOT_READY.toolchains];
+        NOT_READY.toolchains.length = 0;
         const tc = structuredClone(DEFAULTS.toolchains);
         const decide = (entries, hints = {}, settingsOf = tc) => decideToolchains(settingsOf, entries, [], hints);
         const godot = decide(['project.godot']);
@@ -92,6 +96,7 @@ export const pcInstallsSuite = {
         t.check(decide(['project.godot'], {}, godotNet).dotnet.on, "Godot's .NET build brings .NET");
         const fivem = decide(['fxmanifest.lua']);
         t.check(!fivem.fivem.on && fivem.fivem.reason.includes('fivem.acceptLicense'), 'the FiveM server is licensed too');
+        NOT_READY.toolchains.push(...hidden);
         t.section('a project never accepts a licence or shares a sign-in');
         t.check(LICENSED_TOOLCHAINS.every((n) => OFF_IS_SAFER.includes('toolchains.' + n + '.acceptLicense')) &&
             OFF_IS_SAFER.includes('accounts.epic.share') &&

package/dist/selftest/persisted-installs.test.js

@@ -6,6 +6,13 @@ import path from 'node:path';
 import { DEFAULTS } from '../core/config/index.js';
 import { assertLocalRoom, ensurePersisted, installRecords, InstallRecordsSchema, LOCAL_RESERVE_BYTES, recordUse, } from '../guest/toolchains/persisted.js';
 import { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted, } from '../guest/toolchains/native/vs-request.js';
+import { autosdkLayout, layoutNextStep, unrealUsesAutosdk, vsExitText } from '../guest/toolchains/native/vs-request.js';
+import { freeBytesAt } from '../shared/io/disk.js';
+import { SIGNERS, signerMatches } from '../shared/signer.js';
+import { decideToolchains } from '../core/detect/toolchains.js';
+import { NOT_READY } from '../shared/readiness.js';
+import { ConfigFile } from '../app/features/settings/settings-file.js';
+import { settingsOf } from '../app/features/settings/settings-rows.js';
 import { collectDataEntries } from '../cli/services/data-collect.js';
 const GB = 1024 ** 3;
 export const persistedInstallsSuite = {
@@ -103,5 +110,67 @@ export const persistedInstallsSuite = {
             all.for.join() === 'unreal,flutter,unity' &&
             UNREAL_COMPONENTS.every((c) => all.components.includes(c)) &&
             all.components.includes('Microsoft.VisualStudio.Component.VC.Llvm.Clang'), 'with Unreal: one Community install serves all of them');
+        t.section('Unreal on the portable MSVC (autosdk)');
+        tc.unreal.visualStudio = 'autosdk';
+        const noUnreal = visualStudioWanted(tc);
+        t.check(noUnreal?.product === 'buildtools' && noUnreal.for.join() === 'flutter,unity', 'autosdk: Unreal asks for no Visual Studio (the others still get the Build Tools)');
+        tc.flutter.enabled = false;
+        tc.unity.enabled = false;
+        t.equal(visualStudioWanted(tc), null, 'autosdk alone: no Visual Studio at all');
+        t.check(unrealUsesAutosdk(tc, (s) => s === true) && !unrealUsesAutosdk(DEFAULTS.toolchains), 'autosdk is only when asked');
+        const pairs = autosdkLayout('T:\\msvc', '14.44.35207', '10.0.26100.0', 'T:\\autosdk');
+        t.check(pairs.length === 4 &&
+            pairs[0].to === 'T:\\autosdk\\HostWin64\\Win64\\VS2022\\14.44.35207' &&
+            pairs[0].from === 'T:\\msvc\\VC\\Tools\\MSVC\\14.44.35207' &&
+            pairs[1].from === 'T:\\msvc\\Windows Kits\\10\\Include\\10.0.26100.0' &&
+            pairs[1].to === 'T:\\autosdk\\HostWin64\\Win64\\Windows Kits\\10\\Include\\10.0.26100.0', 'the AutoSDK tree is MSVC under VS2022\\<version> and the SDK under Windows Kits\\10 (copies)');
+        const on = DEFAULTS.toolchains;
+        const auto = {
+            ...structuredClone(on),
+            unreal: { ...on.unreal, visualStudio: 'autosdk', acceptLicense: true },
+        };
+        const decided = decideToolchains(auto, ['Game.uproject'], []);
+        t.check(decided.unreal.on && decided.msvc.on, 'an Unreal project with autosdk turns the portable MSVC on, under its licence');
+        t.section('the Visual Studio layout');
+        t.check(vsExitText(3762504530).includes('crashed') &&
+            vsExitText(-1).includes('exit 4294967295') &&
+            vsExitText(0) === 'installed' &&
+            vsExitText(1602) === 'cancelled' &&
+            vsExitText(8006).includes('running') &&
+            vsExitText(3010).includes('restart') &&
+            vsExitText(5007).includes('refused'), 'installer exit codes are told in words (0xE0434352 is a crash)');
+        const reserve = LOCAL_RESERVE_BYTES;
+        const room = (free) => freeBytesAt(t.dir('layout-room'), () => ({ bavail: free, bsize: 1 })) ?? 0;
+        t.check(layoutNextStep(0, 0, reserve) === 'done' &&
+            layoutNextStep(3762504530, room(40 * GB), reserve) === 'stage' &&
+            layoutNextStep(3762504530, room(20 * GB), reserve) === 'skip' &&
+            layoutNextStep(null, room(40 * GB), reserve) === 'stage', 'a failed layout is built on the sandbox disk only with room for it (12 GB plus the reserve)');
+        t.equal(freeBytesAt(path.join(t.dir('layout-room'), 'not', 'there'), () => ({ bavail: 3, bsize: 2 })), 6, 'free room of a folder that does not exist asks its parent');
+        t.equal(freeBytesAt(t.dir('layout-room'), () => {
+            throw new Error('no');
+        }), null, 'unknown free room is null');
+        t.section('signers');
+        const ms = { subject: SIGNERS.microsoft.subject, issuer: undefined };
+        const msSig = {
+            subject: 'CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US',
+            issuer: 'CN=Microsoft Code Signing PCA',
+        };
+        t.check(signerMatches(msSig, ms) &&
+            !signerMatches({ ...msSig, subject: 'CN=Microsoft Corporation Fake, O=Evil' }, ms) &&
+            !signerMatches(null, ms) &&
+            signerMatches({ subject: 'CN="Valve Corp.", O=Valve', issuer: 'x' }, SIGNERS.valve) &&
+            signerMatches({ subject: 'CN=Unity Technologies ApS', issuer: 'x' }, SIGNERS.unity) &&
+            !signerMatches({ subject: 'CN=Microsoft Corporation', issuer: 'x' }, SIGNERS.valve) &&
+            signerMatches(msSig, { subject: ['^CN=Microsoft'], issuer: ['code signing'] }) &&
+            !signerMatches(msSig, { subject: ['^CN=Microsoft'], issuer: ['nobody'] }), 'a signer matches by subject (and issuer when named), never an empty or unsigned file');
+        t.section('not ready yet');
+        const everything = structuredClone(on);
+        for (const name of NOT_READY.toolchains)
+            everything[name].enabled = 'auto';
+        const found = decideToolchains(everything, ['ProjectVersion.txt', 'project.godot', 'fxmanifest.lua'], ['unity']);
+        t.check(NOT_READY.toolchains.every((n) => !found[n].on), '"auto" never turns on a toolchain that is not written yet, whatever the project holds');
+        const shown = settingsOf(ConfigFile.user(t.at('settings', 'config.json'))).map((r) => r.key.join('.'));
+        t.check(!shown.some((k) => /^toolchains\.(unity|godot|android|flutter|dart|reactNative|fivem)\./.test(k)) &&
+            shown.includes('toolchains.unreal.visualStudio'), 'settings do not list the toolchains that are not written yet');
     },
 };