@narumitw/pi-chrome-devtools 0.53.4 → 0.54.0

package/dist/chunks/{chunk-V7N3WI5B.ts → chunk-WOFI2A72.ts}

@@ -3,6 +3,7 @@
 import {
   CHROME_DEVTOOLS_TOOL_NAMES,
   CORE_CHROME_DEVTOOLS_TOOL_NAMES,
+  ToolCatalogApplicationError,
   browserCandidateHint,
   browserLifecycleState,
   browserSettingsForOwner,
@@ -20,10 +21,42 @@ import {
   settingsFilePath,
   state,
   webMcpEnabled
-} from "./chunk-LSJSDY2M.ts";
+} from "./chunk-TVVYQ5KM.ts";
+
+// src/display.ts
+var MAX_SANITIZER_INPUT_CODE_UNITS = 5e4;
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function sanitizeChromeDevtoolsDisplay(value, maxCharacters = 5e4) {
+  const inputWasTruncated = value.length > MAX_SANITIZER_INPUT_CODE_UNITS;
+  const boundedInput = inputWasTruncated ? truncateAtGraphemeBoundary(value, MAX_SANITIZER_INPUT_CODE_UNITS) : value;
+  const normalizedLineEndings = boundedInput.replace(/\r\n/g, "\n");
+  const sanitized = Array.from(normalizedLineEndings, (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const unsafeControl = codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+    const unsafeBidi = codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297;
+    const loneSurrogate = character.length === 1 && codePoint >= 55296 && codePoint <= 57343;
+    return unsafeControl || unsafeBidi || loneSurrogate ? "\uFFFD" : character;
+  }).join("");
+  const outputLimit = Math.min(maxCharacters, MAX_SANITIZER_INPUT_CODE_UNITS);
+  if (!inputWasTruncated && sanitized.length <= outputLimit) return sanitized;
+  return `${truncateAtGraphemeBoundary(sanitized, Math.max(0, outputLimit - 1))}\u2026`;
+}
+function truncateAtGraphemeBoundary(value, maxCodeUnits) {
+  if (value.length <= maxCodeUnits) return value;
+  const boundedLookahead = value.slice(0, Math.max(0, maxCodeUnits) + 2);
+  let safeEnd = 0;
+  for (const { index, segment } of graphemeSegmenter.segment(boundedLookahead)) {
+    const segmentEnd = index + segment.length;
+    if (segmentEnd > maxCodeUnits) break;
+    safeEnd = segmentEnd;
+  }
+  return value.slice(0, safeEnd);
+}
 
 // src/lazy-tools.ts
-import { defineTool } from "@earendil-works/pi-coding-agent";
+import {
+  defineTool
+} from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 var CHROME_DEVTOOLS_LOAD_TOOL_NAME = "chrome_devtools_load";
 var AVAILABLE_TOOLS_STORE = /* @__PURE__ */ Symbol.for("@narumitw/pi-chrome-devtools.available-tools-store");
@@ -33,6 +66,153 @@ var availableToolsByApi = existingAvailableToolsStore ?? /* @__PURE__ */ new Wea
 if (!existingAvailableToolsStore) sharedGlobal[AVAILABLE_TOOLS_STORE] = availableToolsByApi;
 var lazyExposureByApi = /* @__PURE__ */ new WeakMap();
 var sessionOwnerByApi = /* @__PURE__ */ new WeakMap();
+var PROVENANCE_STORE = /* @__PURE__ */ Symbol.for("@narumitw/pi-chrome-devtools.activation-provenance");
+var PROVENANCE_ENTRY = "chrome-devtools.activation-provenance";
+var provenanceGlobal = globalThis;
+var ownedBySession = provenanceGlobal[PROVENANCE_STORE] ?? /* @__PURE__ */ new WeakMap();
+provenanceGlobal[PROVENANCE_STORE] = ownedBySession;
+var modeByApi = /* @__PURE__ */ new WeakMap();
+var loaderRegistered = /* @__PURE__ */ new WeakSet();
+function retainedExplicitTools(pi, before) {
+  const owner = sessionOwnerByApi.get(pi);
+  const ownership = owner ? ownedBySession.get(owner) : void 0;
+  const observed = new Set(before);
+  return CHROME_DEVTOOLS_TOOL_NAMES.filter(
+    (name) => ownership?.explicit.has(name) && (observed.has(name) || ownership.published?.has(name) === false)
+  );
+}
+function publishActiveTools(pi, names, before) {
+  pi.setActiveTools(names);
+  recordOwnership(pi, before);
+}
+function recordOwnership(pi, before) {
+  const names = pi.getActiveTools();
+  const owner = sessionOwnerByApi.get(pi);
+  if (!owner) return;
+  const ownership = ownedBySession.get(owner) ?? {
+    explicit: /* @__PURE__ */ new Set(),
+    owned: /* @__PURE__ */ new Set()
+  };
+  const observed = new Set(before);
+  for (const name of ownership.explicit) {
+    if (!observed.has(name) && (ownership.published?.has(name) ?? true))
+      ownership.explicit.delete(name);
+  }
+  for (const name of before)
+    if (CHROME_DEVTOOLS_TOOL_NAMES.includes(name) && !ownership.owned.has(name))
+      ownership.explicit.add(name);
+  if (chromeDevtoolsToolMode(pi) !== "codemode") {
+    for (const name of names)
+      if (CHROME_DEVTOOLS_TOOL_NAMES.includes(name) && !ownership.explicit.has(name))
+        ownership.owned.add(name);
+  }
+  if (chromeDevtoolsToolMode(pi) === "codemode") ownership.owned.clear();
+  const published = new Set(names);
+  ownership.published = new Set(CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => published.has(name)));
+  ownedBySession.set(owner, ownership);
+  persistOwnership(pi, ownership);
+}
+function ownershipData(ownership) {
+  return {
+    version: 1,
+    explicit: CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => ownership.explicit.has(name)),
+    owned: CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => ownership.owned.has(name)),
+    available: ownership.available ? CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => ownership.available?.has(name)) : void 0,
+    mode: ownership.mode,
+    published: ownership.published ? CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => ownership.published?.has(name)) : void 0
+  };
+}
+var ActivationProvenanceError = class extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+  }
+};
+function formatProvenanceWarning(error) {
+  return sanitizeChromeDevtoolsDisplay(
+    `Activation ownership could not be saved: ${error.message}. Activation is not rolled back; durable ownership may be incomplete until a later loader call or lifecycle update retries successfully.`
+  );
+}
+function publishLifecycleTools(pi, names, before) {
+  try {
+    publishActiveTools(pi, names, before);
+  } catch (error) {
+    if (!(error instanceof ActivationProvenanceError)) throw error;
+    return formatProvenanceWarning(error);
+  }
+}
+function persistOwnership(pi, ownership) {
+  ownership.available = new Set(configuredChromeDevtoolsTools(pi));
+  ownership.mode = chromeDevtoolsToolMode(pi);
+  const data = ownershipData(ownership);
+  const serialized = JSON.stringify(data);
+  if (ownership.serialized === serialized) return;
+  try {
+    pi.appendEntry(PROVENANCE_ENTRY, data);
+    ownership.serialized = serialized;
+  } catch (error) {
+    ownership.serialized = void 0;
+    throw new ActivationProvenanceError(error);
+  }
+}
+function restoredOwnership(entries) {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry.type !== "custom" || entry.customType !== PROVENANCE_ENTRY) continue;
+    const data = entry.data;
+    if (typeof data !== "object" || data === null || Array.isArray(data)) return void 0;
+    const record = data;
+    const validNames = (value) => Array.isArray(value) && value.length <= CHROME_DEVTOOLS_TOOL_NAMES.length && value.every((name) => CHROME_DEVTOOLS_TOOL_NAMES.includes(name));
+    if (record.version !== 1 || !validNames(record.explicit) || !validNames(record.owned) || record.available !== void 0 && !validNames(record.available) || record.published !== void 0 && !validNames(record.published) || record.mode !== void 0 && record.mode !== "codemode" && record.mode !== "lazy" && record.mode !== "direct" || record.owned.some((name) => record.explicit.includes(name)))
+      return void 0;
+    const restored = {
+      explicit: new Set(record.explicit),
+      owned: new Set(record.owned),
+      available: validNames(record.available) ? new Set(record.available) : void 0,
+      mode: record.mode,
+      published: validNames(record.published) ? new Set(record.published) : void 0
+    };
+    return { ...restored, serialized: JSON.stringify(ownershipData(restored)) };
+  }
+  return void 0;
+}
+var definitionsByApi = /* @__PURE__ */ new WeakMap();
+function registerChromeDevtoolsCapabilities(pi, tools) {
+  definitionsByApi.set(pi, tools);
+  for (const tool of tools) pi.registerTool({ ...tool, exposure: "codemode", defaultActive: false });
+  pi.registerTool({
+    ...createChromeDevtoolsLoadTool(pi),
+    exposure: "codemode",
+    defaultActive: false,
+    promptSnippet: void 0,
+    promptGuidelines: void 0
+  });
+  loaderRegistered.add(pi);
+}
+function chromeDevtoolsToolMode(pi) {
+  return modeByApi.get(pi) ?? "codemode";
+}
+function refreshExposure(pi) {
+  const available = effectiveAvailableTools(pi);
+  const mode = chromeDevtoolsToolMode(pi);
+  for (const tool of definitionsByApi.get(pi) ?? []) {
+    pi.registerTool({
+      ...tool,
+      defaultActive: false,
+      exposure: available.has(tool.name) ? mode === "codemode" ? "codemode" : "direct" : "hidden"
+    });
+  }
+  if (mode === "lazy") {
+    pi.registerTool({ ...createChromeDevtoolsLoadTool(pi), defaultActive: false });
+    loaderRegistered.add(pi);
+  } else if (loaderRegistered.has(pi)) {
+    pi.registerTool({
+      ...createChromeDevtoolsLoadTool(pi),
+      exposure: "hidden",
+      promptSnippet: void 0,
+      promptGuidelines: void 0
+    });
+  }
+}
 var SEARCH_TEXT = {
   chrome_devtools_list_pages: "list open inspectable chrome browser pages tabs targets",
   chrome_devtools_select_page: "select choose active chrome browser page tab target",
@@ -42,44 +222,87 @@ var SEARCH_TEXT = {
   chrome_devtools_webmcp_list_tools: "list discover page provided website webmcp tools capabilities experimental",
   chrome_devtools_webmcp_call_tool: "call invoke page provided website webmcp tool confirmation experimental"
 };
-function setChromeDevtoolsSessionOwner(pi, owner) {
+function setChromeDevtoolsSessionOwner(pi, owner, entries) {
   sessionOwnerByApi.set(pi, owner);
+  if (entries) {
+    const ownership2 = restoredOwnership(entries);
+    if (ownership2) {
+      const pending = ownedBySession.get(owner);
+      if (pending && pending.serialized === void 0 && ownership2.serialized === JSON.stringify(ownershipData(pending)))
+        ownership2.serialized = void 0;
+      ownedBySession.set(owner, ownership2);
+    } else {
+      ownedBySession.delete(owner);
+      availableToolsByApi.delete(pi);
+      modeByApi.delete(pi);
+    }
+  }
+  const ownership = ownedBySession.get(owner);
+  if (ownership?.available) setAvailableTools(pi, [...ownership.available]);
+  if (ownership?.mode) modeByApi.set(pi, ownership.mode);
 }
 function initializeAvailableChromeDevtoolsTools(pi) {
   if (availableToolsByApi.has(pi)) return;
-  const activeTools = new Set(pi.getActiveTools());
-  setAvailableTools(
-    pi,
-    CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => activeTools.has(name))
-  );
+  setAvailableTools(pi, CHROME_DEVTOOLS_TOOL_NAMES);
 }
-function configureChromeDevtoolsToolExposure(pi, availableTools, model) {
+function configureChromeDevtoolsToolExposure(pi, availableTools, model, mode = "codemode") {
+  modeByApi.set(pi, mode);
   setAvailableTools(pi, availableTools);
   const available = effectiveAvailableTools(pi);
-  const lazyExposure = supportsNativeDeferredToolLoading(model);
+  const lazyExposure = mode === "lazy" && supportsNativeDeferredToolLoading(model);
   lazyExposureByApi.set(pi, lazyExposure);
-  const exposedTools = lazyExposure ? [] : CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
+  const before = pi.getActiveTools();
+  const owner = sessionOwnerByApi.get(pi);
+  let ownership = owner ? ownedBySession.get(owner) : void 0;
+  if (owner && !ownership && before.includes(CHROME_DEVTOOLS_LOAD_TOOL_NAME)) {
+    ownership = {
+      explicit: /* @__PURE__ */ new Set(),
+      owned: new Set(before.filter((name) => CHROME_DEVTOOLS_TOOL_NAMES.includes(name)))
+    };
+    ownedBySession.set(owner, ownership);
+  }
+  const owned = ownership?.owned;
+  const exposedTools = mode === "codemode" ? unique([...before.filter((name) => !owned?.has(name)), ...retainedExplicitTools(pi, before)]).filter(
+    (name) => available.has(name)
+  ) : lazyExposure ? [] : CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
   const nonCapabilityTools = pi.getActiveTools().filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name));
-  pi.setActiveTools(unique([...nonCapabilityTools, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...exposedTools]));
+  refreshExposure(pi);
+  const target = /* @__PURE__ */ new Set([
+    ...nonCapabilityTools.filter((name) => name !== CHROME_DEVTOOLS_LOAD_TOOL_NAME),
+    ...mode === "lazy" ? [CHROME_DEVTOOLS_LOAD_TOOL_NAME] : [],
+    ...exposedTools
+  ]);
+  return publishLifecycleTools(pi, unique([...before.filter((name) => target.has(name)), ...target]), before);
 }
 function requireEagerChromeDevtoolsToolExposure(pi) {
+  if (chromeDevtoolsToolMode(pi) !== "lazy") return;
   lazyExposureByApi.set(pi, false);
   const active = pi.getActiveTools();
   const available = availableChromeDevtoolsTools(pi);
-  pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...available]));
+  return publishLifecycleTools(pi, unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...available]), active);
 }
-function applyAvailableChromeDevtoolsTools(pi, availableTools) {
+function applyAvailableChromeDevtoolsTools(pi, availableTools, restoredActiveTools) {
   setAvailableTools(pi, availableTools);
   const available = effectiveAvailableTools(pi);
   const lazyExposure = lazyExposureByApi.get(pi) === true;
-  const active = pi.getActiveTools().filter(
+  const before = restoredActiveTools ? restoreCapabilityPositions(pi.getActiveTools(), restoredActiveTools, available) : pi.getActiveTools();
+  const active = before.filter(
     (name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name) || lazyExposure && available.has(name)
   );
-  const eagerTools = lazyExposure ? [] : CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
-  pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...eagerTools]));
+  const mode = chromeDevtoolsToolMode(pi);
+  const eagerTools = mode === "codemode" ? unique([...before, ...retainedExplicitTools(pi, before)]).filter(
+    (name) => available.has(name)
+  ) : lazyExposure ? [] : CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
+  refreshExposure(pi);
+  const target = /* @__PURE__ */ new Set([
+    ...active.filter((name) => name !== CHROME_DEVTOOLS_LOAD_TOOL_NAME),
+    ...mode === "lazy" ? [CHROME_DEVTOOLS_LOAD_TOOL_NAME] : [],
+    ...eagerTools
+  ]);
+  publishActiveTools(pi, unique([...before.filter((name) => target.has(name)), ...target]), before);
 }
 function chromeDevtoolsToolExposureMode(pi) {
-  return lazyExposureByApi.get(pi) === true ? "native deferred" : "eager";
+  return chromeDevtoolsToolMode(pi) === "codemode" ? "codemode" : lazyExposureByApi.get(pi) === true ? "native deferred" : "eager";
 }
 function supportsNativeDeferredToolLoading(model) {
   if (!model) return false;
@@ -106,6 +329,11 @@ function availableChromeDevtoolsTools(pi) {
   const available = effectiveAvailableTools(pi);
   return CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
 }
+function previousChromeDevtoolsTools(pi) {
+  if (availableToolsByApi.has(pi)) return configuredChromeDevtoolsTools(pi);
+  const active = new Set(pi.getActiveTools());
+  return CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => active.has(name));
+}
 function configuredChromeDevtoolsTools(pi) {
   const available = availableToolsByApi.get(pi) ?? /* @__PURE__ */ new Set();
   return CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
@@ -140,13 +368,23 @@ function createChromeDevtoolsLoadTool(pi) {
       const active = pi.getActiveTools();
       const activeSet = new Set(active);
       const added = matches.filter((name) => !activeSet.has(name));
-      if (added.length > 0) {
-        pi.setActiveTools(unique([...active, ...added]));
+      let provenanceWarning;
+      try {
+        if (added.length > 0) {
+          publishActiveTools(pi, unique([...active, ...added]), active);
+        } else {
+          const ownership = ownedBySession.get(ctx.sessionManager);
+          if (ownership && ownership.serialized === void 0) recordOwnership(pi, active);
+        }
+      } catch (error) {
+        if (!(error instanceof ActivationProvenanceError)) throw error;
+        provenanceWarning = formatProvenanceWarning(error);
       }
       const text = matches.length === 0 ? "No available Chrome DevTools tools matched the query." : added.length > 0 ? `Loaded Chrome DevTools tools: ${added.join(", ")}` : `Matching Chrome DevTools tools are already loaded: ${matches.join(", ")}`;
       return {
-        content: [{ type: "text", text }],
-        details: { matches, added }
+        content: [{ type: "text", text: provenanceWarning ? `${text}
+Warning: ${provenanceWarning}` : text }],
+        details: { matches, added, ...provenanceWarning ? { provenanceWarning } : {} }
       };
     }
   });
@@ -183,44 +421,21 @@ function compatString(value, key) {
   const record = value;
   return typeof record[key] === "string" ? record[key] : void 0;
 }
+function restoreCapabilityPositions(current, previous, available) {
+  const restored = [...current];
+  for (const [index, name] of previous.entries()) {
+    if (!available.has(name) || restored.includes(name)) continue;
+    const following = previous.slice(index + 1).find((candidate) => restored.includes(candidate));
+    const insertion = following === void 0 ? restored.length : restored.indexOf(following);
+    restored.splice(insertion, 0, name);
+  }
+  return restored;
+}
 function unique(values) {
   return [...new Set(values)];
 }
 
-// src/display.ts
-var MAX_SANITIZER_INPUT_CODE_UNITS = 5e4;
-var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function sanitizeChromeDevtoolsDisplay(value, maxCharacters = 5e4) {
-  const inputWasTruncated = value.length > MAX_SANITIZER_INPUT_CODE_UNITS;
-  const boundedInput = inputWasTruncated ? truncateAtGraphemeBoundary(value, MAX_SANITIZER_INPUT_CODE_UNITS) : value;
-  const normalizedLineEndings = boundedInput.replace(/\r\n/g, "\n");
-  const sanitized = Array.from(normalizedLineEndings, (character) => {
-    const codePoint = character.codePointAt(0) ?? 0;
-    const unsafeControl = codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
-    const unsafeBidi = codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297;
-    const loneSurrogate = character.length === 1 && codePoint >= 55296 && codePoint <= 57343;
-    return unsafeControl || unsafeBidi || loneSurrogate ? "\uFFFD" : character;
-  }).join("");
-  const outputLimit = Math.min(maxCharacters, MAX_SANITIZER_INPUT_CODE_UNITS);
-  if (!inputWasTruncated && sanitized.length <= outputLimit) return sanitized;
-  return `${truncateAtGraphemeBoundary(sanitized, Math.max(0, outputLimit - 1))}\u2026`;
-}
-function truncateAtGraphemeBoundary(value, maxCodeUnits) {
-  if (value.length <= maxCodeUnits) return value;
-  const boundedLookahead = value.slice(0, Math.max(0, maxCodeUnits) + 2);
-  let safeEnd = 0;
-  for (const { index, segment } of graphemeSegmenter.segment(boundedLookahead)) {
-    const segmentEnd = index + segment.length;
-    if (segmentEnd > maxCodeUnits) break;
-    safeEnd = segmentEnd;
-  }
-  return value.slice(0, safeEnd);
-}
-
 // src/tool-selector.ts
-function unique2(values) {
-  return Array.from(new Set(values));
-}
 function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -242,8 +457,10 @@ async function waitForChromeDevtoolsSettings() {
   await toolTransactionQueue;
 }
 function transactSelectedTools(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools) {
+  const acceptedTools = [...selectedTools];
+  const expectedTools = expectedActiveTools ? [...expectedActiveTools] : void 0;
   const operation = toolTransactionQueue.then(
-    () => transactSelectedToolsNow(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools)
+    () => transactSelectedToolsNow(pi, ctx, acceptedTools, expectedGeneration, expectedTools)
   );
   toolTransactionQueue = operation.then(
     () => void 0,
@@ -252,7 +469,25 @@ function transactSelectedTools(pi, ctx, selectedTools, expectedGeneration, expec
   return operation;
 }
 async function transactSelectedToolsNow(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools) {
-  if (expectedGeneration !== state.sessionGeneration) return "failed";
+  if (expectedGeneration !== state.sessionGeneration) {
+    try {
+      if (expectedActiveTools) {
+        const settings = await loadSettings();
+        if (settings.userFile.kind !== "invalid") {
+          const catalog = new Set(
+            settings.kind === "loaded" && settings.settings.tools ? settings.settings.tools : CHROME_DEVTOOLS_TOOL_NAMES
+          );
+          const current = CHROME_DEVTOOLS_TOOL_NAMES.filter(
+            (name) => catalog.has(name) && (settings.effectiveWebMcpEnabled || !isWebMcpToolName(name))
+          );
+          if (!arraysEqual(current, expectedActiveTools)) return "active-tools-changed";
+        }
+      }
+      await persistSettings(selectedTools);
+    } catch {
+    }
+    return "failed";
+  }
   if (expectedActiveTools && !arraysEqual(availableChromeDevtoolsTools(pi), expectedActiveTools)) {
     ctx.ui.notify(
       "Browser tool selection changed while review was open. Review the current state, then apply again.",
@@ -260,34 +495,38 @@ async function transactSelectedToolsNow(pi, ctx, selectedTools, expectedGenerati
     );
     return "active-tools-changed";
   }
-  const previousActiveTools = pi.getActiveTools();
-  const previousAvailableTools = availableChromeDevtoolsTools(pi);
   try {
-    const previousWebMcpTools = previousAvailableTools.filter(isWebMcpToolName);
-    const selectedWebMcpTools = selectedTools.filter(isWebMcpToolName);
-    if (!arraysEqual(previousWebMcpTools, selectedWebMcpTools)) {
-      invalidateWebMcpOperations(ctx.sessionManager, "Chrome DevTools WebMCP gateway availability changed");
-    }
-    applyChromeDevtoolsTools(pi, selectedTools);
-    await persistSettings(selectedTools);
+    await persistSettings(selectedTools, () => {
+      if (expectedGeneration !== state.sessionGeneration) return;
+      const previousActiveTools = pi.getActiveTools();
+      const previousAvailableTools = availableChromeDevtoolsTools(pi);
+      const previousConfiguredTools = configuredChromeDevtoolsTools(pi);
+      try {
+        const previousWebMcpTools = previousAvailableTools.filter(isWebMcpToolName);
+        applyChromeDevtoolsTools(pi, selectedTools);
+        const publishedWebMcpTools = availableChromeDevtoolsTools(pi).filter(isWebMcpToolName);
+        if (!arraysEqual(previousWebMcpTools, publishedWebMcpTools)) {
+          invalidateWebMcpOperations(ctx.sessionManager, "Chrome DevTools WebMCP gateway availability changed");
+        }
+      } catch (error) {
+        if (expectedGeneration === state.sessionGeneration) {
+          try {
+            applyAvailableChromeDevtoolsTools(pi, previousConfiguredTools, previousActiveTools);
+          } catch (rollbackError) {
+            throw new Error(`${formatError(error)}; active-tool rollback failed: ${formatError(rollbackError)}`, {
+              cause: error
+            });
+          }
+        }
+        throw error;
+      }
+    });
     return expectedGeneration === state.sessionGeneration ? "saved" : "failed";
   } catch (error) {
-    let rollbackError;
-    try {
-      applyAvailableChromeDevtoolsTools(pi, previousAvailableTools);
-      const currentNonChromeTools = pi.getActiveTools().filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name));
-      const previousLoadedChromeTools = previousActiveTools.filter(
-        (name) => CHROME_DEVTOOLS_TOOL_NAMES.includes(name)
-      );
-      const restoredChromeTools = chromeDevtoolsToolExposureMode(pi) === "eager" ? previousAvailableTools : previousLoadedChromeTools;
-      pi.setActiveTools(unique2([...currentNonChromeTools, ...restoredChromeTools]));
-    } catch (caught) {
-      rollbackError = caught;
-    }
     if (expectedGeneration !== state.sessionGeneration) return "failed";
     ctx.ui.notify(
       sanitizeChromeDevtoolsDisplay(
-        rollbackError ? `Chrome DevTools settings save failed: ${formatError(error)}; active-tool rollback failed: ${formatError(rollbackError)}` : `Chrome DevTools settings save failed; active tools restored: ${formatError(error)}`
+        error instanceof ToolCatalogApplicationError ? `Chrome DevTools tool application failed: ${formatError(error)}` : `Chrome DevTools settings save failed; active tools unchanged: ${formatError(error)}`
       ),
       "warning"
     );
@@ -319,12 +558,21 @@ function getToolStatusSummary(pi, owner) {
   };
 }
 async function buildToolStatusMessage(pi, owner) {
+  const generation = state.sessionGeneration;
+  await waitForChromeDevtoolsSettings();
+  if (generation !== state.sessionGeneration) return "";
+  const settings = await loadSettings();
+  if (generation !== state.sessionGeneration) return "";
   const summary = getToolStatusSummary(pi, owner);
-  const persistedSetting = await persistedSettingLabel();
+  const persistedSetting = persistedSettingLabel(settings);
+  const savedMode = settings.userFile.kind === "invalid" ? void 0 : settings.kind === "loaded" ? settings.settings.toolMode : "codemode";
   return sanitizeChromeDevtoolsDisplay(
     [
       `Chrome DevTools tools available: ${formatRuntimeStatus(summary)}`,
+      `Running tool mode: ${chromeDevtoolsToolMode(pi)}`,
       `Tool exposure: ${chromeDevtoolsToolExposureMode(pi)}`,
+      `Saved tool mode: ${savedMode ?? "unavailable (invalid user settings)"}`,
+      ...savedMode !== void 0 && savedMode !== chromeDevtoolsToolMode(pi) ? ["Tool mode change pending; /reload or session replacement required."] : [],
       `Loaded capability tools this session: ${summary.loadedChromeToolCount}/${summary.capabilityCount}`,
       `WebMCP: ${webMcpEnabled(owner) ? "enabled \xB7 experimental \xB7 confirmation required for every call" : "disabled \xB7 experimental"}`,
       `Loader: ${pi.getActiveTools().includes(CHROME_DEVTOOLS_LOAD_TOOL_NAME) ? "active" : "inactive"}`,
@@ -417,15 +665,14 @@ function allChromeDevtoolsTools(owner) {
 function formatRuntimeStatus(summary) {
   return `${summary.availabilityStatus} (${summary.availableChromeToolCount}/${summary.capabilityCount} available)`;
 }
-async function persistedSettingLabel() {
-  const settings = await loadSettings();
+function persistedSettingLabel(settings) {
   if (settings.kind === "loaded" && settings.settings.tools) {
     return formatPersistedSelection(settings.settings.tools);
   }
   if (settings.kind === "invalid") {
     return `none; current active-tool policy preserved (invalid settings ignored: ${settings.reason})`;
   }
-  return "none; current active-tool policy preserved";
+  return "none; default catalog restored on /reload or session replacement";
 }
 function formatPersistedSelection(tools) {
   if (tools.length === CHROME_DEVTOOLS_TOOL_NAMES.length) {
@@ -437,11 +684,14 @@ function formatPersistedSelection(tools) {
 function effectiveCatalog(owner) {
   return webMcpEnabled(owner) ? [...CHROME_DEVTOOLS_TOOL_NAMES] : [...CORE_CHROME_DEVTOOLS_TOOL_NAMES];
 }
-async function persistSettings(selectedTools) {
-  await saveSettings({ tools: [...selectedTools], updatedAt: Date.now() });
+async function persistSettings(selectedTools, applyAfterSave) {
+  await saveSettings({ tools: [...selectedTools], updatedAt: Date.now() }, {}, applyAfterSave);
 }
 
 export {
+  sanitizeChromeDevtoolsDisplay,
+  registerChromeDevtoolsCapabilities,
+  chromeDevtoolsToolMode,
   setChromeDevtoolsSessionOwner,
   initializeAvailableChromeDevtoolsTools,
   configureChromeDevtoolsToolExposure,
@@ -449,9 +699,8 @@ export {
   applyAvailableChromeDevtoolsTools,
   supportsNativeDeferredToolLoading,
   availableChromeDevtoolsTools,
+  previousChromeDevtoolsTools,
   configuredChromeDevtoolsTools,
-  createChromeDevtoolsLoadTool,
-  sanitizeChromeDevtoolsDisplay,
   updateChromeDevtoolsTools,
   setSelectedChromeDevtoolsTools,
   waitForChromeDevtoolsSettings,
@@ -461,4 +710,4 @@ export {
   buildCommandGuide,
   allChromeDevtoolsTools
 };
-//# sourceMappingURL=chunk-V7N3WI5B.ts.map
+//# sourceMappingURL=chunk-WOFI2A72.ts.map