@glasstrace/sdk 0.19.0 → 0.20.1

package/dist/cli/init.cjs

@@ -755,10 +755,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1070,11 +1070,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -1317,7 +1317,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path9 = []) => {
+  const processError = (error49, path10 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1327,7 +1327,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1359,8 +1359,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path10) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14124,13 +14124,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.length === 0) {
+  const path10 = ref.slice(1).split("/").filter(Boolean);
+  if (path10.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15110,11 +15110,11 @@ var init_dist = __esm({
 async function loadFsPath() {
   if (fsPathCache !== void 0) return fsPathCache;
   try {
-    const [fs9, path9] = await Promise.all([
+    const [fs10, path10] = await Promise.all([
       import("node:fs/promises"),
       import("node:path")
     ]);
-    fsPathCache = { fs: fs9, path: path9 };
+    fsPathCache = { fs: fs10, path: path10 };
     return fsPathCache;
   } catch {
     fsPathCache = null;
@@ -15201,9 +15201,9 @@ var init_anon_key = __esm({
 });
 
 // src/agent-detection/detect.ts
-async function pathExists(path9, mode = import_node_fs.constants.R_OK) {
+async function pathExists(path10, mode = import_node_fs.constants.R_OK) {
   try {
-    await (0, import_promises.access)(path9, mode);
+    await (0, import_promises.access)(path10, mode);
     return true;
   } catch {
     return false;
@@ -15955,6 +15955,209 @@ var init_monorepo = __esm({
   }
 });
 
+// src/cli/discovery-file.ts
+function resolveStaticRoot(projectRoot) {
+  if (isSvelteKitProject(projectRoot)) {
+    return {
+      absolutePath: path4.join(projectRoot, "static"),
+      layout: "static"
+    };
+  }
+  return {
+    absolutePath: path4.join(projectRoot, "public"),
+    layout: "public"
+  };
+}
+function isSvelteKitProject(projectRoot) {
+  const pkgPath = path4.join(projectRoot, "package.json");
+  let isEsm = false;
+  try {
+    const pkgContent = fs4.readFileSync(pkgPath, "utf-8");
+    const parsed = JSON.parse(pkgContent);
+    isEsm = parsed.type === "module";
+  } catch {
+    return false;
+  }
+  if (!isEsm) return false;
+  const svelteConfigJs = path4.join(projectRoot, "svelte.config.js");
+  const svelteConfigTs = path4.join(projectRoot, "svelte.config.ts");
+  const appHtml = path4.join(projectRoot, "src", "app.html");
+  return fs4.existsSync(svelteConfigJs) || fs4.existsSync(svelteConfigTs) || fs4.existsSync(appHtml);
+}
+function relativeDiscoveryPath(layout) {
+  const rootDir = layout === "static" ? "static" : "public";
+  return `${rootDir}/${WELL_KNOWN_GLASSTRACE_PATH}`;
+}
+function readExistingDiscoveryFile(filePath) {
+  let raw;
+  try {
+    raw = fs4.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const obj = parsed;
+  const versionRaw = obj.version;
+  if (typeof versionRaw !== "number" || !Number.isInteger(versionRaw) || versionRaw < 1) {
+    return null;
+  }
+  const keyResult = AnonApiKeySchema.safeParse(obj.key);
+  if (!keyResult.success) {
+    return null;
+  }
+  const extras = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "version" || k === "key") continue;
+    extras[k] = v;
+  }
+  return { key: keyResult.data, extras };
+}
+function serializeDiscoveryPayload(key, extras) {
+  const payload = {
+    version: DISCOVERY_FILE_VERSION,
+    key,
+    ...extras
+  };
+  return JSON.stringify(payload, null, 2) + "\n";
+}
+function writeDiscoveryFile(projectRoot, anonKey) {
+  const { absolutePath: staticRoot, layout } = resolveStaticRoot(projectRoot);
+  const wellKnownDir = path4.join(staticRoot, ".well-known");
+  const filePath = path4.join(wellKnownDir, "glasstrace.json");
+  let existingAction;
+  let extras = {};
+  if (fs4.existsSync(filePath)) {
+    const existing = readExistingDiscoveryFile(filePath);
+    if (existing === null) {
+      existingAction = "skipped-foreign";
+    } else if (existing.key === anonKey) {
+      return {
+        action: "skipped-matches",
+        filePath,
+        layout
+      };
+    } else {
+      extras = existing.extras;
+      existingAction = "updated-stale";
+    }
+  } else {
+    existingAction = "created";
+  }
+  const tmpPath = `${filePath}.tmp-${process.pid}`;
+  const needsWindowsReplace = process.platform === "win32" && fs4.existsSync(filePath);
+  const backupPath = needsWindowsReplace ? `${filePath}.bak-${process.pid}` : null;
+  try {
+    fs4.mkdirSync(wellKnownDir, { recursive: true });
+    const payload = serializeDiscoveryPayload(anonKey, extras);
+    fs4.writeFileSync(tmpPath, payload, { encoding: "utf-8" });
+    if (backupPath !== null) {
+      fs4.renameSync(filePath, backupPath);
+      try {
+        fs4.renameSync(tmpPath, filePath);
+      } catch (renameErr) {
+        try {
+          fs4.renameSync(backupPath, filePath);
+        } catch {
+        }
+        throw renameErr;
+      }
+      try {
+        fs4.unlinkSync(backupPath);
+      } catch {
+      }
+    } else {
+      fs4.renameSync(tmpPath, filePath);
+    }
+    return { action: existingAction, filePath, layout };
+  } catch (err) {
+    try {
+      if (fs4.existsSync(tmpPath)) {
+        fs4.unlinkSync(tmpPath);
+      }
+    } catch {
+    }
+    return {
+      action: "failed",
+      filePath,
+      layout,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function removeDiscoveryFile(projectRoot) {
+  const { layout: inferredLayout } = resolveStaticRoot(projectRoot);
+  const layouts = ["public", "static"];
+  const outcomes = [];
+  for (const layout of layouts) {
+    const staticRoot = path4.join(projectRoot, layout);
+    const wellKnownDir = path4.join(staticRoot, ".well-known");
+    const filePath = path4.join(wellKnownDir, "glasstrace.json");
+    let removed = false;
+    try {
+      if (fs4.existsSync(filePath)) {
+        fs4.unlinkSync(filePath);
+        removed = true;
+      }
+    } catch (err) {
+      return {
+        action: "failed",
+        filePath,
+        layout,
+        directoryRemoved: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    let directoryRemoved = false;
+    if (removed) {
+      try {
+        if (fs4.existsSync(wellKnownDir)) {
+          const entries = fs4.readdirSync(wellKnownDir);
+          if (entries.length === 0) {
+            fs4.rmdirSync(wellKnownDir);
+            directoryRemoved = true;
+          }
+        }
+      } catch {
+      }
+    }
+    outcomes.push({ layout, filePath, removed, directoryRemoved });
+  }
+  const removals = outcomes.filter((o) => o.removed);
+  const chosen = (() => {
+    if (removals.length === 0) {
+      return outcomes.find((o) => o.layout === inferredLayout) ?? outcomes[0];
+    }
+    if (removals.length === 1) return removals[0];
+    return removals.find((o) => o.layout === inferredLayout) ?? removals[0];
+  })();
+  const anyDirectoryRemoved = outcomes.some((o) => o.directoryRemoved);
+  return {
+    action: removals.length > 0 ? "removed" : "not-found",
+    filePath: chosen.filePath,
+    layout: chosen.layout,
+    directoryRemoved: chosen.directoryRemoved || anyDirectoryRemoved
+  };
+}
+var fs4, path4, WELL_KNOWN_GLASSTRACE_PATH, DISCOVERY_FILE_VERSION;
+var init_discovery_file = __esm({
+  "src/cli/discovery-file.ts"() {
+    "use strict";
+    fs4 = __toESM(require("node:fs"), 1);
+    path4 = __toESM(require("node:path"), 1);
+    init_dist();
+    WELL_KNOWN_GLASSTRACE_PATH = ".well-known/glasstrace.json";
+    DISCOVERY_FILE_VERSION = 1;
+  }
+});
+
 // src/cli/uninit.ts
 var uninit_exports = {};
 __export(uninit_exports, {
@@ -16272,24 +16475,24 @@ function processTomlMcpConfig(content) {
   return { action: "removed-section", content: result + "\n" };
 }
 function writeShutdownMarker(projectRoot) {
-  const dirPath = path4.join(projectRoot, ".glasstrace");
-  if (!fs4.existsSync(dirPath)) {
+  const dirPath = path5.join(projectRoot, ".glasstrace");
+  if (!fs5.existsSync(dirPath)) {
     return false;
   }
-  const markerPath = path4.join(dirPath, "shutdown-requested");
+  const markerPath = path5.join(dirPath, "shutdown-requested");
   const tmpPath = `${markerPath}.tmp`;
   const body = JSON.stringify({ requestedAt: (/* @__PURE__ */ new Date()).toISOString() });
   try {
-    fs4.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    fs5.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
     try {
-      fs4.chmodSync(tmpPath, 384);
+      fs5.chmodSync(tmpPath, 384);
     } catch {
     }
-    fs4.renameSync(tmpPath, markerPath);
+    fs5.renameSync(tmpPath, markerPath);
     return true;
   } catch {
     try {
-      fs4.unlinkSync(tmpPath);
+      fs5.unlinkSync(tmpPath);
     } catch {
     }
     return false;
@@ -16330,8 +16533,8 @@ async function runUninit(options) {
         summary.push("Wrote .glasstrace/shutdown-requested marker");
       }
     } else {
-      const dirPath = path4.join(projectRoot, ".glasstrace");
-      if (fs4.existsSync(dirPath)) {
+      const dirPath = path5.join(projectRoot, ".glasstrace");
+      if (fs5.existsSync(dirPath)) {
         summary.push(`${prefix}Would write .glasstrace/shutdown-requested marker`);
       }
     }
@@ -16343,11 +16546,11 @@ async function runUninit(options) {
   try {
     let configHandled = false;
     for (const name of NEXT_CONFIG_NAMES) {
-      const configPath = path4.join(projectRoot, name);
-      if (!fs4.existsSync(configPath)) {
+      const configPath = path5.join(projectRoot, name);
+      if (!fs5.existsSync(configPath)) {
         continue;
       }
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs5.readFileSync(configPath, "utf-8");
       if (!content.includes("withGlasstraceConfig")) {
         continue;
       }
@@ -16357,7 +16560,7 @@ async function runUninit(options) {
         const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
         const final = cleanLeadingBlankLines(cleaned);
         if (!dryRun) {
-          fs4.writeFileSync(configPath, final, "utf-8");
+          fs5.writeFileSync(configPath, final, "utf-8");
         }
         summary.push(`${prefix}Unwrapped withGlasstraceConfig from ${name}`);
         configHandled = true;
@@ -16378,20 +16581,20 @@ async function runUninit(options) {
     );
   }
   try {
-    const instrPath = path4.join(projectRoot, "instrumentation.ts");
-    if (fs4.existsSync(instrPath)) {
-      const content = fs4.readFileSync(instrPath, "utf-8");
+    const instrPath = path5.join(projectRoot, "instrumentation.ts");
+    if (fs5.existsSync(instrPath)) {
+      const content = fs5.readFileSync(instrPath, "utf-8");
       if (content.includes("registerGlasstrace") || content.includes("@glasstrace/sdk")) {
         if (isInitCreatedInstrumentation(content)) {
           if (!dryRun) {
-            fs4.unlinkSync(instrPath);
+            fs5.unlinkSync(instrPath);
           }
           summary.push(`${prefix}Deleted instrumentation.ts (init-created)`);
         } else {
           const cleaned = removeRegisterGlasstrace(content);
           if (cleaned !== content) {
             if (!dryRun) {
-              fs4.writeFileSync(instrPath, cleaned, "utf-8");
+              fs5.writeFileSync(instrPath, cleaned, "utf-8");
             }
             summary.push(
               `${prefix}Removed registerGlasstrace() from instrumentation.ts`
@@ -16406,10 +16609,10 @@ async function runUninit(options) {
     );
   }
   try {
-    const glasstraceDir = path4.join(projectRoot, ".glasstrace");
-    if (fs4.existsSync(glasstraceDir)) {
+    const glasstraceDir = path5.join(projectRoot, ".glasstrace");
+    if (fs5.existsSync(glasstraceDir)) {
       if (!dryRun) {
-        fs4.rmSync(glasstraceDir, { recursive: true, force: true });
+        fs5.rmSync(glasstraceDir, { recursive: true, force: true });
       }
       summary.push(`${prefix}Removed .glasstrace/ directory`);
     }
@@ -16419,9 +16622,38 @@ async function runUninit(options) {
     );
   }
   try {
-    const envPath = path4.join(projectRoot, ".env.local");
-    if (fs4.existsSync(envPath)) {
-      const content = fs4.readFileSync(envPath, "utf-8");
+    if (dryRun) {
+      for (const previewLayout of ["public", "static"]) {
+        const relPath = relativeDiscoveryPath(previewLayout);
+        const absPath = path5.join(projectRoot, relPath);
+        if (fs5.existsSync(absPath)) {
+          summary.push(`${prefix}Would remove ${relPath}`);
+        }
+      }
+    } else {
+      const result = removeDiscoveryFile(projectRoot);
+      if (result.action === "removed") {
+        const relPath = relativeDiscoveryPath(result.layout);
+        summary.push(`Removed ${relPath}`);
+        if (result.directoryRemoved) {
+          const dirRel = relPath.replace(/\/glasstrace\.json$/, "/");
+          summary.push(`Removed empty ${dirRel}`);
+        }
+      } else if (result.action === "failed") {
+        warnings.push(
+          `Failed to remove ${relativeDiscoveryPath(result.layout)}${result.error !== void 0 ? `: ${result.error}` : ""}`
+        );
+      }
+    }
+  } catch (err) {
+    warnings.push(
+      `Failed to remove discovery file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  try {
+    const envPath = path5.join(projectRoot, ".env.local");
+    if (fs5.existsSync(envPath)) {
+      const content = fs5.readFileSync(envPath, "utf-8");
       const existingKey = readEnvLocalApiKey(content);
       const hasDevKey = isDevApiKey(existingKey);
       let proceed = true;
@@ -16454,12 +16686,12 @@ async function runUninit(options) {
           const result = filtered.join("\n");
           if (result.trim().length === 0) {
             if (!dryRun) {
-              fs4.unlinkSync(envPath);
+              fs5.unlinkSync(envPath);
             }
             summary.push(`${prefix}Deleted .env.local (no remaining entries)`);
           } else {
             if (!dryRun) {
-              fs4.writeFileSync(envPath, result, "utf-8");
+              fs5.writeFileSync(envPath, result, "utf-8");
             }
             let devKeyAnnotation = "";
             if (devKeyPath === "interactive-confirmed") {
@@ -16482,9 +16714,9 @@ async function runUninit(options) {
     );
   }
   try {
-    const gitignorePath = path4.join(projectRoot, ".gitignore");
-    if (fs4.existsSync(gitignorePath)) {
-      const content = fs4.readFileSync(gitignorePath, "utf-8");
+    const gitignorePath = path5.join(projectRoot, ".gitignore");
+    if (fs5.existsSync(gitignorePath)) {
+      const content = fs5.readFileSync(gitignorePath, "utf-8");
       const lines = content.split("\n");
       const mcpGitignoreEntries = /* @__PURE__ */ new Set([
         ".glasstrace/",
@@ -16500,12 +16732,12 @@ async function runUninit(options) {
         const result = filtered.join("\n");
         if (result.trim().length === 0) {
           if (!dryRun) {
-            fs4.unlinkSync(gitignorePath);
+            fs5.unlinkSync(gitignorePath);
           }
           summary.push(`${prefix}Deleted .gitignore (no remaining entries)`);
         } else {
           if (!dryRun) {
-            fs4.writeFileSync(gitignorePath, result, "utf-8");
+            fs5.writeFileSync(gitignorePath, result, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace entries from .gitignore`);
         }
@@ -16518,63 +16750,63 @@ async function runUninit(options) {
   }
   try {
     for (const configFile of MCP_CONFIG_FILES) {
-      const configPath = path4.join(projectRoot, configFile);
-      if (!fs4.existsSync(configPath)) {
+      const configPath = path5.join(projectRoot, configFile);
+      if (!fs5.existsSync(configPath)) {
         continue;
       }
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs5.readFileSync(configPath, "utf-8");
       const result = processJsonMcpConfig(content);
       if (result.action === "deleted") {
         if (!dryRun) {
-          fs4.unlinkSync(configPath);
+          fs5.unlinkSync(configPath);
         }
         summary.push(`${prefix}Deleted ${configFile}`);
       } else if (result.action === "removed-key" && result.content !== void 0) {
         if (!dryRun) {
-          fs4.writeFileSync(configPath, result.content, "utf-8");
+          fs5.writeFileSync(configPath, result.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from ${configFile}`);
       }
     }
-    const codexConfigPath = path4.join(projectRoot, ".codex", "config.toml");
-    if (fs4.existsSync(codexConfigPath)) {
-      const content = fs4.readFileSync(codexConfigPath, "utf-8");
+    const codexConfigPath = path5.join(projectRoot, ".codex", "config.toml");
+    if (fs5.existsSync(codexConfigPath)) {
+      const content = fs5.readFileSync(codexConfigPath, "utf-8");
       const tomlResult = processTomlMcpConfig(content);
       if (tomlResult.action === "deleted") {
         if (!dryRun) {
-          fs4.unlinkSync(codexConfigPath);
+          fs5.unlinkSync(codexConfigPath);
         }
         summary.push(`${prefix}Deleted .codex/config.toml`);
       } else if (tomlResult.action === "removed-section" && tomlResult.content !== void 0) {
         if (!dryRun) {
-          fs4.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
+          fs5.writeFileSync(codexConfigPath, tomlResult.content, "utf-8");
         }
         summary.push(`${prefix}Removed glasstrace from .codex/config.toml`);
       }
     }
-    const hasWindsurfMarkers = fs4.existsSync(path4.join(projectRoot, ".windsurfrules")) || fs4.existsSync(path4.join(projectRoot, ".windsurf"));
+    const hasWindsurfMarkers = fs5.existsSync(path5.join(projectRoot, ".windsurfrules")) || fs5.existsSync(path5.join(projectRoot, ".windsurf"));
     if (hasWindsurfMarkers) {
-      const windsurfConfigPath = path4.join(
+      const windsurfConfigPath = path5.join(
         os.homedir(),
         ".codeium",
         "windsurf",
         "mcp_config.json"
       );
-      if (fs4.existsSync(windsurfConfigPath)) {
-        const content = fs4.readFileSync(windsurfConfigPath, "utf-8");
+      if (fs5.existsSync(windsurfConfigPath)) {
+        const content = fs5.readFileSync(windsurfConfigPath, "utf-8");
         const windsurfResult = processJsonMcpConfig(content);
         const home = os.homedir();
         const displayPath = windsurfConfigPath.startsWith(home) ? "~" + windsurfConfigPath.slice(home.length) : windsurfConfigPath;
         if (windsurfResult.action === "deleted") {
           if (!dryRun) {
-            fs4.unlinkSync(windsurfConfigPath);
+            fs5.unlinkSync(windsurfConfigPath);
           }
           summary.push(
             `${prefix}Deleted global Windsurf config (${displayPath})`
           );
         } else if (windsurfResult.action === "removed-key" && windsurfResult.content !== void 0) {
           if (!dryRun) {
-            fs4.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
+            fs5.writeFileSync(windsurfConfigPath, windsurfResult.content, "utf-8");
           }
           summary.push(
             `${prefix}Removed glasstrace from global Windsurf config (${displayPath})`
@@ -16589,21 +16821,21 @@ async function runUninit(options) {
   }
   try {
     for (const infoFile of AGENT_INFO_FILES) {
-      const filePath = path4.join(projectRoot, infoFile);
-      if (!fs4.existsSync(filePath)) {
+      const filePath = path5.join(projectRoot, infoFile);
+      if (!fs5.existsSync(filePath)) {
         continue;
       }
-      const content = fs4.readFileSync(filePath, "utf-8");
+      const content = fs5.readFileSync(filePath, "utf-8");
       const result = removeMarkerSection(content);
       if (result.removed) {
         if (result.content.trim().length === 0) {
           if (!dryRun) {
-            fs4.unlinkSync(filePath);
+            fs5.unlinkSync(filePath);
           }
           summary.push(`${prefix}Deleted ${infoFile} (only contained Glasstrace section)`);
         } else {
           if (!dryRun) {
-            fs4.writeFileSync(filePath, result.content, "utf-8");
+            fs5.writeFileSync(filePath, result.content, "utf-8");
           }
           summary.push(`${prefix}Removed Glasstrace section from ${infoFile}`);
         }
@@ -16619,15 +16851,16 @@ async function runUninit(options) {
   }
   return { exitCode: errors.length > 0 ? 1 : 0, summary, warnings, errors };
 }
-var fs4, os, path4, MCP_CONFIG_FILES, AGENT_INFO_FILES;
+var fs5, os, path5, MCP_CONFIG_FILES, AGENT_INFO_FILES;
 var init_uninit = __esm({
   "src/cli/uninit.ts"() {
     "use strict";
-    fs4 = __toESM(require("node:fs"), 1);
+    fs5 = __toESM(require("node:fs"), 1);
     os = __toESM(require("node:os"), 1);
-    path4 = __toESM(require("node:path"), 1);
+    path5 = __toESM(require("node:path"), 1);
     init_constants();
     init_scaffolder();
+    init_discovery_file();
     MCP_CONFIG_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json"];
     AGENT_INFO_FILES = [
       "CLAUDE.md",
@@ -16673,11 +16906,11 @@ async function registerViaCli(agent, anonKey) {
           MCP_ENDPOINT
         ]);
         const configPath = agent.mcpConfigPath;
-        if (configPath !== null && fs5.existsSync(configPath)) {
-          const content = fs5.readFileSync(configPath, "utf-8");
+        if (configPath !== null && fs6.existsSync(configPath)) {
+          const content = fs6.readFileSync(configPath, "utf-8");
           if (!content.includes("bearer_token_env_var")) {
             const appendContent = content.endsWith("\n") ? "" : "\n";
-            fs5.writeFileSync(
+            fs6.writeFileSync(
               configPath,
               content + appendContent + 'bearer_token_env_var = "GLASSTRACE_API_KEY"\n',
               "utf-8"
@@ -16722,8 +16955,8 @@ async function mcpAdd(options) {
       messages: ["Error: Run `glasstrace init` first to generate an API key."]
     };
   }
-  const markerPath = path5.join(projectRoot, ".glasstrace", "mcp-connected");
-  if (fs5.existsSync(markerPath) && !force) {
+  const markerPath = path6.join(projectRoot, ".glasstrace", "mcp-connected");
+  if (fs6.existsSync(markerPath) && !force) {
     return {
       exitCode: 0,
       results: [],
@@ -16782,7 +17015,7 @@ async function mcpAdd(options) {
       try {
         const configContent = generateMcpConfig(agent, MCP_ENDPOINT, anonKey);
         await writeMcpConfig(agent, configContent, projectRoot);
-        if (fs5.existsSync(agent.mcpConfigPath)) {
+        if (fs6.existsSync(agent.mcpConfigPath)) {
           const infoContent = generateInfoSection(agent, MCP_ENDPOINT);
           if (infoContent !== "") {
             await injectInfoSection(agent, infoContent, projectRoot);
@@ -16849,13 +17082,13 @@ async function mcpAdd(options) {
   }
   return { exitCode: 0, results, messages };
 }
-var import_node_child_process2, fs5, path5, import_node_util, execFileAsync;
+var import_node_child_process2, fs6, path6, import_node_util, execFileAsync;
 var init_mcp_add = __esm({
   "src/cli/mcp-add.ts"() {
     "use strict";
     import_node_child_process2 = require("node:child_process");
-    fs5 = __toESM(require("node:fs"), 1);
-    path5 = __toESM(require("node:path"), 1);
+    fs6 = __toESM(require("node:fs"), 1);
+    path6 = __toESM(require("node:path"), 1);
     import_node_util = require("node:util");
     init_anon_key();
     init_detect();
@@ -16886,15 +17119,15 @@ function hasRegisterGlasstraceImport(content) {
 function runValidate(options) {
   const { projectRoot } = options;
   const issues = [];
-  const glasstraceDir = path6.join(projectRoot, ".glasstrace");
-  const instrumentationPath = path6.join(projectRoot, "instrumentation.ts");
-  const markerPath = path6.join(glasstraceDir, "mcp-connected");
+  const glasstraceDir = path7.join(projectRoot, ".glasstrace");
+  const instrumentationPath = path7.join(projectRoot, "instrumentation.ts");
+  const markerPath = path7.join(glasstraceDir, "mcp-connected");
   const glasstraceDirExists = isDirectorySafe(glasstraceDir);
-  const instrumentationExists = fs6.existsSync(instrumentationPath);
+  const instrumentationExists = fs7.existsSync(instrumentationPath);
   const instrumentationContent = instrumentationExists ? safeReadFile(instrumentationPath) : null;
-  const markerExists = fs6.existsSync(markerPath);
+  const markerExists = fs7.existsSync(markerPath);
   const mcpConfigsPresent = MCP_CONFIG_CANDIDATES.filter(
-    (rel) => fs6.existsSync(path6.join(projectRoot, rel))
+    (rel) => fs7.existsSync(path7.join(projectRoot, rel))
   );
   if (glasstraceDirExists) {
     if (instrumentationContent === null || !hasRegisterGlasstraceImport(instrumentationContent)) {
@@ -16944,25 +17177,25 @@ function runValidate(options) {
 }
 function safeReadFile(filePath) {
   try {
-    return fs6.readFileSync(filePath, "utf-8");
+    return fs7.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function isDirectorySafe(dirPath) {
   try {
-    if (!fs6.existsSync(dirPath)) return false;
-    return fs6.statSync(dirPath).isDirectory();
+    if (!fs7.existsSync(dirPath)) return false;
+    return fs7.statSync(dirPath).isDirectory();
   } catch {
     return false;
   }
 }
-var fs6, path6, MCP_CONFIG_CANDIDATES;
+var fs7, path7, MCP_CONFIG_CANDIDATES;
 var init_validate = __esm({
   "src/cli/validate.ts"() {
     "use strict";
-    fs6 = __toESM(require("node:fs"), 1);
-    path6 = __toESM(require("node:path"), 1);
+    fs7 = __toESM(require("node:fs"), 1);
+    path7 = __toESM(require("node:path"), 1);
     MCP_CONFIG_CANDIDATES = [
       ".mcp.json",
       ".cursor/mcp.json",
@@ -16992,8 +17225,8 @@ function runStatus(options) {
 }
 function checkInstalled(root) {
   try {
-    const pkgPath = path7.join(root, "package.json");
-    const content = fs7.readFileSync(pkgPath, "utf-8");
+    const pkgPath = path8.join(root, "package.json");
+    const content = fs8.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     const deps = pkg["dependencies"];
     const devDeps = pkg["devDependencies"];
@@ -17004,7 +17237,7 @@ function checkInstalled(root) {
 }
 function checkInitialized(root) {
   try {
-    return fs7.statSync(path7.join(root, ".glasstrace")).isDirectory();
+    return fs8.statSync(path8.join(root, ".glasstrace")).isDirectory();
   } catch {
     return false;
   }
@@ -17012,7 +17245,7 @@ function checkInitialized(root) {
 function checkInstrumentation(root) {
   for (const name of INSTRUMENTATION_FILES) {
     try {
-      const content = fs7.readFileSync(path7.join(root, name), "utf-8");
+      const content = fs8.readFileSync(path8.join(root, name), "utf-8");
       if (content.includes("registerGlasstrace")) {
         return true;
       }
@@ -17024,7 +17257,7 @@ function checkInstrumentation(root) {
 function checkConfigWrapped(root) {
   for (const name of NEXT_CONFIG_NAMES) {
     try {
-      const content = fs7.readFileSync(path7.join(root, name), "utf-8");
+      const content = fs8.readFileSync(path8.join(root, name), "utf-8");
       if (content.includes("withGlasstraceConfig")) {
         return true;
       }
@@ -17035,7 +17268,7 @@ function checkConfigWrapped(root) {
 }
 function checkAnonKey(root) {
   try {
-    return fs7.statSync(path7.join(root, ".glasstrace", "anon_key")).isFile();
+    return fs8.statSync(path8.join(root, ".glasstrace", "anon_key")).isFile();
   } catch {
     return false;
   }
@@ -17043,7 +17276,7 @@ function checkAnonKey(root) {
 function checkMcpConfigured(root) {
   for (const name of MCP_JSON_FILES) {
     try {
-      const content = fs7.readFileSync(path7.join(root, name), "utf-8");
+      const content = fs8.readFileSync(path8.join(root, name), "utf-8");
       const parsed = JSON.parse(content);
       const mcpServers = parsed["mcpServers"];
       if (mcpServers && typeof mcpServers === "object" && "glasstrace" in mcpServers) {
@@ -17054,7 +17287,7 @@ function checkMcpConfigured(root) {
   }
   for (const name of MCP_TOML_FILES) {
     try {
-      const content = fs7.readFileSync(path7.join(root, name), "utf-8");
+      const content = fs8.readFileSync(path8.join(root, name), "utf-8");
       if (content.includes("[mcp_servers.glasstrace]")) {
         return true;
       }
@@ -17067,7 +17300,7 @@ function checkAgents(root) {
   const found = [];
   for (const name of AGENT_INFO_FILES2) {
     try {
-      const content = fs7.readFileSync(path7.join(root, name), "utf-8");
+      const content = fs8.readFileSync(path8.join(root, name), "utf-8");
       const hasHtmlMarkers = content.includes("<!-- glasstrace:mcp:start -->") && content.includes("<!-- glasstrace:mcp:end -->");
       const hasHashMarkers = content.includes("# glasstrace:mcp:start") && content.includes("# glasstrace:mcp:end");
       if (hasHtmlMarkers || hasHashMarkers) {
@@ -17090,8 +17323,8 @@ function readRuntimeState(root) {
     pid: null
   };
   try {
-    const filePath = path7.join(root, ".glasstrace", "runtime-state.json");
-    const content = fs7.readFileSync(filePath, "utf-8");
+    const filePath = path8.join(root, ".glasstrace", "runtime-state.json");
+    const content = fs8.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const updatedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : null;
     const pid = typeof parsed.pid === "number" ? parsed.pid : null;
@@ -17140,12 +17373,12 @@ function readRuntimeState(root) {
     return empty;
   }
 }
-var fs7, path7, MCP_JSON_FILES, MCP_TOML_FILES, AGENT_INFO_FILES2, INSTRUMENTATION_FILES, STALE_THRESHOLD_MS;
+var fs8, path8, MCP_JSON_FILES, MCP_TOML_FILES, AGENT_INFO_FILES2, INSTRUMENTATION_FILES, STALE_THRESHOLD_MS;
 var init_status = __esm({
   "src/cli/status.ts"() {
     "use strict";
-    fs7 = __toESM(require("node:fs"), 1);
-    path7 = __toESM(require("node:path"), 1);
+    fs8 = __toESM(require("node:fs"), 1);
+    path8 = __toESM(require("node:path"), 1);
     init_constants();
     MCP_JSON_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".glasstrace/mcp.json"];
     MCP_TOML_FILES = [".codex/config.toml"];
@@ -17170,14 +17403,15 @@ var init_status = __esm({
 var init_exports = {};
 __export(init_exports, {
   decideMcpConfigAction: () => decideMcpConfigAction,
+  gitignoreExcludesDiscoveryFile: () => gitignoreExcludesDiscoveryFile,
   meetsNodeVersion: () => meetsNodeVersion,
   rollbackSteps: () => rollbackSteps,
   runInit: () => runInit,
   verifyAnonKeyRegistration: () => verifyAnonKeyRegistration
 });
 module.exports = __toCommonJS(init_exports);
-var fs8 = __toESM(require("node:fs"), 1);
-var path8 = __toESM(require("node:path"), 1);
+var fs9 = __toESM(require("node:fs"), 1);
+var path9 = __toESM(require("node:path"), 1);
 var readline = __toESM(require("node:readline"), 1);
 init_scaffolder();
 
@@ -17705,6 +17939,7 @@ function resolveConfig(options) {
 }
 
 // src/cli/init.ts
+init_discovery_file();
 function meetsNodeVersion(minMajor) {
   const [major] = process.versions.node.split(".").map(Number);
   return major >= minMajor;
@@ -17712,8 +17947,8 @@ function meetsNodeVersion(minMajor) {
 async function decideMcpConfigAction(options) {
   const { configPath, expectedContent, force } = options;
   if (configPath === null) return "write";
-  const exists = options.existsSync ?? fs8.existsSync;
-  const read = options.readFile ?? ((p) => fs8.readFileSync(p, "utf-8"));
+  const exists = options.existsSync ?? fs9.existsSync;
+  const read = options.readFile ?? ((p) => fs9.readFileSync(p, "utf-8"));
   const prompt = options.prompt ?? promptYesNo;
   if (!exists(configPath)) return "write";
   let existingContent;
@@ -17758,22 +17993,69 @@ async function promptYesNo(question, defaultValue) {
 function cleanLeadingBlankLines2(content) {
   return content.replace(/^\n{2,}/, "\n");
 }
+function gitignoreExcludesDiscoveryFile(gitignoreContent, layout) {
+  const staticRoot = layout === "static" ? "static" : "public";
+  const rootTargets = [staticRoot, `${staticRoot}/`];
+  const wellKnownTargets = [
+    `${staticRoot}/.well-known`,
+    `${staticRoot}/.well-known/`,
+    ".well-known",
+    ".well-known/"
+  ];
+  const fileTargets = [
+    `${staticRoot}/.well-known/glasstrace.json`,
+    ".well-known/glasstrace.json"
+  ];
+  let rootIgnored = false;
+  let wellKnownIgnored = false;
+  let fileIgnored = false;
+  for (const rawLine of gitignoreContent.split("\n")) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const negation = line.startsWith("!");
+    const pattern = negation ? line.slice(1).trim() : line;
+    if (pattern === "") continue;
+    const normalized = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+    const matchesRoot = matchesDiscoveryPath(normalized, rootTargets);
+    const matchesWellKnown = matchesDiscoveryPath(normalized, wellKnownTargets);
+    const matchesFile = matchesDiscoveryPath(normalized, fileTargets);
+    if (!matchesRoot && !matchesWellKnown && !matchesFile) continue;
+    const newState = !negation;
+    if (matchesRoot) rootIgnored = newState;
+    if (matchesWellKnown) wellKnownIgnored = newState;
+    if (matchesFile) fileIgnored = newState;
+  }
+  return rootIgnored || wellKnownIgnored || fileIgnored;
+}
+function matchesDiscoveryPath(pattern, targets) {
+  const bare = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+  for (const target of targets) {
+    const tBare = target.endsWith("/") ? target.slice(0, -1) : target;
+    if (bare === tBare) return true;
+    if (pattern.startsWith("**/")) {
+      const suffix = pattern.slice(3);
+      const sBare = suffix.endsWith("/") ? suffix.slice(0, -1) : suffix;
+      if (tBare === sBare || tBare.endsWith(`/${sBare}`)) return true;
+    }
+  }
+  return false;
+}
 async function rollbackSteps(steps, projectRoot, state) {
   for (const step of [...steps].reverse()) {
     try {
       switch (step) {
         case "instrumentation": {
-          const instrPath = state?.instrumentationPath ?? path8.join(projectRoot, "instrumentation.ts");
-          if (fs8.existsSync(instrPath)) {
-            const content = fs8.readFileSync(instrPath, "utf-8");
+          const instrPath = state?.instrumentationPath ?? path9.join(projectRoot, "instrumentation.ts");
+          if (fs9.existsSync(instrPath)) {
+            const content = fs9.readFileSync(instrPath, "utf-8");
             if (isInitCreatedInstrumentation(content)) {
-              fs8.unlinkSync(instrPath);
+              fs9.unlinkSync(instrPath);
             } else if (state?.originalInstrumentationContent !== void 0) {
-              fs8.writeFileSync(instrPath, state.originalInstrumentationContent, "utf-8");
+              fs9.writeFileSync(instrPath, state.originalInstrumentationContent, "utf-8");
             } else {
               const cleaned = removeRegisterGlasstrace(content);
               if (cleaned !== content) {
-                fs8.writeFileSync(instrPath, cleaned, "utf-8");
+                fs9.writeFileSync(instrPath, cleaned, "utf-8");
               }
             }
           }
@@ -17781,11 +18063,11 @@ async function rollbackSteps(steps, projectRoot, state) {
         }
         case "next-config": {
           for (const name of NEXT_CONFIG_NAMES) {
-            const configPath = path8.join(projectRoot, name);
-            if (!fs8.existsSync(configPath)) {
+            const configPath = path9.join(projectRoot, name);
+            if (!fs9.existsSync(configPath)) {
               continue;
             }
-            const content = fs8.readFileSync(configPath, "utf-8");
+            const content = fs9.readFileSync(configPath, "utf-8");
             if (!content.includes("withGlasstraceConfig")) {
               continue;
             }
@@ -17793,16 +18075,16 @@ async function rollbackSteps(steps, projectRoot, state) {
             const unwrapResult = isESM ? unwrapExport(content) : unwrapCJSExport(content);
             if (unwrapResult.unwrapped) {
               const cleaned = removeGlasstraceConfigImport(unwrapResult.content);
-              fs8.writeFileSync(configPath, cleanLeadingBlankLines2(cleaned), "utf-8");
+              fs9.writeFileSync(configPath, cleanLeadingBlankLines2(cleaned), "utf-8");
             }
             break;
           }
           break;
         }
         case "env-local": {
-          const envPath = path8.join(projectRoot, ".env.local");
-          if (fs8.existsSync(envPath)) {
-            const content = fs8.readFileSync(envPath, "utf-8");
+          const envPath = path9.join(projectRoot, ".env.local");
+          if (fs9.existsSync(envPath)) {
+            const content = fs9.readFileSync(envPath, "utf-8");
             const lines = content.split("\n");
             const filtered = lines.filter((line) => {
               const trimmed = line.trim();
@@ -17811,18 +18093,18 @@ async function rollbackSteps(steps, projectRoot, state) {
             if (filtered.length !== lines.length) {
               const result = filtered.join("\n");
               if (result.trim().length === 0) {
-                fs8.unlinkSync(envPath);
+                fs9.unlinkSync(envPath);
               } else {
-                fs8.writeFileSync(envPath, result, "utf-8");
+                fs9.writeFileSync(envPath, result, "utf-8");
               }
             }
           }
           break;
         }
         case "gitignore": {
-          const gitignorePath = path8.join(projectRoot, ".gitignore");
-          if (fs8.existsSync(gitignorePath)) {
-            const content = fs8.readFileSync(gitignorePath, "utf-8");
+          const gitignorePath = path9.join(projectRoot, ".gitignore");
+          if (fs9.existsSync(gitignorePath)) {
+            const content = fs9.readFileSync(gitignorePath, "utf-8");
             const lines = content.split("\n");
             const filtered = lines.filter(
               (line) => line.trim() !== ".glasstrace/"
@@ -17830,14 +18112,18 @@ async function rollbackSteps(steps, projectRoot, state) {
             if (filtered.length !== lines.length) {
               const result = filtered.join("\n");
               if (result.trim().length === 0) {
-                fs8.unlinkSync(gitignorePath);
+                fs9.unlinkSync(gitignorePath);
               } else {
-                fs8.writeFileSync(gitignorePath, result, "utf-8");
+                fs9.writeFileSync(gitignorePath, result, "utf-8");
               }
             }
           }
           break;
         }
+        case "discovery-file": {
+          removeDiscoveryFile(projectRoot);
+          break;
+        }
       }
     } catch {
     }
@@ -17859,8 +18145,8 @@ async function runInit(options) {
     errors.push(err instanceof Error ? err.message : String(err));
     return { exitCode: 1, summary, warnings, errors };
   }
-  const packageJsonPath = path8.join(projectRoot, "package.json");
-  if (!fs8.existsSync(packageJsonPath)) {
+  const packageJsonPath = path9.join(projectRoot, "package.json");
+  if (!fs9.existsSync(packageJsonPath)) {
     errors.push("No package.json found. Run this command from a Node.js project root.");
     return { exitCode: 1, summary, warnings, errors };
   }
@@ -17869,8 +18155,8 @@ async function runInit(options) {
     const preResolved = resolveInstrumentationTarget(projectRoot);
     if (!preResolved.conflict && preResolved.target !== null) {
       rollbackState.instrumentationPath = preResolved.target;
-      if (fs8.existsSync(preResolved.target)) {
-        rollbackState.originalInstrumentationContent = fs8.readFileSync(
+      if (fs9.existsSync(preResolved.target)) {
+        rollbackState.originalInstrumentationContent = fs9.readFileSync(
           preResolved.target,
           "utf-8"
         );
@@ -17885,7 +18171,7 @@ async function runInit(options) {
     if (instrResult.filePath !== void 0) {
       rollbackState.instrumentationPath = instrResult.filePath;
     }
-    const relativePath = instrResult.filePath !== void 0 ? path8.relative(projectRoot, instrResult.filePath) : "instrumentation.ts";
+    const relativePath = instrResult.filePath !== void 0 ? path9.relative(projectRoot, instrResult.filePath) : "instrumentation.ts";
     switch (instrResult.action) {
       case "created":
         summary.push(`Created ${relativePath}`);
@@ -17910,8 +18196,8 @@ async function runInit(options) {
         );
         break;
       case "conflict": {
-        const primary = instrResult.filePath !== void 0 ? path8.relative(projectRoot, instrResult.filePath) : "src/instrumentation.ts";
-        const competing = instrResult.conflictingPath !== void 0 ? path8.relative(projectRoot, instrResult.conflictingPath) : "instrumentation.ts";
+        const primary = instrResult.filePath !== void 0 ? path9.relative(projectRoot, instrResult.filePath) : "src/instrumentation.ts";
+        const competing = instrResult.conflictingPath !== void 0 ? path9.relative(projectRoot, instrResult.conflictingPath) : "instrumentation.ts";
         await rollbackSteps(rollbackState.steps, projectRoot, rollbackState);
         errors.push(
           `Both ${primary} and ${competing} exist. Next.js's loader behavior is undefined when both are present.
@@ -17958,10 +18244,10 @@ Then add this as the first statement in your register() function:
     return { exitCode: 1, summary, warnings, errors };
   }
   try {
-    const envPathForCheck = path8.join(projectRoot, ".env.local");
+    const envPathForCheck = path9.join(projectRoot, ".env.local");
     let existingDevKey = false;
-    if (fs8.existsSync(envPathForCheck)) {
-      const existingContent = fs8.readFileSync(envPathForCheck, "utf-8");
+    if (fs9.existsSync(envPathForCheck)) {
+      const existingContent = fs9.readFileSync(envPathForCheck, "utf-8");
       existingDevKey = isDevApiKey(readEnvLocalApiKey(existingContent));
     }
     const envCreated = await scaffoldEnvLocal(projectRoot);
@@ -18001,11 +18287,55 @@ Then add this as the first statement in your register() function:
     if (preExistingAnonKey !== null) {
       summary.push("Preserved existing .glasstrace/anon_key");
     }
+    try {
+      const discoveryResult = writeDiscoveryFile(projectRoot, anonKey);
+      const relPath = relativeDiscoveryPath(discoveryResult.layout);
+      switch (discoveryResult.action) {
+        case "created":
+          summary.push(`Created ${relPath}`);
+          rollbackState.steps.push("discovery-file");
+          break;
+        case "updated-stale":
+          summary.push(`Updated ${relPath} (anon key had changed)`);
+          break;
+        case "skipped-matches":
+          summary.push(`Skipped ${relPath} (already matches anon key)`);
+          break;
+        case "skipped-foreign":
+          summary.push(
+            `Rewrote ${relPath} (existing file was malformed or not SDK-managed)`
+          );
+          break;
+        case "failed":
+          warnings.push(
+            `Failed to write ${relPath}${discoveryResult.error !== void 0 ? `: ${discoveryResult.error}` : ""}. The Glasstrace browser extension will fall back to the runtime handler until the file is written.`
+          );
+          break;
+      }
+      const gitignorePath = path9.join(projectRoot, ".gitignore");
+      if (fs9.existsSync(gitignorePath)) {
+        try {
+          const gitignoreContent = fs9.readFileSync(gitignorePath, "utf-8");
+          if (gitignoreExcludesDiscoveryFile(gitignoreContent, discoveryResult.layout)) {
+            warnings.push(
+              `Your .gitignore excludes ${relPath} (directly or via a parent rule). The discovery file must be committed for the Glasstrace browser extension to find it in deployed builds. Remove the matching line from .gitignore or add an explicit negation (e.g. \`!` + relPath + "`)."
+            );
+          }
+        } catch {
+        }
+      }
+    } catch (err) {
+      warnings.push(
+        `Failed to write ${relativeDiscoveryPath(
+          resolveStaticRoot(projectRoot).layout
+        )}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     let anyConfigWritten = false;
     if (isCI) {
       const genericAgent = {
         name: "generic",
-        mcpConfigPath: path8.join(projectRoot, ".glasstrace", "mcp.json"),
+        mcpConfigPath: path9.join(projectRoot, ".glasstrace", "mcp.json"),
         infoFilePath: null,
         cliAvailable: false,
         registrationCommand: null
@@ -18019,7 +18349,7 @@ Then add this as the first statement in your register() function:
       if (decision !== "skip") {
         await writeMcpConfig(genericAgent, genericConfig, projectRoot);
       }
-      if (genericAgent.mcpConfigPath !== null && fs8.existsSync(genericAgent.mcpConfigPath)) {
+      if (genericAgent.mcpConfigPath !== null && fs9.existsSync(genericAgent.mcpConfigPath)) {
         anyConfigWritten = true;
         summary.push("Created .glasstrace/mcp.json (CI mode)");
       }
@@ -18033,14 +18363,14 @@ Then add this as the first statement in your register() function:
         );
         const genericAgent = {
           name: "generic",
-          mcpConfigPath: path8.join(projectRoot, ".glasstrace", "mcp.json"),
+          mcpConfigPath: path9.join(projectRoot, ".glasstrace", "mcp.json"),
           infoFilePath: null,
           cliAvailable: false,
           registrationCommand: null
         };
         const genericConfig = generateMcpConfig(genericAgent, MCP_ENDPOINT, anonKey);
         await writeMcpConfig(genericAgent, genericConfig, projectRoot);
-        if (genericAgent.mcpConfigPath !== null && fs8.existsSync(genericAgent.mcpConfigPath)) {
+        if (genericAgent.mcpConfigPath !== null && fs9.existsSync(genericAgent.mcpConfigPath)) {
           anyConfigWritten = true;
         }
         agents = [];
@@ -18058,13 +18388,13 @@ Then add this as the first statement in your register() function:
             summary.push(
               `Preserved existing ${agent.mcpConfigPath ?? agent.name} (user declined overwrite)`
             );
-            if (agent.mcpConfigPath !== null && fs8.existsSync(agent.mcpConfigPath)) {
+            if (agent.mcpConfigPath !== null && fs9.existsSync(agent.mcpConfigPath)) {
               anyConfigWritten = true;
             }
             continue;
           }
           await writeMcpConfig(agent, configContent, projectRoot);
-          const configExists = agent.mcpConfigPath !== null && fs8.existsSync(agent.mcpConfigPath);
+          const configExists = agent.mcpConfigPath !== null && fs9.existsSync(agent.mcpConfigPath);
           if (!configExists) {
             continue;
           }
@@ -18150,9 +18480,9 @@ async function verifyAnonKeyRegistration(projectRoot) {
   }
   let devKey;
   try {
-    const envPath = path8.join(projectRoot, ".env.local");
-    if (fs8.existsSync(envPath)) {
-      const envContent = fs8.readFileSync(envPath, "utf-8");
+    const envPath = path9.join(projectRoot, ".env.local");
+    if (fs9.existsSync(envPath)) {
+      const envContent = fs9.readFileSync(envPath, "utf-8");
       const effective = readEnvLocalApiKey(envContent);
       if (effective !== null && isDevApiKey(effective)) {
         devKey = effective;
@@ -18162,7 +18492,7 @@ async function verifyAnonKeyRegistration(projectRoot) {
   }
   const baseConfig = resolveConfig({ apiKey: devKey });
   const config2 = { ...baseConfig, apiKey: devKey };
-  const sdkVersion = true ? "0.19.0" : "0.0.0-dev";
+  const sdkVersion = true ? "0.20.1" : "0.0.0-dev";
   const result = await verifyInitReachable(config2, anonKey, sdkVersion);
   if (result.ok) {
     return { outcome: "verified" };
@@ -18211,7 +18541,7 @@ function parseArgs(argv) {
   };
 }
 var scriptPath = typeof process !== "undefined" && process.argv[1] !== void 0 ? process.argv[1].replace(/\\/g, "/") : void 0;
-var scriptBasename = scriptPath !== void 0 ? path8.basename(scriptPath) : void 0;
+var scriptBasename = scriptPath !== void 0 ? path9.basename(scriptPath) : void 0;
 var isDirectExecution = scriptPath !== void 0 && (scriptPath.endsWith("/cli/init.js") || scriptPath.endsWith("/cli/init.ts") || scriptBasename === "glasstrace");
 if (isDirectExecution) {
   if (!meetsNodeVersion(20)) {
@@ -18412,6 +18742,7 @@ Usage:
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   decideMcpConfigAction,
+  gitignoreExcludesDiscoveryFile,
   meetsNodeVersion,
   rollbackSteps,
   runInit,