opensteer 0.9.0 → 0.9.1

package/dist/cli/bin.cjs

@@ -4,11 +4,12 @@
 var child_process = require('child_process');
 var promises = require('fs/promises');
 var util = require('util');
-var path7 = require('path');
+var path10 = require('path');
 var fs = require('fs');
 var os = require('os');
 var crypto = require('crypto');
 var url = require('url');
+var module$1 = require('module');
 var enginePlaywright = require('@opensteer/engine-playwright');
 var zlib = require('zlib');
 var cssSelect = require('css-select');
@@ -17,9 +18,10 @@ var cheerio = require('cheerio');
 var prettier = require('prettier');
 var vm = require('vm');
 var async_hooks = require('async_hooks');
-var WebSocket2 = require('ws');
+var WebSocket4 = require('ws');
 var process4 = require('process');
-var module$1 = require('module');
+var http = require('http');
+var events = require('events');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -42,13 +44,13 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path7__default = /*#__PURE__*/_interopDefault(path7);
+var path10__default = /*#__PURE__*/_interopDefault(path10);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var sharp__default = /*#__PURE__*/_interopDefault(sharp);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
 var prettier__namespace = /*#__PURE__*/_interopNamespace(prettier);
 var vm__default = /*#__PURE__*/_interopDefault(vm);
-var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
+var WebSocket4__namespace = /*#__PURE__*/_interopNamespace(WebSocket4);
 var process4__default = /*#__PURE__*/_interopDefault(process4);
 
 var __defProp = Object.defineProperty;
@@ -66,6 +68,40 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+function parseProcessOwner(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const parsed = value;
+  const pid = Number(parsed.pid);
+  const processStartedAtMs = Number(parsed.processStartedAtMs);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  if (!Number.isInteger(processStartedAtMs) || processStartedAtMs <= 0) {
+    return null;
+  }
+  return {
+    pid,
+    processStartedAtMs
+  };
+}
+function processOwnersEqual(left, right) {
+  if (!left || !right) {
+    return left === right;
+  }
+  return left.pid === right.pid && left.processStartedAtMs === right.processStartedAtMs;
+}
+async function getProcessLiveness(owner) {
+  if (owner.pid === process.pid && hasMatchingProcessStartTime(owner.processStartedAtMs, PROCESS_STARTED_AT_MS)) {
+    return "live";
+  }
+  const startedAtMs = await readProcessStartedAtMs(owner.pid);
+  if (typeof startedAtMs === "number") {
+    return hasMatchingProcessStartTime(owner.processStartedAtMs, startedAtMs) ? "live" : "dead";
+  }
+  return isProcessRunning(owner.pid) ? "unknown" : "dead";
+}
 function isProcessRunning(pid) {
   try {
     process.kill(pid, 0);
@@ -75,22 +111,136 @@ function isProcessRunning(pid) {
     return code !== "ESRCH";
   }
 }
-var PROCESS_STARTED_AT_MS;
+function hasMatchingProcessStartTime(expectedStartedAtMs, actualStartedAtMs) {
+  return Math.abs(expectedStartedAtMs - actualStartedAtMs) <= PROCESS_START_TIME_TOLERANCE_MS;
+}
+async function readProcessStartedAtMs(pid) {
+  if (pid <= 0) {
+    return null;
+  }
+  if (process.platform === "linux") {
+    return readLinuxProcessStartedAtMs(pid);
+  }
+  if (process.platform === "win32") {
+    return readWindowsProcessStartedAtMs(pid);
+  }
+  return readPsProcessStartedAtMs(pid);
+}
+async function readLinuxProcessStartedAtMs(pid) {
+  let statRaw;
+  try {
+    statRaw = await promises.readFile(`/proc/${String(pid)}/stat`, "utf8");
+  } catch {
+    return null;
+  }
+  const startTicks = parseLinuxProcessStartTicks(statRaw);
+  if (startTicks === null) {
+    return null;
+  }
+  const [bootTimeMs, clockTicksPerSecond] = await Promise.all([
+    readLinuxBootTimeMs(),
+    readLinuxClockTicksPerSecond()
+  ]);
+  if (bootTimeMs === null || clockTicksPerSecond === null) {
+    return null;
+  }
+  return Math.floor(bootTimeMs + startTicks * 1e3 / clockTicksPerSecond);
+}
+function parseLinuxProcessStartTicks(statRaw) {
+  const closingParenIndex = statRaw.lastIndexOf(")");
+  if (closingParenIndex === -1) {
+    return null;
+  }
+  const fields = statRaw.slice(closingParenIndex + 2).trim().split(/\s+/);
+  const startTicks = Number(fields[LINUX_STAT_START_TIME_FIELD_INDEX]);
+  return Number.isFinite(startTicks) && startTicks >= 0 ? startTicks : null;
+}
+async function readLinuxBootTimeMs() {
+  try {
+    const statRaw = await promises.readFile("/proc/stat", "utf8");
+    const bootTimeLine = statRaw.split("\n").find((line) => line.startsWith("btime "));
+    if (!bootTimeLine) {
+      return null;
+    }
+    const bootTimeSeconds = Number.parseInt(bootTimeLine.slice("btime ".length), 10);
+    return Number.isFinite(bootTimeSeconds) ? bootTimeSeconds * 1e3 : null;
+  } catch {
+    return null;
+  }
+}
+async function readLinuxClockTicksPerSecond() {
+  if (!linuxClockTicksPerSecondPromise) {
+    linuxClockTicksPerSecondPromise = execFileAsync("getconf", ["CLK_TCK"], {
+      encoding: "utf8",
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    }).then(({ stdout }) => {
+      const value = Number.parseInt(stdout.trim(), 10);
+      return Number.isFinite(value) && value > 0 ? value : null;
+    }).catch(() => null);
+  }
+  return linuxClockTicksPerSecondPromise;
+}
+async function readWindowsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-Command",
+        `(Get-Process -Id ${String(pid)}).StartTime.ToUniversalTime().ToString("o")`
+      ],
+      {
+        encoding: "utf8",
+        maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+      }
+    );
+    const isoTimestamp = stdout.trim();
+    if (!isoTimestamp) {
+      return null;
+    }
+    const startedAtMs = Date.parse(isoTimestamp);
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+async function readPsProcessStartedAtMs(pid) {
+  try {
+    const { stdout } = await execFileAsync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      env: PS_COMMAND_ENV,
+      maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES
+    });
+    const startedAt = stdout.trim();
+    if (!startedAt) {
+      return null;
+    }
+    const startedAtMs = Date.parse(startedAt.replace(/\s+/g, " "));
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+var execFileAsync, PROCESS_STARTED_AT_MS, PROCESS_START_TIME_TOLERANCE_MS, PROCESS_LIST_MAX_BUFFER_BYTES, PS_COMMAND_ENV, LINUX_STAT_START_TIME_FIELD_INDEX, CURRENT_PROCESS_OWNER, linuxClockTicksPerSecondPromise;
 var init_process_owner = __esm({
   "src/local-browser/process-owner.ts"() {
-    util.promisify(child_process.execFile);
+    execFileAsync = util.promisify(child_process.execFile);
     PROCESS_STARTED_AT_MS = Math.floor(Date.now() - process.uptime() * 1e3);
-    ({ ...process.env, LC_ALL: "C" });
-    ({
+    PROCESS_START_TIME_TOLERANCE_MS = 1e3;
+    PROCESS_LIST_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+    PS_COMMAND_ENV = { ...process.env, LC_ALL: "C" };
+    LINUX_STAT_START_TIME_FIELD_INDEX = 19;
+    CURRENT_PROCESS_OWNER = {
       pid: process.pid,
       processStartedAtMs: PROCESS_STARTED_AT_MS
-    });
+    };
+    linuxClockTicksPerSecondPromise = null;
   }
 });
 async function clearChromeSingletonEntries(userDataDir) {
   await Promise.all(
     CHROME_SINGLETON_ARTIFACTS.map(
-      (entry) => promises.rm(path7.join(userDataDir, entry), {
+      (entry) => promises.rm(path10.join(userDataDir, entry), {
         recursive: true,
         force: true
       }).catch(() => void 0)
@@ -105,7 +255,7 @@ async function sanitizeChromeProfile(userDataDir) {
   await Promise.all(profileDirs.map((dir) => sanitizeProfilePreferences(userDataDir, dir)));
 }
 async function sanitizeProfilePreferences(userDataDir, profileDir) {
-  const prefsPath = path7.join(userDataDir, profileDir, "Preferences");
+  const prefsPath = path10.join(userDataDir, profileDir, "Preferences");
   try {
     const raw = await promises.readFile(prefsPath, "utf8");
     const prefs = JSON.parse(raw);
@@ -117,7 +267,7 @@ async function sanitizeProfilePreferences(userDataDir, profileDir) {
     profile.exited_cleanly = true;
     prefs.profile = profile;
     await promises.writeFile(prefsPath, JSON.stringify(prefs), "utf8");
-    await promises.rm(path7.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
+    await promises.rm(path10.join(userDataDir, profileDir, "Secure Preferences"), { force: true }).catch(
       () => void 0
     );
   } catch {
@@ -172,23 +322,23 @@ function detectInstalledBrowserBrands() {
       brandId: brand2.id,
       displayName: brand2.displayName,
       executablePath,
-      userDataDir: path7.resolve(expandHome(platformConfig.userDataDir))
+      userDataDir: path10.resolve(expandHome(platformConfig.userDataDir))
     });
   }
   return installations;
 }
 function resolveBrandUserDataDir(brand2, explicitDir) {
   if (explicitDir !== void 0) {
-    return path7.resolve(expandHome(explicitDir));
+    return path10.resolve(expandHome(explicitDir));
   }
   const platformConfig = resolveBrandPlatformConfig(brand2);
   if (!platformConfig) {
     throw new Error(`${brand2.displayName} is not supported on ${process.platform}.`);
   }
-  return path7.resolve(expandHome(platformConfig.userDataDir));
+  return path10.resolve(expandHome(platformConfig.userDataDir));
 }
 function resolveExecutableCandidates(candidates) {
-  return candidates.map((candidate) => candidate ? path7.resolve(expandHome(candidate)) : null);
+  return candidates.map((candidate) => candidate ? path10.resolve(expandHome(candidate)) : null);
 }
 var WINDOWS_PROGRAM_FILES, WINDOWS_PROGRAM_FILES_X86, BROWSER_BRANDS;
 var init_browser_brands = __esm({
@@ -209,9 +359,9 @@ var init_browser_brands = __esm({
         },
         win32: {
           executableCandidates: [
-            path7.join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
-            path7.join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
-            path7.join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
+            path10.join(WINDOWS_PROGRAM_FILES, "Google", "Chrome", "Application", "chrome.exe"),
+            path10.join(WINDOWS_PROGRAM_FILES_X86, "Google", "Chrome", "Application", "chrome.exe"),
+            path10.join("~", "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe")
           ],
           userDataDir: "~/AppData/Local/Google/Chrome/User Data",
           processNames: ["/google/chrome/application/chrome.exe"]
@@ -241,7 +391,7 @@ var init_browser_brands = __esm({
         },
         win32: {
           executableCandidates: [
-            path7.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
+            path10.join("~", "AppData", "Local", "Google", "Chrome SxS", "Application", "chrome.exe")
           ],
           userDataDir: "~/AppData/Local/Google/Chrome SxS/User Data",
           processNames: ["/google/chrome sxs/application/chrome.exe"]
@@ -258,9 +408,9 @@ var init_browser_brands = __esm({
         },
         win32: {
           executableCandidates: [
-            path7.join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
-            path7.join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
-            path7.join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
+            path10.join(WINDOWS_PROGRAM_FILES, "Chromium", "Application", "chrome.exe"),
+            path10.join(WINDOWS_PROGRAM_FILES_X86, "Chromium", "Application", "chrome.exe"),
+            path10.join("~", "AppData", "Local", "Chromium", "Application", "chrome.exe")
           ],
           userDataDir: "~/AppData/Local/Chromium/User Data",
           processNames: ["/chromium/application/chrome.exe"]
@@ -287,15 +437,15 @@ var init_browser_brands = __esm({
         },
         win32: {
           executableCandidates: [
-            path7.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
-            path7.join(
+            path10.join(WINDOWS_PROGRAM_FILES, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+            path10.join(
               WINDOWS_PROGRAM_FILES_X86,
               "BraveSoftware",
               "Brave-Browser",
               "Application",
               "brave.exe"
             ),
-            path7.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
+            path10.join("~", "AppData", "Local", "BraveSoftware", "Brave-Browser", "Application", "brave.exe")
           ],
           userDataDir: "~/AppData/Local/BraveSoftware/Brave-Browser/User Data",
           processNames: ["/bravesoftware/brave-browser/application/brave.exe"]
@@ -321,9 +471,9 @@ var init_browser_brands = __esm({
         },
         win32: {
           executableCandidates: [
-            path7.join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
-            path7.join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
-            path7.join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
+            path10.join(WINDOWS_PROGRAM_FILES, "Microsoft", "Edge", "Application", "msedge.exe"),
+            path10.join(WINDOWS_PROGRAM_FILES_X86, "Microsoft", "Edge", "Application", "msedge.exe"),
+            path10.join("~", "AppData", "Local", "Microsoft", "Edge", "Application", "msedge.exe")
           ],
           userDataDir: "~/AppData/Local/Microsoft/Edge/User Data",
           processNames: ["/microsoft/edge/application/msedge.exe"]
@@ -351,9 +501,9 @@ var init_browser_brands = __esm({
         },
         win32: {
           executableCandidates: [
-            path7.join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
-            path7.join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
-            path7.join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
+            path10.join(WINDOWS_PROGRAM_FILES, "Vivaldi", "Application", "vivaldi.exe"),
+            path10.join(WINDOWS_PROGRAM_FILES_X86, "Vivaldi", "Application", "vivaldi.exe"),
+            path10.join("~", "AppData", "Local", "Vivaldi", "Application", "vivaldi.exe")
           ],
           userDataDir: "~/AppData/Local/Vivaldi/User Data",
           processNames: ["/vivaldi/application/vivaldi.exe"]
@@ -384,13 +534,13 @@ var init_browser_brands = __esm({
 });
 function expandHome(value) {
   if (value === "~" || value.startsWith("~/")) {
-    return path7.join(os.homedir(), value.slice(1));
+    return path10.join(os.homedir(), value.slice(1));
   }
   return value;
 }
 function resolveChromeExecutablePath(executablePath) {
   if (executablePath !== void 0) {
-    const resolvedPath = path7.resolve(expandHome(executablePath));
+    const resolvedPath = path10.resolve(expandHome(executablePath));
     if (!fs.existsSync(resolvedPath)) {
       throw new Error(`Chrome executable was not found at "${resolvedPath}".`);
     }
@@ -414,37 +564,37 @@ function detectLocalChromeInstallations() {
           "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
           "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
         ]),
-        userDataDir: path7.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
+        userDataDir: path10.join(os.homedir(), "Library", "Application Support", "Google", "Chrome")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath(["/Applications/Chromium.app/Contents/MacOS/Chromium"]),
-        userDataDir: path7.join(os.homedir(), "Library", "Application Support", "Chromium")
+        userDataDir: path10.join(os.homedir(), "Library", "Application Support", "Chromium")
       }
     ];
   }
   if (process.platform === "win32") {
     const programFiles = process.env.PROGRAMFILES ?? "C:\\Program Files";
     const programFilesX86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
-    const localAppData = process.env.LOCALAPPDATA ?? path7.join(os.homedir(), "AppData", "Local");
+    const localAppData = process.env.LOCALAPPDATA ?? path10.join(os.homedir(), "AppData", "Local");
     return [
       {
         brand: "chrome",
         executablePath: firstExistingPath([
-          path7.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
-          path7.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
-          path7.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
+          path10.join(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
+          path10.join(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
+          path10.join(localAppData, "Google", "Chrome", "Application", "chrome.exe")
         ]),
-        userDataDir: path7.join(localAppData, "Google", "Chrome", "User Data")
+        userDataDir: path10.join(localAppData, "Google", "Chrome", "User Data")
       },
       {
         brand: "chromium",
         executablePath: firstExistingPath([
-          path7.join(programFiles, "Chromium", "Application", "chrome.exe"),
-          path7.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
-          path7.join(localAppData, "Chromium", "Application", "chrome.exe")
+          path10.join(programFiles, "Chromium", "Application", "chrome.exe"),
+          path10.join(programFilesX86, "Chromium", "Application", "chrome.exe"),
+          path10.join(localAppData, "Chromium", "Application", "chrome.exe")
         ]),
-        userDataDir: path7.join(localAppData, "Chromium", "User Data")
+        userDataDir: path10.join(localAppData, "Chromium", "User Data")
       }
     ];
   }
@@ -457,7 +607,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("google-chrome"),
         resolveBinaryFromPath("google-chrome-stable")
       ]),
-      userDataDir: path7.join(os.homedir(), ".config", "google-chrome")
+      userDataDir: path10.join(os.homedir(), ".config", "google-chrome")
     },
     {
       brand: "chromium",
@@ -467,7 +617,7 @@ function detectLocalChromeInstallations() {
         resolveBinaryFromPath("chromium"),
         resolveBinaryFromPath("chromium-browser")
       ]),
-      userDataDir: path7.join(os.homedir(), ".config", "chromium")
+      userDataDir: path10.join(os.homedir(), ".config", "chromium")
     }
   ];
 }
@@ -479,7 +629,7 @@ function detectLocalBrowserInstallations() {
   }));
 }
 function readDevToolsActivePort(userDataDir) {
-  const devToolsPath = path7.join(userDataDir, "DevToolsActivePort");
+  const devToolsPath = path10.join(userDataDir, "DevToolsActivePort");
   if (!fs.existsSync(devToolsPath)) {
     return null;
   }
@@ -705,8 +855,8 @@ function buildBrowserWebSocketUrl(httpUrl, webSocketPath) {
   const protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
   return `${protocol}//${httpUrl.host}${normalizeWebSocketPath(webSocketPath)}`;
 }
-function normalizeWebSocketPath(path18) {
-  return path18.startsWith("/") ? path18 : `/${path18}`;
+function normalizeWebSocketPath(path24) {
+  return path24.startsWith("/") ? path24 : `/${path24}`;
 }
 function rewriteBrowserWebSocketHost(browserWsUrl, requestedUrl) {
   try {
@@ -742,20 +892,20 @@ var init_cdp_discovery = __esm({
   }
 });
 async function createBrowserProfileSnapshot(input) {
-  const sourceUserDataDir = path7.resolve(expandHome(input.sourceUserDataDir));
-  const targetUserDataDir = path7.resolve(expandHome(input.targetUserDataDir));
+  const sourceUserDataDir = path10.resolve(expandHome(input.sourceUserDataDir));
+  const targetUserDataDir = path10.resolve(expandHome(input.targetUserDataDir));
   const profileDirectory = input.profileDirectory?.trim();
   const copyMode = input.copyMode;
   await promises.mkdir(targetUserDataDir, { recursive: true });
   await clearChromeSingletonEntries(targetUserDataDir);
   if (profileDirectory) {
-    const sourceProfileDir = path7.join(sourceUserDataDir, profileDirectory);
+    const sourceProfileDir = path10.join(sourceUserDataDir, profileDirectory);
     if (!fs.existsSync(sourceProfileDir)) {
       throw new Error(
         `Chrome profile "${profileDirectory}" was not found in "${sourceUserDataDir}".`
       );
     }
-    await promises.cp(sourceProfileDir, path7.join(targetUserDataDir, profileDirectory), {
+    await promises.cp(sourceProfileDir, path10.join(targetUserDataDir, profileDirectory), {
       recursive: true,
       filter: (candidate) => shouldCopyEntry({
         candidatePath: candidate,
@@ -779,8 +929,8 @@ async function copyRootLevelEntries(input) {
     if (CHROME_SINGLETON_ENTRIES.has(entry) || entry === input.selectedProfileDirectory) {
       continue;
     }
-    const sourcePath = path7.join(input.sourceUserDataDir, entry);
-    const targetPath = path7.join(input.targetUserDataDir, entry);
+    const sourcePath = path10.join(input.sourceUserDataDir, entry);
+    const targetPath = path10.join(input.targetUserDataDir, entry);
     const entryStat = await promises.stat(sourcePath).catch(() => null);
     if (!entryStat) {
       continue;
@@ -812,7 +962,7 @@ async function copyRootLevelEntries(input) {
   }
 }
 function isProfileDirectory(userDataDir, entry) {
-  return fs.existsSync(path7.join(userDataDir, entry, "Preferences"));
+  return fs.existsSync(path10.join(userDataDir, entry, "Preferences"));
 }
 function shouldCopyEntry(input) {
   const entryName = input.candidatePath.split("/").at(-1)?.split("\\").at(-1) ?? input.candidatePath;
@@ -822,7 +972,7 @@ function shouldCopyEntry(input) {
   if (input.copyMode !== "session") {
     return true;
   }
-  const relativePath = path7.relative(input.rootPath, input.candidatePath);
+  const relativePath = path10.relative(input.rootPath, input.candidatePath);
   if (relativePath.length === 0) {
     return true;
   }
@@ -1360,30 +1510,30 @@ function isPlainObject(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function canonicalizeJsonValue(value, path18) {
+function canonicalizeJsonValue(value, path24) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
   }
   if (typeof value === "number") {
     if (!Number.isFinite(value)) {
-      throw new TypeError(`${path18} must be a finite JSON number`);
+      throw new TypeError(`${path24} must be a finite JSON number`);
     }
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path18}[${index}]`));
+    return value.map((entry, index) => canonicalizeJsonValue(entry, `${path24}[${index}]`));
   }
   if (!isPlainObject(value)) {
-    throw new TypeError(`${path18} must be a plain JSON object`);
+    throw new TypeError(`${path24} must be a plain JSON object`);
   }
   const sorted = Object.keys(value).sort((left, right) => left.localeCompare(right));
   const result = {};
   for (const key of sorted) {
     const entry = value[key];
     if (entry === void 0) {
-      throw new TypeError(`${path18}.${key} must not be undefined`);
+      throw new TypeError(`${path24}.${key} must not be undefined`);
     }
-    result[key] = canonicalizeJsonValue(entry, `${path18}.${key}`);
+    result[key] = canonicalizeJsonValue(entry, `${path24}.${key}`);
   }
   return result;
 }
@@ -1421,7 +1571,7 @@ function joinStoragePath(...segments) {
   return segments.join("/");
 }
 function resolveStoragePath(rootPath, relativePath) {
-  if (path7__default.default.isAbsolute(relativePath)) {
+  if (path10__default.default.isAbsolute(relativePath)) {
     throw new TypeError(`storage path ${relativePath} must be relative`);
   }
   const segments = relativePath.split("/");
@@ -1433,7 +1583,7 @@ function resolveStoragePath(rootPath, relativePath) {
       throw new TypeError(`storage path ${relativePath} must not contain path traversal`);
     }
   }
-  return path7__default.default.join(rootPath, ...segments);
+  return path10__default.default.join(rootPath, ...segments);
 }
 async function ensureDirectory(directoryPath) {
   await promises.mkdir(directoryPath, { recursive: true });
@@ -1453,7 +1603,7 @@ async function writeJsonFileAtomic(filePath, value) {
   await writeTextFileAtomic(filePath, stableJsonString(value));
 }
 async function writeTextFileAtomic(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   const temporaryPath = `${filePath}.${crypto.randomUUID()}.tmp`;
   await promises.writeFile(temporaryPath, value, "utf8");
   await promises.rename(temporaryPath, filePath);
@@ -1462,7 +1612,7 @@ async function writeJsonFileExclusive(filePath, value) {
   await writeTextFileExclusive(filePath, stableJsonString(value));
 }
 async function writeTextFileExclusive(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   const handle = await promises.open(filePath, "wx");
   try {
     await handle.writeFile(value, "utf8");
@@ -1471,7 +1621,7 @@ async function writeTextFileExclusive(filePath, value) {
   }
 }
 async function writeBufferIfMissing(filePath, value) {
-  await ensureDirectory(path7__default.default.dirname(filePath));
+  await ensureDirectory(path10__default.default.dirname(filePath));
   try {
     const handle = await promises.open(filePath, "wx");
     try {
@@ -1505,7 +1655,7 @@ function isAlreadyExistsError(error) {
   return error?.code === "EEXIST";
 }
 async function withFilesystemLock(lockPath, task) {
-  await ensureDirectory(path7__default.default.dirname(lockPath));
+  await ensureDirectory(path10__default.default.dirname(lockPath));
   let attempt = 0;
   while (true) {
     try {
@@ -1594,8 +1744,8 @@ var init_artifacts = __esm({
     FilesystemArtifactStore = class {
       constructor(rootPath) {
         this.rootPath = rootPath;
-        this.manifestsDirectory = path7__default.default.join(this.rootPath, "artifacts", "manifests");
-        this.objectsDirectory = path7__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
+        this.manifestsDirectory = path10__default.default.join(this.rootPath, "artifacts", "manifests");
+        this.objectsDirectory = path10__default.default.join(this.rootPath, "artifacts", "objects", "sha256");
       }
       manifestsDirectory;
       objectsDirectory;
@@ -1820,7 +1970,7 @@ var init_artifacts = __esm({
         }
       }
       manifestPath(artifactId) {
-        return path7__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
+        return path10__default.default.join(this.manifestsDirectory, `${encodePathSegment(artifactId)}.json`);
       }
     };
   }
@@ -1898,31 +2048,31 @@ var init_json2 = __esm({
 });
 
 // ../protocol/src/validation.ts
-function validateJsonSchema(schema, value, path18 = "$") {
-  return validateSchemaNode(schema, value, path18);
+function validateJsonSchema(schema, value, path24 = "$") {
+  return validateSchemaNode(schema, value, path24);
 }
-function validateSchemaNode(schema, value, path18) {
+function validateSchemaNode(schema, value, path24) {
   const issues = [];
   if ("const" in schema && !isJsonValueEqual(schema.const, value)) {
     issues.push({
-      path: path18,
+      path: path24,
       message: `must equal ${JSON.stringify(schema.const)}`
     });
     return issues;
   }
   if (schema.enum !== void 0 && !schema.enum.some((candidate) => isJsonValueEqual(candidate, value))) {
     issues.push({
-      path: path18,
+      path: path24,
       message: `must be one of ${schema.enum.map((candidate) => JSON.stringify(candidate)).join(", ")}`
     });
     return issues;
   }
   if (schema.oneOf !== void 0) {
-    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path18));
+    const branchIssues = schema.oneOf.map((member) => validateSchemaNode(member, value, path24));
     const validBranches = branchIssues.filter((current) => current.length === 0).length;
     if (validBranches !== 1) {
       issues.push({
-        path: path18,
+        path: path24,
         message: validBranches === 0 ? "must match exactly one supported shape" : "matches multiple supported shapes"
       });
       return issues;
@@ -1930,11 +2080,11 @@ function validateSchemaNode(schema, value, path18) {
   }
   if (schema.anyOf !== void 0) {
     const hasMatch = schema.anyOf.some(
-      (member) => validateSchemaNode(member, value, path18).length === 0
+      (member) => validateSchemaNode(member, value, path24).length === 0
     );
     if (!hasMatch) {
       issues.push({
-        path: path18,
+        path: path24,
         message: "must match at least one supported shape"
       });
       return issues;
@@ -1942,7 +2092,7 @@ function validateSchemaNode(schema, value, path18) {
   }
   if (schema.allOf !== void 0) {
     for (const member of schema.allOf) {
-      issues.push(...validateSchemaNode(member, value, path18));
+      issues.push(...validateSchemaNode(member, value, path24));
     }
     if (issues.length > 0) {
       return issues;
@@ -1950,7 +2100,7 @@ function validateSchemaNode(schema, value, path18) {
   }
   if (schema.type !== void 0 && !matchesSchemaType(schema.type, value)) {
     issues.push({
-      path: path18,
+      path: path24,
       message: `must be ${describeSchemaType(schema.type)}`
     });
     return issues;
@@ -1958,19 +2108,19 @@ function validateSchemaNode(schema, value, path18) {
   if (typeof value === "string") {
     if (schema.minLength !== void 0 && value.length < schema.minLength) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must have length >= ${String(schema.minLength)}`
       });
     }
     if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must have length <= ${String(schema.maxLength)}`
       });
     }
     if (schema.pattern !== void 0 && !new RegExp(schema.pattern).test(value)) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must match pattern ${schema.pattern}`
       });
     }
@@ -1979,25 +2129,25 @@ function validateSchemaNode(schema, value, path18) {
   if (typeof value === "number") {
     if (schema.minimum !== void 0 && value < schema.minimum) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must be >= ${String(schema.minimum)}`
       });
     }
     if (schema.maximum !== void 0 && value > schema.maximum) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must be <= ${String(schema.maximum)}`
       });
     }
     if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must be > ${String(schema.exclusiveMinimum)}`
       });
     }
     if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must be < ${String(schema.exclusiveMaximum)}`
       });
     }
@@ -2006,13 +2156,13 @@ function validateSchemaNode(schema, value, path18) {
   if (Array.isArray(value)) {
     if (schema.minItems !== void 0 && value.length < schema.minItems) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must have at least ${String(schema.minItems)} items`
       });
     }
     if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
       issues.push({
-        path: path18,
+        path: path24,
         message: `must have at most ${String(schema.maxItems)} items`
       });
     }
@@ -2022,7 +2172,7 @@ function validateSchemaNode(schema, value, path18) {
         const key = JSON.stringify(item);
         if (seen.has(key)) {
           issues.push({
-            path: path18,
+            path: path24,
             message: "must not contain duplicate items"
           });
           break;
@@ -2032,7 +2182,7 @@ function validateSchemaNode(schema, value, path18) {
     }
     if (schema.items !== void 0) {
       for (let index = 0; index < value.length; index += 1) {
-        issues.push(...validateSchemaNode(schema.items, value[index], `${path18}[${String(index)}]`));
+        issues.push(...validateSchemaNode(schema.items, value[index], `${path24}[${String(index)}]`));
       }
     }
     return issues;
@@ -2042,7 +2192,7 @@ function validateSchemaNode(schema, value, path18) {
     for (const requiredKey of schema.required ?? []) {
       if (!(requiredKey in value)) {
         issues.push({
-          path: joinObjectPath(path18, requiredKey),
+          path: joinObjectPath(path24, requiredKey),
           message: "is required"
         });
       }
@@ -2051,13 +2201,13 @@ function validateSchemaNode(schema, value, path18) {
       const propertySchema = properties[key];
       if (propertySchema !== void 0) {
         issues.push(
-          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path18, key))
+          ...validateSchemaNode(propertySchema, propertyValue, joinObjectPath(path24, key))
         );
         continue;
       }
       if (schema.additionalProperties === false) {
         issues.push({
-          path: joinObjectPath(path18, key),
+          path: joinObjectPath(path24, key),
           message: "is not allowed"
         });
         continue;
@@ -2067,7 +2217,7 @@ function validateSchemaNode(schema, value, path18) {
           ...validateSchemaNode(
             schema.additionalProperties,
             propertyValue,
-            joinObjectPath(path18, key)
+            joinObjectPath(path24, key)
           )
         );
       }
@@ -2348,8 +2498,8 @@ function matchesNetworkRecordFilters(record, filters) {
     }
   }
   if (filters.path !== void 0) {
-    const path18 = getParsedUrl().pathname;
-    if (!includesCaseInsensitive(path18, filters.path)) {
+    const path24 = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path24, filters.path)) {
       return false;
     }
   }
@@ -5661,6 +5811,12 @@ var init_session_info = __esm({
   }
 });
 
+// ../protocol/src/local-view.ts
+var init_local_view = __esm({
+  "../protocol/src/local-view.ts"() {
+  }
+});
+
 // ../protocol/src/automation.ts
 var init_automation = __esm({
   "../protocol/src/automation.ts"() {
@@ -9678,6 +9834,7 @@ var init_src2 = __esm({
     init_observability();
     init_envelopes();
     init_session_info();
+    init_local_view();
     init_automation();
     init_operations();
     init_rest();
@@ -9763,9 +9920,9 @@ var init_registry = __esm({
     FilesystemRegistryStore = class {
       constructor(rootPath, registryRelativePath) {
         this.registryRelativePath = registryRelativePath;
-        const basePath = path7__default.default.join(rootPath, ...registryRelativePath);
-        this.recordsDirectory = path7__default.default.join(basePath, "records");
-        this.indexesDirectory = path7__default.default.join(basePath, "indexes", "by-key");
+        const basePath = path10__default.default.join(rootPath, ...registryRelativePath);
+        this.recordsDirectory = path10__default.default.join(basePath, "records");
+        this.indexesDirectory = path10__default.default.join(basePath, "indexes", "by-key");
       }
       recordsDirectory;
       indexesDirectory;
@@ -9834,7 +9991,7 @@ var init_registry = __esm({
       async readRecordsFromDirectory() {
         const files = await listJsonFiles(this.recordsDirectory);
         const records = await Promise.all(
-          files.map((fileName) => readJsonFile(path7__default.default.join(this.recordsDirectory, fileName)))
+          files.map((fileName) => readJsonFile(path10__default.default.join(this.recordsDirectory, fileName)))
         );
         records.sort(compareByCreatedAtAndId);
         return records;
@@ -9866,17 +10023,17 @@ var init_registry = __esm({
         return record;
       }
       recordPath(id) {
-        return path7__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
+        return path10__default.default.join(this.recordsDirectory, `${encodePathSegment(id)}.json`);
       }
       indexPath(key, version) {
-        return path7__default.default.join(
+        return path10__default.default.join(
           this.indexesDirectory,
           encodePathSegment(key),
           `${encodePathSegment(version)}.json`
         );
       }
       writeLockPath() {
-        return path7__default.default.join(path7__default.default.dirname(this.recordsDirectory), ".write.lock");
+        return path10__default.default.join(path10__default.default.dirname(this.recordsDirectory), ".write.lock");
       }
     };
     FilesystemDescriptorRegistry = class extends FilesystemRegistryStore {
@@ -10515,7 +10672,7 @@ var init_saved_store = __esm({
       directoryInitialization;
       databaseInitialization;
       constructor(rootPath) {
-        this.databasePath = path7__default.default.join(rootPath, "registry", "saved-network.sqlite");
+        this.databasePath = path10__default.default.join(rootPath, "registry", "saved-network.sqlite");
       }
       async initialize() {
         await this.ensureDatabaseDirectory();
@@ -10755,7 +10912,7 @@ var init_saved_store = __esm({
         }
       }
       async ensureDatabaseDirectory() {
-        this.directoryInitialization ??= ensureDirectory(path7__default.default.dirname(this.databasePath)).catch(
+        this.directoryInitialization ??= ensureDirectory(path10__default.default.dirname(this.databasePath)).catch(
           (error) => {
             this.directoryInitialization = void 0;
             throw error;
@@ -11095,7 +11252,7 @@ var init_observations = __esm({
       constructor(rootPath, artifacts) {
         this.rootPath = rootPath;
         this.artifacts = artifacts;
-        this.sessionsDirectory = path7__default.default.join(this.rootPath, "observations", "sessions");
+        this.sessionsDirectory = path10__default.default.join(this.rootPath, "observations", "sessions");
       }
       sessionsDirectory;
       redactors = /* @__PURE__ */ new Map();
@@ -11192,7 +11349,7 @@ var init_observations = __esm({
               ...raw.artifactIds === void 0 || raw.artifactIds.length === 0 ? {} : { artifactIds: [...raw.artifactIds] }
             };
             await writeJsonFileExclusive(
-              path7__default.default.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
+              path10__default.default.join(this.sessionEventsDirectory(sessionId), eventFileName(sequence)),
               event
             );
             updatedAt = Math.max(updatedAt, createdAt);
@@ -11250,7 +11407,7 @@ var init_observations = __esm({
         }
         const files = await listJsonFiles(directoryPath);
         const events = await Promise.all(
-          files.map((fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName)))
+          files.map((fileName) => readJsonFile(path10__default.default.join(directoryPath, fileName)))
         );
         const filtered = events.filter((event) => {
           if (input.kind !== void 0 && event.kind !== input.kind) return false;
@@ -11277,7 +11434,7 @@ var init_observations = __esm({
         const files = await listJsonFiles(directoryPath);
         const artifacts = await Promise.all(
           files.map(
-            (fileName) => readJsonFile(path7__default.default.join(directoryPath, fileName))
+            (fileName) => readJsonFile(path10__default.default.join(directoryPath, fileName))
           )
         );
         const filtered = artifacts.filter((artifact) => {
@@ -11340,25 +11497,25 @@ var init_observations = __esm({
         )).filter((value) => value !== void 0);
       }
       sessionDirectory(sessionId) {
-        return path7__default.default.join(this.sessionsDirectory, encodePathSegment(sessionId));
+        return path10__default.default.join(this.sessionsDirectory, encodePathSegment(sessionId));
       }
       sessionManifestPath(sessionId) {
-        return path7__default.default.join(this.sessionDirectory(sessionId), "session.json");
+        return path10__default.default.join(this.sessionDirectory(sessionId), "session.json");
       }
       sessionEventsDirectory(sessionId) {
-        return path7__default.default.join(this.sessionDirectory(sessionId), "events");
+        return path10__default.default.join(this.sessionDirectory(sessionId), "events");
       }
       sessionArtifactsDirectory(sessionId) {
-        return path7__default.default.join(this.sessionDirectory(sessionId), "artifacts");
+        return path10__default.default.join(this.sessionDirectory(sessionId), "artifacts");
       }
       sessionArtifactPath(sessionId, artifactId) {
-        return path7__default.default.join(
+        return path10__default.default.join(
           this.sessionArtifactsDirectory(sessionId),
           `${encodePathSegment(artifactId)}.json`
         );
       }
       sessionLockPath(sessionId) {
-        return path7__default.default.join(this.sessionDirectory(sessionId), ".lock");
+        return path10__default.default.join(this.sessionDirectory(sessionId), ".lock");
       }
       async reconcileSessionManifest(sessionId) {
         const session = await this.getSession(sessionId);
@@ -11386,14 +11543,14 @@ var init_observations = __esm({
           Promise.all(
             eventFiles.map(
               (fileName) => readJsonFile(
-                path7__default.default.join(this.sessionEventsDirectory(sessionId), fileName)
+                path10__default.default.join(this.sessionEventsDirectory(sessionId), fileName)
               )
             )
           ),
           Promise.all(
             artifactFiles.map(
               (fileName) => readJsonFile(
-                path7__default.default.join(this.sessionArtifactsDirectory(sessionId), fileName)
+                path10__default.default.join(this.sessionArtifactsDirectory(sessionId), fileName)
               )
             )
           )
@@ -11440,7 +11597,7 @@ var init_traces2 = __esm({
       constructor(rootPath, artifacts) {
         this.rootPath = rootPath;
         this.artifacts = artifacts;
-        this.runsDirectory = path7__default.default.join(this.rootPath, "traces", "runs");
+        this.runsDirectory = path10__default.default.join(this.rootPath, "traces", "runs");
       }
       runsDirectory;
       async initialize() {
@@ -11517,7 +11674,7 @@ var init_traces2 = __esm({
             ...input.error === void 0 ? {} : { error: input.error }
           };
           await writeJsonFileExclusive(
-            path7__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
+            path10__default.default.join(this.runEntriesDirectory(runId), sequenceFileName(sequence)),
             entry
           );
           await writeJsonFileAtomic(this.runManifestPath(runId), {
@@ -11536,7 +11693,7 @@ var init_traces2 = __esm({
         const files = await listJsonFiles(entriesDirectory);
         return Promise.all(
           files.map(
-            (fileName) => readJsonFile(path7__default.default.join(entriesDirectory, fileName))
+            (fileName) => readJsonFile(path10__default.default.join(entriesDirectory, fileName))
           )
         );
       }
@@ -11582,16 +11739,16 @@ var init_traces2 = __esm({
         return { trace, artifacts };
       }
       runDirectory(runId) {
-        return path7__default.default.join(this.runsDirectory, encodeURIComponent(runId));
+        return path10__default.default.join(this.runsDirectory, encodeURIComponent(runId));
       }
       runEntriesDirectory(runId) {
-        return path7__default.default.join(this.runDirectory(runId), "entries");
+        return path10__default.default.join(this.runDirectory(runId), "entries");
       }
       runManifestPath(runId) {
-        return path7__default.default.join(this.runDirectory(runId), "manifest.json");
+        return path10__default.default.join(this.runDirectory(runId), "manifest.json");
       }
       runWriteLockPath(runId) {
-        return path7__default.default.join(this.runDirectory(runId), ".append.lock");
+        return path10__default.default.join(this.runDirectory(runId), ".append.lock");
       }
     };
   }
@@ -11600,7 +11757,7 @@ function normalizeWorkspaceId(workspace) {
   return encodePathSegment(workspace);
 }
 function resolveFilesystemWorkspacePath(input) {
-  return path7__default.default.join(
+  return path10__default.default.join(
     input.rootDir,
     ".opensteer",
     "workspaces",
@@ -11609,18 +11766,18 @@ function resolveFilesystemWorkspacePath(input) {
 }
 async function createFilesystemOpensteerWorkspace(options) {
   await ensureDirectory(options.rootPath);
-  const manifestPath = path7__default.default.join(options.rootPath, "workspace.json");
-  const browserPath = path7__default.default.join(options.rootPath, "browser");
-  const browserManifestPath = path7__default.default.join(browserPath, "manifest.json");
-  const browserUserDataDir = path7__default.default.join(browserPath, "user-data");
-  const livePath = path7__default.default.join(options.rootPath, "live");
-  const liveLocalPath = path7__default.default.join(livePath, "local.json");
-  const liveCloudPath = path7__default.default.join(livePath, "cloud.json");
-  const artifactsPath = path7__default.default.join(options.rootPath, "artifacts");
-  const tracesPath = path7__default.default.join(options.rootPath, "traces");
-  const observationsPath = path7__default.default.join(options.rootPath, "observations");
-  const registryPath = path7__default.default.join(options.rootPath, "registry");
-  const lockPath = path7__default.default.join(options.rootPath, ".lock");
+  const manifestPath = path10__default.default.join(options.rootPath, "workspace.json");
+  const browserPath = path10__default.default.join(options.rootPath, "browser");
+  const browserManifestPath = path10__default.default.join(browserPath, "manifest.json");
+  const browserUserDataDir = path10__default.default.join(browserPath, "user-data");
+  const livePath = path10__default.default.join(options.rootPath, "live");
+  const liveLocalPath = path10__default.default.join(livePath, "local.json");
+  const liveCloudPath = path10__default.default.join(livePath, "cloud.json");
+  const artifactsPath = path10__default.default.join(options.rootPath, "artifacts");
+  const tracesPath = path10__default.default.join(options.rootPath, "traces");
+  const observationsPath = path10__default.default.join(options.rootPath, "observations");
+  const registryPath = path10__default.default.join(options.rootPath, "registry");
+  const lockPath = path10__default.default.join(options.rootPath, ".lock");
   let manifest;
   if (await pathExists(manifestPath)) {
     manifest = await readJsonFile(manifestPath);
@@ -11760,7 +11917,7 @@ var init_filesystem2 = __esm({
   }
 });
 function resolveLiveSessionRecordPath(rootPath, provider) {
-  return path7__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
+  return path10__default.default.join(rootPath, "live", provider === "local" ? "local.json" : "cloud.json");
 }
 async function readPersistedSessionRecord(rootPath, provider) {
   const sessionPath = resolveLiveSessionRecordPath(rootPath, provider);
@@ -11804,6 +11961,585 @@ var init_live_session = __esm({
     OPENSTEER_LIVE_SESSION_VERSION = 1;
   }
 });
+function resolveOpensteerStateDir() {
+  const explicit = process.env.OPENSTEER_HOME?.trim();
+  if (explicit) {
+    return path10__default.default.resolve(explicit);
+  }
+  if (process.platform === "win32") {
+    return path10__default.default.join(
+      process.env.LOCALAPPDATA ?? path10__default.default.join(os.homedir(), "AppData", "Local"),
+      "Opensteer"
+    );
+  }
+  if (process.platform === "darwin") {
+    return path10__default.default.join(os.homedir(), "Library", "Application Support", "Opensteer");
+  }
+  return path10__default.default.join(
+    process.env.XDG_STATE_HOME ?? path10__default.default.join(os.homedir(), ".local", "state"),
+    "opensteer"
+  );
+}
+function resolveLocalViewRootDir() {
+  return path10__default.default.join(resolveOpensteerStateDir(), "local-view");
+}
+function resolveLocalViewPreferencesPath() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "preferences.json");
+}
+function resolveLocalViewServiceDir() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "service");
+}
+function resolveLocalViewSessionsDir() {
+  return path10__default.default.join(resolveLocalViewRootDir(), "sessions");
+}
+function resolveLocalViewServiceLockDir() {
+  return path10__default.default.join(resolveLocalViewServiceDir(), "startup.lock");
+}
+function resolveLocalViewServiceStatePath() {
+  return path10__default.default.join(resolveLocalViewServiceDir(), "state.json");
+}
+var init_runtime_dir = __esm({
+  "src/local-view/runtime-dir.ts"() {
+  }
+});
+
+// src/local-view/preferences.ts
+async function resolveLocalViewMode() {
+  const preferences = await readLocalViewPreferences();
+  return preferences?.mode ?? "auto";
+}
+async function setLocalViewMode(mode) {
+  return writeLocalViewPreferences(mode);
+}
+async function readLocalViewPreferences() {
+  const preferencesPath = resolveLocalViewPreferencesPath();
+  if (!await pathExists(preferencesPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(preferencesPath);
+  return isPersistedLocalViewPreferences(parsed) ? parsed : void 0;
+}
+async function writeLocalViewPreferences(mode) {
+  const preferences = {
+    layout: OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION,
+    mode,
+    updatedAt: Date.now()
+  };
+  await writeJsonFileAtomic(resolveLocalViewPreferencesPath(), preferences);
+  return preferences;
+}
+function isPersistedLocalViewPreferences(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION && (value.mode === "auto" || value.mode === "manual") && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+var OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT, OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION;
+var init_preferences = __esm({
+  "src/local-view/preferences.ts"() {
+    init_filesystem2();
+    init_runtime_dir();
+    OPENSTEER_LOCAL_VIEW_PREFERENCES_LAYOUT = "opensteer-local-view-preferences";
+    OPENSTEER_LOCAL_VIEW_PREFERENCES_VERSION = 1;
+  }
+});
+async function acquireDirLock(lockDirPath) {
+  while (true) {
+    const releaseLock = await tryAcquireDirLock(lockDirPath);
+    if (releaseLock) {
+      return releaseLock;
+    }
+    await sleep(LOCK_RETRY_DELAY_MS);
+  }
+}
+async function tryAcquireDirLock(lockDirPath) {
+  await promises.mkdir(path10.dirname(lockDirPath), { recursive: true });
+  while (true) {
+    const tempLockDirPath = `${lockDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${crypto.randomUUID()}`;
+    try {
+      await promises.mkdir(tempLockDirPath);
+      await writeLockOwner(tempLockDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await promises.rename(tempLockDirPath, lockDirPath);
+        break;
+      } catch (error) {
+        if (!wasDirPublishedByAnotherProcess(error, lockDirPath)) {
+          throw error;
+        }
+      }
+    } finally {
+      await promises.rm(tempLockDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const owner = await readLockOwner(lockDirPath);
+    if ((!owner || await getProcessLiveness(owner) === "dead") && await tryReclaimStaleLock(lockDirPath, owner)) {
+      continue;
+    }
+    return null;
+  }
+  return async () => {
+    await promises.rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  };
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function wasDirPublishedByAnotherProcess(error, targetDirPath) {
+  const code = getErrorCode(error);
+  return fs.existsSync(targetDirPath) && (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM");
+}
+async function writeLockOwner(lockDirPath, owner) {
+  await promises.writeFile(path10.join(lockDirPath, LOCK_OWNER_FILE), JSON.stringify(owner));
+}
+async function readLockOwner(lockDirPath) {
+  return readLockParticipant(path10.join(lockDirPath, LOCK_OWNER_FILE));
+}
+async function readLockParticipant(filePath) {
+  return (await readLockParticipantRecord(filePath)).owner;
+}
+async function readLockParticipantRecord(filePath) {
+  try {
+    const raw = await promises.readFile(filePath, "utf8");
+    return {
+      exists: true,
+      owner: parseProcessOwner(JSON.parse(raw))
+    };
+  } catch (error) {
+    return {
+      exists: getErrorCode(error) !== "ENOENT",
+      owner: null
+    };
+  }
+}
+async function readLockReclaimerRecord(lockDirPath) {
+  return readLockParticipantRecord(path10.join(buildLockReclaimerDirPath(lockDirPath), LOCK_OWNER_FILE));
+}
+async function tryReclaimStaleLock(lockDirPath, expectedOwner) {
+  if (!await tryAcquireLockReclaimer(lockDirPath)) {
+    return false;
+  }
+  let reclaimed = false;
+  try {
+    const owner = await readLockOwner(lockDirPath);
+    if (!processOwnersEqual(owner, expectedOwner)) {
+      return false;
+    }
+    if (owner && await getProcessLiveness(owner) !== "dead") {
+      return false;
+    }
+    await promises.rm(lockDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+    reclaimed = !fs.existsSync(lockDirPath);
+    return reclaimed;
+  } finally {
+    if (!reclaimed) {
+      await promises.rm(buildLockReclaimerDirPath(lockDirPath), {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+  }
+}
+async function tryAcquireLockReclaimer(lockDirPath) {
+  const reclaimerDirPath = buildLockReclaimerDirPath(lockDirPath);
+  while (true) {
+    const tempReclaimerDirPath = `${reclaimerDirPath}-${String(process.pid)}-${String(CURRENT_PROCESS_OWNER.processStartedAtMs)}-${crypto.randomUUID()}`;
+    try {
+      await promises.mkdir(tempReclaimerDirPath);
+      await writeLockOwner(tempReclaimerDirPath, CURRENT_PROCESS_OWNER);
+      try {
+        await promises.rename(tempReclaimerDirPath, reclaimerDirPath);
+        return true;
+      } catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+          return false;
+        }
+        if (!wasDirPublishedByAnotherProcess(error, reclaimerDirPath)) {
+          throw error;
+        }
+      }
+    } catch (error) {
+      if (getErrorCode(error) === "ENOENT") {
+        return false;
+      }
+      throw error;
+    } finally {
+      await promises.rm(tempReclaimerDirPath, {
+        recursive: true,
+        force: true
+      }).catch(() => void 0);
+    }
+    const reclaimerRecord = await readLockReclaimerRecord(lockDirPath);
+    if (!reclaimerRecord.exists || !reclaimerRecord.owner) {
+      return false;
+    }
+    if (await getProcessLiveness(reclaimerRecord.owner) !== "dead") {
+      return false;
+    }
+    await promises.rm(reclaimerDirPath, {
+      recursive: true,
+      force: true
+    }).catch(() => void 0);
+  }
+}
+function buildLockReclaimerDirPath(lockDirPath) {
+  return path10.join(lockDirPath, LOCK_RECLAIMER_DIR);
+}
+async function sleep(ms) {
+  await new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+var LOCK_OWNER_FILE, LOCK_RECLAIMER_DIR, LOCK_RETRY_DELAY_MS;
+var init_dir_lock = __esm({
+  "src/local-browser/dir-lock.ts"() {
+    init_process_owner();
+    LOCK_OWNER_FILE = "owner.json";
+    LOCK_RECLAIMER_DIR = "reclaimer";
+    LOCK_RETRY_DELAY_MS = 50;
+  }
+});
+async function readLocalViewServiceState() {
+  const statePath = resolveLocalViewServiceStatePath();
+  if (!await pathExists(statePath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(statePath);
+  if (!isPersistedLocalViewServiceState(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+async function writeLocalViewServiceState(state) {
+  await writeJsonFileAtomic(resolveLocalViewServiceStatePath(), state);
+}
+async function clearLocalViewServiceState(match = void 0) {
+  if (match !== void 0) {
+    const current = await readLocalViewServiceState();
+    if (current === void 0 || current.pid !== match.pid || current.token !== match.token) {
+      return;
+    }
+  }
+  await promises.rm(resolveLocalViewServiceStatePath(), { force: true });
+}
+async function isLocalViewServiceStateLive(state) {
+  return await getLocalViewServiceStateLiveness(state) !== "dead";
+}
+async function getLocalViewServiceStateLiveness(state) {
+  if (state === void 0) {
+    return "dead";
+  }
+  return getProcessLiveness({
+    pid: state.pid,
+    processStartedAtMs: state.processStartedAtMs
+  });
+}
+function isPersistedLocalViewServiceState(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_SERVICE_VERSION && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.processStartedAtMs === "number" && Number.isFinite(value.processStartedAtMs) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.port === "number" && Number.isFinite(value.port) && typeof value.token === "string" && value.token.length > 0 && typeof value.url === "string" && value.url.length > 0;
+}
+var OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT, OPENSTEER_LOCAL_VIEW_SERVICE_VERSION;
+var init_service_state = __esm({
+  "src/local-view/service-state.ts"() {
+    init_filesystem2();
+    init_process_owner();
+    init_runtime_dir();
+    OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT = "opensteer-local-view-service";
+    OPENSTEER_LOCAL_VIEW_SERVICE_VERSION = 3;
+  }
+});
+async function ensureLocalViewServiceRunning() {
+  const current = await readReachableLocalViewServiceState();
+  if (current !== void 0) {
+    return current;
+  }
+  const releaseLock = await acquireDirLock(resolveLocalViewServiceLockDir());
+  try {
+    const lockedState = await readReachableLocalViewServiceState();
+    if (lockedState !== void 0) {
+      return lockedState;
+    }
+    await spawnLocalViewService();
+    const started = await waitForLocalViewService();
+    if (!started) {
+      throw new Error("Timed out while starting the local view service.");
+    }
+    return started;
+  } finally {
+    await releaseLock();
+  }
+}
+async function stopLocalViewService() {
+  const state = await readLocalViewServiceState();
+  if (state === void 0 || !await isLocalViewServiceStateLive(state)) {
+    await clearLocalViewServiceState(
+      state === void 0 ? void 0 : { pid: state.pid, token: state.token }
+    );
+    return false;
+  }
+  const liveState = state;
+  const stopRequested = await requestLocalViewServiceStop(liveState).catch(() => false);
+  if (!stopRequested && await getLocalViewServiceStateLiveness(liveState) !== "dead") {
+    process.kill(liveState.pid);
+  }
+  await waitForLocalViewServiceStop(liveState);
+  await clearLocalViewServiceState({ pid: liveState.pid, token: liveState.token });
+  return true;
+}
+function buildLocalViewSessionUrl(args) {
+  if (!args.sessionId) {
+    return args.baseUrl;
+  }
+  return `${args.baseUrl}#session=${encodeURIComponent(args.sessionId)}`;
+}
+async function requestLocalViewServiceStop(state) {
+  const response = await fetch(new URL("/api/service/stop", state.url), {
+    method: "POST",
+    headers: {
+      "x-opensteer-local-token": state.token
+    }
+  });
+  return response.ok;
+}
+async function waitForLocalViewServiceStop(state) {
+  const deadline = Date.now() + LOCAL_VIEW_STOP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await getLocalViewServiceStateLiveness(state) === "dead") {
+      return;
+    }
+    await delay(LOCAL_VIEW_STARTUP_POLL_MS);
+  }
+  throw new Error("Timed out while stopping the local view service.");
+}
+function spawnLocalViewService() {
+  const command = resolveLocalViewSpawnCommand();
+  const child = child_process.spawn(command.executable, command.args, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      ...command.env ?? {},
+      OPENSTEER_LOCAL_VIEW_BOOT_TOKEN: process.env.OPENSTEER_LOCAL_VIEW_BOOT_TOKEN ?? crypto.randomBytes(24).toString("hex")
+    },
+    detached: process.platform !== "win32",
+    stdio: "ignore"
+  });
+  child.unref();
+}
+async function waitForLocalViewService() {
+  const deadline = Date.now() + LOCAL_VIEW_STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const state = await readReachableLocalViewServiceState();
+    if (state !== void 0) {
+      return state;
+    }
+    await delay(LOCAL_VIEW_STARTUP_POLL_MS);
+  }
+  return void 0;
+}
+async function readReachableLocalViewServiceState() {
+  const state = await readLocalViewServiceState();
+  if (state === void 0 || !await isLocalViewServiceStateLive(state)) {
+    return void 0;
+  }
+  return await isLocalViewServiceReachable(state.url, state.token) ? state : void 0;
+}
+async function isLocalViewServiceReachable(baseUrl, token) {
+  try {
+    const response = await fetch(new URL("/api/health", baseUrl), {
+      headers: {
+        "x-opensteer-local-token": token
+      }
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function resolveLocalViewSpawnCommand() {
+  const moduleDir = path10__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
+  const distServicePath = findExistingPath([
+    path10__default.default.join(moduleDir, "local-view", "serve-entry.js"),
+    path10__default.default.join(moduleDir, "serve-entry.js"),
+    path10__default.default.join(moduleDir, "..", "local-view", "serve-entry.js")
+  ]);
+  if (distServicePath) {
+    return {
+      executable: process.execPath,
+      args: [distServicePath]
+    };
+  }
+  const distCliPath = findExistingPath([
+    path10__default.default.join(moduleDir, "cli", "bin.js"),
+    path10__default.default.join(moduleDir, "..", "cli", "bin.js")
+  ]);
+  if (distCliPath) {
+    return {
+      executable: process.execPath,
+      args: [distCliPath, "view", "serve"]
+    };
+  }
+  const srcServicePath = findExistingPath([
+    path10__default.default.join(moduleDir, "serve-entry.ts"),
+    path10__default.default.join(moduleDir, "..", "local-view", "serve-entry.ts"),
+    path10__default.default.join(moduleDir, "..", "src", "local-view", "serve-entry.ts")
+  ]);
+  if (srcServicePath) {
+    const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href)));
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path10__default.default.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcServicePath],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  const srcCliPath = findExistingPath([
+    path10__default.default.join(moduleDir, "..", "cli", "bin.ts"),
+    path10__default.default.join(moduleDir, "..", "src", "cli", "bin.ts")
+  ]);
+  if (srcCliPath) {
+    const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href)));
+    const tsxLoaderPath = require2.resolve("tsx");
+    const tsconfigPath = findNearestTsconfig(path10__default.default.resolve(moduleDir, "..", "..", ".."));
+    return {
+      executable: process.execPath,
+      args: ["--import", tsxLoaderPath, srcCliPath, "view", "serve"],
+      ...tsconfigPath ? { env: { TSX_TSCONFIG_PATH: tsconfigPath } } : {}
+    };
+  }
+  throw new Error(`Could not resolve the Opensteer CLI entrypoint from ${moduleDir}.`);
+}
+function findExistingPath(candidates) {
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+function findNearestTsconfig(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const candidate = path10__default.default.join(currentDir, "tsconfig.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path10__default.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
+  });
+}
+var LOCAL_VIEW_STARTUP_TIMEOUT_MS, LOCAL_VIEW_STARTUP_POLL_MS, LOCAL_VIEW_STOP_TIMEOUT_MS;
+var init_service = __esm({
+  "src/local-view/service.ts"() {
+    init_dir_lock();
+    init_service_state();
+    init_runtime_dir();
+    LOCAL_VIEW_STARTUP_TIMEOUT_MS = 1e4;
+    LOCAL_VIEW_STARTUP_POLL_MS = 100;
+    LOCAL_VIEW_STOP_TIMEOUT_MS = 1e4;
+  }
+});
+function buildLocalViewSessionId(input) {
+  const hash = crypto.createHash("sha256").update(`${input.rootPath}
+${String(input.pid)}
+${String(input.startedAt)}`).digest("hex");
+  return `local_${hash.slice(0, 24)}`;
+}
+function createLocalViewSessionManifest(input) {
+  return {
+    layout: OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_SESSION_VERSION,
+    sessionId: buildLocalViewSessionId({
+      rootPath: input.rootPath,
+      pid: input.live.pid,
+      startedAt: input.live.startedAt
+    }),
+    rootPath: input.rootPath,
+    ...input.workspace === void 0 ? {} : { workspace: input.workspace },
+    engine: input.live.engine,
+    ownership: input.ownership,
+    pid: input.live.pid,
+    startedAt: input.live.startedAt,
+    updatedAt: Date.now()
+  };
+}
+async function writeLocalViewSessionManifest(manifest) {
+  await ensureDirectory(resolveLocalViewSessionsDir());
+  await writeJsonFileAtomic(resolveLocalViewSessionManifestPath(manifest.sessionId), manifest);
+}
+async function deleteLocalViewSessionManifest(sessionId) {
+  await promises.rm(resolveLocalViewSessionManifestPath(sessionId), { force: true }).catch(() => void 0);
+}
+async function readLocalViewSessionManifest(sessionId) {
+  const manifestPath = resolveLocalViewSessionManifestPath(sessionId);
+  if (!await pathExists(manifestPath)) {
+    return void 0;
+  }
+  const parsed = await readJsonFile(manifestPath);
+  return isPersistedLocalViewSessionManifest(parsed) ? parsed : void 0;
+}
+async function listLocalViewSessionManifests() {
+  const directoryPath = resolveLocalViewSessionsDir();
+  const fileNames = await listJsonFiles(directoryPath);
+  const manifests = await Promise.all(
+    fileNames.map(async (fileName) => {
+      const parsed = await readJsonFile(
+        path10__default.default.join(directoryPath, fileName)
+      ).catch(() => void 0);
+      return isPersistedLocalViewSessionManifest(parsed) ? parsed : void 0;
+    })
+  );
+  return manifests.filter((manifest) => manifest !== void 0).sort(
+    (left, right) => left.startedAt - right.startedAt || left.sessionId.localeCompare(right.sessionId)
+  );
+}
+function resolveLocalViewSessionManifestPath(sessionId) {
+  return path10__default.default.join(resolveLocalViewSessionsDir(), `${sessionId}.json`);
+}
+function isPersistedLocalViewSessionManifest(value) {
+  return value?.layout === OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT && value.version === OPENSTEER_LOCAL_VIEW_SESSION_VERSION && typeof value.sessionId === "string" && value.sessionId.length > 0 && typeof value.rootPath === "string" && value.rootPath.length > 0 && (value.engine === "playwright" || value.engine === "abp") && (value.ownership === "owned" || value.ownership === "attached" || value.ownership === "managed") && typeof value.pid === "number" && Number.isFinite(value.pid) && typeof value.startedAt === "number" && Number.isFinite(value.startedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt);
+}
+var OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT, OPENSTEER_LOCAL_VIEW_SESSION_VERSION;
+var init_session_manifest = __esm({
+  "src/local-view/session-manifest.ts"() {
+    init_filesystem2();
+    init_runtime_dir();
+    OPENSTEER_LOCAL_VIEW_SESSION_LAYOUT = "opensteer-local-view-session";
+    OPENSTEER_LOCAL_VIEW_SESSION_VERSION = 1;
+  }
+});
+
+// src/local-view/registration.ts
+async function bestEffortRegisterLocalViewSession(input) {
+  try {
+    const manifest = createLocalViewSessionManifest(input);
+    await writeLocalViewSessionManifest(manifest);
+    if (await resolveLocalViewMode() === "auto") {
+      void ensureLocalViewServiceRunning().catch(() => void 0);
+    }
+    return manifest;
+  } catch {
+    return void 0;
+  }
+}
+async function bestEffortUnregisterLocalViewSession(sessionId) {
+  if (!sessionId) {
+    return;
+  }
+  await deleteLocalViewSessionManifest(sessionId).catch(() => void 0);
+}
+var init_registration = __esm({
+  "src/local-view/registration.ts"() {
+    init_preferences();
+    init_service();
+    init_session_manifest();
+  }
+});
 
 // ../runtime-core/src/internal/engine-selection.ts
 function resolveOpensteerEngineName(input = {}) {
@@ -12070,7 +12806,7 @@ async function waitForDevToolsEndpoint(input) {
     if (exitCode !== null) {
       throw new Error(formatChromeLaunchError(input.stderrLines));
     }
-    await sleep(DEVTOOLS_POLL_INTERVAL_MS);
+    await sleep2(DEVTOOLS_POLL_INTERVAL_MS);
   }
   throw new Error(formatChromeLaunchError(input.stderrLines));
 }
@@ -12218,12 +12954,12 @@ async function waitForProcessExit(pid, timeoutMs) {
     if (!isProcessRunning(pid)) {
       return true;
     }
-    await sleep(50);
+    await sleep2(50);
   }
   return !isProcessRunning(pid);
 }
 function resolveAbpSessionDir(workspace) {
-  return path7__default.default.join(workspace.livePath, "abp-session");
+  return path10__default.default.join(workspace.livePath, "abp-session");
 }
 async function allocateEphemeralPort() {
   const { allocatePort } = await loadAbpModule();
@@ -12280,7 +13016,7 @@ function resolveStealthProfile(input) {
 function isStealthProfile(input) {
   return input.id !== void 0 && input.platform !== void 0 && input.browserBrand !== void 0 && input.browserVersion !== void 0 && input.userAgent !== void 0 && input.viewport !== void 0 && input.screenResolution !== void 0 && input.devicePixelRatio !== void 0 && input.maxTouchPoints !== void 0 && input.webglVendor !== void 0 && input.webglRenderer !== void 0 && input.fonts !== void 0 && input.canvasNoiseSeed !== void 0 && input.audioNoiseSeed !== void 0 && input.locale !== void 0 && input.timezoneId !== void 0;
 }
-async function sleep(ms) {
+async function sleep2(ms) {
   await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var DEFAULT_TIMEOUT_MS, DEVTOOLS_POLL_INTERVAL_MS, TEMPORARY_WORKSPACE_PREFIX, BROWSER_CLOSE_TIMEOUT_MS, OpensteerBrowserManager;
@@ -12295,6 +13031,8 @@ var init_browser_manager = __esm({
     init_stealth_profiles();
     init_root2();
     init_live_session();
+    init_registration();
+    init_session_manifest();
     init_filesystem2();
     init_engine_selection2();
     DEFAULT_TIMEOUT_MS = 3e4;
@@ -12323,8 +13061,8 @@ var init_browser_manager = __esm({
           ...options.browser === void 0 ? {} : { browser: options.browser },
           ...this.contextOptions === void 0 ? {} : { context: this.contextOptions }
         });
-        this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7__default.default.join(os.tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-          rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+        this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path10__default.default.join(os.tmpdir(), `${TEMPORARY_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
+          rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
           workspace: this.workspace
         }));
         this.cleanupRootOnDisconnect = this.workspace === void 0;
@@ -12385,7 +13123,7 @@ var init_browser_manager = __esm({
             userDataDir: "browser/user-data",
             bootstrap: {
               kind: "cloneLocalProfile",
-              sourceUserDataDir: path7__default.default.resolve(input.sourceUserDataDir),
+              sourceUserDataDir: path10__default.default.resolve(input.sourceUserDataDir),
               ...input.sourceProfileDirectory === void 0 ? {} : { sourceProfileDirectory: input.sourceProfileDirectory }
             }
           };
@@ -12458,6 +13196,12 @@ var init_browser_manager = __esm({
                 `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before reopening with engine "abp".`
               );
             }
+            await bestEffortRegisterLocalViewSession({
+              rootPath: workspace.rootPath,
+              ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+              live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+              ownership: "owned"
+            });
             return this.createAdoptedAbpEngine(live);
           }
           await this.ensurePersistentBrowserManifest(workspace);
@@ -12490,9 +13234,17 @@ var init_browser_manager = __esm({
             ...launch?.browserExecutablePath === void 0 ? {} : { executablePath: launch.browserExecutablePath }
           };
           await this.writeLivePersistentBrowser(workspace, liveRecord);
+          const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+          await bestEffortRegisterLocalViewSession({
+            rootPath: workspace.rootPath,
+            ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+            live: persistedLiveRecord,
+            ownership: "owned"
+          });
           try {
             return await this.createAdoptedAbpEngine(liveRecord);
           } catch (error) {
+            await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
             await terminateProcess(launched.process.pid ?? 0).catch(() => void 0);
             await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
             throw error;
@@ -12512,23 +13264,45 @@ var init_browser_manager = __esm({
         });
       }
       async createTemporaryEngine() {
-        const userDataDir = await promises.mkdtemp(path7__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
+        const userDataDir = await promises.mkdtemp(path10__default.default.join(os.tmpdir(), "opensteer-temporary-browser-"));
         await clearChromeSingletonEntries(userDataDir);
         const launched = await launchOwnedBrowser({
           userDataDir,
           ...this.launchOptions === void 0 ? {} : { launch: this.launchOptions },
           ...this.contextOptions?.viewport === void 0 ? {} : { viewport: this.contextOptions.viewport }
         });
+        const temporaryLiveRecord = {
+          layout: "opensteer-session",
+          version: 1,
+          provider: "local",
+          engine: "playwright",
+          endpoint: launched.endpoint,
+          pid: launched.pid,
+          startedAt: Date.now(),
+          updatedAt: Date.now(),
+          executablePath: launched.executablePath,
+          userDataDir
+        };
+        await writePersistedSessionRecord(this.rootPath, temporaryLiveRecord);
+        const localViewManifest = await bestEffortRegisterLocalViewSession({
+          rootPath: this.rootPath,
+          live: temporaryLiveRecord,
+          ownership: "owned"
+        });
         try {
           return await this.createAttachedEngine({
             endpoint: launched.endpoint,
             freshTab: false,
             onDispose: async () => {
+              await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+              await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
               await terminateProcess(launched.pid).catch(() => void 0);
               await promises.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
             }
           });
         } catch (error) {
+          await bestEffortUnregisterLocalViewSession(localViewManifest?.sessionId);
+          await clearPersistedSessionRecord(this.rootPath, "local").catch(() => void 0);
           await terminateProcess(launched.pid).catch(() => void 0);
           await promises.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
           throw error;
@@ -12556,6 +13330,12 @@ var init_browser_manager = __esm({
             if (live.endpoint === void 0) {
               throw new Error("workspace live browser record is missing a DevTools endpoint.");
             }
+            await bestEffortRegisterLocalViewSession({
+              rootPath: workspace.rootPath,
+              ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+              live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+              ownership: "owned"
+            });
             return this.createAttachedEngine({
               endpoint: live.endpoint,
               freshTab: false,
@@ -12578,6 +13358,13 @@ var init_browser_manager = __esm({
             userDataDir: workspace.browserUserDataDir
           };
           await this.writeLivePersistentBrowser(workspace, liveRecord);
+          const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+          await bestEffortRegisterLocalViewSession({
+            rootPath: workspace.rootPath,
+            ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+            live: persistedLiveRecord,
+            ownership: "owned"
+          });
           try {
             return await this.createAttachedEngine({
               endpoint: launched.endpoint,
@@ -12585,6 +13372,7 @@ var init_browser_manager = __esm({
               onDispose: async () => void 0
             });
           } catch (error) {
+            await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
             await terminateProcess(launched.pid).catch(() => void 0);
             await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
             throw error;
@@ -12735,6 +13523,10 @@ var init_browser_manager = __esm({
           await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
           return;
         }
+        await this.unregisterLocalViewSessionForRecord(
+          workspace.rootPath,
+          toPersistedLocalBrowserSessionRecord(this.workspace, live)
+        );
         if (live.engine === "playwright") {
           if (live.endpoint !== void 0) {
             await requestBrowserClose(live.endpoint).catch(() => void 0);
@@ -12761,6 +13553,15 @@ var init_browser_manager = __esm({
           throw new Error(`browser.${method}() requires a persistent workspace browser.`);
         }
       }
+      async unregisterLocalViewSessionForRecord(rootPath, record) {
+        await bestEffortUnregisterLocalViewSession(
+          buildLocalViewSessionId({
+            rootPath,
+            pid: record.pid,
+            startedAt: record.startedAt
+          })
+        );
+      }
     };
   }
 });
@@ -12813,17 +13614,17 @@ async function readBrowserCookies(input = {}) {
   const brand2 = resolveRequestedBrand(input);
   const userDataDir = resolveBrandUserDataDir(brand2, input.userDataDir);
   const profileDirectory = input.profileDirectory ?? "Default";
-  const cookiesPath = path7.join(userDataDir, profileDirectory, "Cookies");
+  const cookiesPath = path10.join(userDataDir, profileDirectory, "Cookies");
   if (!fs.existsSync(cookiesPath)) {
     throw new Error(
       `Cookies database not found at "${cookiesPath}". Verify the browser brand, user-data-dir, and profile-directory are correct.`
     );
   }
-  const tempDir = await promises.mkdtemp(path7.join(os.tmpdir(), "opensteer-cookies-"));
+  const tempDir = await promises.mkdtemp(path10.join(os.tmpdir(), "opensteer-cookies-"));
   try {
     await copyCookiesDatabase(cookiesPath, tempDir);
     const decryptionKey = await resolveDecryptionKey(brand2.id, userDataDir);
-    const rows = queryAllCookies(path7.join(tempDir, "Cookies"));
+    const rows = queryAllCookies(path10.join(tempDir, "Cookies"));
     const cookies = decryptCookieRows(rows, decryptionKey);
     return {
       cookies,
@@ -12849,11 +13650,11 @@ function resolveRequestedBrand(input) {
   return installed.brand;
 }
 async function copyCookiesDatabase(cookiesPath, destDir) {
-  await promises.copyFile(cookiesPath, path7.join(destDir, "Cookies"));
+  await promises.copyFile(cookiesPath, path10.join(destDir, "Cookies"));
   for (const suffix of ["-wal", "-journal", "-shm"]) {
     const src = cookiesPath + suffix;
     if (fs.existsSync(src)) {
-      await promises.copyFile(src, path7.join(destDir, "Cookies" + suffix)).catch(() => void 0);
+      await promises.copyFile(src, path10.join(destDir, "Cookies" + suffix)).catch(() => void 0);
     }
   }
 }
@@ -12921,7 +13722,7 @@ async function resolveKeychainPassword(brandId) {
   }
 }
 async function resolveWindowsMasterKey(userDataDir) {
-  const localStatePath = path7.join(userDataDir, "Local State");
+  const localStatePath = path10.join(userDataDir, "Local State");
   let localState;
   try {
     localState = JSON.parse(await promises.readFile(localStatePath, "utf8"));
@@ -13141,14 +13942,14 @@ function toPortableBrowserProfileCookieRecord(cookie) {
   if (!name || !domain) {
     return null;
   }
-  const path18 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
+  const path24 = typeof cookie.path === "string" && cookie.path.trim().length > 0 ? cookie.path : "/";
   const expiresAt = typeof cookie.expires === "number" && Number.isFinite(cookie.expires) && cookie.expires > 0 ? Math.floor(cookie.expires * 1e3) : null;
   const sameSite = normalizeSameSite(cookie.sameSite);
   return {
     name,
     value: cookie.value,
     domain,
-    path: path18,
+    path: path24,
     secure: cookie.secure,
     httpOnly: cookie.httpOnly,
     ...sameSite === void 0 ? {} : { sameSite },
@@ -13216,7 +14017,7 @@ async function waitForBrowserProfileImport(client, importId) {
     if (current.status === "failed") {
       throw new Error(current.error ?? "Browser profile sync failed.");
     }
-    await sleep2(DEFAULT_POLL_INTERVAL_MS);
+    await sleep3(DEFAULT_POLL_INTERVAL_MS);
   }
   throw new Error(`Timed out waiting for browser profile sync "${importId}" to finish.`);
 }
@@ -13225,7 +14026,7 @@ function normalizePlatform(platform) {
   if (platform === "win32") return "windows";
   return platform;
 }
-async function sleep2(ms) {
+async function sleep3(ms) {
   await new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var gzip, DEFAULT_POLL_INTERVAL_MS, DEFAULT_POLL_TIMEOUT_MS;
@@ -13247,7 +14048,7 @@ function createRequestSignal(options) {
   }
   return AbortSignal.any([options.signal, timeoutSignal]);
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve4) => {
     setTimeout(resolve4, ms);
   });
@@ -13464,7 +14265,7 @@ var init_client = __esm({
               `Unexpected cloud session status "${String(session.status)}" while waiting for close.`
             );
           }
-          await delay(CLOUD_CLOSE_POLL_INTERVAL_MS);
+          await delay2(CLOUD_CLOSE_POLL_INTERVAL_MS);
         }
         throw new Error(`Timed out waiting for cloud session ${sessionId} to close.`);
       }
@@ -13519,7 +14320,7 @@ var init_package = __esm({
   "../runtime-core/package.json"() {
     package_default2 = {
       name: "@opensteer/runtime-core",
-      version: "0.2.0",
+      version: "0.2.1",
       description: "Shared semantic runtime for Opensteer local and cloud execution.",
       license: "MIT",
       type: "module",
@@ -14345,9 +15146,9 @@ var init_match_selectors = __esm({
 });
 
 // ../runtime-core/src/runtimes/dom/extraction.ts
-function buildArrayFieldPathCandidates(path18) {
-  const strict = path18.nodes.length ? buildPathCandidates(path18.nodes) : [];
-  const relaxedNodes = stripPositionClauses(path18.nodes);
+function buildArrayFieldPathCandidates(path24) {
+  const strict = path24.nodes.length ? buildPathCandidates(path24.nodes) : [];
+  const relaxedNodes = stripPositionClauses(path24.nodes);
   const relaxed = relaxedNodes.length ? buildPathCandidates(relaxedNodes) : [];
   return dedupeSelectors([...strict, ...relaxed]);
 }
@@ -14895,8 +15696,8 @@ function cloneStructuralElementAnchor(anchor) {
     nodes: anchor.nodes.map(clonePathNode)
   };
 }
-function buildPathSelectorHint(path18) {
-  const nodes = path18?.nodes || [];
+function buildPathSelectorHint(path24) {
+  const nodes = path24?.nodes || [];
   const last = nodes[nodes.length - 1];
   if (!last) {
     return "*";
@@ -14945,15 +15746,15 @@ function sanitizeStructuralElementAnchor(anchor) {
     nodes: sanitizeNodes(anchor.nodes)
   };
 }
-function sanitizeReplayElementPath(path18) {
+function sanitizeReplayElementPath(path24) {
   return {
     resolution: "deterministic",
-    context: sanitizeContext(path18.context),
-    nodes: sanitizeNodes(path18.nodes)
+    context: sanitizeContext(path24.context),
+    nodes: sanitizeNodes(path24.nodes)
   };
 }
-function sanitizeElementPath(path18) {
-  return sanitizeReplayElementPath(path18);
+function sanitizeElementPath(path24) {
+  return sanitizeReplayElementPath(path24);
 }
 function buildLocalStructuralElementAnchor(index, rawTargetNode) {
   const targetNode = requireElementNode(index, rawTargetNode);
@@ -15076,8 +15877,8 @@ function buildTargetNotFoundMessage(domPath, diagnostics) {
   }
   return `${base} Target depth ${String(depth)}. Candidate counts: ${sample}.`;
 }
-function buildArrayFieldCandidates(path18) {
-  return buildArrayFieldPathCandidates(path18);
+function buildArrayFieldCandidates(path24) {
+  return buildArrayFieldPathCandidates(path24);
 }
 function firstDefinedAttribute(node, keys) {
   for (const key of keys) {
@@ -16639,21 +17440,21 @@ var init_runtime = __esm({
         return match;
       }
       async resolvePathTarget(session, pageRef, rawPath, source, persist, descriptor) {
-        const path18 = sanitizeReplayElementPath(rawPath);
-        const context = await this.resolvePathContext(session, pageRef, path18.context);
-        const target = resolveDomPathInScope(context.index, path18.nodes, context.scope);
+        const path24 = sanitizeReplayElementPath(rawPath);
+        const context = await this.resolvePathContext(session, pageRef, path24.context);
+        const target = resolveDomPathInScope(context.index, path24.nodes, context.scope);
         if (!target) {
-          throwTargetNotFound(context.index, path18.nodes, context.scope);
+          throwTargetNotFound(context.index, path24.nodes, context.scope);
         }
         if (target.node.nodeRef === void 0) {
           throw new Error(
-            `resolved path "${buildPathSelectorHint(path18)}" does not point to a live element`
+            `resolved path "${buildPathSelectorHint(path24)}" does not point to a live element`
           );
         }
         const anchor = await this.buildAnchorFromSnapshotNode(session, context.snapshot, target.node);
         return this.createResolvedTarget(source, context.snapshot, target.node, anchor, {
           ...persist === void 0 ? {} : { persist },
-          replayPath: path18,
+          replayPath: path24,
           ...source === "path" || source === "descriptor" ? { selectorUsed: target.selector } : {},
           ...descriptor === void 0 ? {} : { descriptor }
         });
@@ -16674,9 +17475,9 @@ var init_runtime = __esm({
         });
       }
       async queryAllByElementPath(session, pageRef, rawPath) {
-        const path18 = sanitizeReplayElementPath(rawPath);
-        const context = await this.resolvePathContext(session, pageRef, path18.context);
-        return queryAllDomPathInScope(context.index, path18.nodes, context.scope).filter(
+        const path24 = sanitizeReplayElementPath(rawPath);
+        const context = await this.resolvePathContext(session, pageRef, path24.context);
+        return queryAllDomPathInScope(context.index, path24.nodes, context.scope).filter(
           (node) => node.nodeRef !== void 0
         ).map((node) => this.createSnapshotTarget(context.snapshot, node));
       }
@@ -16862,16 +17663,16 @@ var init_runtime = __esm({
         const index = createSnapshotIndex(item.snapshot);
         return this.resolveFirstArrayFieldTargetInNode(index, item.node, field.path);
       }
-      resolveFirstArrayFieldTargetInNode(index, rootNode, path18) {
-        const normalizedPath = sanitizeElementPath(path18);
+      resolveFirstArrayFieldTargetInNode(index, rootNode, path24) {
+        const normalizedPath = sanitizeElementPath(path24);
         const selectors = buildArrayFieldCandidates(normalizedPath);
         if (!selectors.length) {
           return rootNode;
         }
         return resolveFirstWithinNodeBySelectors(index, rootNode, selectors);
       }
-      resolveUniqueArrayFieldTargetInNode(index, rootNode, path18) {
-        const normalizedPath = sanitizeElementPath(path18);
+      resolveUniqueArrayFieldTargetInNode(index, rootNode, path24) {
+        const normalizedPath = sanitizeElementPath(path24);
         const selectors = buildArrayFieldCandidates(normalizedPath);
         if (!selectors.length) {
           return rootNode;
@@ -17703,11 +18504,11 @@ var init_history = __esm({
 });
 async function executeMatchedTlsTransportRequest(input) {
   const binary = await resolveMatchedTlsBinary();
-  const workingDirectory = await promises.mkdtemp(path7__default.default.join(os.tmpdir(), "opensteer-matched-tls-"));
-  const headersPath = path7__default.default.join(workingDirectory, "headers.txt");
-  const bodyPath = path7__default.default.join(workingDirectory, "body.bin");
-  const cookiesPath = path7__default.default.join(workingDirectory, "cookies.txt");
-  const requestBodyPath = path7__default.default.join(workingDirectory, "request-body.bin");
+  const workingDirectory = await promises.mkdtemp(path10__default.default.join(os.tmpdir(), "opensteer-matched-tls-"));
+  const headersPath = path10__default.default.join(workingDirectory, "headers.txt");
+  const bodyPath = path10__default.default.join(workingDirectory, "body.bin");
+  const cookiesPath = path10__default.default.join(workingDirectory, "cookies.txt");
+  const requestBodyPath = path10__default.default.join(workingDirectory, "request-body.bin");
   try {
     await promises.writeFile(cookiesPath, toNetscapeCookieJar(input.cookies ?? []), "utf8");
     if (input.request.body !== void 0) {
@@ -17764,10 +18565,10 @@ async function executeMatchedTlsTransportRequest(input) {
   }
 }
 async function resolveMatchedTlsBinary() {
-  const pathEntries = (process.env.PATH ?? "").split(path7__default.default.delimiter).filter((entry) => entry.length > 0);
+  const pathEntries = (process.env.PATH ?? "").split(path10__default.default.delimiter).filter((entry) => entry.length > 0);
   for (const directory of pathEntries) {
     for (const name of MATCHED_TLS_BINARY_NAMES) {
-      const candidate = path7__default.default.join(directory, name);
+      const candidate = path10__default.default.join(directory, name);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -17775,7 +18576,7 @@ async function resolveMatchedTlsBinary() {
     const files = await readDirSafe(directory);
     const discovered = files.find((file) => file.startsWith("curl_chrome"));
     if (discovered !== void 0) {
-      const candidate = path7__default.default.join(directory, discovered);
+      const candidate = path10__default.default.join(directory, discovered);
       if (await isExecutable(candidate)) {
         return candidate;
       }
@@ -17939,8 +18740,8 @@ function encodeDataPath(tokens) {
   }
   return out;
 }
-function parseDataPath(path18) {
-  const input = path18.trim();
+function parseDataPath(path24) {
+  const input = path24.trim();
   if (input.length === 0) {
     return [];
   }
@@ -17990,8 +18791,8 @@ function parseDataPath(path18) {
 function inflateDataPathObject(flat) {
   let root = {};
   let initialized = false;
-  for (const [path18, value] of Object.entries(flat)) {
-    const tokens = parseDataPath(path18);
+  for (const [path24, value] of Object.entries(flat)) {
+    const tokens = parseDataPath(path24);
     if (!tokens || tokens.length === 0) {
       continue;
     }
@@ -18300,8 +19101,8 @@ function buildVariantDescriptorFromCluster(descriptors) {
     fields: mergedFields
   };
 }
-function minimizePathMatchClauses(path18, mode) {
-  const normalized = sanitizeElementPath(path18);
+function minimizePathMatchClauses(path24, mode) {
+  const normalized = sanitizeElementPath(path24);
   const nodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = node.attrs || {};
@@ -18405,8 +19206,8 @@ function seedMinimalAttrClause(attrs) {
   }
   return null;
 }
-function relaxPathForSingleSample(path18, mode) {
-  const normalized = sanitizeElementPath(path18);
+function relaxPathForSingleSample(path24, mode) {
+  const normalized = sanitizeElementPath(path24);
   const relaxedNodes = normalized.nodes.map((node, index) => {
     const isLast = index === normalized.nodes.length - 1;
     const attrs = normalizeAttrsForSingleSample(node.attrs || {});
@@ -18491,8 +19292,8 @@ function shouldKeepAttrForSingleSample(key) {
   }
   return true;
 }
-function buildPathStructureKey(path18) {
-  const normalized = sanitizeElementPath(path18);
+function buildPathStructureKey(path24) {
+  const normalized = sanitizeElementPath(path24);
   return canonicalJsonString({
     context: (normalized.context || []).map((hop) => ({
       kind: hop.kind,
@@ -18619,30 +19420,30 @@ function buildArrayItemNode(fields) {
   }
   return node;
 }
-function insertNodeAtPath(root, path18, node) {
-  const tokens = parseDataPath(path18);
+function insertNodeAtPath(root, path24, node) {
+  const tokens = parseDataPath(path24);
   if (!tokens || !tokens.length) {
     throw new Error(
-      `Invalid persisted extraction path "${path18}": expected a non-empty object path.`
+      `Invalid persisted extraction path "${path24}": expected a non-empty object path.`
     );
   }
   if (tokens.some((token) => token.kind === "index")) {
     throw new Error(
-      `Invalid persisted extraction path "${path18}": nested array indices are not supported in cached descriptors.`
+      `Invalid persisted extraction path "${path24}": nested array indices are not supported in cached descriptors.`
     );
   }
   let current = root;
   for (let index = 0; index < tokens.length; index += 1) {
     const token = tokens[index];
     if (!token || token.kind !== "prop") {
-      throw new Error(`Invalid persisted extraction path "${path18}": expected object segment.`);
+      throw new Error(`Invalid persisted extraction path "${path24}": expected object segment.`);
     }
     const isLast = index === tokens.length - 1;
     if (isLast) {
       const existing = current[token.key];
       if (existing) {
         throw new Error(
-          `Conflicting persisted extraction path "${path18}" detected while building descriptor tree.`
+          `Conflicting persisted extraction path "${path24}" detected while building descriptor tree.`
         );
       }
       current[token.key] = node;
@@ -18657,7 +19458,7 @@ function insertNodeAtPath(root, path18, node) {
     }
     if (!isPersistedObjectNode(next)) {
       throw new Error(
-        `Conflicting persisted extraction path "${path18}" detected at "${token.key}".`
+        `Conflicting persisted extraction path "${path24}" detected at "${token.key}".`
       );
     }
     current = next;
@@ -18692,7 +19493,7 @@ function buildItemRootForArrayIndex(entries) {
   }
   const paths = entries.map(
     (entry) => isPersistablePathField(entry.source) ? sanitizeElementPath(entry.source.path) : null
-  ).filter((path18) => path18 !== null);
+  ).filter((path24) => path24 !== null);
   if (!paths.length) {
     return null;
   }
@@ -18713,7 +19514,7 @@ function getCommonPathPrefixLength(paths) {
   if (!paths.length) {
     return 0;
   }
-  const nodeChains = paths.map((path18) => path18.nodes);
+  const nodeChains = paths.map((path24) => path24.nodes);
   const minLength = Math.min(...nodeChains.map((nodes) => nodes.length));
   if (!Number.isFinite(minLength) || minLength <= 0) {
     return 0;
@@ -18782,30 +19583,30 @@ function mergeElementPathsByMajority(paths) {
   if (!paths.length) {
     return null;
   }
-  const normalized = paths.map((path18) => sanitizeElementPath(path18));
+  const normalized = paths.map((path24) => sanitizeElementPath(path24));
   const contextKey = pickModeString(
-    normalized.map((path18) => canonicalJsonString(path18.context)),
+    normalized.map((path24) => canonicalJsonString(path24.context)),
     1
   );
   if (!contextKey) {
     return null;
   }
-  const sameContext = normalized.filter((path18) => canonicalJsonString(path18.context) === contextKey);
+  const sameContext = normalized.filter((path24) => canonicalJsonString(path24.context) === contextKey);
   if (!sameContext.length) {
     return null;
   }
   const targetLength = pickModeNumber(
-    sameContext.map((path18) => path18.nodes.length),
+    sameContext.map((path24) => path24.nodes.length),
     1
   ) ?? sameContext[0]?.nodes.length ?? 0;
-  const aligned = sameContext.filter((path18) => path18.nodes.length === targetLength);
+  const aligned = sameContext.filter((path24) => path24.nodes.length === targetLength);
   if (!aligned.length) {
     return null;
   }
   const threshold = majorityThreshold(aligned.length);
   const nodes = [];
   for (let index = 0; index < targetLength; index += 1) {
-    const nodesAtIndex = aligned.map((path18) => path18.nodes[index]).filter((node) => node !== void 0);
+    const nodesAtIndex = aligned.map((path24) => path24.nodes[index]).filter((node) => node !== void 0);
     if (!nodesAtIndex.length) {
       return null;
     }
@@ -19051,8 +19852,8 @@ function clonePathContext(context) {
 function clonePathNodes(nodes) {
   return JSON.parse(JSON.stringify(nodes || []));
 }
-function cloneElementPath2(path18) {
-  return JSON.parse(JSON.stringify(path18));
+function cloneElementPath2(path24) {
+  return JSON.parse(JSON.stringify(path24));
 }
 function clonePersistedOpensteerExtractionNode(node) {
   return JSON.parse(JSON.stringify(node));
@@ -19404,8 +20205,8 @@ function collectPersistedValueNodeRefs(node) {
     return [
       {
         path: sanitizeElementPath(node.$path),
-        replacePath: (path18) => {
-          node.$path = sanitizeElementPath(path18);
+        replacePath: (path24) => {
+          node.$path = sanitizeElementPath(path24);
         }
       }
     ];
@@ -19419,13 +20220,13 @@ function collectPersistedValueNodeRefs(node) {
   }
   return refs;
 }
-function hasPositionClause(path18) {
-  return path18.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
+function hasPositionClause(path24) {
+  return path24.nodes.some((node) => node.match.some((clause) => clause.kind === "position"));
 }
-function stripPositionClauses2(path18) {
+function stripPositionClauses2(path24) {
   return sanitizeElementPath({
-    context: path18.context,
-    nodes: path18.nodes.map((node) => ({
+    context: path24.context,
+    nodes: path24.nodes.map((node) => ({
       ...node,
       match: node.match.filter((clause) => clause.kind !== "position")
     }))
@@ -19745,8 +20546,8 @@ function normalizeNonEmptyString2(name, value) {
 function normalizeKey(value) {
   return String(value ?? "").trim();
 }
-function labelForPath(path18) {
-  return path18.trim().length === 0 ? "$" : path18;
+function labelForPath(path24) {
+  return path24.trim().length === 0 ? "$" : path24;
 }
 function sha256Hex3(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
@@ -22296,11 +23097,11 @@ var init_sandbox = __esm({
       performanceNow() {
         return this.mode === "manual" ? this.manualNow - this.startedAt : (globalThis.performance?.now() ?? 0) - this.performanceStartedAt;
       }
-      setTimeout(callback, delay5 = 0, ...args) {
-        return this.registerTimer(false, callback, delay5, args);
+      setTimeout(callback, delay6 = 0, ...args) {
+        return this.registerTimer(false, callback, delay6, args);
       }
-      setInterval(callback, delay5 = 0, ...args) {
-        return this.registerTimer(true, callback, delay5, args);
+      setInterval(callback, delay6 = 0, ...args) {
+        return this.registerTimer(true, callback, delay6, args);
       }
       clearTimeout(timerId) {
         this.clearTimer(timerId);
@@ -22321,9 +23122,9 @@ var init_sandbox = __esm({
           this.clearTimer(timerId);
         }
       }
-      registerTimer(repeat, callback, delay5, args) {
+      registerTimer(repeat, callback, delay6, args) {
         const timerId = this.nextTimerId++;
-        const normalizedDelay = Math.max(0, delay5);
+        const normalizedDelay = Math.max(0, delay6);
         const record = {
           callback,
           args,
@@ -22422,7 +23223,7 @@ async function pollTask(apiKey, taskId, signal) {
   const deadline = Date.now() + 12e4;
   while (Date.now() < deadline) {
     signal?.throwIfAborted?.();
-    await sleep3(3e3, signal);
+    await sleep4(3e3, signal);
     const response = await fetch(CAPSOLVER_GET_TASK_RESULT_URL, {
       method: "POST",
       headers: {
@@ -22466,7 +23267,7 @@ function extractCaptchaToken(solution) {
 function readString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function sleep3(ms, signal) {
+function sleep4(ms, signal) {
   return new Promise((resolve4, reject) => {
     const timeout = setTimeout(resolve4, ms);
     const abort = () => {
@@ -22525,7 +23326,7 @@ async function pollTask2(apiKey, taskId, signal) {
   const deadline = Date.now() + 12e4;
   while (Date.now() < deadline) {
     signal?.throwIfAborted?.();
-    await sleep4(5e3, signal);
+    await sleep5(5e3, signal);
     const response = await fetch(TWO_CAPTCHA_GET_TASK_RESULT_URL, {
       method: "POST",
       headers: {
@@ -22569,7 +23370,7 @@ function extractCaptchaToken2(solution) {
 function readString2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function sleep4(ms, signal) {
+function sleep5(ms, signal) {
   return new Promise((resolve4, reject) => {
     const timeout = setTimeout(resolve4, ms);
     const abort = () => {
@@ -24061,7 +24862,7 @@ var init_runtime3 = __esm({
         this.workspace = normalizeNamespace2(options.name);
         this.workspaceName = options.workspaceName?.trim() === void 0 || options.workspaceName?.trim().length === 0 ? void 0 : options.workspaceName.trim();
         this.root = options.workspace;
-        this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path7__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
+        this.rootPath = options.workspace?.rootPath ?? options.rootPath ?? path10__default.default.resolve(process.cwd(), ".opensteer", "temporary", crypto.randomUUID());
         this.injectedEngine = options.engine;
         this.engineFactory = options.engineFactory;
         this.policy = options.policy ?? defaultPolicy();
@@ -29077,7 +29878,7 @@ function comparePageIds(left, right) {
   }
   return left.localeCompare(right);
 }
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var FlowRecorderCollector;
@@ -29211,7 +30012,7 @@ var init_event_collector = __esm({
           if (this.loopStopRequested) {
             break;
           }
-          await delay2(this.pollIntervalMs);
+          await delay3(this.pollIntervalMs);
         }
       }
       async readEvaluatedPages(listedPages) {
@@ -30179,7 +30980,7 @@ var init_automation_client = __esm({
         }).catch(() => void 0);
       }
       async ensureConnected() {
-        if (this.socket?.readyState === WebSocket2__default.default.OPEN) {
+        if (this.socket?.readyState === WebSocket4__namespace.default.OPEN) {
           return;
         }
         if (this.connectPromise) {
@@ -30200,7 +31001,7 @@ var init_automation_client = __esm({
         }
         const wsUrl = new URL(grant.url);
         wsUrl.searchParams.set("token", grant.token);
-        const socket = new WebSocket2__default.default(wsUrl);
+        const socket = new WebSocket4__namespace.default(wsUrl);
         this.socket = socket;
         socket.on("message", (data, isBinary) => {
           if (isBinary) {
@@ -30345,7 +31146,7 @@ var init_automation_client = __esm({
         return grant;
       }
       requireSocket() {
-        if (!this.socket || this.socket.readyState !== WebSocket2__default.default.OPEN) {
+        if (!this.socket || this.socket.readyState !== WebSocket4__namespace.default.OPEN) {
           throw new Error("cloud automation socket is not connected");
         }
         return this.socket;
@@ -30503,8 +31304,8 @@ var init_session_proxy = __esm({
         this.workspace = options.workspace;
         this.policy = options.policy ?? defaultPolicy();
         this.observability = options.observability;
-        this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path7__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
-          rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+        this.rootPath = options.rootPath ?? (this.workspace === void 0 ? path10__default.default.join(os.tmpdir(), `${TEMPORARY_CLOUD_WORKSPACE_PREFIX}${crypto.randomUUID()}`) : resolveFilesystemWorkspacePath({
+          rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
           workspace: this.workspace
         }));
         this.cleanupRootOnClose = options.cleanupRootOnClose ?? this.workspace === void 0;
@@ -30956,8 +31757,8 @@ var init_runtime4 = __esm({
     OpensteerRuntime = class extends OpensteerSessionRuntime {
       constructor(options = {}) {
         const publicWorkspace = normalizeWorkspace2(options.workspace);
-        const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path7__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
-          rootDir: path7__default.default.resolve(options.rootDir ?? process.cwd()),
+        const rootPath = options.rootPath ?? (publicWorkspace === void 0 ? path10__default.default.resolve(options.rootDir ?? process.cwd(), ".opensteer", "temporary", crypto.randomUUID()) : resolveFilesystemWorkspacePath({
+          rootDir: path10__default.default.resolve(options.rootDir ?? process.cwd()),
           workspace: publicWorkspace
         }));
         const cleanupRootOnClose = options.cleanupRootOnClose ?? publicWorkspace === void 0;
@@ -31044,7 +31845,7 @@ var init_runtime_resolution = __esm({
   }
 });
 function resolveOpensteerEnvironment(cwd = process.cwd(), baseEnv = process.env) {
-  const resolvedCwd = path7__default.default.resolve(cwd);
+  const resolvedCwd = path10__default.default.resolve(cwd);
   const signature = buildEnvironmentSignature(baseEnv, isOpensteerEnvironmentKey);
   const cached = opensteerEnvironmentCache.get(resolvedCwd);
   if (cached && cached.signature === signature) {
@@ -31058,17 +31859,17 @@ function resolveOpensteerEnvironment(cwd = process.cwd(), baseEnv = process.env)
   return { ...resolved };
 }
 function loadEnvironment(cwd = process.cwd()) {
-  const resolved = resolveEnvironmentFiles(path7__default.default.resolve(cwd), process.env);
+  const resolved = resolveEnvironmentFiles(path10__default.default.resolve(cwd), process.env);
   for (const [key, value] of Object.entries(resolved)) {
     process.env[key] = value;
   }
 }
 function collectDirectories(cwd) {
   const directories = [];
-  let current = path7__default.default.resolve(cwd);
+  let current = path10__default.default.resolve(cwd);
   for (; ; ) {
     directories.unshift(current);
-    const parent = path7__default.default.dirname(current);
+    const parent = path10__default.default.dirname(current);
     if (parent === current) {
       return directories;
     }
@@ -31111,7 +31912,7 @@ function resolveEnvironmentFiles(cwd, baseEnv, predicate) {
   const directories = collectDirectories(cwd);
   for (const directory of directories) {
     for (const filename of ENV_FILENAMES) {
-      const filePath = path7__default.default.join(directory, filename);
+      const filePath = path10__default.default.join(directory, filename);
       if (!fs.existsSync(filePath)) {
         continue;
       }
@@ -31151,6 +31952,52 @@ var init_env = __esm({
   }
 });
 
+// src/local-view/session-control.ts
+var session_control_exports = {};
+__export(session_control_exports, {
+  LocalViewSessionCloseError: () => LocalViewSessionCloseError,
+  closeLocalViewSessionBrowser: () => closeLocalViewSessionBrowser
+});
+async function closeLocalViewSessionBrowser(sessionId) {
+  const manifest = await readLocalViewSessionManifest(sessionId);
+  if (!manifest) {
+    throw new LocalViewSessionCloseError("Session not found.", 404);
+  }
+  if (manifest.ownership !== "owned") {
+    throw new LocalViewSessionCloseError(
+      "Only Opensteer-owned local browsers can be closed from the local view.",
+      409
+    );
+  }
+  const record = await readPersistedLocalBrowserSessionRecord(manifest.rootPath);
+  if (!record || record.pid !== manifest.pid || record.startedAt !== manifest.startedAt || record.engine !== manifest.engine) {
+    await deleteLocalViewSessionManifest(sessionId).catch(() => void 0);
+    throw new LocalViewSessionCloseError("Session not found.", 404);
+  }
+  const manager = new OpensteerBrowserManager({
+    rootPath: manifest.rootPath,
+    ...manifest.workspace === void 0 ? {} : { workspace: manifest.workspace },
+    engineName: record.engine,
+    browser: "persistent"
+  });
+  await manager.close();
+}
+var LocalViewSessionCloseError;
+var init_session_control = __esm({
+  "src/local-view/session-control.ts"() {
+    init_live_session();
+    init_browser_manager();
+    init_session_manifest();
+    LocalViewSessionCloseError = class extends Error {
+      constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "LocalViewSessionCloseError";
+      }
+    };
+  }
+});
+
 // src/sdk/opensteer.ts
 var opensteer_exports = {};
 __export(opensteer_exports, {
@@ -31250,7 +32097,7 @@ function decodeBody(response) {
   }
   return Uint8Array.from(Buffer.from(response.body.data, "base64"));
 }
-function delay4(ms) {
+function delay5(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var SessionCookieJar, Opensteer;
@@ -31432,7 +32279,7 @@ var init_opensteer = __esm({
           if (Date.now() >= timeoutAt) {
             throw new Error("waitForNetwork timed out");
           }
-          await delay4(pollInterval);
+          await delay5(pollInterval);
         }
       }
       async waitForResponse(input) {
@@ -31461,7 +32308,7 @@ var init_opensteer = __esm({
           if (Date.now() >= timeoutAt) {
             throw new Error("waitForPage timed out");
           }
-          await delay4(pollIntervalMs);
+          await delay5(pollIntervalMs);
         }
       }
       async snapshot(mode = "action") {
@@ -31524,7 +32371,7 @@ var init_opensteer = __esm({
 
 // package.json
 var package_default = {
-  version: "0.9.0"};
+  version: "0.9.1"};
 
 // src/cli/bin.ts
 init_browser_manager();
@@ -31547,6 +32394,10 @@ Session:
   open <url> [--workspace <id>] [--headless] [--provider local|cloud]
   close
   status
+  view [--workspace <id>] [--json]
+  view stop [--json]
+  view --auto [--json]
+  view --no-auto [--json]
 
 Navigation:
   goto <url> [--capture-network <label>]
@@ -31671,6 +32522,9 @@ function resolveCommandLength(tokens) {
   if (tokens[0] === "skills") {
     return Math.min(tokens.length, 2);
   }
+  if (tokens[0] === "view") {
+    return Math.min(tokens.length, 2);
+  }
   if (tokens[0] === "status" || tokens[0] === "record" || tokens[0] === "exec") {
     return 1;
   }
@@ -31702,6 +32556,8 @@ var CLI_OPTION_SPECS = {
   copy: { kind: "boolean" },
   all: { kind: "boolean" },
   list: { kind: "boolean" },
+  auto: { kind: "boolean" },
+  "no-auto": { kind: "boolean" },
   "attach-endpoint": { kind: "value" },
   "attach-header": { kind: "value", multiple: true },
   "fresh-tab": { kind: "boolean" },
@@ -31863,6 +32719,14 @@ function parseCommandLine(argv) {
   const json = readOptionalBoolean(rawOptions, "json");
   const agents = rawOptions.get("agent");
   const skills = rawOptions.get("skill");
+  const autoLocalView = readOptionalBoolean(rawOptions, "auto");
+  const noAutoLocalView = readOptionalBoolean(rawOptions, "no-auto");
+  if (autoLocalView === true && noAutoLocalView === true) {
+    throw new Error('Options "--auto" and "--no-auto" cannot be combined.');
+  }
+  if (command[0] !== "view" && (autoLocalView !== void 0 || noAutoLocalView !== void 0)) {
+    throw new Error('Options "--auto" and "--no-auto" are only supported with "view".');
+  }
   const global = readOptionalBoolean(rawOptions, "global");
   const yes = readOptionalBoolean(rawOptions, "yes");
   const copy = readOptionalBoolean(rawOptions, "copy");
@@ -31885,6 +32749,7 @@ function parseCommandLine(argv) {
     ...json === void 0 ? {} : { json },
     ...agents === void 0 ? {} : { agents },
     ...skills === void 0 ? {} : { skills },
+    ...autoLocalView === true ? { localViewMode: "auto" } : noAutoLocalView === true ? { localViewMode: "manual" } : {},
     ...global === void 0 ? {} : { global },
     ...yes === void 0 ? {} : { yes },
     ...copy === void 0 ? {} : { copy },
@@ -32111,7 +32976,7 @@ async function buildOperationInput(operation, parsed, runtime) {
       const capture = readSingle(parsed.rawOptions, "capture");
       const url = readSingle(parsed.rawOptions, "url");
       const hostname = readSingle(parsed.rawOptions, "hostname");
-      const path18 = readSingle(parsed.rawOptions, "path");
+      const path24 = readSingle(parsed.rawOptions, "path");
       const method = readSingle(parsed.rawOptions, "method");
       const status = readOptionalNumber(parsed.rawOptions, "status");
       const resourceType = readSingle(parsed.rawOptions, "type");
@@ -32123,7 +32988,7 @@ async function buildOperationInput(operation, parsed, runtime) {
         ...capture === void 0 ? {} : { capture },
         ...url === void 0 ? {} : { url },
         ...hostname === void 0 ? {} : { hostname },
-        ...path18 === void 0 ? {} : { path: path18 },
+        ...path24 === void 0 ? {} : { path: path24 },
         ...method === void 0 ? {} : { method },
         ...status === void 0 ? {} : { status },
         ...resourceType === void 0 ? {} : { resourceType },
@@ -33214,7 +34079,7 @@ async function runOpensteerRecordCommand(input) {
       workspace: input.workspace,
       startUrl: opened.url
     });
-    await promises.mkdir(path7__default.default.dirname(outputPath), { recursive: true });
+    await promises.mkdir(path10__default.default.dirname(outputPath), { recursive: true });
     await promises.writeFile(outputPath, script, "utf8");
     if (input.closeSession !== void 0) {
       await input.closeSession();
@@ -33249,7 +34114,7 @@ async function runOpensteerCloudRecordCommand(input) {
     workspace: input.workspace
   });
   const client = input.client ?? resolveCloud();
-  const sleep5 = input.sleep ?? delay3;
+  const sleep6 = input.sleep ?? delay4;
   const openUrl = input.openUrl ?? openBrowserUrl;
   let closed = false;
   try {
@@ -33275,12 +34140,12 @@ async function runOpensteerCloudRecordCommand(input) {
       client,
       sessionId,
       ...input.pollIntervalMs === void 0 ? {} : { pollIntervalMs: input.pollIntervalMs },
-      sleep: sleep5
+      sleep: sleep6
     });
     if (completed.result === void 0) {
       throw new Error("Cloud recording completed without a replay script.");
     }
-    await promises.mkdir(path7__default.default.dirname(outputPath), { recursive: true });
+    await promises.mkdir(path10__default.default.dirname(outputPath), { recursive: true });
     await promises.writeFile(outputPath, completed.result.script, "utf8");
     await runtime.close();
     closed = true;
@@ -33298,9 +34163,9 @@ async function runOpensteerCloudRecordCommand(input) {
 }
 function resolveRecordOutputPath(input) {
   if (input.outputPath !== void 0) {
-    return path7__default.default.resolve(input.rootDir, input.outputPath);
+    return path10__default.default.resolve(input.rootDir, input.outputPath);
   }
-  return path7__default.default.join(
+  return path10__default.default.join(
     resolveFilesystemWorkspacePath({
       rootDir: input.rootDir,
       workspace: input.workspace
@@ -33394,7 +34259,7 @@ function formatRecordedAction(action) {
       return `[${time}] reload ${action.pageId}`;
   }
 }
-function delay3(ms) {
+function delay4(ms) {
   return new Promise((resolve4) => {
     setTimeout(resolve4, ms);
   });
@@ -33433,25 +34298,40 @@ function createOpensteerSkillsInvocation(input) {
 function resolveOpensteerSkillsCliPath() {
   const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href)));
   const skillsPackagePath = require2.resolve("skills/package.json");
-  const skillsPackageDir = path7__default.default.dirname(skillsPackagePath);
-  const cliPath = path7__default.default.join(skillsPackageDir, "bin", "cli.mjs");
+  const skillsPackageDir = path10__default.default.dirname(skillsPackagePath);
+  const cliPath = path10__default.default.join(skillsPackageDir, "bin", "cli.mjs");
   if (!fs.existsSync(cliPath)) {
     throw new Error(`skills CLI entrypoint was not found at "${cliPath}".`);
   }
   return cliPath;
 }
 function resolveOpensteerLocalSkillSourcePath() {
-  let ancestor = path7__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
+  let ancestor = path10__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
   for (let index = 0; index < 6; index += 1) {
-    const candidate = path7__default.default.join(ancestor, "skills");
-    const skillManifest = path7__default.default.join(candidate, "opensteer", "SKILL.md");
+    const candidate = path10__default.default.join(ancestor, "skills");
+    const skillManifest = path10__default.default.join(candidate, "opensteer", "SKILL.md");
     if (fs.existsSync(skillManifest)) {
       return candidate;
     }
-    ancestor = path7__default.default.resolve(ancestor, "..");
+    ancestor = path10__default.default.resolve(ancestor, "..");
   }
   throw new Error("Unable to find the packaged Opensteer skill source directory.");
 }
+function resolveOpensteerRepoSkillSourcePath(startDir = process.cwd()) {
+  let currentDir = path10__default.default.resolve(startDir);
+  const filesystemRoot = path10__default.default.parse(currentDir).root;
+  while (true) {
+    const candidate = path10__default.default.join(currentDir, "skills");
+    const skillManifest = path10__default.default.join(candidate, "opensteer", "SKILL.md");
+    if (fs.existsSync(skillManifest)) {
+      return candidate;
+    }
+    if (currentDir === filesystemRoot) {
+      return void 0;
+    }
+    currentDir = path10__default.default.dirname(currentDir);
+  }
+}
 async function checkOpensteerGitHubReachable() {
   try {
     const response = await fetch(`https://github.com/${OPENSTEER_GITHUB_SOURCE}`, {
@@ -33467,13 +34347,14 @@ async function checkOpensteerGitHubReachable() {
 async function runOpensteerSkillsInstaller(options = {}, overrideDeps = {}) {
   const deps = {
     resolveSkillsCliPath: resolveOpensteerSkillsCliPath,
+    resolveRepoSkillSourcePath: resolveOpensteerRepoSkillSourcePath,
     resolveLocalSkillSourcePath: resolveOpensteerLocalSkillSourcePath,
     checkGitHubReachable: checkOpensteerGitHubReachable,
     spawnInvocation: spawnOpensteerSkillsInvocation,
     ...overrideDeps
   };
-  const useGitHub = await deps.checkGitHubReachable();
-  const skillSourcePath = useGitHub ? OPENSTEER_GITHUB_SOURCE : deps.resolveLocalSkillSourcePath();
+  const repoSkillSourcePath = deps.resolveRepoSkillSourcePath();
+  const skillSourcePath = repoSkillSourcePath ?? (await deps.checkGitHubReachable() ? OPENSTEER_GITHUB_SOURCE : deps.resolveLocalSkillSourcePath());
   const invocation = createOpensteerSkillsInvocation({
     options,
     skillsCliPath: deps.resolveSkillsCliPath(),
@@ -33595,7 +34476,7 @@ function describeLocalLane(record, current) {
       summary: "none"
     };
   }
-  const browser = record.executablePath ? path7__default.default.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+  const browser = record.executablePath ? path10__default.default.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
   return {
     provider: "local",
     status: "active",
@@ -33683,6 +34564,1890 @@ async function runExecExpression(context, expression) {
   return fn.call(context);
 }
 
+// src/cli/view.ts
+init_live_session();
+init_process_owner();
+init_preferences();
+
+// src/local-view/discovery.ts
+init_filesystem2();
+init_live_session();
+init_process_owner();
+init_session_manifest();
+
+// src/local-view/resolve-browser-websocket.ts
+init_cdp_discovery();
+async function resolveBrowserWebSocketUrl(record) {
+  if (record.engine === "playwright") {
+    if (!record.endpoint) {
+      throw new Error("Local Playwright session is missing a browser WebSocket endpoint.");
+    }
+    return record.endpoint;
+  }
+  if (!record.remoteDebuggingUrl) {
+    throw new Error("Local ABP session is missing a remote debugging URL.");
+  }
+  const inspected = await inspectCdpEndpoint({
+    endpoint: record.remoteDebuggingUrl,
+    timeoutMs: 5e3
+  });
+  return inspected.endpoint;
+}
+
+// src/local-view/discovery.ts
+async function listResolvedLocalViewSessions() {
+  const manifests = await listLocalViewSessionManifests();
+  const resolved = await Promise.all(manifests.map((manifest) => resolveSessionSummary(manifest)));
+  return resolved.filter((session) => session !== void 0).sort(
+    (left, right) => right.startedAt - left.startedAt || left.label.localeCompare(right.label)
+  );
+}
+async function resolveLocalViewSession(sessionId) {
+  const manifest = await readLocalViewSessionManifest(sessionId);
+  if (!manifest) {
+    return void 0;
+  }
+  return readResolvedLocalViewSession(manifest);
+}
+async function resolveSessionSummary(manifest) {
+  const record = await readLiveRecord(manifest);
+  if (!record) {
+    await deleteLocalViewSessionManifest(manifest.sessionId);
+    return void 0;
+  }
+  const browserName = record.executablePath ? path10__default.default.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+  return {
+    sessionId: manifest.sessionId,
+    label: manifest.workspace ?? (path10__default.default.basename(manifest.rootPath) || manifest.sessionId),
+    status: isProcessRunning(record.pid) ? "live" : "stale",
+    ...manifest.workspace === void 0 ? {} : { workspace: manifest.workspace },
+    rootPath: manifest.rootPath,
+    engine: record.engine,
+    ownership: manifest.ownership,
+    pid: record.pid,
+    startedAt: record.startedAt,
+    ...browserName === void 0 ? {} : { browserName }
+  };
+}
+async function readResolvedLocalViewSession(manifest) {
+  const record = await readLiveRecord(manifest);
+  if (!record) {
+    await deleteLocalViewSessionManifest(manifest.sessionId);
+    return void 0;
+  }
+  const browserWebSocketUrl = await resolveBrowserWebSocketUrl(record).catch(() => void 0);
+  if (!browserWebSocketUrl) {
+    return void 0;
+  }
+  return {
+    manifest,
+    record,
+    browserWebSocketUrl
+  };
+}
+async function readLiveRecord(manifest) {
+  if (!await pathExists(manifest.rootPath)) {
+    return void 0;
+  }
+  const record = await readPersistedLocalBrowserSessionRecord(manifest.rootPath);
+  if (!record) {
+    return void 0;
+  }
+  if (record.pid !== manifest.pid || record.startedAt !== manifest.startedAt || !isProcessRunning(record.pid)) {
+    return void 0;
+  }
+  return record;
+}
+
+// src/local-view/runtime-state.ts
+var LocalViewRuntimeState = class {
+  activationIntentBySessionId = /* @__PURE__ */ new Map();
+  setPageActivationIntent(sessionId, targetId) {
+    this.activationIntentBySessionId.set(sessionId, {
+      targetId,
+      ts: Date.now()
+    });
+  }
+  getPageActivationIntent(sessionId) {
+    return this.activationIntentBySessionId.get(sessionId);
+  }
+  clearPageActivationIntent(sessionId, targetId) {
+    const current = this.activationIntentBySessionId.get(sessionId);
+    if (!current) {
+      return;
+    }
+    if (targetId !== void 0 && current.targetId !== targetId) {
+      return;
+    }
+    this.activationIntentBySessionId.delete(sessionId);
+  }
+};
+var LocalViewWebSocketServer = WebSocket4__namespace.WebSocketServer;
+
+// src/local-view/cdp-proxy.ts
+var DEFAULT_MAX_PENDING_CLIENT_BUFFER_BYTES = 1e6;
+var DEFAULT_UPSTREAM_OPEN_TIMEOUT_MS = 1e4;
+var LocalViewCdpProxy = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.wss = new LocalViewWebSocketServer({ noServer: true });
+    this.createUpstreamSocket = deps.createUpstreamSocket ?? ((url) => new WebSocket4__namespace.default(url));
+    this.maxPendingClientBufferBytes = deps.maxPendingClientBufferBytes ?? DEFAULT_MAX_PENDING_CLIENT_BUFFER_BYTES;
+    this.upstreamOpenTimeoutMs = deps.upstreamOpenTimeoutMs ?? DEFAULT_UPSTREAM_OPEN_TIMEOUT_MS;
+  }
+  wss;
+  createUpstreamSocket;
+  maxPendingClientBufferBytes;
+  upstreamOpenTimeoutMs;
+  handleUpgrade(req, socket, head) {
+    const url = new URL(req.url || "/", "http://localhost");
+    const parts = url.pathname.split("/").filter(Boolean);
+    const isCdpPath = parts.length === 3 && parts[0] === "ws" && parts[1] === "cdp";
+    if (!isCdpPath) {
+      socket.destroy();
+      return;
+    }
+    const sessionId = parts[2];
+    this.wss.handleUpgrade(req, socket, head, (clientSocket) => {
+      void this.bindProxy(clientSocket, sessionId).catch(() => {
+        safeCloseSocket(clientSocket);
+      });
+    });
+  }
+  close() {
+    for (const client of this.wss.clients) {
+      safeCloseSocket(client);
+    }
+    this.wss.close();
+  }
+  async bindProxy(clientSocket, sessionId) {
+    const resolved = await resolveLocalViewSession(sessionId);
+    if (!resolved) {
+      safeCloseSocket(clientSocket);
+      return;
+    }
+    const upstream = this.createUpstreamSocket(resolved.browserWebSocketUrl);
+    const pendingCreateTargetCommandIds = /* @__PURE__ */ new Set();
+    const pendingAttachTargetCommandTargetIds = /* @__PURE__ */ new Map();
+    const targetIdByAttachedSessionId = /* @__PURE__ */ new Map();
+    const pendingClientMessages = [];
+    let pendingClientBufferBytes = 0;
+    let closed = false;
+    let upstreamOpenTimeout = null;
+    const closeConnection = () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      if (upstreamOpenTimeout) {
+        clearTimeout(upstreamOpenTimeout);
+        upstreamOpenTimeout = null;
+      }
+      pendingClientMessages.length = 0;
+      pendingClientBufferBytes = 0;
+      safeCloseSocket(upstream);
+      safeCloseSocket(clientSocket);
+    };
+    upstreamOpenTimeout = setTimeout(() => {
+      if (upstream.readyState === WebSocket4__namespace.default.OPEN) {
+        return;
+      }
+      closeConnection();
+    }, this.upstreamOpenTimeoutMs);
+    clientSocket.on("message", (data, isBinary) => {
+      const outboundData = data;
+      if (!isBinary) {
+        const message = parseCdpProtocolMessage(data);
+        if (message) {
+          const activatedTargetId = readActivateTargetCommandTargetId(message);
+          if (activatedTargetId) {
+            this.deps.runtimeState.setPageActivationIntent(sessionId, activatedTargetId);
+          }
+          const createTargetCommandId = readCreateTargetCommandId(message);
+          if (createTargetCommandId !== null) {
+            pendingCreateTargetCommandIds.add(createTargetCommandId);
+          }
+          const attachTargetCommand = readAttachTargetCommand(message);
+          if (attachTargetCommand) {
+            pendingAttachTargetCommandTargetIds.set(
+              attachTargetCommand.id,
+              attachTargetCommand.targetId
+            );
+          }
+          const interactionTargetId = readInteractionTargetId(message, targetIdByAttachedSessionId);
+          if (interactionTargetId) {
+            this.deps.runtimeState.setPageActivationIntent(sessionId, interactionTargetId);
+          }
+        }
+      }
+      if (upstream.readyState === WebSocket4__namespace.default.OPEN) {
+        upstream.send(outboundData, { binary: isBinary });
+        return;
+      }
+      if (upstream.readyState !== WebSocket4__namespace.default.CONNECTING) {
+        closeConnection();
+        return;
+      }
+      const sizeBytes = rawDataSizeBytes(outboundData);
+      if (pendingClientBufferBytes + sizeBytes > this.maxPendingClientBufferBytes) {
+        closeConnection();
+        return;
+      }
+      pendingClientMessages.push({ data: outboundData, isBinary });
+      pendingClientBufferBytes += sizeBytes;
+    });
+    upstream.on("open", () => {
+      if (upstreamOpenTimeout) {
+        clearTimeout(upstreamOpenTimeout);
+        upstreamOpenTimeout = null;
+      }
+      for (const pendingMessage of pendingClientMessages.splice(0)) {
+        upstream.send(pendingMessage.data, { binary: pendingMessage.isBinary });
+      }
+      pendingClientBufferBytes = 0;
+    });
+    upstream.on("message", (data, isBinary) => {
+      if (!isBinary) {
+        const message = parseCdpProtocolMessage(data);
+        if (message) {
+          const createdTargetId = readCreateTargetResultTargetId(
+            message,
+            pendingCreateTargetCommandIds
+          );
+          if (createdTargetId) {
+            this.deps.runtimeState.setPageActivationIntent(sessionId, createdTargetId);
+          }
+          const attachedTarget = readAttachTargetResult(
+            message,
+            pendingAttachTargetCommandTargetIds
+          );
+          if (attachedTarget) {
+            targetIdByAttachedSessionId.set(attachedTarget.sessionId, attachedTarget.targetId);
+          }
+          const detachedSessionId = readDetachedTargetSessionId(message);
+          if (detachedSessionId) {
+            targetIdByAttachedSessionId.delete(detachedSessionId);
+          }
+        }
+      }
+      if (clientSocket.readyState === WebSocket4__namespace.default.OPEN) {
+        clientSocket.send(data, { binary: isBinary });
+      }
+    });
+    clientSocket.on("close", closeConnection);
+    clientSocket.on("error", closeConnection);
+    upstream.on("close", closeConnection);
+    upstream.on("error", closeConnection);
+  }
+};
+function parseCdpProtocolMessage(data) {
+  try {
+    const parsed = JSON.parse(rawDataToString(data));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readCreateTargetCommandId(message) {
+  return message.method === "Target.createTarget" && typeof message.id === "number" ? message.id : null;
+}
+function readCreateTargetResultTargetId(message, pendingCommandIds) {
+  if (typeof message.id !== "number" || !pendingCommandIds.has(message.id)) {
+    return null;
+  }
+  pendingCommandIds.delete(message.id);
+  const targetId = message.result?.targetId;
+  return typeof targetId === "string" && targetId.length > 0 ? targetId : null;
+}
+function readActivateTargetCommandTargetId(message) {
+  const targetId = message.method === "Target.activateTarget" ? message.params?.targetId : void 0;
+  return typeof targetId === "string" && targetId.length > 0 ? targetId : null;
+}
+function readAttachTargetCommand(message) {
+  if (message.method !== "Target.attachToTarget" || typeof message.id !== "number") {
+    return null;
+  }
+  const targetId = message.params?.targetId;
+  if (typeof targetId !== "string" || targetId.length === 0) {
+    return null;
+  }
+  return {
+    id: message.id,
+    targetId
+  };
+}
+function readAttachTargetResult(message, pendingTargetIds) {
+  if (typeof message.id !== "number") {
+    return null;
+  }
+  const targetId = pendingTargetIds.get(message.id);
+  if (!targetId) {
+    return null;
+  }
+  pendingTargetIds.delete(message.id);
+  const sessionId = message.result?.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    return null;
+  }
+  return {
+    sessionId,
+    targetId
+  };
+}
+function readInteractionTargetId(message, targetIdByAttachedSessionId) {
+  const sessionId = message.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    return null;
+  }
+  if (!message.method || !message.method.startsWith("Input.") && !message.method.startsWith("Page.")) {
+    return null;
+  }
+  return targetIdByAttachedSessionId.get(sessionId) ?? null;
+}
+function readDetachedTargetSessionId(message) {
+  if (message.method !== "Target.detachedFromTarget") {
+    return null;
+  }
+  const sessionId = message.params?.sessionId;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+function rawDataToString(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("utf8");
+  }
+  if (Array.isArray(data)) {
+    return Buffer.concat(data).toString("utf8");
+  }
+  return data.toString("utf8");
+}
+function rawDataSizeBytes(data) {
+  if (typeof data === "string") {
+    return Buffer.byteLength(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data.byteLength;
+  }
+  if (Array.isArray(data)) {
+    return data.reduce((total, entry) => total + entry.byteLength, 0);
+  }
+  return data.byteLength;
+}
+function safeCloseSocket(socket) {
+  try {
+    socket.close();
+  } catch {
+  }
+}
+
+// src/local-view/server.ts
+init_process_owner();
+init_service_state();
+init_service_state();
+
+// src/local-view/tab-state-tracker.ts
+var ACTIVATION_INTENT_DISCOVERY_GRACE_MS = 2e3;
+var TabStateTracker = class {
+  deps;
+  timer = null;
+  running = false;
+  lastActivePage = null;
+  lastTabsSignature = "";
+  tickInFlight = false;
+  metadataByPage = /* @__PURE__ */ new Map();
+  targetIdByPage = /* @__PURE__ */ new WeakMap();
+  pageCleanupByPage = /* @__PURE__ */ new Map();
+  boundContextCleanup = null;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.bindContextEvents();
+    void this.reconcile({
+      includeFocus: true,
+      refreshMetadata: true
+    });
+  }
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.boundContextCleanup?.();
+    this.boundContextCleanup = null;
+    for (const cleanup of this.pageCleanupByPage.values()) {
+      cleanup();
+    }
+    this.pageCleanupByPage.clear();
+    this.metadataByPage.clear();
+  }
+  bindContextEvents() {
+    if (this.boundContextCleanup) {
+      this.syncTrackedPages(this.deps.browserContext.pages());
+      this.updatePolling(this.deps.browserContext.pages().length);
+      return;
+    }
+    const onPage = (page) => {
+      this.syncTrackedPages(this.deps.browserContext.pages());
+      this.updatePolling(this.deps.browserContext.pages().length);
+      this.attachPageListeners(page);
+      void this.reconcile({
+        includeFocus: true,
+        refreshMetadata: true
+      });
+    };
+    this.deps.browserContext.on("page", onPage);
+    this.boundContextCleanup = () => {
+      this.deps.browserContext.off("page", onPage);
+    };
+    this.syncTrackedPages(this.deps.browserContext.pages());
+    this.updatePolling(this.deps.browserContext.pages().length);
+  }
+  syncTrackedPages(pages) {
+    const nextPages = new Set(pages);
+    for (const [page, cleanup] of this.pageCleanupByPage.entries()) {
+      if (nextPages.has(page)) {
+        continue;
+      }
+      cleanup();
+      this.pageCleanupByPage.delete(page);
+      this.metadataByPage.delete(page);
+    }
+    for (const page of pages) {
+      this.attachPageListeners(page);
+    }
+  }
+  attachPageListeners(page) {
+    if (this.pageCleanupByPage.has(page)) {
+      return;
+    }
+    const refreshMetadata = () => {
+      void this.reconcile({
+        includeFocus: false,
+        refreshMetadata: true
+      });
+    };
+    const handleClose = () => {
+      this.pageCleanupByPage.get(page)?.();
+      this.pageCleanupByPage.delete(page);
+      this.metadataByPage.delete(page);
+      void this.reconcile({
+        includeFocus: true,
+        refreshMetadata: true
+      });
+    };
+    page.on("close", handleClose);
+    page.on("domcontentloaded", refreshMetadata);
+    page.on("load", refreshMetadata);
+    page.on("framenavigated", refreshMetadata);
+    this.pageCleanupByPage.set(page, () => {
+      page.off("close", handleClose);
+      page.off("domcontentloaded", refreshMetadata);
+      page.off("load", refreshMetadata);
+      page.off("framenavigated", refreshMetadata);
+    });
+  }
+  updatePolling(pageCount) {
+    const shouldPoll = this.running && pageCount > 0;
+    if (!shouldPoll) {
+      if (this.timer) {
+        clearInterval(this.timer);
+        this.timer = null;
+      }
+      return;
+    }
+    if (this.timer) {
+      return;
+    }
+    this.timer = setInterval(() => {
+      const trackedPageCount = this.deps.browserContext.pages().length;
+      void this.reconcile({
+        includeFocus: trackedPageCount > 1,
+        refreshMetadata: true
+      });
+    }, this.deps.pollMs);
+  }
+  async reconcile(args) {
+    if (!this.running || this.tickInFlight) {
+      return;
+    }
+    this.tickInFlight = true;
+    try {
+      this.bindContextEvents();
+      const pages = this.deps.browserContext.pages();
+      this.syncTrackedPages(pages);
+      this.updatePolling(pages.length);
+      const preferredActivePage = this.lastActivePage ?? pages[0] ?? null;
+      const pageStates = await Promise.all(
+        pages.map(async (page, index) => {
+          const metadata = await this.readPageMetadata(page, {
+            refresh: args.refreshMetadata
+          });
+          const focusState = args.includeFocus ? await this.readFocusState(page) : {
+            isVisible: page === preferredActivePage,
+            hasFocus: page === preferredActivePage
+          };
+          return {
+            page,
+            index,
+            targetId: metadata.targetId,
+            url: page.url(),
+            title: metadata.title,
+            isVisible: focusState.isVisible,
+            hasFocus: focusState.hasFocus
+          };
+        })
+      );
+      const activePage = this.pickActivePage(
+        pageStates,
+        this.lastActivePage,
+        preferredActivePage,
+        this.resolveIntentPage(pageStates)
+      );
+      if (activePage && activePage !== this.lastActivePage) {
+        this.lastActivePage = activePage;
+        this.deps.onActivePageChanged(activePage);
+      }
+      const tabs = pageStates.map((state) => ({
+        index: state.index,
+        ...state.targetId === void 0 ? {} : { targetId: state.targetId },
+        url: state.url,
+        title: state.title,
+        active: activePage ? state.page === activePage : false
+      }));
+      const activeTabIndex = tabs.findIndex((tab) => tab.active);
+      const signature = JSON.stringify({
+        activeTabIndex,
+        tabs: tabs.map((tab) => ({
+          index: tab.index,
+          targetId: tab.targetId,
+          url: tab.url,
+          title: tab.title,
+          active: tab.active
+        }))
+      });
+      if (signature !== this.lastTabsSignature) {
+        this.lastTabsSignature = signature;
+        this.deps.onTabsChanged({
+          tabs,
+          activeTabIndex
+        });
+      }
+    } finally {
+      this.tickInFlight = false;
+    }
+  }
+  async readPageMetadata(page, options) {
+    const cached = this.metadataByPage.get(page);
+    if (cached && !options.refresh) {
+      return cached;
+    }
+    const [title, targetId] = await Promise.all([
+      page.title().catch(() => cached?.title ?? ""),
+      this.resolveTargetId(page).catch(() => cached?.targetId)
+    ]);
+    const nextMetadata = {
+      title,
+      targetId: targetId ?? void 0
+    };
+    this.metadataByPage.set(page, nextMetadata);
+    return nextMetadata;
+  }
+  async resolveTargetId(page) {
+    const cached = this.targetIdByPage.get(page);
+    if (cached) {
+      return cached;
+    }
+    const cdp = await page.context().newCDPSession(page);
+    try {
+      const result = await cdp.send("Target.getTargetInfo");
+      const targetId = result?.targetInfo?.targetId;
+      if (typeof targetId === "string" && targetId.length > 0) {
+        this.targetIdByPage.set(page, targetId);
+        return targetId;
+      }
+      return null;
+    } finally {
+      await cdp.detach().catch(() => void 0);
+    }
+  }
+  async readFocusState(page) {
+    try {
+      const result = await page.evaluate(() => ({
+        visibilityState: globalThis.document?.visibilityState,
+        hasFocus: globalThis.document?.hasFocus?.() ?? false
+      }));
+      return {
+        isVisible: result.visibilityState === "visible",
+        hasFocus: result.hasFocus === true
+      };
+    } catch {
+      return {
+        isVisible: false,
+        hasFocus: false
+      };
+    }
+  }
+  pickActivePage(pageStates, lastActivePage, fallbackPage, intent) {
+    if (intent) {
+      return intent.page;
+    }
+    const focusedVisiblePages = pageStates.filter((state) => state.isVisible && state.hasFocus);
+    if (focusedVisiblePages.length === 1) {
+      return focusedVisiblePages[0]?.page ?? null;
+    }
+    const visiblePages = pageStates.filter((state) => state.isVisible);
+    if (visiblePages.length === 1) {
+      return visiblePages[0]?.page ?? null;
+    }
+    const lastActivePageState = lastActivePage ? pageStates.find((state) => state.page === lastActivePage) ?? null : null;
+    if (lastActivePageState && (focusedVisiblePages.length > 1 && lastActivePageState.isVisible && lastActivePageState.hasFocus || visiblePages.length > 1 && lastActivePageState.isVisible || visiblePages.length === 0)) {
+      return lastActivePage;
+    }
+    const fallbackPageState = fallbackPage ? pageStates.find((state) => state.page === fallbackPage) ?? null : null;
+    if (fallbackPageState && (focusedVisiblePages.length > 1 && fallbackPageState.isVisible && fallbackPageState.hasFocus || visiblePages.length > 1 && fallbackPageState.isVisible)) {
+      return fallbackPage;
+    }
+    if (focusedVisiblePages.length > 0) {
+      return focusedVisiblePages[0]?.page ?? null;
+    }
+    if (visiblePages.length > 0) {
+      return visiblePages[0]?.page ?? null;
+    }
+    if (lastActivePageState) {
+      return lastActivePageState.page;
+    }
+    if (fallbackPageState) {
+      return fallbackPageState.page;
+    }
+    return pageStates[0]?.page ?? null;
+  }
+  resolveIntentPage(pageStates) {
+    const intent = this.deps.runtimeState.getPageActivationIntent(this.deps.sessionId);
+    if (!intent) {
+      return null;
+    }
+    const matched = pageStates.find((state) => state.targetId === intent.targetId);
+    if (!matched) {
+      if (Date.now() - intent.ts > ACTIVATION_INTENT_DISCOVERY_GRACE_MS) {
+        this.deps.runtimeState.clearPageActivationIntent(this.deps.sessionId, intent.targetId);
+      }
+      return null;
+    }
+    this.deps.runtimeState.clearPageActivationIntent(this.deps.sessionId, intent.targetId);
+    return { page: matched.page };
+  }
+};
+
+// src/local-view/view-stream-capture-policy.ts
+var MIN_CAPTURE_DIMENSION_PX = 100;
+var MAX_CAPTURE_DIMENSION_PX = 8192;
+var CAPTURE_BUCKET_PX = 64;
+function selectScreencastSize(args) {
+  const viewport = normalizeViewport(args.viewport);
+  if (!viewport) {
+    return null;
+  }
+  let maxRequestedWidth = 0;
+  let maxRequestedHeight = 0;
+  for (const requestedSize of args.requestedSizes) {
+    const normalized = normalizeRequestedSize(requestedSize);
+    if (!normalized) {
+      return null;
+    }
+    maxRequestedWidth = Math.max(maxRequestedWidth, normalized.width);
+    maxRequestedHeight = Math.max(maxRequestedHeight, normalized.height);
+  }
+  if (maxRequestedWidth < MIN_CAPTURE_DIMENSION_PX || maxRequestedHeight < MIN_CAPTURE_DIMENSION_PX) {
+    return null;
+  }
+  const desiredScale = Math.max(
+    maxRequestedWidth / viewport.width,
+    maxRequestedHeight / viewport.height
+  );
+  if (desiredScale >= 1) {
+    return viewport;
+  }
+  const landscape = viewport.width >= viewport.height;
+  const sourcePrimary = landscape ? viewport.width : viewport.height;
+  const sourceSecondary = landscape ? viewport.height : viewport.width;
+  const nextPrimary = bucketDimension(sourcePrimary * desiredScale);
+  const nextSecondary = clampDimension(Math.round(nextPrimary / sourcePrimary * sourceSecondary));
+  if (!nextSecondary) {
+    return null;
+  }
+  return landscape ? { width: nextPrimary, height: nextSecondary } : { width: nextSecondary, height: nextPrimary };
+}
+function normalizeViewport(viewport) {
+  const width = clampDimension(viewport.width);
+  const height = clampDimension(viewport.height);
+  return width && height ? { width, height } : null;
+}
+function normalizeRequestedSize(requestedSize) {
+  const width = clampDimension(requestedSize.width);
+  const height = clampDimension(requestedSize.height);
+  return width && height ? { width, height } : null;
+}
+function clampDimension(value) {
+  if (!Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.floor(value);
+  if (normalized < MIN_CAPTURE_DIMENSION_PX) {
+    return null;
+  }
+  return Math.min(MAX_CAPTURE_DIMENSION_PX, normalized);
+}
+function bucketDimension(value) {
+  const bucketed = Math.ceil(Math.max(MIN_CAPTURE_DIMENSION_PX, value) / CAPTURE_BUCKET_PX) * CAPTURE_BUCKET_PX;
+  return Math.min(MAX_CAPTURE_DIMENSION_PX, bucketed);
+}
+function buildHelloMessage(args) {
+  return {
+    type: "hello",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    mimeType: "image/jpeg",
+    fps: args.fps,
+    quality: args.quality,
+    viewport: args.viewport
+  };
+}
+function buildTabsMessage(args) {
+  return {
+    type: "tabs",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    tabs: args.tabs,
+    activeTabIndex: args.activeTabIndex
+  };
+}
+function buildStatusMessage(args) {
+  return {
+    type: "status",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    status: args.status
+  };
+}
+function buildErrorMessage(args) {
+  return {
+    type: "error",
+    sessionId: args.sessionId,
+    ts: Date.now(),
+    error: args.error
+  };
+}
+function sendControlMessage(ws, message) {
+  if (ws.readyState !== WebSocket4__namespace.default.OPEN) {
+    return;
+  }
+  try {
+    ws.send(JSON.stringify(message), { binary: false });
+  } catch {
+  }
+}
+function parseViewClientMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.type !== "stream-config") {
+      return null;
+    }
+    const renderWidth = normalizeRenderDimension(parsed.renderWidth);
+    const renderHeight = normalizeRenderDimension(parsed.renderHeight);
+    if (renderWidth === null || renderHeight === null) {
+      return null;
+    }
+    return {
+      type: "stream-config",
+      renderWidth,
+      renderHeight
+    };
+  } catch {
+    return null;
+  }
+}
+function normalizeRenderDimension(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.floor(value);
+  if (normalized < 100) {
+    return null;
+  }
+  return Math.min(8192, normalized);
+}
+
+// src/local-view/view-stream.ts
+var INITIAL_FRAME_CAPTURE_ATTEMPTS = 3;
+var INITIAL_FRAME_CAPTURE_RETRY_DELAY_MS = 150;
+var TAB_STATE_POLL_MS = 1e3;
+var CLIENT_FRAME_FLUSH_RETRY_MS = 16;
+var LocalViewStreamHub = class {
+  deps;
+  producers = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.deps = deps;
+  }
+  attachClient(sessionId, ws) {
+    let producer = this.producers.get(sessionId);
+    if (!producer) {
+      producer = new SessionViewStreamProducer({
+        sessionId,
+        runtimeState: this.deps.runtimeState,
+        maxFps: this.deps.maxFps,
+        quality: this.deps.quality,
+        maxClientBufferBytes: this.deps.maxClientBufferBytes,
+        onDrained: () => {
+          this.producers.delete(sessionId);
+        }
+      });
+      this.producers.set(sessionId, producer);
+    }
+    producer.addClient(ws);
+  }
+};
+var SessionViewStreamProducer = class {
+  deps;
+  clients = /* @__PURE__ */ new Set();
+  clientStateBySocket = /* @__PURE__ */ new Map();
+  frameIntervalMs;
+  tracker = null;
+  browser = null;
+  browserDisconnectedHandler = null;
+  context = null;
+  cdpSession = null;
+  screencastHandler = null;
+  pageLifecycleCleanup = null;
+  activePage = null;
+  activeViewport = null;
+  activeScreencastSizeKey = null;
+  pendingFrameAckTimer = null;
+  starting = null;
+  started = false;
+  rebinding = Promise.resolve();
+  stopped = false;
+  lastFrameSentAt = 0;
+  lastFrameBuffer = null;
+  lastTabsPayload = null;
+  constructor(deps) {
+    this.deps = deps;
+    this.frameIntervalMs = Math.max(1, Math.floor(1e3 / Math.max(1, deps.maxFps)));
+  }
+  addClient(ws) {
+    if (this.stopped) {
+      ws.close(1011, "View stream is unavailable.");
+      return;
+    }
+    this.clients.add(ws);
+    this.clientStateBySocket.set(ws, {
+      requestedRenderSize: null,
+      frameSendInFlight: false,
+      pendingFrameBuffer: null,
+      pendingFlushTimer: null
+    });
+    if (this.activeViewport) {
+      sendControlMessage(
+        ws,
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport: this.activeViewport
+        })
+      );
+    }
+    if (this.lastTabsPayload) {
+      sendControlMessage(
+        ws,
+        buildTabsMessage({
+          sessionId: this.deps.sessionId,
+          tabs: this.lastTabsPayload.tabs,
+          activeTabIndex: this.lastTabsPayload.activeTabIndex
+        })
+      );
+    }
+    if (this.lastFrameBuffer) {
+      const queued = this.enqueueFrameForClient(ws, this.lastFrameBuffer);
+      if (!queued) {
+        this.removeClient(ws);
+        return;
+      }
+    }
+    ws.on("close", () => {
+      this.removeClient(ws);
+    });
+    ws.on("error", () => {
+      this.removeClient(ws);
+    });
+    ws.on("message", (raw, isBinary) => {
+      if (isBinary) {
+        return;
+      }
+      const message = parseViewClientMessage(readTextFrame(raw));
+      if (message?.type !== "stream-config") {
+        return;
+      }
+      const nextSize = {
+        width: message.renderWidth,
+        height: message.renderHeight
+      };
+      const clientState = this.clientStateBySocket.get(ws);
+      if (!clientState) {
+        return;
+      }
+      const priorSize = clientState.requestedRenderSize;
+      if (priorSize?.width === nextSize.width && priorSize?.height === nextSize.height) {
+        return;
+      }
+      clientState.requestedRenderSize = nextSize;
+      this.maybeRebindForStreamConfigChange();
+    });
+    void this.ensureStarted();
+  }
+  maybeRebindForStreamConfigChange() {
+    if (!this.activePage || !this.started || this.stopped) {
+      return;
+    }
+    const nextSizeKey = this.getRequestedScreencastSizeKey();
+    if (nextSizeKey === this.activeScreencastSizeKey) {
+      return;
+    }
+    void this.queueBindToPage(this.activePage, { force: true }).catch(() => void 0);
+  }
+  removeClient(ws) {
+    this.clients.delete(ws);
+    const clientState = this.clientStateBySocket.get(ws);
+    if (clientState?.pendingFlushTimer) {
+      clearTimeout(clientState.pendingFlushTimer);
+    }
+    this.clientStateBySocket.delete(ws);
+    if (this.clients.size === 0) {
+      void this.stop();
+      return;
+    }
+    this.maybeRebindForStreamConfigChange();
+  }
+  async ensureStarted() {
+    if (this.stopped || this.started) {
+      return;
+    }
+    if (this.starting) {
+      return this.starting;
+    }
+    this.starting = this.start().then(() => {
+      if (!this.stopped) {
+        this.started = true;
+      }
+    }).finally(() => {
+      this.starting = null;
+    });
+    try {
+      await this.starting;
+    } catch {
+      this.broadcastControl(
+        buildErrorMessage({
+          sessionId: this.deps.sessionId,
+          error: "Failed to start live browser stream."
+        })
+      );
+      this.closeAllClients(1011, "View stream failed");
+      await this.stop();
+    }
+  }
+  async start() {
+    const session = await this.connectSession();
+    this.broadcastControl(
+      buildStatusMessage({
+        sessionId: this.deps.sessionId,
+        status: "starting"
+      })
+    );
+    this.browser = session.browser;
+    this.browserDisconnectedHandler = () => {
+      if (this.stopped) {
+        return;
+      }
+      this.browserDisconnectedHandler = null;
+      this.broadcastControl(
+        buildErrorMessage({
+          sessionId: this.deps.sessionId,
+          error: "Live browser stream disconnected."
+        })
+      );
+      this.closeAllClients(1011, "View stream failed");
+      void this.stop();
+    };
+    this.browser.once("disconnected", this.browserDisconnectedHandler);
+    this.context = session.context;
+    this.activePage = session.page;
+    this.activeViewport = await readViewportForPage(session.page);
+    if (this.stopped) {
+      return;
+    }
+    if (this.activeViewport) {
+      this.broadcastControl(
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport: this.activeViewport
+        })
+      );
+    }
+    this.tracker = new TabStateTracker({
+      browserContext: session.context,
+      sessionId: this.deps.sessionId,
+      pollMs: TAB_STATE_POLL_MS,
+      runtimeState: this.deps.runtimeState,
+      onActivePageChanged: (page) => {
+        this.activePage = page;
+        void this.queueBindToPage(page).catch(() => void 0);
+      },
+      onTabsChanged: ({ tabs, activeTabIndex }) => {
+        this.lastTabsPayload = { tabs, activeTabIndex };
+        this.broadcastControl(
+          buildTabsMessage({
+            sessionId: this.deps.sessionId,
+            tabs,
+            activeTabIndex
+          })
+        );
+      }
+    });
+    this.tracker.start();
+    await this.queueBindToPage(session.page);
+    if (this.stopped) {
+      return;
+    }
+    this.broadcastControl(
+      buildStatusMessage({
+        sessionId: this.deps.sessionId,
+        status: "live"
+      })
+    );
+  }
+  queueBindToPage(page, options = {}) {
+    this.rebinding = this.rebinding.catch(() => void 0).then(() => this.bindToPage(page, options));
+    return this.rebinding;
+  }
+  async bindToPage(page, options = {}) {
+    if (this.stopped) {
+      return;
+    }
+    const requestedSizeKey = this.getRequestedScreencastSizeKey();
+    if (!options.force && this.activePage === page && this.cdpSession && this.activeScreencastSizeKey === requestedSizeKey) {
+      return;
+    }
+    await this.stopScreencast();
+    if (this.stopped) {
+      return;
+    }
+    const context = this.context;
+    if (!context) {
+      throw new Error("Browser context is unavailable.");
+    }
+    const requestedSize = this.getRequestedScreencastSize();
+    this.activePage = page;
+    this.activeScreencastSizeKey = requestedSizeKey;
+    this.activeViewport = await readViewportForPage(page);
+    if (this.activeViewport) {
+      this.broadcastControl(
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport: this.activeViewport
+        })
+      );
+    }
+    const cdpSession = await context.newCDPSession(page);
+    if (this.stopped) {
+      await cdpSession.detach().catch(() => void 0);
+      return;
+    }
+    this.cdpSession = cdpSession;
+    const onFrame = (event) => {
+      void this.handleScreencastFrame(event);
+    };
+    this.screencastHandler = onFrame;
+    cdpSession.on("Page.screencastFrame", onFrame);
+    await cdpSession.send("Page.enable");
+    await cdpSession.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: this.deps.quality,
+      everyNthFrame: 1,
+      ...requestedSize ? {
+        maxWidth: requestedSize.width,
+        maxHeight: requestedSize.height
+      } : {}
+    });
+    this.bindPageLifecycleFrameRefresh(page, cdpSession);
+    void this.seedInitialFrame(cdpSession).catch(() => void 0);
+  }
+  async connectSession() {
+    const resolved = await resolveLocalViewSession(this.deps.sessionId);
+    if (!resolved) {
+      throw new Error(`Local view session ${this.deps.sessionId} is unavailable.`);
+    }
+    const browser = await connectPlaywrightChromiumBrowser2({
+      url: resolved.browserWebSocketUrl
+    });
+    try {
+      const context = browser.contexts()[0];
+      if (!context) {
+        throw new Error("Connected browser did not expose a Chromium browser context.");
+      }
+      const page = context.pages()[0] ?? await context.newPage();
+      return {
+        browser,
+        context,
+        page
+      };
+    } catch (error) {
+      await disconnectPlaywrightChromiumBrowser2(browser).catch(() => void 0);
+      throw error;
+    }
+  }
+  async handleScreencastFrame(event) {
+    const cdpSession = this.cdpSession;
+    if (!cdpSession || this.stopped) {
+      return;
+    }
+    const frameBuffer = Buffer.from(event.data, "base64");
+    this.lastFrameBuffer = frameBuffer;
+    const now = Date.now();
+    const delayMs = Math.max(0, this.frameIntervalMs - (now - this.lastFrameSentAt));
+    if (delayMs === 0) {
+      this.flushScreencastFrame({
+        cdpSession,
+        sessionId: event.sessionId,
+        frameBuffer
+      });
+      return;
+    }
+    if (this.pendingFrameAckTimer !== null) {
+      return;
+    }
+    this.pendingFrameAckTimer = setTimeout(() => {
+      this.pendingFrameAckTimer = null;
+      if (this.stopped || this.cdpSession !== cdpSession) {
+        return;
+      }
+      this.flushScreencastFrame({
+        cdpSession,
+        sessionId: event.sessionId,
+        frameBuffer
+      });
+    }, delayMs);
+  }
+  flushScreencastFrame(args) {
+    this.lastFrameSentAt = Date.now();
+    this.broadcastFrame(args.frameBuffer);
+    void args.cdpSession.send("Page.screencastFrameAck", { sessionId: args.sessionId }).catch(() => void 0);
+  }
+  broadcastFrame(frameBuffer) {
+    for (const client of this.clients) {
+      if (!this.enqueueFrameForClient(client, frameBuffer)) {
+        this.removeClient(client);
+      }
+    }
+    if (this.clients.size === 0) {
+      void this.stop();
+    }
+  }
+  enqueueFrameForClient(client, frameBuffer) {
+    if (client.readyState !== WebSocket4__namespace.default.OPEN) {
+      return false;
+    }
+    const clientState = this.clientStateBySocket.get(client);
+    if (!clientState) {
+      return false;
+    }
+    clientState.pendingFrameBuffer = frameBuffer;
+    this.flushQueuedFrameToClient(client);
+    return true;
+  }
+  flushQueuedFrameToClient(client) {
+    if (client.readyState !== WebSocket4__namespace.default.OPEN) {
+      this.removeClient(client);
+      return;
+    }
+    const clientState = this.clientStateBySocket.get(client);
+    if (!clientState || clientState.frameSendInFlight || !clientState.pendingFrameBuffer) {
+      return;
+    }
+    if (clientState.pendingFlushTimer) {
+      clearTimeout(clientState.pendingFlushTimer);
+      clientState.pendingFlushTimer = null;
+    }
+    if (client.bufferedAmount > this.deps.maxClientBufferBytes) {
+      clientState.pendingFlushTimer = setTimeout(() => {
+        clientState.pendingFlushTimer = null;
+        this.flushQueuedFrameToClient(client);
+      }, CLIENT_FRAME_FLUSH_RETRY_MS);
+      return;
+    }
+    const frameBuffer = clientState.pendingFrameBuffer;
+    clientState.pendingFrameBuffer = null;
+    clientState.frameSendInFlight = true;
+    try {
+      client.send(frameBuffer, { binary: true }, (error) => {
+        const latestClientState = this.clientStateBySocket.get(client);
+        if (latestClientState) {
+          latestClientState.frameSendInFlight = false;
+        }
+        if (error) {
+          this.removeClient(client);
+          return;
+        }
+        this.flushQueuedFrameToClient(client);
+      });
+    } catch {
+      clientState.frameSendInFlight = false;
+      this.removeClient(client);
+    }
+  }
+  broadcastControl(message) {
+    for (const client of this.clients) {
+      sendControlMessage(client, message);
+    }
+  }
+  closeAllClients(code, reason) {
+    for (const client of this.clients) {
+      try {
+        client.close(code, reason);
+      } catch {
+      }
+    }
+    this.clients.clear();
+    for (const clientState of this.clientStateBySocket.values()) {
+      if (clientState.pendingFlushTimer) {
+        clearTimeout(clientState.pendingFlushTimer);
+      }
+    }
+    this.clientStateBySocket.clear();
+  }
+  async stop() {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
+    this.started = false;
+    if (this.tracker) {
+      this.tracker.stop();
+      this.tracker = null;
+    }
+    await this.rebinding.catch(() => void 0);
+    await this.stopScreencast();
+    const browser = this.browser;
+    const browserDisconnectedHandler = this.browserDisconnectedHandler;
+    this.browser = null;
+    this.browserDisconnectedHandler = null;
+    this.context = null;
+    this.activePage = null;
+    if (browser) {
+      if (browserDisconnectedHandler) {
+        browser.off("disconnected", browserDisconnectedHandler);
+      }
+      await disconnectPlaywrightChromiumBrowser2(browser).catch(() => void 0);
+    }
+    this.deps.onDrained();
+  }
+  async stopScreencast() {
+    const cdpSession = this.cdpSession;
+    const handler = this.screencastHandler;
+    const pageLifecycleCleanup = this.pageLifecycleCleanup;
+    this.cdpSession = null;
+    this.screencastHandler = null;
+    this.pageLifecycleCleanup = null;
+    this.activeScreencastSizeKey = null;
+    if (this.pendingFrameAckTimer !== null) {
+      clearTimeout(this.pendingFrameAckTimer);
+      this.pendingFrameAckTimer = null;
+    }
+    pageLifecycleCleanup?.();
+    if (!cdpSession) {
+      return;
+    }
+    if (handler) {
+      cdpSession.off("Page.screencastFrame", handler);
+    }
+    await cdpSession.send("Page.stopScreencast").catch(() => void 0);
+    await cdpSession.detach().catch(() => void 0);
+  }
+  bindPageLifecycleFrameRefresh(page, cdpSession) {
+    this.pageLifecycleCleanup?.();
+    const refresh = () => {
+      void this.refreshPageFrame(page, cdpSession).catch(() => void 0);
+    };
+    page.on("domcontentloaded", refresh);
+    page.on("load", refresh);
+    page.on("framenavigated", refresh);
+    this.pageLifecycleCleanup = () => {
+      page.off("domcontentloaded", refresh);
+      page.off("load", refresh);
+      page.off("framenavigated", refresh);
+    };
+  }
+  async refreshPageFrame(page, cdpSession) {
+    if (this.stopped || this.cdpSession !== cdpSession || this.activePage !== page) {
+      return;
+    }
+    const viewport = await readViewportForPage(page);
+    if (viewport && this.cdpSession === cdpSession && this.activePage === page) {
+      this.activeViewport = viewport;
+      this.broadcastControl(
+        buildHelloMessage({
+          sessionId: this.deps.sessionId,
+          fps: this.deps.maxFps,
+          quality: this.deps.quality,
+          viewport
+        })
+      );
+    }
+    if (this.stopped || this.cdpSession !== cdpSession || this.activePage !== page) {
+      return;
+    }
+    await this.seedInitialFrame(cdpSession);
+  }
+  async seedInitialFrame(cdpSession) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= INITIAL_FRAME_CAPTURE_ATTEMPTS; attempt += 1) {
+      if (this.stopped || this.cdpSession !== cdpSession) {
+        return;
+      }
+      try {
+        const screenshotData = await this.captureCurrentFrame(cdpSession);
+        if (this.stopped || this.cdpSession !== cdpSession) {
+          return;
+        }
+        const frameBuffer = Buffer.from(screenshotData, "base64");
+        this.lastFrameBuffer = frameBuffer;
+        this.lastFrameSentAt = Date.now();
+        this.broadcastFrame(frameBuffer);
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+      if (attempt < INITIAL_FRAME_CAPTURE_ATTEMPTS) {
+        await new Promise((resolve4) => setTimeout(resolve4, INITIAL_FRAME_CAPTURE_RETRY_DELAY_MS));
+      }
+    }
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+    throw new Error("Failed to capture initial stream screenshot.");
+  }
+  async captureCurrentFrame(cdpSession) {
+    const primaryParams = {
+      format: "jpeg",
+      quality: this.deps.quality,
+      optimizeForSpeed: true
+    };
+    try {
+      const result = await cdpSession.send("Page.captureScreenshot", primaryParams);
+      if (result && typeof result.data === "string" && result.data.length > 0) {
+        return result.data;
+      }
+    } catch {
+    }
+    const fallbackResult = await cdpSession.send("Page.captureScreenshot", {
+      format: "jpeg",
+      quality: this.deps.quality
+    });
+    if (!fallbackResult || typeof fallbackResult.data !== "string" || fallbackResult.data.length === 0) {
+      throw new Error("Failed to capture initial stream screenshot.");
+    }
+    return fallbackResult.data;
+  }
+  getRequestedScreencastSize() {
+    if (this.clients.size === 0 || !this.activeViewport) {
+      return null;
+    }
+    const requestedSizes = [];
+    for (const client of this.clients) {
+      const requestedSize = this.clientStateBySocket.get(client)?.requestedRenderSize ?? null;
+      if (!requestedSize) {
+        return null;
+      }
+      requestedSizes.push(requestedSize);
+    }
+    return selectScreencastSize({
+      viewport: this.activeViewport,
+      requestedSizes
+    });
+  }
+  getRequestedScreencastSizeKey() {
+    const size = this.getRequestedScreencastSize();
+    return size ? `${size.width}x${size.height}` : null;
+  }
+};
+async function readViewportForPage(page) {
+  const cdp = await page.context().newCDPSession(page);
+  try {
+    const result = await cdp.send("Page.getLayoutMetrics");
+    const candidates = [
+      result?.cssVisualViewport,
+      result?.cssLayoutViewport,
+      result?.visualViewport,
+      result?.layoutViewport
+    ];
+    for (const candidate of candidates) {
+      const width = normalizeViewportDimension(candidate?.clientWidth);
+      const height = normalizeViewportDimension(candidate?.clientHeight);
+      if (width !== null && height !== null) {
+        return { width, height };
+      }
+    }
+    return null;
+  } catch {
+    const viewportSize = page.viewportSize();
+    if (!viewportSize) {
+      return null;
+    }
+    const width = normalizeViewportDimension(viewportSize.width);
+    const height = normalizeViewportDimension(viewportSize.height);
+    return width !== null && height !== null ? { width, height } : null;
+  } finally {
+    await cdp.detach().catch(() => void 0);
+  }
+}
+function normalizeViewportDimension(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.floor(value);
+  if (normalized < 100) {
+    return null;
+  }
+  return Math.min(8192, normalized);
+}
+function readTextFrame(raw) {
+  if (typeof raw === "string") {
+    return raw;
+  }
+  if (raw instanceof ArrayBuffer) {
+    return Buffer.from(raw).toString("utf8");
+  }
+  if (Array.isArray(raw)) {
+    return Buffer.concat(raw).toString("utf8");
+  }
+  return raw.toString("utf8");
+}
+async function connectPlaywrightChromiumBrowser2(input) {
+  const { connectPlaywrightChromiumBrowser: connect } = await import('@opensteer/engine-playwright');
+  return connect(input);
+}
+async function disconnectPlaywrightChromiumBrowser2(browser) {
+  const { disconnectPlaywrightChromiumBrowser: disconnect } = await import('@opensteer/engine-playwright');
+  await disconnect(browser);
+}
+
+// src/local-view/server.ts
+var DEFAULT_MAX_FPS = 12;
+var DEFAULT_QUALITY = 75;
+var DEFAULT_MAX_CLIENT_BUFFER_BYTES = 512 * 1024;
+var LOCAL_VIEW_ACCESS_EXPIRES_AT = Number.MAX_SAFE_INTEGER;
+async function startLocalViewServer(input = {}) {
+  const token = input.token ?? crypto.randomBytes(24).toString("hex");
+  const runtimeState = new LocalViewRuntimeState();
+  const viewStreamHub = new LocalViewStreamHub({
+    runtimeState,
+    maxFps: DEFAULT_MAX_FPS,
+    quality: DEFAULT_QUALITY,
+    maxClientBufferBytes: DEFAULT_MAX_CLIENT_BUFFER_BYTES
+  });
+  const cdpProxy = new LocalViewCdpProxy({
+    runtimeState
+  });
+  const httpServer = http.createServer((request, response) => {
+    void handleHttpRequest({ request, response, token, shutdown: closeServer }).catch(() => {
+      if (!response.headersSent && !response.writableEnded) {
+        writeJson(response, 500, { error: "Internal server error." });
+        return;
+      }
+      response.destroy();
+    });
+  });
+  const viewWss = new LocalViewWebSocketServer({ noServer: true });
+  viewWss.on("connection", (ws, request) => {
+    const url2 = new URL(request.url ?? "/", "http://localhost");
+    const parts = url2.pathname.split("/").filter(Boolean);
+    const sessionId = parts[2];
+    if (!sessionId) {
+      ws.close(1008, "Session id is required.");
+      return;
+    }
+    viewStreamHub.attachClient(sessionId, ws);
+  });
+  httpServer.on("upgrade", (request, socket, head) => {
+    const url2 = new URL(request.url ?? "/", "http://localhost");
+    const tokenParam = url2.searchParams.get("token");
+    if (tokenParam !== token || !isAllowedOrigin(request.headers.origin)) {
+      socket.destroy();
+      return;
+    }
+    const parts = url2.pathname.split("/").filter(Boolean);
+    if (parts[0] !== "ws" || parts.length !== 3) {
+      socket.destroy();
+      return;
+    }
+    if (parts[1] === "view") {
+      viewWss.handleUpgrade(request, socket, head, (ws) => {
+        viewWss.emit("connection", ws, request);
+      });
+      return;
+    }
+    if (parts[1] === "cdp") {
+      cdpProxy.handleUpgrade(request, socket, head);
+      return;
+    }
+    socket.destroy();
+  });
+  let closePromise;
+  async function closeServer() {
+    closePromise ??= (async () => {
+      viewWss.clients.forEach((client) => {
+        try {
+          client.close();
+        } catch {
+        }
+      });
+      viewWss.close();
+      cdpProxy.close();
+      httpServer.close();
+      await events.once(httpServer, "close");
+      await clearLocalViewServiceState({ pid: process.pid, token });
+      await input.onClosed?.();
+    })();
+    await closePromise;
+  }
+  httpServer.listen(input.port ?? 0, "127.0.0.1");
+  await events.once(httpServer, "listening");
+  const address = httpServer.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Failed to resolve the local view server address.");
+  }
+  const url = `http://127.0.0.1:${String(address.port)}`;
+  await writeLocalViewServiceState({
+    layout: OPENSTEER_LOCAL_VIEW_SERVICE_LAYOUT,
+    version: OPENSTEER_LOCAL_VIEW_SERVICE_VERSION,
+    pid: process.pid,
+    processStartedAtMs: CURRENT_PROCESS_OWNER.processStartedAtMs,
+    startedAt: Date.now(),
+    port: address.port,
+    token,
+    url
+  });
+  return {
+    url,
+    token,
+    close: closeServer
+  };
+}
+async function handleHttpRequest(args) {
+  const url = new URL(args.request.url ?? "/", "http://localhost");
+  if (url.pathname === "/api/health") {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    writeJson(args.response, 200, { ok: true });
+    return;
+  }
+  if (url.pathname === "/api/sessions") {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    const sessions = await listResolvedLocalViewSessions();
+    const payload = { sessions };
+    writeJson(args.response, 200, payload);
+    return;
+  }
+  if (url.pathname === "/api/service/stop") {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    if (args.request.method !== "POST") {
+      writeJson(args.response, 405, { error: "Method not allowed." });
+      return;
+    }
+    args.response.once("finish", () => {
+      void args.shutdown();
+    });
+    writeJson(args.response, 200, { stopped: true });
+    return;
+  }
+  const accessMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/access$/u);
+  if (accessMatch) {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    const sessionId = decodeURIComponent(accessMatch[1]);
+    if (!await resolveLocalViewSession(sessionId)) {
+      writeJson(args.response, 404, { error: "Session not found." });
+      return;
+    }
+    const payload = {
+      sessionId,
+      expiresAt: LOCAL_VIEW_ACCESS_EXPIRES_AT,
+      grants: {
+        view: {
+          kind: "view",
+          transport: "ws",
+          url: `${resolveWsBaseUrl(args.request)}/ws/view/${encodeURIComponent(sessionId)}`,
+          token: args.token,
+          expiresAt: LOCAL_VIEW_ACCESS_EXPIRES_AT
+        },
+        cdp: {
+          kind: "cdp",
+          transport: "ws",
+          url: `${resolveWsBaseUrl(args.request)}/ws/cdp/${encodeURIComponent(sessionId)}`,
+          token: args.token,
+          expiresAt: LOCAL_VIEW_ACCESS_EXPIRES_AT
+        }
+      }
+    };
+    writeJson(args.response, 200, payload);
+    return;
+  }
+  const closeMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/close$/u);
+  if (closeMatch) {
+    if (!isAuthorizedApiRequest(args.request, args.token)) {
+      writeJson(args.response, 401, { error: "Unauthorized." });
+      return;
+    }
+    if (args.request.method !== "POST") {
+      writeJson(args.response, 405, { error: "Method not allowed." });
+      return;
+    }
+    const sessionId = decodeURIComponent(closeMatch[1]);
+    const { closeLocalViewSessionBrowser: closeLocalViewSessionBrowser2, LocalViewSessionCloseError: LocalViewSessionCloseError2 } = await Promise.resolve().then(() => (init_session_control(), session_control_exports));
+    try {
+      await closeLocalViewSessionBrowser2(sessionId);
+    } catch (error) {
+      if (error instanceof LocalViewSessionCloseError2) {
+        writeJson(args.response, error.statusCode, { error: error.message });
+        return;
+      }
+      throw error;
+    }
+    const payload = {
+      sessionId,
+      closed: true
+    };
+    writeJson(args.response, 200, payload);
+    return;
+  }
+  if (url.pathname === "/favicon.ico") {
+    args.response.statusCode = 204;
+    args.response.end();
+    return;
+  }
+  if (url.pathname === "/" || url.pathname.startsWith("/assets/") || url.pathname.startsWith("/images/")) {
+    await serveStaticAsset(args.response, url.pathname, args.token);
+    return;
+  }
+  args.response.statusCode = 404;
+  args.response.end("not found");
+}
+async function serveStaticAsset(response, pathname, token) {
+  const publicDir = resolveLocalViewPublicDir();
+  const relativePath = pathname === "/" ? "index.html" : pathname.slice(1);
+  const assetPath = path10__default.default.resolve(publicDir, relativePath);
+  const relativeAssetPath = path10__default.default.relative(publicDir, assetPath);
+  if (relativeAssetPath.startsWith("..") || path10__default.default.isAbsolute(relativeAssetPath) || !fs.existsSync(assetPath)) {
+    response.statusCode = 404;
+    response.end("not found");
+    return;
+  }
+  if (relativePath === "index.html") {
+    const html = await promises.readFile(assetPath, "utf8");
+    response.setHeader("content-type", "text/html; charset=utf-8");
+    response.setHeader("cache-control", "no-store");
+    response.end(
+      html.replace(
+        "__OPENSTEER_LOCAL_BOOTSTRAP_JSON__",
+        JSON.stringify({
+          apiBasePath: "/api",
+          token
+        })
+      )
+    );
+    return;
+  }
+  response.setHeader("content-type", guessContentType(assetPath));
+  response.setHeader("cache-control", "no-store");
+  response.end(await promises.readFile(assetPath));
+}
+function resolveLocalViewPublicDir() {
+  const moduleDir = path10__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin.cjs', document.baseURI).href))));
+  const candidates = [
+    path10__default.default.resolve(moduleDir, "local-view", "public"),
+    path10__default.default.resolve(moduleDir, "public"),
+    path10__default.default.resolve(moduleDir, "..", "local-view", "public")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not resolve local view public assets from ${moduleDir}.`);
+}
+function isAuthorizedApiRequest(request, token) {
+  return request.headers["x-opensteer-local-token"] === token && isAllowedOrigin(request.headers.origin);
+}
+function isAllowedOrigin(origin) {
+  if (origin === void 0) {
+    return true;
+  }
+  try {
+    const url = new URL(origin);
+    const host = url.hostname;
+    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+  } catch {
+    return false;
+  }
+}
+function resolveWsBaseUrl(request) {
+  const host = request.headers.host ?? "127.0.0.1";
+  return `ws://${host}`;
+}
+function writeJson(response, statusCode, value) {
+  response.statusCode = statusCode;
+  response.setHeader("content-type", "application/json; charset=utf-8");
+  response.end(JSON.stringify(value));
+}
+function guessContentType(assetPath) {
+  if (assetPath.endsWith(".css")) {
+    return "text/css; charset=utf-8";
+  }
+  if (assetPath.endsWith(".js")) {
+    return "application/javascript; charset=utf-8";
+  }
+  if (assetPath.endsWith(".svg")) {
+    return "image/svg+xml";
+  }
+  if (assetPath.endsWith(".json")) {
+    return "application/json; charset=utf-8";
+  }
+  if (assetPath.endsWith(".png")) {
+    return "image/png";
+  }
+  if (assetPath.endsWith(".ico")) {
+    return "image/x-icon";
+  }
+  return "application/octet-stream";
+}
+
+// src/local-view/serve.ts
+async function runLocalViewService() {
+  const server = await startLocalViewServer({
+    token: process.env.OPENSTEER_LOCAL_VIEW_BOOT_TOKEN ?? crypto.randomBytes(24).toString("hex"),
+    onClosed: () => {
+      process.exit(0);
+    }
+  });
+  const handleShutdownSignal = () => {
+    void server.close();
+  };
+  process.once("SIGINT", handleShutdownSignal);
+  process.once("SIGTERM", handleShutdownSignal);
+  await new Promise(() => void 0);
+}
+
+// src/cli/view.ts
+init_service();
+init_session_manifest();
+init_root2();
+async function handleViewCommand(parsed) {
+  const subcommand = parsed.command[1];
+  if (subcommand === "serve") {
+    assertNoViewPreferenceFlag(parsed);
+    await runLocalViewService();
+    return;
+  }
+  if (subcommand === "stop") {
+    assertNoViewPreferenceFlag(parsed);
+    const stopped = await stopLocalViewService();
+    writeViewOutput(parsed, { stopped });
+    return;
+  }
+  if (subcommand !== void 0) {
+    throw new Error(`Unknown view command: view ${subcommand}`);
+  }
+  if (parsed.options.localViewMode !== void 0) {
+    const preference = await setLocalViewMode(parsed.options.localViewMode);
+    writeViewOutput(parsed, { mode: preference.mode });
+    return;
+  }
+  const service = await ensureLocalViewServiceRunning();
+  const sessionId = parsed.options.workspace === void 0 ? void 0 : await resolveWorkspaceSessionId({
+    rootDir: process.cwd(),
+    workspace: parsed.options.workspace
+  });
+  const url = buildLocalViewSessionUrl({
+    baseUrl: service.url,
+    ...sessionId === void 0 ? {} : { sessionId }
+  });
+  writeViewOutput(parsed, {
+    url,
+    ...sessionId === void 0 ? {} : { sessionId }
+  });
+}
+async function resolveWorkspaceSessionId(input) {
+  const rootPath = resolveFilesystemWorkspacePath({
+    rootDir: path10__default.default.resolve(input.rootDir),
+    workspace: input.workspace
+  });
+  const live = await readPersistedLocalBrowserSessionRecord(rootPath);
+  if (!live || !isProcessRunning(live.pid)) {
+    return void 0;
+  }
+  return buildLocalViewSessionId({
+    rootPath,
+    pid: live.pid,
+    startedAt: live.startedAt
+  });
+}
+function assertNoViewPreferenceFlag(parsed) {
+  if (parsed.options.localViewMode !== void 0) {
+    throw new Error("View preference flags cannot be combined with this subcommand.");
+  }
+}
+function writeViewOutput(parsed, value) {
+  if (parsed.options.json === true) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+    return;
+  }
+  if ("url" in value) {
+    process.stdout.write(`${value.url}
+`);
+    return;
+  }
+  if ("stopped" in value) {
+    process.stdout.write(
+      `${value.stopped ? "Local view service stopped." : "Local view service is not running."}
+`
+    );
+    return;
+  }
+  process.stdout.write(`Local view preference set to ${value.mode}.
+`);
+}
+
 // src/cli/bin.ts
 var emitProcessWarning = process4__default.default.emitWarning.bind(process4__default.default);
 process4__default.default.emitWarning = ((warning, ...args) => {
@@ -33733,6 +36498,10 @@ async function main() {
     await handleRecordCommandEntry(parsed);
     return;
   }
+  if (parsed.command[0] === "view") {
+    await handleViewCommand(parsed);
+    return;
+  }
   if (parsed.command[0] === "exec") {
     await handleExecCommand(parsed);
     return;