grain-tools 0.10.12 → 0.10.14

package/out/server/standalone.js

@@ -206,11 +206,12 @@ function classifyRecordInstance(record2, status, nowMs) {
   const processStartedAt = nowMs - status.uptime * 1e3;
   return Math.abs(publishedAt - processStartedAt) <= RECORD_INSTANCE_START_SKEW_MS ? "match" : "mismatch";
 }
-var DAEMON_SERVICE_IDENTITY, DAEMON_SERVICE_IDENTITY_IPC, DAEMON_SERVICE_IDENTITY_STDIO, MCP_SERVICE_IDENTITY, RECORD_INSTANCE_START_SKEW_MS;
+var DAEMON_SERVICE_IDENTITY, GRAIN_SERVICE_LABEL, DAEMON_SERVICE_IDENTITY_IPC, DAEMON_SERVICE_IDENTITY_STDIO, MCP_SERVICE_IDENTITY, RECORD_INSTANCE_START_SKEW_MS;
 var init_daemonRecordInstance = __esm({
   "src/common/daemonRecordInstance.ts"() {
     "use strict";
     DAEMON_SERVICE_IDENTITY = "grain-daemon";
+    GRAIN_SERVICE_LABEL = `tools.${DAEMON_SERVICE_IDENTITY}`;
     DAEMON_SERVICE_IDENTITY_IPC = `${DAEMON_SERVICE_IDENTITY}-ipc`;
     DAEMON_SERVICE_IDENTITY_STDIO = `${DAEMON_SERVICE_IDENTITY}-stdio`;
     MCP_SERVICE_IDENTITY = "grain-mcp";
@@ -19277,13 +19278,40 @@ var init_StdioBridge = __esm({
         }
       }
       async forwardAgentMessage(message, fatal) {
+        const isInitialize = "method" in message && message.method === "initialize";
+        if (!this.initializeRequest && !isInitialize) {
+          if ("method" in message && "id" in message) {
+            await this.options.agentTransport.send({
+              jsonrpc: "2.0",
+              id: message.id,
+              error: {
+                code: -32601,
+                message: `Method not found: ${message.method}. This server speaks MCP 2025-11-25; open a session with initialize.`
+              }
+            }).catch(() => void 0);
+          }
+          return;
+        }
+        const isHandshake = isInitialize || "method" in message && message.method === "notifications/initialized";
+        if (!isInitialize && this.sessionOpening) {
+          await this.sessionOpening;
+        }
         if (this.reconnecting) {
-          this.queuedAgentMessages.push(message);
+          if (!isHandshake) {
+            this.queuedAgentMessages.push(message);
+          }
           return;
         }
+        const sending = this.daemonTransport.send(message);
+        if (isInitialize) {
+          this.sessionOpening = sending.catch(() => void 0);
+        }
         try {
-          await this.daemonTransport.send(message);
+          await sending;
         } catch {
+          if (!isHandshake) {
+            this.queuedAgentMessages.push(message);
+          }
           void this.reconnect(fatal);
         }
       }
@@ -19462,6 +19490,48 @@ var init_DaemonAuthToken = __esm({
   }
 });
 
+// src/common/serviceMode.ts
+function serviceModePath(configDir) {
+  return path7.join(configDir, SERVICE_MODE_FILENAME);
+}
+function writeServiceMode(fileSystem, configDir, record2) {
+  fileSystem.writeFileSync(serviceModePath(configDir), `${JSON.stringify(record2, null, 2)}
+`, {
+    mode: 384
+  });
+}
+function readServiceModeStatus(configDir) {
+  let raw;
+  try {
+    raw = fs5.readFileSync(serviceModePath(configDir), "utf8");
+  } catch {
+    return { type: "missing" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { type: "unparseable" };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { type: "malformed" };
+  }
+  const r = parsed;
+  if (r["mode"] !== "spawn-on-demand") {
+    return { type: "malformed" };
+  }
+  return { type: "valid", record: r };
+}
+var fs5, path7, SERVICE_MODE_FILENAME;
+var init_serviceMode = __esm({
+  "src/common/serviceMode.ts"() {
+    "use strict";
+    fs5 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
+    SERVICE_MODE_FILENAME = "service-mode.json";
+  }
+});
+
 // src/common/localUrl.ts
 function formatUserFacingLocalUrl(host, port) {
   const displayHost = host === "127.0.0.1" || host === "::1" ? "localhost" : host;
@@ -19481,7 +19551,7 @@ async function readGrainServiceStatus(configDir = resolveGrainHome()) {
     let reason = "";
     switch (endpoint.type) {
       case "missing":
-        reason = GRAIN_NOT_INSTALLED_MESSAGE;
+        reason = readServiceModeStatus(configDir).type === "valid" ? GRAIN_STARTS_ON_DEMAND_MESSAGE : GRAIN_NOT_INSTALLED_MESSAGE;
         break;
       case "unparseable":
         reason = "Grain's note of where it is listening is damaged, so it cannot be reached. Run `grain install` to rewrite it.";
@@ -19541,15 +19611,17 @@ async function statusCommand() {
   console.log(JSON.stringify(await readGrainServiceStatus(), null, 2));
   return 0;
 }
-var http2;
+var http2, GRAIN_STARTS_ON_DEMAND_MESSAGE;
 var init_statusCommand = __esm({
   "src/server/cli/statusCommand.ts"() {
     "use strict";
     http2 = __toESM(require("http"));
     init_daemonEndpointFile();
     init_grainHome();
+    init_serviceMode();
     init_daemonRecordInstance();
     init_localUrl();
+    GRAIN_STARTS_ON_DEMAND_MESSAGE = "Grain is set up to start when needed on this machine and is not running right now. Run `grain start` to start it.";
   }
 });
 
@@ -19576,6 +19648,206 @@ var init_firstValueStep = __esm({
   }
 });
 
+// src/common/toolProfiles.ts
+function toolRuleFor(profile, tool) {
+  return profile.policy?.rules?.[TOOL_RESOURCE_CLASS[tool]] ?? "allow";
+}
+function toolRefusalMessage(profile, tool) {
+  return `Tool '${tool}' is not permitted for the '${profile.name}' profile: its resource class '${TOOL_RESOURCE_CLASS[tool]}' is refused by policy. The tool exists and is advertised; this call was declined, not lost.`;
+}
+function toolRefusalResult(profile, tool) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: toolRefusalMessage(profile, tool) }],
+    structuredContent: { errorKind: "permission", errorId: "tool_not_permitted_for_profile" }
+  };
+}
+function refuseIfNotPermitted(profile, tool) {
+  const name = tool;
+  if (TOOL_RESOURCE_CLASS[name] === void 0)
+    return void 0;
+  if (toolRuleFor(profile, name) === "allow")
+    return void 0;
+  return toolRefusalResult(profile, name);
+}
+function isToolProfileName(value) {
+  return value === "vscode" || value === "headless" || value === "readonly" || value === "agent";
+}
+function operatorProfileOverride(onUnknownEnvValue) {
+  const fromEnv = process.env["MCP_PROFILE"];
+  if (fromEnv === void 0)
+    return void 0;
+  if (isToolProfileName(fromEnv))
+    return TOOL_PROFILES[fromEnv];
+  onUnknownEnvValue?.(fromEnv);
+  return void 0;
+}
+function resolveToolProfile(explicit, onUnknownEnvValue) {
+  if (explicit) {
+    return TOOL_PROFILES[explicit];
+  }
+  const fromEnv = process.env["MCP_PROFILE"];
+  if (fromEnv !== void 0) {
+    if (isToolProfileName(fromEnv)) {
+      return TOOL_PROFILES[fromEnv];
+    }
+    onUnknownEnvValue?.(fromEnv);
+  }
+  return TOOL_PROFILES.vscode;
+}
+function isSafeModeActive(profile, liveSafeMode) {
+  return profile.forceSafeMode || liveSafeMode;
+}
+function toolNamesForProfile(profile) {
+  const cached2 = toolNameSets.get(profile);
+  if (cached2)
+    return cached2;
+  const names = new Set(profile.tools);
+  toolNameSets.set(profile, names);
+  return names;
+}
+function composeToolProfiles(...profiles) {
+  const present = profiles.filter((p) => p !== void 0);
+  if (present.length === 0)
+    return TOOL_PROFILES.vscode;
+  if (present.length === 1)
+    return present[0];
+  const sets = present.map((p) => new Set(p.tools));
+  const rules = {};
+  for (const p of present) {
+    for (const [cls, rule] of Object.entries(p.policy?.rules ?? {})) {
+      if (rule === "refuse")
+        rules[cls] = "refuse";
+    }
+  }
+  const refusalCount = (p) => Object.keys(p.policy?.rules ?? {}).length;
+  const narrowest = present.reduce((a, b) => {
+    if (b.tools.length !== a.tools.length)
+      return b.tools.length < a.tools.length ? b : a;
+    return refusalCount(b) > refusalCount(a) ? b : a;
+  });
+  return {
+    name: narrowest.name,
+    tools: ALL_TOOLS.filter((tool) => sets.every((s) => s.has(tool))),
+    forceSafeMode: present.some((p) => p.forceSafeMode),
+    ...Object.keys(rules).length > 0 ? { policy: { rules } } : {}
+  };
+}
+function createToolProfileResolver(explicit, onUnknownEnvValue) {
+  const defaultProfile = resolveToolProfile(explicit, onUnknownEnvValue);
+  const pinned = explicit === void 0 ? void 0 : TOOL_PROFILES[explicit];
+  const fromEnv = operatorProfileOverride(onUnknownEnvValue);
+  return {
+    defaultProfile,
+    forCall(profile) {
+      const declared = profile === void 0 ? void 0 : TOOL_PROFILES[profile];
+      if (pinned === void 0 && fromEnv === void 0 && declared === void 0) {
+        return defaultProfile;
+      }
+      return composeToolProfiles(pinned, fromEnv, declared);
+    }
+  };
+}
+var ALL_TOOLS, READ_ONLY_TOOLS, TOOL_RESOURCE_CLASS, TOOL_PROFILES, WEB_PROXIED_TOOLS, toolNameSets;
+var init_toolProfiles = __esm({
+  "src/common/toolProfiles.ts"() {
+    "use strict";
+    ALL_TOOLS = [
+      "list_connectors",
+      "run_query",
+      "get_tab_info",
+      "list_sessions",
+      "list_connections",
+      "save_connection",
+      "request_connection_credentials",
+      "test_connection",
+      "delete_connection",
+      "list_schemas",
+      "list_tables",
+      "describe_table",
+      "cancel_query",
+      "close_tab",
+      "render_chart",
+      "save_chart",
+      "list_charts",
+      "ledger_stats",
+      "verify_ledger",
+      "record_ui_event"
+    ];
+    READ_ONLY_TOOLS = [
+      "list_connectors",
+      "run_query",
+      "get_tab_info",
+      "list_sessions",
+      "list_connections",
+      "test_connection",
+      "list_schemas",
+      "list_tables",
+      "describe_table",
+      "cancel_query",
+      "close_tab",
+      "render_chart",
+      "list_charts",
+      "ledger_stats",
+      "verify_ledger",
+      "record_ui_event"
+    ];
+    TOOL_RESOURCE_CLASS = {
+      list_connectors: "read",
+      list_connections: "read",
+      list_sessions: "read",
+      get_tab_info: "read",
+      list_schemas: "read",
+      list_tables: "read",
+      describe_table: "read",
+      list_charts: "read",
+      ledger_stats: "read",
+      verify_ledger: "read",
+      test_connection: "read",
+      cancel_query: "session",
+      close_tab: "session",
+      render_chart: "session",
+      run_query: "query",
+      save_connection: "connection-config",
+      delete_connection: "connection-config",
+      request_connection_credentials: "credential",
+      save_chart: "workspace-write",
+      record_ui_event: "app-telemetry"
+    };
+    TOOL_PROFILES = {
+      // Human-in-the-loop VS Code surface: full toolset, safe mode from settings.
+      vscode: { name: "vscode", tools: ALL_TOOLS, forceSafeMode: false },
+      // Autonomous agents: starts as the full current toolset (RFC-062); will
+      // diverge toward synchronous/structured tools without breaking clients.
+      headless: { name: "headless", tools: ALL_TOOLS, forceSafeMode: false },
+      // Safe exploration: no profile/credential mutation, SQL gating always on.
+      readonly: { name: "readonly", tools: READ_ONLY_TOOLS, forceSafeMode: true },
+      // RFC-134: intended as the default for an attached AI agent surface — may read,
+      // query and chart, may not change saved connections or ask for stored credentials.
+      // This profile is assigned to the local agent identity and enforced on the stdio bridge.
+      // End-to-end enforcement is proven by the 'bridged client (agent profile) is permitted
+      // read tools but refused config/credential tools' test in stdio_bridge.test.ts.
+      // SQL restriction is deliberately not forced here: `grain.mcpSafeMode`
+      // already defaults to on, and a ceiling would make that setting silently stop
+      // working for the recommended agent path.
+      agent: {
+        name: "agent",
+        tools: ALL_TOOLS,
+        forceSafeMode: false,
+        policy: { rules: { "connection-config": "refuse", credential: "refuse" } }
+      }
+    };
+    WEB_PROXIED_TOOLS = [
+      "list_connectors",
+      "list_connections",
+      "save_connection",
+      "test_connection",
+      "delete_connection"
+    ];
+    toolNameSets = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // src/common/telemetry/TelemetrySchema.ts
 function isTelemetryEventName(value) {
   return EVENT_SET.has(value);
@@ -19601,6 +19873,38 @@ function normalizeTelemetryConnector(value) {
 function isTelemetryErrorCode(value) {
   return typeof value === "string" && ERROR_CODE_SET.has(value);
 }
+function normalizeTelemetryDiagnosticErrorCode(value) {
+  const text = typeof value === "number" && Number.isFinite(value) ? String(value) : value;
+  return typeof text === "string" && /^[A-Za-z0-9_.-]{1,32}$/.test(text) ? text : void 0;
+}
+function normalizeTelemetryDiagnosticErrorClass(value) {
+  return typeof value === "string" && /^[A-Za-z][A-Za-z0-9_]{0,63}$/.test(value) ? value : void 0;
+}
+function diagnosticErrorCodeOf(error52) {
+  if (error52 === null || typeof error52 !== "object") {
+    return void 0;
+  }
+  const record2 = error52;
+  const code = normalizeTelemetryDiagnosticErrorCode(record2.code);
+  if (code) {
+    return code;
+  }
+  if (record2.cause === null || typeof record2.cause !== "object") {
+    return void 0;
+  }
+  return normalizeTelemetryDiagnosticErrorCode(record2.cause.code);
+}
+function diagnosticErrorClassOf(error52) {
+  if (error52 === null || typeof error52 !== "object") {
+    return void 0;
+  }
+  const record2 = error52;
+  const constructorName = normalizeTelemetryDiagnosticErrorClass(record2.constructor?.name);
+  if (constructorName && constructorName !== "Error" && constructorName !== "Object") {
+    return constructorName;
+  }
+  return normalizeTelemetryDiagnosticErrorClass(record2.name) ?? constructorName;
+}
 function normalizeTelemetryToolName(value) {
   return value && TOOL_NAME_SET.has(value) ? value : "unknown";
 }
@@ -19770,6 +20074,10 @@ function sanitizeTelemetryProperty(rule, value) {
       return typeof value === "string" && DISCOVERY_KEY_PATTERN.test(value) ? value : void 0;
     case "errorCode":
       return typeof value === "string" && ERROR_CODE_SET.has(value) ? value : void 0;
+    case "diagnosticErrorCode":
+      return normalizeTelemetryDiagnosticErrorCode(value);
+    case "diagnosticErrorClass":
+      return normalizeTelemetryDiagnosticErrorClass(value);
     case "loopExecutor":
       return typeof value === "string" && LOOP_EXECUTOR_SET.has(value) ? value : void 0;
     case "mcpClient":
@@ -19822,6 +20130,8 @@ function sanitizeTelemetryProperty(rule, value) {
       return typeof value === "string" && TOOL_NAME_SET.has(value) ? value : void 0;
     case "uiAction":
       return typeof value === "string" && UI_ACTION_SET.has(value) ? value : void 0;
+    case "uiActionOutcome":
+      return typeof value === "string" && UI_ACTION_OUTCOME_SET.has(value) ? value : void 0;
     case "version":
       return typeof value === "string" && VERSION_PATTERN.test(value) ? value : void 0;
     case "firstValueStep":
@@ -19830,12 +20140,13 @@ function sanitizeTelemetryProperty(rule, value) {
       return isFirstValueOutcome(value) ? value : void 0;
   }
 }
-var TELEMETRY_SCHEMA_VERSION, TELEMETRY_EVENTS, REQUEST_ORIGINS, REQUEST_ORIGIN_SET, TELEMETRY_RESOURCE_KINDS, TELEMETRY_MCP_CLIENTS, MCP_CLIENT_SET, TELEMETRY_UI_ACTIONS, UI_ACTION_SET, TELEMETRY_CONNECTORS, TELEMETRY_TOOL_NAMES, TELEMETRY_COMMAND_IDS, TELEMETRY_PLATFORMS, TELEMETRY_SURFACES, TELEMETRY_STATES, TELEMETRY_SOURCES, TELEMETRY_STATUS_REASONS, TELEMETRY_STATEMENT_TYPES, TELEMETRY_DURATION_BUCKETS, TELEMETRY_ROW_COUNT_BUCKETS, TELEMETRY_COLUMN_COUNT_BUCKETS, TELEMETRY_QUERY_LENGTH_BUCKETS, TELEMETRY_SELECTION_MODES, TELEMETRY_TAB_MODES, TELEMETRY_ERROR_CODES, TELEMETRY_LOOP_EXECUTORS, TELEMETRY_ERROR_IDS, TELEMETRY_ERROR_KINDS, TELEMETRY_FLAG_KEYS, TELEMETRY_ACQUISITION_CHANNELS, TELEMETRY_FLAG_SOURCES, TELEMETRY_FLAG_REASONS, COMMON_PROPERTY_RULES, EVENT_PROPERTY_RULES, EVENT_SET, COMMAND_ID_SET, PLATFORM_SET, SURFACE_SET, STATE_SET, SOURCE_SET, STATUS_REASON_SET, STATEMENT_TYPE_SET, DURATION_BUCKET_SET, ROW_COUNT_BUCKET_SET, COLUMN_COUNT_BUCKET_SET, QUERY_LENGTH_BUCKET_SET, SELECTION_MODE_SET, TAB_MODE_SET, RESOURCE_KIND_SET, ERROR_KIND_SET, ERROR_ID_SET, ERROR_CODE_SET, LOOP_EXECUTOR_SET, CONNECTOR_SET, TOOL_NAME_SET, FLAG_KEY_SET, FLAG_SOURCE_SET, FLAG_REASON_SET, ACQUISITION_CHANNEL_SET, UUID_PATTERN, SAFE_STRING_PATTERN, VERSION_PATTERN, DISCOVERY_KEY_PATTERN, DIGITS_PATTERN, CRASH_KIND_SET, MCP_ERROR_PHASE_SET, SERVICE_LIFECYCLE_PHASE_SET, SERVICE_LIFECYCLE_OUTCOME_SET;
+var TELEMETRY_SCHEMA_VERSION, TELEMETRY_EVENTS, REQUEST_ORIGINS, REQUEST_ORIGIN_SET, TELEMETRY_RESOURCE_KINDS, TELEMETRY_MCP_CLIENTS, MCP_CLIENT_SET, TELEMETRY_UI_ACTIONS, UI_ACTION_SET, UI_ACTION_OUTCOME_SET, TELEMETRY_CONNECTORS, TELEMETRY_TOOL_NAMES, TELEMETRY_COMMAND_IDS, TELEMETRY_PLATFORMS, TELEMETRY_SURFACES, TELEMETRY_STATES, TELEMETRY_SOURCES, TELEMETRY_STATUS_REASONS, TELEMETRY_STATEMENT_TYPES, TELEMETRY_DURATION_BUCKETS, TELEMETRY_ROW_COUNT_BUCKETS, TELEMETRY_COLUMN_COUNT_BUCKETS, TELEMETRY_QUERY_LENGTH_BUCKETS, TELEMETRY_SELECTION_MODES, TELEMETRY_TAB_MODES, TELEMETRY_ERROR_CODES, TELEMETRY_LOOP_EXECUTORS, TELEMETRY_ERROR_IDS, TELEMETRY_ERROR_KINDS, TELEMETRY_FLAG_KEYS, TELEMETRY_ACQUISITION_CHANNELS, TELEMETRY_FLAG_SOURCES, TELEMETRY_FLAG_REASONS, COMMON_PROPERTY_RULES, EVENT_PROPERTY_RULES, EVENT_SET, COMMAND_ID_SET, PLATFORM_SET, SURFACE_SET, STATE_SET, SOURCE_SET, STATUS_REASON_SET, STATEMENT_TYPE_SET, DURATION_BUCKET_SET, ROW_COUNT_BUCKET_SET, COLUMN_COUNT_BUCKET_SET, QUERY_LENGTH_BUCKET_SET, SELECTION_MODE_SET, TAB_MODE_SET, RESOURCE_KIND_SET, ERROR_KIND_SET, ERROR_ID_SET, ERROR_CODE_SET, LOOP_EXECUTOR_SET, CONNECTOR_SET, TOOL_NAME_SET, FLAG_KEY_SET, FLAG_SOURCE_SET, FLAG_REASON_SET, ACQUISITION_CHANNEL_SET, UUID_PATTERN, SAFE_STRING_PATTERN, VERSION_PATTERN, DISCOVERY_KEY_PATTERN, DIGITS_PATTERN, CRASH_KIND_SET, MCP_ERROR_PHASE_SET, SERVICE_LIFECYCLE_PHASE_SET, SERVICE_LIFECYCLE_OUTCOME_SET;
 var init_TelemetrySchema = __esm({
   "src/common/telemetry/TelemetrySchema.ts"() {
     "use strict";
     init_firstValueStep();
-    TELEMETRY_SCHEMA_VERSION = "2.6";
+    init_toolProfiles();
+    TELEMETRY_SCHEMA_VERSION = "2.7";
     TELEMETRY_EVENTS = [
       "extension_activated",
       "command_invoked",
@@ -19886,8 +20197,16 @@ var init_TelemetrySchema = __esm({
       "unknown"
     ];
     MCP_CLIENT_SET = new Set(TELEMETRY_MCP_CLIENTS);
-    TELEMETRY_UI_ACTIONS = ["sort", "filter", "export", "tab_switch"];
+    TELEMETRY_UI_ACTIONS = [
+      "sort",
+      "filter",
+      "export",
+      "tab_switch",
+      "run_query",
+      "connection_created"
+    ];
     UI_ACTION_SET = new Set(TELEMETRY_UI_ACTIONS);
+    UI_ACTION_OUTCOME_SET = /* @__PURE__ */ new Set(["success", "error"]);
     TELEMETRY_CONNECTORS = [
       "trino",
       "postgres",
@@ -19902,29 +20221,7 @@ var init_TelemetrySchema = __esm({
       "custom",
       "unknown"
     ];
-    TELEMETRY_TOOL_NAMES = [
-      "list_connectors",
-      "run_query",
-      "get_tab_info",
-      "list_sessions",
-      "list_connections",
-      "save_connection",
-      "request_connection_credentials",
-      "test_connection",
-      "delete_connection",
-      "list_schemas",
-      "list_tables",
-      "describe_table",
-      "cancel_query",
-      "close_tab",
-      "render_chart",
-      "save_chart",
-      "list_charts",
-      "ledger_stats",
-      "verify_ledger",
-      "record_ui_event",
-      "unknown"
-    ];
+    TELEMETRY_TOOL_NAMES = [...ALL_TOOLS, "unknown"];
     TELEMETRY_COMMAND_IDS = [
       "grain.showDaemonInfo",
       "grain.mcp.restart",
@@ -19967,6 +20264,7 @@ var init_TelemetrySchema = __esm({
       "extension_host",
       "onboarding",
       "query_editor",
+      "workspace_ready",
       "connection_manager",
       "connection_form",
       "results_grid",
@@ -20302,6 +20600,7 @@ var init_TelemetrySchema = __esm({
       "connection_save_unknown",
       /** The supervisor rejected registration of the installed service. */
       "service_supervisor_registration_failed",
+      "service_runtime_provision_failed",
       /** The supervisor rejected starting the installed service. */
       "service_supervisor_start_failed",
       /** The supervisor accepted the service, but it never published a reachable endpoint. */
@@ -20427,6 +20726,8 @@ var init_TelemetrySchema = __esm({
         success: "boolean",
         duration_bucket: "durationBucket",
         error_kind: "errorKind",
+        error_code: "diagnosticErrorCode",
+        error_class: "diagnosticErrorClass",
         error_id: "errorId",
         connector: "connector"
       },
@@ -20473,7 +20774,11 @@ var init_TelemetrySchema = __esm({
         duration_bucket: "durationBucket",
         error_kind: "errorKind"
       },
-      ledger_health: { entries_bucket: "rowCountBucket", write_failures_bucket: "rowCountBucket" },
+      ledger_health: {
+        entries_bucket: "rowCountBucket",
+        write_failures_bucket: "rowCountBucket",
+        outcome: "safeString"
+      },
       ledger_verify_completed: {
         outcome: "safeString",
         entries_checked_bucket: "rowCountBucket",
@@ -20508,7 +20813,8 @@ var init_TelemetrySchema = __esm({
       },
       ui_state_shown: {},
       ui_action_performed: {
-        ui_action: "uiAction"
+        ui_action: "uiAction",
+        outcome: "uiActionOutcome"
       },
       first_value_step: {
         step: "firstValueStep",
@@ -20908,7 +21214,7 @@ var init_TelemetryEmitter = __esm({
 
 // src/common/telemetryConsent.ts
 function telemetryConsentPath(configDir) {
-  return path9.join(configDir, TELEMETRY_CONSENT_FILENAME);
+  return path10.join(configDir, TELEMETRY_CONSENT_FILENAME);
 }
 function writeTelemetryConsent(fileSystem, configDir, record2) {
   const targetPath = telemetryConsentPath(configDir);
@@ -20928,7 +21234,7 @@ function writeTelemetryConsent(fileSystem, configDir, record2) {
 function readTelemetryConsentStatus(configDir) {
   let raw;
   try {
-    raw = fs7.readFileSync(telemetryConsentPath(configDir), "utf8");
+    raw = fs8.readFileSync(telemetryConsentPath(configDir), "utf8");
   } catch {
     return { type: "missing" };
   }
@@ -20964,12 +21270,12 @@ function readTelemetryConsentStatus(configDir) {
     }
   };
 }
-var fs7, path9, TELEMETRY_CONSENT_FILENAME;
+var fs8, path10, TELEMETRY_CONSENT_FILENAME;
 var init_telemetryConsent = __esm({
   "src/common/telemetryConsent.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
+    fs8 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
     TELEMETRY_CONSENT_FILENAME = "telemetry-consent.json";
   }
 });
@@ -20979,7 +21285,7 @@ function isAcquisitionChannel(value) {
   return typeof value === "string" && ACQUISITION_CHANNEL_SET2.has(value);
 }
 function acquisitionChannelPath(configDir) {
-  return path10.join(configDir, ACQUISITION_CHANNEL_FILENAME);
+  return path11.join(configDir, ACQUISITION_CHANNEL_FILENAME);
 }
 function acquisitionChannelFromEnvironment(env2) {
   const channel = env2["GRAIN_ACQUISITION_CHANNEL"];
@@ -20996,7 +21302,7 @@ function writeAcquisitionChannel(fileSystem, configDir, record2) {
 function readAcquisitionChannelStatus(configDir) {
   let raw;
   try {
-    raw = fs8.readFileSync(acquisitionChannelPath(configDir), "utf8");
+    raw = fs9.readFileSync(acquisitionChannelPath(configDir), "utf8");
   } catch {
     return { type: "missing" };
   }
@@ -21015,12 +21321,12 @@ function readAcquisitionChannelStatus(configDir) {
   }
   return { type: "valid", record: { channel: record2["channel"] } };
 }
-var fs8, path10, ACQUISITION_CHANNEL_FILENAME, ACQUISITION_CHANNELS, ACQUISITION_CHANNEL_SET2;
+var fs9, path11, ACQUISITION_CHANNEL_FILENAME, ACQUISITION_CHANNELS, ACQUISITION_CHANNEL_SET2;
 var init_acquisitionChannel = __esm({
   "src/common/acquisitionChannel.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
     ACQUISITION_CHANNEL_FILENAME = "acquisition-channel.json";
     ACQUISITION_CHANNELS = ["marketplace", "open_vsx", "cli"];
     ACQUISITION_CHANNEL_SET2 = new Set(ACQUISITION_CHANNELS);
@@ -21044,13 +21350,13 @@ function isHumanOrigin(origin2) {
 function isDaemonEmittedOrigin(origin2) {
   return origin2 !== "vscode_extension";
 }
-var crypto5, fs9, path11, INSTALL_ID_FILENAME, UUID_PATTERN2, TELEMETRY_CONSENT_REFRESH_MS, DaemonTelemetryService;
+var crypto5, fs10, path12, INSTALL_ID_FILENAME, UUID_PATTERN2, TELEMETRY_CONSENT_REFRESH_MS, DaemonTelemetryService;
 var init_DaemonTelemetryService = __esm({
   "src/server/DaemonTelemetryService.ts"() {
     "use strict";
     crypto5 = __toESM(require("crypto"));
-    fs9 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    fs10 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
     init_TelemetryEmitter();
     init_TelemetrySchema();
     init_ConsoleLogger();
@@ -21154,9 +21460,9 @@ var init_DaemonTelemetryService = __esm({
         if (this.cachedInstallId) {
           return this.cachedInstallId;
         }
-        const filePath = path11.join(this.configDir, INSTALL_ID_FILENAME);
+        const filePath = path12.join(this.configDir, INSTALL_ID_FILENAME);
         try {
-          const existing = fs9.readFileSync(filePath, "utf8").trim();
+          const existing = fs10.readFileSync(filePath, "utf8").trim();
           if (UUID_PATTERN2.test(existing)) {
             this.cachedInstallId = existing;
             return this.cachedInstallId;
@@ -21165,8 +21471,8 @@ var init_DaemonTelemetryService = __esm({
         }
         this.cachedInstallId = crypto5.randomUUID();
         try {
-          fs9.mkdirSync(this.configDir, { recursive: true });
-          fs9.writeFileSync(filePath, this.cachedInstallId, "utf8");
+          fs10.mkdirSync(this.configDir, { recursive: true });
+          fs10.writeFileSync(filePath, this.cachedInstallId, "utf8");
         } catch (e2) {
           logger.warn("[Daemon] Could not persist telemetry install ID:", e2);
         }
@@ -21193,7 +21499,7 @@ function downloadToFile(url3, destPath, options) {
   const responseTimeoutMs = options?.responseTimeoutMs ?? 1e4;
   const idleTimeoutMs = options?.idleTimeoutMs ?? 3e4;
   return new Promise((resolve11, reject) => {
-    fs10.mkdirSync(path12.dirname(destPath), { recursive: true });
+    fs11.mkdirSync(path13.dirname(destPath), { recursive: true });
     let settled = false;
     let file4;
     let responseTimeout = void 0;
@@ -21215,7 +21521,7 @@ function downloadToFile(url3, destPath, options) {
       if (file4) {
         file4.destroy();
       }
-      fs10.rm(destPath, { force: true }, () => reject(err));
+      fs11.rm(destPath, { force: true }, () => reject(err));
     };
     const client = clientFor(url3);
     const request2 = client.get(url3, (response) => {
@@ -21236,7 +21542,7 @@ function downloadToFile(url3, destPath, options) {
       };
       response.on("data", resetIdleTimeout);
       resetIdleTimeout();
-      file4 = fs10.createWriteStream(destPath);
+      file4 = fs11.createWriteStream(destPath);
       response.pipe(file4);
       response.on("error", failOnce);
       file4.on("finish", () => {
@@ -21261,7 +21567,7 @@ function downloadToFile(url3, destPath, options) {
 function sha512File(filePath) {
   return new Promise((resolve11, reject) => {
     const hash2 = crypto6.createHash("sha512");
-    const stream4 = fs10.createReadStream(filePath);
+    const stream4 = fs11.createReadStream(filePath);
     stream4.on("data", (chunk) => hash2.update(chunk));
     stream4.on("end", () => resolve11(hash2.digest("base64")));
     stream4.on("error", reject);
@@ -21270,7 +21576,7 @@ function sha512File(filePath) {
 function sha256File(filePath) {
   return new Promise((resolve11, reject) => {
     const hash2 = crypto6.createHash("sha256");
-    const stream4 = fs10.createReadStream(filePath);
+    const stream4 = fs11.createReadStream(filePath);
     stream4.on("data", (chunk) => hash2.update(chunk));
     stream4.on("end", () => resolve11(hash2.digest("hex")));
     stream4.on("error", reject);
@@ -21280,14 +21586,14 @@ function verifyIntegrity(actualBase64Sha512, expectedIntegrity) {
   const expectedBase64 = expectedIntegrity.replace(/^sha512-/, "");
   return actualBase64Sha512 === expectedBase64;
 }
-var http4, https2, fs10, path12, crypto6;
+var http4, https2, fs11, path13, crypto6;
 var init_ArtifactDownloader = __esm({
   "src/server/runtime/ArtifactDownloader.ts"() {
     "use strict";
     http4 = __toESM(require("http"));
     https2 = __toESM(require("https"));
-    fs10 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
     crypto6 = __toESM(require("crypto"));
   }
 });
@@ -21371,37 +21677,37 @@ function parseTar(buffer) {
   return entries;
 }
 async function extractTarGz(tarGzPath, destDir) {
-  const compressed = fs11.readFileSync(tarGzPath);
+  const compressed = fs12.readFileSync(tarGzPath);
   const tarBuffer = zlib.gunzipSync(compressed);
   const entries = parseTar(tarBuffer);
-  const resolvedDestDir = path13.resolve(destDir);
-  fs11.mkdirSync(resolvedDestDir, { recursive: true });
-  const within = (candidate) => candidate === resolvedDestDir || candidate.startsWith(resolvedDestDir + path13.sep);
+  const resolvedDestDir = path14.resolve(destDir);
+  fs12.mkdirSync(resolvedDestDir, { recursive: true });
+  const within = (candidate) => candidate === resolvedDestDir || candidate.startsWith(resolvedDestDir + path14.sep);
   for (const entry of entries) {
     if (!entry.name || entry.name === "." || entry.name === "./") {
       continue;
     }
-    const targetPath = path13.resolve(resolvedDestDir, entry.name);
+    const targetPath = path14.resolve(resolvedDestDir, entry.name);
     if (!within(targetPath)) {
       throw new Error(
         `Refusing to extract tar entry that escapes destination directory: ${entry.name}`
       );
     }
     if (entry.typeflag === "5" || entry.name.endsWith("/")) {
-      fs11.mkdirSync(targetPath, { recursive: true });
+      fs12.mkdirSync(targetPath, { recursive: true });
       continue;
     }
     if (entry.typeflag === "0" || entry.typeflag === "\0" || entry.typeflag === "7") {
-      fs11.mkdirSync(path13.dirname(targetPath), { recursive: true });
-      fs11.writeFileSync(targetPath, entry.content);
+      fs12.mkdirSync(path14.dirname(targetPath), { recursive: true });
+      fs12.writeFileSync(targetPath, entry.content);
       continue;
     }
     if (entry.typeflag === "2") {
       if (!entry.linkname) {
         throw new Error(`Tar symlink entry has no target: ${entry.name}`);
       }
-      const resolvedLink = path13.resolve(path13.dirname(targetPath), entry.linkname);
-      if (path13.isAbsolute(entry.linkname) || !within(resolvedLink)) {
+      const resolvedLink = path14.resolve(path14.dirname(targetPath), entry.linkname);
+      if (path14.isAbsolute(entry.linkname) || !within(resolvedLink)) {
         throw new Error(
           `Refusing to extract tar symlink that escapes destination directory: ${entry.name} -> ${entry.linkname}`
         );
@@ -21409,9 +21715,9 @@ async function extractTarGz(tarGzPath, destDir) {
       if (process.platform === "win32") {
         continue;
       }
-      fs11.mkdirSync(path13.dirname(targetPath), { recursive: true });
-      fs11.rmSync(targetPath, { force: true });
-      fs11.symlinkSync(entry.linkname, targetPath);
+      fs12.mkdirSync(path14.dirname(targetPath), { recursive: true });
+      fs12.rmSync(targetPath, { force: true });
+      fs12.symlinkSync(entry.linkname, targetPath);
       continue;
     }
     throw new Error(
@@ -21419,12 +21725,12 @@ async function extractTarGz(tarGzPath, destDir) {
     );
   }
 }
-var fs11, path13, zlib, GNU_LONG_NAME, GNU_LONG_LINK, PAX_EXTENDED_HEADER, PAX_GLOBAL_HEADER;
+var fs12, path14, zlib, GNU_LONG_NAME, GNU_LONG_LINK, PAX_EXTENDED_HEADER, PAX_GLOBAL_HEADER;
 var init_MinimalTarExtractor = __esm({
   "src/server/runtime/MinimalTarExtractor.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
     zlib = __toESM(require("zlib"));
     GNU_LONG_NAME = "L";
     GNU_LONG_LINK = "K";
@@ -21444,13 +21750,13 @@ function currentPlatformKey() {
   return key;
 }
 function artifactRuntimeDir(sqlPreviewHome, artifactId) {
-  return path14.join(sqlPreviewHome, "runtime", artifactId);
+  return path15.join(sqlPreviewHome, "runtime", artifactId);
 }
 function artifactVersionDir(sqlPreviewHome, artifactId, version3) {
-  return path14.join(artifactRuntimeDir(sqlPreviewHome, artifactId), version3);
+  return path15.join(artifactRuntimeDir(sqlPreviewHome, artifactId), version3);
 }
 function artifactManifestPath(versionDir) {
-  return path14.join(versionDir, ".provision-manifest.json");
+  return path15.join(versionDir, ".provision-manifest.json");
 }
 function isManifestRecord(value) {
   return typeof value === "object" && value !== null;
@@ -21469,7 +21775,7 @@ function isLegacyDuckDbProvisionManifest(value) {
 }
 function readManifest(manifestPath) {
   try {
-    const raw = fs12.readFileSync(manifestPath, "utf8");
+    const raw = fs13.readFileSync(manifestPath, "utf8");
     const parsed = JSON.parse(raw);
     if (isArtifactProvisionManifest(parsed) || isLegacyDuckDbProvisionManifest(parsed)) {
       return parsed;
@@ -21480,15 +21786,15 @@ function readManifest(manifestPath) {
   }
 }
 function writeManifest(manifestPath, manifest) {
-  fs12.mkdirSync(path14.dirname(manifestPath), { recursive: true });
-  fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+  fs13.mkdirSync(path15.dirname(manifestPath), { recursive: true });
+  fs13.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
 }
-var fs12, path14, SUPPORTED_PLATFORMS;
+var fs13, path15, SUPPORTED_PLATFORMS;
 var init_ManagedArtifactTypes = __esm({
   "src/server/runtime/ManagedArtifactTypes.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path14 = __toESM(require("path"));
+    fs13 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
     SUPPORTED_PLATFORMS = [
       "darwin-arm64",
       "darwin-x64",
@@ -21575,18 +21881,18 @@ var init_protocolVersion = __esm({
 
 // src/server/install/applicationPayload.ts
 function applicationDir(configHome, version3) {
-  return path19.join(configHome, "app", version3);
+  return path20.join(configHome, "app", version3);
 }
 function isStandaloneApplication(configHome, entryPath) {
   if (!entryPath) {
     return false;
   }
-  const appRoot = path19.resolve(configHome, "app") + path19.sep;
-  return path19.resolve(entryPath).startsWith(appRoot);
+  const appRoot = path20.resolve(configHome, "app") + path20.sep;
+  return path20.resolve(entryPath).startsWith(appRoot);
 }
 function isWithin(parent, child) {
-  const relative5 = path19.relative(path19.resolve(parent), path19.resolve(child));
-  return relative5 === "" || !relative5.startsWith(`..${path19.sep}`) && relative5 !== "..";
+  const relative5 = path20.relative(path20.resolve(parent), path20.resolve(child));
+  return relative5 === "" || !relative5.startsWith(`..${path20.sep}`) && relative5 !== "..";
 }
 function removeDirectoryBestEffort(fileSystem, directory) {
   try {
@@ -21596,7 +21902,7 @@ function removeDirectoryBestEffort(fileSystem, directory) {
   }
 }
 function writeVersionManifest(fileSystem, directory, version3) {
-  const manifestPath = path19.join(directory, "package.json");
+  const manifestPath = path20.join(directory, "package.json");
   let manifest = { name: "grain-daemon", private: true };
   try {
     const existing = JSON.parse(fileSystem.readFileSync(manifestPath, "utf8"));
@@ -21610,10 +21916,10 @@ function writeVersionManifest(fileSystem, directory, version3) {
 `, "utf8");
 }
 function installApplicationPayload(options) {
-  const fileSystem = options.fileSystem ?? fs16;
+  const fileSystem = options.fileSystem ?? fs17;
   const { configHome, version: version3, sourceEntry } = options;
   const destinationDir = applicationDir(configHome, version3);
-  const applicationRoot = path19.join(configHome, "app");
+  const applicationRoot = path20.join(configHome, "app");
   if (!isWithin(applicationRoot, destinationDir)) {
     throw new Error(`Application version must stay inside ${applicationRoot}`);
   }
@@ -21623,21 +21929,21 @@ function installApplicationPayload(options) {
   fileSystem.rmSync(staging, { recursive: true, force: true });
   fileSystem.mkdirSync(staging, { recursive: true });
   const isDirectory = fileSystem.statSync(sourceEntry).isDirectory();
-  const entryName = isDirectory ? "standalone.js" : path19.basename(sourceEntry);
+  const entryName = isDirectory ? "standalone.js" : path20.basename(sourceEntry);
   if (isDirectory) {
     fileSystem.cpSync(sourceEntry, staging, { recursive: true });
   } else {
-    fileSystem.copyFileSync(sourceEntry, path19.join(staging, entryName));
+    fileSystem.copyFileSync(sourceEntry, path20.join(staging, entryName));
     const pagesDir = [
-      path19.join(path19.dirname(sourceEntry), "dist"),
-      path19.join(path19.dirname(sourceEntry), "..", "..", "dist")
-    ].find((candidate) => fileSystem.existsSync(path19.join(candidate, "web-app.html")));
+      path20.join(path20.dirname(sourceEntry), "dist"),
+      path20.join(path20.dirname(sourceEntry), "..", "..", "dist")
+    ].find((candidate) => fileSystem.existsSync(path20.join(candidate, "web-app.html")));
     if (pagesDir) {
-      fileSystem.mkdirSync(path19.join(staging, "dist"), { recursive: true });
+      fileSystem.mkdirSync(path20.join(staging, "dist"), { recursive: true });
       for (const page of ["web-app.html", "mcp-app.html"]) {
-        const pagePath = path19.join(pagesDir, page);
+        const pagePath = path20.join(pagesDir, page);
         if (fileSystem.existsSync(pagePath)) {
-          fileSystem.copyFileSync(pagePath, path19.join(staging, "dist", page));
+          fileSystem.copyFileSync(pagePath, path20.join(staging, "dist", page));
         }
       }
     }
@@ -21664,23 +21970,23 @@ function installApplicationPayload(options) {
     throw error52;
   }
   removeDirectoryBestEffort(fileSystem, backup);
-  return path19.join(destinationDir, entryName);
+  return path20.join(destinationDir, entryName);
 }
 function retainedApplicationVersions(configHome) {
   try {
-    return fs16.readdirSync(path19.join(configHome, "app"), { withFileTypes: true }).filter(
+    return fs17.readdirSync(path20.join(configHome, "app"), { withFileTypes: true }).filter(
       (entry) => entry.isDirectory() && !entry.name.includes(".staging-") && !entry.name.includes(".backup-")
     ).map((entry) => entry.name).sort((left, right) => compareSemver(right, left));
   } catch {
     return [];
   }
 }
-var fs16, path19;
+var fs17, path20;
 var init_applicationPayload = __esm({
   "src/server/install/applicationPayload.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    path19 = __toESM(require("path"));
+    fs17 = __toESM(require("fs"));
+    path20 = __toESM(require("path"));
     init_protocolVersion();
   }
 });
@@ -21724,7 +22030,7 @@ async function runRegistration(platform2, runner, command, args) {
   if (isUserServicesForbidden(platform2, result.output)) {
     throw new UserServicesForbiddenError(result.output);
   }
-  throw new Error(`${command} ${args.join(" ")} failed: ${result.output.trim()}`);
+  throw new RegistrationError(command, args, result.exitCode, result.output);
 }
 async function runStart(runner, command, args) {
   const result = await runner.run(command, args);
@@ -21741,12 +22047,45 @@ function isCommandMissing(error52) {
 }
 function createSupervisorAdapter(platform2, runner, uid) {
   if (platform2 === "darwin") {
-    const target = (identifier) => `gui/${uid}/${identifier}`;
+    const target = (domain2, identifier) => `${domain2}/${uid}/${identifier}`;
+    const registeredTarget = async (identifier) => {
+      for (const domain2 of ["gui", "user"]) {
+        const serviceTarget = target(domain2, identifier);
+        if (await probeRegistration(runner, "launchctl", ["print", serviceTarget])) {
+          return serviceTarget;
+        }
+      }
+      return void 0;
+    };
     return {
-      isRegistered: (identifier) => probeRegistration(runner, "launchctl", ["print", target(identifier)]),
-      register: (unitPath) => runRegistration(platform2, runner, "launchctl", ["bootstrap", `gui/${uid}`, unitPath]),
-      unregister: (identifier) => runRegistration(platform2, runner, "launchctl", ["bootout", target(identifier)]),
-      start: (identifier) => runStart(runner, "launchctl", ["kickstart", "-k", target(identifier)])
+      isRegistered: async (identifier) => await registeredTarget(identifier) !== void 0,
+      register: async (unitPath) => {
+        try {
+          await runRegistration(platform2, runner, "launchctl", [
+            "bootstrap",
+            `gui/${uid}`,
+            unitPath
+          ]);
+        } catch (error52) {
+          if (!(error52 instanceof RegistrationError) || !(error52.exitCode === 125 || /(?:^|\D)125(?:\D|$)|Domain does not support specified action/i.test(error52.output))) {
+            throw error52;
+          }
+          await runRegistration(platform2, runner, "launchctl", [
+            "bootstrap",
+            `user/${uid}`,
+            unitPath
+          ]);
+        }
+      },
+      unregister: async (identifier) => runRegistration(platform2, runner, "launchctl", [
+        "bootout",
+        await registeredTarget(identifier) ?? target("gui", identifier)
+      ]),
+      start: async (identifier) => runStart(runner, "launchctl", [
+        "kickstart",
+        "-k",
+        await registeredTarget(identifier) ?? target("gui", identifier)
+      ])
     };
   }
   if (platform2 === "linux") {
@@ -21797,7 +22136,7 @@ function createSupervisorAdapter(platform2, runner, uid) {
     start: (identifier) => runStart(runner, "schtasks", ["/Run", "/TN", identifier])
   };
 }
-var import_child_process3, UserServicesForbiddenError, ServiceManagerMissingError;
+var import_child_process3, UserServicesForbiddenError, ServiceManagerMissingError, RegistrationError;
 var init_supervisorAdapter = __esm({
   "src/server/install/supervisorAdapter.ts"() {
     "use strict";
@@ -21806,6 +22145,13 @@ var init_supervisorAdapter = __esm({
     };
     ServiceManagerMissingError = class extends UserServicesForbiddenError {
     };
+    RegistrationError = class extends Error {
+      constructor(command, args, exitCode, output) {
+        super(`${command} ${args.join(" ")} failed: ${output.trim()}`);
+        this.exitCode = exitCode;
+        this.output = output;
+      }
+    };
   }
 });
 
@@ -21816,7 +22162,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.12",
+      version: "0.10.14",
       license: "UNLICENSED",
       mcpName: "io.github.pattrnlabs/grain",
       publisher: "pattrnlabs",
@@ -21869,7 +22215,8 @@ var require_package = __commonJS({
         "Other"
       ],
       activationEvents: [
-        "onLanguage:sql"
+        "onLanguage:sql",
+        "onStartupFinished"
       ],
       main: "./out/extension.js",
       contributes: {
@@ -22166,6 +22513,22 @@ var require_package = __commonJS({
               maximum: 20,
               order: 10
             },
+            "grain.panelTheme": {
+              type: "string",
+              enum: [
+                "inherit",
+                "grain-light",
+                "grain-dark"
+              ],
+              default: "inherit",
+              description: "Color theme for the Grain results panel. Inherit follows your VS Code theme; the Grain themes use the Grain brand palette and type.",
+              enumDescriptions: [
+                "Follow the active VS Code color theme",
+                "Grain Light: the Grain brand palette on a light ground",
+                "Grain Dark: the Grain brand palette on a dark ground"
+              ],
+              order: 10.2
+            },
             "grain.filterResultsByActiveFile": {
               type: "boolean",
               default: true,
@@ -22221,7 +22584,7 @@ var require_package = __commonJS({
             },
             "grain.mcpEnabled": {
               type: "boolean",
-              default: false,
+              default: true,
               description: "(Beta) Serve the MCP surface so LLM agents can interact with Grain. When off, the daemon does not register /mcp at all. Changing this restarts the daemon. An explicitly launched stdio bridge is treated as consent and still works; to refuse MCP everywhere, set mcp.enabled to false in ~/.grain/daemon.json.",
               order: 20
             },
@@ -22362,11 +22725,17 @@ var require_package = __commonJS({
         watch: "tsc -watch -p ./",
         package: "node scripts/package-vsix.js",
         "ci:burn": "node scripts/ci-burn.mjs",
-        lint: 'eslint "src/**/*.ts" "scripts/**/*.js" "scripts/**/*.mjs" --cache',
-        "lint:fix": 'eslint "src/**/*.ts" "scripts/**/*.js" --fix --cache',
-        format: 'prettier --write "src/**/*.{ts,js,json}"',
-        "format:check": 'prettier --check "src/**/*.{ts,js,json}" --cache',
+        lint: "oxlint -c .oxlintrc.json src scripts",
+        "lint:legacy": 'eslint "src/**/*.ts" "scripts/**/*.js" "scripts/**/*.mjs" --cache',
+        "lint:fix": "oxlint -c .oxlintrc.json --fix src scripts",
+        "lint:fix:legacy": 'eslint "src/**/*.ts" "scripts/**/*.js" --fix --cache',
+        format: 'oxfmt "src/**/*.{ts,js,json}"',
+        "format:legacy": 'npx --yes prettier@3.6.2 --write "src/**/*.{ts,js,json}"',
+        "format:check": 'oxfmt --check "src/**/*.{ts,js,json}"',
         workbench: "vite --config vite.config.workbench.mts",
+        "check:panel-themes:vscode": "node scripts/check-panel-themes-vscode.cjs",
+        "test:gui": "jest --config jest.medium.config.js --runInBand --roots <rootDir>/src/test/gui --testRegex \\.gui\\.test\\.js$",
+        "check:panel-themes:workbench": "node scripts/check-panel-themes-workbench.cjs",
         "check:ui-contract": "node scripts/check-ui-token-contract.js",
         "check:brand-tokens": "node scripts/check-brand-tokens.js",
         "check:identity": "node scripts/check-identity.js",
@@ -22374,7 +22743,7 @@ var require_package = __commonJS({
         "check:token-theme-parity": "node scripts/check-token-theme-parity.js",
         "generate:duckdb-pins": "node scripts/generate-duckdb-pins.js",
         "generate:artifact-pins": "node scripts/generate-artifact-pins.js",
-        "generate:node-pins": "node scripts/generate-node-pins.js && npx prettier --write src/server/runtime/nodePins.generated.ts",
+        "generate:node-pins": "node scripts/generate-node-pins.js && npx oxfmt src/server/runtime/nodePins.generated.ts",
         "check:duckdb-pins": "node scripts/check-duckdb-pins.js",
         "rfc:check": "node scripts/validate-rfcs.js",
         "docs:coverage-manifest": "node scripts/generate-coverage-manifest.js",
@@ -22389,7 +22758,11 @@ var require_package = __commonJS({
         "check:no-execpath-units": "node scripts/check-no-execpath-units.js",
         "check:gates": "node scripts/check-gates.js",
         "rfc:new": "node scripts/new-rfc.js",
-        "type-check": "tsc --noEmit --incremental --tsBuildInfoFile .tsbuildinfo",
+        "type-check": "tsgo --noEmit -p ./",
+        "type-check:legacy": "tsc --noEmit --incremental --tsBuildInfoFile .tsbuildinfo",
+        typecheck: "npm run -s type-check",
+        "typecheck:compare": "node scripts/compare-typecheck.js",
+        "check:fast": "node scripts/check-fast.js",
         "esbuild-base": "esbuild ./src/extension.ts --bundle --outfile=out/extension.js --external:vscode --external:ws --format=cjs --platform=node",
         "esbuild-daemon": "esbuild ./src/server/Daemon.ts --bundle --outfile=out/server/Daemon.js --platform=node --format=cjs --external:vscode --external:@duckdb/node-api --external:@napi-rs/keyring --external:@google-cloud/bigquery --external:mysql2 --external:mysql2/* --external:mssql --external:snowflake-sdk --external:sql.js --alias:@opentelemetry/configuration=./src/stubs/otel-configuration-stub.js --alias:@opentelemetry/exporter-trace-otlp-grpc=./src/stubs/otel-grpc-exporters-stub.js --alias:@opentelemetry/exporter-logs-otlp-grpc=./src/stubs/otel-grpc-exporters-stub.js --alias:@opentelemetry/exporter-metrics-otlp-grpc=./src/stubs/otel-grpc-exporters-stub.js",
         "esbuild-standalone": 'esbuild ./src/server/standalone.ts --bundle --outfile=out/server/standalone.js --platform=node --format=cjs --external:vscode --external:@duckdb/node-api --external:@napi-rs/keyring --external:@google-cloud/bigquery --external:mysql2 --external:mysql2/* --external:mssql --external:snowflake-sdk --external:sql.js --banner:js="#!/usr/bin/env node" --alias:@opentelemetry/configuration=./src/stubs/otel-configuration-stub.js --alias:@opentelemetry/exporter-trace-otlp-grpc=./src/stubs/otel-grpc-exporters-stub.js --alias:@opentelemetry/exporter-logs-otlp-grpc=./src/stubs/otel-grpc-exporters-stub.js --alias:@opentelemetry/exporter-metrics-otlp-grpc=./src/stubs/otel-grpc-exporters-stub.js',
@@ -22446,7 +22819,7 @@ var require_package = __commonJS({
         "test:integration:stdio-bridge": 'node scripts/emit-seam-receipt.js "npm run test:integration:stdio-bridge" -- jest --config jest.config.js --runInBand --runTestsByPath src/test/integration/stdio_bridge.test.ts',
         "test:medium:rfc-baseline": "jest --config jest.medium.config.js --runInBand --runTestsByPath src/test/medium/rfcBaselineResolution.medium.test.js",
         "test:integration": "node ./out/test/runTest.js",
-        prewalkthrough: "npm run compile",
+        prewalkthrough: "npm run compile && node scripts/build-daemon.js --entry=standalone",
         walkthrough: "node scripts/walkthrough-runner/run.js",
         "pretest:mcp-conformance": "npm run build:packages:dev && node scripts/build-daemon.js --entry=standalone",
         "test:mcp-conformance": "node scripts/run-mcp-conformance.js",
@@ -22485,7 +22858,6 @@ var require_package = __commonJS({
         "check:release-notes": "node scripts/release-note-fragments.js validate",
         "check:release-note-range": "node scripts/release-note-fragments.js check",
         "changelog:draft": "node scripts/release-note-fragments.js draft",
-        typecheck: "npm run type-check",
         "docs:graph": "node scripts/generate-architecture-graph.js",
         "docs:api": "typedoc",
         "docs:gen": "npm run docs:graph && npm run docs:api",
@@ -22529,6 +22901,7 @@ var require_package = __commonJS({
         "@types/vscode": "^1.80.0",
         "@typescript-eslint/eslint-plugin": "^5.59.8",
         "@typescript-eslint/parser": "^5.59.8",
+        "@typescript/native-preview": "^7.0.0-dev.20260707.2",
         "@vitejs/plugin-react-swc": "^4.3.0",
         "@vscode/test-electron": "^2.5.2",
         "@vscode/vsce": "^3.9.1",
@@ -22537,8 +22910,6 @@ var require_package = __commonJS({
         "dotenv-cli": "^7.4.1",
         esbuild: "^0.17.19",
         eslint: "^8.41.0",
-        "eslint-config-prettier": "^9.1.2",
-        "eslint-plugin-prettier": "^5.5.3",
         glob: "^11.0.1",
         husky: "^8.0.3",
         jest: "^29.7.0",
@@ -22547,9 +22918,11 @@ var require_package = __commonJS({
         "lint-staged": "^15.5.2",
         madge: "^8.0.0",
         mocha: "^11.1.0",
+        oxfmt: "^0.70.0",
+        oxlint: "^1.85.0",
         "patch-package": "^8.0.1",
         pg: "^8.17.2",
-        prettier: "^3.6.2",
+        "playwright-core": "1.62.1",
         secretlint: "^11.3.1",
         semver: "^7.8.5",
         sinon: "^20.0.0",
@@ -22559,6 +22932,7 @@ var require_package = __commonJS({
         typescript: "^5.1.3",
         vite: "^5.4.21",
         "vite-plugin-singlefile": "^2.3.0",
+        vitest: "^3.2.7",
         yaml: "^2.8.3"
       },
       dependencies: {
@@ -22593,11 +22967,11 @@ var require_package = __commonJS({
       },
       "lint-staged": {
         "*.{ts,js,mjs}": [
-          "eslint --fix",
-          "prettier --write"
+          "oxlint -c .oxlintrc.json --fix",
+          "oxfmt"
         ],
         "*.{json,md}": [
-          "prettier --write"
+          "oxfmt"
         ],
         "*.{ts,js,mjs,cjs,json,env,yaml,yml,sh,toml,ini,cfg,conf,pem,key,crt}": [
           "secretlint"
@@ -22612,206 +22986,6 @@ var require_package = __commonJS({
   }
 });
 
-// src/common/toolProfiles.ts
-function toolRuleFor(profile, tool) {
-  return profile.policy?.rules?.[TOOL_RESOURCE_CLASS[tool]] ?? "allow";
-}
-function toolRefusalMessage(profile, tool) {
-  return `Tool '${tool}' is not permitted for the '${profile.name}' profile: its resource class '${TOOL_RESOURCE_CLASS[tool]}' is refused by policy. The tool exists and is advertised; this call was declined, not lost.`;
-}
-function toolRefusalResult(profile, tool) {
-  return {
-    isError: true,
-    content: [{ type: "text", text: toolRefusalMessage(profile, tool) }],
-    structuredContent: { errorKind: "permission", errorId: "tool_not_permitted_for_profile" }
-  };
-}
-function refuseIfNotPermitted(profile, tool) {
-  const name = tool;
-  if (TOOL_RESOURCE_CLASS[name] === void 0)
-    return void 0;
-  if (toolRuleFor(profile, name) === "allow")
-    return void 0;
-  return toolRefusalResult(profile, name);
-}
-function isToolProfileName(value) {
-  return value === "vscode" || value === "headless" || value === "readonly" || value === "agent";
-}
-function operatorProfileOverride(onUnknownEnvValue) {
-  const fromEnv = process.env["MCP_PROFILE"];
-  if (fromEnv === void 0)
-    return void 0;
-  if (isToolProfileName(fromEnv))
-    return TOOL_PROFILES[fromEnv];
-  onUnknownEnvValue?.(fromEnv);
-  return void 0;
-}
-function resolveToolProfile(explicit, onUnknownEnvValue) {
-  if (explicit) {
-    return TOOL_PROFILES[explicit];
-  }
-  const fromEnv = process.env["MCP_PROFILE"];
-  if (fromEnv !== void 0) {
-    if (isToolProfileName(fromEnv)) {
-      return TOOL_PROFILES[fromEnv];
-    }
-    onUnknownEnvValue?.(fromEnv);
-  }
-  return TOOL_PROFILES.vscode;
-}
-function isSafeModeActive(profile, liveSafeMode) {
-  return profile.forceSafeMode || liveSafeMode;
-}
-function toolNamesForProfile(profile) {
-  const cached2 = toolNameSets.get(profile);
-  if (cached2)
-    return cached2;
-  const names = new Set(profile.tools);
-  toolNameSets.set(profile, names);
-  return names;
-}
-function composeToolProfiles(...profiles) {
-  const present = profiles.filter((p) => p !== void 0);
-  if (present.length === 0)
-    return TOOL_PROFILES.vscode;
-  if (present.length === 1)
-    return present[0];
-  const sets = present.map((p) => new Set(p.tools));
-  const rules = {};
-  for (const p of present) {
-    for (const [cls, rule] of Object.entries(p.policy?.rules ?? {})) {
-      if (rule === "refuse")
-        rules[cls] = "refuse";
-    }
-  }
-  const refusalCount = (p) => Object.keys(p.policy?.rules ?? {}).length;
-  const narrowest = present.reduce((a, b) => {
-    if (b.tools.length !== a.tools.length)
-      return b.tools.length < a.tools.length ? b : a;
-    return refusalCount(b) > refusalCount(a) ? b : a;
-  });
-  return {
-    name: narrowest.name,
-    tools: ALL_TOOLS.filter((tool) => sets.every((s) => s.has(tool))),
-    forceSafeMode: present.some((p) => p.forceSafeMode),
-    ...Object.keys(rules).length > 0 ? { policy: { rules } } : {}
-  };
-}
-function createToolProfileResolver(explicit, onUnknownEnvValue) {
-  const defaultProfile = resolveToolProfile(explicit, onUnknownEnvValue);
-  const pinned = explicit === void 0 ? void 0 : TOOL_PROFILES[explicit];
-  const fromEnv = operatorProfileOverride(onUnknownEnvValue);
-  return {
-    defaultProfile,
-    forCall(profile) {
-      const declared = profile === void 0 ? void 0 : TOOL_PROFILES[profile];
-      if (pinned === void 0 && fromEnv === void 0 && declared === void 0) {
-        return defaultProfile;
-      }
-      return composeToolProfiles(pinned, fromEnv, declared);
-    }
-  };
-}
-var ALL_TOOLS, READ_ONLY_TOOLS, TOOL_RESOURCE_CLASS, TOOL_PROFILES, WEB_PROXIED_TOOLS, toolNameSets;
-var init_toolProfiles = __esm({
-  "src/common/toolProfiles.ts"() {
-    "use strict";
-    ALL_TOOLS = [
-      "list_connectors",
-      "run_query",
-      "get_tab_info",
-      "list_sessions",
-      "list_connections",
-      "save_connection",
-      "request_connection_credentials",
-      "test_connection",
-      "delete_connection",
-      "list_schemas",
-      "list_tables",
-      "describe_table",
-      "cancel_query",
-      "close_tab",
-      "render_chart",
-      "save_chart",
-      "list_charts",
-      "ledger_stats",
-      "verify_ledger",
-      "record_ui_event"
-    ];
-    READ_ONLY_TOOLS = [
-      "list_connectors",
-      "run_query",
-      "get_tab_info",
-      "list_sessions",
-      "list_connections",
-      "test_connection",
-      "list_schemas",
-      "list_tables",
-      "describe_table",
-      "cancel_query",
-      "close_tab",
-      "render_chart",
-      "list_charts",
-      "ledger_stats",
-      "verify_ledger",
-      "record_ui_event"
-    ];
-    TOOL_RESOURCE_CLASS = {
-      list_connectors: "read",
-      list_connections: "read",
-      list_sessions: "read",
-      get_tab_info: "read",
-      list_schemas: "read",
-      list_tables: "read",
-      describe_table: "read",
-      list_charts: "read",
-      ledger_stats: "read",
-      verify_ledger: "read",
-      test_connection: "read",
-      cancel_query: "session",
-      close_tab: "session",
-      render_chart: "session",
-      run_query: "query",
-      save_connection: "connection-config",
-      delete_connection: "connection-config",
-      request_connection_credentials: "credential",
-      save_chart: "workspace-write",
-      record_ui_event: "app-telemetry"
-    };
-    TOOL_PROFILES = {
-      // Human-in-the-loop VS Code surface: full toolset, safe mode from settings.
-      vscode: { name: "vscode", tools: ALL_TOOLS, forceSafeMode: false },
-      // Autonomous agents: starts as the full current toolset (RFC-062); will
-      // diverge toward synchronous/structured tools without breaking clients.
-      headless: { name: "headless", tools: ALL_TOOLS, forceSafeMode: false },
-      // Safe exploration: no profile/credential mutation, SQL gating always on.
-      readonly: { name: "readonly", tools: READ_ONLY_TOOLS, forceSafeMode: true },
-      // RFC-134: intended as the default for an attached AI agent surface — may read,
-      // query and chart, may not change saved connections or ask for stored credentials.
-      // This profile is assigned to the local agent identity and enforced on the stdio bridge.
-      // End-to-end enforcement is proven by the 'bridged client (agent profile) is permitted
-      // read tools but refused config/credential tools' test in stdio_bridge.test.ts.
-      // SQL restriction is deliberately not forced here: `grain.mcpSafeMode`
-      // already defaults to on, and a ceiling would make that setting silently stop
-      // working for the recommended agent path.
-      agent: {
-        name: "agent",
-        tools: ALL_TOOLS,
-        forceSafeMode: false,
-        policy: { rules: { "connection-config": "refuse", credential: "refuse" } }
-      }
-    };
-    WEB_PROXIED_TOOLS = [
-      "list_connectors",
-      "list_connections",
-      "save_connection",
-      "test_connection",
-      "delete_connection"
-    ];
-    toolNameSets = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // src/server/auth/ClientRegistry.ts
 function clientRegistryPath(configDir) {
   return import_path3.default.join(configDir, CLIENT_REGISTRY_FILENAME);
@@ -23017,32 +23191,32 @@ async function startCommand(configDir = resolveGrainHome(), spawner = import_chi
   const lockPath = path24.join(configDir, "start.lock");
   let claimedLock = false;
   try {
-    const content = fs20.readFileSync(lockPath, "utf8");
+    const content = fs21.readFileSync(lockPath, "utf8");
     const parts = content.split("\n");
     const pidStr = parts[0];
     const tsStr = parts[1];
     if (pidStr === void 0 || tsStr === void 0) {
-      fs20.unlinkSync(lockPath);
+      fs21.unlinkSync(lockPath);
     } else {
       const lockPid = parseInt(pidStr, 10);
       const lockTs = parseInt(tsStr, 10);
       if (!isNaN(lockTs) && clock.now() - lockTs > 2e4) {
-        fs20.unlinkSync(lockPath);
+        fs21.unlinkSync(lockPath);
       } else if (!isNaN(lockPid)) {
         try {
           process.kill(lockPid, 0);
         } catch {
-          fs20.unlinkSync(lockPath);
+          fs21.unlinkSync(lockPath);
         }
       }
     }
   } catch {
   }
   try {
-    const fd = fs20.openSync(lockPath, "wx");
-    fs20.writeSync(fd, `${process.pid}
+    const fd = fs21.openSync(lockPath, "wx");
+    fs21.writeSync(fd, `${process.pid}
 ${clock.now()}`);
-    fs20.closeSync(fd);
+    fs21.closeSync(fd);
     claimedLock = true;
   } catch (e2) {
     if (e2.code !== "EEXIST") {
@@ -23051,8 +23225,8 @@ ${clock.now()}`);
   }
   const logPath = path24.join(configDir, "daemon.log");
   if (claimedLock) {
-    const out2 = fs20.openSync(logPath, "a");
-    const err = fs20.openSync(logPath, "a");
+    const out2 = fs21.openSync(logPath, "a");
+    const err = fs21.openSync(logPath, "a");
     const child = spawner(process.execPath, [process.argv[1] ?? ""], {
       detached: true,
       stdio: ["ignore", out2, err],
@@ -23087,18 +23261,18 @@ ${clock.now()}`);
   } finally {
     if (claimedLock) {
       try {
-        fs20.unlinkSync(lockPath);
+        fs21.unlinkSync(lockPath);
       } catch {
       }
     }
   }
 }
-var import_child_process4, fs20, path24, http5, OWNERSHIP_PROBE_PATH;
+var import_child_process4, fs21, path24, http5, OWNERSHIP_PROBE_PATH;
 var init_startCommand = __esm({
   "src/server/cli/startCommand.ts"() {
     "use strict";
     import_child_process4 = require("child_process");
-    fs20 = __toESM(require("fs"));
+    fs21 = __toESM(require("fs"));
     path24 = __toESM(require("path"));
     http5 = __toESM(require("http"));
     init_grainHome();
@@ -23140,7 +23314,7 @@ var init_localBrowserPaths = __esm({
 function findPackageRoot(startDir) {
   let dir3 = startDir;
   for (let i = 0; i < 8; i++) {
-    if (fs21.existsSync(path25.join(dir3, "package.json"))) {
+    if (fs22.existsSync(path25.join(dir3, "package.json"))) {
       return dir3;
     }
     const parent = path25.dirname(dir3);
@@ -23154,17 +23328,17 @@ function findPackageRoot(startDir) {
 function readDaemonVersion() {
   try {
     const pkgPath = path25.join(findPackageRoot(__dirname), "package.json");
-    const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf8"));
+    const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf8"));
     return pkg.version ?? null;
   } catch {
     return null;
   }
 }
-var fs21, path25;
+var fs22, path25;
 var init_daemonVersion = __esm({
   "src/server/daemonVersion.ts"() {
     "use strict";
-    fs21 = __toESM(require("fs"));
+    fs22 = __toESM(require("fs"));
     path25 = __toESM(require("path"));
   }
 });
@@ -45701,7 +45875,7 @@ var require_view = __commonJS({
     "use strict";
     var debug = require_src()("express:view");
     var path46 = require("node:path");
-    var fs44 = require("node:fs");
+    var fs45 = require("node:fs");
     var dirname16 = path46.dirname;
     var basename5 = path46.basename;
     var extname = path46.extname;
@@ -45781,7 +45955,7 @@ var require_view = __commonJS({
     function tryStat(path47) {
       debug('stat "%s"', path47);
       try {
-        return fs44.statSync(path47);
+        return fs45.statSync(path47);
       } catch (e2) {
         return void 0;
       }
@@ -77968,7 +78142,7 @@ var require_send = __commonJS({
     var escapeHtml2 = require_escape_html();
     var etag = require_etag();
     var fresh = require_fresh();
-    var fs44 = require("fs");
+    var fs45 = require("fs");
     var mime = require_mime_types4();
     var ms = require_ms();
     var onFinished = require_on_finished();
@@ -78251,7 +78425,7 @@ var require_send = __commonJS({
       var i = 0;
       var self2 = this;
       debug('stat "%s"', path47);
-      fs44.stat(path47, function onstat(err, stat) {
+      fs45.stat(path47, function onstat(err, stat) {
         var pathEndsWithSep = path47[path47.length - 1] === sep7;
         if (err && err.code === "ENOENT" && !extname(path47) && !pathEndsWithSep) {
           return next(err);
@@ -78271,7 +78445,7 @@ var require_send = __commonJS({
         }
         var p = path47 + "." + self2._extensions[i++];
         debug('stat "%s"', p);
-        fs44.stat(p, function(err2, stat) {
+        fs45.stat(p, function(err2, stat) {
           if (err2)
             return next(err2);
           if (stat.isDirectory())
@@ -78292,7 +78466,7 @@ var require_send = __commonJS({
         }
         var p = join37(path47, self2._index[i]);
         debug('stat "%s"', p);
-        fs44.stat(p, function(err2, stat) {
+        fs45.stat(p, function(err2, stat) {
           if (err2)
             return next(err2);
           if (stat.isDirectory())
@@ -78306,7 +78480,7 @@ var require_send = __commonJS({
     SendStream.prototype.stream = function stream4(path47, options) {
       var self2 = this;
       var res = this.res;
-      var stream5 = fs44.createReadStream(path47, options);
+      var stream5 = fs45.createReadStream(path47, options);
       this.emit("stream", stream5);
       stream5.pipe(res);
       function cleanup() {
@@ -79198,13 +79372,13 @@ function endpointExists(endpoint) {
   if (isWindowsNamedPipe(endpoint)) {
     return true;
   }
-  return fs22.existsSync(endpoint);
+  return fs23.existsSync(endpoint);
 }
-var fs22, os6, path26, import_crypto5, UNIX_SOCKET_PATH_MAX_BYTES, SOCKET_BASENAME, PRIVATE_SOCKET_BASENAME_LENGTH;
+var fs23, os6, path26, import_crypto5, UNIX_SOCKET_PATH_MAX_BYTES, SOCKET_BASENAME, PRIVATE_SOCKET_BASENAME_LENGTH;
 var init_ipcEndpoint = __esm({
   "src/common/ipcEndpoint.ts"() {
     "use strict";
-    fs22 = __toESM(require("fs"));
+    fs23 = __toESM(require("fs"));
     os6 = __toESM(require("os"));
     path26 = __toESM(require("path"));
     import_crypto5 = require("crypto");
@@ -79344,11 +79518,11 @@ var init_ConnectorRegistry = __esm({
 });
 
 // src/services/DriverManager.ts
-var fs23, path27, DriverManager;
+var fs24, path27, DriverManager;
 var init_DriverManager = __esm({
   "src/services/DriverManager.ts"() {
     "use strict";
-    fs23 = __toESM(require("fs"));
+    fs24 = __toESM(require("fs"));
     path27 = __toESM(require("path"));
     DriverManager = class {
       constructor(configDir, driverResolver) {
@@ -79367,7 +79541,7 @@ var init_DriverManager = __esm({
         }
         if (this.configDir) {
           const driverPath = path27.join(this.configDir, "drivers", "node_modules", driverName);
-          if (fs23.existsSync(driverPath)) {
+          if (fs24.existsSync(driverPath)) {
             return driverPath;
           }
         }
@@ -79378,7 +79552,7 @@ var init_DriverManager = __esm({
        */
       async getConnectorExecutablePath(connectorType, customPath) {
         if (customPath) {
-          if (path27.isAbsolute(customPath) && fs23.existsSync(customPath)) {
+          if (path27.isAbsolute(customPath) && fs24.existsSync(customPath)) {
             return customPath;
           }
           throw new Error(`Custom connector executable not found at path: ${customPath}`);
@@ -79404,7 +79578,7 @@ var init_DriverManager = __esm({
           path27.join(__dirname, "..", "..", "..", "packages", executableName, "dist", "cli.js")
         ];
         for (const p of possiblePaths) {
-          if (fs23.existsSync(p)) {
+          if (fs24.existsSync(p)) {
             return p;
           }
         }
@@ -79815,11 +79989,11 @@ var src_exports = {};
 __export(src_exports, {
   default: () => DuckDbConnector
 });
-var fs24, import_connector_api, DuckDbConnector;
+var fs25, import_connector_api, DuckDbConnector;
 var init_src = __esm({
   "packages/sql-preview-duckdb/src/index.ts"() {
     "use strict";
-    fs24 = __toESM(require("fs"));
+    fs25 = __toESM(require("fs"));
     import_connector_api = __toESM(require_dist2());
     init_descriptor();
     DuckDbConnector = class {
@@ -79890,7 +80064,7 @@ var init_src = __esm({
           }
           if (config2.mounts) {
             for (const filePath of Object.values(config2.mounts)) {
-              if (!fs24.existsSync(filePath)) {
+              if (!fs25.existsSync(filePath)) {
               }
             }
           }
@@ -79937,12 +80111,18 @@ var init_src = __esm({
                 }
                 if (cell !== null && typeof cell === "object") {
                   const c = cell;
+                  if (typeof c.toDouble === "function" && typeof c.width === "number") {
+                    return c.width <= 15 ? c.toDouble() : c.toString();
+                  }
                   if (typeof c.days === "number") {
                     return typeof c.toString === "function" ? c.toString() : new Date(c.days * 864e5).toISOString().slice(0, 10);
                   }
                   if (c.micros !== void 0) {
                     return typeof c.toString === "function" ? c.toString() : new Date(Number(c.micros) / 1e3).toISOString().replace("T", " ").slice(0, 19);
                   }
+                  if (typeof c.toString === "function" && c.toString !== Object.prototype.toString) {
+                    return c.toString();
+                  }
                 }
                 return cell;
               })
@@ -90196,7 +90376,7 @@ var require_form_data = __commonJS({
     var http9 = require("http");
     var https6 = require("https");
     var parseUrl2 = require("url").parse;
-    var fs44 = require("fs");
+    var fs45 = require("fs");
     var Stream = require("stream").Stream;
     var crypto19 = require("crypto");
     var mime = require_mime_types5();
@@ -90263,7 +90443,7 @@ var require_form_data = __commonJS({
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
-          fs44.stat(value.path, function(err, stat) {
+          fs45.stat(value.path, function(err, stat) {
             if (err) {
               callback(err);
               return;
@@ -97674,11 +97854,11 @@ var src_exports4 = {};
 __export(src_exports4, {
   default: () => SQLiteConnector
 });
-var fs25, import_connector_api4, SQLiteConnector;
+var fs26, import_connector_api4, SQLiteConnector;
 var init_src4 = __esm({
   "packages/sql-preview-sqlite/src/index.ts"() {
     "use strict";
-    fs25 = __toESM(require("fs"));
+    fs26 = __toESM(require("fs"));
     import_connector_api4 = __toESM(require_dist2());
     init_descriptor4();
     SQLiteConnector = class {
@@ -97712,7 +97892,7 @@ var init_src4 = __esm({
         if (!this.db) {
           let fileBuffer;
           try {
-            fileBuffer = await fs25.promises.readFile(databasePath);
+            fileBuffer = await fs26.promises.readFile(databasePath);
           } catch (err) {
             throw new import_connector_api4.ConnectionError(`Failed to load SQLite file at ${databasePath}: ${err.message}`);
           }
@@ -99916,11 +100096,11 @@ var init_BuiltInProfileStore = __esm({
 });
 
 // src/server/connection/FileProfileStore.ts
-var fs26, path28, FileProfileStore;
+var fs27, path28, FileProfileStore;
 var init_FileProfileStore = __esm({
   "src/server/connection/FileProfileStore.ts"() {
     "use strict";
-    fs26 = __toESM(require("fs"));
+    fs27 = __toESM(require("fs"));
     path28 = __toESM(require("path"));
     init_ConsoleLogger();
     init_grainHome();
@@ -99932,20 +100112,20 @@ var init_FileProfileStore = __esm({
         this.ensureConfigExists();
       }
       ensureConfigExists() {
-        if (!fs26.existsSync(this.configPath)) {
+        if (!fs27.existsSync(this.configPath)) {
           const dir3 = path28.dirname(this.configPath);
-          if (!fs26.existsSync(dir3)) {
-            fs26.mkdirSync(dir3, { recursive: true });
+          if (!fs27.existsSync(dir3)) {
+            fs27.mkdirSync(dir3, { recursive: true });
           }
           this.writeConfig({ connections: [] });
         }
       }
       readConfig() {
         try {
-          if (!fs26.existsSync(this.configPath)) {
+          if (!fs27.existsSync(this.configPath)) {
             return { connections: [] };
           }
-          const raw = fs26.readFileSync(this.configPath, "utf8");
+          const raw = fs27.readFileSync(this.configPath, "utf8");
           return JSON.parse(raw);
         } catch (error52) {
           logger.error("Failed to read config:", error52);
@@ -99953,7 +100133,7 @@ var init_FileProfileStore = __esm({
         }
       }
       writeConfig(config2) {
-        fs26.writeFileSync(this.configPath, JSON.stringify(config2, null, 2), "utf8");
+        fs27.writeFileSync(this.configPath, JSON.stringify(config2, null, 2), "utf8");
       }
       async loadProfiles() {
         const config2 = this.readConfig();
@@ -100005,18 +100185,18 @@ var init_MemoryCredentialStore = __esm({
 });
 
 // src/server/connection/FileCredentialStore.ts
-var fs27, path29, FileCredentialStore;
+var fs28, path29, FileCredentialStore;
 var init_FileCredentialStore = __esm({
   "src/server/connection/FileCredentialStore.ts"() {
     "use strict";
-    fs27 = __toESM(require("fs"));
+    fs28 = __toESM(require("fs"));
     path29 = __toESM(require("path"));
     init_ConsoleLogger();
     FileCredentialStore = class {
       constructor(configDir) {
         this.credentialsPath = path29.join(configDir, "credentials.json");
-        if (!fs27.existsSync(configDir)) {
-          fs27.mkdirSync(configDir, { recursive: true });
+        if (!fs28.existsSync(configDir)) {
+          fs28.mkdirSync(configDir, { recursive: true });
         }
       }
       async getPassword(profileId) {
@@ -100037,10 +100217,10 @@ var init_FileCredentialStore = __esm({
       }
       readMap() {
         try {
-          if (!fs27.existsSync(this.credentialsPath)) {
+          if (!fs28.existsSync(this.credentialsPath)) {
             return {};
           }
-          const raw = fs27.readFileSync(this.credentialsPath, "utf8");
+          const raw = fs28.readFileSync(this.credentialsPath, "utf8");
           const parsed = JSON.parse(raw);
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch (error52) {
@@ -100053,9 +100233,9 @@ var init_FileCredentialStore = __esm({
       }
       writeMap(map4) {
         const tmpPath = `${this.credentialsPath}.tmp-${process.pid}-${Date.now()}`;
-        fs27.writeFileSync(tmpPath, JSON.stringify(map4, null, 2), { mode: 384 });
-        fs27.renameSync(tmpPath, this.credentialsPath);
-        fs27.chmodSync(this.credentialsPath, 384);
+        fs28.writeFileSync(tmpPath, JSON.stringify(map4, null, 2), { mode: 384 });
+        fs28.renameSync(tmpPath, this.credentialsPath);
+        fs28.chmodSync(this.credentialsPath, 384);
       }
     };
   }
@@ -100114,7 +100294,7 @@ var init_ExtensionCredentialStore = __esm({
             { method: CREDENTIAL_GET_METHOD, params: { profileId } },
             CredentialGetResultSchema
           );
-          return result.password;
+          return result.password ?? this.fallback.getPassword(profileId);
         } catch (error52) {
           logger.warn(
             `[ExtensionCredentialStore] Channel unavailable for getPassword(${profileId}); falling back to file store`,
@@ -100329,7 +100509,7 @@ var init_KeychainCredentialStore = __esm({
             [SERVICE_NAME, profileId],
             this.timeoutMs
           );
-          return typeof password === "string" ? password : void 0;
+          return typeof password === "string" ? password : this.fallback.getPassword(profileId);
         } catch (error52) {
           if (error52 instanceof KeychainTimeoutError) {
             throw error52;
@@ -101069,6 +101249,7 @@ var init_classifyQueryError = __esm({
           /configuration error/,
           /no valid connection profile/,
           /connection ['"].*['"] not found/,
+          /connection ['"].*['"] no longer exists/,
           /invalid connection/,
           /missing required (?:field|option|setting)/,
           /databasepath .*(?:required|missing|empty)/
@@ -101556,13 +101737,26 @@ var init_QueryOperationRunner = __esm({
           sql
         };
       }
+      getNextResultNumber(session) {
+        let maxCount = 0;
+        session.tabs.forEach((tab) => {
+          const match = tab.title.match(/^Result (\d+)$/);
+          if (match && match[1]) {
+            const count2 = parseInt(match[1], 10);
+            if (count2 > maxCount) {
+              maxCount = count2;
+            }
+          }
+        });
+        return maxCount + 1;
+      }
       resolveTab(session, providedTabId, shouldCreateNewTab, providedTitle) {
         if (providedTabId) {
           const tab = session.tabs.get(providedTabId);
           return {
             tab,
             tabId: providedTabId,
-            tabTitle: providedTitle || tab?.title || `Result ${session.tabs.size + 1}`
+            tabTitle: providedTitle || tab?.title || `Result ${this.getNextResultNumber(session)}`
           };
         }
         if (!shouldCreateNewTab && session.activeTabId) {
@@ -101578,7 +101772,7 @@ var init_QueryOperationRunner = __esm({
         return {
           tab: void 0,
           tabId: `t${Math.random().toString(36).substring(2, 10)}`,
-          tabTitle: providedTitle || `Result ${session.tabs.size + 1}`
+          tabTitle: providedTitle || `Result ${this.getNextResultNumber(session)}`
         };
       }
       async executeAndStore(sessionId, tabId, sql, connectionId, connectionProfile, authHeader, controller, origin2, loadAllRows, enforceReadOnly, clientConsent, workspaceRoot) {
@@ -102822,6 +103016,29 @@ function classifyForHumanGate(sql, dialect) {
   const classification = classifyStatement(sql, dialect);
   return classification.kind === "write" || classification.kind === "multi_statement" ? { kind: "confirm", classification } : { kind: "allow", classification };
 }
+function humanConfirmationFor(sql, dialect) {
+  const verdict = classifyForHumanGate(sql, dialect);
+  if (verdict.kind !== "confirm") {
+    return void 0;
+  }
+  const classification = verdict.classification;
+  if (classification.kind === "write") {
+    return {
+      message: `Confirmation required for write statement (${classification.keyword}).`,
+      confirmation: { kind: "write", keyword: classification.keyword }
+    };
+  }
+  if (classification.kind === "multi_statement") {
+    return {
+      message: `Confirmation required for multi-statement query (${classification.count} statements).`,
+      confirmation: { kind: "multi_statement", count: classification.count }
+    };
+  }
+  return {
+    message: "Confirmation required because the connection dialect could not be resolved.",
+    confirmation: { kind: "unknown_dialect" }
+  };
+}
 var WRITE_KEYWORDS, READ_ONLY_START_KEYWORDS;
 var init_sqlPolicy = __esm({
   "src/common/sqlPolicy.ts"() {
@@ -115850,7 +116067,7 @@ function vRatio(u, v) {
 function vAngle(u, v) {
   return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));
 }
-function processArc(x1, y1, x2, y2, fa, fs44, rx, ry, psiDeg, cmd, path46) {
+function processArc(x1, y1, x2, y2, fa, fs45, rx, ry, psiDeg, cmd, path46) {
   var psi = psiDeg * (PI3 / 180);
   var xp = mathCos3(psi) * (x1 - x2) / 2 + mathSin3(psi) * (y1 - y2) / 2;
   var yp = -1 * mathSin3(psi) * (x1 - x2) / 2 + mathCos3(psi) * (y1 - y2) / 2;
@@ -115859,7 +116076,7 @@ function processArc(x1, y1, x2, y2, fa, fs44, rx, ry, psiDeg, cmd, path46) {
     rx *= mathSqrt3(lambda);
     ry *= mathSqrt3(lambda);
   }
-  var f = (fa === fs44 ? -1 : 1) * mathSqrt3((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp))) || 0;
+  var f = (fa === fs45 ? -1 : 1) * mathSqrt3((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp))) || 0;
   var cxp = f * rx * yp / ry;
   var cyp = f * -ry * xp / rx;
   var cx = (x1 + x2) / 2 + mathCos3(psi) * cxp - mathSin3(psi) * cyp;
@@ -115878,7 +116095,7 @@ function processArc(x1, y1, x2, y2, fa, fs44, rx, ry, psiDeg, cmd, path46) {
     var n = Math.round(dTheta / PI3 * 1e6) / 1e6;
     dTheta = PI3 * 2 + n % 2 * PI3;
   }
-  path46.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs44);
+  path46.addData(cmd, cx, cy, rx, ry, theta, dTheta, psi, fs45);
 }
 function createPathProxyFromString(data) {
   var path46 = new PathProxy_default();
@@ -115912,7 +116129,7 @@ function createPathProxyFromString(data) {
       var ry = void 0;
       var psi = void 0;
       var fa = void 0;
-      var fs44 = void 0;
+      var fs45 = void 0;
       var x1 = cpx;
       var y1 = cpy;
       var len2 = void 0;
@@ -116061,24 +116278,24 @@ function createPathProxyFromString(data) {
           ry = p[off++];
           psi = p[off++];
           fa = p[off++];
-          fs44 = p[off++];
+          fs45 = p[off++];
           x1 = cpx, y1 = cpy;
           cpx = p[off++];
           cpy = p[off++];
           cmd = CMD6.A;
-          processArc(x1, y1, cpx, cpy, fa, fs44, rx, ry, psi, cmd, path46);
+          processArc(x1, y1, cpx, cpy, fa, fs45, rx, ry, psi, cmd, path46);
           break;
         case "a":
           rx = p[off++];
           ry = p[off++];
           psi = p[off++];
           fa = p[off++];
-          fs44 = p[off++];
+          fs45 = p[off++];
           x1 = cpx, y1 = cpy;
           cpx += p[off++];
           cpy += p[off++];
           cmd = CMD6.A;
-          processArc(x1, y1, cpx, cpy, fa, fs44, rx, ry, psi, cmd, path46);
+          processArc(x1, y1, cpx, cpy, fa, fs45, rx, ry, psi, cmd, path46);
           break;
       }
     }
@@ -182971,11 +183188,11 @@ var init_ChartSsrRenderer = __esm({
 });
 
 // src/server/charts/ChartDocumentStore.ts
-var fs28, path31, ChartDocumentStore;
+var fs29, path31, ChartDocumentStore;
 var init_ChartDocumentStore = __esm({
   "src/server/charts/ChartDocumentStore.ts"() {
     "use strict";
-    fs28 = __toESM(require("fs/promises"));
+    fs29 = __toESM(require("fs/promises"));
     path31 = __toESM(require("path"));
     init_ChartSpecV1();
     ChartDocumentStore = class {
@@ -183012,8 +183229,8 @@ var init_ChartDocumentStore = __esm({
         if (!target.endsWith(".chart.yml") && !target.endsWith(".chart.yaml")) {
           throw new Error("Chart path must end in .chart.yml or .chart.yaml");
         }
-        await fs28.mkdir(path31.dirname(target), { recursive: true });
-        await fs28.writeFile(target, `${JSON.stringify(validation.spec, null, 2)}
+        await fs29.mkdir(path31.dirname(target), { recursive: true });
+        await fs29.writeFile(target, `${JSON.stringify(validation.spec, null, 2)}
 `, "utf8");
         return path31.relative(this.workspaceRoot, target);
       }
@@ -183034,7 +183251,7 @@ var init_ChartDocumentStore = __esm({
       async readDirectory(directory) {
         let entries;
         try {
-          entries = await fs28.readdir(directory, { withFileTypes: true });
+          entries = await fs29.readdir(directory, { withFileTypes: true });
         } catch (error52) {
           if (error52.code === "ENOENT") {
             return [];
@@ -183047,7 +183264,7 @@ var init_ChartDocumentStore = __esm({
           if (entry.isDirectory()) {
             results.push(...await this.readDirectory(child));
           } else if (/\.chart\.ya?ml$/i.test(entry.name)) {
-            const validation = validateChartSpec(JSON.parse(await fs28.readFile(child, "utf8")));
+            const validation = validateChartSpec(JSON.parse(await fs29.readFile(child, "utf8")));
             if (validation.valid) {
               results.push({
                 path: path31.relative(this.workspaceRoot, child),
@@ -183171,6 +183388,24 @@ var init_DaemonMcpToolManager = __esm({
       get isConfirmWrites() {
         return this.confirmWrites;
       }
+      async humanWriteConfirmation(sql, connectionId, clientConsent) {
+        if (!this.confirmWrites) {
+          return void 0;
+        }
+        let dialect = "unknown";
+        try {
+          const profile = await this.queryExecutor.resolveProfile(
+            sql,
+            connectionId,
+            void 0,
+            clientConsent
+          );
+          dialect = isConnectorType(profile?.type) ? profile.type : "unknown";
+        } catch {
+          dialect = "unknown";
+        }
+        return humanConfirmationFor(sql, dialect);
+      }
       /** Updates human write confirmation requirement live (e.g. from a settings-panel save). */
       setConfirmWrites(value) {
         this.confirmWrites = value;
@@ -183199,7 +183434,7 @@ var init_DaemonMcpToolManager = __esm({
        * received from the client.
        */
       captureUiEvent(event, properties, clientConsent) {
-        this.options.telemetry?.capture(event, properties, clientConsent);
+        this.options.telemetry?.capture(event, { state: "unknown", ...properties }, clientConsent);
       }
       /** False for an alpha tool whose feature flag is off; such a tool is unlisted and uncallable. */
       isToolEnabled(name) {
@@ -183265,7 +183500,11 @@ var init_DaemonMcpToolManager = __esm({
         const success2 = thrown === void 0 && resultRecord?.isError !== true;
         let errorKind;
         let errorId;
+        let errorCode;
+        let errorClass;
         if (!success2) {
+          errorCode = thrown !== void 0 ? diagnosticErrorCodeOf(thrown) : normalizeTelemetryDiagnosticErrorCode(resultRecord?.structuredContent?.errorCode);
+          errorClass = thrown !== void 0 ? diagnosticErrorClassOf(thrown) : normalizeTelemetryDiagnosticErrorClass(resultRecord?.structuredContent?.errorClass);
           errorKind = thrown !== void 0 ? classifyErrorLike(thrown) : typeof resultRecord?.structuredContent?.errorKind === "string" ? resultRecord.structuredContent.errorKind : "unknown";
           if (typeof resultRecord?.structuredContent?.errorId === "string") {
             errorId = resultRecord.structuredContent.errorId;
@@ -183273,21 +183512,26 @@ var init_DaemonMcpToolManager = __esm({
         }
         const profileType = args;
         const connectorSource = typeof profileType?.connectionProfile?.type === "string" ? profileType.connectionProfile.type : typeof profileType?.type === "string" ? profileType.type : void 0;
+        const invoked = {
+          state: "mcp_server",
+          source: "mcp",
+          // Which agent transport this arrived on. Gating emission on origin without
+          // recording it left RFC-082's rollout unmeasurable (#113).
+          origin: origin2,
+          mcp_client: clientLabel,
+          tool_name: normalizeTelemetryToolName(name),
+          success: success2,
+          duration_bucket: bucketDurationMs(Date.now() - startedAt),
+          ...connectorSource !== void 0 ? { connector: normalizeTelemetryConnector(connectorSource) } : {}
+        };
         telemetry.capture(
           "mcp_tool_invoked",
-          {
-            state: "mcp_server",
-            source: "mcp",
-            // Which agent transport this arrived on. Gating emission on origin without
-            // recording it left RFC-082's rollout unmeasurable (#113).
-            origin: origin2,
-            mcp_client: clientLabel,
-            tool_name: normalizeTelemetryToolName(name),
-            success: success2,
-            duration_bucket: bucketDurationMs(Date.now() - startedAt),
-            ...errorKind !== void 0 ? { error_kind: errorKind } : {},
-            ...errorId !== void 0 ? { error_id: errorId } : {},
-            ...connectorSource !== void 0 ? { connector: normalizeTelemetryConnector(connectorSource) } : {}
+          success2 ? invoked : {
+            ...invoked,
+            error_kind: errorKind ?? "unknown",
+            ...errorCode !== void 0 ? { error_code: errorCode } : {},
+            ...errorClass !== void 0 ? { error_class: errorClass } : {},
+            ...errorId !== void 0 ? { error_id: errorId } : {}
           },
           clientConsent
         );
@@ -183311,50 +183555,33 @@ var init_DaemonMcpToolManager = __esm({
         const refusal = admitToolCall(profile, name, this.isToolEnabled(name));
         if (refusal)
           return refusal;
-        switch (name) {
-          case "run_query":
-            return this.handleRunQuery(args, origin2, profile, clientConsent);
-          case "get_tab_info":
-            return this.handleGetTabInfo(args);
-          case "list_sessions":
-            return this.handleListSessions();
-          case "list_connectors":
-            return this.handleListConnectors();
-          case "list_connections":
-            return this.handleListConnections();
-          case "save_connection":
-            return this.handleSaveConnection(args, clientConsent);
-          case "request_connection_credentials":
-            return this.handleRequestConnectionCredentials(args, clientConsent);
-          case "test_connection":
-            return this.handleTestConnection(args, origin2, clientConsent);
-          case "delete_connection":
-            return this.handleDeleteConnection(args);
-          case "list_schemas":
-            return this.handleListSchemas(args, clientConsent);
-          case "list_tables":
-            return this.handleListTables(args, clientConsent);
-          case "describe_table":
-            return this.handleDescribeTable(args, clientConsent);
-          case "cancel_query":
-            return this.handleCancelQuery(args);
-          case "close_tab":
-            return this.handleCloseTab(args);
-          case "render_chart":
-            return this.handleRenderChart(args);
-          case "save_chart":
-            return this.handleSaveChart(args, workspaceRoot);
-          case "list_charts":
-            return this.handleListCharts(workspaceRoot);
-          case "ledger_stats":
-            return this.handleLedgerStats(clientConsent);
-          case "verify_ledger":
-            return this.handleVerifyLedger(clientConsent);
-          case "record_ui_event":
-            return this.handleRecordUiEvent(args, clientConsent);
-          default:
-            throw new Error("Unknown tool");
-        }
+        const handlers3 = {
+          run_query: () => this.handleRunQuery(args, origin2, profile, clientConsent),
+          get_tab_info: () => this.handleGetTabInfo(args),
+          list_sessions: () => this.handleListSessions(),
+          list_connectors: () => this.handleListConnectors(),
+          list_connections: () => this.handleListConnections(),
+          save_connection: () => this.handleSaveConnection(args, clientConsent),
+          request_connection_credentials: () => this.handleRequestConnectionCredentials(args, clientConsent),
+          test_connection: () => this.handleTestConnection(args, origin2, clientConsent),
+          delete_connection: () => this.handleDeleteConnection(args),
+          list_schemas: () => this.handleListSchemas(args, clientConsent),
+          list_tables: () => this.handleListTables(args, clientConsent),
+          describe_table: () => this.handleDescribeTable(args, clientConsent),
+          cancel_query: () => this.handleCancelQuery(args),
+          close_tab: () => this.handleCloseTab(args),
+          render_chart: () => this.handleRenderChart(args),
+          save_chart: () => this.handleSaveChart(args, workspaceRoot),
+          list_charts: () => this.handleListCharts(workspaceRoot),
+          ledger_stats: () => this.handleLedgerStats(clientConsent),
+          verify_ledger: () => this.handleVerifyLedger(clientConsent),
+          record_ui_event: () => this.handleRecordUiEvent(args, clientConsent)
+        };
+        const definition = TOOL_DEFINITIONS.find((def) => def.name === name);
+        if (!definition) {
+          throw new Error("Unknown tool");
+        }
+        return handlers3[definition.name]();
       }
       /**
        * RFC-088 Rung 2. The MCP app renders in an opaque-origin sandbox that cannot
@@ -183409,7 +183636,11 @@ var init_DaemonMcpToolManager = __esm({
           return {
             isError: true,
             content: [{ type: "text", text: e2 instanceof Error ? e2.message : String(e2) }],
-            structuredContent: { errorKind: classifyErrorLike(e2) }
+            structuredContent: {
+              errorKind: classifyErrorLike(e2),
+              errorCode: diagnosticErrorCodeOf(e2),
+              errorClass: diagnosticErrorClassOf(e2)
+            }
           };
         }
       }
@@ -183431,7 +183662,11 @@ var init_DaemonMcpToolManager = __esm({
           return {
             isError: true,
             content: [{ type: "text", text: e2 instanceof Error ? e2.message : String(e2) }],
-            structuredContent: { errorKind: classifyErrorLike(e2) }
+            structuredContent: {
+              errorKind: classifyErrorLike(e2),
+              errorCode: diagnosticErrorCodeOf(e2),
+              errorClass: diagnosticErrorClassOf(e2)
+            }
           };
         }
       }
@@ -183454,7 +183689,11 @@ var init_DaemonMcpToolManager = __esm({
           return {
             isError: true,
             content: [{ type: "text", text: e2 instanceof Error ? e2.message : String(e2) }],
-            structuredContent: { errorKind: classifyErrorLike(e2) }
+            structuredContent: {
+              errorKind: classifyErrorLike(e2),
+              errorCode: diagnosticErrorCodeOf(e2),
+              errorClass: diagnosticErrorClassOf(e2)
+            }
           };
         }
       }
@@ -183720,9 +183959,16 @@ This link expires at ${new Date(
         } catch (error52) {
           const errorKind = classifyErrorLike(error52, typeToTest);
           const message = error52 instanceof Error ? error52.message : String(error52);
+          const errorCode = diagnosticErrorCodeOf(error52);
+          const errorClass = diagnosticErrorClassOf(error52);
           return this.failConnectionTest(
             `Connection Test Failed: ${message}`,
-            { errorKind, errorId: "connection_test_connection_failed" },
+            {
+              errorKind,
+              errorId: "connection_test_connection_failed",
+              ...errorCode !== void 0 ? { errorCode } : {},
+              ...errorClass !== void 0 ? { errorClass } : {}
+            },
             clientConsent
           );
         }
@@ -183741,13 +183987,21 @@ This link expires at ${new Date(
           if (errorKind === "config") {
             return this.failConnectionTest(
               message,
-              { errorKind, errorId: "connection_test_configuration_invalid" },
+              {
+                errorKind,
+                errorId: "connection_test_configuration_invalid",
+                ...result.errorCode !== void 0 ? { errorCode: result.errorCode } : {}
+              },
               clientConsent
             );
           }
           return this.failConnectionTest(
             message,
-            { errorKind, errorId: "connection_test_connection_failed" },
+            {
+              errorKind,
+              errorId: "connection_test_connection_failed",
+              ...result.errorCode !== void 0 ? { errorCode: result.errorCode } : {}
+            },
             clientConsent
           );
         }
@@ -183845,11 +184099,9 @@ This link expires at ${new Date(
             }
           }
           if (isHumanOrigin(origin2) && this.confirmWrites && !confirmWrite) {
-            const verdict = classifyForHumanGate(sql, dialect);
-            if (verdict.kind === "confirm") {
-              const classification = verdict.classification;
-              const message = classification.kind === "write" ? `Confirmation required for write statement (${classification.keyword}).` : classification.kind === "multi_statement" ? `Confirmation required for multi-statement query (${classification.count} statements).` : "Confirmation required because the connection dialect could not be resolved.";
-              const confirmation = classification.kind === "write" ? { kind: "write", keyword: classification.keyword } : classification.kind === "multi_statement" ? { kind: "multi_statement", count: classification.count } : { kind: "unknown_dialect" };
+            const gate = humanConfirmationFor(sql, dialect);
+            if (gate) {
+              const { message, confirmation } = gate;
               return withQueryCallKey(
                 {
                   isError: true,
@@ -183912,7 +184164,9 @@ This link expires at ${new Date(
                 status: "error",
                 sessionId,
                 error: message,
-                errorKind: classifyErrorLike(error52)
+                errorKind: classifyErrorLike(error52),
+                errorCode: diagnosticErrorCodeOf(error52),
+                errorClass: diagnosticErrorClassOf(error52)
               }
             },
             callKey
@@ -183984,13 +184238,25 @@ This link expires at ${new Date(
         };
       }
       async handleLedgerStats(clientConsent) {
-        if (!this.ledger)
+        if (!this.ledger) {
+          this.options.telemetry?.capture(
+            "ledger_health",
+            {
+              state: "daemon",
+              outcome: "disabled",
+              entries_bucket: "0",
+              write_failures_bucket: "0"
+            },
+            clientConsent
+          );
           return textToolResult("Ledger disabled.");
+        }
         const stats = await this.ledger.stats();
         this.options.telemetry?.capture(
           "ledger_health",
           {
             state: "daemon",
+            outcome: "enabled",
             entries_bucket: bucketRowCount(stats.persisted_entries),
             write_failures_bucket: bucketRowCount(stats.write_failures)
           },
@@ -183999,8 +184265,19 @@ This link expires at ${new Date(
         return { content: [{ type: "text", text: JSON.stringify(stats) }], structuredContent: stats };
       }
       async handleVerifyLedger(clientConsent) {
-        if (!this.ledger)
+        if (!this.ledger) {
+          this.options.telemetry?.capture(
+            "ledger_verify_completed",
+            {
+              state: "daemon",
+              outcome: "disabled",
+              entries_checked_bucket: "0",
+              duration_bucket: "<100ms"
+            },
+            clientConsent
+          );
           return textToolResult("Ledger disabled.");
+        }
         const startedAt = Date.now();
         const result = await verifyLedger(this.ledger);
         this.options.telemetry?.capture(
@@ -184684,6 +184961,7 @@ var init_DaemonQueryExecutor = __esm({
     init_optionalDrivers();
     init_sqlPolicy();
     init_classifyQueryError();
+    init_TelemetrySchema();
     init_DaemonConfig();
     init_SubProcessConnectorClient();
     init_ConnectorProcessPool();
@@ -184872,6 +185150,15 @@ var init_DaemonQueryExecutor = __esm({
           }
           if (!profile && connectionId) {
             profile = await this.connectionManager.getProfile(connectionId, clientConsent);
+            if (!profile) {
+              throw attachErrorKind(
+                new AppError(
+                  "query_no_connection_profile",
+                  `The connection '${connectionId}' no longer exists. Pick another connection and run the query again.`
+                ),
+                "config"
+              );
+            }
           }
           if (!profile) {
             this.logger.info(`Fetching connections for fallback...`);
@@ -185035,7 +185322,13 @@ var init_DaemonQueryExecutor = __esm({
           return { success: true };
         } catch (e2) {
           const message = e2 instanceof Error ? e2.message : String(e2);
-          return { success: false, error: message, errorKind: classifyErrorLike(e2) };
+          const errorCode = diagnosticErrorCodeOf(e2);
+          return {
+            success: false,
+            error: message,
+            errorKind: classifyErrorLike(e2),
+            ...errorCode !== void 0 ? { errorCode } : {}
+          };
         }
       }
     };
@@ -192619,9 +192912,9 @@ var init_requireDaemonAuth = __esm({
 // src/server/surfaces/DaemonSettingsRoute.ts
 function persistConfigPatch(configPath, patch2) {
   let onDisk = {};
-  if (fs29.existsSync(configPath)) {
+  if (fs30.existsSync(configPath)) {
     try {
-      onDisk = JSON.parse(fs29.readFileSync(configPath, "utf8"));
+      onDisk = JSON.parse(fs30.readFileSync(configPath, "utf8"));
     } catch (err) {
       logger.warn(`[Daemon] Could not parse existing config at ${configPath}, overwriting:`, err);
       onDisk = {};
@@ -192633,7 +192926,7 @@ function persistConfigPatch(configPath, patch2) {
   if (patch2.mcp) {
     onDisk["mcp"] = { ...onDisk["mcp"], ...patch2.mcp };
   }
-  fs29.writeFileSync(configPath, JSON.stringify(onDisk, null, 2) + "\n");
+  fs30.writeFileSync(configPath, JSON.stringify(onDisk, null, 2) + "\n");
 }
 function createSettingsUpdateHandler(context2) {
   return (req, res) => {
@@ -192695,11 +192988,11 @@ function createSettingsUpdateHandler(context2) {
     }
   };
 }
-var fs29, SETTINGS_SAFE_MODE_DECLINED_MESSAGE, SETTINGS_CONFIRM_WRITES_DECLINED_MESSAGE;
+var fs30, SETTINGS_SAFE_MODE_DECLINED_MESSAGE, SETTINGS_CONFIRM_WRITES_DECLINED_MESSAGE;
 var init_DaemonSettingsRoute = __esm({
   "src/server/surfaces/DaemonSettingsRoute.ts"() {
     "use strict";
-    fs29 = __toESM(require("fs"));
+    fs30 = __toESM(require("fs"));
     init_ConsoleLogger();
     init_requireDaemonAuth();
     init_ClientIdentity();
@@ -192750,13 +193043,13 @@ function distFileCandidates(fileName, baseDir = __dirname) {
 }
 function findDistFile(fileName, baseDir = __dirname) {
   const candidates = distFileCandidates(fileName, baseDir);
-  return candidates.find((candidate) => fs30.existsSync(candidate)) ?? candidates[1] ?? fileName;
+  return candidates.find((candidate) => fs31.existsSync(candidate)) ?? candidates[1] ?? fileName;
 }
-var fs30, path33;
+var fs31, path33;
 var init_distFiles = __esm({
   "src/server/surfaces/distFiles.ts"() {
     "use strict";
-    fs30 = __toESM(require("fs"));
+    fs31 = __toESM(require("fs"));
     path33 = __toESM(require("path"));
   }
 });
@@ -193327,6 +193620,22 @@ async function handleQueryRoute(context2, req, res, options) {
       res.status(400).json({ error: options.missingQueryMessage });
       return;
     }
+    const connectionId = options.supportsConnectionId && typeof body.connectionId === "string" ? body.connectionId : void 0;
+    if (body.confirmWrite !== true) {
+      const gate = await context2.toolManager.humanWriteConfirmation(
+        query,
+        connectionId,
+        profiles.consent
+      );
+      if (gate) {
+        res.status(409).json({
+          status: "confirmation_required",
+          error: gate.message,
+          confirmation: gate.confirmation
+        });
+        return;
+      }
+    }
     const sessionId = typeof body.sessionId === "string" && body.sessionId.length > 0 ? body.sessionId : `${options.sessionPrefix}-${import_crypto11.default.randomUUID()}`;
     const controller = new AbortController();
     const cleanupDisconnectAbort = attachAbortOnHttpDisconnect(
@@ -193347,7 +193656,7 @@ async function handleQueryRoute(context2, req, res, options) {
           origin: "http_api",
           ...isSafeModeActive(policy.profile, context2.resolvedConfig.config.mcp.safeMode) ? { enforceReadOnly: true } : {},
           ...typeof body.tabId === "string" ? { tabId: body.tabId } : {},
-          ...options.supportsConnectionId && typeof body.connectionId === "string" ? { connectionId: body.connectionId } : {},
+          ...connectionId !== void 0 ? { connectionId } : {},
           clientConsent: profiles.consent
         })
       );
@@ -193400,12 +193709,12 @@ function sendQueryResult(res, result) {
 function serveHtmlFile(res, fileName, notFoundMessage) {
   try {
     const htmlPath = findDistFile(fileName);
-    if (!fs31.existsSync(htmlPath)) {
+    if (!fs32.existsSync(htmlPath)) {
       res.status(404).send(notFoundMessage);
       return;
     }
     res.setHeader("Content-Type", "text/html");
-    fs31.createReadStream(htmlPath).pipe(res);
+    fs32.createReadStream(htmlPath).pipe(res);
   } catch (err) {
     logger.error(`[Daemon] Failed to serve ${fileName}:`, err);
     res.status(500).send("Internal Server Error");
@@ -193477,13 +193786,13 @@ function escapeHtml(value) {
     }
   });
 }
-var import_crypto11, import_express, fs31, WEB_APP_CSP_DIRECTIVES, webProxiedTools;
+var import_crypto11, import_express, fs32, WEB_APP_CSP_DIRECTIVES, webProxiedTools;
 var init_DaemonHttpRoutes = __esm({
   "src/server/surfaces/DaemonHttpRoutes.ts"() {
     "use strict";
     import_crypto11 = __toESM(require("crypto"));
     import_express = __toESM(require_express2());
-    fs31 = __toESM(require("fs"));
+    fs32 = __toESM(require("fs"));
     init_ConsoleLogger();
     init_httpAbort();
     init_toolProfiles();
@@ -203328,12 +203637,12 @@ var require_dist3 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs44, exportName) {
+    function addFormats(ajv, list, fs45, exportName) {
       var _a4;
       var _b2;
       (_a4 = (_b2 = ajv.opts.code).formats) !== null && _a4 !== void 0 ? _a4 : _b2.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs44[f]);
+        ajv.addFormat(f, fs45[f]);
     }
     module2.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -228684,7 +228993,7 @@ function readFileFromEnv(signalSpecificEnvVar, nonSignalSpecificEnvVar, warningM
   const filePath = signalSpecificPath ?? nonSignalSpecificPath;
   if (filePath != null) {
     try {
-      return fs32.readFileSync(path34.resolve(process.cwd(), filePath));
+      return fs33.readFileSync(path34.resolve(process.cwd(), filePath));
     } catch {
       diag2.warn(warningMessage);
       return void 0;
@@ -228715,10 +229024,10 @@ function getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourc
     })
   };
 }
-var fs32, path34, import_core24;
+var fs33, path34, import_core24;
 var init_otlp_node_http_env_configuration = __esm({
   "node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js"() {
-    fs32 = __toESM(require("fs"));
+    fs33 = __toESM(require("fs"));
     path34 = __toESM(require("path"));
     import_core24 = __toESM(require_src2());
     init_esm2();
@@ -230422,7 +230731,7 @@ var require_utils14 = __commonJS({
     var exporter_metrics_otlp_http_1 = require_src20();
     var exporter_metrics_otlp_proto_1 = require_src21();
     var sdk_logs_1 = require_src5();
-    var fs44 = require("fs");
+    var fs45 = require("fs");
     var RESOURCE_DETECTOR_ENVIRONMENT = "env";
     var RESOURCE_DETECTOR_HOST = "host";
     var RESOURCE_DETECTOR_OS = "os";
@@ -230845,21 +231154,21 @@ var require_utils14 = __commonJS({
         const httpsAgentOptions = {};
         if (tls.ca_file) {
           try {
-            httpsAgentOptions.ca = fs44.readFileSync(tls.ca_file);
+            httpsAgentOptions.ca = fs45.readFileSync(tls.ca_file);
           } catch (e2) {
             api_1.diag.warn(`Failed to read TLS CA file at ${tls.ca_file}: ${e2}`);
           }
         }
         if (tls.cert_file) {
           try {
-            httpsAgentOptions.cert = fs44.readFileSync(tls.cert_file);
+            httpsAgentOptions.cert = fs45.readFileSync(tls.cert_file);
           } catch (e2) {
             api_1.diag.warn(`Failed to read TLS cert file at ${tls.cert_file}: ${e2}`);
           }
         }
         if (tls.key_file) {
           try {
-            httpsAgentOptions.key = fs44.readFileSync(tls.key_file);
+            httpsAgentOptions.key = fs45.readFileSync(tls.key_file);
           } catch (e2) {
             api_1.diag.warn(`Failed to read TLS key file at ${tls.key_file}: ${e2}`);
           }
@@ -231838,12 +232147,12 @@ var init_guideHub = __esm({
 });
 
 // src/server/DaemonMcpServer.ts
-var fs33, import_crypto13, import_url3, UI_RESOURCE_URI, GUIDE_HUB_RESOURCE_URI, DaemonMcpServer;
+var fs34, import_crypto13, import_url3, UI_RESOURCE_URI, GUIDE_HUB_RESOURCE_URI, DaemonMcpServer;
 var init_DaemonMcpServer = __esm({
   "src/server/DaemonMcpServer.ts"() {
     "use strict";
     init_types();
-    fs33 = __toESM(require("fs"));
+    fs34 = __toESM(require("fs"));
     import_crypto13 = require("crypto");
     init_telemetry();
     init_esm2();
@@ -232022,7 +232331,7 @@ var init_DaemonMcpServer = __esm({
           if (uri === UI_RESOURCE_URI) {
             try {
               const htmlPath = findDistFile("mcp-app.html");
-              const html = await fs33.promises.readFile(htmlPath, "utf-8");
+              const html = await fs34.promises.readFile(htmlPath, "utf-8");
               const result2 = {
                 contents: [
                   {
@@ -232481,11 +232790,11 @@ var init_ExtensionConnectionTracker = __esm({
 });
 
 // src/server/surfaces/DaemonSocketSurface.ts
-var fs34, net2, path35, bindSequence, DaemonSocketSurface;
+var fs35, net2, path35, bindSequence, DaemonSocketSurface;
 var init_DaemonSocketSurface = __esm({
   "src/server/surfaces/DaemonSocketSurface.ts"() {
     "use strict";
-    fs34 = __toESM(require("fs"));
+    fs35 = __toESM(require("fs"));
     net2 = __toESM(require("net"));
     path35 = __toESM(require("path"));
     init_ipcEndpoint();
@@ -232521,8 +232830,8 @@ var init_DaemonSocketSurface = __esm({
           return;
         }
         if (isRelocatedDaemonIpcEndpoint(this.options.configDir, this.options.socketPath)) {
-          fs34.mkdirSync(path35.dirname(this.options.socketPath), { recursive: true, mode: 448 });
-          fs34.chmodSync(path35.dirname(this.options.socketPath), 448);
+          fs35.mkdirSync(path35.dirname(this.options.socketPath), { recursive: true, mode: 448 });
+          fs35.chmodSync(path35.dirname(this.options.socketPath), 448);
           logger.warn(
             `[Daemon] Relocated IPC endpoint from ${path35.join(this.options.configDir, "srv.sock")} to ${this.options.socketPath}.`
           );
@@ -232538,9 +232847,9 @@ var init_DaemonSocketSurface = __esm({
           );
         }
         const bindPath = canPublishByRename ? privatePath : this.options.socketPath;
-        if (usesFilesystemPath && fs34.existsSync(bindPath)) {
+        if (usesFilesystemPath && fs35.existsSync(bindPath)) {
           try {
-            fs34.unlinkSync(bindPath);
+            fs35.unlinkSync(bindPath);
           } catch (e2) {
             logger.warn("Failed to clean up socket:", e2);
           }
@@ -232594,8 +232903,8 @@ var init_DaemonSocketSurface = __esm({
           const onListen = () => {
             if (canPublishByRename) {
               try {
-                fs34.renameSync(bindPath, this.options.socketPath);
-                this.ownedEndpointInode = fs34.statSync(this.options.socketPath).ino;
+                fs35.renameSync(bindPath, this.options.socketPath);
+                this.ownedEndpointInode = fs35.statSync(this.options.socketPath).ino;
               } catch (error52) {
                 cleanup();
                 reject(error52);
@@ -232678,10 +232987,10 @@ var init_DaemonSocketSurface = __esm({
           return;
         }
         try {
-          if (fs34.statSync(this.options.socketPath).ino !== owned) {
+          if (fs35.statSync(this.options.socketPath).ino !== owned) {
             return;
           }
-          fs34.unlinkSync(this.options.socketPath);
+          fs35.unlinkSync(this.options.socketPath);
         } catch {
         }
       }
@@ -247393,12 +247702,12 @@ var init_artifactPins_generated = __esm({
 });
 
 // src/server/runtime/ManagedArtifactRuntime.ts
-var crypto18, fs35, import_module, os7, path36, ORPHAN_DOWNLOAD_MIN_AGE_MS, WAIT_LOG_INTERVAL_MS, requireFromRuntime, ManagedArtifactRuntime;
+var crypto18, fs36, import_module, os7, path36, ORPHAN_DOWNLOAD_MIN_AGE_MS, WAIT_LOG_INTERVAL_MS, requireFromRuntime, ManagedArtifactRuntime;
 var init_ManagedArtifactRuntime = __esm({
   "src/server/runtime/ManagedArtifactRuntime.ts"() {
     "use strict";
     crypto18 = __toESM(require("crypto"));
-    fs35 = __toESM(require("fs"));
+    fs36 = __toESM(require("fs"));
     import_module = require("module");
     os7 = __toESM(require("os"));
     path36 = __toESM(require("path"));
@@ -247477,7 +247786,7 @@ var init_ManagedArtifactRuntime = __esm({
         const manifestPath = artifactManifestPath(versionDir);
         const existing = readManifest(manifestPath);
         if (existing && existing.layoutVersion === 2 && existing.platform === platform2 && this.manifestVersion(existing) === pins.artifactVersion) {
-          if (fs35.existsSync(versionDir)) {
+          if (fs36.existsSync(versionDir)) {
             return versionDir;
           }
         }
@@ -247582,7 +247891,7 @@ var init_ManagedArtifactRuntime = __esm({
           }
         }
         const lockDir = `${versionDir}.provision-lock`;
-        fs35.mkdirSync(path36.dirname(lockDir), { recursive: true });
+        fs36.mkdirSync(path36.dirname(lockDir), { recursive: true });
         const lockWaitStartMs = Date.now();
         const staleMs = this.options.provisionLockStaleMs ?? 5 * 60 * 1e3;
         const maxWaitMs = this.options.provisionLockMaxWaitMs ?? 10 * 60 * 1e3;
@@ -247622,13 +247931,13 @@ var init_ManagedArtifactRuntime = __esm({
             );
           }
           try {
-            const stats = fs35.statSync(lockDir);
+            const stats = fs36.statSync(lockDir);
             const ageMs = Date.now() - stats.mtimeMs;
             if (ageMs > staleMs) {
               logger.warn(
                 `[${this.logTag()}] Breaking stale provisioning lock: ${lockDir}, ageMs=${ageMs}`
               );
-              fs35.rmSync(lockDir, { recursive: true, force: true });
+              fs36.rmSync(lockDir, { recursive: true, force: true });
               continue;
             }
           } catch (error52) {
@@ -247641,7 +247950,7 @@ var init_ManagedArtifactRuntime = __esm({
           heartbeatTimer = setInterval(() => {
             try {
               const now = Date.now() / 1e3;
-              fs35.utimesSync(lockDir, now, now);
+              fs36.utimesSync(lockDir, now, now);
             } catch (error52) {
             }
           }, heartbeatIntervalMs);
@@ -247654,9 +247963,9 @@ var init_ManagedArtifactRuntime = __esm({
           }
           if (provisionToken) {
             try {
-              const currentToken = fs35.readFileSync(path36.join(lockDir, "owner"), "utf-8");
+              const currentToken = fs36.readFileSync(path36.join(lockDir, "owner"), "utf-8");
               if (currentToken === provisionToken) {
-                fs35.rmSync(lockDir, { recursive: true, force: true });
+                fs36.rmSync(lockDir, { recursive: true, force: true });
               }
             } catch (error52) {
             }
@@ -247669,8 +247978,8 @@ var init_ManagedArtifactRuntime = __esm({
         }
         this.reapOrphans(versionDir);
         const tempDir = `${versionDir}-tmp-${process.pid}-${Date.now()}`;
-        fs35.rmSync(tempDir, { recursive: true, force: true });
-        fs35.mkdirSync(tempDir, { recursive: true });
+        fs36.rmSync(tempDir, { recursive: true, force: true });
+        fs36.mkdirSync(tempDir, { recursive: true });
         const downloadPaths = [];
         const downloadPrefix = `sql-preview-${this.options.artifactId}-`;
         try {
@@ -247692,7 +248001,7 @@ var init_ManagedArtifactRuntime = __esm({
             }
             const actualHash = await sha512File(downloadPath);
             if (!verifyIntegrity(actualHash, tarball.integrity)) {
-              fs35.rmSync(downloadPath, { force: true });
+              fs36.rmSync(downloadPath, { force: true });
               return this.fail("checksum_failed", `Integrity check failed for ${tarball.name}.`);
             }
             const packageDestDir = path36.join(
@@ -247701,10 +248010,10 @@ var init_ManagedArtifactRuntime = __esm({
             );
             await extractTarGz(downloadPath, packageDestDir);
             this.flattenNpmPackage(packageDestDir);
-            fs35.rmSync(downloadPath, { force: true });
+            fs36.rmSync(downloadPath, { force: true });
           }
-          fs35.rmSync(versionDir, { recursive: true, force: true });
-          fs35.renameSync(tempDir, versionDir);
+          fs36.rmSync(versionDir, { recursive: true, force: true });
+          fs36.renameSync(tempDir, versionDir);
           const manifestBase = {
             layoutVersion: 2,
             platform: platform2,
@@ -247735,12 +248044,12 @@ var init_ManagedArtifactRuntime = __esm({
           );
         } finally {
           try {
-            fs35.rmSync(tempDir, { recursive: true, force: true });
+            fs36.rmSync(tempDir, { recursive: true, force: true });
           } catch (error52) {
           }
           for (const downloadPath of downloadPaths) {
             try {
-              fs35.rmSync(downloadPath, { force: true });
+              fs36.rmSync(downloadPath, { force: true });
             } catch (error52) {
             }
           }
@@ -247749,9 +248058,9 @@ var init_ManagedArtifactRuntime = __esm({
           }
           if (provisionToken) {
             try {
-              const currentToken = fs35.readFileSync(path36.join(lockDir, "owner"), "utf-8");
+              const currentToken = fs36.readFileSync(path36.join(lockDir, "owner"), "utf-8");
               if (currentToken === provisionToken) {
-                fs35.rmSync(lockDir, { recursive: true, force: true });
+                fs36.rmSync(lockDir, { recursive: true, force: true });
               }
             } catch (error52) {
             }
@@ -247766,12 +248075,12 @@ var init_ManagedArtifactRuntime = __esm({
         const versionBase = path36.basename(versionDir);
         const prefix = `${versionBase}-tmp-`;
         try {
-          const siblings = fs35.readdirSync(parentDir);
+          const siblings = fs36.readdirSync(parentDir);
           for (const sibling of siblings) {
             if (sibling.startsWith(prefix)) {
               const siblingPath = path36.join(parentDir, sibling);
               try {
-                fs35.rmSync(siblingPath, { recursive: true, force: true });
+                fs36.rmSync(siblingPath, { recursive: true, force: true });
               } catch (error52) {
               }
             }
@@ -247780,16 +248089,16 @@ var init_ManagedArtifactRuntime = __esm({
         }
         try {
           const downloadDir = this.downloadDir();
-          const files = fs35.readdirSync(downloadDir);
+          const files = fs36.readdirSync(downloadDir);
           const now = Date.now();
           const downloadPrefix = `sql-preview-${this.options.artifactId}-`;
           for (const file4 of files) {
             if (file4.startsWith(downloadPrefix) && file4.endsWith(".tgz")) {
               const filePath = path36.join(downloadDir, file4);
               try {
-                const stats = fs35.statSync(filePath);
+                const stats = fs36.statSync(filePath);
                 if (now - stats.mtimeMs > ORPHAN_DOWNLOAD_MIN_AGE_MS) {
-                  fs35.rmSync(filePath, { force: true });
+                  fs36.rmSync(filePath, { force: true });
                 }
               } catch (error52) {
               }
@@ -247800,9 +248109,9 @@ var init_ManagedArtifactRuntime = __esm({
       }
       tryAcquireProvisionLock(lockDir) {
         try {
-          fs35.mkdirSync(lockDir, { recursive: false });
+          fs36.mkdirSync(lockDir, { recursive: false });
           const token = `${process.pid}-${crypto18.randomUUID()}`;
-          fs35.writeFileSync(path36.join(lockDir, "owner"), token, "utf-8");
+          fs36.writeFileSync(path36.join(lockDir, "owner"), token, "utf-8");
           return { acquired: true, token };
         } catch (error52) {
           if (error52.code === "EEXIST") {
@@ -247840,11 +248149,11 @@ var init_ManagedArtifactRuntime = __esm({
       }
       flattenNpmPackage(packageDestDir) {
         let archiveRoot = path36.join(packageDestDir, "package");
-        if (!fs35.statSync(archiveRoot, { throwIfNoEntry: false })?.isDirectory()) {
-          const entries = fs35.readdirSync(packageDestDir);
+        if (!fs36.statSync(archiveRoot, { throwIfNoEntry: false })?.isDirectory()) {
+          const entries = fs36.readdirSync(packageDestDir);
           if (entries.length === 1 && entries[0]) {
             const singleEntry = entries[0];
-            if (fs35.statSync(path36.join(packageDestDir, singleEntry)).isDirectory()) {
+            if (fs36.statSync(path36.join(packageDestDir, singleEntry)).isDirectory()) {
               archiveRoot = path36.join(packageDestDir, singleEntry);
             } else {
               throw new Error(
@@ -247857,10 +248166,10 @@ var init_ManagedArtifactRuntime = __esm({
             );
           }
         }
-        for (const entry of fs35.readdirSync(archiveRoot)) {
-          fs35.renameSync(path36.join(archiveRoot, entry), path36.join(packageDestDir, entry));
+        for (const entry of fs36.readdirSync(archiveRoot)) {
+          fs36.renameSync(path36.join(archiveRoot, entry), path36.join(packageDestDir, entry));
         }
-        fs35.rmdirSync(archiveRoot);
+        fs36.rmdirSync(archiveRoot);
       }
     };
   }
@@ -248056,11 +248365,11 @@ var init_DuckDbRuntime = __esm({
 });
 
 // src/server/runtime/DriverArtifactProvisioner.ts
-var fs36, path37, DRIVER_ARTIFACTS, DriverArtifactProvisioner;
+var fs37, path37, DRIVER_ARTIFACTS, DriverArtifactProvisioner;
 var init_DriverArtifactProvisioner = __esm({
   "src/server/runtime/DriverArtifactProvisioner.ts"() {
     "use strict";
-    fs36 = __toESM(require("fs"));
+    fs37 = __toESM(require("fs"));
     path37 = __toESM(require("path"));
     init_optionalDrivers();
     init_ManagedArtifactTypes();
@@ -248096,7 +248405,7 @@ var init_DriverArtifactProvisioner = __esm({
           pins.artifactVersion
         );
         const depPath = path37.join(versionDir, "node_modules", ...dependency.split("/"));
-        if (fs36.existsSync(depPath)) {
+        if (fs37.existsSync(depPath)) {
           return depPath;
         }
         return null;
@@ -248226,11 +248535,11 @@ function rowToLedgerEntry(row) {
 function describeError3(error52) {
   return error52 instanceof Error ? error52.message : String(error52);
 }
-var fs37, path38, LEDGER_DB_FILENAME, JOURNAL_SCHEMA_VERSION, META_KEY_SCHEMA_VERSION, META_KEY_HEAD_HASH, JournalStoreOpenError, openJournalPaths, JournalStore;
+var fs38, path38, LEDGER_DB_FILENAME, JOURNAL_SCHEMA_VERSION, META_KEY_SCHEMA_VERSION, META_KEY_HEAD_HASH, JournalStoreOpenError, openJournalPaths, JournalStore;
 var init_JournalStore = __esm({
   "src/server/ledger/JournalStore.ts"() {
     "use strict";
-    fs37 = __toESM(require("fs"));
+    fs38 = __toESM(require("fs"));
     path38 = __toESM(require("path"));
     init_canonicalSerialize();
     init_LedgerTypes();
@@ -248279,7 +248588,7 @@ var init_JournalStore = __esm({
         const lockPath = path38.join(options.storageDir, "execution-ledger.lock");
         let ownsLockfile = false;
         try {
-          fs37.mkdirSync(options.storageDir, { recursive: true });
+          fs38.mkdirSync(options.storageDir, { recursive: true });
         } catch (error52) {
           throw new JournalStoreOpenError(
             "io-error",
@@ -248290,9 +248599,9 @@ var init_JournalStore = __esm({
         while (attempts < 2) {
           attempts++;
           try {
-            const fd = fs37.openSync(lockPath, "wx");
-            fs37.writeSync(fd, process.pid.toString());
-            fs37.closeSync(fd);
+            const fd = fs38.openSync(lockPath, "wx");
+            fs38.writeSync(fd, process.pid.toString());
+            fs38.closeSync(fd);
             ownsLockfile = true;
             break;
           } catch (error52) {
@@ -248304,7 +248613,7 @@ var init_JournalStore = __esm({
             }
             let existingPid;
             try {
-              const pidContent = fs37.readFileSync(lockPath, "utf8");
+              const pidContent = fs38.readFileSync(lockPath, "utf8");
               existingPid = parseInt(pidContent, 10);
             } catch (readError) {
               if (readError.code === "ENOENT") {
@@ -248336,7 +248645,7 @@ var init_JournalStore = __esm({
               );
             }
             try {
-              fs37.unlinkSync(lockPath);
+              fs38.unlinkSync(lockPath);
             } catch (unlinkError) {
               if (unlinkError.code !== "ENOENT") {
                 throw new JournalStoreOpenError(
@@ -248356,7 +248665,7 @@ var init_JournalStore = __esm({
         } catch (error52) {
           if (ownsLockfile) {
             try {
-              fs37.unlinkSync(lockPath);
+              fs38.unlinkSync(lockPath);
             } catch {
             }
           }
@@ -248375,7 +248684,7 @@ var init_JournalStore = __esm({
         } catch (error52) {
           if (ownsLockfile) {
             try {
-              fs37.unlinkSync(lockPath);
+              fs38.unlinkSync(lockPath);
             } catch {
             }
           }
@@ -248484,7 +248793,7 @@ var init_JournalStore = __esm({
         this.connection.closeSync();
         this.instance.closeSync();
         try {
-          fs37.unlinkSync(this.lockPath);
+          fs38.unlinkSync(this.lockPath);
         } catch {
         }
       }
@@ -248931,11 +249240,11 @@ var init_LedgerService = __esm({
 function redactFatalText(text) {
   return text.replace(AUTHORIZATION_VALUE2, "$1 [redacted]").replace(SENSITIVE_ASSIGNMENT2, "$1[redacted]").replace(QUERY_ASSIGNMENT2, "$1[redacted]").replace(URL_SECRET2, "$1[redacted]");
 }
-var fs38, path39, MAX_BYTES, RETAINED_FILES, SENSITIVE_ASSIGNMENT2, QUERY_ASSIGNMENT2, AUTHORIZATION_VALUE2, URL_SECRET2, FatalJournal;
+var fs39, path39, MAX_BYTES, RETAINED_FILES, SENSITIVE_ASSIGNMENT2, QUERY_ASSIGNMENT2, AUTHORIZATION_VALUE2, URL_SECRET2, FatalJournal;
 var init_FatalJournal = __esm({
   "src/server/FatalJournal.ts"() {
     "use strict";
-    fs38 = __toESM(require("fs"));
+    fs39 = __toESM(require("fs"));
     path39 = __toESM(require("path"));
     MAX_BYTES = 5 * 1024 * 1024;
     RETAINED_FILES = 5;
@@ -248970,23 +249279,23 @@ ${redactFatalText(detail)}
           return;
         }
         try {
-          fs38.mkdirSync(this.logDir, { recursive: true, mode: 448 });
-          fs38.chmodSync(this.logDir, 448);
+          fs39.mkdirSync(this.logDir, { recursive: true, mode: 448 });
+          fs39.chmodSync(this.logDir, 448);
           const bytes = Buffer.byteLength(text);
           this.rotateIfNeeded(bytes);
           this.assertNotSymlink(this.logPath);
-          const noFollow = fs38.constants.O_NOFOLLOW ?? 0;
-          const fd = fs38.openSync(
+          const noFollow = fs39.constants.O_NOFOLLOW ?? 0;
+          const fd = fs39.openSync(
             this.logPath,
-            fs38.constants.O_APPEND | fs38.constants.O_CREAT | fs38.constants.O_WRONLY | noFollow,
+            fs39.constants.O_APPEND | fs39.constants.O_CREAT | fs39.constants.O_WRONLY | noFollow,
             384
           );
           try {
-            fs38.writeSync(fd, text);
-            fs38.fsyncSync(fd);
-            fs38.fchmodSync(fd, 384);
+            fs39.writeSync(fd, text);
+            fs39.fsyncSync(fd);
+            fs39.fchmodSync(fd, 384);
           } finally {
-            fs38.closeSync(fd);
+            fs39.closeSync(fd);
           }
         } catch {
           this.disabled = true;
@@ -248997,7 +249306,7 @@ ${redactFatalText(detail)}
         let currentBytes = 0;
         try {
           this.assertNotSymlink(this.logPath);
-          currentBytes = fs38.statSync(this.logPath).size;
+          currentBytes = fs39.statSync(this.logPath).size;
         } catch (error52) {
           if (error52.code !== "ENOENT") {
             throw error52;
@@ -249007,27 +249316,27 @@ ${redactFatalText(detail)}
           return;
         }
         const oldest = `${this.logPath}.${RETAINED_FILES}`;
-        if (fs38.existsSync(oldest)) {
+        if (fs39.existsSync(oldest)) {
           this.assertNotSymlink(oldest);
-          fs38.unlinkSync(oldest);
+          fs39.unlinkSync(oldest);
         }
         for (let index = RETAINED_FILES - 1; index >= 1; index--) {
           const source = `${this.logPath}.${index}`;
-          if (!fs38.existsSync(source)) {
+          if (!fs39.existsSync(source)) {
             continue;
           }
           this.assertNotSymlink(source);
-          fs38.renameSync(source, `${this.logPath}.${index + 1}`);
+          fs39.renameSync(source, `${this.logPath}.${index + 1}`);
         }
-        if (fs38.existsSync(this.logPath)) {
+        if (fs39.existsSync(this.logPath)) {
           this.assertNotSymlink(this.logPath);
-          fs38.renameSync(this.logPath, `${this.logPath}.1`);
-          fs38.chmodSync(`${this.logPath}.1`, 384);
+          fs39.renameSync(this.logPath, `${this.logPath}.1`);
+          fs39.chmodSync(`${this.logPath}.1`, 384);
         }
       }
       assertNotSymlink(target) {
         try {
-          if (fs38.lstatSync(target).isSymbolicLink()) {
+          if (fs39.lstatSync(target).isSymbolicLink()) {
             throw new Error("Refusing to write fatal journal through a symbolic link");
           }
         } catch (error52) {
@@ -249100,11 +249409,11 @@ var init_registerDriverModulePath = __esm({
 function faultIdentity(daemonVersion, kind, errorName) {
   return `${daemonVersion}:${kind}:${errorName}`;
 }
-var fs39, path41, DIAGNOSTICS_REPORT_BUDGET, DIAGNOSTICS_BUDGET_WINDOW_MS, MAX_RETAINED_REPORTS, BUDGET_VERSION, DiagnosticsBudget;
+var fs40, path41, DIAGNOSTICS_REPORT_BUDGET, DIAGNOSTICS_BUDGET_WINDOW_MS, MAX_RETAINED_REPORTS, BUDGET_VERSION, DiagnosticsBudget;
 var init_DiagnosticsBudget = __esm({
   "src/server/DiagnosticsBudget.ts"() {
     "use strict";
-    fs39 = __toESM(require("fs"));
+    fs40 = __toESM(require("fs"));
     path41 = __toESM(require("path"));
     DIAGNOSTICS_REPORT_BUDGET = 3;
     DIAGNOSTICS_BUDGET_WINDOW_MS = 60 * 6e4;
@@ -249118,10 +249427,10 @@ var init_DiagnosticsBudget = __esm({
       }
       read() {
         try {
-          if (!fs39.existsSync(this.filePath)) {
+          if (!fs40.existsSync(this.filePath)) {
             return { version: BUDGET_VERSION, entries: {} };
           }
-          const content = fs39.readFileSync(this.filePath, "utf8");
+          const content = fs40.readFileSync(this.filePath, "utf8");
           const parsed = JSON.parse(content);
           if (!parsed || typeof parsed !== "object" || parsed.version !== BUDGET_VERSION || typeof parsed.entries !== "object" || parsed.entries === null || Array.isArray(parsed.entries)) {
             return { version: BUDGET_VERSION, entries: {} };
@@ -249134,12 +249443,12 @@ var init_DiagnosticsBudget = __esm({
       write(file4) {
         try {
           const dir3 = path41.dirname(this.filePath);
-          if (!fs39.existsSync(dir3)) {
-            fs39.mkdirSync(dir3, { recursive: true });
+          if (!fs40.existsSync(dir3)) {
+            fs40.mkdirSync(dir3, { recursive: true });
           }
           const tempPath = `${this.filePath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-          fs39.writeFileSync(tempPath, JSON.stringify(file4, null, 2), "utf8");
-          fs39.renameSync(tempPath, this.filePath);
+          fs40.writeFileSync(tempPath, JSON.stringify(file4, null, 2), "utf8");
+          fs40.renameSync(tempPath, this.filePath);
         } catch (error52) {
           if (!this.hasLoggedWriteError) {
             this.hasLoggedWriteError = true;
@@ -249538,8 +249847,8 @@ function pointerPath(configHome, version3) {
 function removeVersion(configHome, version3) {
   const appPath = applicationDir(configHome, version3);
   try {
-    fs40.rmSync(appPath, { recursive: true, force: true });
-    fs40.rmSync(pointerPath(configHome, version3), { force: true });
+    fs41.rmSync(appPath, { recursive: true, force: true });
+    fs41.rmSync(pointerPath(configHome, version3), { force: true });
     return true;
   } catch {
     return false;
@@ -249556,11 +249865,11 @@ function pruneOldVersions(configHome, keep) {
   }
   return removed;
 }
-var fs40, path42, SEMVER_PATTERN2;
+var fs41, path42, SEMVER_PATTERN2;
 var init_VersionRetention = __esm({
   "src/server/update/VersionRetention.ts"() {
     "use strict";
-    fs40 = __toESM(require("fs"));
+    fs41 = __toESM(require("fs"));
     path42 = __toESM(require("path"));
     init_applicationPayload();
     SEMVER_PATTERN2 = /^(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-]+)*)?$/;
@@ -249592,7 +249901,7 @@ function removeBestEffort(fileSystem, target) {
 function findPayloadEntry(root) {
   const entries = [];
   const visit = (directory) => {
-    for (const entry2 of fs41.readdirSync(directory, { withFileTypes: true })) {
+    for (const entry2 of fs42.readdirSync(directory, { withFileTypes: true })) {
       const entryPath = path43.join(directory, entry2.name);
       if (entry2.isDirectory()) {
         visit(entryPath);
@@ -249639,11 +249948,11 @@ function atomicWritePointer(fileSystem, pointerPath2, pointer) {
   }
   removeBestEffort(fileSystem, backupPath);
 }
-var fs41, os8, path43, SEMVER_PATTERN3, UpdateStager;
+var fs42, os8, path43, SEMVER_PATTERN3, UpdateStager;
 var init_UpdateStager = __esm({
   "src/server/update/UpdateStager.ts"() {
     "use strict";
-    fs41 = __toESM(require("fs"));
+    fs42 = __toESM(require("fs"));
     os8 = __toESM(require("os"));
     path43 = __toESM(require("path"));
     init_protocolVersion();
@@ -249659,7 +249968,7 @@ var init_UpdateStager = __esm({
         this.configHome = options.configHome;
         this.currentVersion = options.currentVersion;
         this.downloadDir = options.downloadDir ?? os8.tmpdir();
-        this.fileSystem = options.fileSystem ?? fs41;
+        this.fileSystem = options.fileSystem ?? fs42;
       }
       stagedVersion() {
         const versionsDir = path43.join(this.configHome, "versions");
@@ -249787,7 +250096,7 @@ var init_UpdateStager = __esm({
 function namesADeadProcess(pidPath) {
   let pid;
   try {
-    pid = parseInt(fs42.readFileSync(pidPath, "utf8"), 10);
+    pid = parseInt(fs43.readFileSync(pidPath, "utf8"), 10);
   } catch {
     return true;
   }
@@ -249804,7 +250113,7 @@ function namesADeadProcess(pidPath) {
 function pruneDeadPidFiles(configDir, ownPidPath) {
   let entries;
   try {
-    entries = fs42.readdirSync(configDir);
+    entries = fs43.readdirSync(configDir);
   } catch {
     return [];
   }
@@ -249821,7 +250130,7 @@ function pruneDeadPidFiles(configDir, ownPidPath) {
       continue;
     }
     try {
-      fs42.unlinkSync(candidate);
+      fs43.unlinkSync(candidate);
       pruned.push(entry);
     } catch {
       continue;
@@ -249829,11 +250138,11 @@ function pruneDeadPidFiles(configDir, ownPidPath) {
   }
   return pruned;
 }
-var fs42, path44, PID_FILE_PATTERN;
+var fs43, path44, PID_FILE_PATTERN;
 var init_pidFilePruning = __esm({
   "src/server/pidFilePruning.ts"() {
     "use strict";
-    fs42 = __toESM(require("fs"));
+    fs43 = __toESM(require("fs"));
     path44 = __toESM(require("path"));
     PID_FILE_PATTERN = /^server-\d+\.pid$/;
   }
@@ -249882,7 +250191,7 @@ function createDaemonActivationGate(sources) {
     })
   });
 }
-function readInstalledApplicationVersion(configHome, entryPath, fileSystem = fs43) {
+function readInstalledApplicationVersion(configHome, entryPath, fileSystem = fs44) {
   if (!entryPath) {
     return null;
   }
@@ -249913,7 +250222,7 @@ function readInstalledApplicationVersion(configHome, entryPath, fileSystem = fs4
 function writePidFileAtomically(pidPath, pid) {
   const tempPath = `${pidPath}.${pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    fs43.writeFileSync(tempPath, pid.toString());
+    fs44.writeFileSync(tempPath, pid.toString());
   } catch {
     return false;
   }
@@ -249923,7 +250232,7 @@ function writePidFileAtomically(pidPath, pid) {
   let lastErrorCode;
   for (let attempt = 1; attempt <= MAX_RENAME_ATTEMPTS; attempt++) {
     try {
-      fs43.renameSync(tempPath, pidPath);
+      fs44.renameSync(tempPath, pidPath);
       renameSuccess = true;
       break;
     } catch (e2) {
@@ -249942,28 +250251,28 @@ function writePidFileAtomically(pidPath, pid) {
   }
   let directWriteSuccess = false;
   try {
-    if (!fs43.existsSync(pidPath)) {
-      fs43.writeFileSync(pidPath, pid.toString());
+    if (!fs44.existsSync(pidPath)) {
+      fs44.writeFileSync(pidPath, pid.toString());
       directWriteSuccess = true;
     } else {
       logger.warn(`[Daemon] Failed to write PID file ${pidPath}: ${lastErrorCode || "unknown"}`);
     }
   } finally {
     try {
-      if (fs43.existsSync(tempPath)) {
-        fs43.unlinkSync(tempPath);
+      if (fs44.existsSync(tempPath)) {
+        fs44.unlinkSync(tempPath);
       }
     } catch {
     }
   }
   return directWriteSuccess;
 }
-var import_express4, fs43, http8, path45, FATAL_EXIT_WATCHDOG_MS, LEDGER_CLOSE_TIMEOUT_MS, ServeInconsistencyError, TakeoverRefusalError, INGRESS_CONNECTION_ESCALATION_MS, STOP_STAGE_TIMEOUT_MS, STOP_TOTAL_TIMEOUT_MS, SERVE_INCONSISTENCY_REBIND_TIMEOUT_MS, OCCUPANT_ENDPOINT_GRACE_MS, Daemon;
+var import_express4, fs44, http8, path45, FATAL_EXIT_WATCHDOG_MS, LEDGER_CLOSE_TIMEOUT_MS, ServeInconsistencyError, TakeoverRefusalError, INGRESS_CONNECTION_ESCALATION_MS, STOP_STAGE_TIMEOUT_MS, STOP_TOTAL_TIMEOUT_MS, SERVE_INCONSISTENCY_REBIND_TIMEOUT_MS, OCCUPANT_ENDPOINT_GRACE_MS, Daemon;
 var init_Daemon = __esm({
   "src/server/Daemon.ts"() {
     "use strict";
     import_express4 = __toESM(require_express2());
-    fs43 = __toESM(require("fs"));
+    fs44 = __toESM(require("fs"));
     http8 = __toESM(require("http"));
     path45 = __toESM(require("path"));
     init_ipcEndpoint();
@@ -250592,8 +250901,8 @@ var init_Daemon = __esm({
         }
         return this.ingressClosePromise;
       }
-      async terminateExistingDaemonProcess(existingPid) {
-        const isSqlPreviewDaemon = await this.isSqlPreviewDaemonProcess(existingPid);
+      async terminateExistingDaemonProcess(existingPid, host, port) {
+        const isSqlPreviewDaemon = await this.isSqlPreviewDaemonProcess(existingPid, host, port);
         if (!isSqlPreviewDaemon) {
           logger.warn(
             `[Daemon] Could not confirm live process ${existingPid} is a Grain daemon (its /status did not report a matching pid); leaving process untouched.`
@@ -250678,17 +250987,17 @@ var init_Daemon = __esm({
           return;
         }
         for (let attempt = 0; attempt < 20; attempt++) {
-          if (!fs43.existsSync(this.SOCKET_PATH)) {
+          if (!fs44.existsSync(this.SOCKET_PATH)) {
             await new Promise((resolve11) => setTimeout(resolve11, 100));
-            if (!fs43.existsSync(this.SOCKET_PATH)) {
+            if (!fs44.existsSync(this.SOCKET_PATH)) {
               return;
             }
           }
           await new Promise((resolve11) => setTimeout(resolve11, 50));
         }
       }
-      async isSqlPreviewDaemonProcess(pid) {
-        const status = await this.readExistingDaemonStatus();
+      async isSqlPreviewDaemonProcess(pid, host, port) {
+        const status = await this.readExistingDaemonStatus(host, port);
         return status?.service === DAEMON_SERVICE_IDENTITY && status.pid === pid;
       }
       async readExistingDaemonStatus(host = this.config.server.host, port = this.HTTP_PORT) {
@@ -250706,7 +251015,7 @@ var init_Daemon = __esm({
               host,
               port,
               path: "/status",
-              timeout: 500,
+              timeout: 2e3,
               headers: this.authToken ? { Authorization: `Bearer ${this.authToken}` } : void 0
             },
             (res) => {
@@ -250756,25 +251065,66 @@ var init_Daemon = __esm({
           await new Promise((resolve11) => setTimeout(resolve11, 50));
         }
       }
+      takeoverFailureExitCode(e2, pid) {
+        const err = e2;
+        if (err.code === "ESRCH") {
+          logger.info(`[Daemon] Cleaning up stale PID file for ${pid}`);
+          return void 0;
+        }
+        if (err.code === "EPERM") {
+          logger.info(
+            `[Daemon] PID file names live process ${pid} owned by another user (EPERM); cleaning up stale PID file.`
+          );
+          return void 0;
+        }
+        if (e2 instanceof TakeoverRefusalError && e2.code === "UNIDENTIFIED_OCCUPANT") {
+          logger.error(
+            `[Daemon] Endpoint ${this.config.server.host}:${this.HTTP_PORT} is occupied by live unidentified process ${pid}; refusing startup.`
+          );
+          return EXIT_UNIDENTIFIED_ENDPOINT_OCCUPIED;
+        }
+        if (e2 instanceof TakeoverRefusalError && e2.code === "PREDECESSOR_DID_NOT_DRAIN") {
+          logger.error(
+            `[Daemon] Predecessor daemon PID ${pid} did not exit after its drain window; refusing takeover.`
+          );
+          return EXIT_PREDECESSOR_DRAIN_TIMEOUT;
+        }
+        logger.error(`[Daemon] Failed to terminate existing process ${pid}: ${e2}`);
+        return 1;
+      }
+      evaluateOccupantVersion(version3, state) {
+        if (!version3) {
+          return { yield: false };
+        }
+        const myVersion = require_package().version;
+        const cmp = compareSemver(version3, myVersion);
+        if (cmp > 0) {
+          return { yield: true, reason: "newer" };
+        }
+        if (cmp === 0 && state !== "draining" && state !== "refusing") {
+          return { yield: true, reason: "healthy same-version" };
+        }
+        return { yield: false };
+      }
       async resolveEndpointOccupant() {
         const endpoint = `${this.config.server.host}:${this.HTTP_PORT}`;
         if (await isTcpPortAvailable(this.HTTP_PORT, this.config.server.host)) {
           return { action: "proceed" };
         }
         const status = await this.readExistingDaemonStatus();
-        if (status?.service !== DAEMON_SERVICE_IDENTITY || typeof status.pid !== "number") {
+        const record2 = readDaemonEndpoint(this.CONFIG_DIR);
+        if (status?.service !== DAEMON_SERVICE_IDENTITY || typeof status.pid !== "number" || !record2 || record2.pid !== status.pid) {
           logger.error(
-            `[Daemon] Endpoint ${endpoint} is already in use and its occupant does not identify as a Grain daemon; refusing startup.`
+            `[Daemon] Endpoint ${endpoint} is already in use and its occupant does not identify as this configuration directory's daemon; refusing startup.`
           );
           return { action: "exit", code: EXIT_UNIDENTIFIED_ENDPOINT_OCCUPIED };
         }
         if (status.version) {
-          const myVersion = require_package().version;
-          const cmp = compareSemver(status.version, myVersion);
-          if (cmp > 0 || cmp === 0 && status.state !== "draining" && status.state !== "refusing") {
+          const evalResult = this.evaluateOccupantVersion(status.version, status.state);
+          if (evalResult.yield) {
             if (await this.waitForOccupantEndpoint(OCCUPANT_ENDPOINT_GRACE_MS)) {
               logger.info(
-                `[Daemon] Endpoint ${endpoint} is served by a ${cmp > 0 ? "newer" : "healthy same-version"} daemon v${status.version} (pid ${status.pid}) that no PID file names; yielding.`
+                `[Daemon] Endpoint ${endpoint} is served by a ${evalResult.reason} daemon v${status.version} (pid ${status.pid}) that no PID file names; yielding.`
               );
               return { action: "exit", code: 42 };
             }
@@ -250805,10 +251155,10 @@ var init_Daemon = __esm({
         let deferPidClaimUntilAfterBind = this.HTTP_PORT === 0 || shouldFallbackToEphemeral;
         try {
           pruneDeadPidFiles(this.CONFIG_DIR, pidPath);
-          if (!shouldFallbackToEphemeral && fs43.existsSync(pidPath)) {
+          if (!shouldFallbackToEphemeral && fs44.existsSync(pidPath)) {
             let pidContent = null;
             try {
-              pidContent = fs43.readFileSync(pidPath, "utf8");
+              pidContent = fs44.readFileSync(pidPath, "utf8");
             } catch (error52) {
               logger.info(
                 `[Daemon] PID file at ${pidPath} could not be read (${error52.code ?? "unknown"}); treating it as unclaimed and checking the endpoint instead.`
@@ -250820,13 +251170,12 @@ var init_Daemon = __esm({
                 process.kill(existingPid, 0);
                 const status = await this.readExistingDaemonStatus();
                 if (status?.service === DAEMON_SERVICE_IDENTITY && status.pid === existingPid && status.version) {
-                  const myVersion = require_package().version;
-                  const cmp = compareSemver(status.version, myVersion);
-                  if (cmp > 0 || cmp === 0 && status.state !== "draining" && status.state !== "refusing") {
+                  const evalResult = this.evaluateOccupantVersion(status.version, status.state);
+                  if (evalResult.yield) {
                     logger.info(
-                      `[Daemon] Yielding to ${cmp > 0 ? "newer" : "healthy same-version"} daemon v${status.version} (pid ${existingPid})`
+                      `[Daemon] Yielding to ${evalResult.reason} daemon v${status.version} (pid ${existingPid})`
                     );
-                    process.exit(42);
+                    return process.exit(42);
                   }
                 }
                 const termination = await this.terminateExistingDaemonProcess(existingPid);
@@ -250840,31 +251189,14 @@ var init_Daemon = __esm({
                   deferPidClaimUntilAfterBind = true;
                 }
               } catch (e2) {
-                const err = e2;
-                if (err.code === "ESRCH") {
-                  logger.info(`[Daemon] Cleaning up stale PID file for ${existingPid}`);
-                } else if (err.code === "EPERM") {
-                  logger.info(
-                    `[Daemon] PID file names live process ${existingPid} owned by another user (EPERM); cleaning up stale PID file.`
-                  );
-                } else if (e2 instanceof TakeoverRefusalError && e2.code === "UNIDENTIFIED_OCCUPANT") {
-                  logger.error(
-                    `[Daemon] Endpoint ${this.config.server.host}:${this.HTTP_PORT} is occupied by live unidentified process ${existingPid}; refusing startup.`
-                  );
-                  return process.exit(EXIT_UNIDENTIFIED_ENDPOINT_OCCUPIED);
-                } else if (e2 instanceof TakeoverRefusalError && e2.code === "PREDECESSOR_DID_NOT_DRAIN") {
-                  logger.error(
-                    `[Daemon] Predecessor daemon PID ${existingPid} did not exit after its drain window; refusing takeover.`
-                  );
-                  return process.exit(EXIT_PREDECESSOR_DRAIN_TIMEOUT);
-                } else {
-                  logger.error(`[Daemon] Failed to terminate existing process ${existingPid}: ${e2}`);
-                  return process.exit(1);
+                const exitCode = this.takeoverFailureExitCode(e2, existingPid);
+                if (exitCode !== void 0) {
+                  return process.exit(exitCode);
                 }
               }
             }
-            if (!deferPidClaimUntilAfterBind && !isNaN(existingPid) && fs43.existsSync(pidPath)) {
-              fs43.unlinkSync(pidPath);
+            if (!deferPidClaimUntilAfterBind && !isNaN(existingPid) && fs44.existsSync(pidPath)) {
+              fs44.unlinkSync(pidPath);
             }
           }
           if (!deferPidClaimUntilAfterBind && !shouldFallbackToEphemeral) {
@@ -250876,7 +251208,7 @@ var init_Daemon = __esm({
               deferPidClaimUntilAfterBind = true;
             }
           }
-          if (shouldFallbackToEphemeral) {
+          if (deferPidClaimUntilAfterBind || shouldFallbackToEphemeral) {
             const record2 = readDaemonEndpoint(this.CONFIG_DIR);
             if (record2) {
               let alive = false;
@@ -250888,10 +251220,34 @@ var init_Daemon = __esm({
               if (alive) {
                 const status = await this.readExistingDaemonStatus(record2.host, record2.port);
                 if (status?.service === DAEMON_SERVICE_IDENTITY && status.pid === record2.pid) {
+                  const evalResult = this.evaluateOccupantVersion(status.version, status.state);
+                  if (evalResult.yield) {
+                    logger.info(
+                      `[Daemon] Endpoint in ${this.CONFIG_DIR} is already served by daemon pid ${record2.pid} at ${record2.host}:${record2.port}; yielding.`
+                    );
+                    return process.exit(42);
+                  }
                   logger.info(
-                    `[Daemon] Endpoint in ${this.CONFIG_DIR} is already served by daemon pid ${record2.pid} at ${record2.host}:${record2.port}; yielding.`
+                    `[Daemon] Endpoint in ${this.CONFIG_DIR} is held by older daemon pid ${record2.pid}; taking over.`
                   );
-                  return process.exit(42);
+                  try {
+                    const termination = await this.terminateExistingDaemonProcess(
+                      record2.pid,
+                      record2.host,
+                      record2.port
+                    );
+                    if (termination === "unidentified" && !await isTcpPortAvailable(this.HTTP_PORT, this.config.server.host)) {
+                      throw new TakeoverRefusalError(
+                        `Refusing to replace live unidentified PID ${record2.pid}: endpoint ${this.config.server.host}:${this.HTTP_PORT} is occupied.`,
+                        "UNIDENTIFIED_OCCUPANT"
+                      );
+                    }
+                  } catch (e2) {
+                    const exitCode = this.takeoverFailureExitCode(e2, record2.pid);
+                    if (exitCode !== void 0) {
+                      return process.exit(exitCode);
+                    }
+                  }
                 }
               }
             }
@@ -251194,11 +251550,11 @@ var init_Daemon = __esm({
         if (this.ownsPidAndSocket && !this.preserveOwnershipArtifactsOnStop) {
           const pidPath = this.pidFilePath();
           removeDaemonEndpoint(this.CONFIG_DIR);
-          if (fs43.existsSync(pidPath)) {
+          if (fs44.existsSync(pidPath)) {
             try {
-              const recordedPid = Number(fs43.readFileSync(pidPath, "utf8"));
+              const recordedPid = Number(fs44.readFileSync(pidPath, "utf8"));
               if (recordedPid === process.pid) {
-                fs43.unlinkSync(pidPath);
+                fs44.unlinkSync(pidPath);
               }
             } catch {
             }
@@ -251234,6 +251590,7 @@ var init_Daemon = __esm({
 var standalone_exports = {};
 __export(standalone_exports, {
   SERVICE_START_FLUSH_BUDGET_MS: () => SERVICE_START_FLUSH_BUDGET_MS,
+  connectStdioToSharedDaemon: () => connectStdioToSharedDaemon,
   main: () => main
 });
 module.exports = __toCommonJS(standalone_exports);
@@ -251308,7 +251665,14 @@ function confirmsExpectedInstance(expected, identity2) {
   if (expected.token && identity2.pid === void 0) {
     return false;
   }
-  return classifyRecordInstance(expected, identity2, Date.now()) !== "mismatch";
+  if (expected.pid === void 0 || expected.startedAt === void 0) {
+    return true;
+  }
+  return classifyRecordInstance(
+    { pid: expected.pid, startedAt: expected.startedAt },
+    identity2,
+    Date.now()
+  ) !== "mismatch";
 }
 function probeSharedDaemonOnce(port, timeoutMs, expected) {
   return new Promise((resolve11) => {
@@ -251363,40 +251727,78 @@ function probeSharedDaemonOnce(port, timeoutMs, expected) {
     });
   });
 }
+function isTokenAccepted(port, token, timeoutMs) {
+  return new Promise((resolve11) => {
+    const request2 = http.get(
+      {
+        host: "127.0.0.1",
+        port,
+        path: "/bridge-token-check",
+        timeout: timeoutMs,
+        headers: { Authorization: `Bearer ${token}` }
+      },
+      (response) => {
+        response.resume();
+        resolve11(response.statusCode !== 401 && response.statusCode !== 403);
+      }
+    );
+    request2.on("timeout", () => {
+      request2.destroy();
+      resolve11(true);
+    });
+    request2.on("error", () => resolve11(true));
+  });
+}
 
 // src/server/standalone.ts
 init_StdioBridge();
 init_DaemonAuthToken();
+init_AgentToken();
 init_ConfigLoader();
 
 // src/server/cli/subcommands.ts
 init_statusCommand();
 
 // src/server/install/addToPathCommand.ts
-var fs6 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var os2 = __toESM(require("os"));
-var path8 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 var import_child_process = require("child_process");
 init_grainHome();
 
 // src/server/install/grainCommand.ts
-var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
-function writeGrainCommand(home, platform2 = process.platform) {
-  const bin = path7.join(home, "bin");
-  fs5.mkdirSync(bin, { recursive: true });
+var fs6 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+function writeGrainCommand(home, platform2 = process.platform, fileSystem = fs6) {
+  const bin = path8.join(home, "bin");
+  fileSystem.mkdirSync(bin, { recursive: true });
   if (platform2 === "win32") {
-    const libexec = path7.join(home, "libexec");
-    fs5.mkdirSync(libexec, { recursive: true });
+    const libexec = path8.join(home, "libexec");
+    fileSystem.mkdirSync(libexec, { recursive: true });
     const script2 = WIN_SCRIPT.replace("__GRAIN_HOME__", home);
-    fs5.writeFileSync(path7.join(libexec, "grain.ps1"), "\uFEFF" + script2 + "\r\n", "utf8");
-    fs5.writeFileSync(path7.join(bin, "grain.cmd"), CMD_SCRIPT, "ascii");
-    fs5.rmSync(path7.join(bin, "grain.ps1"), { force: true });
+    const psPath = path8.join(libexec, "grain.ps1");
+    const psContent = "\uFEFF" + script2 + "\r\n";
+    if (!fileSystem.existsSync(psPath) || fileSystem.readFileSync(psPath, "utf8") !== psContent) {
+      fileSystem.writeFileSync(psPath, psContent, { encoding: "utf8" });
+    }
+    const cmdPath = path8.join(bin, "grain.cmd");
+    if (!fileSystem.existsSync(cmdPath) || fileSystem.readFileSync(cmdPath, "ascii") !== CMD_SCRIPT) {
+      fileSystem.writeFileSync(cmdPath, CMD_SCRIPT, { encoding: "ascii" });
+    }
+    const legacyPath = path8.join(bin, "grain.ps1");
+    if (fileSystem.existsSync(legacyPath)) {
+      fileSystem.rmSync(legacyPath, { force: true });
+    }
     return;
   }
   const script = POSIX_SCRIPT.replace("__GRAIN_HOME__", home);
-  fs5.writeFileSync(path7.join(bin, "grain"), script, { mode: 493 });
-  fs5.chmodSync(path7.join(bin, "grain"), 493);
+  const commandPath = path8.join(bin, "grain");
+  if (!fileSystem.existsSync(commandPath) || fileSystem.readFileSync(commandPath, "utf8") !== script) {
+    fileSystem.writeFileSync(commandPath, script, { mode: 493 });
+  }
+  if ((fileSystem.statSync(commandPath).mode & 511) !== 493) {
+    fileSystem.chmodSync(commandPath, 493);
+  }
 }
 var POSIX_SCRIPT = `#!/bin/sh
 GRAIN_HOME="\${GRAIN_HOME:-__GRAIN_HOME__}"
@@ -251437,21 +251839,21 @@ var CMD_SCRIPT = '@echo off\r\npowershell -NoProfile -ExecutionPolicy Bypass -Fi
 // src/server/install/addToPathCommand.ts
 function profileForShell(deps) {
   const home = deps.home ?? os2.homedir();
-  switch (path8.basename(deps.shell ?? process.env["SHELL"] ?? "sh")) {
+  switch (path9.basename(deps.shell ?? process.env["SHELL"] ?? "sh")) {
     case "zsh":
-      return path8.join(deps.zdotdir ?? process.env["ZDOTDIR"] ?? home, ".zshrc");
+      return path9.join(deps.zdotdir ?? process.env["ZDOTDIR"] ?? home, ".zshrc");
     case "bash":
-      return path8.join(home, deps.platform === "darwin" ? ".bash_profile" : ".bashrc");
+      return path9.join(home, deps.platform === "darwin" ? ".bash_profile" : ".bashrc");
     case "fish":
-      return path8.join(home, ".config/fish/conf.d/grain.fish");
+      return path9.join(home, ".config/fish/conf.d/grain.fish");
     default:
-      return path8.join(home, ".profile");
+      return path9.join(home, ".profile");
   }
 }
 function addToPathCommand(deps = {}) {
   const platform2 = deps.platform ?? process.platform;
   const grainHome = deps.grainHome ?? resolveGrainHome();
-  const bin = path8.join(grainHome, "bin");
+  const bin = path9.join(grainHome, "bin");
   const output = deps.writeOutput ?? console.log;
   writeGrainCommand(grainHome, platform2);
   if ((deps.noModifyPath ?? process.env["GRAIN_NO_MODIFY_PATH"]) === "1") {
@@ -251475,25 +251877,42 @@ function addToPathCommand(deps = {}) {
         { input: value }
       );
     });
-    const current = read();
-    if (!current.split(";").some((entry) => entry.toLowerCase() === bin.toLowerCase())) {
-      write(current ? `${bin};${current}` : bin);
-      output(`Added ${bin} to your user PATH.`);
-    } else {
-      output("PATH unchanged.");
+    try {
+      const current = read();
+      if (!current.split(";").some((entry) => entry.toLowerCase() === bin.toLowerCase())) {
+        write(current ? `${bin};${current}` : bin);
+        output(`Added ${bin} to your user PATH.`);
+      } else {
+        output("PATH unchanged.");
+      }
+    } catch (error52) {
+      const message = error52 instanceof Error ? error52.message : String(error52);
+      output(
+        `Could not update your user PATH: ${message}. Add ${bin} to your PATH yourself, then open a new terminal.`
+      );
+      return 2;
     }
   } else {
     const profile = profileForShell({ ...deps, platform: platform2 });
-    if (!fs6.existsSync(profile) || !fs6.readFileSync(profile, "utf8").includes(bin)) {
-      fs6.mkdirSync(path8.dirname(profile), { recursive: true });
-      const line = profile.endsWith(".fish") ? `fish_add_path "${bin}"` : `export PATH="${bin}:$PATH"`;
-      fs6.appendFileSync(profile, `
+    const line = profile.endsWith(".fish") ? `fish_add_path "${bin}"` : `export PATH="${bin}:$PATH"`;
+    try {
+      if (!fs7.existsSync(profile) || !fs7.readFileSync(profile, "utf8").includes(bin)) {
+        fs7.mkdirSync(path9.dirname(profile), { recursive: true });
+        fs7.appendFileSync(profile, `
 # Added by the Grain installer
 ${line}
 `);
-      output(`Added ${bin} to your PATH in ${profile}`);
-    } else {
-      output("PATH unchanged.");
+        output(`Added ${bin} to your PATH in ${profile}`);
+      } else {
+        output("PATH unchanged.");
+      }
+    } catch (error52) {
+      const message = error52 instanceof Error ? error52.message : String(error52);
+      output(
+        `Could not update ${profile}: ${message}. Add this line to it yourself, then open a new terminal:
+  ${line}`
+      );
+      return 2;
     }
   }
   output("Open a new terminal, then run: grain");
@@ -251502,7 +251921,7 @@ ${line}
 
 // src/server/install/installCommand.ts
 var crypto8 = __toESM(require("crypto"));
-var fs17 = __toESM(require("fs"));
+var fs18 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
 var path21 = __toESM(require("path"));
 init_grainHome();
@@ -251512,9 +251931,9 @@ init_DaemonTelemetryService();
 
 // src/server/runtime/NodeRuntimeProvisioner.ts
 var crypto7 = __toESM(require("crypto"));
-var fs14 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
-var path16 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 init_ArtifactDownloader();
 init_MinimalTarExtractor();
 init_ManagedArtifactTypes();
@@ -251568,8 +251987,8 @@ var NODE_PLATFORM_PINS = {
 
 // src/server/runtime/daemonRuntimeIdentity.ts
 var import_child_process2 = require("child_process");
-var fs13 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var DAEMON_RUNTIME_SIGNING_IDENTIFIER = "tools.grain-daemon";
 function runtimeBinaryName(kind) {
   return kind === "exe" ? "grain-daemon.exe" : "grain-daemon";
@@ -251578,22 +251997,22 @@ function legacyRuntimeBinaryName(kind) {
   return kind === "exe" ? "node.exe" : "node";
 }
 function binaryDir(versionDir, kind) {
-  return kind === "exe" ? versionDir : path15.join(versionDir, "bin");
+  return kind === "exe" ? versionDir : path16.join(versionDir, "bin");
 }
 function runtimeBinaryPath(versionDir, kind) {
-  return path15.join(binaryDir(versionDir, kind), runtimeBinaryName(kind));
+  return path16.join(binaryDir(versionDir, kind), runtimeBinaryName(kind));
 }
 function legacyRuntimeBinaryPath(versionDir, kind) {
-  return path15.join(binaryDir(versionDir, kind), legacyRuntimeBinaryName(kind));
+  return path16.join(binaryDir(versionDir, kind), legacyRuntimeBinaryName(kind));
 }
 function adoptRuntimeBinary(versionDir, kind, platform2 = process.platform) {
   const target = runtimeBinaryPath(versionDir, kind);
   const legacy = legacyRuntimeBinaryPath(versionDir, kind);
   let outcome;
-  if (fs13.existsSync(target)) {
+  if (fs14.existsSync(target)) {
     outcome = "already-adopted";
-  } else if (fs13.existsSync(legacy)) {
-    fs13.renameSync(legacy, target);
+  } else if (fs14.existsSync(legacy)) {
+    fs14.renameSync(legacy, target);
     outcome = "renamed";
   } else {
     return "nothing-to-adopt";
@@ -251656,7 +252075,7 @@ var _NodeRuntimeProvisioner = class {
   installedNodePath() {
     const binary = this.binaryPath();
     try {
-      fs14.accessSync(binary, fs14.constants.X_OK);
+      fs15.accessSync(binary, fs15.constants.X_OK);
       return binary;
     } catch {
       return this.adoptLegacyInstall();
@@ -251673,7 +252092,7 @@ var _NodeRuntimeProvisioner = class {
       return null;
     }
     try {
-      fs14.accessSync(this.binaryPath(), fs14.constants.X_OK);
+      fs15.accessSync(this.binaryPath(), fs15.constants.X_OK);
       return this.binaryPath();
     } catch {
       return null;
@@ -251685,7 +252104,7 @@ var _NodeRuntimeProvisioner = class {
     if (existing) {
       return existing;
     }
-    const key = path16.resolve(this.versionDir());
+    const key = path17.resolve(this.versionDir());
     const pending = _NodeRuntimeProvisioner.inFlight.get(key);
     if (pending) {
       return pending;
@@ -251703,7 +252122,7 @@ var _NodeRuntimeProvisioner = class {
   async provisionWithLock() {
     const pin = this.pin();
     const downloadDir = this.options.downloadDir ?? os3.tmpdir();
-    fs14.mkdirSync(downloadDir, { recursive: true });
+    fs15.mkdirSync(downloadDir, { recursive: true });
     const finalDir = this.versionDir();
     const lock = await this.acquireProvisionLock(`${finalDir}.provision-lock`);
     try {
@@ -251713,9 +252132,9 @@ var _NodeRuntimeProvisioner = class {
       if (lockedExisting) {
         return lockedExisting;
       }
-      fs14.rmSync(finalDir, { recursive: true, force: true });
-      const stagingDir = fs14.mkdtempSync(path16.join(downloadDir, "grain-node-"));
-      const downloadPath = path16.join(stagingDir, pin.kind === "exe" ? "node.exe" : "node.tar.gz");
+      fs15.rmSync(finalDir, { recursive: true, force: true });
+      const stagingDir = fs15.mkdtempSync(path17.join(downloadDir, "grain-node-"));
+      const downloadPath = path17.join(stagingDir, pin.kind === "exe" ? "node.exe" : "node.tar.gz");
       try {
         await downloadToFile(pin.url, downloadPath);
         const actual = await sha256File(downloadPath);
@@ -251724,24 +252143,24 @@ var _NodeRuntimeProvisioner = class {
             `Node runtime checksum mismatch for ${pin.platform}: expected ${pin.sha256}, got ${actual}`
           );
         }
-        const unpackDir = path16.join(stagingDir, "unpacked");
-        fs14.mkdirSync(unpackDir, { recursive: true });
+        const unpackDir = path17.join(stagingDir, "unpacked");
+        fs15.mkdirSync(unpackDir, { recursive: true });
         if (pin.kind === "exe") {
-          fs14.copyFileSync(downloadPath, path16.join(unpackDir, "node.exe"));
+          fs15.copyFileSync(downloadPath, path17.join(unpackDir, "node.exe"));
         } else {
           await extractTarGz(downloadPath, unpackDir);
         }
-        const extractedBinary = path16.join(unpackDir, pin.binaryPathInArchive);
-        if (!fs14.existsSync(extractedBinary)) {
+        const extractedBinary = path17.join(unpackDir, pin.binaryPathInArchive);
+        if (!fs15.existsSync(extractedBinary)) {
           throw new Error(`Node artifact did not contain ${pin.binaryPathInArchive}`);
         }
-        fs14.chmodSync(extractedBinary, 493);
-        fs14.mkdirSync(path16.dirname(finalDir), { recursive: true });
+        fs15.chmodSync(extractedBinary, 493);
+        fs15.mkdirSync(path17.dirname(finalDir), { recursive: true });
         const archiveRoot = pin.binaryPathInArchive.split("/")[0];
         if (!archiveRoot && pin.kind !== "exe") {
           throw new Error(`Node artifact has an invalid binary path: ${pin.binaryPathInArchive}`);
         }
-        const sourceRoot = pin.kind === "exe" ? unpackDir : path16.join(unpackDir, archiveRoot ?? "");
+        const sourceRoot = pin.kind === "exe" ? unpackDir : path17.join(unpackDir, archiveRoot ?? "");
         this.moveIntoPlace(sourceRoot, finalDir);
         adoptRuntimeBinary(finalDir, pin.kind);
         const provisioned = this.installedNodePath();
@@ -251761,16 +252180,16 @@ var _NodeRuntimeProvisioner = class {
     }
   }
   async acquireProvisionLock(lockDir) {
-    fs14.mkdirSync(path16.dirname(lockDir), { recursive: true });
+    fs15.mkdirSync(path17.dirname(lockDir), { recursive: true });
     const startedAt = Date.now();
     const staleMs = this.options.provisionLockStaleMs ?? PROVISION_LOCK_STALE_MS;
     const maxWaitMs = this.options.provisionLockMaxWaitMs ?? PROVISION_LOCK_MAX_WAIT_MS;
     const token = `${process.pid}-${crypto7.randomUUID()}`;
     for (; ; ) {
       try {
-        fs14.mkdirSync(lockDir);
+        fs15.mkdirSync(lockDir);
         try {
-          fs14.writeFileSync(path16.join(lockDir, "owner"), token, "utf8");
+          fs15.writeFileSync(path17.join(lockDir, "owner"), token, "utf8");
         } catch (error52) {
           this.removeBestEffort(lockDir);
           throw error52;
@@ -251779,7 +252198,7 @@ var _NodeRuntimeProvisioner = class {
           () => {
             try {
               const now = Date.now() / 1e3;
-              fs14.utimesSync(lockDir, now, now);
+              fs15.utimesSync(lockDir, now, now);
             } catch {
               return;
             }
@@ -251805,7 +252224,7 @@ var _NodeRuntimeProvisioner = class {
   }
   isStaleLock(lockDir, staleMs) {
     try {
-      return Date.now() - fs14.statSync(lockDir).mtimeMs > staleMs;
+      return Date.now() - fs15.statSync(lockDir).mtimeMs > staleMs;
     } catch {
       return false;
     }
@@ -251813,8 +252232,8 @@ var _NodeRuntimeProvisioner = class {
   releaseProvisionLock(lock) {
     clearInterval(lock.heartbeat);
     try {
-      if (fs14.readFileSync(path16.join(lock.directory, "owner"), "utf8") === lock.token) {
-        fs14.rmSync(lock.directory, { recursive: true, force: true });
+      if (fs15.readFileSync(path17.join(lock.directory, "owner"), "utf8") === lock.token) {
+        fs15.rmSync(lock.directory, { recursive: true, force: true });
       }
     } catch {
       return;
@@ -251824,7 +252243,7 @@ var _NodeRuntimeProvisioner = class {
     const staleMs = this.options.stagingDirStaleMs ?? STAGING_DIR_STALE_MS;
     let entries;
     try {
-      entries = fs14.readdirSync(downloadDir, { withFileTypes: true });
+      entries = fs15.readdirSync(downloadDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -251832,9 +252251,9 @@ var _NodeRuntimeProvisioner = class {
       if (!entry.isDirectory() || !entry.name.startsWith("grain-node-")) {
         continue;
       }
-      const stagingDir = path16.join(downloadDir, entry.name);
+      const stagingDir = path17.join(downloadDir, entry.name);
       try {
-        if (Date.now() - fs14.statSync(stagingDir).mtimeMs > staleMs) {
+        if (Date.now() - fs15.statSync(stagingDir).mtimeMs > staleMs) {
           this.removeBestEffort(stagingDir);
         }
       } catch {
@@ -251843,12 +252262,12 @@ var _NodeRuntimeProvisioner = class {
     }
   }
   reapDestinationStages(finalDir) {
-    const parentDir = path16.dirname(finalDir);
-    const prefix = `.${path16.basename(finalDir)}-tmp-`;
+    const parentDir = path17.dirname(finalDir);
+    const prefix = `.${path17.basename(finalDir)}-tmp-`;
     const staleMs = this.options.stagingDirStaleMs ?? STAGING_DIR_STALE_MS;
     let entries;
     try {
-      entries = fs14.readdirSync(parentDir, { withFileTypes: true });
+      entries = fs15.readdirSync(parentDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -251856,9 +252275,9 @@ var _NodeRuntimeProvisioner = class {
       if (!entry.isDirectory() || !entry.name.startsWith(prefix)) {
         continue;
       }
-      const destinationStage = path16.join(parentDir, entry.name);
+      const destinationStage = path17.join(parentDir, entry.name);
       try {
-        if (Date.now() - fs14.statSync(destinationStage).mtimeMs > staleMs) {
+        if (Date.now() - fs15.statSync(destinationStage).mtimeMs > staleMs) {
           this.removeBestEffort(destinationStage);
         }
       } catch {
@@ -251868,25 +252287,25 @@ var _NodeRuntimeProvisioner = class {
   }
   removeBestEffort(target) {
     try {
-      fs14.rmSync(target, { recursive: true, force: true });
+      fs15.rmSync(target, { recursive: true, force: true });
     } catch {
       return;
     }
   }
   moveIntoPlace(source, destination) {
     try {
-      fs14.renameSync(source, destination);
+      fs15.renameSync(source, destination);
     } catch (error52) {
       if (error52.code !== "EXDEV") {
         throw error52;
       }
       let destinationStage;
       try {
-        destinationStage = fs14.mkdtempSync(
-          path16.join(path16.dirname(destination), `.${path16.basename(destination)}-tmp-`)
+        destinationStage = fs15.mkdtempSync(
+          path17.join(path17.dirname(destination), `.${path17.basename(destination)}-tmp-`)
         );
-        fs14.cpSync(source, destinationStage, { recursive: true });
-        fs14.renameSync(destinationStage, destination);
+        fs15.cpSync(source, destinationStage, { recursive: true });
+        fs15.renameSync(destinationStage, destination);
         destinationStage = void 0;
         this.removeBestEffort(source);
       } finally {
@@ -251946,15 +252365,15 @@ function generateLaunchAgent(descriptor) {
 }
 
 // src/server/install/launcher.ts
-var path18 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 init_protocolVersion();
 
 // src/server/install/launchFailureMarker.ts
-var fs15 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 var LAUNCH_FAILURE_MARKER_FILENAME = "grain-launch-failure.json";
 function launchFailureMarkerPath(configHome) {
-  return path17.join(configHome, LAUNCH_FAILURE_MARKER_FILENAME);
+  return path18.join(configHome, LAUNCH_FAILURE_MARKER_FILENAME);
 }
 function isLaunchFailureReason(value) {
   return value === "no_payload" || value === "spawn_failed" || value === "launch_attempt";
@@ -251966,7 +252385,7 @@ function isLaunchFailureMarker(value) {
   const entry = value;
   return isLaunchFailureReason(entry["reason"]) && typeof entry["message"] === "string" && typeof entry["at"] === "number" && Number.isFinite(entry["at"]) && (entry["version"] === void 0 || typeof entry["version"] === "string") && (entry["recoveredFrom"] === void 0 || typeof entry["recoveredFrom"] === "string");
 }
-function readAndClearLaunchFailureMarker(configHome, fileSystem = fs15) {
+function readAndClearLaunchFailureMarker(configHome, fileSystem = fs16) {
   const markerPath = launchFailureMarkerPath(configHome);
   if (!fileSystem.existsSync(markerPath)) {
     return void 0;
@@ -251990,7 +252409,7 @@ function readAndClearLaunchFailureMarker(configHome, fileSystem = fs15) {
 // src/server/install/launcher.ts
 var LAUNCHER_FILENAME = "grain-daemon-launcher.js";
 function launcherPath(configHome) {
-  return path18.join(configHome, LAUNCHER_FILENAME);
+  return path19.join(configHome, LAUNCHER_FILENAME);
 }
 function launcherSource(configHome) {
   return `#!/usr/bin/env node
@@ -252090,7 +252509,8 @@ const recoveredFrom = recoverFromFailedLaunch(previousMarker);
 const payload = resolvePayload();
 if (!payload) {
   writeLaunchFailureMarker('no_payload', 'No valid daemon payload pointer was found.');
-  console.error('[grain] No valid daemon payload pointer was found. Reinstall Grain from VS Code or npx -y grain-tools install.');
+  const installCmd = process.platform === 'win32' ? 'irm https://grain.tools/install.ps1 | iex' : 'curl -fsSL https://grain.tools/install.sh | sh';
+  console.error('[grain] No valid daemon payload pointer was found. Reinstall Grain from VS Code or run: ' + installCmd);
   process.exit(1);
 }
 
@@ -252207,23 +252627,11 @@ function generateWindowsStartupTask(descriptor) {
   };
 }
 
-// src/common/serviceMode.ts
-var path20 = __toESM(require("path"));
-var SERVICE_MODE_FILENAME = "service-mode.json";
-function serviceModePath(configDir) {
-  return path20.join(configDir, SERVICE_MODE_FILENAME);
-}
-function writeServiceMode(fileSystem, configDir, record2) {
-  fileSystem.writeFileSync(serviceModePath(configDir), `${JSON.stringify(record2, null, 2)}
-`, {
-    mode: 384
-  });
-}
-
 // src/server/install/installCommand.ts
+init_serviceMode();
 init_acquisitionChannel();
 init_telemetryConsent();
-var GRAIN_SERVICE_LABEL = `tools.${DAEMON_SERVICE_IDENTITY}`;
+init_daemonRecordInstance();
 function unitFor(platform2, launcher, configHome, nodePath) {
   const descriptor = {
     launcherPath: launcher,
@@ -252344,15 +252752,19 @@ function registerCliPayload(fileSystem, configHome, standalonePath, writeOutput)
     if (!fileSystem.existsSync(standalonePath)) {
       return;
     }
-    const installedEntry = installApplicationPayload({
-      configHome,
-      version: version3,
-      sourceEntry: standalonePath
-    });
+    const installedEntry = path21.join(configHome, "app", version3, "standalone.js");
+    const manifestPath = path21.join(configHome, "app", version3, "package.json");
+    const payloadUnchanged = fileSystem.existsSync(installedEntry) && fileSystem.existsSync(manifestPath) && fileSystem.readFileSync(installedEntry).equals(fileSystem.readFileSync(standalonePath));
+    if (!payloadUnchanged) {
+      installApplicationPayload({ configHome, version: version3, sourceEntry: standalonePath });
+    }
     const versionsDir = path21.join(configHome, "versions");
     fileSystem.mkdirSync(versionsDir, { recursive: true });
     const pointerPath2 = path21.join(versionsDir, `${version3}.json`);
-    writeAtomicPointer(fileSystem, pointerPath2, JSON.stringify({ path: installedEntry, version: version3 }));
+    const pointerContents = JSON.stringify({ path: installedEntry, version: version3 });
+    if (!fileSystem.existsSync(pointerPath2) || fileSystem.readFileSync(pointerPath2, "utf8") !== pointerContents) {
+      writeAtomicPointer(fileSystem, pointerPath2, pointerContents);
+    }
   } catch (error52) {
     writeOutput(`Warning: could not register this build for the launcher: ${describeError(error52)}`);
   }
@@ -252365,7 +252777,7 @@ async function installCommand(deps = {}) {
   const configHome = deps.configHome ?? resolveGrainHome();
   const homeDirectory = deps.homeDirectory ?? os4.homedir();
   const uid = deps.uid ?? process.getuid?.() ?? 0;
-  const fileSystem = deps.fileSystem ?? fs17;
+  const fileSystem = deps.fileSystem ?? fs18;
   const runner = deps.commandRunner ?? createCommandRunner();
   const adapter2 = deps.adapter ?? createSupervisorAdapter(platform2, runner, uid);
   const readStatus = deps.readStatus ?? readGrainServiceStatus;
@@ -252374,11 +252786,11 @@ async function installCommand(deps = {}) {
   const telemetryConsentFlag = deps.telemetryConsent;
   const standalonePath = deps.standalonePath ?? require.main?.filename;
   fileSystem.mkdirSync(configHome, { recursive: true });
-  writeGrainCommand(configHome, platform2);
+  writeGrainCommand(configHome, platform2, fileSystem);
   if (standalonePath !== void 0) {
     registerCliPayload(fileSystem, configHome, standalonePath, writeOutput);
   }
-  if (readAcquisitionChannelStatus(configHome).type === "missing") {
+  if (readAcquisitionChannelStatus(configHome).type !== "valid") {
     writeAcquisitionChannel(fileSystem, configHome, {
       channel: acquisitionChannelFromEnvironment(process.env)
     });
@@ -252390,10 +252802,22 @@ async function installCommand(deps = {}) {
     flag: telemetryConsentFlag
   });
   const telemetry = deps.telemetry ?? new DaemonTelemetryService({ configDir: configHome });
-  const nodePath = deps.nodePath ?? await new NodeRuntimeProvisioner({ sqlPreviewHome: configHome, telemetry }).provision();
   const captureLifecycle = (properties) => {
     telemetry.capture("service_lifecycle", properties);
   };
+  const nodePath = deps.nodePath ?? await new NodeRuntimeProvisioner({ sqlPreviewHome: configHome, telemetry }).provision().catch(async (error52) => {
+    const failure = new AppError("service_runtime_provision_failed", describeError(error52), {
+      cause: error52
+    });
+    captureLifecycle({
+      state: "standalone_mcp",
+      phase: "install",
+      outcome: "failed",
+      error_id: failure.errorId
+    });
+    await flushTelemetry(telemetry);
+    throw error52;
+  });
   const launcher = platformLauncherPath(platform2, configHome);
   const unit = unitFor(platform2, launcher, configHome, nodePath);
   const unitPath = path21.join(homeDirectory, unit.destination);
@@ -252493,7 +252917,7 @@ Check the supervisor logs at ${path21.join(configHome, "grain-daemon.out.log")}
 }
 
 // src/server/install/uninstallCommand.ts
-var fs18 = __toESM(require("fs"));
+var fs19 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
 var path22 = __toESM(require("path"));
 init_grainHome();
@@ -252528,7 +252952,7 @@ async function uninstallCommand(deps = {}) {
   const homeDirectory = deps.homeDirectory ?? os5.homedir();
   const uid = deps.uid ?? process.getuid?.() ?? 0;
   const nodePath = deps.nodePath ?? "";
-  const fileSystem = deps.fileSystem ?? fs18;
+  const fileSystem = deps.fileSystem ?? fs19;
   const runner = deps.commandRunner ?? createCommandRunner();
   const adapter2 = deps.adapter ?? createSupervisorAdapter(platform2, runner, uid);
   const writeOutput = deps.writeOutput ?? ((message) => console.log(message));
@@ -252952,12 +253376,17 @@ Options:
 init_AppError();
 
 // src/server/bridge/notSetUpNotice.ts
-var NOT_SET_UP_MESSAGE = "Grain is not set up on this machine, so this session is running on its own and will not appear in your other Grain surfaces. Run: npx -y grain-tools install";
-function resolveNotSetUpMessage(hasConnectionsEnv) {
-  return hasConnectionsEnv ? void 0 : NOT_SET_UP_MESSAGE;
+function getNotSetUpMessage(platform2 = process.platform) {
+  const command = platform2 === "win32" ? "irm https://grain.tools/install.ps1 | iex" : "curl -fsSL https://grain.tools/install.sh | sh";
+  return `Grain is not set up on this machine, so this session is running on its own and will not appear in your other Grain surfaces. Run: ${command}`;
+}
+function resolveNotSetUpMessage(hasConnectionsEnv, platform2 = process.platform) {
+  return hasConnectionsEnv ? void 0 : getNotSetUpMessage(platform2);
 }
 
 // src/server/standalone.ts
+init_daemonRecordInstance();
+init_supervisorAdapter();
 var SERVICE_START_FLUSH_BUDGET_MS = 2e3;
 async function flushWithinBudget(telemetry, budgetMs) {
   let timer;
@@ -253025,41 +253454,124 @@ async function handleLaunchFailureMarker(configDir, telemetry) {
     return;
   }
 }
-async function main() {
+async function connectStdioToSharedDaemon(args, env2, configDir, embedded, deps = {}) {
+  if (embedded) {
+    return { bridged: false };
+  }
+  const resolve11 = deps.resolveDaemonAddress ?? resolveDaemonAddress;
+  const probeDaemon = deps.probeSharedDaemon ?? probeSharedDaemon;
+  const authToken = deps.readDaemonAuthToken ?? readDaemonAuthToken;
+  const agentToken = deps.readAgentToken ?? readAgentToken;
+  const tokenAccepted = deps.isTokenAccepted ?? isTokenAccepted;
+  const bridge = deps.runStdioBridge ?? runStdioBridge;
+  const launchFailureMarker = deps.handleLaunchFailureMarker ?? handleLaunchFailureMarker;
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? ((milliseconds) => new Promise((r) => setTimeout(r, milliseconds)));
+  const resolved = () => resolve11({ args, env: env2, configDir });
+  async function inspect() {
+    const endpoint = resolved();
+    if (!endpoint.address) {
+      return { endpoint };
+    }
+    const accessToken = authToken(configDir);
+    const expected = endpoint.record ? { pid: endpoint.record.pid, startedAt: endpoint.record.startedAt, token: accessToken } : accessToken ? { token: accessToken } : void 0;
+    const probed = await probeDaemon(endpoint.address.port, 500, expected);
+    const token = agentToken(configDir);
+    const foreignReason = !probed.identity ? void 0 : !token ? "no-agent-token" : await tokenAccepted(endpoint.address.port, token, 500) ? void 0 : "agent-token-rejected";
+    const probe2 = foreignReason ? { attempts: probed.attempts, failureReason: foreignReason } : probed;
+    return { endpoint, probe: probe2 };
+  }
+  async function attach(result2, started) {
+    const { address: address2, source: source2 } = result2.endpoint;
+    const identity2 = result2.probe?.identity;
+    if (!address2 || !identity2) {
+      return false;
+    }
+    if (started) {
+      console.error("[grain] started the Grain service and bridged stdio to it");
+    } else {
+      console.error(
+        `[grain] bridging stdio to shared daemon v${identity2.version ?? "?"} on ${address2.host}:${address2.port} (via ${source2}, RFC-082) after ${result2.probe?.attempts} attempt(s)`
+      );
+    }
+    await launchFailureMarker(configDir);
+    await bridge(address2.port);
+    return true;
+  }
+  let result = await inspect();
+  if (await attach(result, false)) {
+    return { bridged: true };
+  }
+  const foreignReasons = ["wrong-instance", "no-agent-token", "agent-token-rejected"];
+  let serviceReason;
+  if (!result.probe?.failureReason || !foreignReasons.includes(result.probe.failureReason)) {
+    try {
+      const adapter2 = deps.adapter ?? createSupervisorAdapter(
+        process.platform,
+        createCommandRunner(),
+        process.getuid?.() ?? 0
+      );
+      if (await adapter2.isRegistered(GRAIN_SERVICE_LABEL)) {
+        await adapter2.start(GRAIN_SERVICE_LABEL);
+        const deadline = now() + 1e4;
+        do {
+          result = await inspect();
+          if (await attach(result, true)) {
+            return { bridged: true };
+          }
+          if (result.probe?.failureReason && foreignReasons.includes(result.probe.failureReason)) {
+            serviceReason = result.probe.failureReason;
+            break;
+          }
+          if (now() >= deadline) {
+            break;
+          }
+          await sleep(Math.min(250, deadline - now()));
+        } while (now() <= deadline);
+        serviceReason ?? (serviceReason = "service did not publish a reachable endpoint within 10 s");
+      } else {
+        serviceReason = "service not registered";
+      }
+    } catch (error52) {
+      serviceReason = `service start failed: ${error52 instanceof Error ? error52.message : String(error52)}`;
+    }
+  }
+  const { address, source, record: record2 } = result.endpoint;
+  const probe = result.probe;
+  if (address && probe) {
+    const reasonStr = probe.failureReason === "stale-record" ? `stale-record pid ${record2?.pid}` : probe.failureReason;
+    const detail = probe.failureReason === "no-agent-token" ? `answered, but ${configDir} has no agent-token for this bridge to present` : probe.failureReason === "wrong-instance" || probe.failureReason === "agent-token-rejected" ? `answered, but it does not accept the tokens in ${configDir}, so it belongs to a different Grain home` : void 0;
+    console.error(
+      (detail ? `[grain] the daemon at ${address.host}:${address.port} (via ${source}) ${detail} (${reasonStr}); check GRAIN_HOME in this MCP server's config. Starting embedded stdio ` : `[grain] no shared daemon at ${address.host}:${address.port} (via ${source}) after ${probe.attempts} attempt(s) (${reasonStr}); starting embedded stdio `) + `daemon \u2014 this session's queries will not appear in the extension's results panel` + (serviceReason ? ` (${serviceReason})` : "")
+    );
+  } else {
+    console.error(
+      `[grain] no daemon endpoint published in ${configDir} and no port pinned; starting embedded stdio daemon \u2014 this session's queries will not appear in the extension's results panel (${serviceReason ?? "no reachable service"})`
+    );
+  }
+  return {
+    bridged: false,
+    notSetUpMessage: resolveNotSetUpMessage(Boolean(env2["GRAIN_CONNECTIONS"]))
+  };
+}
+async function main(deps = {}) {
   await dispatchSubcommand(process.argv.slice(2));
   const args = parseArgs();
   const isStdio = args["stdio"] === "true";
   const isEmbedded = args["embedded"] === "true" || process.env["GRAIN_EMBEDDED"] === "1";
   let notSetUpMessage;
   if (isStdio && !isEmbedded) {
-    const configDir = defaultDaemonConfigDir();
-    const { address, source, record: record2 } = resolveDaemonAddress({ args, env: process.env, configDir });
-    if (address) {
-      const expected = record2 ? {
-        pid: record2.pid,
-        startedAt: record2.startedAt,
-        token: readDaemonAuthToken(configDir)
-      } : void 0;
-      const probe = await probeSharedDaemon(address.port, 500, expected);
-      if (probe.identity) {
-        console.error(
-          `[grain] bridging stdio to shared daemon v${probe.identity.version ?? "?"} on ${address.host}:${address.port} (via ${source}, RFC-082) after ${probe.attempts} attempt(s)`
-        );
-        await handleLaunchFailureMarker(configDir);
-        await runStdioBridge(address.port);
-        return;
-      }
-      const reasonStr = probe.failureReason === "stale-record" ? `stale-record pid ${expected?.pid}` : probe.failureReason;
-      console.error(
-        `[grain] no shared daemon at ${address.host}:${address.port} (via ${source}) after ${probe.attempts} attempt(s) (${reasonStr}); starting embedded stdio daemon \u2014 this session's queries will not appear in the extension's results panel`
-      );
-      notSetUpMessage = resolveNotSetUpMessage(Boolean(process.env["GRAIN_CONNECTIONS"]));
-    } else {
-      console.error(
-        `[grain] no daemon endpoint published in ${configDir} and no port pinned; starting embedded stdio daemon \u2014 this session's queries will not appear in the extension's results panel`
-      );
-      notSetUpMessage = resolveNotSetUpMessage(Boolean(process.env["GRAIN_CONNECTIONS"]));
+    const result = await connectStdioToSharedDaemon(
+      args,
+      process.env,
+      defaultDaemonConfigDir(),
+      false,
+      deps
+    );
+    if (result.bridged) {
+      return;
     }
+    notSetUpMessage = result.notSetUpMessage;
   }
   if (!isStdio) {
     console.log("[INFO] Grain daemon process starting...");
@@ -253163,6 +253675,7 @@ if (require.main === module) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SERVICE_START_FLUSH_BUDGET_MS,
+  connectStdioToSharedDaemon,
   main
 });
 /*! Bundled license information: