grain-tools 0.10.21 → 0.10.22

package/out/server/standalone.js

@@ -59,7 +59,20 @@ function publishDaemonEndpoint(configDir, record2) {
   try {
     fs.writeFileSync(sibling, `${JSON.stringify(payload, null, 2)}
 `, { mode: 384 });
-    fs.renameSync(sibling, target);
+    for (let attempt = 1; ; attempt += 1) {
+      try {
+        fs.renameSync(sibling, target);
+        break;
+      } catch (error52) {
+        const code = error52.code;
+        if (!code || !TRANSIENT_RENAME_ERRORS.has(code) || attempt >= RENAME_ATTEMPTS) {
+          throw error52;
+        }
+        if (typeof Atomics !== "undefined" && typeof SharedArrayBuffer !== "undefined") {
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, RENAME_RETRY_DELAY_MS);
+        }
+      }
+    }
   } catch (e2) {
     try {
       fs.unlinkSync(sibling);
@@ -103,7 +116,7 @@ function removeDaemonEndpoint(configDir) {
   } catch {
   }
 }
-var fs, path, DAEMON_ENDPOINT_FILENAME, DAEMON_ENDPOINT_SCHEMA_VERSION, GRAIN_NOT_INSTALLED_MESSAGE, publishSeq;
+var fs, path, DAEMON_ENDPOINT_FILENAME, DAEMON_ENDPOINT_SCHEMA_VERSION, GRAIN_NOT_INSTALLED_MESSAGE, publishSeq, TRANSIENT_RENAME_ERRORS, RENAME_ATTEMPTS, RENAME_RETRY_DELAY_MS;
 var init_daemonEndpointFile = __esm({
   "src/common/daemonEndpointFile.ts"() {
     "use strict";
@@ -113,6 +126,9 @@ var init_daemonEndpointFile = __esm({
     DAEMON_ENDPOINT_SCHEMA_VERSION = 1;
     GRAIN_NOT_INSTALLED_MESSAGE = "Grain is not set up on this machine yet. Run `grain install` to set it up.";
     publishSeq = 0;
+    TRANSIENT_RENAME_ERRORS = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY", "EEXIST"]);
+    RENAME_ATTEMPTS = 5;
+    RENAME_RETRY_DELAY_MS = 10;
   }
 });
 
@@ -16945,6 +16961,40 @@ var init_stdio2 = __esm({
   }
 });
 
+// src/server/bridge/agentGone.ts
+function watchAgentGone(onGone, options = {}) {
+  const stdin = options.stdin ?? process.stdin;
+  const getParentPid = options.getParentPid ?? (() => process.ppid);
+  const originalParent = getParentPid();
+  let fired = false;
+  const fire = () => {
+    if (!fired) {
+      fired = true;
+      stop2();
+      onGone();
+    }
+  };
+  const timer = setInterval(() => {
+    if (getParentPid() !== originalParent) {
+      fire();
+    }
+  }, options.intervalMs ?? 5e3);
+  timer.unref?.();
+  stdin.on("end", fire);
+  stdin.on("close", fire);
+  function stop2() {
+    clearInterval(timer);
+    stdin.off("end", fire);
+    stdin.off("close", fire);
+  }
+  return stop2;
+}
+var init_agentGone = __esm({
+  "src/server/bridge/agentGone.ts"() {
+    "use strict";
+  }
+});
+
 // node_modules/content-type/index.js
 var require_content_type = __commonJS({
   "node_modules/content-type/index.js"(exports) {
@@ -19295,6 +19345,7 @@ async function runStdioBridge(port) {
   });
   process.on("SIGINT", () => void bridge.close());
   process.on("SIGTERM", () => void bridge.close());
+  watchAgentGone(() => void bridge.close());
   await bridge.start();
 }
 var BRIDGE_ORIGIN_HEADER, StdioBridge;
@@ -19303,6 +19354,7 @@ var init_StdioBridge = __esm({
     "use strict";
     init_engineUpdating();
     init_stdio2();
+    init_agentGone();
     init_streamableHttp();
     init_AgentToken();
     init_ConfigLoader();
@@ -19906,8 +19958,12 @@ async function main() {
 main();
 `;
 }
-function windowsLauncherSource(nodePath, scriptPath) {
-  return `@echo off\\r\\n"${nodePath.replace(/"/g, '""')}" "${scriptPath.replace(/"/g, '""')}"\\r\\n`;
+function windowsLauncherSource(nodePath, scriptPath, environment) {
+  const setup = Object.entries(environment ?? {}).map(([key, value]) => `set "${key}=${value.replace(/%/g, "%%").replace(/"/g, '""')}"\r
+`).join("");
+  return `@echo off\r
+${setup}"${nodePath.replace(/"/g, '""')}" "${scriptPath.replace(/"/g, '""')}"\r
+`;
 }
 var path9, LAUNCHER_RESTART_DELAYS_MS;
 var init_launcher = __esm({
@@ -20180,7 +20236,7 @@ function writeGrainCommand(home, platform2 = process.platform, fileSystem = fs9)
   if (platform2 === "win32") {
     const libexec = path12.join(home, "libexec");
     fileSystem.mkdirSync(libexec, { recursive: true });
-    const script2 = WIN_SCRIPT.replace("__GRAIN_HOME__", home);
+    const script2 = WIN_SCRIPT.replace("__GRAIN_HOME__", escapePowerShellLiteral(home));
     const psPath = path12.join(libexec, "grain.ps1");
     const psContent = "\uFEFF" + script2 + "\r\n";
     if (!fileSystem.existsSync(psPath) || fileSystem.readFileSync(psPath, "utf8") !== psContent) {
@@ -20205,6 +20261,9 @@ function writeGrainCommand(home, platform2 = process.platform, fileSystem = fs9)
     fileSystem.chmodSync(commandPath, 493);
   }
 }
+function escapePowerShellLiteral(value) {
+  return value.replace(/'/g, "''");
+}
 var fs9, path12, POSIX_SCRIPT, WIN_SCRIPT, CMD_SCRIPT;
 var init_grainCommand = __esm({
   "src/server/install/grainCommand.ts"() {
@@ -20229,20 +20288,20 @@ fi
 exec "$node" "$app" "$@"
 `;
     WIN_SCRIPT = `$GrainHome = if ($env:GRAIN_HOME) { $env:GRAIN_HOME } else { '__GRAIN_HOME__' }
-$Node = Get-ChildItem -Path (Join-Path $GrainHome 'runtime\\node') -Directory -ErrorAction SilentlyContinue |
+$Node = Get-ChildItem -LiteralPath (Join-Path $GrainHome 'runtime\\node') -Directory -ErrorAction SilentlyContinue |
     Sort-Object { try { [version]($_.Name -replace '-.*$', '') } catch { [version]'0.0.0' } }, Name |
     ForEach-Object {
         $FlatNodePath = Join-Path $_.FullName 'Grain.exe'
-        if (Test-Path $FlatNodePath) { $FlatNodePath } else { Join-Path $_.FullName 'bin\\Grain.exe' }
+        if (Test-Path -LiteralPath $FlatNodePath) { $FlatNodePath } else { Join-Path $_.FullName 'bin\\Grain.exe' }
     } |
-    Where-Object { Test-Path $_ } | Select-Object -Last 1
-$Versions = @(Get-ChildItem -Path (Join-Path $GrainHome 'versions') -Filter '*.json' -ErrorAction SilentlyContinue | ForEach-Object { $_.BaseName }) + @(Get-ChildItem -Path (Join-Path $GrainHome 'app') -Directory -ErrorAction SilentlyContinue | ForEach-Object { $_.Name })
+    Where-Object { Test-Path -LiteralPath $_ } | Select-Object -Last 1
+$Versions = @(Get-ChildItem -LiteralPath (Join-Path $GrainHome 'versions') -Filter '*.json' -ErrorAction SilentlyContinue | ForEach-Object { $_.BaseName }) + @(Get-ChildItem -LiteralPath (Join-Path $GrainHome 'app') -Directory -ErrorAction SilentlyContinue | ForEach-Object { $_.Name })
 $Version = $Versions |
     Sort-Object { try { [version]($_ -replace '-.*$', '') } catch { [version]'0.0.0' } }, { $_ } |
-    Where-Object { Test-Path (Join-Path $GrainHome "app\\$_\\standalone.js") } |
+    Where-Object { Test-Path -LiteralPath (Join-Path $GrainHome "app\\$_\\standalone.js") } |
     Select-Object -Last 1
 $App = if ($Version) { Join-Path $GrainHome "app\\$Version\\standalone.js" } else { $null }
-if (-not $Node -or -not $App -or -not (Test-Path $App)) {
+if (-not $Node -or -not $App -or -not (Test-Path -LiteralPath $App)) {
     [Console]::Error.WriteLine("Grain is not installed correctly in $GrainHome. Reinstall with: irm https://grain.tools/install.ps1 | iex")
     exit 1
 }
@@ -21838,7 +21897,7 @@ var require_package = __commonJS({
       name: "grain",
       displayName: "Grain SQL",
       description: "Run SQL in VS Code and expose safe, visible MCP database tools for Claude, Cursor, and other AI agents.",
-      version: "0.10.21",
+      version: "0.10.22",
       license: "UNLICENSED",
       mcpName: "io.github.pattrnlabs/grain",
       publisher: "pattrnlabs",
@@ -22514,6 +22573,7 @@ var require_package = __commonJS({
         "pretest:medium:webapp-gate": "npm run build:web-app",
         "test:medium:webapp-gate": "vitest run --config vitest.medium.config.ts src/test/medium/standaloneWebAppGate.medium.test.js",
         "test:integration:stdio-bridge": 'node scripts/emit-seam-receipt.js "npm run test:integration:stdio-bridge" -- vitest run --no-file-parallelism src/test/integration/stdio_bridge.test.ts',
+        "test:seam:trino-axios": 'node scripts/emit-seam-receipt.js "npm run test:seam:trino-axios" -- vitest run --config packages/sql-preview-trino/vitest.config.ts packages/sql-preview-trino/src/__tests__/TrinoConnector.axios-seam.test.ts',
         "test:medium:rfc-baseline": "vitest run --config vitest.medium.config.ts src/test/medium/rfcBaselineResolution.medium.test.js",
         "test:integration": "node ./out/test/runTest.js",
         prewalkthrough: "npm run compile && node scripts/build-daemon.js --entry=standalone",
@@ -22748,7 +22808,7 @@ function postJson(url3, payload, timeoutMs) {
     const parsed = new import_url.URL(url3);
     const body = JSON.stringify(payload);
     const client = parsed.protocol === "http:" ? http3 : https;
-    const request3 = client.request(
+    const request4 = client.request(
       {
         hostname: parsed.hostname,
         method: "POST",
@@ -22778,10 +22838,10 @@ function postJson(url3, payload, timeoutMs) {
         });
       }
     );
-    request3.on("timeout", () => request3.destroy(new Error("Telemetry request timed out")));
-    request3.on("error", reject);
-    request3.write(body);
-    request3.end();
+    request4.on("timeout", () => request4.destroy(new Error("Telemetry request timed out")));
+    request4.on("error", reject);
+    request4.write(body);
+    request4.end();
   });
 }
 var http3, https, import_url, DEFAULT_POSTHOG_HOST, TelemetrySendError, TelemetryEmitter, DEFAULT_TELEMETRY_TRANSPORT;
@@ -23307,11 +23367,11 @@ function downloadToFile(url3, destPath, options) {
     const download = (currentUrl, redirects) => {
       try {
         const client = clientFor(currentUrl);
-        const request3 = client.get(currentUrl, (response) => {
+        const request4 = client.get(currentUrl, (response) => {
           clearHopTimers();
           if ([301, 302, 303, 307, 308].includes(response.statusCode ?? 0)) {
             response.destroy();
-            request3.destroy();
+            request4.destroy();
             if (redirects >= 5) {
               failOnce(new Error(`Download failed for ${url3}: too many redirects`));
               return;
@@ -23349,7 +23409,7 @@ function downloadToFile(url3, destPath, options) {
               clearTimeout(idleTimeout);
             }
             idleTimeout = setTimeout(() => {
-              request3.destroy();
+              request4.destroy();
               failOnce(new Error(`Download timed out waiting for data for ${currentUrl}`));
             }, idleTimeoutMs);
           };
@@ -23358,7 +23418,7 @@ function downloadToFile(url3, destPath, options) {
             receivedBytes += chunk.length;
             if (options?.maxBytes !== void 0 && receivedBytes > options.maxBytes) {
               failOnce(new Error("Download exceeded expected size"));
-              request3.destroy();
+              request4.destroy();
             }
           });
           resetIdleTimeout();
@@ -23377,12 +23437,12 @@ function downloadToFile(url3, destPath, options) {
           });
           file5.on("error", failOnce);
         });
-        activeRequest = request3;
+        activeRequest = request4;
         responseTimeout = setTimeout(() => {
-          request3.destroy();
+          request4.destroy();
           failOnce(new Error(`Download timed out waiting for response headers for ${currentUrl}`));
         }, responseTimeoutMs);
-        request3.on("error", failOnce);
+        request4.on("error", failOnce);
       } catch (error52) {
         failOnce(error52 instanceof Error ? error52 : new Error(String(error52)));
       }
@@ -24099,6 +24159,11 @@ var init_supervisorUnits = __esm({
 // src/server/install/launchAgent.ts
 function generateLaunchAgent(descriptor) {
   const dest = serviceUnitRelativePath("darwin", descriptor.serviceIdentifier);
+  const environment = { GRAIN_HOME: descriptor.configHome, ...descriptor.environment };
+  const environmentEntries = Object.entries(environment).map(
+    ([name, value]) => `    <key>${escapeXml(name)}</key>
+    <string>${escapeXml(value)}</string>`
+  ).join("\n");
   const content = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -24112,8 +24177,7 @@ function generateLaunchAgent(descriptor) {
   </array>
   <key>EnvironmentVariables</key>
   <dict>
-    <key>GRAIN_HOME</key>
-    <string>${escapeXml(descriptor.configHome)}</string>
+${environmentEntries}
   </dict>
   <key>StandardOutPath</key>
   <string>${escapeXml(descriptor.stdoutPath)}</string>
@@ -24159,13 +24223,15 @@ function generateSystemdUserUnit(descriptor) {
     }
     return str;
   };
+  const environment = { GRAIN_HOME: descriptor.configHome, ...descriptor.environment };
+  const environmentEntries = Object.entries(environment).map(([name, value]) => `Environment=${name}=${escapeExec(value)}`).join("\n");
   const content = `[Unit]
 Description=${descriptor.serviceIdentifier} Supervisor
 After=network.target
 
 [Service]
 ExecStart=${escapeExec(descriptor.nodePath)} ${escapeExec(descriptor.launcherPath)}
-Environment=GRAIN_HOME=${escapeExec(descriptor.configHome)}
+${environmentEntries}
 StandardOutput=append:${descriptor.stdoutPath}
 StandardError=append:${descriptor.stderrPath}
 Restart=always
@@ -24743,7 +24809,7 @@ function writeAtomicPointer(fileSystem, pointerPath2, contents, mode) {
     throw error52;
   }
 }
-function writeLauncherAtomically(fileSystem, platform2, configHome, nodePath) {
+function writeLauncherAtomically(fileSystem, platform2, configHome, nodePath, environment) {
   const scriptPath = launcherPath(configHome);
   writeAtomicPointer(fileSystem, scriptPath, launcherSource(configHome), 448);
   fileSystem.chmodSync(scriptPath, 448);
@@ -24751,7 +24817,7 @@ function writeLauncherAtomically(fileSystem, platform2, configHome, nodePath) {
     writeAtomicPointer(
       fileSystem,
       platformLauncherPath(platform2, configHome),
-      windowsLauncherSource(nodePath, scriptPath)
+      windowsLauncherSource(nodePath, scriptPath, environment)
     );
   }
 }
@@ -24816,22 +24882,30 @@ var init_serviceReadiness = __esm({
 });
 
 // src/server/install/installCommand.ts
-function unitFor(platform2, launcher, configHome, nodePath) {
+function unitFor(platform2, launcher, configHome, nodePath, env2 = {}) {
+  const environment = env2["GRAIN_TEST_FORBID_NATIVE_KEYCHAIN"] === "1" ? Object.fromEntries(
+    [
+      "GRAIN_TEST_FORBID_NATIVE_KEYCHAIN",
+      "GRAIN_TEST_KEYRING_MODULE_PATH",
+      "GRAIN_TEST_KEYRING_STORE_PATH"
+    ].filter((name) => env2[name] !== void 0).map((name) => [name, env2[name]])
+  ) : void 0;
   const descriptor = {
     launcherPath: launcher,
     nodePath,
     configHome,
     serviceIdentifier: GRAIN_SERVICE_LABEL,
     stdoutPath: path27.join(configHome, "grain-daemon.out.log"),
-    stderrPath: path27.join(configHome, "grain-daemon.err.log")
+    stderrPath: path27.join(configHome, "grain-daemon.err.log"),
+    ...environment ? { environment } : {}
   };
   if (platform2 === "darwin") {
-    return generateLaunchAgent(descriptor);
+    return { ...generateLaunchAgent(descriptor), ...environment ? { environment } : {} };
   }
   if (platform2 === "linux") {
-    return generateSystemdUserUnit(descriptor);
+    return { ...generateSystemdUserUnit(descriptor), ...environment ? { environment } : {} };
   }
-  return generateWindowsStartupTask(descriptor);
+  return { ...generateWindowsStartupTask(descriptor), ...environment ? { environment } : {} };
 }
 function platformLauncherPath2(platform2, configHome) {
   return platform2 === "win32" ? path27.join(configHome, "grain-daemon-launcher.cmd") : launcherPath(configHome);
@@ -24987,13 +25061,13 @@ async function installCommand(deps = {}) {
     throw error52;
   });
   const launcher = platformLauncherPath2(platform2, configHome);
-  const unit = unitFor(platform2, launcher, configHome, nodePath);
+  const unit = unitFor(platform2, launcher, configHome, nodePath, process.env);
   const unitPath = path27.join(homeDirectory, unit.destination);
   const initialStatus = await readStatus();
   const unitExists = fileSystem.existsSync(unitPath);
   const unitChanged = !unitExists || String(fileSystem.readFileSync(unitPath, { encoding: unit.encoding })) !== unit.content;
   const registered = await adapter2.isRegistered(GRAIN_SERVICE_LABEL);
-  writeLauncherAtomically(fileSystem, platform2, configHome, nodePath);
+  writeLauncherAtomically(fileSystem, platform2, configHome, nodePath, unit.environment);
   const installedVersion = deps.installedVersion ?? readDaemonVersion();
   if (!installedVersion) {
     const errLog2 = path27.join(configHome, "grain-daemon.err.log");
@@ -27093,6 +27167,81 @@ var init_spawnOnDemandStart = __esm({
   }
 });
 
+// src/server/cli/stopCommand.ts
+var stopCommand_exports = {};
+__export(stopCommand_exports, {
+  stopCommand: () => stopCommand
+});
+function defaultIsProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error52) {
+    return error52.code !== "ESRCH";
+  }
+}
+async function stopCommand(configDir = resolveGrainHome(), clock = Date, processKiller = process.kill, adapter2 = createSupervisorAdapter(
+  process.platform,
+  createCommandRunner(),
+  process.getuid?.() ?? 0
+), isProcessAlive = defaultIsProcessAlive, platform2 = process.platform, requestStop = requestDaemonControlStop) {
+  if (await adapter2.isRegistered(DAEMON_SERVICE_IDENTITY)) {
+    console.error(
+      "Grain is installed as a background service. Run `grain uninstall` to remove it."
+    );
+    return 1;
+  }
+  const status = await readGrainServiceStatus(configDir);
+  if (!isRunningGrainService(status)) {
+    console.log("Grain is not running.");
+    return 0;
+  }
+  const pid = readDaemonEndpoint(configDir)?.pid;
+  if (pid === void 0) {
+    console.error("Could not determine Grain daemon PID.");
+    return 1;
+  }
+  const token = platform2 === "win32" ? readDaemonAuthToken(configDir) : void 0;
+  const accepted = token ? await requestStop(daemonControlEndpoint(configDir), token) : false;
+  try {
+    if (!accepted) {
+      processKiller(pid, "SIGTERM");
+    }
+  } catch (error52) {
+    const code = error52.code;
+    if (code !== "ESRCH") {
+      console.error(`Could not signal Grain (pid ${pid}): ${code ?? String(error52)}`);
+      return 1;
+    }
+  }
+  const startMs = clock.now();
+  const timeoutMs = accepted ? drainStopBudgetMs(configDir) : 1e4;
+  while (clock.now() - startMs < timeoutMs) {
+    const currentStatus = await readGrainServiceStatus(configDir);
+    if (!isRunningGrainService(currentStatus) && !isProcessAlive(pid)) {
+      console.log("Grain stopped.");
+      return 0;
+    }
+    await new Promise((resolve15) => setTimeout(resolve15, 250));
+  }
+  console.error(`Grain did not stop within ${timeoutMs / 1e3} seconds.`);
+  return 1;
+}
+var init_stopCommand = __esm({
+  "src/server/cli/stopCommand.ts"() {
+    "use strict";
+    init_grainHome();
+    init_daemonEndpointFile();
+    init_statusCommand();
+    init_supervisorAdapter();
+    init_daemonRecordInstance();
+    init_ipcEndpoint();
+    init_DaemonAuthToken();
+    init_requestDaemonControlStop();
+    init_drainStopBudget();
+  }
+});
+
 // src/server/cli/serviceControl.ts
 var serviceControl_exports = {};
 __export(serviceControl_exports, {
@@ -27107,29 +27256,150 @@ function printSuccess(version3, status) {
   process.stdout.write(`Grain ${version3} is running at ${url3}.
 `);
 }
-async function serviceManagesHome(options) {
-  if (!await options.adapter.isRegistered(GRAIN_SERVICE_LABEL)) {
-    return false;
+async function inspectServiceHomeOwnership(options) {
+  try {
+    if (!await options.adapter.isRegistered(GRAIN_SERVICE_LABEL)) {
+      return "unregistered";
+    }
+  } catch {
+    return "unknown";
   }
   const platform2 = options.platform ?? process.platform;
   const launcher = platformLauncherPath2(platform2, options.configHome);
-  const unit = unitFor(platform2, launcher, options.configHome, process.execPath);
+  const unit = unitFor(platform2, launcher, options.configHome, process.execPath, process.env);
   const unitPath = (0, import_path5.join)(options.homeDirectory ?? (0, import_os.homedir)(), unit.destination);
-  const content = (options.readUnit ?? defaultReadUnit)(unitPath, unit.encoding);
-  if (content === void 0) {
-    return false;
+  let content;
+  try {
+    content = (options.readUnit ?? defaultReadUnit)(unitPath, unit.encoding);
+  } catch {
+    return "unknown";
   }
-  return content.includes(launcher) || content.includes(escapeXml(launcher));
+  if (!content?.trim()) {
+    return "unknown";
+  }
+  const registeredLauncher = parseRecognizedGrainLauncher(platform2, content);
+  if (!registeredLauncher) {
+    return "unknown";
+  }
+  return registeredLauncher === launcher ? "this-home" : "other-home";
+}
+function parseRecognizedGrainLauncher(platform2, content) {
+  const fields = platform2 === "darwin" ? parseLaunchAgent(content) : platform2 === "linux" ? parseSystemdUnit(content) : parseWindowsTask(content);
+  if (!fields) {
+    return void 0;
+  }
+  if (fields.launcher !== platformLauncherPath2(platform2, fields.configHome)) {
+    return void 0;
+  }
+  const expected = unitFor(
+    platform2,
+    fields.launcher,
+    fields.configHome,
+    fields.nodePath ?? process.execPath,
+    process.env
+  ).content;
+  return content === expected ? fields.launcher : void 0;
+}
+function decodeXmlText(value) {
+  const decoded = value.replace(/&(amp|lt|gt|quot|apos);/g, (_entity, name) => {
+    switch (name) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      default:
+        return "'";
+    }
+  });
+  return escapeXml(decoded) === value ? decoded : void 0;
+}
+function parseXmlStringAfter(content, marker) {
+  const markerIndex = content.indexOf(marker);
+  const match = markerIndex < 0 ? void 0 : /^\s*<string>([^<]*)<\/string>/.exec(content.slice(markerIndex + marker.length));
+  const value = match?.[1];
+  return value === void 0 ? void 0 : decodeXmlText(value);
+}
+function parseLaunchAgent(content) {
+  const args = /<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>\s*<string>([^<]*)<\/string>\s*<\/array>/.exec(
+    content
+  );
+  const nodeValue = args?.[1];
+  const launcherValue = args?.[2];
+  const nodePath = nodeValue === void 0 ? void 0 : decodeXmlText(nodeValue);
+  const launcher = launcherValue === void 0 ? void 0 : decodeXmlText(launcherValue);
+  const configHome = parseXmlStringAfter(content, "<key>GRAIN_HOME</key>");
+  return nodePath && launcher && configHome ? { nodePath, launcher, configHome } : void 0;
+}
+function parseSystemdArgument(value) {
+  if (value.startsWith('"') && value.endsWith('"')) {
+    const unescaped = value.slice(1, -1).replace(/\\(["\\])/g, "$1");
+    return `"${unescaped.replace(/(["\\])/g, "\\$1")}"` === value ? unescaped : void 0;
+  }
+  return /[\s"&]/.test(value) ? void 0 : value;
+}
+function parseSystemdUnit(content) {
+  const execStart = /^ExecStart=(\S+|"(?:\\.|[^"\\])*"?) (\S+|"(?:\\.|[^"\\])*"?)$/m.exec(content);
+  const environment = /^Environment=GRAIN_HOME=(\S+|"(?:\\.|[^"\\])*"?)$/m.exec(content);
+  const nodeValue = execStart?.[1];
+  const launcherValue = execStart?.[2];
+  const homeValue = environment?.[1];
+  const nodePath = nodeValue === void 0 ? void 0 : parseSystemdArgument(nodeValue);
+  const launcher = launcherValue === void 0 ? void 0 : parseSystemdArgument(launcherValue);
+  const configHome = homeValue === void 0 ? void 0 : parseSystemdArgument(homeValue);
+  return nodePath && launcher && configHome ? { nodePath, launcher, configHome } : void 0;
+}
+function parseWindowsTask(content) {
+  const command = /<Command>([^<]*)<\/Command>/.exec(content);
+  const commandValue = command?.[1];
+  const launcher = commandValue === void 0 ? void 0 : decodeXmlText(commandValue);
+  return launcher ? { launcher, configHome: (0, import_path5.dirname)(launcher) } : void 0;
+}
+async function serviceManagesHome(options) {
+  return await inspectServiceHomeOwnership(options) === "this-home";
 }
 async function requireForegroundAllowed(supervised, adapter2, configHome = resolveGrainHome(), readUnit) {
-  if (supervised)
+  if (supervised) {
     return;
-  if (await serviceManagesHome({ adapter: adapter2, configHome, ...readUnit ? { readUnit } : {} })) {
+  }
+  const ownership = await inspectServiceHomeOwnership({
+    adapter: adapter2,
+    configHome,
+    ...readUnit ? { readUnit } : {}
+  });
+  if (ownership === "this-home") {
     throw new Error(
       `Grain's background service is installed, so Grain is already managed by it. Use grain restart, or grain uninstall first to run it in the foreground.
 `
     );
   }
+  if (ownership === "unknown") {
+    throw new Error(
+      "Grain's background service is registered, but its definition could not be safely read; refusing to run in the foreground.\n"
+    );
+  }
+}
+async function restartOnDemandHome(configHome, adapter2, readUnit) {
+  const ownership = await inspectServiceHomeOwnership({
+    adapter: adapter2,
+    configHome,
+    ...readUnit ? { readUnit } : {}
+  });
+  if (ownership === "this-home" || ownership === "unknown") {
+    process.stderr.write(
+      "Grain service ownership could not be safely established for this home; refusing direct restart.\n"
+    );
+    return 1;
+  }
+  const stopAdapter = ownership === "other-home" ? { ...adapter2, isRegistered: async () => false } : adapter2;
+  const stopExitCode = await stopCommand(configHome, void 0, void 0, stopAdapter);
+  if (stopExitCode !== 0) {
+    return stopExitCode;
+  }
+  return await spawnOnDemandStart(configHome);
 }
 async function startThroughService(options) {
   const adapter2 = options.adapter ?? createSupervisorAdapter(
@@ -27139,17 +27409,38 @@ async function startThroughService(options) {
     options.configHome
   );
   const install56 = options.install ?? (() => installCommand({ configHome: options.configHome }));
+  const installAndStartFallback = async () => {
+    const exitCode = await install56();
+    if (exitCode !== 0) {
+      return exitCode;
+    }
+    const installedServiceMode = readServiceModeStatus(options.configHome);
+    if (installedServiceMode.type === "valid" && installedServiceMode.record.mode === "spawn-on-demand") {
+      return await spawnOnDemandStart(options.configHome);
+    }
+    return exitCode;
+  };
   const serviceMode = readServiceModeStatus(options.configHome);
   if (serviceMode.type === "valid" && serviceMode.record.mode === "spawn-on-demand") {
+    if (options.restart) {
+      return await restartOnDemandHome(options.configHome, adapter2, options.readUnit);
+    }
     return await spawnOnDemandStart(options.configHome);
   }
-  const manages = await serviceManagesHome({
+  const ownership = await inspectServiceHomeOwnership({
     adapter: adapter2,
     configHome: options.configHome,
     ...options.readUnit ? { readUnit: options.readUnit } : {}
   });
+  if (options.restart && ownership === "unknown") {
+    process.stderr.write(
+      "Grain service ownership could not be safely established for this home; refusing restart.\n"
+    );
+    return 1;
+  }
+  const manages = ownership === "this-home";
   if (!manages) {
-    return await install56();
+    return await installAndStartFallback();
   }
   const activeJsonPath = (0, import_path5.join)(options.configHome, ACTIVE_VERSION_FILENAME);
   let activeJson = {};
@@ -27159,7 +27450,7 @@ async function startThroughService(options) {
   }
   const expectedVersion = activeJson.version;
   if (!expectedVersion) {
-    return await install56();
+    return await installAndStartFallback();
   }
   const readStatus = options.readStatus ?? (() => readGrainServiceStatus(options.configHome));
   const waitFn = options.wait ?? (() => waitForVersion(readStatus, (ms) => new Promise((r) => setTimeout(r, ms)), expectedVersion));
@@ -27226,6 +27517,7 @@ var init_serviceControl = __esm({
     init_launchFailureMarker();
     init_serviceMode();
     init_spawnOnDemandStart();
+    init_stopCommand();
     defaultReadUnit = (unitPath, encoding) => {
       try {
         return fs28.readFileSync(unitPath, { encoding });
@@ -27324,7 +27616,8 @@ var init_localBrowserPaths = __esm({
 // src/server/install/supervisedStart.ts
 function readCgroup() {
   try {
-    return fs29.readFileSync("/proc/self/cgroup", "utf8");
+    const cgroup = fs29.readFileSync("/proc/self/cgroup", "utf8");
+    return typeof cgroup === "string" ? cgroup : "";
   } catch {
     return "";
   }
@@ -27396,6 +27689,162 @@ var init_supervisedStart = __esm({
   }
 });
 
+// src/services/featureFlags/FeatureFlagDefinitions.ts
+var FEATURE_FLAGS;
+var init_FeatureFlagDefinitions = __esm({
+  "src/services/featureFlags/FeatureFlagDefinitions.ts"() {
+    "use strict";
+    FEATURE_FLAGS = {
+      managedDuckDbRuntime: {
+        id: "sql_preview_managed_duckdb_runtime",
+        defaultValue: true,
+        description: "Gates background auto-provisioning of the managed DuckDB runtime (RFC-075).",
+        source: "local"
+      },
+      standaloneWebApp: {
+        id: "sql_preview_standalone_web_app",
+        defaultValue: true,
+        description: "Gates the local workbench serving route (RFC-163), opened with `grain ui`.",
+        source: "local"
+      },
+      charts: {
+        id: "sql_preview_charts",
+        defaultValue: false,
+        description: "Gates the chart representation UI and MCP chart tools (RFC-070).",
+        source: "posthog"
+      },
+      sessionReplay: {
+        id: "sql_preview_session_replay",
+        defaultValue: false,
+        description: "Gates masked PostHog session replay in VS Code webviews (RFC-069).",
+        source: "posthog"
+      },
+      executionLedger: {
+        id: "sql_preview_execution_ledger",
+        defaultValue: false,
+        description: "Gates local execution-ledger journaling and provenance capture (RFC-071).",
+        source: "posthog"
+      },
+      credentialRequiredSignal: {
+        id: "sql_preview_credential_required_signal",
+        defaultValue: true,
+        description: "Offers a one-time credential page on auth-failed queries (RFC-171).",
+        source: "local",
+        locked: true
+      },
+      crashDiagnostics: {
+        id: "sql_preview_crash_diagnostics",
+        defaultValue: true,
+        description: "Gates posthog-node exception autocapture on the daemon (RFC-092).",
+        source: "local"
+      },
+      mcpSurface: {
+        id: "sql_preview_mcp_surface",
+        defaultValue: false,
+        description: "Gates the generic MCP HTTP surface, requiring both entitlement and local consent (RFC-110).",
+        source: "posthog"
+      },
+      resultsCardRouting: {
+        id: "results-card-routing",
+        defaultValue: true,
+        description: "Gates two-view MCP result routing (RFC-167).",
+        source: "posthog"
+      }
+    };
+  }
+});
+
+// src/services/featureFlags/isFeatureEnabled.ts
+function isFeatureEnabled(key, env2 = process.env) {
+  const definition = FEATURE_FLAGS[key];
+  if (definition.locked) {
+    return definition.defaultValue;
+  }
+  const override = env2[`GRAIN_FF_${definition.id.toUpperCase()}`];
+  if (override === "1" || override === "true") {
+    return true;
+  }
+  if (override === "0" || override === "false") {
+    return false;
+  }
+  return definition.defaultValue;
+}
+var init_isFeatureEnabled = __esm({
+  "src/services/featureFlags/isFeatureEnabled.ts"() {
+    "use strict";
+    init_FeatureFlagDefinitions();
+  }
+});
+
+// src/server/policy/callPolicy.ts
+function clientPolicyFromMeta(meta3) {
+  const asked = meta3?.[CLIENT_POLICY_META_KEY];
+  if (typeof asked !== "object" || asked === null)
+    return void 0;
+  const safeMode = asked.safeMode;
+  return typeof safeMode === "boolean" ? { safeMode } : {};
+}
+function resolveCallPolicy(serviceProfile, serviceSafeMode, requested) {
+  if (requested?.safeMode === void 0) {
+    return { profile: serviceProfile, declined: [] };
+  }
+  if (requested.safeMode) {
+    const tightened = { ...serviceProfile, forceSafeMode: true };
+    return { profile: composeToolProfiles(serviceProfile, tightened), declined: [] };
+  }
+  if (isSafeModeActive(serviceProfile, serviceSafeMode)) {
+    return { profile: serviceProfile, declined: [SAFE_MODE_DECLINED_MESSAGE] };
+  }
+  return { profile: serviceProfile, declined: [] };
+}
+function alphaToolEnabled(name, chartsEnabled = isFeatureEnabled("charts"), ledgerEnabled = isFeatureEnabled("executionLedger")) {
+  if (CHART_TOOLS.includes(name))
+    return chartsEnabled;
+  if (LEDGER_TOOLS.includes(name))
+    return ledgerEnabled;
+  return true;
+}
+function admitToolCall(profile, name, featureEnabled) {
+  if (!toolNamesForProfile(profile).has(name) || !featureEnabled) {
+    throw new Error("Unknown tool");
+  }
+  return refuseIfNotPermitted(profile, name);
+}
+function refuseRestToolCall(profile, name) {
+  const tool = name;
+  if (!ALL_TOOLS.includes(tool)) {
+    return void 0;
+  }
+  if (!toolNamesForProfile(profile).has(name)) {
+    return toolRefusalResult(profile, tool);
+  }
+  return refuseIfNotPermitted(profile, name);
+}
+function withPolicyNotice(result, policy) {
+  if (policy.declined.length === 0)
+    return result;
+  const existing = result;
+  const notice = { type: "text", text: policy.declined.join(" ") };
+  return {
+    ...existing,
+    content: Array.isArray(existing.content) ? [...existing.content, notice] : [notice],
+    _meta: { ...existing._meta, [DECLINED_POLICY_META_KEY]: policy.declined }
+  };
+}
+var CLIENT_POLICY_META_KEY, DECLINED_POLICY_META_KEY, SAFE_MODE_DECLINED_MESSAGE, CHART_TOOLS, LEDGER_TOOLS;
+var init_callPolicy = __esm({
+  "src/server/policy/callPolicy.ts"() {
+    "use strict";
+    init_isFeatureEnabled();
+    init_toolProfiles();
+    CLIENT_POLICY_META_KEY = "sqlpreview/policy";
+    DECLINED_POLICY_META_KEY = "sqlpreview/policyDeclined";
+    SAFE_MODE_DECLINED_MESSAGE = "Declined this client's request to run with safe mode off: 'mcpSafeMode' is client-restrict-only, so an attaching client may only make it more restrictive than the service, never less. This call ran under safe mode; the override was declined, not lost.";
+    CHART_TOOLS = ["render_chart", "save_chart", "list_charts"];
+    LEDGER_TOOLS = ["ledger_stats", "verify_ledger"];
+  }
+});
+
 // node_modules/zod/v4/mini/parse.js
 var init_parse3 = __esm({
   "node_modules/zod/v4/mini/parse.js"() {
@@ -27956,8 +28405,8 @@ var init_protocol = __esm({
         this._taskStore = _options?.taskStore;
         this._taskMessageQueue = _options?.taskMessageQueue;
         if (this._taskStore) {
-          this.setRequestHandler(GetTaskRequestSchema, async (request3, extra) => {
-            const task = await this._taskStore.getTask(request3.params.taskId, extra.sessionId);
+          this.setRequestHandler(GetTaskRequestSchema, async (request4, extra) => {
+            const task = await this._taskStore.getTask(request4.params.taskId, extra.sessionId);
             if (!task) {
               throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
             }
@@ -27965,9 +28414,9 @@ var init_protocol = __esm({
               ...task
             };
           });
-          this.setRequestHandler(GetTaskPayloadRequestSchema, async (request3, extra) => {
+          this.setRequestHandler(GetTaskPayloadRequestSchema, async (request4, extra) => {
             const handleTaskResult = async () => {
-              const taskId = request3.params.taskId;
+              const taskId = request4.params.taskId;
               if (this._taskMessageQueue) {
                 let queuedMessage;
                 while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -28018,9 +28467,9 @@ var init_protocol = __esm({
             };
             return await handleTaskResult();
           });
-          this.setRequestHandler(ListTasksRequestSchema, async (request3, extra) => {
+          this.setRequestHandler(ListTasksRequestSchema, async (request4, extra) => {
             try {
-              const { tasks, nextCursor } = await this._taskStore.listTasks(request3.params?.cursor, extra.sessionId);
+              const { tasks, nextCursor } = await this._taskStore.listTasks(request4.params?.cursor, extra.sessionId);
               return {
                 tasks,
                 nextCursor,
@@ -28030,20 +28479,20 @@ var init_protocol = __esm({
               throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error52 instanceof Error ? error52.message : String(error52)}`);
             }
           });
-          this.setRequestHandler(CancelTaskRequestSchema, async (request3, extra) => {
+          this.setRequestHandler(CancelTaskRequestSchema, async (request4, extra) => {
             try {
-              const task = await this._taskStore.getTask(request3.params.taskId, extra.sessionId);
+              const task = await this._taskStore.getTask(request4.params.taskId, extra.sessionId);
               if (!task) {
-                throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request3.params.taskId}`);
+                throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request4.params.taskId}`);
               }
               if (isTerminal(task.status)) {
                 throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
               }
-              await this._taskStore.updateTaskStatus(request3.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-              this._clearTaskQueue(request3.params.taskId);
-              const cancelledTask = await this._taskStore.getTask(request3.params.taskId, extra.sessionId);
+              await this._taskStore.updateTaskStatus(request4.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+              this._clearTaskQueue(request4.params.taskId);
+              const cancelledTask = await this._taskStore.getTask(request4.params.taskId, extra.sessionId);
               if (!cancelledTask) {
-                throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request3.params.taskId}`);
+                throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request4.params.taskId}`);
               }
               return {
                 _meta: {},
@@ -28164,14 +28613,14 @@ var init_protocol = __esm({
         }
         Promise.resolve().then(() => handler(notification)).catch((error52) => this._onerror(new Error(`Uncaught error in notification handler: ${error52}`)));
       }
-      _onrequest(request3, extra) {
-        const handler = this._requestHandlers.get(request3.method) ?? this.fallbackRequestHandler;
+      _onrequest(request4, extra) {
+        const handler = this._requestHandlers.get(request4.method) ?? this.fallbackRequestHandler;
         const capturedTransport = this._transport;
-        const relatedTaskId = request3.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+        const relatedTaskId = request4.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
         if (handler === void 0) {
           const errorResponse = {
             jsonrpc: "2.0",
-            id: request3.id,
+            id: request4.id,
             error: {
               code: ErrorCode.MethodNotFound,
               message: "Method not found"
@@ -28189,17 +28638,17 @@ var init_protocol = __esm({
           return;
         }
         const abortController = new AbortController();
-        this._requestHandlerAbortControllers.set(request3.id, abortController);
-        const taskCreationParams = isTaskAugmentedRequestParams(request3.params) ? request3.params.task : void 0;
-        const taskStore = this._taskStore ? this.requestTaskStore(request3, capturedTransport?.sessionId) : void 0;
+        this._requestHandlerAbortControllers.set(request4.id, abortController);
+        const taskCreationParams = isTaskAugmentedRequestParams(request4.params) ? request4.params.task : void 0;
+        const taskStore = this._taskStore ? this.requestTaskStore(request4, capturedTransport?.sessionId) : void 0;
         const fullExtra = {
           signal: abortController.signal,
           sessionId: capturedTransport?.sessionId,
-          _meta: request3.params?._meta,
+          _meta: request4.params?._meta,
           sendNotification: async (notification) => {
             if (abortController.signal.aborted)
               return;
-            const notificationOptions = { relatedRequestId: request3.id };
+            const notificationOptions = { relatedRequestId: request4.id };
             if (relatedTaskId) {
               notificationOptions.relatedTask = { taskId: relatedTaskId };
             }
@@ -28209,7 +28658,7 @@ var init_protocol = __esm({
             if (abortController.signal.aborted) {
               throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
             }
-            const requestOptions = { ...options, relatedRequestId: request3.id };
+            const requestOptions = { ...options, relatedRequestId: request4.id };
             if (relatedTaskId && !requestOptions.relatedTask) {
               requestOptions.relatedTask = { taskId: relatedTaskId };
             }
@@ -28220,7 +28669,7 @@ var init_protocol = __esm({
             return await this.request(r, resultSchema, requestOptions);
           },
           authInfo: extra?.authInfo,
-          requestId: request3.id,
+          requestId: request4.id,
           requestInfo: extra?.requestInfo,
           taskId: relatedTaskId,
           taskStore,
@@ -28230,16 +28679,16 @@ var init_protocol = __esm({
         };
         Promise.resolve().then(() => {
           if (taskCreationParams) {
-            this.assertTaskHandlerCapability(request3.method);
+            this.assertTaskHandlerCapability(request4.method);
           }
-        }).then(() => handler(request3, fullExtra)).then(async (result) => {
+        }).then(() => handler(request4, fullExtra)).then(async (result) => {
           if (abortController.signal.aborted) {
             return;
           }
           const response = {
             result,
             jsonrpc: "2.0",
-            id: request3.id
+            id: request4.id
           };
           if (relatedTaskId && this._taskMessageQueue) {
             await this._enqueueTaskMessage(relatedTaskId, {
@@ -28256,7 +28705,7 @@ var init_protocol = __esm({
           }
           const errorResponse = {
             jsonrpc: "2.0",
-            id: request3.id,
+            id: request4.id,
             error: {
               code: Number.isSafeInteger(error52["code"]) ? error52["code"] : ErrorCode.InternalError,
               message: error52.message ?? "Internal error",
@@ -28273,8 +28722,8 @@ var init_protocol = __esm({
             await capturedTransport?.send(errorResponse);
           }
         }).catch((error52) => this._onerror(new Error(`Failed to send response: ${error52}`))).finally(() => {
-          if (this._requestHandlerAbortControllers.get(request3.id) === abortController) {
-            this._requestHandlerAbortControllers.delete(request3.id);
+          if (this._requestHandlerAbortControllers.get(request4.id) === abortController) {
+            this._requestHandlerAbortControllers.delete(request4.id);
           }
         });
       }
@@ -28378,11 +28827,11 @@ var init_protocol = __esm({
        *
        * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
        */
-      async *requestStream(request3, resultSchema, options) {
+      async *requestStream(request4, resultSchema, options) {
         const { task } = options ?? {};
         if (!task) {
           try {
-            const result = await this.request(request3, resultSchema, options);
+            const result = await this.request(request4, resultSchema, options);
             yield { type: "result", result };
           } catch (error52) {
             yield {
@@ -28394,7 +28843,7 @@ var init_protocol = __esm({
         }
         let taskId;
         try {
-          const createResult = await this.request(request3, CreateTaskResultSchema, options);
+          const createResult = await this.request(request4, CreateTaskResultSchema, options);
           if (createResult.task) {
             taskId = createResult.task.taskId;
             yield { type: "taskCreated", task: createResult.task };
@@ -28442,7 +28891,7 @@ var init_protocol = __esm({
        *
        * Do not use this method to emit notifications! Use notification() instead.
        */
-      request(request3, resultSchema, options) {
+      request(request4, resultSchema, options) {
         const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
         return new Promise((resolve15, reject) => {
           const earlyReject = (error52) => {
@@ -28454,9 +28903,9 @@ var init_protocol = __esm({
           }
           if (this._options?.enforceStrictCapabilities === true) {
             try {
-              this.assertCapabilityForMethod(request3.method);
+              this.assertCapabilityForMethod(request4.method);
               if (task) {
-                this.assertTaskCapability(request3.method);
+                this.assertTaskCapability(request4.method);
               }
             } catch (e2) {
               earlyReject(e2);
@@ -28466,16 +28915,16 @@ var init_protocol = __esm({
           options?.signal?.throwIfAborted();
           const messageId = this._requestMessageId++;
           const jsonrpcRequest = {
-            ...request3,
+            ...request4,
             jsonrpc: "2.0",
             id: messageId
           };
           if (options?.onprogress) {
             this._progressHandlers.set(messageId, options.onprogress);
             jsonrpcRequest.params = {
-              ...request3.params,
+              ...request4.params,
               _meta: {
-                ...request3.params?._meta || {},
+                ...request4.params?._meta || {},
                 progressToken: messageId
               }
             };
@@ -28679,8 +29128,8 @@ var init_protocol = __esm({
       setRequestHandler(requestSchema, handler) {
         const method = getMethodLiteral(requestSchema);
         this.assertRequestHandlerCapability(method);
-        this._requestHandlers.set(method, (request3, extra) => {
-          const parsed = parseWithCompat(requestSchema, request3);
+        this._requestHandlers.set(method, (request4, extra) => {
+          const parsed = parseWithCompat(requestSchema, request4);
           return Promise.resolve(handler(parsed, extra));
         });
       }
@@ -28795,19 +29244,19 @@ var init_protocol = __esm({
           }, { once: true });
         });
       }
-      requestTaskStore(request3, sessionId) {
+      requestTaskStore(request4, sessionId) {
         const taskStore = this._taskStore;
         if (!taskStore) {
           throw new Error("No task store configured");
         }
         return {
           createTask: async (taskParams) => {
-            if (!request3) {
+            if (!request4) {
               throw new Error("No request provided");
             }
-            return await taskStore.createTask(taskParams, request3.id, {
-              method: request3.method,
-              params: request3.params
+            return await taskStore.createTask(taskParams, request4.id, {
+              method: request4.method,
+              params: request4.params
             }, sessionId);
           },
           getTask: async (taskId) => {
@@ -32384,7 +32833,7 @@ var require_schemes = __commonJS({
       urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
       return urnComponent;
     }
-    var http10 = (
+    var http11 = (
       /** @type {SchemeHandler} */
       {
         scheme: "http",
@@ -32397,7 +32846,7 @@ var require_schemes = __commonJS({
       /** @type {SchemeHandler} */
       {
         scheme: "https",
-        domainHost: http10.domainHost,
+        domainHost: http11.domainHost,
         parse: httpParse,
         serialize: httpSerialize
       }
@@ -32441,7 +32890,7 @@ var require_schemes = __commonJS({
     var SCHEMES = (
       /** @type {Record<SchemeName, SchemeHandler>} */
       {
-        http: http10,
+        http: http11,
         https: https6,
         ws,
         wss,
@@ -36034,93 +36483,86 @@ var init_connectCommand = __esm({
   }
 });
 
-// src/server/cli/stopCommand.ts
-var stopCommand_exports = {};
-__export(stopCommand_exports, {
-  stopCommand: () => stopCommand
+// src/server/cli/restartCommand.ts
+var restartCommand_exports = {};
+__export(restartCommand_exports, {
+  restartCommand: () => restartCommand
 });
-function defaultIsProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error52) {
-    return error52.code !== "ESRCH";
+function controlRequester(configDir) {
+  const endpoint = readDaemonEndpointStatus(configDir);
+  const token = readControlToken(configDir);
+  if (endpoint.type !== "valid" || !token) {
+    return void 0;
   }
-}
-async function stopCommand(configDir = resolveGrainHome(), clock = Date, processKiller = process.kill, adapter2 = createSupervisorAdapter(
-  process.platform,
-  createCommandRunner(),
-  process.getuid?.() ?? 0
-), isProcessAlive = defaultIsProcessAlive, platform2 = process.platform, requestStop = requestDaemonControlStop) {
-  if (await adapter2.isRegistered(DAEMON_SERVICE_IDENTITY)) {
-    console.error(
-      "Grain is installed as a background service. Run `grain uninstall` to remove it."
+  const host = endpoint.record.host === "0.0.0.0" ? "127.0.0.1" : endpoint.record.host;
+  return (method, path60, body) => new Promise((resolve15, reject) => {
+    const payload = body === void 0 ? void 0 : JSON.stringify(body);
+    const req = http7.request(
+      {
+        host,
+        port: endpoint.record.port,
+        path: path60,
+        method,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          ...payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {}
+        }
+      },
+      (res) => {
+        let text = "";
+        res.on("data", (chunk) => {
+          text += chunk;
+        });
+        res.on("end", () => {
+          try {
+            resolve15({ status: res.statusCode ?? 0, body: JSON.parse(text) });
+          } catch {
+            resolve15({ status: res.statusCode ?? 0, body: text });
+          }
+        });
+      }
     );
-    return 1;
-  }
-  const status = await readGrainServiceStatus(configDir);
-  if (!isRunningGrainService(status)) {
-    console.log("Grain is not running.");
-    return 0;
-  }
-  const pid = readDaemonEndpoint(configDir)?.pid;
-  if (pid === void 0) {
-    console.error("Could not determine Grain daemon PID.");
-    return 1;
-  }
-  const token = platform2 === "win32" ? readDaemonAuthToken(configDir) : void 0;
-  const accepted = token ? await requestStop(daemonControlEndpoint(configDir), token) : false;
+    req.on("error", reject);
+    req.setTimeout(5e3, () => req.destroy(new Error("timeout")));
+    req.end(payload);
+  });
+}
+async function stagedVersion(request4) {
   try {
-    if (!accepted) {
-      processKiller(pid, "SIGTERM");
-    }
-  } catch (error52) {
-    const code = error52.code;
-    if (code !== "ESRCH") {
-      console.error(`Could not signal Grain (pid ${pid}): ${code ?? String(error52)}`);
-      return 1;
-    }
-  }
-  const startMs = clock.now();
-  const timeoutMs = accepted ? drainStopBudgetMs(configDir) : 1e4;
-  while (clock.now() - startMs < timeoutMs) {
-    const currentStatus = await readGrainServiceStatus(configDir);
-    if (!isRunningGrainService(currentStatus) && !isProcessAlive(pid)) {
-      console.log("Grain stopped.");
-      return 0;
-    }
-    await new Promise((resolve15) => setTimeout(resolve15, 250));
+    const { status, body } = await request4("GET", "/api/v1/update");
+    const staged = body?.stagedVersion;
+    return status === 200 && typeof staged === "string" ? staged : void 0;
+  } catch {
+    return void 0;
   }
-  console.error(`Grain did not stop within ${timeoutMs / 1e3} seconds.`);
-  return 1;
 }
-var init_stopCommand = __esm({
-  "src/server/cli/stopCommand.ts"() {
-    "use strict";
-    init_grainHome();
-    init_daemonEndpointFile();
-    init_statusCommand();
-    init_supervisorAdapter();
-    init_daemonRecordInstance();
-    init_ipcEndpoint();
-    init_DaemonAuthToken();
-    init_requestDaemonControlStop();
-    init_drainStopBudget();
+async function restartCommand(configDir = resolveGrainHome(), request4 = controlRequester(configDir), write = (text) => process.stdout.write(text)) {
+  const staged = request4 ? await stagedVersion(request4) : void 0;
+  if (request4 && staged) {
+    try {
+      const { body } = await request4("POST", "/api/v1/update/restart", { discardResults: true });
+      if (body?.result === "activated") {
+        write(`Restarting Grain into ${staged}.
+`);
+        return await startThroughService({ configHome: configDir, restart: false });
+      }
+      write(`Grain could not switch to ${staged} yet; restarting the current version.
+`);
+    } catch {
+      write(`Grain could not switch to ${staged} yet; restarting the current version.
+`);
+    }
   }
-});
-
-// src/server/cli/restartCommand.ts
-var restartCommand_exports = {};
-__export(restartCommand_exports, {
-  restartCommand: () => restartCommand
-});
-async function restartCommand(configDir = resolveGrainHome()) {
   return await startThroughService({ configHome: configDir, restart: true });
 }
+var http7;
 var init_restartCommand = __esm({
   "src/server/cli/restartCommand.ts"() {
     "use strict";
+    http7 = __toESM(require("http"));
     init_grainHome();
+    init_ControlToken();
+    init_daemonEndpointFile();
     init_serviceControl();
   }
 });
@@ -36132,7 +36574,7 @@ __export(updateCommand_exports, {
 });
 function defaultRequester(host, port, token) {
   return new Promise((resolve15, reject) => {
-    const req = http7.request(
+    const req = http8.request(
       {
         host: host === "0.0.0.0" ? "127.0.0.1" : host,
         port,
@@ -36191,11 +36633,11 @@ async function updateCommand(configDir = resolveGrainHome(), requester = default
     return 1;
   }
 }
-var http7;
+var http8;
 var init_updateCommand = __esm({
   "src/server/cli/updateCommand.ts"() {
     "use strict";
-    http7 = __toESM(require("http"));
+    http8 = __toESM(require("http"));
     init_grainHome();
     init_ControlToken();
     init_daemonEndpointFile();
@@ -58640,7 +59082,7 @@ var require_view = __commonJS({
     var debug = require_src()("express:view");
     var path60 = require("node:path");
     var fs58 = require("node:fs");
-    var dirname18 = path60.dirname;
+    var dirname19 = path60.dirname;
     var basename5 = path60.basename;
     var extname = path60.extname;
     var join49 = path60.join;
@@ -58679,7 +59121,7 @@ var require_view = __commonJS({
       for (var i = 0; i < roots2.length && !path61; i++) {
         var root = roots2[i];
         var loc = resolve15(root, name);
-        var dir3 = dirname18(loc);
+        var dir3 = dirname19(loc);
         var file5 = basename5(loc);
         path61 = this.resolve(dir3, file5);
       }
@@ -70367,7 +70809,7 @@ var require_application = __commonJS({
     var finalhandler = require_finalhandler();
     var debug = require_src()("express:application");
     var View2 = require_view();
-    var http10 = require("node:http");
+    var http11 = require("node:http");
     var methods = require_utils4().methods;
     var compileETag = require_utils4().compileETag;
     var compileQueryParser = require_utils4().compileQueryParser;
@@ -70600,7 +71042,7 @@ var require_application = __commonJS({
       tryRender(view, renderOptions, done);
     };
     app.listen = function listen() {
-      var server = http10.createServer(this);
+      var server = http11.createServer(this);
       var args = slice2.call(arguments);
       if (typeof args[args.length - 1] === "function") {
         var done = args[args.length - 1] = once(args[args.length - 1]);
@@ -71096,11 +71538,11 @@ var require_negotiator = __commonJS({
     var preferredMediaTypes = require_mediaType();
     module2.exports = Negotiator;
     module2.exports.Negotiator = Negotiator;
-    function Negotiator(request3) {
+    function Negotiator(request4) {
       if (!(this instanceof Negotiator)) {
-        return new Negotiator(request3);
+        return new Negotiator(request4);
       }
-      this.request = request3;
+      this.request = request4;
     }
     Negotiator.prototype.charset = function charset(available) {
       var set4 = this.charsets(available);
@@ -80889,12 +81331,12 @@ var require_request = __commonJS({
     var accepts = require_accepts();
     var isIP = require("node:net").isIP;
     var typeis = require_type_is();
-    var http10 = require("node:http");
+    var http11 = require("node:http");
     var fresh = require_fresh();
     var parseRange = require_range_parser();
     var parse7 = require_parseurl();
     var proxyaddr = require_proxy_addr();
-    var req = Object.create(http10.IncomingMessage.prototype);
+    var req = Object.create(http11.IncomingMessage.prototype);
     module2.exports = req;
     req.get = req.header = function header(name) {
       if (!name) {
@@ -91471,7 +91913,7 @@ var require_response = __commonJS({
     var deprecate = require_depd()("express");
     var encodeUrl = require_encodeurl();
     var escapeHtml2 = require_escape_html();
-    var http10 = require("node:http");
+    var http11 = require("node:http");
     var onFinished = require_on_finished();
     var mime = require_mime_types2();
     var path60 = require("node:path");
@@ -91487,7 +91929,7 @@ var require_response = __commonJS({
     var resolve15 = path60.resolve;
     var vary = require_vary();
     var { Buffer: Buffer2 } = require("node:buffer");
-    var res = Object.create(http10.ServerResponse.prototype);
+    var res = Object.create(http11.ServerResponse.prototype);
     module2.exports = res;
     res.status = function status(code) {
       if (!Number.isInteger(code)) {
@@ -92295,93 +92737,6 @@ var init_DriverManager = __esm({
   }
 });
 
-// src/services/featureFlags/FeatureFlagDefinitions.ts
-var FEATURE_FLAGS;
-var init_FeatureFlagDefinitions = __esm({
-  "src/services/featureFlags/FeatureFlagDefinitions.ts"() {
-    "use strict";
-    FEATURE_FLAGS = {
-      managedDuckDbRuntime: {
-        id: "sql_preview_managed_duckdb_runtime",
-        defaultValue: true,
-        description: "Gates background auto-provisioning of the managed DuckDB runtime (RFC-075).",
-        source: "local"
-      },
-      standaloneWebApp: {
-        id: "sql_preview_standalone_web_app",
-        defaultValue: true,
-        description: "Gates the local workbench serving route (RFC-163), opened with `grain ui`.",
-        source: "local"
-      },
-      charts: {
-        id: "sql_preview_charts",
-        defaultValue: false,
-        description: "Gates the chart representation UI and MCP chart tools (RFC-070).",
-        source: "posthog"
-      },
-      sessionReplay: {
-        id: "sql_preview_session_replay",
-        defaultValue: false,
-        description: "Gates masked PostHog session replay in VS Code webviews (RFC-069).",
-        source: "posthog"
-      },
-      executionLedger: {
-        id: "sql_preview_execution_ledger",
-        defaultValue: false,
-        description: "Gates local execution-ledger journaling and provenance capture (RFC-071).",
-        source: "posthog"
-      },
-      credentialRequiredSignal: {
-        id: "sql_preview_credential_required_signal",
-        defaultValue: true,
-        description: "Offers a one-time credential page on auth-failed queries (RFC-171).",
-        source: "local",
-        locked: true
-      },
-      crashDiagnostics: {
-        id: "sql_preview_crash_diagnostics",
-        defaultValue: true,
-        description: "Gates posthog-node exception autocapture on the daemon (RFC-092).",
-        source: "local"
-      },
-      mcpSurface: {
-        id: "sql_preview_mcp_surface",
-        defaultValue: false,
-        description: "Gates the generic MCP HTTP surface, requiring both entitlement and local consent (RFC-110).",
-        source: "posthog"
-      },
-      resultsCardRouting: {
-        id: "results-card-routing",
-        defaultValue: false,
-        description: "Gates two-view MCP result routing (RFC-167).",
-        source: "posthog"
-      }
-    };
-  }
-});
-
-// src/services/featureFlags/isFeatureEnabled.ts
-function isFeatureEnabled(key, env2 = process.env) {
-  const definition = FEATURE_FLAGS[key];
-  if (definition.locked) {
-    return definition.defaultValue;
-  }
-  const override = env2[`GRAIN_FF_${definition.id.toUpperCase()}`];
-  if (override === "1" || override === "true") {
-    return true;
-  }
-  if (override === "0" || override === "false") {
-    return false;
-  }
-  return definition.defaultValue;
-}
-var init_isFeatureEnabled = __esm({
-  "src/services/featureFlags/isFeatureEnabled.ts"() {
-    "use strict";
-    init_FeatureFlagDefinitions();
-  }
-});
-
 // src/server/publishBoundEndpoint.ts
 function publishBoundEndpoint(options) {
   const host = UNREACHABLE_BIND_HOSTS.includes(options.host) ? "127.0.0.1" : options.host;
@@ -92416,7 +92771,7 @@ function readExistingDaemonStatus(host, port, authToken) {
       settled = true;
       resolve15(status);
     };
-    const req = http8.get(
+    const req = http9.get(
       {
         host,
         port,
@@ -92492,11 +92847,11 @@ async function checkForNewerDaemon(options) {
     checkingForSuccessor.delete(options.owner);
   }
 }
-var http8, checkingForSuccessor;
+var http9, checkingForSuccessor;
 var init_daemonSuccession = __esm({
   "src/server/lifecycle/daemonSuccession.ts"() {
     "use strict";
-    http8 = __toESM(require("http"));
+    http9 = __toESM(require("http"));
     init_daemonEndpointFile();
     init_daemonRecordInstance();
     init_ConsoleLogger();
@@ -92921,6 +93276,10 @@ var init_src = __esm({
           const setup = await created.connect();
           try {
             const { directories, files } = allowListExcluding(protectedDirectory);
+            const demoDirectory = path36.join(realpathOrSelf(protectedDirectory), "demo", "data");
+            if (realpathOrSelf(demoDirectory) === demoDirectory) {
+              directories.push(demoDirectory + path36.sep);
+            }
             await setup.run(`SET allowed_directories = ${sqlStringList(directories)}`);
             await setup.run(`SET allowed_paths = ${sqlStringList(files)}`);
             await setup.run("SET enable_external_access = false");
@@ -94046,8 +94405,8 @@ var init_AxiosError = __esm({
     init_AxiosHeaders();
     REDACTED = "[REDACTED ****]";
     AxiosError = class extends Error {
-      static from(error52, code, config2, request3, response, customProps) {
-        const axiosError = new AxiosError(error52.message, code || error52.code, config2, request3, response);
+      static from(error52, code, config2, request4, response, customProps) {
+        const axiosError = new AxiosError(error52.message, code || error52.code, config2, request4, response);
         axiosError.cause = error52;
         axiosError.name = error52.name;
         if (error52.status != null && axiosError.status == null) {
@@ -94067,7 +94426,7 @@ var init_AxiosError = __esm({
        *
        * @returns {Error} The created error.
        */
-      constructor(message, code, config2, request3, response) {
+      constructor(message, code, config2, request4, response) {
         super(message);
         Object.defineProperty(this, "message", {
           // Null-proto descriptor so a polluted Object.prototype.get cannot turn
@@ -94082,7 +94441,7 @@ var init_AxiosError = __esm({
         this.isAxiosError = true;
         code && (this.code = code);
         config2 && (this.config = config2);
-        request3 && (this.request = request3);
+        request4 && (this.request = request4);
         if (response) {
           this.response = response;
           this.status = response.status;
@@ -103286,7 +103645,7 @@ var require_form_data = __commonJS({
     var CombinedStream = require_combined_stream();
     var util3 = require("util");
     var path60 = require("path");
-    var http10 = require("http");
+    var http11 = require("http");
     var https6 = require("https");
     var parseUrl2 = require("url").parse;
     var fs58 = require("fs");
@@ -103537,7 +103896,7 @@ var require_form_data = __commonJS({
       });
     };
     FormData3.prototype.submit = function(params, cb) {
-      var request3;
+      var request4;
       var options;
       var defaults3 = { method: "post" };
       if (typeof params === "string") {
@@ -103556,9 +103915,9 @@ var require_form_data = __commonJS({
       }
       options.headers = this.getHeaders(params.headers);
       if (options.protocol === "https:") {
-        request3 = https6.request(options);
+        request4 = https6.request(options);
       } else {
-        request3 = http10.request(options);
+        request4 = http11.request(options);
       }
       this.getLength(function(err, length) {
         if (err && err !== "Unknown stream") {
@@ -103566,22 +103925,22 @@ var require_form_data = __commonJS({
           return;
         }
         if (length) {
-          request3.setHeader("Content-Length", length);
+          request4.setHeader("Content-Length", length);
         }
-        this.pipe(request3);
+        this.pipe(request4);
         if (cb) {
           var onResponse;
           var callback = function(error52, responce) {
-            request3.removeListener("error", callback);
-            request3.removeListener("response", onResponse);
+            request4.removeListener("error", callback);
+            request4.removeListener("response", onResponse);
             return cb.call(this, error52, responce);
           };
           onResponse = callback.bind(this, null);
-          request3.on("error", callback);
-          request3.on("response", onResponse);
+          request4.on("error", callback);
+          request4.on("response", onResponse);
         }
       }.bind(this));
-      return request3;
+      return request4;
     };
     FormData3.prototype._error = function(err) {
       if (!this.error) {
@@ -104249,8 +104608,8 @@ var init_CanceledError = __esm({
        *
        * @returns {CanceledError} The created error.
        */
-      constructor(message, config2, request3) {
-        super(message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config2, request3);
+      constructor(message, config2, request4) {
+        super(message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config2, request4);
         this.name = "CanceledError";
         this.__CANCEL__ = true;
       }
@@ -104418,7 +104777,7 @@ var require_follow_redirects = __commonJS({
   "node_modules/follow-redirects/index.js"(exports, module2) {
     var url3 = require("url");
     var URL3 = url3.URL;
-    var http10 = require("http");
+    var http11 = require("http");
     var https6 = require("https");
     var Writable = require("stream").Writable;
     var assert3 = require("assert");
@@ -104673,10 +105032,10 @@ var require_follow_redirects = __commonJS({
         var scheme = protocol.slice(0, -1);
         this._options.agent = this._options.agents[scheme];
       }
-      var request3 = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
-      request3._redirectable = this;
+      var request4 = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
+      request4._redirectable = this;
       for (var event of events) {
-        request3.on(event, eventHandlers[event]);
+        request4.on(event, eventHandlers[event]);
       }
       this._currentUrl = /^\//.test(this._options.path) ? url3.format(this._options) : (
         // When making a request to a proxy, […]
@@ -104688,16 +105047,16 @@ var require_follow_redirects = __commonJS({
         var self2 = this;
         var buffers = this._requestBodyBuffers;
         (function writeNext(error52) {
-          if (request3 === self2._currentRequest) {
+          if (request4 === self2._currentRequest) {
             if (error52) {
               self2.emit("error", error52);
             } else if (i < buffers.length) {
               var buffer = buffers[i++];
-              if (!request3.finished) {
-                request3.write(buffer.data, buffer.encoding, writeNext);
+              if (!request4.finished) {
+                request4.write(buffer.data, buffer.encoding, writeNext);
               }
             } else if (self2._ended) {
-              request3.end();
+              request4.end();
             }
           }
         })();
@@ -104779,7 +105138,7 @@ var require_follow_redirects = __commonJS({
         var protocol = scheme + ":";
         var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
         var wrappedProtocol = exports2[scheme] = Object.create(nativeProtocol);
-        function request3(input, options, callback) {
+        function request4(input, options, callback) {
           if (isURL(input)) {
             input = spreadUrlObject(input);
           } else if (isString4(input)) {
@@ -104811,7 +105170,7 @@ var require_follow_redirects = __commonJS({
           return wrappedRequest;
         }
         Object.defineProperties(wrappedProtocol, {
-          request: { value: request3, configurable: true, enumerable: true, writable: true },
+          request: { value: request4, configurable: true, enumerable: true, writable: true },
           get: { value: get6, configurable: true, enumerable: true, writable: true }
         });
       });
@@ -104889,12 +105248,12 @@ var require_follow_redirects = __commonJS({
       });
       return CustomError;
     }
-    function destroyRequest(request3, error52) {
+    function destroyRequest(request4, error52) {
       for (var event of events) {
-        request3.removeListener(event, eventHandlers[event]);
+        request4.removeListener(event, eventHandlers[event]);
       }
-      request3.on("error", noop4);
-      request3.destroy(error52);
+      request4.on("error", noop4);
+      request4.destroy(error52);
     }
     function isSubdomain(subdomain, domain2) {
       assert3(isString4(subdomain) && isString4(domain2));
@@ -104919,7 +105278,7 @@ var require_follow_redirects = __commonJS({
     function escapeRegex2(regex) {
       return regex.replace(/[\]\\/()*+?.$]/g, "\\$&");
     }
-    module2.exports = wrap({ http: http10, https: https6 });
+    module2.exports = wrap({ http: http11, https: https6 });
     module2.exports.wrap = wrap;
   }
 });
@@ -106791,24 +107150,24 @@ var init_xhr = __esm({
           _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
           _config.signal && _config.signal.removeEventListener("abort", onCanceled);
         }
-        let request3 = new XMLHttpRequest();
-        request3.open(_config.method.toUpperCase(), _config.url, true);
-        request3.timeout = _config.timeout;
+        let request4 = new XMLHttpRequest();
+        request4.open(_config.method.toUpperCase(), _config.url, true);
+        request4.timeout = _config.timeout;
         function onloadend() {
-          if (!request3) {
+          if (!request4) {
             return;
           }
           const responseHeaders = AxiosHeaders_default.from(
-            "getAllResponseHeaders" in request3 && request3.getAllResponseHeaders()
+            "getAllResponseHeaders" in request4 && request4.getAllResponseHeaders()
           );
-          const responseData = !responseType || responseType === "text" || responseType === "json" ? request3.responseText : request3.response;
+          const responseData = !responseType || responseType === "text" || responseType === "json" ? request4.responseText : request4.response;
           const response = {
             data: responseData,
-            status: request3.status,
-            statusText: request3.statusText,
+            status: request4.status,
+            statusText: request4.statusText,
             headers: responseHeaders,
             config: config2,
-            request: request3
+            request: request4
           };
           settle(
             function _resolve(value) {
@@ -106821,38 +107180,38 @@ var init_xhr = __esm({
             },
             response
           );
-          request3 = null;
+          request4 = null;
         }
-        if ("onloadend" in request3) {
-          request3.onloadend = onloadend;
+        if ("onloadend" in request4) {
+          request4.onloadend = onloadend;
         } else {
-          request3.onreadystatechange = function handleLoad() {
-            if (!request3 || request3.readyState !== 4) {
+          request4.onreadystatechange = function handleLoad() {
+            if (!request4 || request4.readyState !== 4) {
               return;
             }
-            if (request3.status === 0 && !(request3.responseURL && request3.responseURL.startsWith("file:"))) {
+            if (request4.status === 0 && !(request4.responseURL && request4.responseURL.startsWith("file:"))) {
               return;
             }
             setTimeout(onloadend);
           };
         }
-        request3.onabort = function handleAbort() {
-          if (!request3) {
+        request4.onabort = function handleAbort() {
+          if (!request4) {
             return;
           }
-          reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config2, request3));
+          reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config2, request4));
           done();
-          request3 = null;
+          request4 = null;
         };
-        request3.onerror = function handleError(event) {
+        request4.onerror = function handleError(event) {
           const msg = event && event.message ? event.message : "Network Error";
-          const err = new AxiosError_default(msg, AxiosError_default.ERR_NETWORK, config2, request3);
+          const err = new AxiosError_default(msg, AxiosError_default.ERR_NETWORK, config2, request4);
           err.event = event || null;
           reject(err);
           done();
-          request3 = null;
+          request4 = null;
         };
-        request3.ontimeout = function handleTimeout() {
+        request4.ontimeout = function handleTimeout() {
           let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
           const transitional2 = _config.transitional || transitional_default;
           if (_config.timeoutErrorMessage) {
@@ -106863,42 +107222,42 @@ var init_xhr = __esm({
               timeoutErrorMessage,
               transitional2.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED,
               config2,
-              request3
+              request4
             )
           );
           done();
-          request3 = null;
+          request4 = null;
         };
         requestData === void 0 && requestHeaders.setContentType(null);
-        if ("setRequestHeader" in request3) {
+        if ("setRequestHeader" in request4) {
           utils_default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
-            request3.setRequestHeader(key, val);
+            request4.setRequestHeader(key, val);
           });
         }
         if (!utils_default.isUndefined(_config.withCredentials)) {
-          request3.withCredentials = !!_config.withCredentials;
+          request4.withCredentials = !!_config.withCredentials;
         }
         if (responseType && responseType !== "json") {
-          request3.responseType = _config.responseType;
+          request4.responseType = _config.responseType;
         }
         if (onDownloadProgress) {
           [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
-          request3.addEventListener("progress", downloadThrottled);
+          request4.addEventListener("progress", downloadThrottled);
         }
-        if (onUploadProgress && request3.upload) {
+        if (onUploadProgress && request4.upload) {
           [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
-          request3.upload.addEventListener("progress", uploadThrottled);
-          request3.upload.addEventListener("loadend", flushUpload);
+          request4.upload.addEventListener("progress", uploadThrottled);
+          request4.upload.addEventListener("loadend", flushUpload);
         }
         if (_config.cancelToken || _config.signal) {
           onCanceled = (cancel) => {
-            if (!request3) {
+            if (!request4) {
               return;
             }
-            reject(!cancel || cancel.type ? new CanceledError_default(null, config2, request3) : cancel);
-            request3.abort();
+            reject(!cancel || cancel.type ? new CanceledError_default(null, config2, request4) : cancel);
+            request4.abort();
             done();
-            request3 = null;
+            request4 = null;
           };
           _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
           if (_config.signal) {
@@ -106916,7 +107275,7 @@ var init_xhr = __esm({
           );
           return;
         }
-        request3.send(requestData || null);
+        request4.send(requestData || null);
       });
     };
   }
@@ -107101,7 +107460,7 @@ var init_fetch = __esm({
       const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder2()) : async (str) => new Uint8Array(await new Request3(str).arrayBuffer()));
       const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
         let duplexAccessed = false;
-        const request3 = new Request3(platform_default.origin, {
+        const request4 = new Request3(platform_default.origin, {
           body: new ReadableStream2(),
           method: "POST",
           get duplex() {
@@ -107109,9 +107468,9 @@ var init_fetch = __esm({
             return "half";
           }
         });
-        const hasContentType = request3.headers.has("Content-Type");
-        if (request3.body != null) {
-          request3.body.cancel();
+        const hasContentType = request4.headers.has("Content-Type");
+        if (request4.body != null) {
+          request4.body.cancel();
         }
         return duplexAccessed && !hasContentType;
       });
@@ -107187,7 +107546,7 @@ var init_fetch = __esm({
           [signal, cancelToken && cancelToken.toAbortSignal()],
           timeout
         );
-        let request3 = null;
+        let request4 = null;
         const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
           composedSignal.unsubscribe();
         });
@@ -107200,7 +107559,7 @@ var init_fetch = __esm({
                 "maxContentLength size of " + maxContentLength + " exceeded",
                 AxiosError_default.ERR_BAD_RESPONSE,
                 config2,
-                request3
+                request4
               );
             }
           }
@@ -107211,7 +107570,7 @@ var init_fetch = __esm({
                 "Request body larger than maxBodyLength limit",
                 AxiosError_default.ERR_BAD_REQUEST,
                 config2,
-                request3
+                request4
               );
             }
           }
@@ -107253,8 +107612,8 @@ var init_fetch = __esm({
             duplex: "half",
             credentials: isCredentialsSupported ? withCredentials : void 0
           };
-          request3 = isRequestSupported && new Request3(url3, resolvedOptions);
-          let response = await (isRequestSupported ? _fetch(request3, fetchOptions) : _fetch(url3, resolvedOptions));
+          request4 = isRequestSupported && new Request3(url3, resolvedOptions);
+          let response = await (isRequestSupported ? _fetch(request4, fetchOptions) : _fetch(url3, resolvedOptions));
           if (hasMaxContentLength) {
             const declaredLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
             if (declaredLength != null && declaredLength > maxContentLength) {
@@ -107262,7 +107621,7 @@ var init_fetch = __esm({
                 "maxContentLength size of " + maxContentLength + " exceeded",
                 AxiosError_default.ERR_BAD_RESPONSE,
                 config2,
-                request3
+                request4
               );
             }
           }
@@ -107286,7 +107645,7 @@ var init_fetch = __esm({
                     "maxContentLength size of " + maxContentLength + " exceeded",
                     AxiosError_default.ERR_BAD_RESPONSE,
                     config2,
-                    request3
+                    request4
                   );
                 }
               }
@@ -107321,7 +107680,7 @@ var init_fetch = __esm({
                 "maxContentLength size of " + maxContentLength + " exceeded",
                 AxiosError_default.ERR_BAD_RESPONSE,
                 config2,
-                request3
+                request4
               );
             }
           }
@@ -107333,7 +107692,7 @@ var init_fetch = __esm({
               status: response.status,
               statusText: response.statusText,
               config: config2,
-              request: request3
+              request: request4
             });
           });
         } catch (err) {
@@ -107341,7 +107700,7 @@ var init_fetch = __esm({
           if (composedSignal && composedSignal.aborted && composedSignal.reason instanceof AxiosError_default) {
             const canceledError = composedSignal.reason;
             canceledError.config = config2;
-            request3 && (canceledError.request = request3);
+            request4 && (canceledError.request = request4);
             err !== canceledError && (canceledError.cause = err);
             throw canceledError;
           }
@@ -107351,7 +107710,7 @@ var init_fetch = __esm({
                 "Network Error",
                 AxiosError_default.ERR_NETWORK,
                 config2,
-                request3,
+                request4,
                 err && err.response
               ),
               {
@@ -107359,7 +107718,7 @@ var init_fetch = __esm({
               }
             );
           }
-          throw AxiosError_default.from(err, err && err.code, config2, request3, err && err.response);
+          throw AxiosError_default.from(err, err && err.code, config2, request4, err && err.response);
         }
       };
     };
@@ -107846,11 +108205,11 @@ var init_CancelToken = __esm({
           };
           return promise2;
         };
-        executor(function cancel(message, config2, request3) {
+        executor(function cancel(message, config2, request4) {
           if (token.reason) {
             return;
           }
-          token.reason = new CanceledError_default(message, config2, request3);
+          token.reason = new CanceledError_default(message, config2, request4);
           resolvePromise(token.reason);
         });
       }
@@ -111583,11 +111942,11 @@ var init_src7 = __esm({
           pool: { max: 1, min: 0, idleTimeoutMillis: 2e3 }
         });
         try {
-          const request3 = pool.request();
+          const request4 = pool.request();
           for (const [key, value] of Object.entries(params)) {
-            request3.input(key, value);
+            request4.input(key, value);
           }
-          const result = await request3.query(sql);
+          const result = await request4.query(sql);
           const recordset = result.recordset ?? [];
           if (recordset.length === 0) {
             return [];
@@ -112438,14 +112797,14 @@ var init_ElasticsearchConnector = __esm({
         const validationError = this.validateConfig(config2);
         if (validationError)
           throw new import_connector_api9.ConnectionError(validationError);
-        const request3 = this.requestConfig(config2, authHeader, abortSignal);
+        const request4 = this.requestConfig(config2, authHeader, abortSignal);
         let cursor;
         let cursorToClose;
         try {
           let response = await this.postSql(
             this.baseUrl(config2),
             { query, fetch_size: 1e3, field_multi_value_leniency: true },
-            request3,
+            request4,
             query
           );
           cursor = response.cursor;
@@ -112456,7 +112815,7 @@ var init_ElasticsearchConnector = __esm({
             response = await this.postSql(
               this.baseUrl(config2),
               { cursor: requestedCursor },
-              request3,
+              request4,
               query
             );
             cursor = response.cursor;
@@ -112466,7 +112825,7 @@ var init_ElasticsearchConnector = __esm({
           }
         } finally {
           if (cursorToClose)
-            await this.clearCursor(this.baseUrl(config2), cursorToClose, request3);
+            await this.clearCursor(this.baseUrl(config2), cursorToClose, request4);
         }
       }
       async testConnection(config2, authHeader) {
@@ -112562,12 +112921,12 @@ var init_ElasticsearchConnector = __esm({
           return password ? `ApiKey ${password}` : void 0;
         return config2.user && password ? `Basic ${Buffer.from(`${config2.user}:${password}`).toString("base64")}` : void 0;
       }
-      async postSql(baseUrl, body, request3, query) {
+      async postSql(baseUrl, body, request4, query) {
         try {
           const response = await axios_default.post(
             `${baseUrl}/_sql?format=json`,
             body,
-            request3
+            request4
           );
           if (response.status >= 400)
             this.throwHttpError(response.status, response.data, query);
@@ -112584,8 +112943,8 @@ var init_ElasticsearchConnector = __esm({
           supportsPagination: true
         };
       }
-      async clearCursor(baseUrl, cursor, request3) {
-        const closeRequest = { ...request3 };
+      async clearCursor(baseUrl, cursor, request4) {
+        const closeRequest = { ...request4 };
         delete closeRequest.signal;
         try {
           await axios_default.post(`${baseUrl}/_sql/close`, { cursor }, closeRequest);
@@ -113366,7 +113725,17 @@ if (parentPort) {
 });
 
 // src/server/connection/KeychainCredentialStore.ts
+function isNativeKeychainForbiddenError(error52) {
+  return error52 instanceof Error && error52.code === NATIVE_KEYCHAIN_FORBIDDEN_CODE;
+}
 function resolveDefaultKeyringModule() {
+  if (process.env["GRAIN_TEST_FORBID_NATIVE_KEYCHAIN"] === "1") {
+    const testKeyringModulePath = process.env["GRAIN_TEST_KEYRING_MODULE_PATH"];
+    if (testKeyringModulePath) {
+      return testKeyringModulePath;
+    }
+    throw new NativeKeychainForbiddenError();
+  }
   require("@napi-rs/keyring/keytar");
   return require.resolve("@napi-rs/keyring/keytar");
 }
@@ -113380,7 +113749,7 @@ function describeProbeFailure(error52) {
     detail
   };
 }
-var SERVICE_NAME, PROBE_ACCOUNT, DEFAULT_TIMEOUT_MS, MAX_DETAIL_LENGTH, KeychainCredentialStore;
+var SERVICE_NAME, PROBE_ACCOUNT, DEFAULT_TIMEOUT_MS, NATIVE_KEYCHAIN_FORBIDDEN_CODE, NativeKeychainForbiddenError, MAX_DETAIL_LENGTH, KeychainCredentialStore;
 var init_KeychainCredentialStore = __esm({
   "src/server/connection/KeychainCredentialStore.ts"() {
     "use strict";
@@ -113389,6 +113758,16 @@ var init_KeychainCredentialStore = __esm({
     SERVICE_NAME = "Grain";
     PROBE_ACCOUNT = "__sql_preview_keychain_probe__";
     DEFAULT_TIMEOUT_MS = 5e3;
+    NATIVE_KEYCHAIN_FORBIDDEN_CODE = "GRAIN_TEST_NATIVE_KEYCHAIN_FORBIDDEN";
+    NativeKeychainForbiddenError = class extends Error {
+      constructor() {
+        super(
+          "Native keychain access is forbidden in tests because GRAIN_TEST_FORBID_NATIVE_KEYCHAIN=1; configure GRAIN_TEST_KEYRING_MODULE_PATH to use a test keyring."
+        );
+        this.code = NATIVE_KEYCHAIN_FORBIDDEN_CODE;
+        this.name = "NativeKeychainForbiddenError";
+      }
+    };
     MAX_DETAIL_LENGTH = 200;
     KeychainCredentialStore = class {
       constructor(fallback, options = {}) {
@@ -113419,6 +113798,9 @@ var init_KeychainCredentialStore = __esm({
           await invokeWorker(modulePath, "deletePassword", [SERVICE_NAME, PROBE_ACCOUNT], timeoutMs);
           return { available: true };
         } catch (error52) {
+          if (isNativeKeychainForbiddenError(error52)) {
+            throw error52;
+          }
           logger.warn("[KeychainCredentialStore] Probe failed; will use file fallback", error52);
           return { available: false, ...describeProbeFailure(error52) };
         }
@@ -113436,6 +113818,9 @@ var init_KeychainCredentialStore = __esm({
           );
           return typeof password === "string" ? password : this.fallback.getPassword(profileId);
         } catch (error52) {
+          if (isNativeKeychainForbiddenError(error52)) {
+            throw error52;
+          }
           if (error52 instanceof KeychainTimeoutError) {
             throw error52;
           }
@@ -113455,6 +113840,9 @@ var init_KeychainCredentialStore = __esm({
             this.timeoutMs
           );
         } catch (error52) {
+          if (isNativeKeychainForbiddenError(error52)) {
+            throw error52;
+          }
           if (error52 instanceof KeychainTimeoutError) {
             throw error52;
           }
@@ -113474,6 +113862,9 @@ var init_KeychainCredentialStore = __esm({
             this.timeoutMs
           );
         } catch (error52) {
+          if (isNativeKeychainForbiddenError(error52)) {
+            throw error52;
+          }
           if (error52 instanceof KeychainTimeoutError) {
             throw error52;
           }
@@ -114641,49 +115032,49 @@ var init_QueryOperationRunner = __esm({
           detachAbortForwarder();
         }
       }
-      async run(request3) {
+      async run(request4) {
         const releaseAdmission = this.admission.acquire();
         let prepared;
         try {
-          prepared = this.prepareQueryOperation(request3);
+          prepared = this.prepareQueryOperation(request4);
         } catch (error52) {
           releaseAdmission();
-          if (errorIdOf(error52) === "query_result_tab_limit" && request3.origin !== void 0 && isDaemonEmittedOrigin(request3.origin)) {
+          if (errorIdOf(error52) === "query_result_tab_limit" && request4.origin !== void 0 && isDaemonEmittedOrigin(request4.origin)) {
             this.telemetry?.capture(
               "query_failed",
               {
                 state: "daemon",
-                source: isAgentOrigin(request3.origin) ? "mcp" : "unknown",
-                statement_type: classifySqlStatement(request3.sql),
+                source: isAgentOrigin(request4.origin) ? "mcp" : "unknown",
+                statement_type: classifySqlStatement(request4.sql),
                 duration_bucket: bucketDurationMs(0),
-                query_length_bucket: bucketQueryLength(request3.sql.length),
-                connector: normalizeTelemetryConnector(request3.connectionProfile?.type),
+                query_length_bucket: bucketQueryLength(request4.sql.length),
+                connector: normalizeTelemetryConnector(request4.connectionProfile?.type),
                 error_kind: "unknown",
                 error_id: "query_result_tab_limit"
               },
-              request3.clientConsent
+              request4.clientConsent
             );
           }
           throw error52;
         }
-        const waitForResult = request3.waitForResult ?? true;
+        const waitForResult = request4.waitForResult ?? true;
         const controller = new AbortController();
-        const detachAbortForwarder = this.forwardAbort(request3.abortSignal, controller);
+        const detachAbortForwarder = this.forwardAbort(request4.abortSignal, controller);
         this.abortRunningQuery(prepared.session, prepared.tabId);
         this.sessionManager.registerOperation(controller, prepared.session.id, prepared.tabId);
         const executionPromise = this.executeAndStore(
           prepared.session.id,
           prepared.tabId,
           prepared.sql,
-          request3.connectionId,
-          request3.connectionProfile,
-          request3.authHeader,
+          request4.connectionId,
+          request4.connectionProfile,
+          request4.authHeader,
           controller,
-          request3.origin,
-          request3.loadAllRows,
-          request3.enforceReadOnly,
-          request3.clientConsent,
-          request3.workspaceRoot
+          request4.origin,
+          request4.loadAllRows,
+          request4.enforceReadOnly,
+          request4.clientConsent,
+          request4.workspaceRoot
         ).finally(() => {
           releaseAdmission();
           this.sessionManager.unregisterOperation(controller);
@@ -114743,12 +115134,12 @@ var init_QueryOperationRunner = __esm({
         this.sessionManager.removeTab(sessionId, tabId);
         session.lastActivityAt = /* @__PURE__ */ new Date();
       }
-      getTabInfo(request3) {
-        const session = this.sessionManager.getSession(request3.sessionId);
+      getTabInfo(request4) {
+        const session = this.sessionManager.getSession(request4.sessionId);
         if (!session) {
           throw new Error("Session not found");
         }
-        const tabId = request3.tabId || session.activeTabId;
+        const tabId = request4.tabId || session.activeTabId;
         if (!tabId) {
           return void 0;
         }
@@ -114756,14 +115147,14 @@ var init_QueryOperationRunner = __esm({
         if (!tab) {
           return void 0;
         }
-        const mode = request3.mode || "preview";
+        const mode = request4.mode || "preview";
         const totalRows = tab.rows?.length ?? 0;
-        const resourceUri = `sql-preview://sessions/${request3.sessionId}/tabs/${tabId}`;
+        const resourceUri = `sql-preview://sessions/${request4.sessionId}/tabs/${tabId}`;
         if (mode === "preview") {
-          const previewLimit = request3.limit || 10;
+          const previewLimit = request4.limit || 10;
           const previewRows = tab.rows ? tab.rows.slice(0, previewLimit) : [];
           return {
-            sessionId: request3.sessionId,
+            sessionId: request4.sessionId,
             tabId,
             status: tab.status,
             meta: {
@@ -114782,8 +115173,8 @@ var init_QueryOperationRunner = __esm({
             ...tab.wasTruncated !== void 0 ? { wasTruncated: tab.wasTruncated } : {}
           };
         }
-        const offset = request3.offset || 0;
-        const limit = request3.limit ?? 100;
+        const offset = request4.offset || 0;
+        const limit = request4.limit ?? 100;
         const candidateRows = tab.rows ? tab.rows.slice(offset, offset + limit) : [];
         const rows = [];
         let currentSizeBytes = 0;
@@ -114798,7 +115189,7 @@ var init_QueryOperationRunner = __esm({
         const hasMore = offset + rows.length < totalRows;
         return {
           id: tab.id,
-          sessionId: request3.sessionId,
+          sessionId: request4.sessionId,
           tabId,
           title: tab.title,
           status: tab.status,
@@ -114820,38 +115211,38 @@ var init_QueryOperationRunner = __esm({
           ...tab.wasTruncated !== void 0 ? { wasTruncated: tab.wasTruncated } : {}
         };
       }
-      prepareQueryOperation(request3) {
-        const sql = request3.sql.trim();
+      prepareQueryOperation(request4) {
+        const sql = request4.sql.trim();
         if (!sql) {
           throw new Error("SQL query is required");
         }
-        let session = this.sessionManager.getSession(request3.sessionId);
+        let session = this.sessionManager.getSession(request4.sessionId);
         if (!session) {
           logger.info("Session not found, auto-registering...");
-          const isEditor = request3.origin === "vscode_extension" || request3.displayName === "VS Code";
+          const isEditor = request4.origin === "vscode_extension" || request4.displayName === "VS Code";
           this.sessionManager.registerSession(
-            request3.sessionId,
-            request3.displayName || (isEditor ? "VS Code" : "MCP Client"),
+            request4.sessionId,
+            request4.displayName || (isEditor ? "VS Code" : "MCP Client"),
             isEditor ? "vscode" : "standalone"
           );
-          session = this.sessionManager.getSession(request3.sessionId);
+          session = this.sessionManager.getSession(request4.sessionId);
           if (!session) {
-            throw new Error(`Failed to auto-register session: ${request3.sessionId}`);
+            throw new Error(`Failed to auto-register session: ${request4.sessionId}`);
           }
         }
-        if (request3.shownTabId !== void 0) {
-          if (request3.shownTabId && session.tabs.has(request3.shownTabId)) {
-            session.activeTabId = request3.shownTabId;
+        if (request4.shownTabId !== void 0) {
+          if (request4.shownTabId && session.tabs.has(request4.shownTabId)) {
+            session.activeTabId = request4.shownTabId;
           } else {
             delete session.activeTabId;
           }
         }
-        const shouldCreateNewTab = request3.newTab !== false;
+        const shouldCreateNewTab = request4.newTab !== false;
         const { tab, tabId, tabTitle } = this.resolveTab(
           session,
-          request3.tabId,
+          request4.tabId,
           shouldCreateNewTab,
-          request3.title
+          request4.title
         );
         if (!tab && !this.sessionManager.canAddTab(session.id) && !this.sessionManager.makeRoomForTab(session.id)) {
           throw new AppError(
@@ -115286,7 +115677,7 @@ var init_CredentialRequestService = __esm({
         }
         const id = import_crypto8.default.randomUUID();
         const token = import_crypto8.default.randomBytes(24).toString("base64url");
-        const request3 = {
+        const request4 = {
           id,
           token,
           connectionId,
@@ -115297,26 +115688,26 @@ var init_CredentialRequestService = __esm({
             token
           )}`
         };
-        this.requests.set(id, request3);
+        this.requests.set(id, request4);
         if (clientConsent !== void 0) {
           this.requestConsents.set(id, clientConsent);
         }
-        return request3;
+        return request4;
       }
       get(id, token) {
         this.pruneExpired();
-        const request3 = this.requests.get(id);
-        if (!request3 || request3.token !== token) {
+        const request4 = this.requests.get(id);
+        if (!request4 || request4.token !== token) {
           return void 0;
         }
-        return request3;
+        return request4;
       }
       async fulfill(id, token, password) {
-        const request3 = this.get(id, token);
-        if (!request3) {
+        const request4 = this.get(id, token);
+        if (!request4) {
           throw new Error("Credential request is invalid or expired.");
         }
-        if (request3.kind === "draft") {
+        if (request4.kind === "draft") {
           throw new Error("This setup page needs an updated Grain.");
         }
         if (!password) {
@@ -115325,12 +115716,12 @@ var init_CredentialRequestService = __esm({
         return this.complete(id, token, { password });
       }
       async describe(id, token) {
-        const request3 = this.get(id, token);
-        if (!request3) {
+        const request4 = this.get(id, token);
+        if (!request4) {
           return void 0;
         }
         const profile = await this.connectionManager.getProfile(
-          request3.connectionId,
+          request4.connectionId,
           this.requestConsents.get(id)
         );
         if (!profile) {
@@ -115343,29 +115734,29 @@ var init_CredentialRequestService = __esm({
           )
         );
         return {
-          kind: request3.kind,
-          connectionId: request3.connectionId,
-          connectionName: request3.connectionName,
-          expiresAt: request3.expiresAt,
+          kind: request4.kind,
+          connectionId: request4.connectionId,
+          connectionName: request4.connectionName,
+          expiresAt: request4.expiresAt,
           profile: safeProfile
         };
       }
       async complete(id, token, input) {
-        const request3 = this.get(id, token);
-        if (!request3) {
+        const request4 = this.get(id, token);
+        if (!request4) {
           throw new Error("Credential request is invalid or expired.");
         }
         const fields = input.fields ?? {};
-        if (request3.kind === "password" && Object.keys(fields).length > 0) {
+        if (request4.kind === "password" && Object.keys(fields).length > 0) {
           throw new Error("Only a password can be changed with this setup link.");
         }
-        if (request3.kind === "password" && !input.password) {
+        if (request4.kind === "password" && !input.password) {
           throw new Error("Password is required.");
         }
         const clientConsent = this.requestConsents.get(id);
-        const profile = await this.connectionManager.getProfile(request3.connectionId, clientConsent);
+        const profile = await this.connectionManager.getProfile(request4.connectionId, clientConsent);
         if (!profile) {
-          throw new Error(`Connection profile '${request3.connectionId}' not found`);
+          throw new Error(`Connection profile '${request4.connectionId}' not found`);
         }
         const schema = this.connectorRegistry?.getConnectorMetadata().find((item) => item.id === profile.type)?.configSchema;
         if (Object.keys(fields).some(
@@ -115380,7 +115771,7 @@ var init_CredentialRequestService = __esm({
             draft: false,
             ...input.password !== void 0 ? { password: input.password } : {}
           });
-          if (request3.kind === "draft") {
+          if (request4.kind === "draft") {
             this.telemetry?.capture(
               "first_value_step",
               { step: "connection_saved", outcome: "success", state: "mcp_server" },
@@ -115388,7 +115779,7 @@ var init_CredentialRequestService = __esm({
             );
           }
         } catch (e2) {
-          if (request3.kind !== "draft") {
+          if (request4.kind !== "draft") {
             throw e2;
           }
           this.telemetry?.capture(
@@ -115405,11 +115796,11 @@ var init_CredentialRequestService = __esm({
         }
         this.requests.delete(id);
         this.requestConsents.delete(id);
-        return request3;
+        return request4;
       }
       pruneExpired(now = Date.now()) {
-        for (const [id, request3] of this.requests.entries()) {
-          if (request3.expiresAt <= now) {
+        for (const [id, request4] of this.requests.entries()) {
+          if (request4.expiresAt <= now) {
             this.requests.delete(id);
             this.requestConsents.delete(id);
           }
@@ -115457,9 +115848,9 @@ async function createConnectionDraft(deps, args, clientConsent) {
     type: connector.id,
     draft: true
   });
-  let request3;
+  let request4;
   try {
-    request3 = await service.create(connectionId, {
+    request4 = await service.create(connectionId, {
       expiresInMinutes: input.expiresInMinutes,
       clientConsent
     });
@@ -115467,18 +115858,18 @@ async function createConnectionDraft(deps, args, clientConsent) {
     await deps.connectionManager.deleteProfile(connectionId);
     throw error52;
   }
-  const browserOpened = await deps.openBrowser?.(request3.url) ?? false;
+  const browserOpened = await deps.openBrowser?.(request4.url) ?? false;
   return {
     structuredContent: {
       connectionId,
-      url: request3.url,
+      url: request4.url,
       browserOpened,
-      expiresAt: new Date(request3.expiresAt).toISOString()
+      expiresAt: new Date(request4.expiresAt).toISOString()
     },
     content: [
       {
         type: "text",
-        text: `Draft connection '${name}' (id ${connectionId}) created. Setup page: ${request3.url} (expires ${new Date(request3.expiresAt).toISOString()}).`
+        text: `Draft connection '${name}' (id ${connectionId}) created. Setup page: ${request4.url} (expires ${new Date(request4.expiresAt).toISOString()}).`
       }
     ]
   };
@@ -115568,74 +115959,6 @@ var init_authHeaders = __esm({
   }
 });
 
-// src/server/policy/callPolicy.ts
-function clientPolicyFromMeta(meta3) {
-  const asked = meta3?.[CLIENT_POLICY_META_KEY];
-  if (typeof asked !== "object" || asked === null)
-    return void 0;
-  const safeMode = asked.safeMode;
-  return typeof safeMode === "boolean" ? { safeMode } : {};
-}
-function resolveCallPolicy(serviceProfile, serviceSafeMode, requested) {
-  if (requested?.safeMode === void 0) {
-    return { profile: serviceProfile, declined: [] };
-  }
-  if (requested.safeMode) {
-    const tightened = { ...serviceProfile, forceSafeMode: true };
-    return { profile: composeToolProfiles(serviceProfile, tightened), declined: [] };
-  }
-  if (isSafeModeActive(serviceProfile, serviceSafeMode)) {
-    return { profile: serviceProfile, declined: [SAFE_MODE_DECLINED_MESSAGE] };
-  }
-  return { profile: serviceProfile, declined: [] };
-}
-function alphaToolEnabled(name, chartsEnabled, ledgerEnabled) {
-  if (CHART_TOOLS.includes(name))
-    return chartsEnabled;
-  if (LEDGER_TOOLS.includes(name))
-    return ledgerEnabled;
-  return true;
-}
-function admitToolCall(profile, name, featureEnabled) {
-  if (!toolNamesForProfile(profile).has(name) || !featureEnabled) {
-    throw new Error("Unknown tool");
-  }
-  return refuseIfNotPermitted(profile, name);
-}
-function refuseRestToolCall(profile, name) {
-  const tool = name;
-  if (!ALL_TOOLS.includes(tool)) {
-    return void 0;
-  }
-  if (!toolNamesForProfile(profile).has(name)) {
-    return toolRefusalResult(profile, tool);
-  }
-  return refuseIfNotPermitted(profile, name);
-}
-function withPolicyNotice(result, policy) {
-  if (policy.declined.length === 0)
-    return result;
-  const existing = result;
-  const notice = { type: "text", text: policy.declined.join(" ") };
-  return {
-    ...existing,
-    content: Array.isArray(existing.content) ? [...existing.content, notice] : [notice],
-    _meta: { ...existing._meta, [DECLINED_POLICY_META_KEY]: policy.declined }
-  };
-}
-var CLIENT_POLICY_META_KEY, DECLINED_POLICY_META_KEY, SAFE_MODE_DECLINED_MESSAGE, CHART_TOOLS, LEDGER_TOOLS;
-var init_callPolicy = __esm({
-  "src/server/policy/callPolicy.ts"() {
-    "use strict";
-    init_toolProfiles();
-    CLIENT_POLICY_META_KEY = "sqlpreview/policy";
-    DECLINED_POLICY_META_KEY = "sqlpreview/policyDeclined";
-    SAFE_MODE_DECLINED_MESSAGE = "Declined this client's request to run with safe mode off: 'mcpSafeMode' is client-restrict-only, so an attaching client may only make it more restrictive than the service, never less. This call ran under safe mode; the override was declined, not lost.";
-    CHART_TOOLS = ["render_chart", "save_chart", "list_charts"];
-    LEDGER_TOOLS = ["ledger_stats", "verify_ledger"];
-  }
-});
-
 // src/server/tools/toolDefinitions.ts
 function projectToolForWire(def) {
   const { name, description, inputSchema, _meta } = def;
@@ -116185,52 +116508,52 @@ function pickActiveConnectionId(profiles, explicitId) {
   );
   return active?.id ?? profiles[0]?.id;
 }
-function buildCredentialRequiredResult(request3, browserOpened) {
-  const expiresAt = new Date(request3.expiresAt).toISOString();
+function buildCredentialRequiredResult(request4, browserOpened) {
+  const expiresAt = new Date(request4.expiresAt).toISOString();
   return {
     isError: true,
     content: [
       {
         type: "text",
-        text: browserOpened ? `I opened a one-time Grain password page for '${request3.connectionName}' in your browser. Enter the password there, not in chat.
+        text: browserOpened ? `I opened a one-time Grain password page for '${request4.connectionName}' in your browser. Enter the password there, not in chat.
 
-If it did not open: ${request3.url}
+If it did not open: ${request4.url}
 
-The link expires at ${expiresAt}. After saving the password, retry the query.` : `Connection '${request3.connectionName}' needs a password before this query can run. Open this one-time Grain credential form and enter it there \u2014 do not paste the password into chat:
+The link expires at ${expiresAt}. After saving the password, retry the query.` : `Connection '${request4.connectionName}' needs a password before this query can run. Open this one-time Grain credential form and enter it there \u2014 do not paste the password into chat:
 
-${request3.url}
+${request4.url}
 
 The link expires at ${expiresAt}. After saving the password, retry the query.`
       }
     ],
     structuredContent: {
       status: "credential_required",
-      connectionId: request3.connectionId,
-      connectionName: request3.connectionName,
+      connectionId: request4.connectionId,
+      connectionName: request4.connectionName,
       ...browserOpened === void 0 ? {} : { browserOpened },
-      credentialUrl: request3.url,
+      credentialUrl: request4.url,
       expiresAt,
       errorKind: "auth",
       errorId: "credential_required"
     }
   };
 }
-function buildSetupRequiredResult(request3, browserOpened) {
-  const expiresAt = new Date(request3.expiresAt).toISOString();
+function buildSetupRequiredResult(request4, browserOpened) {
+  const expiresAt = new Date(request4.expiresAt).toISOString();
   return {
     isError: true,
     content: [
       {
         type: "text",
-        text: `Connection '${request3.connectionName}' (id ${request3.connectionId}) is a draft and has no credentials yet. Setup page: ${request3.url} (expires ${expiresAt}). Queries on this connection will work once setup is saved.`
+        text: `Connection '${request4.connectionName}' (id ${request4.connectionId}) is a draft and has no credentials yet. Setup page: ${request4.url} (expires ${expiresAt}). Queries on this connection will work once setup is saved.`
       }
     ],
     structuredContent: {
       status: "setup_required",
-      connectionId: request3.connectionId,
-      connectionName: request3.connectionName,
+      connectionId: request4.connectionId,
+      connectionName: request4.connectionName,
       ...browserOpened === void 0 ? {} : { browserOpened },
-      setupUrl: request3.url,
+      setupUrl: request4.url,
       expiresAt,
       errorKind: "config",
       errorId: "setup_required"
@@ -117116,18 +117439,18 @@ var init_SessionChartService = __esm({
         this.sessionManager = sessionManager;
         this.runtime = runtime;
       }
-      async execute(request3) {
-        const session = this.sessionManager.getSession(request3.sessionId);
-        const tab = session?.tabs.get(request3.tabId);
+      async execute(request4) {
+        const session = this.sessionManager.getSession(request4.sessionId);
+        const tab = session?.tabs.get(request4.tabId);
         if (!tab) {
           throw new Error(
-            `Result tab '${request3.tabId}' was not found in session '${request3.sessionId}'.`
+            `Result tab '${request4.tabId}' was not found in session '${request4.sessionId}'.`
           );
         }
         if (!tab.rows || !tab.columns) {
-          throw new Error(`Result tab '${request3.tabId}' has no completed result to chart.`);
+          throw new Error(`Result tab '${request4.tabId}' has no completed result to chart.`);
         }
-        const validation = validateChartSpec(request3.spec);
+        const validation = validateChartSpec(request4.spec);
         if (!validation.valid) {
           throw new Error(`Invalid chart spec: ${validation.errors.join("; ")}`);
         }
@@ -117136,7 +117459,7 @@ var init_SessionChartService = __esm({
           tab.columns,
           tab.rows,
           this.runtime,
-          request3.paramValues
+          request4.paramValues
         );
       }
     };
@@ -197598,23 +197921,23 @@ ${query.sql}`).join("\n\n")
         if (!connectionId) {
           throw new Error("connectionId is required");
         }
-        const request3 = await service.create(connectionId, {
+        const request4 = await service.create(connectionId, {
           expiresInMinutes: typedArgs?.expiresInMinutes,
           clientConsent
         });
-        const browserOpened = await this.options.openBrowser?.(request3.url) ?? false;
+        const browserOpened = await this.options.openBrowser?.(request4.url) ?? false;
         return {
           structuredContent: {
-            connectionId: request3.connectionId,
-            connectionName: request3.connectionName,
-            url: request3.url,
+            connectionId: request4.connectionId,
+            connectionName: request4.connectionName,
+            url: request4.url,
             browserOpened,
-            expiresAt: new Date(request3.expiresAt).toISOString()
+            expiresAt: new Date(request4.expiresAt).toISOString()
           },
           content: [
             {
               type: "text",
-              text: `One-time Grain setup page for '${request3.connectionName}' (id ${request3.connectionId}): ${request3.url} (expires ${new Date(request3.expiresAt).toISOString()}). ${browserOpened ? "The page was opened in the browser." : "The page was not opened in the browser."} Connection setup takes effect once saved.`
+              text: `One-time Grain setup page for '${request4.connectionName}' (id ${request4.connectionId}): ${request4.url} (expires ${new Date(request4.expiresAt).toISOString()}). ${browserOpened ? "The page was opened in the browser." : "The page was not opened in the browser."} Connection setup takes effect once saved.`
             }
           ]
         };
@@ -197966,9 +198289,9 @@ ${query.sql}`).join("\n\n")
           if (!connectionId) {
             return null;
           }
-          const request3 = await service.create(connectionId, { clientConsent });
-          const browserOpened = await this.options.openBrowser?.(request3.url) ?? false;
-          return buildCredentialRequiredResult(request3, browserOpened);
+          const request4 = await service.create(connectionId, { clientConsent });
+          const browserOpened = await this.options.openBrowser?.(request4.url) ?? false;
+          return buildCredentialRequiredResult(request4, browserOpened);
         } catch (err) {
           logger.warn("[MCP] Failed to build credential_required result", err);
           return null;
@@ -197983,9 +198306,9 @@ ${query.sql}`).join("\n\n")
         const profile = profiles.find((item) => item.id === connectionId);
         if (!profile?.draft)
           return null;
-        const request3 = await service.create(profile.id, { clientConsent });
-        const browserOpened = await this.options.openBrowser?.(request3.url) ?? false;
-        return buildSetupRequiredResult(request3, browserOpened);
+        const request4 = await service.create(profile.id, { clientConsent });
+        const browserOpened = await this.options.openBrowser?.(request4.url) ?? false;
+        return buildSetupRequiredResult(request4, browserOpened);
       }
       async chartDocuments(root) {
         if (!this.chartsEnabled) {
@@ -206512,8 +206835,8 @@ function registerConnectionSetupRoutes(app, context2) {
   app.get("/connection-setup/:id", (req, res) => {
     setCredentialPageHeaders(res);
     const token = typeof req.query["token"] === "string" ? req.query["token"] : "";
-    const request3 = req.params.id ? context2.credentialRequestService.get(req.params.id, token) : void 0;
-    if (!request3) {
+    const request4 = req.params.id ? context2.credentialRequestService.get(req.params.id, token) : void 0;
+    if (!request4) {
       res.status(404).send(renderCredentialPage({ error: "This credential request is invalid or expired." }));
       return;
     }
@@ -206545,11 +206868,11 @@ function registerConnectionSetupRoutes(app, context2) {
       res.type("html").send(bundle);
       return;
     }
-    if (request3.kind === "draft") {
+    if (request4.kind === "draft") {
       res.send(renderCredentialPage({ error: "This setup page needs an updated Grain." }));
       return;
     }
-    res.send(renderCredentialPage({ request: request3 }));
+    res.send(renderCredentialPage({ request: request4 }));
   });
   app.get("/connection-setup/:id/state", async (req, res) => {
     setCredentialPageHeaders(res);
@@ -206736,11 +207059,11 @@ var init_ClientIdentity = __esm({
 });
 
 // src/server/auth/requireDaemonAuth.ts
-function setRequestClient(request3, identity2) {
-  requestClients.set(request3, identity2);
+function setRequestClient(request4, identity2) {
+  requestClients.set(request4, identity2);
 }
-function getRequestClient(request3) {
-  return requestClients.get(request3);
+function getRequestClient(request4) {
+  return requestClients.get(request4);
 }
 function isPublicDaemonPath(pathname) {
   if (PUBLIC_EXACT_PATHS.has(pathname)) {
@@ -206909,6 +207232,7 @@ function createSettingsUpdateHandler(context2) {
         maxRowsToDisplay: context2.resolvedConfig.config.query.maxRows,
         mcpSafeMode: context2.resolvedConfig.config.mcp.safeMode,
         confirmWriteQueries: context2.toolManager.isConfirmWrites,
+        resultsCardRouting: context2.toolManager.isResultsCardRoutingEnabled,
         ...declined.length > 0 ? { declined } : {}
       });
     } catch (err) {
@@ -207115,14 +207439,14 @@ function registerDaemonHttpRoutes(context2, mcpHttpSurface) {
     setCredentialPageHeaders(res);
     const id = req.params.id;
     const token = typeof req.query["token"] === "string" ? req.query["token"] : "";
-    const request3 = id ? context2.credentialRequestService.get(id, token) : void 0;
-    if (!request3) {
+    const request4 = id ? context2.credentialRequestService.get(id, token) : void 0;
+    if (!request4) {
       res.status(404).send(renderCredentialPage({ error: "This credential request is invalid or expired." }));
       return;
     }
     res.redirect(
       302,
-      `/connection-setup/${encodeURIComponent(request3.id)}?token=${encodeURIComponent(token)}`
+      `/connection-setup/${encodeURIComponent(request4.id)}?token=${encodeURIComponent(token)}`
     );
   });
   registerConnectionSetupRoutes(app, context2);
@@ -207250,8 +207574,10 @@ data: ${Date.now()}
     app.get("/api/v1/update", (_req, res) => {
       res.json(updateService.status());
     });
-    app.post("/api/v1/update/restart", async (_req, res) => {
-      const result = await updateService.restartToUpdate();
+    app.post("/api/v1/update/restart", import_express2.default.json(), async (req, res) => {
+      const result = await updateService.restartToUpdate({
+        discardResults: req.body?.discardResults === true
+      });
       res.json({ result, blockers: updateService.status().blockers });
     });
   }
@@ -207716,11 +208042,11 @@ function readCredentialTemplate() {
   }
 }
 function credentialBody(input) {
-  const request3 = input.request;
+  const request4 = input.request;
   const status = input.success ? `<p class="grain-connection-success" role="status">${escapeHtml(input.success)}</p>` : input.error ? `<p class="grain-connection-error" role="alert">${escapeHtml(input.error)}</p>` : "";
-  const form = request3 ? `<p class="grain-connection-intro">Enter the password for <strong>${escapeHtml(request3.connectionName)}</strong>${input.connectionType ? ` <span class="grain-credential-meta">(${escapeHtml(input.connectionType)})</span>` : ""}.</p>
-       <form method="post" action="/credential-requests/${encodeURIComponent(request3.id)}" autocomplete="off" class="grain-connection-section">
-         <input type="hidden" name="token" value="${escapeHtml(request3.token)}" />
+  const form = request4 ? `<p class="grain-connection-intro">Enter the password for <strong>${escapeHtml(request4.connectionName)}</strong>${input.connectionType ? ` <span class="grain-credential-meta">(${escapeHtml(input.connectionType)})</span>` : ""}.</p>
+       <form method="post" action="/credential-requests/${encodeURIComponent(request4.id)}" autocomplete="off" class="grain-connection-section">
+         <input type="hidden" name="token" value="${escapeHtml(request4.token)}" />
          <div class="grain-connection-field">
            <label for="password">Password</label>
            <input id="password" class="grain-connection-password" name="password" type="password" autocomplete="new-password" data-1p-ignore data-lpignore="true" autofocus required />
@@ -207730,7 +208056,7 @@ function credentialBody(input) {
          </div>
        </form>
        <p class="grain-credential-meta">Your password goes straight to Grain on this computer. Your agent never sees it. This link works once and expires at ${escapeHtml(
-    new Date(request3.expiresAt).toLocaleString()
+    new Date(request4.expiresAt).toLocaleString()
   )}.</p>` : "";
   return `<main class="grain-connection-page"><div class="grain-credential-card"><h1>Connection password</h1>${status}${form}</div></main>`;
 }
@@ -207741,16 +208067,16 @@ function renderCredentialPage(input, template = readCredentialTemplate()) {
   const title = "Grain Credential Request";
   const message = input.success || input.error || "";
   const escapedMessage = escapeHtml(message);
-  const request3 = input.request;
-  const form = request3 ? `<p>Enter the password for <strong>${escapeHtml(request3.connectionName)}</strong>.</p>
+  const request4 = input.request;
+  const form = request4 ? `<p>Enter the password for <strong>${escapeHtml(request4.connectionName)}</strong>.</p>
        <p class="hint">The password is sent directly to the local Grain daemon and is not shown in the MCP/chat transcript.</p>
-       <form method="post" action="/credential-requests/${encodeURIComponent(request3.id)}" autocomplete="off">
-         <input type="hidden" name="token" value="${escapeHtml(request3.token)}" />
+       <form method="post" action="/credential-requests/${encodeURIComponent(request4.id)}" autocomplete="off">
+         <input type="hidden" name="token" value="${escapeHtml(request4.token)}" />
          <label for="password">Password</label>
          <input id="password" name="password" type="password" autocomplete="new-password" data-1p-ignore data-lpignore="true" autofocus required />
          <button type="submit">Save password</button>
        </form>
-       <p class="hint">This request expires at ${escapeHtml(new Date(request3.expiresAt).toLocaleString())}.</p>` : "";
+       <p class="hint">This request expires at ${escapeHtml(new Date(request4.expiresAt).toLocaleString())}.</p>` : "";
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -209432,8 +209758,8 @@ var init_server = __esm({
        *
        * @experimental
        */
-      requestStream(request3, resultSchema, options) {
-        return this._server.requestStream(request3, resultSchema, options);
+      requestStream(request4, resultSchema, options) {
+        return this._server.requestStream(request4, resultSchema, options);
       }
       /**
        * Sends a sampling request and returns an AsyncGenerator that yields response messages.
@@ -209654,12 +209980,12 @@ var init_server2 = __esm({
         this._capabilities = options?.capabilities ?? {};
         this._instructions = options?.instructions;
         this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
-        this.setRequestHandler(InitializeRequestSchema, (request3) => this._oninitialize(request3));
+        this.setRequestHandler(InitializeRequestSchema, (request4) => this._oninitialize(request4));
         this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
         if (this._capabilities.logging) {
-          this.setRequestHandler(SetLevelRequestSchema, async (request3, extra) => {
+          this.setRequestHandler(SetLevelRequestSchema, async (request4, extra) => {
             const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0;
-            const { level } = request3.params;
+            const { level } = request4.params;
             const parseResult = LoggingLevelSchema.safeParse(level);
             if (parseResult.success) {
               this._loggingLevels.set(transportSessionId, parseResult.data);
@@ -209709,14 +210035,14 @@ var init_server2 = __esm({
         }
         const method = methodValue;
         if (method === "tools/call") {
-          const wrappedHandler = async (request3, extra) => {
-            const validatedRequest = safeParse3(CallToolRequestSchema, request3);
+          const wrappedHandler = async (request4, extra) => {
+            const validatedRequest = safeParse3(CallToolRequestSchema, request4);
             if (!validatedRequest.success) {
               const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
               throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
             }
             const { params } = validatedRequest.data;
-            const result = await Promise.resolve(handler(request3, extra));
+            const result = await Promise.resolve(handler(request4, extra));
             if (params.task) {
               const taskValidationResult = safeParse3(CreateTaskResultSchema, result);
               if (!taskValidationResult.success) {
@@ -209847,10 +210173,10 @@ var init_server2 = __esm({
         }
         assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
       }
-      async _oninitialize(request3) {
-        const requestedVersion = request3.params.protocolVersion;
-        this._clientCapabilities = request3.params.capabilities;
-        this._clientVersion = request3.params.clientInfo;
+      async _oninitialize(request4) {
+        const requestedVersion = request4.params.protocolVersion;
+        this._clientCapabilities = request4.params.capabilities;
+        this._clientVersion = request4.params.clientInfo;
         const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
         return {
           protocolVersion,
@@ -228095,12 +228421,12 @@ var require_service = __commonJS({
       this.requestDelimited = Boolean(requestDelimited);
       this.responseDelimited = Boolean(responseDelimited);
     }
-    Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request3, callback) {
-      if (!request3)
+    Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request4, callback) {
+      if (!request4)
         throw TypeError("request must be specified");
       var self2 = this;
       if (!callback)
-        return util3.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request3);
+        return util3.asPromise(rpcCall, self2, method, requestCtor, responseCtor, request4);
       if (!self2.rpcImpl) {
         setTimeout(function() {
           callback(Error("already ended"));
@@ -228110,7 +228436,7 @@ var require_service = __commonJS({
       try {
         return self2.rpcImpl(
           method,
-          requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request3).finish(),
+          requestCtor[self2.requestDelimited ? "encodeDelimited" : "encode"](request4).finish(),
           function rpcCallback(err, response) {
             if (err) {
               self2.emit("error", err, method);
@@ -232816,8 +233142,8 @@ var require_root = __commonJS({
                 MetricsService.create = function create5(rpcImpl, requestDelimited, responseDelimited) {
                   return new this(rpcImpl, requestDelimited, responseDelimited);
                 };
-                Object.defineProperty(MetricsService.prototype["export"] = function export_(request3, callback) {
-                  return this.rpcCall(export_, $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest, $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse, request3, callback);
+                Object.defineProperty(MetricsService.prototype["export"] = function export_(request4, callback) {
+                  return this.rpcCall(export_, $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest, $root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse, request4, callback);
                 }, "name", { value: "Export" });
                 return MetricsService;
               }();
@@ -233461,8 +233787,8 @@ var require_metrics = __commonJS({
     var metricsRequestType = root.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest;
     exports.ProtobufMetricsSerializer = {
       serializeRequest: (arg) => {
-        const request3 = (0, internal_1.createExportMetricsServiceRequest)([arg], utils_1.PROTOBUF_ENCODER);
-        return metricsRequestType.encode(request3).finish();
+        const request4 = (0, internal_1.createExportMetricsServiceRequest)([arg], utils_1.PROTOBUF_ENCODER);
+        return metricsRequestType.encode(request4).finish();
       },
       deserializeResponse: (arg) => {
         return metricsResponseType.decode(arg);
@@ -233868,9 +234194,9 @@ var require_logs3 = __commonJS({
     var api_1 = (init_esm2(), __toCommonJS(esm_exports));
     exports.JsonLogsSerializer = {
       serializeRequest: (arg) => {
-        const request3 = (0, internal_1.createExportLogsServiceRequest)(arg, utils_1.JSON_ENCODER);
+        const request4 = (0, internal_1.createExportLogsServiceRequest)(arg, utils_1.JSON_ENCODER);
         const encoder = new TextEncoder();
-        return encoder.encode(JSON.stringify(request3));
+        return encoder.encode(JSON.stringify(request4));
       },
       deserializeResponse: (arg) => {
         if (arg.length === 0) {
@@ -233912,9 +234238,9 @@ var require_metrics2 = __commonJS({
     var api_1 = (init_esm2(), __toCommonJS(esm_exports));
     exports.JsonMetricsSerializer = {
       serializeRequest: (arg) => {
-        const request3 = (0, internal_1.createExportMetricsServiceRequest)([arg], utils_1.JSON_ENCODER);
+        const request4 = (0, internal_1.createExportMetricsServiceRequest)([arg], utils_1.JSON_ENCODER);
         const encoder = new TextEncoder();
-        return encoder.encode(JSON.stringify(request3));
+        return encoder.encode(JSON.stringify(request4));
       },
       deserializeResponse: (arg) => {
         if (arg.length === 0) {
@@ -234081,9 +234407,9 @@ var require_trace2 = __commonJS({
     var api_1 = (init_esm2(), __toCommonJS(esm_exports));
     exports.JsonTraceSerializer = {
       serializeRequest: (arg) => {
-        const request3 = (0, internal_1.createExportTraceServiceRequest)(arg, utils_1.JSON_ENCODER);
+        const request4 = (0, internal_1.createExportTraceServiceRequest)(arg, utils_1.JSON_ENCODER);
         const encoder = new TextEncoder();
-        return encoder.encode(JSON.stringify(request3));
+        return encoder.encode(JSON.stringify(request4));
       },
       deserializeResponse: (arg) => {
         if (arg.length === 0) {
@@ -234277,7 +234603,7 @@ var init_version3 = __esm({
 });
 
 // node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
-function sendWithHttp(request3, url3, headers, compression, userAgent, agent, data, timeoutMillis) {
+function sendWithHttp(request4, url3, headers, compression, userAgent, agent, data, timeoutMillis) {
   return new Promise((resolve15) => {
     const parsedUrl = new URL(url3);
     if (userAgent) {
@@ -234293,7 +234619,7 @@ function sendWithHttp(request3, url3, headers, compression, userAgent, agent, da
       headers,
       agent
     };
-    const req = request3(options, (res) => {
+    const req = request4(options, (res) => {
       const responseData = [];
       let responseSize = 0;
       res.on("data", (chunk) => {
@@ -234418,8 +234744,8 @@ var init_http_transport_utils = __esm({
 // node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js
 async function requestFunctionFactory(protocol) {
   const module2 = protocol === "http:" ? import("http") : import("https");
-  const { request: request3 } = await module2;
-  return request3;
+  const { request: request4 } = await module2;
+  return request4;
 }
 function createHttpExporterTransport(parameters) {
   return new HttpExporterTransport(parameters);
@@ -234435,9 +234761,9 @@ var init_http_exporter_transport = __esm({
         this._parameters = parameters;
       }
       async send(data, timeoutMillis) {
-        const { agent, request: request3 } = await this._loadUtils();
+        const { agent, request: request4 } = await this._loadUtils();
         const headers = await this._parameters.headers();
-        return sendWithHttp(request3, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, timeoutMillis);
+        return sendWithHttp(request4, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, timeoutMillis);
       }
       shutdown() {
       }
@@ -234445,11 +234771,11 @@ var init_http_exporter_transport = __esm({
         let utils = this._utils;
         if (utils === null) {
           const protocol = new URL(this._parameters.url).protocol;
-          const [agent, request3] = await Promise.all([
+          const [agent, request4] = await Promise.all([
             this._parameters.agentFactory(protocol),
             requestFunctionFactory(protocol)
           ]);
-          utils = this._utils = { agent, request: request3 };
+          utils = this._utils = { agent, request: request4 };
         }
         return utils;
       }
@@ -235224,11 +235550,11 @@ var require_PrometheusExporter = __commonJS({
        * @param request Incoming HTTP request to export server
        * @param response HTTP response object used to respond to request
        */
-      _requestHandler = (request3, response) => {
+      _requestHandler = (request4, response) => {
         let pathname;
         try {
-          if (request3.url != null) {
-            pathname = new url_1.URL(request3.url, this._baseUrl).pathname;
+          if (request4.url != null) {
+            pathname = new url_1.URL(request4.url, this._baseUrl).pathname;
           }
         } catch {
           response.statusCode = 400;
@@ -235423,7 +235749,7 @@ var require_util3 = __commonJS({
     exports.prepareSend = void 0;
     var api_1 = (init_esm2(), __toCommonJS(esm_exports));
     var core_1 = require_src2();
-    var http10 = require("http");
+    var http11 = require("http");
     var https6 = require("https");
     function prepareSend(urlStr, headers) {
       const url3 = new URL(urlStr);
@@ -235439,8 +235765,8 @@ var require_util3 = __commonJS({
           api_1.diag.debug("Zipkin send with empty spans");
           return done({ code: core_1.ExportResultCode.SUCCESS });
         }
-        const { request: request3 } = url3.protocol === "http:" ? http10 : https6;
-        const req = request3(url3, reqOpts, (res) => {
+        const { request: request4 } = url3.protocol === "http:" ? http11 : https6;
+        const req = request4(url3, reqOpts, (res) => {
           let rawData = "";
           res.on("data", (chunk) => {
             rawData += chunk;
@@ -237990,7 +238316,6 @@ var init_ResultRouting = __esm({
     ResultRouting = class {
       constructor(options) {
         this.options = options;
-        this.firstResultRevealed = false;
       }
       async apply(name, result, enabled, rendersApps, origin2, clientLabel, clientConsent) {
         const isQuery = name === "run_query";
@@ -238021,8 +238346,8 @@ var init_ResultRouting = __esm({
             }
           }
         }
-        if (enabled && isQuery && !this.firstResultRevealed && structured?.["status"] === "success" && typeof structured["sessionId"] === "string" && typeof structured["tabId"] === "string" && await editorConfirmation.reveal(roots2, structured["sessionId"], structured["tabId"])) {
-          this.firstResultRevealed = true;
+        if (enabled && isQuery && structured?.["status"] === "success" && typeof structured["sessionId"] === "string" && typeof structured["tabId"] === "string") {
+          await editorConfirmation.reveal(roots2, structured["sessionId"], structured["tabId"]);
         }
         if ((route === "text-workspace" || route === "text-editor") && isQuery && structured?.["status"] === "success") {
           const sessionId = structured["sessionId"];
@@ -238195,11 +238520,13 @@ var init_DaemonMcpServer = __esm({
        * to observe. An `unknown` label is always preferable to a failed read.
        */
       resolveClientLabel() {
+        return normalizeTelemetryMcpClient(this.resolveClientName());
+      }
+      resolveClientName() {
         try {
-          const reported = typeof this.server.getClientVersion === "function" ? this.server.getClientVersion()?.name : void 0;
-          return normalizeTelemetryMcpClient(reported);
+          return (typeof this.server.getClientVersion === "function" ? this.server.getClientVersion()?.name : void 0)?.trim();
         } catch {
-          return "unknown";
+          return void 0;
         }
       }
       clientRendersApps() {
@@ -238269,13 +238596,13 @@ var init_DaemonMcpServer = __esm({
             tools: this.toolsForClient()
           };
         });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request3) => {
+        this.server.setRequestHandler(CallToolRequestSchema, async (request4) => {
           return await getTracer().startActiveSpan(`mcp.tool_call`, async (span) => {
             try {
-              span.setAttribute("mcp.tool.name", request3.params.name);
-              if (request3.params.name === "open_result_view") {
+              span.setAttribute("mcp.tool.name", request4.params.name);
+              if (request4.params.name === "open_result_view") {
                 return handleOpenResultView({
-                  args: request3.params.arguments,
+                  args: request4.params.arguments,
                   enabled: this.toolManager.isResultsCardRoutingEnabled,
                   clientRendersApps: this.clientRendersApps(),
                   toolRegistered: this.toolManager.getTools(this.profile).some((tool) => tool.name === "open_result_view"),
@@ -238289,9 +238616,12 @@ var init_DaemonMcpServer = __esm({
                 });
               }
               const clientLabel = this.resolveClientLabel();
+              const args = request4.params.arguments;
+              const clientName = this.resolveClientName();
+              const toolArgs = request4.params.name === "run_query" && args && !args["displayName"] && clientName ? { ...args, displayName: clientName } : args;
               const result = await this.toolManager.handleToolCall(
-                request3.params.name,
-                request3.params.arguments,
+                request4.params.name,
+                toolArgs,
                 this.origin,
                 clientLabel,
                 this.profile,
@@ -238302,13 +238632,13 @@ var init_DaemonMcpServer = __esm({
                 // the second attached client the first one's policy. It can only ever
                 // tighten; `resolveCallPolicy` declines anything that would relax a
                 // control the service set, and says so on the result.
-                clientPolicyFromMeta(request3.params._meta),
+                clientPolicyFromMeta(request4.params._meta),
                 this.telemetryConsent
               );
               const rendersApps = this.clientRendersApps();
               const routingEnabled = Boolean(this.toolManager.isResultsCardRoutingEnabled);
               await this.resultRouting.apply(
-                request3.params.name,
+                request4.params.name,
                 result,
                 routingEnabled,
                 rendersApps,
@@ -238403,8 +238733,8 @@ var init_DaemonMcpServer = __esm({
           });
           return { resources };
         });
-        this.server.setRequestHandler(ReadResourceRequestSchema, async (request3) => {
-          const uri = request3.params.uri;
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request4) => {
+          const uri = request4.params.uri;
           const clientLabel = this.resolveClientLabel();
           const routingEnabled = Boolean(this.toolManager.isResultsCardRoutingEnabled);
           if (uri === UI_FULL_RESOURCE_URI && !routingEnabled) {
@@ -238990,8 +239320,8 @@ var init_DaemonSocketSurface = __esm({
           });
           let isRegistered = false;
           if (typeof server.setRequestHandler === "function") {
-            server.setRequestHandler(EditorWindowStateRequestSchema, async (request3) => {
-              editorConfirmation.report(server, request3.params.folders, request3.params.focused);
+            server.setRequestHandler(EditorWindowStateRequestSchema, async (request4) => {
+              editorConfirmation.report(server, request4.params.folders, request4.params.focused);
               return { ok: true };
             });
           }
@@ -255656,7 +255986,7 @@ var init_ActivationGate = __esm({
           throw error52;
         }
       }
-      async tryActivate(activate) {
+      async tryActivate(activate, options = {}) {
         if (this.admission.isDraining || this.activationInProgress) {
           return "blocked";
         }
@@ -255664,7 +255994,9 @@ var init_ActivationGate = __esm({
         this.activationInProgress = true;
         try {
           this.options.onAdmissionClosed?.();
-          if (this.admission.otherInFlightCount > 0 || !this.isIdle()) {
+          const state = this.options.inspect();
+          const activationState = options.discardResults ? { ...state, retainedResultTabs: 0 } : state;
+          if (this.admission.otherInFlightCount > 0 || !isIdleState(activationState)) {
             this.reopenAdmission();
             return "blocked";
           }
@@ -255937,14 +256269,18 @@ var init_UpdateService = __esm({
           lastError: this.lastError
         };
       }
-      async restartToUpdate() {
-        const stagedVersion = this.stager.stagedVersion();
-        if (stagedVersion === null) {
+      async restartToUpdate(options = {}) {
+        const stagedVersion2 = this.stager.stagedVersion();
+        if (stagedVersion2 === null) {
           return "blocked";
         }
         try {
-          if (this.requestUpdate) {
-            return await this.activationGate.tryActivate(() => this.requestUpdate("client_request"));
+          const requestUpdate = this.requestUpdate;
+          if (requestUpdate) {
+            return await this.activationGate.tryActivate(
+              () => requestUpdate("client_request"),
+              options
+            );
           }
         } catch (error52) {
           this.lastError = error52 instanceof Error ? error52.message : String(error52);
@@ -255963,8 +256299,8 @@ var init_UpdateService = __esm({
           const manifest = parseReleaseManifest(rawManifest);
           this.lastCheckedAt = this.now().toISOString();
           this.lastError = null;
-          const stagedVersion = this.stager.stagedVersion();
-          if (stagedVersion !== null) {
+          const stagedVersion2 = this.stager.stagedVersion();
+          if (stagedVersion2 !== null) {
             return "staged";
           }
           if (!isUpgrade(manifest, this.currentVersion)) {
@@ -256019,6 +256355,11 @@ function pruneOldVersions(configHome, keep) {
   if (keep.running) {
     protectedVersions.add(keep.running);
   }
+  if (keep.protect) {
+    for (const version3 of keep.protect) {
+      protectedVersions.add(version3);
+    }
+  }
   const extra = Number.isFinite(keep.extra) ? Math.max(0, Math.floor(keep.extra)) : 0;
   const candidates = retainedApplicationVersions(configHome).filter(isVersion).filter((version3) => !protectedVersions.has(version3));
   const removed = [];
@@ -256044,6 +256385,13 @@ var init_VersionRetention = __esm({
 });
 
 // src/server/update/UpdateStager.ts
+function replayObserver(callback) {
+  try {
+    callback();
+  } catch {
+    return;
+  }
+}
 function isWithin3(parent, child) {
   const relative9 = path55.relative(path55.resolve(parent), path55.resolve(child));
   return relative9 === "" || !relative9.startsWith(`..${path55.sep}`) && relative9 !== "..";
@@ -256134,6 +256482,8 @@ var init_UpdateStager = __esm({
     SEMVER_PATTERN3 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
     UpdateStager = class {
       constructor(options) {
+        this.stagedInProcess = /* @__PURE__ */ new Set();
+        this.inFlight = null;
         this.configHome = options.configHome;
         this.currentVersion = options.currentVersion;
         this.downloadDir = options.downloadDir ?? os9.tmpdir();
@@ -256185,6 +256535,59 @@ var init_UpdateStager = __esm({
         return highest;
       }
       async stage(manifest, observer) {
+        while (this.inFlight !== null) {
+          const flight2 = this.inFlight;
+          if (flight2.version === manifest.version) {
+            try {
+              return await flight2.promise;
+            } finally {
+              const verification = flight2.verification;
+              if (flight2.downloaded) {
+                replayObserver(() => observer?.downloaded());
+              }
+              if (verification !== void 0) {
+                replayObserver(() => observer?.verification(verification));
+              }
+            }
+          }
+          try {
+            await flight2.promise;
+          } catch {
+            continue;
+          }
+        }
+        const progress = {
+          downloaded: false,
+          verification: void 0
+        };
+        const operation = this.performStage(manifest, {
+          downloaded: () => {
+            progress.downloaded = true;
+            observer?.downloaded();
+          },
+          verification: (outcome) => {
+            progress.verification = outcome;
+            observer?.verification(outcome);
+          }
+        });
+        const flight = {
+          version: manifest.version,
+          get downloaded() {
+            return progress.downloaded;
+          },
+          get verification() {
+            return progress.verification;
+          },
+          promise: operation.finally(() => {
+            if (this.inFlight === flight) {
+              this.inFlight = null;
+            }
+          })
+        };
+        this.inFlight = flight;
+        return flight.promise;
+      }
+      async performStage(manifest, observer) {
         const platform2 = currentPlatformKey();
         const artifact = selectArtifact(manifest, platform2);
         if (!artifact) {
@@ -256226,11 +256629,13 @@ var init_UpdateStager = __esm({
           const sourceEntry = findPayloadEntry(extractedPath);
           const minClientProtocol = this.readMinClientProtocol(path55.dirname(sourceEntry));
           const installed3 = this.install(manifest.version, sourceEntry);
+          this.stagedInProcess.add(installed3.version);
           const active = this.readActive();
           const running = this.runningVersion();
           pruneOldVersions(this.configHome, {
             ...active ? { active } : {},
             ...running ? { running } : {},
+            protect: Array.from(this.stagedInProcess),
             extra: 1
           });
           return {
@@ -258264,7 +258669,7 @@ function probeSharedDaemonOnce(port, timeoutMs, expected) {
       settled = true;
       resolve15(outcome);
     };
-    const request3 = http.get(
+    const request4 = http.get(
       {
         host: "127.0.0.1",
         port,
@@ -258298,18 +258703,18 @@ function probeSharedDaemonOnce(port, timeoutMs, expected) {
         response.on("close", () => settle2({ kind: "connection-lost" }));
       }
     );
-    request3.on("timeout", () => {
-      request3.destroy();
+    request4.on("timeout", () => {
+      request4.destroy();
       settle2({ kind: "timeout" });
     });
-    request3.on("error", (err) => {
+    request4.on("error", (err) => {
       settle2({ kind: err.code === "ECONNREFUSED" ? "refused" : "connection-lost" });
     });
   });
 }
 function isTokenAccepted(port, token, timeoutMs) {
   return new Promise((resolve15) => {
-    const request3 = http.get(
+    const request4 = http.get(
       {
         host: "127.0.0.1",
         port,
@@ -258322,11 +258727,11 @@ function isTokenAccepted(port, token, timeoutMs) {
         resolve15(response.statusCode !== 401 && response.statusCode !== 403);
       }
     );
-    request3.on("timeout", () => {
-      request3.destroy();
+    request4.on("timeout", () => {
+      request4.destroy();
       resolve15(true);
     });
-    request3.on("error", () => resolve15(true));
+    request4.on("error", () => resolve15(true));
   });
 }
 
@@ -258535,7 +258940,7 @@ async function uninstallCommand(deps = {}) {
     }
   }
   const launcher = platformLauncherPath2(platform2, configHome);
-  const unit = unitFor(platform2, launcher, configHome, nodePath);
+  const unit = unitFor(platform2, launcher, configHome, nodePath, process.env);
   const grainCommand = path30.join(configHome, "bin", platform2 === "win32" ? "grain.cmd" : "grain");
   const ownedPaths = [
     grainCommand,
@@ -258861,7 +259266,7 @@ async function openCommand(configDir = resolveGrainHome(), runner = createComman
   ]);
   if (result.exitCode !== 0) {
     console.error(
-      `Opening a browser failed. Run \`grain ui --url\` and paste the link it prints into any browser.`
+      `Opening a browser failed for ${cleanUrl}. Run \`grain ui --url\` and paste the link it prints into any browser.`
     );
     return 1;
   }
@@ -258878,6 +259283,7 @@ init_supervisedStart();
 
 // src/server/cli/toolCommands.ts
 var fs30 = __toESM(require("fs"));
+init_callPolicy();
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
 init_protocol();
@@ -259035,8 +259441,8 @@ var ExperimentalClientTasks = class {
    *
    * @experimental
    */
-  requestStream(request3, resultSchema, options) {
-    return this._client.requestStream(request3, resultSchema, options);
+  requestStream(request4, resultSchema, options) {
+    return this._client.requestStream(request4, resultSchema, options);
   }
 };
 
@@ -259167,8 +259573,8 @@ var Client = class extends Protocol {
     }
     const method = methodValue;
     if (method === "elicitation/create") {
-      const wrappedHandler = async (request3, extra) => {
-        const validatedRequest = safeParse3(ElicitRequestSchema, request3);
+      const wrappedHandler = async (request4, extra) => {
+        const validatedRequest = safeParse3(ElicitRequestSchema, request4);
         if (!validatedRequest.success) {
           const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
           throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
@@ -259182,7 +259588,7 @@ var Client = class extends Protocol {
         if (params.mode === "url" && !supportsUrlMode) {
           throw new McpError(ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
         }
-        const result = await Promise.resolve(handler(request3, extra));
+        const result = await Promise.resolve(handler(request4, extra));
         if (params.task) {
           const taskValidationResult = safeParse3(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
@@ -259211,14 +259617,14 @@ var Client = class extends Protocol {
       return super.setRequestHandler(requestSchema, wrappedHandler);
     }
     if (method === "sampling/createMessage") {
-      const wrappedHandler = async (request3, extra) => {
-        const validatedRequest = safeParse3(CreateMessageRequestSchema, request3);
+      const wrappedHandler = async (request4, extra) => {
+        const validatedRequest = safeParse3(CreateMessageRequestSchema, request4);
         if (!validatedRequest.success) {
           const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
           throw new McpError(ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
         }
         const { params } = validatedRequest.data;
-        const result = await Promise.resolve(handler(request3, extra));
+        const result = await Promise.resolve(handler(request4, extra));
         if (params.task) {
           const taskValidationResult = safeParse3(CreateTaskResultSchema, result);
           if (!taskValidationResult.success) {
@@ -259589,7 +259995,7 @@ async function callTool(name, args, deps = {}) {
 }
 
 // src/server/cli/toolCommands.ts
-var TOOL_COMMANDS = [
+var ALL_TOOL_COMMANDS = [
   { words: ["connectors"], tool: "list_connectors", usage: "connectors" },
   { words: ["connections", "list"], tool: "list_connections", usage: "connections list" },
   {
@@ -259693,6 +260099,9 @@ var TOOL_COMMANDS = [
   { words: ["ledger", "stats"], tool: "ledger_stats", usage: "ledger stats" },
   { words: ["ledger", "verify"], tool: "verify_ledger", usage: "ledger verify" }
 ];
+var TOOL_COMMANDS = ALL_TOOL_COMMANDS.filter(
+  (command) => alphaToolEnabled(command.tool)
+);
 var DATA_COMMAND_WORDS = new Set(TOOL_COMMANDS.map((command) => command.words[0]));
 function dataCommandHelp() {
   return TOOL_COMMANDS.map((command) => `  ${command.usage}`).join("\n");