@glasstrace/sdk 1.10.2 → 1.11.0

package/dist/cli/init.cjs

@@ -15226,10 +15226,7 @@ async function detectAgents(projectRoot) {
       continue;
     }
     seenAgents.add(rule.name);
-    let infoFilePath = rule.infoFilePath(foundDir);
-    if (infoFilePath !== null && !await pathExists(infoFilePath)) {
-      infoFilePath = null;
-    }
+    const infoFilePath = rule.infoFilePath(foundDir);
     const cliAvailable = rule.cliBinary ? await isCliAvailable(rule.cliBinary) : false;
     detected.push({
       name: rule.name,
@@ -15242,7 +15239,7 @@ async function detectAgents(projectRoot) {
   detected.push({
     name: "generic",
     mcpConfigPath: (0, import_node_path.join)(resolvedRoot, ".glasstrace", "mcp.json"),
-    infoFilePath: null,
+    infoFilePath: (0, import_node_path.join)(resolvedRoot, "AGENTS.md"),
     cliAvailable: false,
     registrationCommand: null
   });
@@ -15268,33 +15265,61 @@ var init_detect = __esm({
       },
       {
         name: "codex",
+        // Codex 2026 default discovery is `AGENTS.override.md` → `AGENTS.md` →
+        // opt-in `project_doc_fallback_filenames`; `codex.md` is NOT in the
+        // default fallback list. Detection requires Codex-specific markers
+        // (`codex.md` legacy, `.codex/` config dir) — `AGENTS.md` is NOT
+        // included as a marker because the SDK now writes `AGENTS.md`
+        // broadly via the multi-target dispatcher's companion writes; if
+        // `AGENTS.md` were a Codex marker, every project with the SDK's
+        // own companion AGENTS.md would re-classify as Codex on subsequent
+        // detect runs and trigger unintended `.codex/config.toml` writes
+        // (Codex P1 + Copilot P1 review of Wave 18 PR #274). The canonical
+        // write destination remains AGENTS.md regardless of which marker
+        // classified the project.
         markers: ["codex.md", ".codex"],
         mcpConfigPath: (dir) => (0, import_node_path.join)(dir, ".codex", "config.toml"),
-        infoFilePath: (dir) => (0, import_node_path.join)(dir, "codex.md"),
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, "AGENTS.md"),
         cliBinary: "codex",
         registrationCommand: "npx glasstrace mcp add --agent codex"
       },
       {
         name: "gemini",
-        markers: [".gemini"],
+        markers: [".gemini", "GEMINI.md"],
         mcpConfigPath: (dir) => (0, import_node_path.join)(dir, ".gemini", "settings.json"),
-        infoFilePath: () => null,
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, "GEMINI.md"),
         cliBinary: "gemini",
         registrationCommand: "npx glasstrace mcp add --agent gemini"
       },
       {
         name: "cursor",
+        // `.cursor/rules/*.mdc` is the current canonical format per Cursor's
+        // 2026 docs. `.cursorrules` (single file) is supported-but-deprecated
+        // and stays as a transitional fallback that the multi-target write
+        // helper writes unconditionally alongside the .mdc canonical.
         markers: [".cursor", ".cursorrules"],
         mcpConfigPath: (dir) => (0, import_node_path.join)(dir, ".cursor", "mcp.json"),
-        infoFilePath: (dir) => (0, import_node_path.join)(dir, ".cursorrules"),
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, ".cursor", "rules", "glasstrace.mdc"),
         cliBinary: null,
         registrationCommand: "npx glasstrace mcp add --agent cursor"
       },
       {
         name: "windsurf",
-        markers: [".windsurfrules", ".windsurf"],
+        // Windsurf's current canonical workspace-rules format is
+        // `.windsurf/rules/*.md`. AGENTS.md is a parallel cross-tool
+        // mechanism Windsurf also reads BUT is NOT included as a Windsurf
+        // detection marker — the SDK writes `AGENTS.md` broadly via the
+        // multi-target dispatcher's companion writes, so treating
+        // `AGENTS.md` as a Windsurf marker would re-classify every
+        // SDK-managed project as Windsurf and cause `glasstrace uninit`
+        // to mutate the global `~/.codeium/windsurf/mcp_config.json` for
+        // non-Windsurf projects (Codex P1 + Copilot P1 review of Wave 18
+        // PR #274). The single-file `.windsurfrules` is the deprecated
+        // legacy form — recognized as a marker so legacy projects classify
+        // correctly, but the SDK no longer writes to it.
+        markers: [".windsurf", ".windsurfrules"],
         mcpConfigPath: () => (0, import_node_path.join)((0, import_node_os.homedir)(), ".codeium", "windsurf", "mcp_config.json"),
-        infoFilePath: (dir) => (0, import_node_path.join)(dir, ".windsurfrules"),
+        infoFilePath: (dir) => (0, import_node_path.join)(dir, ".windsurf", "rules", "glasstrace.md"),
         cliBinary: null,
         registrationCommand: "npx glasstrace mcp add --agent windsurf"
       }
@@ -15479,34 +15504,71 @@ function generateInfoSection(agent, endpoint, sdkVersion) {
   }
   const content = buildAgentInstructionBody();
   switch (agent.name) {
-    case "claude": {
-      const m = htmlMarkers(sdkVersion);
-      return `${m.start}
-${content}${m.end}
-`;
-    }
-    case "codex": {
+    case "claude":
+    case "codex":
+    case "gemini":
+    case "windsurf":
+    case "generic": {
       const m = htmlMarkers(sdkVersion);
       return `${m.start}
 ${content}${m.end}
 `;
     }
     case "cursor": {
-      const m = hashMarkers(sdkVersion);
+      const m = htmlMarkers(sdkVersion);
       return `${m.start}
 ${content}${m.end}
 `;
     }
-    case "gemini":
-    case "windsurf":
-    case "generic":
-      return "";
     default: {
       const _exhaustive = agent.name;
       throw new Error(`Unknown agent: ${_exhaustive}`);
     }
   }
 }
+function generateInfoSectionForCursorrulesLegacy(endpoint, sdkVersion) {
+  if (!endpoint || endpoint.trim() === "") {
+    throw new Error("endpoint must not be empty");
+  }
+  if (!sdkVersion || sdkVersion.trim() === "") {
+    throw new Error("sdkVersion must not be empty");
+  }
+  if (!SDK_VERSION_STAMP_PATTERN.test(sdkVersion)) {
+    throw new Error(
+      "sdkVersion must match [A-Za-z0-9.+\\-]+ (semver-shaped, no whitespace, no angle brackets)"
+    );
+  }
+  const content = buildAgentInstructionBody();
+  const m = hashMarkers(sdkVersion);
+  return `${m.start}
+${content}${m.end}
+`;
+}
+function generateInfoSectionForCursorMdc(endpoint, sdkVersion) {
+  if (!endpoint || endpoint.trim() === "") {
+    throw new Error("endpoint must not be empty");
+  }
+  if (!sdkVersion || sdkVersion.trim() === "") {
+    throw new Error("sdkVersion must not be empty");
+  }
+  if (!SDK_VERSION_STAMP_PATTERN.test(sdkVersion)) {
+    throw new Error(
+      "sdkVersion must match [A-Za-z0-9.+\\-]+ (semver-shaped, no whitespace, no angle brackets)"
+    );
+  }
+  const content = buildAgentInstructionBody();
+  const m = htmlMarkers(sdkVersion);
+  return [
+    "---",
+    "description: Glasstrace MCP runtime debugging tools \u2014 runtime evidence the agent reads when source alone cannot resolve a bug",
+    "alwaysApply: true",
+    "---",
+    "",
+    `${m.start}
+${content}${m.end}
+`
+  ].join("\n");
+}
 var SDK_VERSION_STAMP_PATTERN;
 var init_configs = __esm({
   "src/agent-detection/configs.ts"() {
@@ -15586,71 +15648,6 @@ function findMarkerBoundaries(lines) {
   }
   return null;
 }
-async function injectInfoSection(agent, content, projectRoot) {
-  if (agent.infoFilePath === null) {
-    return;
-  }
-  if (content === "") {
-    return;
-  }
-  const filePath = agent.infoFilePath;
-  let existingContent = null;
-  try {
-    existingContent = await (0, import_promises2.readFile)(filePath, "utf-8");
-  } catch (err) {
-    const code = err.code;
-    if (code !== "ENOENT") {
-      if (isPermissionError(err)) {
-        process.stderr.write(
-          `Warning: cannot read info file ${filePath}: permission denied
-`
-        );
-        return;
-      }
-      throw err;
-    }
-  }
-  if (existingContent === null) {
-    try {
-      await (0, import_promises2.mkdir)((0, import_node_path2.dirname)(filePath), { recursive: true });
-      await (0, import_promises2.writeFile)(filePath, content, "utf-8");
-    } catch (err) {
-      if (isPermissionError(err)) {
-        process.stderr.write(
-          `Warning: cannot write info file ${filePath}: permission denied
-`
-        );
-        return;
-      }
-      throw err;
-    }
-    return;
-  }
-  const lines = existingContent.split("\n");
-  const boundaries = findMarkerBoundaries(lines);
-  let newContent;
-  if (boundaries !== null) {
-    const before = lines.slice(0, boundaries.startIdx);
-    const after = lines.slice(boundaries.endIdx + 1);
-    const contentWithoutTrailingNewline = content.endsWith("\n") ? content.slice(0, -1) : content;
-    newContent = [...before, contentWithoutTrailingNewline, ...after].join("\n");
-  } else {
-    const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
-    newContent = existingContent + separator + content;
-  }
-  try {
-    await (0, import_promises2.writeFile)(filePath, newContent, "utf-8");
-  } catch (err) {
-    if (isPermissionError(err)) {
-      process.stderr.write(
-        `Warning: cannot write info file ${filePath}: permission denied
-`
-      );
-      return;
-    }
-    throw err;
-  }
-}
 async function hasManagedSection(filePath) {
   let content;
   try {
@@ -15721,6 +15718,238 @@ var init_inject = __esm({
   }
 });
 
+// src/agent-detection/inject-all-targets.ts
+async function injectAllTargets(agents, endpoint, sdkVersion, projectRoot) {
+  const writtenAgentsMd = /* @__PURE__ */ new Set();
+  for (const agent of agents) {
+    const targets = computeTargets(agent, projectRoot);
+    for (const target of targets) {
+      if (target.isAgentsMdCompanion) {
+        if (writtenAgentsMd.has(target.path)) {
+          continue;
+        }
+        writtenAgentsMd.add(target.path);
+      }
+      let createContent;
+      let managedSectionOnly;
+      if (target.kind === "cursor-mdc") {
+        createContent = generateInfoSectionForCursorMdc(endpoint, sdkVersion);
+        managedSectionOnly = generateInfoSection(agent, endpoint, sdkVersion);
+      } else if (target.kind === "cursorrules-legacy") {
+        createContent = generateInfoSectionForCursorrulesLegacy(
+          endpoint,
+          sdkVersion
+        );
+        managedSectionOnly = createContent;
+      } else {
+        createContent = generateInfoSection(agent, endpoint, sdkVersion);
+        managedSectionOnly = createContent;
+      }
+      if (managedSectionOnly === "") continue;
+      await writeManagedSectionToTarget(
+        target.path,
+        createContent,
+        managedSectionOnly
+      );
+    }
+  }
+}
+function foundDirFromAgent(agent) {
+  if (agent.infoFilePath === null) return null;
+  switch (agent.name) {
+    case "claude":
+    case "codex":
+    case "gemini":
+    case "generic":
+      return (0, import_node_path3.dirname)(agent.infoFilePath);
+    case "cursor":
+      return (0, import_node_path3.dirname)((0, import_node_path3.dirname)((0, import_node_path3.dirname)(agent.infoFilePath)));
+    case "windsurf":
+      return (0, import_node_path3.dirname)((0, import_node_path3.dirname)((0, import_node_path3.dirname)(agent.infoFilePath)));
+  }
+}
+function computeTargets(agent, projectRoot) {
+  const targets = [];
+  const foundDir = foundDirFromAgent(agent) ?? projectRoot;
+  switch (agent.name) {
+    case "claude": {
+      if (agent.infoFilePath) {
+        targets.push({
+          path: agent.infoFilePath,
+          kind: "primary",
+          isAgentsMdCompanion: false
+        });
+      }
+      targets.push({
+        path: (0, import_node_path3.join)(foundDir, "AGENTS.md"),
+        kind: "agents-md-companion",
+        isAgentsMdCompanion: true
+      });
+      return targets;
+    }
+    case "codex": {
+      if (agent.infoFilePath) {
+        targets.push({
+          path: agent.infoFilePath,
+          kind: "primary",
+          isAgentsMdCompanion: true
+        });
+      }
+      return targets;
+    }
+    case "gemini": {
+      if (agent.infoFilePath) {
+        targets.push({
+          path: agent.infoFilePath,
+          kind: "primary",
+          isAgentsMdCompanion: false
+        });
+      }
+      targets.push({
+        path: (0, import_node_path3.join)(foundDir, "AGENTS.md"),
+        kind: "agents-md-companion",
+        isAgentsMdCompanion: true
+      });
+      return targets;
+    }
+    case "cursor": {
+      if (agent.infoFilePath) {
+        targets.push({
+          path: agent.infoFilePath,
+          kind: "cursor-mdc",
+          isAgentsMdCompanion: false
+        });
+        targets.push({
+          path: (0, import_node_path3.join)(foundDir, ".cursorrules"),
+          kind: "cursorrules-legacy",
+          isAgentsMdCompanion: false
+        });
+      }
+      targets.push({
+        path: (0, import_node_path3.join)(foundDir, "AGENTS.md"),
+        kind: "agents-md-companion",
+        isAgentsMdCompanion: true
+      });
+      return targets;
+    }
+    case "windsurf": {
+      if (agent.infoFilePath) {
+        targets.push({
+          path: agent.infoFilePath,
+          kind: "primary",
+          isAgentsMdCompanion: false
+        });
+      }
+      targets.push({
+        path: (0, import_node_path3.join)(foundDir, "AGENTS.md"),
+        kind: "agents-md-companion",
+        isAgentsMdCompanion: true
+      });
+      return targets;
+    }
+    case "generic": {
+      if (agent.infoFilePath) {
+        targets.push({
+          path: agent.infoFilePath,
+          kind: "primary",
+          isAgentsMdCompanion: true
+        });
+      }
+      return targets;
+    }
+    default: {
+      const _exhaustive = agent.name;
+      throw new Error(`Unknown agent: ${_exhaustive}`);
+    }
+  }
+}
+async function writeManagedSectionToTarget(filePath, createContent, managedSectionOnly) {
+  let existingContent = null;
+  try {
+    existingContent = await (0, import_promises3.readFile)(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      emitTargetWarning(filePath, "read", err);
+      return;
+    }
+  }
+  if (existingContent === null) {
+    try {
+      await (0, import_promises3.mkdir)((0, import_node_path3.dirname)(filePath), { recursive: true });
+      await (0, import_promises3.writeFile)(filePath, createContent, "utf-8");
+    } catch (err) {
+      emitTargetWarning(filePath, "write", err);
+      return;
+    }
+    return;
+  }
+  const lines = existingContent.split("\n");
+  const boundaries = findMarkerBoundaries(lines);
+  let newContent;
+  if (boundaries !== null) {
+    const before = lines.slice(0, boundaries.startIdx);
+    const after = lines.slice(boundaries.endIdx + 1);
+    const contentWithoutTrailingNewline = managedSectionOnly.endsWith("\n") ? managedSectionOnly.slice(0, -1) : managedSectionOnly;
+    newContent = [...before, contentWithoutTrailingNewline, ...after].join(
+      "\n"
+    );
+  } else {
+    const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
+    newContent = existingContent + separator + managedSectionOnly;
+  }
+  try {
+    await (0, import_promises3.writeFile)(filePath, newContent, "utf-8");
+  } catch (err) {
+    emitTargetWarning(filePath, "write", err);
+  }
+}
+function emitTargetWarning(filePath, op, err) {
+  const code = err.code;
+  let qualifier;
+  switch (code) {
+    case "EACCES":
+    case "EPERM":
+      qualifier = "permission denied";
+      break;
+    case "EROFS":
+      qualifier = "filesystem read-only";
+      break;
+    case "ENOSPC":
+      qualifier = "disk full";
+      break;
+    case "ENAMETOOLONG":
+      qualifier = "path too long";
+      break;
+    case "ENOTDIR":
+      qualifier = "not a directory";
+      break;
+    case "EISDIR":
+      qualifier = "is a directory";
+      break;
+    default:
+      qualifier = "I/O error";
+      break;
+  }
+  try {
+    process.stderr.write(
+      `Warning: cannot ${op} info file ${filePath}: ${qualifier}
+`
+    );
+  } catch {
+  }
+}
+var import_promises3, import_node_path3;
+var init_inject_all_targets = __esm({
+  "src/agent-detection/inject-all-targets.ts"() {
+    "use strict";
+    import_promises3 = require("node:fs/promises");
+    import_node_path3 = require("node:path");
+    init_configs();
+    init_inject();
+  }
+});
+
 // src/cli/monorepo.ts
 var monorepo_exports = {};
 __export(monorepo_exports, {
@@ -16873,9 +17102,14 @@ var init_uninit = __esm({
     init_inject();
     MCP_CONFIG_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json"];
     AGENT_INFO_FILES = [
+      "AGENTS.md",
       "CLAUDE.md",
+      "GEMINI.md",
+      ".cursor/rules/glasstrace.mdc",
+      ".windsurf/rules/glasstrace.md",
+      ".cursorrules",
       "codex.md",
-      ".cursorrules"
+      ".windsurfrules"
     ];
   }
 });
@@ -17026,14 +17260,9 @@ async function mcpAdd(options) {
   const bearer = resolved.effective.key;
   for (const agent of targetAgents) {
     const name = formatAgentName(agent.name);
-    const sdkVersion = true ? "1.10.2" : "0.0.0-dev";
     if (agent.name !== "generic") {
       const cliSuccess = await registerViaCli(agent, bearer);
       if (cliSuccess) {
-        const infoContent = generateInfoSection(agent, MCP_ENDPOINT, sdkVersion);
-        if (infoContent !== "") {
-          await injectInfoSection(agent, infoContent, projectRoot);
-        }
         results.push({
           agent: agent.name,
           success: true,
@@ -17048,10 +17277,6 @@ async function mcpAdd(options) {
         const configContent = generateMcpConfig(agent, MCP_ENDPOINT, bearer);
         await writeMcpConfig(agent, configContent, projectRoot);
         if (fs6.existsSync(agent.mcpConfigPath)) {
-          const infoContent = generateInfoSection(agent, MCP_ENDPOINT, sdkVersion);
-          if (infoContent !== "") {
-            await injectInfoSection(agent, infoContent, projectRoot);
-          }
           results.push({
             agent: agent.name,
             success: true,
@@ -17084,6 +17309,34 @@ async function mcpAdd(options) {
       message: `${name}: No registration method available`
     });
   }
+  const successfulAgentNames = new Set(
+    results.filter((r) => r.success).map((r) => r.agent)
+  );
+  const agentsWithMcpReady = targetAgents.filter(
+    (a) => successfulAgentNames.has(a.name)
+  );
+  const detectedNonGenericMcpAdd = targetAgents.filter(
+    (a) => a.name !== "generic"
+  );
+  const nonGenericReadyMcpAdd = agentsWithMcpReady.filter(
+    (a) => a.name !== "generic"
+  );
+  const dispatchSetMcpAdd = detectedNonGenericMcpAdd.length === 0 ? agentsWithMcpReady : nonGenericReadyMcpAdd;
+  if (dispatchSetMcpAdd.length > 0) {
+    const sdkVersion = true ? "1.11.0" : "0.0.0-dev";
+    try {
+      await injectAllTargets(
+        dispatchSetMcpAdd,
+        MCP_ENDPOINT,
+        sdkVersion,
+        projectRoot
+      );
+    } catch (injectErr) {
+      messages.push(
+        `Warning: Failed to write some agent-instruction files: ${injectErr instanceof Error ? injectErr.message : String(injectErr)}`
+      );
+    }
+  }
   await updateGitignore(
     [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".codex/config.toml"],
     projectRoot
@@ -17139,6 +17392,7 @@ var init_mcp_add = __esm({
     init_mcp_runtime();
     init_detect();
     init_configs();
+    init_inject_all_targets();
     init_inject();
     init_constants();
     execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
@@ -17273,9 +17527,41 @@ var upgrade_instructions_exports = {};
 __export(upgrade_instructions_exports, {
   runUpgradeInstructions: () => runUpgradeInstructions
 });
+function legacyDestinationsForAgent(agent) {
+  if (agent.infoFilePath === null) {
+    return [];
+  }
+  switch (agent.name) {
+    case "codex":
+      return [(0, import_node_path4.join)((0, import_node_path4.dirname)(agent.infoFilePath), "codex.md")];
+    case "cursor":
+      return [
+        (0, import_node_path4.join)((0, import_node_path4.dirname)((0, import_node_path4.dirname)((0, import_node_path4.dirname)(agent.infoFilePath))), ".cursorrules")
+      ];
+    case "windsurf":
+      return [
+        (0, import_node_path4.join)(
+          (0, import_node_path4.dirname)((0, import_node_path4.dirname)((0, import_node_path4.dirname)(agent.infoFilePath))),
+          ".windsurfrules"
+        )
+      ];
+    case "claude":
+    case "gemini":
+    case "generic":
+      return [];
+  }
+}
+async function anyHasManagedSection(paths) {
+  for (const p of paths) {
+    if (await hasManagedSection(p)) {
+      return true;
+    }
+  }
+  return false;
+}
 function formatPathForOutput(filePath, projectRoot) {
-  const rel = (0, import_node_path3.relative)(projectRoot, filePath);
-  if (rel === "" || rel.startsWith("..") || (0, import_node_path3.isAbsolute)(rel)) {
+  const rel = (0, import_node_path4.relative)(projectRoot, filePath);
+  if (rel === "" || rel.startsWith("..") || (0, import_node_path4.isAbsolute)(rel)) {
     return filePath;
   }
   return rel;
@@ -17294,7 +17580,8 @@ async function runUpgradeInstructions(options) {
     );
     return { exitCode: 1, refreshed, skipped, warnings, errors };
   }
-  const sdkVersion = true ? "1.10.2" : "0.0.0-dev";
+  const sdkVersion = true ? "1.11.0" : "0.0.0-dev";
+  const optedInAgents = [];
   for (const agent of agents) {
     if (agent.infoFilePath === null) {
       continue;
@@ -17303,44 +17590,64 @@ async function runUpgradeInstructions(options) {
       agent.infoFilePath,
       options.projectRoot
     );
-    let containsSection;
+    const legacyDestinations = legacyDestinationsForAgent(agent);
+    let optedIn;
     try {
-      containsSection = await hasManagedSection(agent.infoFilePath);
+      optedIn = await anyHasManagedSection([
+        agent.infoFilePath,
+        ...legacyDestinations
+      ]);
     } catch (err) {
       warnings.push(
         `Could not inspect ${displayPath}: ${err instanceof Error ? err.message : String(err)}`
       );
       continue;
     }
-    if (!containsSection) {
+    if (!optedIn) {
       skipped.push(displayPath);
       continue;
     }
-    const content = generateInfoSection(agent, MCP_ENDPOINT, sdkVersion);
-    if (content === "") {
-      continue;
-    }
+    optedInAgents.push(agent);
+  }
+  if (optedInAgents.length > 0) {
     try {
-      await injectInfoSection(agent, content, options.projectRoot);
-      refreshed.push(displayPath);
+      await injectAllTargets(
+        optedInAgents,
+        MCP_ENDPOINT,
+        sdkVersion,
+        options.projectRoot
+      );
+      for (const a of optedInAgents) {
+        if (a.infoFilePath !== null) {
+          refreshed.push(formatPathForOutput(a.infoFilePath, options.projectRoot));
+        }
+      }
     } catch (err) {
       errors.push(
-        `Failed to refresh ${displayPath}: ${err instanceof Error ? err.message : String(err)}`
+        `Failed to refresh agent-instruction files: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
+  const refreshedSet = new Set(refreshed);
+  const dedupedSkipped = skipped.filter((p) => !refreshedSet.has(p));
   const exitCode = errors.length === 0 ? 0 : 1;
-  return { exitCode, refreshed, skipped, warnings, errors };
+  return {
+    exitCode,
+    refreshed,
+    skipped: dedupedSkipped,
+    warnings,
+    errors
+  };
 }
-var import_node_path3;
+var import_node_path4;
 var init_upgrade_instructions = __esm({
   "src/cli/upgrade-instructions.ts"() {
     "use strict";
-    import_node_path3 = require("node:path");
+    import_node_path4 = require("node:path");
     init_mcp_runtime();
     init_detect();
-    init_configs();
     init_inject();
+    init_inject_all_targets();
   }
 });
 
@@ -17528,9 +17835,14 @@ var init_status = __esm({
     MCP_JSON_FILES = [".mcp.json", ".cursor/mcp.json", ".gemini/settings.json", ".glasstrace/mcp.json"];
     MCP_TOML_FILES = [".codex/config.toml"];
     AGENT_INFO_FILES2 = [
+      "AGENTS.md",
       "CLAUDE.md",
+      "GEMINI.md",
+      ".cursor/rules/glasstrace.mdc",
+      ".windsurf/rules/glasstrace.md",
+      ".cursorrules",
       "codex.md",
-      ".cursorrules"
+      ".windsurfrules"
     ];
     INSTRUMENTATION_FILES = [
       "instrumentation.ts",
@@ -18112,6 +18424,7 @@ async function buildImportGraph(projectRoot) {
 init_anon_key();
 init_detect();
 init_configs();
+init_inject_all_targets();
 init_inject();
 init_constants();
 init_monorepo();
@@ -18910,6 +19223,7 @@ Then add this as the first statement in your register() function:
         agents = [];
       }
       const configuredNames = [];
+      const agentsWithMcpReady = [];
       for (const agent of agents) {
         try {
           const configContent = generateMcpConfig(agent, MCP_ENDPOINT, bearer);
@@ -18924,6 +19238,7 @@ Then add this as the first statement in your register() function:
             );
             if (agent.mcpConfigPath !== null && fs9.existsSync(agent.mcpConfigPath)) {
               anyConfigWritten = true;
+              agentsWithMcpReady.push(agent);
             }
             continue;
           }
@@ -18934,15 +19249,7 @@ Then add this as the first statement in your register() function:
           }
           anyConfigWritten = true;
           anyConfigRewrittenWithBearer = true;
-          const sdkVersionForInject = true ? "1.10.2" : "0.0.0-dev";
-          const infoContent = generateInfoSection(
-            agent,
-            MCP_ENDPOINT,
-            sdkVersionForInject
-          );
-          if (infoContent !== "") {
-            await injectInfoSection(agent, infoContent, projectRoot);
-          }
+          agentsWithMcpReady.push(agent);
           if (agent.name !== "generic") {
             configuredNames.push(formatAgentName(agent.name));
           }
@@ -18952,6 +19259,26 @@ Then add this as the first statement in your register() function:
           );
         }
       }
+      const detectedNonGeneric = agents.filter((a) => a.name !== "generic");
+      const nonGenericReady = agentsWithMcpReady.filter(
+        (a) => a.name !== "generic"
+      );
+      const dispatchSet = detectedNonGeneric.length === 0 ? agentsWithMcpReady : nonGenericReady;
+      if (dispatchSet.length > 0) {
+        const sdkVersionForInject = true ? "1.11.0" : "0.0.0-dev";
+        try {
+          await injectAllTargets(
+            dispatchSet,
+            MCP_ENDPOINT,
+            sdkVersionForInject,
+            projectRoot
+          );
+        } catch (injectErr) {
+          warnings.push(
+            `Failed to write agent-instruction files: ${injectErr instanceof Error ? injectErr.message : String(injectErr)}`
+          );
+        }
+      }
       if (configuredNames.length > 0) {
         summary.push(`Configured MCP for: ${configuredNames.join(", ")}`);
       } else if (anyConfigWritten) {
@@ -19040,7 +19367,7 @@ async function verifyAnonKeyRegistration(projectRoot) {
   }
   const baseConfig = resolveConfig({ apiKey: devKey });
   const config2 = { ...baseConfig, apiKey: devKey };
-  const sdkVersion = true ? "1.10.2" : "0.0.0-dev";
+  const sdkVersion = true ? "1.11.0" : "0.0.0-dev";
   const result = await verifyInitReachable(config2, anonKey, sdkVersion);
   if (result.ok) {
     return { outcome: "verified" };