@tonyclaw/agent-inspector 3.0.44 → 3.0.45

package/.output/server/_ssr/{router-DWcUFPR3.mjs → router-BJ_ltLim.mjs}

@@ -1,4 +1,5 @@
 import { c as createRouter, a as createRootRoute, b as createFileRoute, l as lazyRouteComponent, O as Outlet, H as HeadContent, S as Scripts } from "../_libs/tanstack__react-router.mjs";
+import { h as getRouterBasePath, r as runWithRequestPublicBasePath, a as getPublicBasePath, w as withBasePath, s as stripBasePath, g as getConfiguredBasePath, n as normalizeBasePath, e as appendBasePathToOrigin, A as AGENT_INSPECTOR_BASE_PATH_META_NAME, f as AGENT_INSPECTOR_BASE_PATH_ENV, b as getPublicPort, c as AGENT_INSPECTOR_PUBLIC_BASE_PATH_HEADER, d as AGENT_INSPECTOR_PUBLIC_PORT_HEADER } from "./publicBasePathContext-5264L3rX.mjs";
 import { r as reactExports, j as jsxRuntimeExports } from "../_libs/react.mjs";
 import { S as SWRConfig } from "../_libs/swr.mjs";
 import { c as cva } from "../_libs/class-variance-authority.mjs";
@@ -6,8 +7,8 @@ import { c as clsx } from "../_libs/clsx.mjs";
 import { t as twMerge } from "../_libs/tailwind-merge.mjs";
 import { randomUUID, timingSafeEqual, createHash, createDecipheriv, randomBytes, createCipheriv } from "node:crypto";
 import fs, { readdir, open, readFile, unlink, writeFile, appendFile, stat, rename, rm, statfs } from "node:fs/promises";
-import path, { basename, join, dirname, isAbsolute, resolve, relative } from "node:path";
-import { existsSync, readFileSync, writeFileSync, unlinkSync, renameSync, copyFileSync, createReadStream, mkdirSync, statSync, readdirSync, rmSync, chmodSync, cpSync, lstatSync, appendFileSync, createWriteStream } from "node:fs";
+import path, { basename, join, dirname, isAbsolute, resolve, win32, posix, relative } from "node:path";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, renameSync, copyFileSync, createReadStream, mkdirSync, statSync, readdirSync, rmSync, chmodSync, cpSync, lstatSync, appendFileSync, createWriteStream, realpathSync, openSync, closeSync } from "node:fs";
 import { spawn, execFile, spawnSync } from "node:child_process";
 import { Buffer } from "node:buffer";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -17,12 +18,12 @@ import { C as Conf } from "../_libs/conf.mjs";
 import { randomUUID as randomUUID$1 } from "crypto";
 import { promisify } from "node:util";
 import { lookup } from "node:dns/promises";
-import { isIP } from "node:net";
+import { isIP, createServer } from "node:net";
 import assert from "node:assert/strict";
 import { M as McpServer, W as WebStandardStreamableHTTPServerTransport, R as ResourceTemplate } from "../_libs/modelcontextprotocol__server.mjs";
 import { J as JSZip } from "../_libs/jszip.mjs";
 import { homedir } from "node:os";
-import { o as object, c as string, e as array, n as number, r as record, f as _enum, u as union, h as unknown, a as literal, d as boolean, k as discriminatedUnion, _ as _null, b as lazy } from "../_libs/zod.mjs";
+import { o as object, c as string, f as array, n as number, r as record, g as _enum, u as union, j as unknown, a as literal, e as boolean, k as discriminatedUnion, _ as _null, b as lazy, q as url, d as datetime } from "../_libs/zod.mjs";
 import "../_libs/tanstack__router-core.mjs";
 import "../_libs/cookie-es.mjs";
 import "../_libs/seroval.mjs";
@@ -35,6 +36,7 @@ import "util";
 import "async_hooks";
 import "stream";
 import "../_libs/isbot.mjs";
+import "node:async_hooks";
 import "../_libs/use-sync-external-store.mjs";
 import "../_libs/dequal.mjs";
 import "node:process";
@@ -70,52 +72,6 @@ import "../_libs/lie.mjs";
 import "../_libs/immediate.mjs";
 import "../_libs/setimmediate.mjs";
 import "../_libs/pako.mjs";
-const AGENT_INSPECTOR_BASE_PATH_ENV = "AGENT_INSPECTOR_BASE_PATH";
-const AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH_ENV = "AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH";
-const AGENT_INSPECTOR_BASE_PATH_META_NAME = "agent-inspector-base-path";
-const DEFAULT_AGENT_INSPECTOR_BASE_PATH = "/inspector";
-function trimSlashes(value) {
-  return value.replace(/^\/+/u, "").replace(/\/+$/u, "");
-}
-function normalizeBasePath(value) {
-  const trimmed = value?.trim();
-  if (trimmed === void 0 || trimmed.length === 0 || trimmed === "/") return "";
-  const path2 = trimSlashes(trimmed);
-  if (path2.length === 0) return "";
-  return `/${path2}`;
-}
-function readDocumentBasePath() {
-  if (typeof document === "undefined") return void 0;
-  return document.querySelector(`meta[name="${AGENT_INSPECTOR_BASE_PATH_META_NAME}"]`)?.getAttribute("content") ?? void 0;
-}
-function readProcessBasePath() {
-  if (typeof process === "undefined") return void 0;
-  return process.env[AGENT_INSPECTOR_BASE_PATH_ENV];
-}
-function getConfiguredBasePath(env) {
-  return normalizeBasePath(
-    env?.[AGENT_INSPECTOR_BASE_PATH_ENV] ?? readProcessBasePath() ?? readDocumentBasePath() ?? "/" ?? DEFAULT_AGENT_INSPECTOR_BASE_PATH
-  );
-}
-function getRouterBasePath(env) {
-  if (env?.[AGENT_INSPECTOR_INTERNAL_STRIPPED_BASE_PATH_ENV] === "1") return "";
-  return getConfiguredBasePath(env);
-}
-function withBasePath(path2, basePath = getConfiguredBasePath()) {
-  const normalized = normalizeBasePath(basePath);
-  if (/^[a-z][a-z0-9+.-]*:/iu.test(path2)) return path2;
-  if (normalized.length === 0) return path2;
-  if (path2.length === 0 || path2 === "/") return normalized;
-  if (path2.startsWith(`${normalized}/`) || path2 === normalized) return path2;
-  return path2.startsWith("/") ? `${normalized}${path2}` : `${normalized}/${path2}`;
-}
-function stripBasePath(pathname, basePath = getConfiguredBasePath()) {
-  const normalized = normalizeBasePath(basePath);
-  if (normalized.length === 0) return pathname;
-  if (pathname === normalized) return "/";
-  if (pathname.startsWith(`${normalized}/`)) return pathname.slice(normalized.length);
-  return pathname;
-}
 const faviconSvg = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2024%2024'%20role='img'%20aria-label='Agent%20Inspector'%3e%3cg%20fill='none'%20stroke='%23f59e0b'%20stroke-width='1.5'%20stroke-linecap='round'%20stroke-linejoin='round'%20%3e%3cpath%20d='M5%2013%20C5%209%208%207%2012%207%20C16%207%2019%209%2019%2013%20C19%2016%2016%2018%2012%2018%20C8%2018%205%2016%205%2013%20Z'%20/%3e%3cpath%20d='M5%2011%20C3.5%209.5%201.5%2010%202%2012.5%20C2.5%2014%204%2013.5%205%2012.5'%20/%3e%3cpath%20d='M19%2011%20C20.5%209.5%2022.5%2010%2022%2012.5%20C21.5%2014%2020%2013.5%2019%2012.5'%20/%3e%3cline%20x1='10'%20y1='7'%20x2='9.5'%20y2='5'%20/%3e%3cline%20x1='14'%20y1='7'%20x2='14.5'%20y2='5'%20/%3e%3cline%20x1='6.5'%20y1='16'%20x2='4.5'%20y2='19.5'%20/%3e%3cline%20x1='9'%20y1='17.5'%20x2='8'%20y2='20.5'%20/%3e%3cline%20x1='15'%20y1='17.5'%20x2='16'%20y2='20.5'%20/%3e%3cline%20x1='17.5'%20y1='16'%20x2='19.5'%20y2='19.5'%20/%3e%3c/g%3e%3ccircle%20cx='9.5'%20cy='4.5'%20r='0.9'%20fill='%23f59e0b'%20/%3e%3ccircle%20cx='14.5'%20cy='4.5'%20r='0.9'%20fill='%23f59e0b'%20/%3e%3c/svg%3e";
 function restoreSelection(selection, ranges) {
   if (selection === null) return;
@@ -339,8 +295,8 @@ function SafeErrorFallback({
 }) {
   const [copied, setCopied] = reactExports.useState(false);
   const handleCopy = reactExports.useCallback(() => {
-    void copyTextToClipboard(reference).then((success) => {
-      if (!success) return;
+    void copyTextToClipboard(reference).then((success2) => {
+      if (!success2) return;
       setCopied(true);
     });
   }, [reference]);
@@ -447,7 +403,7 @@ function SafeRouteError({
     }
   );
 }
-const appCss = "/assets/index-BWjeqxbk.css";
+const appCss = "/assets/index-ZWschkCh.css";
 const CHUNK_LOAD_RELOAD_AT_KEY = "agent-inspector.chunkLoadReloadAt";
 const CHUNK_LOAD_RELOAD_WINDOW_MS = 15e3;
 const CHUNK_LOAD_FAILURE_PATTERNS = [
@@ -700,7 +656,7 @@ const uiScaleBootstrapScript = `
   }
 })();
 `;
-const Route$O = createRootRoute({
+const Route$U = createRootRoute({
   head: () => ({
     meta: [
       { charSet: "utf-8" },
@@ -3002,11 +2958,11 @@ function destroyAllSessionProcesses() {
     sp.destroy();
   }
 }
-function isRecord(value) {
+function isRecord$2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readProperty$3(value, name2) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord$2(value)) return void 0;
   const descriptor = Object.getOwnPropertyDescriptor(value, name2);
   return descriptor === void 0 ? void 0 : descriptor.value;
 }
@@ -4015,13 +3971,13 @@ function buildAbsoluteUrl(baseUrl, path2) {
 }
 function buildApiPath(sessionId) {
   return buildRelativePath(
-    withBasePath("/api/sessions", getConfiguredBasePath(process.env)),
+    withBasePath("/api/sessions", getPublicBasePath()),
     new URLSearchParams({ sessionId })
   );
 }
 function buildCompactLogsPath(sessionId) {
   return buildRelativePath(
-    withBasePath("/api/logs", getConfiguredBasePath(process.env)),
+    withBasePath("/api/logs", getPublicBasePath()),
     new URLSearchParams({ compact: "1", sessionId })
   );
 }
@@ -4100,7 +4056,7 @@ function buildSessionInfo(input) {
   const queuedTasks = input.snapshot?.queuedTasks ?? 0;
   const runningTasks = input.snapshot?.runningTasks ?? 0;
   const lastTaskError = normalizeString(input.snapshot?.lastTaskError);
-  const inspectorPath = getSessionPath(input.sessionId, getConfiguredBasePath(process.env));
+  const inspectorPath = getSessionPath(input.sessionId, getPublicBasePath());
   const apiPath = buildApiPath(input.sessionId);
   const compactLogsPath = buildCompactLogsPath(input.sessionId);
   const latestLogs = summaries.slice(0, latestLogLimit).map((summary, index) => ({
@@ -5838,7 +5794,7 @@ function readStringArray(value, key) {
 }
 function readObject(value, key) {
   const property = readProperty$3(value, key);
-  return isRecord(property) ? property : null;
+  return isRecord$2(property) ? property : null;
 }
 function normalizeExpectedType(typeName) {
   switch (typeName) {
@@ -5883,7 +5839,7 @@ function actualType(value) {
     case "function":
     case "object":
     case "symbol":
-      return isRecord(value) ? "object" : "unknown";
+      return isRecord$2(value) ? "object" : "unknown";
   }
   return "unknown";
 }
@@ -5900,7 +5856,7 @@ function matchesExpectedType(value, expected) {
     case "number":
       return typeof value === "number" && Number.isFinite(value);
     case "object":
-      return isRecord(value);
+      return isRecord$2(value);
     case "string":
       return typeof value === "string";
   }
@@ -6005,7 +5961,7 @@ function validateEnum(schema, value, toolName, path2, warnings) {
   }
 }
 function validateValueAgainstSchema(schema, value, toolName, path2, warnings) {
-  if (!isRecord(schema)) return;
+  if (!isRecord$2(schema)) return;
   const expectedTypes = schemaTypes(schema);
   if (expectedTypes.length > 0 && !matchesAnyExpectedType(value, expectedTypes)) {
     addTypeWarning(warnings, toolName, path2, expectedTypes, value);
@@ -6013,7 +5969,7 @@ function validateValueAgainstSchema(schema, value, toolName, path2, warnings) {
   }
   validateEnum(schema, value, toolName, path2, warnings);
   if (schemaAllowsObjectValidation(schema, expectedTypes)) {
-    if (isRecord(value)) {
+    if (isRecord$2(value)) {
       validateObjectSchema(schema, value, toolName, path2, warnings);
     } else if (expectedTypes.length === 0) {
       warnings.push(
@@ -6034,7 +5990,7 @@ function validateValueAgainstSchema(schema, value, toolName, path2, warnings) {
 function extractAnthropicToolSchemas(request) {
   const tools = /* @__PURE__ */ new Map();
   for (const tool of readArray(request, "tools")) {
-    if (!isRecord(tool)) continue;
+    if (!isRecord$2(tool)) continue;
     const name2 = readString(tool, "name");
     if (name2 === null || name2 === "") continue;
     tools.set(name2, {
@@ -6848,7 +6804,7 @@ async function readinessResponse() {
     headers: { "cache-control": "no-store" }
   });
 }
-const Route$N = createFileRoute("/readyz")({
+const Route$T = createFileRoute("/readyz")({
   server: {
     handlers: {
       GET: readinessResponse
@@ -6858,23 +6814,23 @@ const Route$N = createFileRoute("/readyz")({
 function livenessResponse() {
   return Response.json({ status: "ok" }, { headers: { "cache-control": "no-store" } });
 }
-const Route$M = createFileRoute("/livez")({
+const Route$S = createFileRoute("/livez")({
   server: {
     handlers: {
       GET: livenessResponse
     }
   }
 });
-const $$splitErrorComponentImporter$1 = () => import("./index-D0At9nfd.mjs");
-const $$splitComponentImporter$1 = () => import("./index-lcfulIXa.mjs");
-const Route$L = createFileRoute("/")({
+const $$splitErrorComponentImporter$1 = () => import("./index-DW-M7XUG.mjs");
+const $$splitComponentImporter$1 = () => import("./index-Bcj1Hcy4.mjs");
+const Route$R = createFileRoute("/")({
   ssr: false,
   component: lazyRouteComponent($$splitComponentImporter$1, "component"),
   errorComponent: lazyRouteComponent($$splitErrorComponentImporter$1, "errorComponent")
 });
-const $$splitErrorComponentImporter = () => import("../_sessionId-U54BAqdp.mjs");
-const $$splitComponentImporter = () => import("../_sessionId-E_Dmopc-.mjs");
-const Route$K = createFileRoute("/session/$sessionId")({
+const $$splitErrorComponentImporter = () => import("../_sessionId-CJ99gZFV.mjs");
+const $$splitComponentImporter = () => import("../_sessionId-DEjScBpK.mjs");
+const Route$Q = createFileRoute("/session/$sessionId")({
   ssr: false,
   component: lazyRouteComponent($$splitComponentImporter, "component"),
   errorComponent: lazyRouteComponent($$splitErrorComponentImporter, "errorComponent"),
@@ -7302,9 +7258,9 @@ function providerEntryMatches(provider, entry) {
     return providerName.includes(normalized) || normalized.includes(providerName);
   });
   if (nameMatches) return true;
-  const normalizedProviderUrls = providerBaseUrls(provider).map((url) => normalizeUrl(url)).filter((url) => url !== null);
-  const baseUrlMatches = entry.baseUrls.some((url) => {
-    const normalized = normalizeUrl(url);
+  const normalizedProviderUrls = providerBaseUrls(provider).map((url2) => normalizeUrl(url2)).filter((url2) => url2 !== null);
+  const baseUrlMatches = entry.baseUrls.some((url2) => {
+    const normalized = normalizeUrl(url2);
     return normalized !== null && normalizedProviderUrls.includes(normalized);
   });
   if (baseUrlMatches) return true;
@@ -8260,8 +8216,8 @@ function isZhipuProvider(provider) {
     return normalizedName.includes(normalizedAlias) || normalizedAlias.includes(normalizedName);
   });
   if (nameMatches) return true;
-  return providerRoutingUrls(provider).some((url) => {
-    const normalizedUrl = url.toLowerCase().replace(/\/+$/, "");
+  return providerRoutingUrls(provider).some((url2) => {
+    const normalizedUrl = url2.toLowerCase().replace(/\/+$/, "");
     return ZHIPU_BASE_URL_MARKERS.some((marker) => normalizedUrl.includes(marker));
   });
 }
@@ -9405,9 +9361,9 @@ function describeApiRoute(apiPath) {
   const normalizedPath = isOpenAI && !apiPath.startsWith("/v1/") ? `/v1${apiPath}` : apiPath;
   return { apiPath, endpointPath, isChatCompletions, isResponses, isOpenAI, normalizedPath };
 }
-function getProxyApiPath(url) {
-  const pathname = stripBasePath(url.pathname, getConfiguredBasePath(process.env));
-  return pathname.replace(/^\/proxy/, "") + url.search;
+function getProxyApiPath(url2) {
+  const pathname = stripBasePath(url2.pathname, getConfiguredBasePath(process.env));
+  return pathname.replace(/^\/proxy/, "") + url2.search;
 }
 function selectUpstreamBase(route, provider) {
   if (provider === null) {
@@ -9472,8 +9428,8 @@ function buildProxyHeaders(originalHeaders, captureRawHeaders) {
   }
   return { headers, rawHeaders };
 }
-function parseRequestPath(req, url) {
-  const route = describeApiRoute(getProxyApiPath(url));
+function parseRequestPath(req, url2) {
+  const route = describeApiRoute(getProxyApiPath(url2));
   const isPost = req.method === "POST";
   const isChatCompletions = isPost && route.isChatCompletions;
   const isMessages = isPost && (route.endpointPath === PATH_V1_MESSAGES$1 || route.isChatCompletions);
@@ -9641,8 +9597,8 @@ function handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log,
   });
 }
 async function handleAdmittedProxy(req) {
-  const url = new URL(req.url);
-  const parsed = parseRequestPath(req, url);
+  const url2 = new URL(req.url);
+  const parsed = parseRequestPath(req, url2);
   const bodyRead = await readBodyWithLimit(req, MAX_REQUEST_BODY_BYTES);
   if (!bodyRead.ok) {
     logger.warn(`[handler] Rejected oversized request body: ${req.method} ${parsed.apiPath}`);
@@ -9818,7 +9774,7 @@ async function handleProxy(req) {
     return await Promise.reject(error);
   }
 }
-const Route$J = createFileRoute("/proxy/$")({
+const Route$P = createFileRoute("/proxy/$")({
   server: {
     handlers: {
       GET: ({ request }) => handleProxy(request),
@@ -9833,18 +9789,18 @@ const Route$J = createFileRoute("/proxy/$")({
 function parseBooleanFlag(value) {
   return value === "1" || value === "true";
 }
-const Route$I = createFileRoute("/api/sessions")({
+const Route$O = createFileRoute("/api/sessions")({
   server: {
     handlers: {
       GET: async ({ request }) => {
-        const url = new URL(request.url);
-        const sessionId = url.searchParams.get("sessionId");
+        const url2 = new URL(request.url);
+        const sessionId = url2.searchParams.get("sessionId");
         if (sessionId !== null) {
           if (sessionId.length === 0) {
             return Response.json({ error: "sessionId is required" }, { status: 400 });
           }
           const limitResult = parseBoundedIntegerParameter({
-            value: url.searchParams.get("limit"),
+            value: url2.searchParams.get("limit"),
             parameter: "limit",
             fallback: SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT,
             minimum: 1,
@@ -9853,8 +9809,8 @@ const Route$I = createFileRoute("/api/sessions")({
           });
           if (!limitResult.ok) return limitResult.response;
           const info = await getSessionInfo(sessionId, {
-            baseUrl: url.origin,
-            includeHistory: parseBooleanFlag(url.searchParams.get("includeHistory")),
+            baseUrl: url2.origin,
+            includeHistory: parseBooleanFlag(url2.searchParams.get("includeHistory")),
             latestLogLimit: limitResult.value
           });
           if (info === null) {
@@ -9862,7 +9818,7 @@ const Route$I = createFileRoute("/api/sessions")({
           }
           return Response.json(info);
         }
-        const details = url.searchParams.get("details");
+        const details = url2.searchParams.get("details");
         if (details === "true" || details === "1") {
           return Response.json(getSessionSnapshots());
         }
@@ -11226,7 +11182,7 @@ function failureFromRun(run) {
   };
 }
 function listRecentFailures(limit) {
-  const failures = listRuns().map(failureFromRun).filter((failure) => failure !== null).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  const failures = listRuns().map(failureFromRun).filter((failure2) => failure2 !== null).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
   const clampedLimit = clampRecentFailuresLimit(limit);
   return {
     failures: failures.slice(0, clampedLimit),
@@ -11282,14 +11238,14 @@ async function readJsonBody$6(request) {
     return { ok: false };
   }
 }
-const Route$H = createFileRoute("/api/runs")({
+const Route$N = createFileRoute("/api/runs")({
   server: {
     handlers: {
       GET: ({ request }) => {
-        const url = new URL(request.url);
-        if (url.searchParams.get("failures") === "1") {
+        const url2 = new URL(request.url);
+        if (url2.searchParams.get("failures") === "1") {
           const limitResult = parseBoundedIntegerParameter({
-            value: url.searchParams.get("limit"),
+            value: url2.searchParams.get("limit"),
             parameter: "limit",
             fallback: RECENT_FAILURES_DEFAULT_LIMIT,
             minimum: 1,
@@ -11334,7 +11290,7 @@ const ProviderInputSchema = object({
   modelMetadata: ProviderModelMetadataListSchema.optional(),
   source: _enum(["company", "personal"]).optional()
 });
-const Route$G = createFileRoute("/api/providers")({
+const Route$M = createFileRoute("/api/providers")({
   server: {
     handlers: {
       GET: () => {
@@ -11874,8 +11830,8 @@ function warningObservation(log, warning) {
 }
 function addLogObservations(map, logs, slowResponseThresholdSeconds) {
   for (const log of logs) {
-    const failure = requestFailureObservation(log);
-    if (failure !== null) addObservation(map, failure);
+    const failure2 = requestFailureObservation(log);
+    if (failure2 !== null) addObservation(map, failure2);
     const slow = slowResponseObservation(log, slowResponseThresholdSeconds);
     if (slow !== null) addObservation(map, slow);
     for (const warning of log.warnings ?? []) {
@@ -11883,8 +11839,8 @@ function addLogObservations(map, logs, slowResponseThresholdSeconds) {
     }
   }
 }
-function alertSeverityFromFailure(failure) {
-  switch (failure.classification.severity) {
+function alertSeverityFromFailure(failure2) {
+  switch (failure2.classification.severity) {
     case "high":
       return "critical";
     case "medium":
@@ -11894,47 +11850,47 @@ function alertSeverityFromFailure(failure) {
       return "notice";
   }
 }
-function providerFromRun(failure) {
-  const provider = failure.run.metadata["provider"] ?? failure.run.metadata["providerName"];
+function providerFromRun(failure2) {
+  const provider = failure2.run.metadata["provider"] ?? failure2.run.metadata["providerName"];
   return typeof provider === "string" && provider.length > 0 ? provider : null;
 }
-function modelFromRun(failure) {
-  const model = failure.run.metadata["model"] ?? failure.run.metadata["modelName"];
+function modelFromRun(failure2) {
+  const model = failure2.run.metadata["model"] ?? failure2.run.metadata["modelName"];
   return typeof model === "string" && model.length > 0 ? model : null;
 }
-function runFailureObservation(failure) {
-  const groupId = failure.run.groupId;
-  const logEvidenceLinks = failure.classification.evidenceLogIds.map(logEvidence$1);
+function runFailureObservation(failure2) {
+  const groupId = failure2.run.groupId;
+  const logEvidenceLinks = failure2.classification.evidenceLogIds.map(logEvidence$1);
   const links = mergeEvidence(
-    baseEvidence(null, failure.sessionId, failure.run.id, groupId),
+    baseEvidence(null, failure2.sessionId, failure2.run.id, groupId),
     logEvidenceLinks
   );
   return {
-    fingerprint: fingerprint(["run", failure.run.id, failure.classification.category]),
-    severity: alertSeverityFromFailure(failure),
+    fingerprint: fingerprint(["run", failure2.run.id, failure2.classification.category]),
+    severity: alertSeverityFromFailure(failure2),
     category: "run-failure",
     source: "run",
-    title: `Run ${failure.run.status}`,
-    message: failure.classification.summary,
-    observedAt: failure.updatedAt,
-    logId: failure.classification.evidenceLogIds[0] ?? null,
-    sessionId: failure.sessionId,
-    runId: failure.run.id,
+    title: `Run ${failure2.run.status}`,
+    message: failure2.classification.summary,
+    observedAt: failure2.updatedAt,
+    logId: failure2.classification.evidenceLogIds[0] ?? null,
+    sessionId: failure2.sessionId,
+    runId: failure2.run.id,
     groupId,
-    provider: providerFromRun(failure),
-    model: modelFromRun(failure),
+    provider: providerFromRun(failure2),
+    model: modelFromRun(failure2),
     apiFormat: null,
     evidence: links,
     metadata: {
-      runStatus: failure.run.status,
-      failureCategory: failure.classification.category,
-      evidenceMarkdownPath: failure.evidenceMarkdownPath
+      runStatus: failure2.run.status,
+      failureCategory: failure2.classification.category,
+      evidenceMarkdownPath: failure2.evidenceMarkdownPath
     }
   };
 }
 function addRunFailureObservations(map, recentFailures) {
-  for (const failure of recentFailures) {
-    addObservation(map, runFailureObservation(failure));
+  for (const failure2 of recentFailures) {
+    addObservation(map, runFailureObservation(failure2));
   }
 }
 function memberProvider(member) {
@@ -12950,14 +12906,14 @@ const MAX_CONTEXT_CHARS = 18e3;
 const MAX_HISTORY_CHARS = 4e3;
 const PI_AGENT_MAX_OUTPUT_TOKENS = 900;
 const DEFAULT_CONTEXT_WINDOW = 128e3;
-function nonEmpty(value) {
+function nonEmpty$1(value) {
   return value !== void 0 && value.trim() !== "" ? value.trim() : void 0;
 }
 function firstModel(provider) {
-  const explicitModel = nonEmpty(provider.model);
+  const explicitModel = nonEmpty$1(provider.model);
   if (explicitModel !== void 0) return explicitModel;
   for (const model of provider.models) {
-    const trimmed = nonEmpty(model);
+    const trimmed = nonEmpty$1(model);
     if (trimmed !== void 0) return trimmed;
   }
   return void 0;
@@ -12978,7 +12934,7 @@ function selectProvider(request) {
   for (const provider of providerCandidates(request)) {
     const modelName = request.model ?? firstModel(provider);
     if (modelName === void 0) continue;
-    const responsesBaseUrl = nonEmpty(provider.openaiResponsesBaseUrl);
+    const responsesBaseUrl = nonEmpty$1(provider.openaiResponsesBaseUrl);
     if (responsesBaseUrl !== void 0) {
       return {
         provider,
@@ -12989,7 +12945,7 @@ function selectProvider(request) {
         upstreamPath: "/v1/responses"
       };
     }
-    const openaiBaseUrl = nonEmpty(provider.openaiBaseUrl);
+    const openaiBaseUrl = nonEmpty$1(provider.openaiBaseUrl);
     if (openaiBaseUrl !== void 0) {
       return {
         provider,
@@ -13000,7 +12956,7 @@ function selectProvider(request) {
         upstreamPath: "/v1/chat/completions"
       };
     }
-    const anthropicBaseUrl = nonEmpty(provider.anthropicBaseUrl);
+    const anthropicBaseUrl = nonEmpty$1(provider.anthropicBaseUrl);
     if (anthropicBaseUrl !== void 0) {
       return {
         provider,
@@ -13131,14 +13087,14 @@ function stripUrlSuffix(value, suffix) {
 }
 function sdkBaseUrlFromFinalUrl(finalUrl, protocol) {
   try {
-    const url = new URL(finalUrl);
-    const pathname = url.pathname.replace(/\/+$/, "");
+    const url2 = new URL(finalUrl);
+    const pathname = url2.pathname.replace(/\/+$/, "");
     const suffixes = protocol === "openaiResponses" ? ["/responses"] : protocol === "openaiChat" ? ["/chat/completions"] : ["/v1/messages", "/messages"];
     for (const suffix of suffixes) {
       const nextPath = stripUrlSuffix(pathname, suffix);
       if (nextPath !== null) {
-        url.pathname = nextPath;
-        return url.toString().replace(/\/+$/, "");
+        url2.pathname = nextPath;
+        return url2.toString().replace(/\/+$/, "");
       }
     }
   } catch {
@@ -13278,7 +13234,7 @@ async function runPiAgent(request) {
     queryStats: retrieval.queryStats
   };
 }
-const Route$F = createFileRoute("/api/pi-agent")({
+const Route$L = createFileRoute("/api/pi-agent")({
   server: {
     handlers: {
       POST: async ({ request }) => {
@@ -13301,7 +13257,7 @@ const Route$F = createFileRoute("/api/pi-agent")({
     }
   }
 });
-const Route$E = createFileRoute("/api/models")({
+const Route$K = createFileRoute("/api/models")({
   server: {
     handlers: {
       GET: () => Response.json(getModels())
@@ -13309,33 +13265,158 @@ const Route$E = createFileRoute("/api/models")({
   }
 });
 const name = "@tonyclaw/agent-inspector";
-const version = "3.0.44";
+const version = "3.0.45";
 const packageJson = {
   name,
   version
 };
-let overridePort = null;
-function setCurrentPort(port) {
-  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-    throw new Error(`setCurrentPort: invalid port ${port}`);
-  }
-  overridePort = port;
-}
-function getCurrentPort() {
-  if (overridePort !== null) return overridePort;
-  const publicPort = process.env["AGENT_INSPECTOR_PUBLIC_PORT"];
-  if (publicPort !== void 0 && publicPort !== "") {
-    const n = Number(publicPort);
-    if (Number.isInteger(n) && n > 0 && n <= 65535) return n;
-  }
-  const envPort = process.env["PORT"];
-  if (envPort !== void 0 && envPort !== "") {
-    const n = Number(envPort);
-    if (Number.isInteger(n) && n > 0 && n <= 65535) return n;
-  }
-  throw new Error(
-    "Inspector server port not initialized: PORT env var is unset and setCurrentPort() has not been called"
-  );
+const INSTANCE_API_SCHEMA_VERSION = 1;
+const InstanceStateSchema = _enum(["running", "stopped", "conflict"]);
+const InstanceStateReasonSchema = _enum(["identity_mismatch", "port_conflict"]);
+const InstanceUrlsSchema = object({
+  ui: url(),
+  api: url(),
+  health: url(),
+  proxy: url(),
+  openai: url(),
+  mcp: url()
+}).strict();
+const InstanceStatusOutputSchema = object({
+  schemaVersion: literal(INSTANCE_API_SCHEMA_VERSION),
+  name: string().min(1),
+  instanceId: string().min(1),
+  state: InstanceStateSchema,
+  stateReason: InstanceStateReasonSchema.nullable(),
+  checkedAt: datetime(),
+  createdAt: datetime(),
+  updatedAt: datetime(),
+  launch: object({
+    launchId: string().min(1),
+    startedAt: datetime()
+  }).strict(),
+  host: string().min(1),
+  publicPort: number().int().min(1).max(65535),
+  upstreamPort: number().int().min(1).max(65535),
+  basePath: string().startsWith("/"),
+  captureMode: _enum(["simple", "full"]),
+  dataDir: string().min(1),
+  supervisorPid: number().int().positive().nullable(),
+  urls: InstanceUrlsSchema
+}).strict();
+const InstanceConnectionOutputSchema = object({
+  schemaVersion: literal(INSTANCE_API_SCHEMA_VERSION),
+  instance: InstanceStatusOutputSchema,
+  baseUrl: url(),
+  endpoints: InstanceUrlsSchema,
+  environment: object({
+    ANTHROPIC_BASE_URL: url(),
+    LLM_BASE_URL: url(),
+    OPENAI_BASE_URL: url(),
+    AGENT_INSPECTOR_MCP_URL: url()
+  }).strict(),
+  mcp: object({
+    serverName: string().min(1),
+    transport: literal("streamable-http"),
+    url: url()
+  }).strict(),
+  codex: object({
+    providerName: string().min(1),
+    baseUrl: url(),
+    wireApi: literal("responses")
+  }).strict()
+}).strict();
+const InstanceStartRequestSchema = object({
+  port: number().int().min(1).max(65535).optional(),
+  basePath: string().min(1).max(2048).refine(
+    (value) => value.startsWith("/") && !value.includes("?") && !value.includes("#") && !value.includes("\\"),
+    "Base Path must be an absolute URL path without query, hash, or backslash"
+  ).optional(),
+  host: string().min(1).max(253).refine(
+    (value) => value.trim() === value && !value.includes("://") && !value.includes("/") && !value.includes("\\") && !/\s/u.test(value),
+    "Host must be a hostname or IP address without protocol, path, or whitespace"
+  ).optional(),
+  captureMode: _enum(["simple", "full"]).optional(),
+  dataDir: string().trim().min(1).max(32767).optional()
+}).strict();
+const InstanceEmptyRequestSchema = object({}).strict();
+const InstanceOperationSchema = _enum(["start", "stop", "restart"]);
+const InstanceOperationOutcomeSchema = _enum([
+  "created",
+  "started",
+  "already_running",
+  "stopped",
+  "already_stopped",
+  "restarted"
+]);
+const InstanceOperationOutputSchema = object({
+  schemaVersion: literal(INSTANCE_API_SCHEMA_VERSION),
+  operation: InstanceOperationSchema,
+  outcome: InstanceOperationOutcomeSchema,
+  instance: InstanceStatusOutputSchema
+}).strict();
+const InstanceListOutputSchema = object({
+  schemaVersion: literal(INSTANCE_API_SCHEMA_VERSION),
+  instances: array(InstanceStatusOutputSchema)
+}).strict();
+const InstancePublicErrorCodeSchema = _enum([
+  "argument_invalid",
+  "config_mismatch",
+  "data_dir_conflict",
+  "data_dir_invalid",
+  "identity_mismatch",
+  "instance_not_found",
+  "launch_failed",
+  "launch_unavailable",
+  "lock_not_owned",
+  "lock_timeout",
+  "name_invalid",
+  "port_conflict",
+  "port_exhausted",
+  "port_invalid",
+  "record_invalid",
+  "registry_io",
+  "restart_failed_degraded",
+  "restart_failed_rolled_back",
+  "self_lifecycle_unsupported",
+  "shutdown_failed"
+]);
+const InstancePublicErrorSchema = object({
+  code: InstancePublicErrorCodeSchema,
+  message: string().min(1),
+  retryable: boolean()
+}).strict();
+const InstanceErrorOutputSchema = object({
+  schemaVersion: literal(INSTANCE_API_SCHEMA_VERSION),
+  error: InstancePublicErrorSchema
+}).strict();
+function isRetryableInstanceError(code) {
+  switch (code) {
+    case "launch_failed":
+    case "launch_unavailable":
+    case "lock_timeout":
+    case "port_exhausted":
+    case "registry_io":
+    case "restart_failed_degraded":
+    case "restart_failed_rolled_back":
+    case "shutdown_failed":
+      return true;
+    case "argument_invalid":
+    case "config_mismatch":
+    case "data_dir_conflict":
+    case "data_dir_invalid":
+    case "identity_mismatch":
+    case "instance_not_found":
+    case "lock_not_owned":
+    case "name_invalid":
+    case "port_conflict":
+    case "port_invalid":
+    case "record_invalid":
+    case "self_lifecycle_unsupported":
+      return false;
+  }
+}
+function instanceErrorOutput(error) {
+  return { schemaVersion: INSTANCE_API_SCHEMA_VERSION, error };
 }
 function envString(name2) {
   const value = process.env[name2];
@@ -13370,6 +13451,7 @@ function setCurrentContext(patch) {
   };
   return currentContext;
 }
+const MCP_INSTANCE_WRITES_ENV = "AGENT_INSPECTOR_MCP_INSTANCE_WRITES";
 function parseFlag(value) {
   if (value === void 0) return null;
   switch (value.trim().toLowerCase()) {
@@ -13393,6 +13475,20 @@ function isMcpWriteEnabled() {
   const writesFlag = parseFlag(process.env["AGENT_INSPECTOR_MCP_WRITES"]);
   return writesFlag === true;
 }
+function isMcpInstanceWriteEnabled() {
+  return process.env[MCP_INSTANCE_WRITES_ENV] === "1";
+}
+function getMcpInstanceModeInfo() {
+  const writesEnabled = isMcpInstanceWriteEnabled();
+  return {
+    writeMode: writesEnabled ? "enabled" : "readonly",
+    writesEnabled,
+    env: {
+      AGENT_INSPECTOR_MCP_INSTANCE_WRITES: process.env[MCP_INSTANCE_WRITES_ENV] ?? null
+    },
+    note: writesEnabled ? "Named-instance lifecycle tools passed the instance-specific opt-in. General MCP writes must also be enabled." : "Named-instance lifecycle tools require AGENT_INSPECTOR_MCP_INSTANCE_WRITES=1 in addition to general MCP writes."
+  };
+}
 function getMcpModeInfo() {
   const writesEnabled = isMcpWriteEnabled();
   return {
@@ -13405,6 +13501,95 @@ function getMcpModeInfo() {
     note: writesEnabled ? "MCP write/action tools are enabled explicitly by AGENT_INSPECTOR_MCP_WRITES=1." : "MCP is readonly by default. Read tools/resources still work; set AGENT_INSPECTOR_MCP_WRITES=1 to enable mutations."
   };
 }
+const INSTANCE_LIFECYCLE_TIMEOUT_MS = 6e4;
+const InstanceToolNameSchema = string().trim().min(1).max(64);
+const InstanceLifecycleToolInputSchema = InstanceStartRequestSchema.extend({
+  name: InstanceToolNameSchema
+});
+const InstanceNameToolInputSchema = object({
+  name: InstanceToolNameSchema
+}).strict();
+function textJson$1(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function toolError$1(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+async function responseJson$1(response) {
+  try {
+    const value = await response.json();
+    return value;
+  } catch {
+    return null;
+  }
+}
+async function validatedInstanceResponse(response, schema, operation) {
+  const value = await responseJson$1(response);
+  if (!response.ok) {
+    const error = InstanceErrorOutputSchema.safeParse(value);
+    return error.success ? { ...textJson$1(error.data), isError: true } : toolError$1(
+      `${operation} returned HTTP ${String(response.status)} with an invalid error body`
+    );
+  }
+  const parsed = schema.safeParse(value);
+  return parsed.success ? textJson$1(parsed.data) : toolError$1(`${operation} returned an invalid public instance document`);
+}
+function instancePath(name2, suffix = "") {
+  return `/api/instances/${encodeURIComponent(name2)}${suffix}`;
+}
+function jsonPost(body) {
+  return {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body),
+    timeoutMs: INSTANCE_LIFECYCLE_TIMEOUT_MS
+  };
+}
+function lifecycleRequest(input) {
+  return {
+    port: input.port,
+    basePath: input.basePath,
+    host: input.host,
+    captureMode: input.captureMode,
+    dataDir: input.dataDir
+  };
+}
+async function listInstancesImpl(callApi2) {
+  const response = await callApi2("/api/instances", {
+    headers: { accept: "application/json" }
+  });
+  return validatedInstanceResponse(response, InstanceListOutputSchema, "GET /api/instances");
+}
+async function getInstanceImpl(callApi2, name2) {
+  const path2 = instancePath(name2);
+  const response = await callApi2(path2, { headers: { accept: "application/json" } });
+  return validatedInstanceResponse(response, InstanceStatusOutputSchema, `GET ${path2}`);
+}
+async function getInstanceConnectionImpl(callApi2, name2) {
+  const path2 = instancePath(name2, "/connection");
+  const response = await callApi2(path2, { headers: { accept: "application/json" } });
+  return validatedInstanceResponse(response, InstanceConnectionOutputSchema, `GET ${path2}`);
+}
+async function startInstanceImpl(callApi2, input) {
+  const path2 = instancePath(input.name, "/start");
+  const request = lifecycleRequest(input);
+  const response = await callApi2(path2, jsonPost(InstanceStartRequestSchema.parse(request)));
+  return validatedInstanceResponse(response, InstanceOperationOutputSchema, `POST ${path2}`);
+}
+async function stopInstanceImpl(callApi2, name2) {
+  const path2 = instancePath(name2, "/stop");
+  const response = await callApi2(path2, jsonPost(InstanceEmptyRequestSchema.parse({})));
+  return validatedInstanceResponse(response, InstanceOperationOutputSchema, `POST ${path2}`);
+}
+async function restartInstanceImpl(callApi2, input) {
+  const path2 = instancePath(input.name, "/restart");
+  const request = lifecycleRequest(input);
+  const response = await callApi2(path2, jsonPost(InstanceStartRequestSchema.parse(request)));
+  return validatedInstanceResponse(response, InstanceOperationOutputSchema, `POST ${path2}`);
+}
 function groupEvidenceDir(groupId) {
   return join(getDataDir(), "evidence", "groups", groupId);
 }
@@ -13774,9 +13959,16 @@ async function callApi(path2, options = {}) {
   if (!path2.startsWith("/")) {
     throw new Error(`callApi: path must start with '/', got: ${path2}`);
   }
-  const port = getCurrentPort();
-  const url = `http://127.0.0.1:${port}${withBasePath(path2, getConfiguredBasePath(process.env))}`;
+  const port = getPublicPort();
+  const publicBasePath = getPublicBasePath();
+  const url2 = `http://127.0.0.1:${port}${withBasePath(path2, publicBasePath)}`;
   const { timeoutMs = DEFAULT_TIMEOUT_MS, signal: userSignal, ...rest } = options;
+  const headers = new Headers(rest.headers);
+  headers.set(
+    AGENT_INSPECTOR_PUBLIC_BASE_PATH_HEADER,
+    publicBasePath.length === 0 ? "/" : publicBasePath
+  );
+  headers.set(AGENT_INSPECTOR_PUBLIC_PORT_HEADER, String(port));
   const controller = new AbortController();
   const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
   if (userSignal !== void 0 && userSignal !== null) {
@@ -13787,7 +13979,7 @@ async function callApi(path2, options = {}) {
     }
   }
   try {
-    return await fetch(url, { ...rest, signal: controller.signal });
+    return await fetch(url2, { ...rest, headers, signal: controller.signal });
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
       throw new LoopbackTimeoutError(path2, timeoutMs);
@@ -13995,7 +14187,7 @@ function redactedProvidersResult(value) {
   return textJson(toRedactedProviderDtos(parsed.data));
 }
 function inspectorBaseUrl() {
-  return `http://127.0.0.1:${String(getCurrentPort())}`;
+  return `http://127.0.0.1:${String(getPublicPort())}`;
 }
 function hasBodyText(value, byteLength) {
   if (value !== null && value.length > 0) return true;
@@ -14527,8 +14719,8 @@ async function diagnoseCaptureImpl(callApi2, args = {}) {
     runtimePayload = JSON.parse(runtimeText);
   } catch {
   }
-  const runtimeRecord = isRecord(runtimePayload) ? runtimePayload : {};
-  const configRecord = isRecord(runtimeRecord["config"]) ? runtimeRecord["config"] : {};
+  const runtimeRecord = isRecord$2(runtimePayload) ? runtimePayload : {};
+  const configRecord = isRecord$2(runtimeRecord["config"]) ? runtimeRecord["config"] : {};
   const captureMode = stringField(configRecord, "captureMode");
   let log = null;
   if (args.id !== void 0) {
@@ -14850,11 +15042,11 @@ function collectProviderDiagnosticIssues(value, path2, issues) {
     );
     return;
   }
-  if (!isRecord(value)) return;
-  const success = value["success"];
+  if (!isRecord$2(value)) return;
+  const success2 = value["success"];
   const status = firstNumberField(value, ["status", "responseStatus", "statusCode"]);
   const error = firstStringField(value, ["error", "message", "errorMessage"]);
-  if (success === false || error !== null || status !== null && status >= 400) {
+  if (success2 === false || error !== null || status !== null && status >= 400) {
     issues.push({
       path: path2,
       status,
@@ -15055,14 +15247,10 @@ async function getServer() {
   return initPromise;
 }
 async function handleMcpRequest(request) {
-  try {
-    const url = new URL(request.url);
-    const port = Number(url.port);
-    if (port > 0) setCurrentPort(port);
-  } catch {
-  }
-  const { transport } = await getServer();
-  return transport.handleRequest(request);
+  return runWithRequestPublicBasePath(request, async () => {
+    const { transport } = await getServer();
+    return transport.handleRequest(request);
+  });
 }
 const TOOL_LIST_LOGS_DESC = `List recent captured agent/model proxy logs in reverse-chronological order with parsed previews. Useful for "what did I just send?" discovery.
 
@@ -15084,6 +15272,22 @@ Returns: array of "thick summary" objects, each containing:
 
 Either preview field is null when the body is unknown format, unparseable, or the relevant content is non-text (e.g., image-only).`;
 const PROVIDER_WRITE_WARNING = "⚠ This tool mutates provider configuration. Confirm with the user before invoking.";
+const INSTANCE_LIFECYCLE_WRITE_WARNING = "This tool changes a local Agent Inspector process. Obtain explicit user approval before invoking it.";
+const INSTANCE_READ_TOOL_NAMES = [
+  "inspector_list_instances",
+  "inspector_get_instance",
+  "inspector_get_instance_connection"
+];
+const INSTANCE_WRITE_TOOL_NAMES = [
+  "inspector_start_instance",
+  "inspector_stop_instance",
+  "inspector_restart_instance"
+];
+const INSTANCE_RESOURCE_URIS = [
+  "inspector://instances",
+  "inspector://instances/{name}",
+  "inspector://instances/{name}/connection"
+];
 const AddProviderInputSchema = object({
   name: string().min(1).describe("Provider display name."),
   apiKey: string().min(1).describe("Plaintext provider API key."),
@@ -15132,9 +15336,9 @@ function jsonResource(uri, data) {
   return textResource(uri, "application/json", JSON.stringify(data, null, 2));
 }
 function mcpEndpointUrl() {
-  return `http://localhost:${String(getCurrentPort())}${withBasePath(
+  return `http://localhost:${String(getPublicPort())}${withBasePath(
     "/api/mcp",
-    getConfiguredBasePath(process.env)
+    getPublicBasePath()
   )}`;
 }
 function mcpHealth() {
@@ -15146,7 +15350,7 @@ function mcpHealth() {
     },
     transport: {
       primary: "streamable-http",
-      endpoint: withBasePath("/api/mcp", getConfiguredBasePath(process.env)),
+      endpoint: mcpEndpointUrl(),
       stateless: true
     },
     mode: getMcpModeInfo(),
@@ -15158,6 +15362,7 @@ function mcpHealth() {
   };
 }
 const WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  ...INSTANCE_WRITE_TOOL_NAMES,
   "inspector_create_run",
   "inspector_update_run",
   "inspector_export_evidence",
@@ -15181,42 +15386,59 @@ const WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
 function mcpCapabilities() {
   const readTools = TOOL_NAMES.filter((name2) => !WRITE_TOOL_NAMES.has(name2));
   const writeTools = TOOL_NAMES.filter((name2) => WRITE_TOOL_NAMES.has(name2));
+  const generalWriteMode = getMcpModeInfo();
+  const instanceWriteMode = getMcpInstanceModeInfo();
   return {
     serverInfo: {
       name: "agent-inspector",
       version: MCP_SERVER_VERSION
     },
-    mode: getMcpModeInfo(),
+    mode: generalWriteMode,
     tools: {
       read: readTools,
       writeOrAction: writeTools
     },
     resources: RESOURCE_NAMES,
-    prompts: PROMPT_NAMES
+    prompts: PROMPT_NAMES,
+    instanceControl: {
+      tools: {
+        read: INSTANCE_READ_TOOL_NAMES,
+        writeOrAction: INSTANCE_WRITE_TOOL_NAMES
+      },
+      resources: INSTANCE_RESOURCE_URIS,
+      writeGates: {
+        general: generalWriteMode,
+        instance: instanceWriteMode,
+        lifecycleWritesEnabled: generalWriteMode.writesEnabled && instanceWriteMode.writesEnabled
+      },
+      limitations: {
+        selfStopOrRestart: "The serving managed instance cannot stop or restart itself over REST or MCP. Use the CLI or a sibling controller instance."
+      }
+    }
   };
 }
 function mcpConfig() {
-  const endpoint = mcpEndpointUrl();
+  const endpoint2 = mcpEndpointUrl();
   return {
     streamableHttp: {
-      endpoint,
+      endpoint: endpoint2,
       config: {
         mcpServers: {
           "agent-inspector": {
             type: "streamableHttp",
-            url: endpoint
+            url: endpoint2
           }
         }
       }
     },
     stdioBridge: {
       command: "agent-inspector-mcp",
-      args: ["stdio", "--url", endpoint],
+      args: ["stdio", "--url", endpoint2],
       config: {
         mcpServers: {
           "agent-inspector": {
             command: "agent-inspector-mcp",
-            args: ["stdio", "--url", endpoint]
+            args: ["stdio", "--url", endpoint2]
           }
         }
       }
@@ -15225,7 +15447,7 @@ function mcpConfig() {
       mcp: {
         "agent-inspector": {
           type: "local",
-          command: ["agent-inspector-mcp", "stdio", "--url", endpoint],
+          command: ["agent-inspector-mcp", "stdio", "--url", endpoint2],
           enabled: true
         }
       }
@@ -15234,7 +15456,7 @@ function mcpConfig() {
       mcp: {
         "agent-inspector": {
           type: "local",
-          command: ["agent-inspector-mcp", "stdio", "--url", endpoint],
+          command: ["agent-inspector-mcp", "stdio", "--url", endpoint2],
           enabled: true
         }
       }
@@ -15267,6 +15489,32 @@ function safeWriteCall(toolName, fn) {
     return fn();
   });
 }
+function disabledInstanceWriteTool(toolName) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            error: "mcp-instance-write-disabled",
+            tool: toolName,
+            generalMode: getMcpModeInfo(),
+            instanceMode: getMcpInstanceModeInfo()
+          },
+          null,
+          2
+        )
+      }
+    ],
+    isError: true
+  };
+}
+function safeInstanceWriteCall(toolName, fn) {
+  return safeWriteCall(
+    toolName,
+    () => isMcpInstanceWriteEnabled() ? fn() : disabledInstanceWriteTool(toolName)
+  );
+}
 function variableString(variables, name2) {
   const value = variables[name2];
   if (Array.isArray(value)) return value[0] ?? null;
@@ -15291,6 +15539,32 @@ function readServiceJsonResource(uri, result) {
   if (!result.ok) return textResource(uri, "text/plain", result.message);
   return jsonResource(uri, result.value);
 }
+async function readInstanceToolResource(uri, resultPromise) {
+  const result = await resultPromise;
+  const text = result.content[0]?.text ?? "";
+  return textResource(uri, result.isError === true ? "text/plain" : "application/json", text);
+}
+async function listInstanceTemplateResources(connection) {
+  try {
+    const response = await callApi("/api/instances", {
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok) return listResult([]);
+    const parsed = InstanceListOutputSchema.safeParse(await response.json());
+    if (!parsed.success) return listResult([]);
+    return listResult(
+      parsed.data.instances.map((instance) => ({
+        uri: connection ? `inspector://instances/${encodeURIComponent(instance.name)}/connection` : `inspector://instances/${encodeURIComponent(instance.name)}`,
+        name: connection ? `instance-connection:${instance.name}` : `instance:${instance.name}`,
+        title: connection ? `Agent Inspector connection for ${instance.name}` : `Agent Inspector instance ${instance.name}`,
+        mimeType: "application/json",
+        description: `${instance.state} at ${instance.urls.ui}`
+      }))
+    );
+  } catch {
+    return listResult([]);
+  }
+}
 async function listSessionResources() {
   try {
     const response = await callApi("/api/sessions");
@@ -15467,6 +15741,60 @@ function userPrompt(text) {
   };
 }
 function registerTools(server) {
+  server.registerTool(
+    "inspector_list_instances",
+    {
+      title: "List named Agent Inspector instances",
+      description: "Returns the versioned, token-free REST instance list with live state, saved configuration, and public URLs. Available in readonly mode.",
+      inputSchema: object({}).strict()
+    },
+    () => safeCall(() => listInstancesImpl(callApi))
+  );
+  server.registerTool(
+    "inspector_get_instance",
+    {
+      title: "Get a named Agent Inspector instance",
+      description: "Returns one versioned, token-free named-instance status document from the REST control plane. Available in readonly mode.",
+      inputSchema: InstanceNameToolInputSchema
+    },
+    ({ name: name2 }) => safeCall(() => getInstanceImpl(callApi, name2))
+  );
+  server.registerTool(
+    "inspector_get_instance_connection",
+    {
+      title: "Get coding-agent connection settings for an instance",
+      description: "Returns the REST connection descriptor for one named instance, including protocol-correct proxy, OpenAI /v1, MCP, health, environment, and Codex values. It never includes credentials.",
+      inputSchema: InstanceNameToolInputSchema
+    },
+    ({ name: name2 }) => safeCall(() => getInstanceConnectionImpl(callApi, name2))
+  );
+  server.registerTool(
+    "inspector_start_instance",
+    {
+      title: "Start or create a named Agent Inspector instance",
+      description: `${INSTANCE_LIFECYCLE_WRITE_WARNING} Starts, creates, or idempotently reuses a named sibling instance through the REST lifecycle API. Requires both AGENT_INSPECTOR_MCP_WRITES=1 and AGENT_INSPECTOR_MCP_INSTANCE_WRITES=1.`,
+      inputSchema: InstanceLifecycleToolInputSchema
+    },
+    (args) => safeInstanceWriteCall("inspector_start_instance", () => startInstanceImpl(callApi, args))
+  );
+  server.registerTool(
+    "inspector_stop_instance",
+    {
+      title: "Stop a named Agent Inspector instance",
+      description: `${INSTANCE_LIFECYCLE_WRITE_WARNING} Gracefully stops a sibling instance after authenticated ownership checks. The instance serving this MCP connection cannot stop itself. Requires both MCP write gates.`,
+      inputSchema: InstanceNameToolInputSchema
+    },
+    ({ name: name2 }) => safeInstanceWriteCall("inspector_stop_instance", () => stopInstanceImpl(callApi, name2))
+  );
+  server.registerTool(
+    "inspector_restart_instance",
+    {
+      title: "Restart a named Agent Inspector instance",
+      description: `${INSTANCE_LIFECYCLE_WRITE_WARNING} Validates and restarts a sibling instance through the bounded REST lifecycle path. The instance serving this MCP connection cannot restart itself. Requires both MCP write gates.`,
+      inputSchema: InstanceLifecycleToolInputSchema
+    },
+    (args) => safeInstanceWriteCall("inspector_restart_instance", () => restartInstanceImpl(callApi, args))
+  );
   server.registerTool(
     "inspector_list_logs",
     {
@@ -16012,6 +16340,46 @@ PATCH-style update: only the fields you supply are changed. Use models to update
   );
 }
 function registerResources(server) {
+  server.registerResource(
+    "inspector_instances",
+    "inspector://instances",
+    {
+      title: "Named Agent Inspector instances",
+      description: "Versioned, token-free named-instance list backed by GET /api/instances.",
+      mimeType: "application/json"
+    },
+    (uri) => readInstanceToolResource(uri, listInstancesImpl(callApi))
+  );
+  server.registerResource(
+    "inspector_instance",
+    new ResourceTemplate("inspector://instances/{name}", {
+      list: async () => await listInstanceTemplateResources(false)
+    }),
+    {
+      title: "Named Agent Inspector instance",
+      description: "Versioned, token-free status for one named instance backed by GET /api/instances/{name}.",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const name2 = variableString(variables, "name");
+      return name2 === null ? textResource(uri, "text/plain", "Missing instance name") : readInstanceToolResource(uri, getInstanceImpl(callApi, name2));
+    }
+  );
+  server.registerResource(
+    "inspector_instance_connection",
+    new ResourceTemplate("inspector://instances/{name}/connection", {
+      list: async () => await listInstanceTemplateResources(true)
+    }),
+    {
+      title: "Named instance coding-agent connection",
+      description: "Token-free connection descriptor backed by GET /api/instances/{name}/connection.",
+      mimeType: "application/json"
+    },
+    (uri, variables) => {
+      const name2 = variableString(variables, "name");
+      return name2 === null ? textResource(uri, "text/plain", "Missing instance name") : readInstanceToolResource(uri, getInstanceConnectionImpl(callApi, name2));
+    }
+  );
   server.registerResource(
     "inspector_mcp_health",
     "inspector://mcp/health",
@@ -16456,6 +16824,8 @@ Return:
   );
 }
 const TOOL_NAMES = [
+  ...INSTANCE_READ_TOOL_NAMES,
+  ...INSTANCE_WRITE_TOOL_NAMES,
   "inspector_list_logs",
   "inspector_search_logs",
   "inspector_get_log",
@@ -16503,6 +16873,9 @@ const TOOL_NAMES = [
   "inspector_get_project_context"
 ];
 const RESOURCE_NAMES = [
+  "inspector_instances",
+  "inspector_instance",
+  "inspector_instance_connection",
   "inspector_mcp_health",
   "inspector_mcp_capabilities",
   "inspector_mcp_config",
@@ -16533,7 +16906,7 @@ const PROMPT_NAMES = [
   "inspector_generate_group_report",
   "inspector_extract_repro_steps"
 ];
-const Route$D = createFileRoute("/api/mcp")({
+const Route$J = createFileRoute("/api/mcp")({
   server: {
     handlers: {
       // The SDK may issue either POST, GET, or DELETE. TanStack Start only
@@ -16646,15 +17019,15 @@ function parseOptionalPositiveInt(value) {
   if (!Number.isInteger(parsed) || parsed < 1) return { ok: false };
   return { ok: true, value: parsed };
 }
-const Route$C = createFileRoute("/api/logs")({
+const Route$I = createFileRoute("/api/logs")({
   server: {
     handlers: {
       GET: async ({ request }) => {
-        const url = new URL(request.url);
-        if (url.searchParams.get("stats") === "1") {
+        const url2 = new URL(request.url);
+        if (url2.searchParams.get("stats") === "1") {
           return Response.json(getLogStorageStats());
         }
-        const replayOf = url.searchParams.get("replayOf");
+        const replayOf = url2.searchParams.get("replayOf");
         if (replayOf !== null) {
           const id = Number(replayOf);
           if (!Number.isInteger(id) || id <= 0) {
@@ -16663,15 +17036,15 @@ const Route$C = createFileRoute("/api/logs")({
           const logs = getReplayLogsForSource(id);
           return Response.json({ logs, total: logs.length, offset: 0, limit: logs.length });
         }
-        const sessionId = url.searchParams.get("sessionId") ?? void 0;
-        const model = url.searchParams.get("model") ?? void 0;
-        const clientPidResult = parseOptionalPositiveInt(url.searchParams.get("clientPid"));
+        const sessionId = url2.searchParams.get("sessionId") ?? void 0;
+        const model = url2.searchParams.get("model") ?? void 0;
+        const clientPidResult = parseOptionalPositiveInt(url2.searchParams.get("clientPid"));
         if (!clientPidResult.ok) {
           return Response.json({ error: "Invalid clientPid" }, { status: 400 });
         }
         const clientPid = clientPidResult.value ?? void 0;
-        const query = url.searchParams.get("q") ?? url.searchParams.get("search");
-        const offset = parseNonNegativeInt(url.searchParams.get("offset"), 0);
+        const query = url2.searchParams.get("q") ?? url2.searchParams.get("search");
+        const offset = parseNonNegativeInt(url2.searchParams.get("offset"), 0);
         if (query !== null) {
           if (query.length > MAX_SEARCH_QUERY_CHARS) {
             return resourceLimitResponse({
@@ -16684,7 +17057,7 @@ const Route$C = createFileRoute("/api/logs")({
             });
           }
           const limitResult2 = parseBoundedIntegerParameter({
-            value: url.searchParams.get("limit"),
+            value: url2.searchParams.get("limit"),
             parameter: "limit",
             fallback: LOG_SEARCH_DEFAULT_LIMIT,
             minimum: 1,
@@ -16693,7 +17066,7 @@ const Route$C = createFileRoute("/api/logs")({
           });
           if (!limitResult2.ok) return limitResult2.response;
           const scanLimitResult = parseBoundedIntegerParameter({
-            value: url.searchParams.get("scanLimit"),
+            value: url2.searchParams.get("scanLimit"),
             parameter: "scanLimit",
             fallback: LOG_SEARCH_DEFAULT_SCAN_LIMIT,
             minimum: 1,
@@ -16714,7 +17087,7 @@ const Route$C = createFileRoute("/api/logs")({
           );
         }
         const limitResult = parseBoundedIntegerParameter({
-          value: url.searchParams.get("limit"),
+          value: url2.searchParams.get("limit"),
           parameter: "limit",
           fallback: 50,
           minimum: 1,
@@ -16723,10 +17096,10 @@ const Route$C = createFileRoute("/api/logs")({
         });
         if (!limitResult.ok) return limitResult.response;
         const limit = limitResult.value;
-        const includeBodies = url.searchParams.get("compact") !== "1";
-        if (url.searchParams.get("cursor") === "1" || url.searchParams.get("cursor") === "true") {
-          const beforeLogId = parseOptionalPositiveInt(url.searchParams.get("beforeLogId"));
-          const afterLogId = parseOptionalPositiveInt(url.searchParams.get("afterLogId"));
+        const includeBodies = url2.searchParams.get("compact") !== "1";
+        if (url2.searchParams.get("cursor") === "1" || url2.searchParams.get("cursor") === "true") {
+          const beforeLogId = parseOptionalPositiveInt(url2.searchParams.get("beforeLogId"));
+          const afterLogId = parseOptionalPositiveInt(url2.searchParams.get("afterLogId"));
           if (!beforeLogId.ok || !afterLogId.ok) {
             return Response.json({ error: "Invalid cursor log ID" }, { status: 400 });
           }
@@ -16736,7 +17109,7 @@ const Route$C = createFileRoute("/api/logs")({
               { status: 400 }
             );
           }
-          const anchor = url.searchParams.get("anchor") === "oldest" ? "oldest" : "newest";
+          const anchor = url2.searchParams.get("anchor") === "oldest" ? "oldest" : "newest";
           return Response.json(
             await listLogsCursorPage({
               sessionId,
@@ -16803,94 +17176,1549 @@ const Route$C = createFileRoute("/api/logs")({
     }
   }
 });
-function createShutdownCoordinator(dependencies, deadlineMs) {
-  let shutdownPromise = null;
-  async function shutdown(_reason = "manual") {
-    if (shutdownPromise !== null) return await shutdownPromise;
-    dependencies.markShuttingDown();
-    dependencies.stopAdmission();
-    let forced = false;
-    let forceClosed = false;
-    let deadline = null;
-    function forceCloseOnce() {
-      if (forceClosed) return;
-      forceClosed = true;
-      dependencies.forceClose();
-    }
-    async function gracefulShutdown() {
-      try {
-        await dependencies.drainTraffic();
-        if (forced) return { forced: true, reason: "deadline" };
-        await dependencies.drainFinalizers();
-        if (forced) return { forced: true, reason: "deadline" };
-        await dependencies.flushPersistence();
-        if (forced) return { forced: true, reason: "deadline" };
-        await dependencies.closeResources();
-        return { forced: false, reason: "completed" };
-      } catch {
-        forceCloseOnce();
-        return { forced: true, reason: "error" };
-      }
-    }
-    const timedOut = new Promise((resolve2) => {
-      deadline = setTimeout(
-        () => {
-          forced = true;
-          forceCloseOnce();
-          resolve2({ forced: true, reason: "deadline" });
-        },
-        Math.max(1, deadlineMs)
-      );
-    });
-    shutdownPromise = Promise.race([gracefulShutdown(), timedOut]).finally(() => {
-      if (deadline !== null) clearTimeout(deadline);
-    });
-    return await shutdownPromise;
-  }
-  return { shutdown };
+const MANAGED_INSTANCE_CONTROL_PATH = "/.agent-inspector/instance";
+const MANAGED_INSTANCE_SHUTDOWN_PATH = `${MANAGED_INSTANCE_CONTROL_PATH}/shutdown`;
+const MANAGED_INSTANCE_TOKEN_HEADER = "x-agent-inspector-instance-token";
+const MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE = "agent-inspector:managed-shutdown";
+const AGENT_INSPECTOR_CLI_ENTRY_ENV = "AGENT_INSPECTOR_CLI_ENTRY";
+const MANAGED_INSTANCE_ENV = {
+  name: "AGENT_INSPECTOR_INSTANCE_NAME",
+  instanceId: "AGENT_INSPECTOR_INSTANCE_ID",
+  launchId: "AGENT_INSPECTOR_INSTANCE_LAUNCH_ID",
+  controlToken: "AGENT_INSPECTOR_INSTANCE_CONTROL_TOKEN",
+  startedAt: "AGENT_INSPECTOR_INSTANCE_STARTED_AT",
+  upstreamPort: "AGENT_INSPECTOR_UPSTREAM_PORT"
+};
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed === void 0 || trimmed.length === 0 ? null : trimmed;
 }
-function createShutdownSignalHandler(coordinator, onComplete) {
-  let handled = false;
-  return (signal) => {
-    if (handled) return;
-    handled = true;
-    void coordinator.shutdown(signal).then(onComplete);
+function isRecord$1(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readManagedInstanceLaunch(env = process.env) {
+  const values = [
+    env[MANAGED_INSTANCE_ENV.name],
+    env[MANAGED_INSTANCE_ENV.instanceId],
+    env[MANAGED_INSTANCE_ENV.launchId],
+    env[MANAGED_INSTANCE_ENV.controlToken],
+    env[MANAGED_INSTANCE_ENV.startedAt],
+    env[MANAGED_INSTANCE_ENV.upstreamPort]
+  ];
+  if (values.every((value) => value === void 0 || value.trim().length === 0)) {
+    return { kind: "unmanaged" };
+  }
+  const name2 = nonEmpty(env[MANAGED_INSTANCE_ENV.name]);
+  const instanceId = nonEmpty(env[MANAGED_INSTANCE_ENV.instanceId]);
+  const launchId = nonEmpty(env[MANAGED_INSTANCE_ENV.launchId]);
+  const controlToken = nonEmpty(env[MANAGED_INSTANCE_ENV.controlToken]);
+  const startedAt = nonEmpty(env[MANAGED_INSTANCE_ENV.startedAt]);
+  const upstreamPort = Number(env[MANAGED_INSTANCE_ENV.upstreamPort]);
+  if (name2 === null || instanceId === null || launchId === null || controlToken === null || controlToken.length < 32 || startedAt === null || !Number.isFinite(Date.parse(startedAt)) || !Number.isInteger(upstreamPort) || upstreamPort < 1 || upstreamPort > 65535) {
+    return {
+      kind: "invalid",
+      message: "Managed instance launch environment is incomplete or invalid."
+    };
+  }
+  return {
+    kind: "managed",
+    launch: { name: name2, instanceId, launchId, controlToken, startedAt, upstreamPort }
   };
 }
-const DEFAULT_SHUTDOWN_DEADLINE_MS = 15e3;
-function shutdownDeadlineMs() {
-  const raw = process.env["AGENT_INSPECTOR_SHUTDOWN_TIMEOUT_MS"];
-  if (raw === void 0 || raw === "") return DEFAULT_SHUTDOWN_DEADLINE_MS;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) && parsed > 0 && parsed <= 3e5 ? parsed : DEFAULT_SHUTDOWN_DEADLINE_MS;
+function parseManagedInstanceShutdownMessage(value) {
+  if (!isRecord$1(value)) return null;
+  return value["type"] === MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE && typeof value["controlToken"] === "string" ? { type: MANAGED_INSTANCE_SHUTDOWN_MESSAGE_TYPE, controlToken: value["controlToken"] } : null;
 }
-async function drainFinalizers() {
-  await flushAllRawStreamCaptures();
-  await flushSessionTasks();
-  await flushToolSchemaWarningAnalysis();
+function platformCommand(command, args, platform = process.platform) {
+  if (platform !== "win32") return { command, args: [...args] };
+  return { command: "cmd.exe", args: ["/d", "/s", "/c", command, ...args] };
 }
-async function flushPersistence() {
-  await flushLogBuffer();
-  await flushSessionArchiveWrites();
-  await flushIndex();
-  await flushApplicationLog();
+function npmCommand(platform = process.platform) {
+  return platform === "win32" ? "npm.cmd" : "npm";
 }
-async function closeResources() {
-  await closeLogFinalizerWorkers();
-  destroyAllSessionProcesses();
-  closeSqliteLogIndex();
-  await flushApplicationLog();
+function npmSpawnCommand(args, platform = process.platform) {
+  return platformCommand(npmCommand(platform), args, platform);
 }
-function forceCloseResources() {
-  forceCloseLogFinalizerWorkers();
-  destroyAllSessionProcesses();
-  closeSqliteLogIndex();
+function openUrlCommand(targetUrl, platform = process.platform) {
+  switch (platform) {
+    case "darwin":
+      return { command: "open", args: [targetUrl] };
+    case "linux":
+    case "freebsd":
+    case "openbsd":
+    case "netbsd":
+      return { command: "xdg-open", args: [targetUrl] };
+    case "win32":
+      return { command: "cmd.exe", args: ["/d", "/s", "/c", "start", "", targetUrl] };
+    case "aix":
+    case "android":
+    case "cygwin":
+    case "haiku":
+    case "sunos":
+      return null;
+  }
+  return null;
 }
-const runtimeShutdownCoordinator = createShutdownCoordinator(
-  {
-    markShuttingDown: () => setRuntimeShuttingDown(true),
-    stopAdmission: stopRuntimeAdmission,
-    drainTraffic: waitForRuntimeTrafficDrain,
+function localUrlForPort(port) {
+  return `http://localhost:${String(port)}`;
+}
+function trimHost(host) {
+  const trimmed = host?.trim();
+  return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
+}
+function isWildcardHost(host) {
+  const trimmed = trimHost(host);
+  return trimmed === void 0 || trimmed === "0.0.0.0" || trimmed === "::" || trimmed === "[::]";
+}
+function bracketIpv6(host) {
+  if (!host.includes(":")) return host;
+  if (host.startsWith("[") && host.endsWith("]")) return host;
+  return `[${host}]`;
+}
+function urlForHost(port, host) {
+  const trimmed = trimHost(host);
+  if (trimmed === void 0 || isWildcardHost(trimmed)) return localUrlForPort(port);
+  return `http://${bracketIpv6(trimmed)}:${String(port)}`;
+}
+function probeHostForBindHost(host) {
+  const trimmed = trimHost(host);
+  if (trimmed === void 0 || isWildcardHost(trimmed)) return "127.0.0.1";
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) return trimmed.slice(1, -1);
+  return trimmed;
+}
+const DEFAULT_CONTROL_TIMEOUT_MS = 2e3;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseIdentity(value) {
+  if (!isRecord(value)) return null;
+  const schemaVersion = value["schemaVersion"];
+  const instanceId = value["instanceId"];
+  const launchId = value["launchId"];
+  const supervisorPid = value["supervisorPid"];
+  const startedAt = value["startedAt"];
+  const publicPort = value["publicPort"];
+  const upstreamPort = value["upstreamPort"];
+  if (schemaVersion !== 1 || typeof instanceId !== "string" || instanceId.length === 0 || typeof launchId !== "string" || launchId.length === 0 || typeof supervisorPid !== "number" || !Number.isInteger(supervisorPid) || supervisorPid < 1 || typeof startedAt !== "string" || !Number.isFinite(Date.parse(startedAt)) || typeof publicPort !== "number" || !Number.isInteger(publicPort) || publicPort < 1 || publicPort > 65535 || typeof upstreamPort !== "number" || !Number.isInteger(upstreamPort) || upstreamPort < 1 || upstreamPort > 65535) {
+    return null;
+  }
+  return {
+    schemaVersion: 1,
+    instanceId,
+    launchId,
+    supervisorPid,
+    startedAt,
+    publicPort,
+    upstreamPort
+  };
+}
+function hostForUrl(host) {
+  if (host.startsWith("[") && host.endsWith("]")) return host;
+  return host.includes(":") ? `[${host}]` : host;
+}
+function endpoint(identity, path2) {
+  return `http://${hostForUrl(identity.host)}:${String(identity.publicPort)}${path2}`;
+}
+function requestInit(identity, controller, method) {
+  return {
+    method,
+    headers: {
+      accept: "application/json",
+      [MANAGED_INSTANCE_TOKEN_HEADER]: identity.controlToken
+    },
+    cache: "no-store",
+    signal: controller.signal
+  };
+}
+async function responseJson(response) {
+  try {
+    const value = await response.json();
+    return value;
+  } catch {
+    return null;
+  }
+}
+async function probeInstanceControl(expected, fetchImpl = fetch, timeoutMs = DEFAULT_CONTROL_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(
+      endpoint(expected, MANAGED_INSTANCE_CONTROL_PATH),
+      requestInit(expected, controller, "GET")
+    );
+    if (!response.ok) return { kind: "identity-mismatch" };
+    const identity = parseIdentity(await responseJson(response));
+    if (identity === null) return { kind: "invalid-response" };
+    if (identity.instanceId !== expected.instanceId || identity.launchId !== expected.launchId || identity.publicPort !== expected.publicPort) {
+      return { kind: "identity-mismatch" };
+    }
+    return { kind: "running", identity };
+  } catch (error) {
+    return {
+      kind: "unreachable",
+      timedOut: controller.signal.aborted || error instanceof Error && error.name === "AbortError"
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function requestInstanceShutdown(expected, fetchImpl = fetch, timeoutMs = DEFAULT_CONTROL_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(
+      endpoint(expected, MANAGED_INSTANCE_SHUTDOWN_PATH),
+      requestInit(expected, controller, "POST")
+    );
+    if (response.status === 202) return { kind: "accepted" };
+    if (response.status === 401 || response.status === 403 || response.status === 404) {
+      return { kind: "identity-mismatch" };
+    }
+    return { kind: "rejected" };
+  } catch (error) {
+    return {
+      kind: "unreachable",
+      timedOut: controller.signal.aborted || error instanceof Error && error.name === "AbortError"
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+const INSTANCE_RECORD_SCHEMA_VERSION = 1;
+const MAX_INSTANCE_NAME_LENGTH = 64;
+const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/u;
+const INSTANCE_NAME_CHARACTERS = /^[a-z0-9._-]+$/u;
+function instanceRegistrySuccess(value) {
+  return { kind: "success", value };
+}
+function instanceRegistryError(code, message) {
+  return { kind: "error", error: { code, message } };
+}
+function validateInstanceName(rawName) {
+  const normalized = rawName.toLowerCase();
+  const invalid = rawName.length === 0 || rawName !== rawName.trim() || normalized.length > MAX_INSTANCE_NAME_LENGTH || normalized === "." || normalized === ".." || normalized === "default" || normalized.endsWith(".") || normalized.endsWith(" ") || !INSTANCE_NAME_CHARACTERS.test(normalized) || WINDOWS_DEVICE_NAME.test(normalized);
+  return invalid ? instanceRegistryError(
+    "name_invalid",
+    `Invalid instance name ${JSON.stringify(rawName)}. Use 1-${String(MAX_INSTANCE_NAME_LENGTH)} letters, digits, dots, hyphens, or underscores; "default" and Windows device names are reserved.`
+  ) : instanceRegistrySuccess(normalized);
+}
+function normalizeInstanceBasePath(rawBasePath) {
+  const value = rawBasePath ?? "";
+  const trimmed = value.trim();
+  const hasControlCharacter = [...trimmed].some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint < 32 || codePoint === 127;
+  });
+  if (trimmed.length > 0 && (!trimmed.startsWith("/") || trimmed.includes("?") || trimmed.includes("#") || trimmed.includes("\\") || hasControlCharacter)) {
+    return instanceRegistryError(
+      "record_invalid",
+      "Instance Base Path must be an absolute URL path without a query, hash, backslash, or control character."
+    );
+  }
+  const normalized = normalizeBasePath(trimmed);
+  const reservedControlRoot = MANAGED_INSTANCE_CONTROL_PATH.replace(/\/instance$/u, "");
+  if (normalized === reservedControlRoot || normalized.startsWith(`${reservedControlRoot}/`)) {
+    return instanceRegistryError(
+      "record_invalid",
+      `Instance Base Path ${normalized} collides with the reserved Agent Inspector control namespace.`
+    );
+  }
+  return instanceRegistrySuccess(normalized);
+}
+const NormalizedInstanceNameSchema = string().refine((name2) => {
+  const result = validateInstanceName(name2);
+  return result.kind === "success" && result.value === name2;
+});
+const NormalizedBasePathSchema = string().refine((basePath) => {
+  const result = normalizeInstanceBasePath(basePath);
+  return result.kind === "success" && result.value === basePath;
+});
+const PortSchema = number().int().min(1).max(65535);
+const TimestampSchema = string().datetime();
+const IdentifierSchema = string().min(8).max(128);
+const InstanceLaunchSchema = object({
+  launchId: IdentifierSchema,
+  controlToken: string().min(32).max(256),
+  startedAt: TimestampSchema
+}).strict();
+const InstanceRecordSchema = object({
+  schemaVersion: literal(INSTANCE_RECORD_SCHEMA_VERSION),
+  name: NormalizedInstanceNameSchema,
+  instanceId: IdentifierSchema,
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+  host: string().trim().min(1).max(255),
+  publicPort: PortSchema,
+  upstreamPort: PortSchema,
+  basePath: NormalizedBasePathSchema,
+  captureMode: CaptureModeSchema,
+  dataDir: string().min(1).refine((path2) => isAbsolute(path2)),
+  launch: InstanceLaunchSchema
+}).strict().superRefine((record2, context) => {
+  if (record2.publicPort === record2.upstreamPort) {
+    context.addIssue({
+      code: "custom",
+      message: "Public and upstream ports must be different.",
+      path: ["upstreamPort"]
+    });
+  }
+});
+function createLaunch(factory, now) {
+  return {
+    launchId: factory.createLaunchId?.() ?? randomUUID(),
+    controlToken: factory.createControlToken?.() ?? randomBytes(32).toString("base64url"),
+    startedAt: now.toISOString()
+  };
+}
+function createInstanceRecord(input, factory = {}) {
+  const name2 = validateInstanceName(input.name);
+  if (name2.kind === "error") return name2;
+  const basePath = normalizeInstanceBasePath(input.basePath);
+  if (basePath.kind === "error") return basePath;
+  const now = factory.now?.() ?? /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString();
+  const candidate = {
+    schemaVersion: INSTANCE_RECORD_SCHEMA_VERSION,
+    name: name2.value,
+    instanceId: factory.createInstanceId?.() ?? randomUUID(),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    host: input.host.trim(),
+    publicPort: input.publicPort,
+    upstreamPort: input.upstreamPort,
+    basePath: basePath.value,
+    captureMode: input.captureMode,
+    dataDir: input.dataDir,
+    launch: createLaunch(factory, now)
+  };
+  const parsed = InstanceRecordSchema.safeParse(candidate);
+  return parsed.success ? instanceRegistrySuccess(parsed.data) : instanceRegistryError(
+    "record_invalid",
+    `Cannot create instance record: ${parsed.error.issues[0]?.message ?? "invalid saved configuration"}`
+  );
+}
+function rotateInstanceLaunch(record2, factory = {}) {
+  const now = factory.now?.() ?? /* @__PURE__ */ new Date();
+  const candidate = {
+    ...record2,
+    updatedAt: now.toISOString(),
+    launch: createLaunch(factory, now)
+  };
+  const parsed = InstanceRecordSchema.safeParse(candidate);
+  return parsed.success ? instanceRegistrySuccess(parsed.data) : instanceRegistryError(
+    "record_invalid",
+    `Cannot rotate instance launch: ${parsed.error.issues[0]?.message ?? "invalid saved configuration"}`
+  );
+}
+const AGENT_INSPECTOR_INSTANCES_DIR_ENV = "AGENT_INSPECTOR_INSTANCES_DIR";
+const DEFAULT_NAMED_INSTANCE_PUBLIC_PORT = 9530;
+const NAMED_INSTANCE_PORT_STEP = 3;
+const NAMED_INSTANCE_UPSTREAM_OFFSET = 2;
+const DEFAULT_INSTANCE_LOCK_TIMEOUT_MS = 1e4;
+const DEFAULT_INSTANCE_LOCK_STALE_MS = 3e4;
+const INSTANCE_RECORD_FILE_NAME = "instance.json";
+const ROOT_LOCK_DIRECTORY_NAME = ".allocation.lock";
+const INSTANCE_LOCK_DIRECTORY_NAME = ".mutation.lock";
+const LOCK_OWNER_FILE_NAME = "owner.json";
+const DEFAULT_LOCK_RETRY_MS = 50;
+function getInstancesRoot(env = process.env, platform = process.platform) {
+  const pathApi = platform === "win32" ? win32 : posix;
+  const explicitRoot = env[AGENT_INSPECTOR_INSTANCES_DIR_ENV];
+  if (explicitRoot !== void 0 && explicitRoot.trim().length > 0) {
+    return pathApi.isAbsolute(explicitRoot) ? explicitRoot : pathApi.resolve(explicitRoot);
+  }
+  if (platform === "win32") {
+    const localAppData = env["LOCALAPPDATA"];
+    if (localAppData !== void 0 && localAppData.trim().length > 0) {
+      return win32.join(localAppData, "agent-inspector", "instances");
+    }
+    const userProfile = env["USERPROFILE"];
+    const fallback = userProfile !== void 0 && userProfile.trim().length > 0 ? userProfile : homedir();
+    return win32.join(fallback, ".agent-inspector", "instances");
+  }
+  const home = env["HOME"];
+  const base = home !== void 0 && home.trim().length > 0 ? home : homedir();
+  return posix.join(base, ".agent-inspector", "instances");
+}
+function getInstancePaths(root, rawName) {
+  const name2 = validateInstanceName(rawName);
+  if (name2.kind === "error") return name2;
+  const instanceDir = join(root, name2.value);
+  return instanceRegistrySuccess({
+    root,
+    instanceDir,
+    dataDir: join(instanceDir, "data"),
+    recordPath: join(instanceDir, INSTANCE_RECORD_FILE_NAME),
+    lockPath: join(instanceDir, INSTANCE_LOCK_DIRECTORY_NAME)
+  });
+}
+function ensureInstancesRoot(root = getInstancesRoot()) {
+  return ensurePrivateDirectorySync(root) ? instanceRegistrySuccess(root) : instanceRegistryError(
+    "registry_io",
+    `Cannot create or secure the private instance registry at ${root}.`
+  );
+}
+function nodeErrorCode(error) {
+  if (typeof error !== "object" || error === null) return null;
+  const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+  return typeof descriptor?.value === "string" ? descriptor.value : null;
+}
+function readRecordFile(recordPath) {
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(readFileSync(recordPath, "utf8"));
+  } catch {
+    return instanceRegistryError(
+      "record_invalid",
+      `Instance record ${recordPath} is unreadable or is not valid JSON.`
+    );
+  }
+  const parsed = InstanceRecordSchema.safeParse(parsedJson);
+  return parsed.success ? instanceRegistrySuccess(parsed.data) : instanceRegistryError(
+    "record_invalid",
+    `Instance record ${recordPath} does not match schema version 1: ${parsed.error.issues[0]?.message ?? "invalid record"}.`
+  );
+}
+function readInstanceRecord(root, rawName) {
+  const paths = getInstancePaths(root, rawName);
+  if (paths.kind === "error") return paths;
+  if (!existsSync(paths.value.recordPath)) return instanceRegistrySuccess(null);
+  return readRecordFile(paths.value.recordPath);
+}
+function listInstanceRecords(root) {
+  if (!existsSync(root)) return instanceRegistrySuccess([]);
+  let entries;
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return instanceRegistryError("registry_io", `Cannot read the instance registry at ${root}.`);
+  }
+  const records = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const recordPath = join(root, entry.name, INSTANCE_RECORD_FILE_NAME);
+    if (!existsSync(recordPath)) continue;
+    const record2 = readRecordFile(recordPath);
+    if (record2.kind === "error") return record2;
+    const expectedName = validateInstanceName(entry.name);
+    if (expectedName.kind === "error" || record2.value.name !== expectedName.value || names.has(record2.value.name)) {
+      return instanceRegistryError(
+        "record_invalid",
+        `Instance directory ${entry.name} does not uniquely match its saved normalized name.`
+      );
+    }
+    names.add(record2.value.name);
+    records.push(record2.value);
+  }
+  records.sort((left, right) => left.name.localeCompare(right.name));
+  return instanceRegistrySuccess(records);
+}
+function cleanupFile(path2) {
+  try {
+    rmSync(path2, { force: true });
+  } catch {
+  }
+}
+function writeInstanceRecord(root, record2) {
+  const validated = InstanceRecordSchema.safeParse(record2);
+  if (!validated.success) {
+    return instanceRegistryError(
+      "record_invalid",
+      `Cannot save instance record: ${validated.error.issues[0]?.message ?? "invalid record"}.`
+    );
+  }
+  const paths = getInstancePaths(root, validated.data.name);
+  if (paths.kind === "error") return paths;
+  const rootResult = ensureInstancesRoot(root);
+  if (rootResult.kind === "error") return rootResult;
+  if (!ensurePrivateDirectorySync(paths.value.instanceDir)) {
+    return instanceRegistryError(
+      "registry_io",
+      `Cannot create or secure the private directory for instance ${validated.data.name}.`
+    );
+  }
+  if (!ensurePrivateDirectorySync(validated.data.dataDir)) {
+    return instanceRegistryError(
+      "registry_io",
+      `Cannot create or secure the data directory for instance ${validated.data.name}.`
+    );
+  }
+  const temporaryPath = join(
+    paths.value.instanceDir,
+    `.${INSTANCE_RECORD_FILE_NAME}.${String(process.pid)}.${randomUUID()}.tmp`
+  );
+  let descriptor = null;
+  try {
+    descriptor = openSync(temporaryPath, "wx", PRIVATE_FILE_MODE);
+    writeFileSync(descriptor, `${JSON.stringify(validated.data, null, 2)}
+`, "utf8");
+    closeSync(descriptor);
+    descriptor = null;
+    if (!securePrivateFileSync(temporaryPath)) {
+      cleanupFile(temporaryPath);
+      return instanceRegistryError(
+        "registry_io",
+        `Cannot secure the saved record for instance ${validated.data.name}.`
+      );
+    }
+    renameSync(temporaryPath, paths.value.recordPath);
+    return instanceRegistrySuccess(validated.data);
+  } catch {
+    if (descriptor !== null) {
+      try {
+        closeSync(descriptor);
+      } catch {
+      }
+    }
+    cleanupFile(temporaryPath);
+    return instanceRegistryError(
+      "registry_io",
+      `Cannot atomically save the record for instance ${validated.data.name}.`
+    );
+  }
+}
+const InstanceLockOwnerSchema = object({
+  schemaVersion: literal(1),
+  pid: number().int().positive(),
+  token: string().min(8),
+  createdAt: string().datetime()
+}).strict();
+function defaultSleep(milliseconds) {
+  return new Promise((resolveSleep) => {
+    setTimeout(resolveSleep, milliseconds);
+  });
+}
+function defaultIsProcessAlive(pid) {
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return nodeErrorCode(error) !== "ESRCH";
+  }
+}
+function readLockOwner(lockPath) {
+  try {
+    const raw = JSON.parse(readFileSync(join(lockPath, LOCK_OWNER_FILE_NAME), "utf8"));
+    const parsed = InstanceLockOwnerSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function lockCreatedAt(lockPath, owner) {
+  if (owner !== null) return Date.parse(owner.createdAt);
+  try {
+    return statSync(lockPath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function recoverStaleLock(lockPath, staleAfterMs, now, isProcessAlive) {
+  const owner = readLockOwner(lockPath);
+  const createdAt = lockCreatedAt(lockPath, owner);
+  if (createdAt === null || now - createdAt < staleAfterMs) return false;
+  if (owner !== null && isProcessAlive(owner.pid)) return false;
+  const recoveredPath = `${lockPath}.stale-${randomUUID()}`;
+  try {
+    renameSync(lockPath, recoveredPath);
+    rmSync(recoveredPath, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseDirectoryLock(lockPath, token) {
+  if (!existsSync(lockPath)) return instanceRegistrySuccess(void 0);
+  const owner = readLockOwner(lockPath);
+  if (owner === null || owner.token !== token) {
+    return instanceRegistryError(
+      "lock_not_owned",
+      `Lifecycle lock ${lockPath} is no longer owned by this command.`
+    );
+  }
+  try {
+    rmSync(lockPath, { recursive: true, force: true });
+    return instanceRegistrySuccess(void 0);
+  } catch {
+    return instanceRegistryError("registry_io", `Cannot release lifecycle lock ${lockPath}.`);
+  }
+}
+async function acquireDirectoryLock(lockPath, options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_INSTANCE_LOCK_TIMEOUT_MS;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_LOCK_RETRY_MS;
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_INSTANCE_LOCK_STALE_MS;
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now;
+  const sleep2 = options.sleep ?? defaultSleep;
+  const isProcessAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+  const createToken = options.createToken ?? randomUUID;
+  const startedAt = now();
+  while (now() - startedAt <= timeoutMs) {
+    const token = createToken();
+    try {
+      mkdirSync(lockPath, { mode: 448 });
+    } catch (error) {
+      if (nodeErrorCode(error) !== "EEXIST") {
+        return instanceRegistryError("registry_io", `Cannot acquire lifecycle lock ${lockPath}.`);
+      }
+      if (recoverStaleLock(lockPath, staleAfterMs, now(), isProcessAlive)) continue;
+      if (now() - startedAt >= timeoutMs) break;
+      await sleep2(retryDelayMs);
+      continue;
+    }
+    try {
+      if (!ensurePrivateDirectorySync(lockPath)) {
+        rmSync(lockPath, { recursive: true, force: true });
+        return instanceRegistryError("registry_io", `Cannot secure lifecycle lock ${lockPath}.`);
+      }
+      const owner = {
+        schemaVersion: 1,
+        pid,
+        token,
+        createdAt: new Date(now()).toISOString()
+      };
+      const ownerPath = join(lockPath, LOCK_OWNER_FILE_NAME);
+      writeFileSync(ownerPath, `${JSON.stringify(owner)}
+`, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: PRIVATE_FILE_MODE
+      });
+      if (!securePrivateFileSync(ownerPath)) {
+        rmSync(lockPath, { recursive: true, force: true });
+        return instanceRegistryError("registry_io", `Cannot secure lifecycle lock ${lockPath}.`);
+      }
+      return instanceRegistrySuccess({
+        path: lockPath,
+        release: () => releaseDirectoryLock(lockPath, token)
+      });
+    } catch {
+      try {
+        rmSync(lockPath, { recursive: true, force: true });
+      } catch {
+      }
+      return instanceRegistryError("registry_io", `Cannot acquire lifecycle lock ${lockPath}.`);
+    }
+  }
+  return instanceRegistryError(
+    "lock_timeout",
+    `Timed out waiting for lifecycle lock ${lockPath}; retry after the other command finishes.`
+  );
+}
+async function acquireRegistryLock(root, options = {}) {
+  const ensured = ensureInstancesRoot(root);
+  return ensured.kind === "error" ? ensured : acquireDirectoryLock(join(root, ROOT_LOCK_DIRECTORY_NAME), options);
+}
+async function acquireInstanceLock(root, rawName, options = {}) {
+  const paths = getInstancePaths(root, rawName);
+  if (paths.kind === "error") return paths;
+  const ensured = ensureInstancesRoot(root);
+  if (ensured.kind === "error") return ensured;
+  if (!ensurePrivateDirectorySync(paths.value.instanceDir)) {
+    return instanceRegistryError(
+      "registry_io",
+      `Cannot create or secure the private directory for instance ${rawName}.`
+    );
+  }
+  return acquireDirectoryLock(paths.value.lockPath, options);
+}
+function pathApiForPlatform(platform) {
+  return platform === "win32" ? win32 : posix;
+}
+function resolveRealPathWithMissingTail(absolutePath, pathApi, realpath) {
+  let current = absolutePath;
+  const missingSegments = [];
+  while (true) {
+    try {
+      return pathApi.join(realpath(current), ...missingSegments.reverse());
+    } catch {
+      const parent = pathApi.dirname(current);
+      if (parent === current) return absolutePath;
+      missingSegments.push(pathApi.basename(current));
+      current = parent;
+    }
+  }
+}
+function canonicalizeDataDirectory(rawPath, options = {}) {
+  if (rawPath.trim().length === 0 || rawPath.includes("\0")) {
+    return instanceRegistryError("data_dir_invalid", "Instance data directory cannot be empty.");
+  }
+  const platform = options.platform ?? process.platform;
+  const pathApi = pathApiForPlatform(platform);
+  const cwd = options.cwd ?? process.cwd();
+  const absolutePath = pathApi.resolve(cwd, rawPath);
+  const resolvedPath = resolveRealPathWithMissingTail(
+    absolutePath,
+    pathApi,
+    options.realpath ?? realpathSync.native
+  );
+  const normalizedPath = pathApi.normalize(resolvedPath);
+  const root = pathApi.parse(normalizedPath).root;
+  const withoutTrailingSeparator = normalizedPath === root ? normalizedPath : normalizedPath.replace(/[\\/]+$/u, "");
+  return instanceRegistrySuccess({
+    path: withoutTrailingSeparator,
+    comparisonKey: platform === "win32" ? withoutTrailingSeparator.toLowerCase() : withoutTrailingSeparator
+  });
+}
+function validateDataDirectoryAssignment(rawPath, records, excludeName, options = {}) {
+  const candidate = canonicalizeDataDirectory(rawPath, options);
+  if (candidate.kind === "error") return candidate;
+  const normalizedExcludedName = excludeName?.toLowerCase();
+  for (const record2 of records) {
+    if (record2.name === normalizedExcludedName) continue;
+    const registered = canonicalizeDataDirectory(record2.dataDir, options);
+    if (registered.kind === "error") {
+      return instanceRegistryError(
+        "data_dir_conflict",
+        `Cannot safely compare the data directory registered to instance ${record2.name}.`
+      );
+    }
+    if (registered.value.comparisonKey === candidate.value.comparisonKey) {
+      return instanceRegistryError(
+        "data_dir_conflict",
+        `Data directory ${candidate.value.path} is already assigned to instance ${record2.name}; named instances cannot share data.`
+      );
+    }
+  }
+  return candidate;
+}
+function validPort(port) {
+  return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+function registeredPortOwner(pair, records, excludeName) {
+  const excluded = excludeName?.toLowerCase();
+  for (const record2 of records) {
+    if (record2.name === excluded) continue;
+    const occupied = /* @__PURE__ */ new Set([record2.publicPort, record2.upstreamPort]);
+    if (occupied.has(pair.publicPort) || occupied.has(pair.upstreamPort)) return record2.name;
+  }
+  return null;
+}
+function isPortAvailableByBinding(port, host) {
+  return new Promise((resolveAvailability) => {
+    const server = createServer();
+    let settled = false;
+    const finish = (available) => {
+      if (settled) return;
+      settled = true;
+      server.removeAllListeners();
+      resolveAvailability(available);
+    };
+    server.once("error", () => finish(false));
+    server.once("listening", () => {
+      server.close((error) => finish(error === void 0));
+    });
+    server.unref();
+    try {
+      server.listen({ port, host, exclusive: true });
+    } catch {
+      finish(false);
+    }
+  });
+}
+async function pairIsAvailable(pair, publicHost, check) {
+  if (!await check(pair.publicPort, publicHost)) {
+    return { available: false, conflictingPort: pair.publicPort };
+  }
+  if (!await check(pair.upstreamPort, "127.0.0.1")) {
+    return { available: false, conflictingPort: pair.upstreamPort };
+  }
+  return { available: true, conflictingPort: null };
+}
+async function planInstancePorts(options) {
+  const check = options.isPortAvailable ?? isPortAvailableByBinding;
+  const publicHost = options.publicHost ?? "127.0.0.1";
+  if (options.requestedPublicPort === void 0 && options.requestedUpstreamPort !== void 0) {
+    return instanceRegistryError(
+      "port_invalid",
+      "An explicit upstream port requires an explicit public port."
+    );
+  }
+  if (options.requestedPublicPort !== void 0) {
+    const pair = {
+      publicPort: options.requestedPublicPort,
+      upstreamPort: options.requestedUpstreamPort ?? options.requestedPublicPort + NAMED_INSTANCE_UPSTREAM_OFFSET
+    };
+    if (!validPort(pair.publicPort) || !validPort(pair.upstreamPort) || pair.publicPort === pair.upstreamPort) {
+      return instanceRegistryError(
+        "port_invalid",
+        "Public and upstream ports must be different integers from 1 to 65535."
+      );
+    }
+    const owner = registeredPortOwner(pair, options.records, options.excludeName);
+    if (owner !== null) {
+      return instanceRegistryError(
+        "port_conflict",
+        `Requested port pair ${String(pair.publicPort)}/${String(pair.upstreamPort)} overlaps instance ${owner}.`
+      );
+    }
+    const availability = await pairIsAvailable(pair, publicHost, check);
+    return availability.available ? instanceRegistrySuccess(pair) : instanceRegistryError(
+      "port_conflict",
+      `Port ${String(availability.conflictingPort)} already has a listener; no process was terminated.`
+    );
+  }
+  for (let publicPort = DEFAULT_NAMED_INSTANCE_PUBLIC_PORT; publicPort + NAMED_INSTANCE_UPSTREAM_OFFSET <= 65535; publicPort += NAMED_INSTANCE_PORT_STEP) {
+    const pair = {
+      publicPort,
+      upstreamPort: publicPort + NAMED_INSTANCE_UPSTREAM_OFFSET
+    };
+    if (registeredPortOwner(pair, options.records, options.excludeName) !== null) continue;
+    const availability = await pairIsAvailable(pair, publicHost, check);
+    if (availability.available) return instanceRegistrySuccess(pair);
+  }
+  return instanceRegistryError(
+    "port_exhausted",
+    `No available named-instance port pair was found from ${String(DEFAULT_NAMED_INSTANCE_PUBLIC_PORT)} through 65535.`
+  );
+}
+const DEFAULT_INSTANCE_HOST = "127.0.0.1";
+const DEFAULT_INSTANCE_CAPTURE_MODE = "simple";
+const INSTANCE_READY_TIMEOUT_MS = 15e3;
+const INSTANCE_STOP_TIMEOUT_MS = 2e4;
+const INSTANCE_POLL_INTERVAL_MS = 200;
+function success(value) {
+  return { kind: "success", value };
+}
+function failure(code, message) {
+  return {
+    kind: "error",
+    error: { code, message, retryable: isRetryableInstanceError(code) }
+  };
+}
+function fromRegistry(result) {
+  return result.kind === "success" ? success(result.value) : failure(result.error.code, result.error.message);
+}
+function sleep(milliseconds) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, milliseconds));
+}
+function displayBasePath(basePath) {
+  return basePath.length === 0 ? "/" : basePath;
+}
+function recordUrls(record2) {
+  const origin = urlForHost(record2.publicPort, record2.host);
+  return {
+    ui: appendBasePathToOrigin(origin, "/", record2.basePath),
+    api: appendBasePathToOrigin(origin, "/api", record2.basePath),
+    health: appendBasePathToOrigin(origin, "/api/health", record2.basePath),
+    proxy: appendBasePathToOrigin(origin, "/proxy", record2.basePath),
+    openai: appendBasePathToOrigin(origin, "/proxy/v1", record2.basePath),
+    mcp: appendBasePathToOrigin(origin, "/api/mcp", record2.basePath)
+  };
+}
+function statusOutput(record2, live, checkedAt = /* @__PURE__ */ new Date()) {
+  return {
+    schemaVersion: INSTANCE_API_SCHEMA_VERSION,
+    name: record2.name,
+    instanceId: record2.instanceId,
+    state: live.state,
+    stateReason: live.state === "conflict" ? live.code : null,
+    checkedAt: checkedAt.toISOString(),
+    createdAt: record2.createdAt,
+    updatedAt: record2.updatedAt,
+    launch: {
+      launchId: record2.launch.launchId,
+      startedAt: record2.launch.startedAt
+    },
+    host: record2.host,
+    publicPort: record2.publicPort,
+    upstreamPort: record2.upstreamPort,
+    basePath: displayBasePath(record2.basePath),
+    captureMode: record2.captureMode,
+    dataDir: record2.dataDir,
+    supervisorPid: live.supervisorPid,
+    urls: recordUrls(record2)
+  };
+}
+function operationOutput(operation, outcome, instance) {
+  return {
+    schemaVersion: INSTANCE_API_SCHEMA_VERSION,
+    operation,
+    outcome,
+    instance
+  };
+}
+function connectionOutput(instance) {
+  const serverName = `agent-inspector-${instance.name}`;
+  return {
+    schemaVersion: INSTANCE_API_SCHEMA_VERSION,
+    instance,
+    baseUrl: instance.urls.ui,
+    endpoints: instance.urls,
+    environment: {
+      ANTHROPIC_BASE_URL: instance.urls.proxy,
+      LLM_BASE_URL: instance.urls.proxy,
+      OPENAI_BASE_URL: instance.urls.openai,
+      AGENT_INSPECTOR_MCP_URL: instance.urls.mcp
+    },
+    mcp: {
+      serverName,
+      transport: "streamable-http",
+      url: instance.urls.mcp
+    },
+    codex: {
+      providerName: serverName,
+      baseUrl: instance.urls.openai,
+      wireApi: "responses"
+    }
+  };
+}
+function expectedIdentity(record2) {
+  return {
+    instanceId: record2.instanceId,
+    launchId: record2.launch.launchId,
+    controlToken: record2.launch.controlToken,
+    host: probeHostForBindHost(record2.host),
+    publicPort: record2.publicPort
+  };
+}
+async function classifyRecord(record2, deps) {
+  const probe = await probeInstanceControl(expectedIdentity(record2), deps.fetchImpl);
+  if (probe.kind === "running") {
+    return { state: "running", supervisorPid: probe.identity.supervisorPid };
+  }
+  if (probe.kind === "identity-mismatch" || probe.kind === "invalid-response") {
+    return { state: "conflict", supervisorPid: null, code: "identity_mismatch" };
+  }
+  const check = deps.isPortAvailable ?? isPortAvailableByBinding;
+  const publicAvailable = await check(record2.publicPort, record2.host);
+  const upstreamAvailable = await check(record2.upstreamPort, DEFAULT_INSTANCE_HOST);
+  return publicAvailable && upstreamAvailable ? { state: "stopped", supervisorPid: null } : { state: "conflict", supervisorPid: null, code: "port_conflict" };
+}
+function waitForProcess(child) {
+  return new Promise((resolveExit) => {
+    let settled = false;
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      resolveExit(code);
+    };
+    child.once("exit", (code) => finish(code ?? 1));
+    child.once("error", () => finish(1));
+  });
+}
+function defaultOpenUrl(targetUrl) {
+  const command = openUrlCommand(targetUrl);
+  if (command === null) return;
+  const child = spawn(command.command, command.args, {
+    stdio: "ignore",
+    detached: true,
+    windowsHide: true
+  });
+  child.once("error", () => void 0);
+  child.unref();
+}
+function launchArgs(record2, open2) {
+  const args = [
+    "--background",
+    "--no-open",
+    "--port",
+    String(record2.publicPort),
+    "--host",
+    record2.host,
+    "--mode",
+    record2.captureMode
+  ];
+  if (open2) args.push("--open");
+  return args;
+}
+async function defaultLaunch(record2, open2, cliEntry) {
+  const child = spawn(process.execPath, [cliEntry, ...launchArgs(record2, open2)], {
+    stdio: "ignore",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      [AGENT_INSPECTOR_CLI_ENTRY_ENV]: cliEntry,
+      AGENT_INSPECTOR_DATA_DIR: record2.dataDir,
+      [AGENT_INSPECTOR_BASE_PATH_ENV]: displayBasePath(record2.basePath),
+      [MANAGED_INSTANCE_ENV.name]: record2.name,
+      [MANAGED_INSTANCE_ENV.instanceId]: record2.instanceId,
+      [MANAGED_INSTANCE_ENV.launchId]: record2.launch.launchId,
+      [MANAGED_INSTANCE_ENV.controlToken]: record2.launch.controlToken,
+      [MANAGED_INSTANCE_ENV.startedAt]: record2.launch.startedAt,
+      [MANAGED_INSTANCE_ENV.upstreamPort]: String(record2.upstreamPort)
+    }
+  });
+  return await waitForProcess(child) === 0;
+}
+async function launchRecord(record2, open2, deps) {
+  const cliEntry = deps.cliEntry ?? process.env[AGENT_INSPECTOR_CLI_ENTRY_ENV] ?? process.argv[1];
+  if (deps.launch === void 0 && (cliEntry === void 0 || cliEntry.length === 0)) {
+    return failure("launch_unavailable", "Cannot resolve the packaged Agent Inspector CLI entry.");
+  }
+  const launched = deps.launch === void 0 ? await defaultLaunch(record2, open2, cliEntry ?? "") : await deps.launch(record2, open2);
+  if (!launched) {
+    return failure(
+      "launch_failed",
+      `Instance ${record2.name} did not become ready; its saved configuration is retained for retry.`
+    );
+  }
+  const wait = deps.sleep ?? sleep;
+  const deadline = Date.now() + (deps.readyTimeoutMs ?? INSTANCE_READY_TIMEOUT_MS);
+  while (Date.now() <= deadline) {
+    const live = await classifyRecord(record2, deps);
+    if (live.state === "running") return success(live);
+    if (live.state === "conflict") {
+      return failure(
+        live.code,
+        `Instance ${record2.name} launch identity does not own its saved port pair; no process was terminated.`
+      );
+    }
+    await wait(INSTANCE_POLL_INTERVAL_MS);
+  }
+  return failure(
+    "launch_failed",
+    `Instance ${record2.name} launch timed out; its saved configuration is retained for retry.`
+  );
+}
+async function waitForPortsToClose(record2, deps) {
+  const check = deps.isPortAvailable ?? isPortAvailableByBinding;
+  const wait = deps.sleep ?? sleep;
+  const deadline = Date.now() + (deps.stopTimeoutMs ?? INSTANCE_STOP_TIMEOUT_MS);
+  while (Date.now() <= deadline) {
+    const publicAvailable = await check(record2.publicPort, record2.host);
+    const upstreamAvailable = await check(record2.upstreamPort, DEFAULT_INSTANCE_HOST);
+    if (publicAvailable && upstreamAvailable) return true;
+    await wait(INSTANCE_POLL_INTERVAL_MS);
+  }
+  return false;
+}
+async function stopRecord(record2, deps) {
+  const live = await classifyRecord(record2, deps);
+  if (live.state === "stopped") return success({ live, outcome: "already_stopped" });
+  if (live.state === "conflict") {
+    return failure(
+      live.code,
+      `Instance ${record2.name} does not own its saved port pair; refusing to stop another process.`
+    );
+  }
+  const requested = await requestInstanceShutdown(expectedIdentity(record2), deps.fetchImpl);
+  if (requested.kind === "identity-mismatch") {
+    return failure(
+      "identity_mismatch",
+      `Instance ${record2.name} changed identity before shutdown; no process was terminated.`
+    );
+  }
+  if (requested.kind !== "accepted") {
+    return failure("shutdown_failed", `Instance ${record2.name} rejected the shutdown request.`);
+  }
+  return await waitForPortsToClose(record2, deps) ? success({
+    live: { state: "stopped", supervisorPid: null },
+    outcome: "stopped"
+  }) : failure(
+    "shutdown_failed",
+    `Instance ${record2.name} did not stop before the shutdown deadline.`
+  );
+}
+async function acquireLocks(root, name2, includeRegistry) {
+  const registryResult = includeRegistry ? await acquireRegistryLock(root) : null;
+  if (registryResult !== null && registryResult.kind === "error") {
+    return fromRegistry(registryResult);
+  }
+  const registry2 = registryResult?.kind === "success" ? registryResult.value : null;
+  const instanceResult = await acquireInstanceLock(root, name2);
+  if (instanceResult.kind === "error") {
+    registry2?.release();
+    return fromRegistry(instanceResult);
+  }
+  return success({ registry: registry2, instance: instanceResult.value });
+}
+function releaseLocks(locks) {
+  const instanceReleased = locks.instance.release();
+  const registryReleased = locks.registry?.release() ?? instanceRegistrySuccess(void 0);
+  if (instanceReleased.kind === "error") return fromRegistry(instanceReleased);
+  return fromRegistry(registryReleased);
+}
+async function withLocks(root, name2, includeRegistry, operation) {
+  const locks = await acquireLocks(root, name2, includeRegistry);
+  if (locks.kind === "error") return locks;
+  let result;
+  try {
+    result = await operation();
+  } catch {
+    result = failure("registry_io", "The named-instance lifecycle operation failed.");
+  }
+  const released = releaseLocks(locks.value);
+  return result.kind === "success" && released.kind === "error" ? released : result;
+}
+function readRequiredRecord(root, name2) {
+  const read = readInstanceRecord(root, name2);
+  if (read.kind === "error") return fromRegistry(read);
+  return read.value === null ? failure("instance_not_found", `Named instance ${name2} does not exist.`) : success(read.value);
+}
+function overridesDiffer(record2, action) {
+  const { overrides } = action;
+  if (overrides.port !== null && overrides.port !== record2.publicPort) return true;
+  if (overrides.basePath !== null && overrides.basePath !== record2.basePath) return true;
+  if (overrides.host !== null && overrides.host !== record2.host) return true;
+  if (overrides.captureMode !== null && overrides.captureMode !== record2.captureMode) return true;
+  if (overrides.dataDir !== null) {
+    const requested = canonicalizeDataDirectory(overrides.dataDir);
+    const saved = canonicalizeDataDirectory(record2.dataDir);
+    if (requested.kind === "error" || saved.kind === "error" || requested.value.comparisonKey !== saved.value.comparisonKey) {
+      return true;
+    }
+  }
+  return false;
+}
+function updatedRecord(record2, action, pair, dataDir2) {
+  const candidate = {
+    ...record2,
+    host: action.overrides.host ?? record2.host,
+    publicPort: pair.publicPort,
+    upstreamPort: pair.upstreamPort,
+    basePath: action.overrides.basePath ?? record2.basePath,
+    captureMode: action.overrides.captureMode ?? record2.captureMode,
+    dataDir: dataDir2
+  };
+  const parsed = InstanceRecordSchema.safeParse(candidate);
+  if (!parsed.success) {
+    return failure(
+      "record_invalid",
+      `Cannot update instance ${record2.name}: ${parsed.error.issues[0]?.message ?? "invalid configuration"}.`
+    );
+  }
+  return fromRegistry(rotateInstanceLaunch(parsed.data));
+}
+function saveRecord(root, record2) {
+  return fromRegistry(writeInstanceRecord(root, record2));
+}
+function validateInstanceDataDirectory(rawPath, records, excludeName) {
+  const assigned = validateDataDirectoryAssignment(rawPath, records, excludeName);
+  if (assigned.kind === "error") return fromRegistry(assigned);
+  const defaultDirectory = canonicalizeDataDirectory(resolveDataDir());
+  if (defaultDirectory.kind === "error") return fromRegistry(defaultDirectory);
+  if (assigned.value.comparisonKey === defaultDirectory.value.comparisonKey) {
+    return failure(
+      "data_dir_conflict",
+      `Data directory ${assigned.value.path} belongs to the unmanaged default instance; named instances cannot share it.`
+    );
+  }
+  return success(assigned.value.path);
+}
+async function createNewRecord(root, action, deps) {
+  const recordsResult = listInstanceRecords(root);
+  if (recordsResult.kind === "error") return fromRegistry(recordsResult);
+  const pathsResult = getInstancePaths(root, action.name);
+  if (pathsResult.kind === "error") return fromRegistry(pathsResult);
+  const host = action.overrides.host ?? DEFAULT_INSTANCE_HOST;
+  const pairResult = await planInstancePorts({
+    records: recordsResult.value,
+    requestedPublicPort: action.overrides.port ?? void 0,
+    publicHost: host,
+    isPortAvailable: deps.isPortAvailable
+  });
+  if (pairResult.kind === "error") return fromRegistry(pairResult);
+  const requestedDataDir = action.overrides.dataDir ?? pathsResult.value.dataDir;
+  const dataDirResult = validateInstanceDataDirectory(requestedDataDir, recordsResult.value);
+  if (dataDirResult.kind === "error") return dataDirResult;
+  const created = createInstanceRecord({
+    name: action.name,
+    host,
+    publicPort: pairResult.value.publicPort,
+    upstreamPort: pairResult.value.upstreamPort,
+    basePath: action.overrides.basePath ?? getConfiguredBasePath(process.env),
+    captureMode: action.overrides.captureMode ?? DEFAULT_INSTANCE_CAPTURE_MODE,
+    dataDir: dataDirResult.value
+  });
+  return created.kind === "error" ? fromRegistry(created) : saveRecord(root, created.value);
+}
+async function prepareStoppedStart(root, record2, deps) {
+  const records = listInstanceRecords(root);
+  if (records.kind === "error") return fromRegistry(records);
+  const pair = await planInstancePorts({
+    records: records.value,
+    requestedPublicPort: record2.publicPort,
+    requestedUpstreamPort: record2.upstreamPort,
+    excludeName: record2.name,
+    publicHost: record2.host,
+    isPortAvailable: deps.isPortAvailable
+  });
+  if (pair.kind === "error") return fromRegistry(pair);
+  const dataDir2 = validateInstanceDataDirectory(record2.dataDir, records.value, record2.name);
+  if (dataDir2.kind === "error") return dataDir2;
+  const rotated = rotateInstanceLaunch({ ...record2, dataDir: dataDir2.value });
+  return rotated.kind === "error" ? fromRegistry(rotated) : saveRecord(root, rotated.value);
+}
+async function startAction(root, action, deps) {
+  return withLocks(root, action.name, true, async () => {
+    const read = readInstanceRecord(root, action.name);
+    if (read.kind === "error") return fromRegistry(read);
+    if (read.value === null) {
+      const created = await createNewRecord(root, action, deps);
+      if (created.kind === "error") return created;
+      const launched2 = await launchRecord(created.value, action.overrides.open, deps);
+      return launched2.kind === "error" ? launched2 : success(operationOutput("start", "created", statusOutput(created.value, launched2.value)));
+    }
+    const record2 = read.value;
+    if (overridesDiffer(record2, action)) {
+      return failure(
+        "config_mismatch",
+        `Instance ${record2.name} already has saved configuration; use "agent-inspector instance restart ${record2.name}" with overrides to change it.`
+      );
+    }
+    const live = await classifyRecord(record2, deps);
+    if (live.state === "running") {
+      if (action.overrides.open) (deps.openUrl ?? defaultOpenUrl)(recordUrls(record2).ui);
+      return success(operationOutput("start", "already_running", statusOutput(record2, live)));
+    }
+    if (live.state === "conflict") {
+      return failure(
+        live.code,
+        `Instance ${record2.name} does not own its saved port pair; no process was terminated.`
+      );
+    }
+    const prepared = await prepareStoppedStart(root, record2, deps);
+    if (prepared.kind === "error") return prepared;
+    const launched = await launchRecord(prepared.value, action.overrides.open, deps);
+    return launched.kind === "error" ? launched : success(operationOutput("start", "started", statusOutput(prepared.value, launched.value)));
+  });
+}
+async function planRestartRecord(root, record2, action, wasRunning, deps) {
+  const records = listInstanceRecords(root);
+  if (records.kind === "error") return fromRegistry(records);
+  const desiredPublicPort = action.overrides.port ?? record2.publicPort;
+  const desiredUpstreamPort = desiredPublicPort + 2;
+  const sameLivePair = wasRunning && desiredPublicPort === record2.publicPort && desiredUpstreamPort === record2.upstreamPort;
+  let pair;
+  if (sameLivePair) {
+    pair = { publicPort: record2.publicPort, upstreamPort: record2.upstreamPort };
+  } else {
+    const planned = await planInstancePorts({
+      records: records.value,
+      requestedPublicPort: desiredPublicPort,
+      requestedUpstreamPort: desiredUpstreamPort,
+      excludeName: record2.name,
+      publicHost: action.overrides.host ?? record2.host,
+      isPortAvailable: deps.isPortAvailable
+    });
+    if (planned.kind === "error") return fromRegistry(planned);
+    pair = planned.value;
+  }
+  const requestedDataDir = action.overrides.dataDir ?? record2.dataDir;
+  const dataDir2 = validateInstanceDataDirectory(requestedDataDir, records.value, record2.name);
+  if (dataDir2.kind === "error") return dataDir2;
+  return updatedRecord(record2, action, pair, dataDir2.value);
+}
+async function rollbackRestart(root, previous, deps) {
+  const rotated = rotateInstanceLaunch(previous);
+  if (rotated.kind === "error") return false;
+  const saved = saveRecord(root, rotated.value);
+  if (saved.kind === "error") return false;
+  const launched = await launchRecord(saved.value, false, deps);
+  return launched.kind === "success";
+}
+async function restartFailureAfterStop(root, previous, deps) {
+  const rolledBack = await rollbackRestart(root, previous, deps);
+  return rolledBack ? failure(
+    "restart_failed_rolled_back",
+    `Instance ${previous.name} replacement failed; the previous configuration was restored with a fresh launch.`
+  ) : failure(
+    "restart_failed_degraded",
+    `Instance ${previous.name} replacement and rollback both failed; its saved configuration remains recoverable for a later start.`
+  );
+}
+async function restartAction(root, action, deps) {
+  return withLocks(root, action.name, true, async () => {
+    const required = readRequiredRecord(root, action.name);
+    if (required.kind === "error") return required;
+    const current = required.value;
+    const live = await classifyRecord(current, deps);
+    if (live.state === "conflict") {
+      return failure(
+        live.code,
+        `Instance ${current.name} does not own its saved port pair; refusing to replace another process.`
+      );
+    }
+    const planned = await planRestartRecord(root, current, action, live.state === "running", deps);
+    if (planned.kind === "error") return planned;
+    if (live.state === "running") {
+      const stopped = await stopRecord(current, deps);
+      if (stopped.kind === "error") return stopped;
+      if (planned.value.publicPort === current.publicPort && planned.value.upstreamPort === current.upstreamPort) {
+        const check = deps.isPortAvailable ?? isPortAvailableByBinding;
+        if (!await check(current.publicPort, current.host) || !await check(current.upstreamPort, DEFAULT_INSTANCE_HOST)) {
+          return failure(
+            "port_conflict",
+            `Instance ${current.name} ports did not become available after shutdown.`
+          );
+        }
+      }
+    }
+    const saved = saveRecord(root, planned.value);
+    if (saved.kind === "error") {
+      return live.state === "running" ? restartFailureAfterStop(root, current, deps) : saved;
+    }
+    const launched = await launchRecord(saved.value, action.overrides.open, deps);
+    if (launched.kind === "error") {
+      return live.state === "running" ? restartFailureAfterStop(root, current, deps) : launched;
+    }
+    return success(
+      operationOutput("restart", "restarted", statusOutput(saved.value, launched.value))
+    );
+  });
+}
+async function stopAction(root, action, deps) {
+  return withLocks(root, action.name, false, async () => {
+    const required = readRequiredRecord(root, action.name);
+    if (required.kind === "error") return required;
+    const stopped = await stopRecord(required.value, deps);
+    return stopped.kind === "error" ? stopped : success(
+      operationOutput(
+        "stop",
+        stopped.value.outcome,
+        statusOutput(required.value, stopped.value.live)
+      )
+    );
+  });
+}
+async function statusAction(root, name2, deps) {
+  const required = readRequiredRecord(root, name2);
+  if (required.kind === "error") return required;
+  const live = await classifyRecord(required.value, deps);
+  return success(statusOutput(required.value, live));
+}
+async function listAction(root, deps) {
+  const records = listInstanceRecords(root);
+  if (records.kind === "error") return fromRegistry(records);
+  const outputs = await Promise.all(
+    records.value.map(async (record2) => statusOutput(record2, await classifyRecord(record2, deps)))
+  );
+  return success(outputs);
+}
+function requestActionOverrides(input) {
+  return {
+    port: input.port ?? null,
+    basePath: input.basePath === void 0 ? null : normalizeBasePath(input.basePath),
+    host: input.host ?? null,
+    captureMode: input.captureMode ?? null,
+    dataDir: input.dataDir ?? null,
+    open: false
+  };
+}
+function lifecycleRoot(deps) {
+  return resolve(deps.root ?? getInstancesRoot());
+}
+function normalizedServiceName(rawName) {
+  const validated = validateInstanceName(rawName);
+  return validated.kind === "error" ? fromRegistry(validated) : success(validated.value);
+}
+async function startNamedInstance(rawName, input = {}, deps = {}) {
+  const name2 = normalizedServiceName(rawName);
+  if (name2.kind === "error") return name2;
+  return startAction(
+    lifecycleRoot(deps),
+    { kind: "start", name: name2.value, overrides: requestActionOverrides(input), json: true },
+    deps
+  );
+}
+async function restartNamedInstance(rawName, input = {}, deps = {}) {
+  const name2 = normalizedServiceName(rawName);
+  if (name2.kind === "error") return name2;
+  return restartAction(
+    lifecycleRoot(deps),
+    { kind: "restart", name: name2.value, overrides: requestActionOverrides(input), json: true },
+    deps
+  );
+}
+async function stopNamedInstance(rawName, deps = {}) {
+  const name2 = normalizedServiceName(rawName);
+  if (name2.kind === "error") return name2;
+  return stopAction(lifecycleRoot(deps), { kind: "stop", name: name2.value, json: true }, deps);
+}
+async function getNamedInstance(rawName, deps = {}) {
+  const name2 = normalizedServiceName(rawName);
+  if (name2.kind === "error") return name2;
+  return statusAction(lifecycleRoot(deps), name2.value, deps);
+}
+async function getNamedInstanceConnection(rawName, deps = {}) {
+  const instance = await getNamedInstance(rawName, deps);
+  return instance.kind === "error" ? instance : success(connectionOutput(instance.value));
+}
+async function listNamedInstances(deps = {}) {
+  return listAction(lifecycleRoot(deps), deps);
+}
+const NO_STORE_HEADERS$1 = { "cache-control": "no-store" };
+function errorStatus(code) {
+  switch (code) {
+    case "argument_invalid":
+    case "data_dir_invalid":
+    case "name_invalid":
+    case "port_invalid":
+    case "record_invalid":
+      return 400;
+    case "instance_not_found":
+      return 404;
+    case "config_mismatch":
+    case "data_dir_conflict":
+    case "identity_mismatch":
+    case "port_conflict":
+    case "self_lifecycle_unsupported":
+      return 409;
+    case "lock_not_owned":
+    case "lock_timeout":
+      return 423;
+    case "launch_failed":
+    case "launch_unavailable":
+    case "port_exhausted":
+    case "registry_io":
+    case "restart_failed_degraded":
+    case "restart_failed_rolled_back":
+    case "shutdown_failed":
+      return 503;
+  }
+}
+function instanceErrorResponse(error) {
+  return Response.json(instanceErrorOutput(error), {
+    status: errorStatus(error.code),
+    headers: NO_STORE_HEADERS$1
+  });
+}
+function instanceResultResponse(result, successStatus = 200) {
+  return result.kind === "error" ? instanceErrorResponse(result.error) : Response.json(result.value, { status: successStatus, headers: NO_STORE_HEADERS$1 });
+}
+async function parseInstanceBody(request, schema) {
+  let value;
+  try {
+    const text = await request.text();
+    value = text.trim().length === 0 ? {} : JSON.parse(text);
+  } catch {
+    return {
+      ok: false,
+      response: instanceErrorResponse({
+        code: "argument_invalid",
+        message: "Request body must be valid JSON.",
+        retryable: false
+      })
+    };
+  }
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      response: instanceErrorResponse({
+        code: "argument_invalid",
+        message: `Invalid instance request: ${parsed.error.issues[0]?.message ?? "invalid body"}`,
+        retryable: false
+      })
+    };
+  }
+  return { ok: true, value: parsed.data };
+}
+function selfLifecycleError(rawName) {
+  const current = readManagedInstanceLaunch(process.env);
+  return current.kind === "managed" && current.launch.name.toLowerCase() === rawName.toLowerCase() ? {
+    code: "self_lifecycle_unsupported",
+    message: "A managed runtime cannot stop or restart itself through its own REST/MCP transport; use the CLI or a different controller instance.",
+    retryable: false
+  } : null;
+}
+function instanceListResponse(instances) {
+  return Response.json(
+    { schemaVersion: INSTANCE_API_SCHEMA_VERSION, instances },
+    { headers: NO_STORE_HEADERS$1 }
+  );
+}
+const Route$H = createFileRoute("/api/instances")({
+  server: {
+    handlers: {
+      GET: async () => {
+        const result = await listNamedInstances();
+        return result.kind === "error" ? instanceResultResponse(result) : instanceListResponse(result.value);
+      }
+    }
+  }
+});
+function createShutdownCoordinator(dependencies, deadlineMs) {
+  let shutdownPromise = null;
+  async function shutdown(_reason = "manual") {
+    if (shutdownPromise !== null) return await shutdownPromise;
+    dependencies.markShuttingDown();
+    dependencies.stopAdmission();
+    let forced = false;
+    let forceClosed = false;
+    let deadline = null;
+    function forceCloseOnce() {
+      if (forceClosed) return;
+      forceClosed = true;
+      dependencies.forceClose();
+    }
+    async function gracefulShutdown() {
+      try {
+        await dependencies.drainTraffic();
+        if (forced) return { forced: true, reason: "deadline" };
+        await dependencies.drainFinalizers();
+        if (forced) return { forced: true, reason: "deadline" };
+        await dependencies.flushPersistence();
+        if (forced) return { forced: true, reason: "deadline" };
+        await dependencies.closeResources();
+        return { forced: false, reason: "completed" };
+      } catch {
+        forceCloseOnce();
+        return { forced: true, reason: "error" };
+      }
+    }
+    const timedOut = new Promise((resolve2) => {
+      deadline = setTimeout(
+        () => {
+          forced = true;
+          forceCloseOnce();
+          resolve2({ forced: true, reason: "deadline" });
+        },
+        Math.max(1, deadlineMs)
+      );
+    });
+    shutdownPromise = Promise.race([gracefulShutdown(), timedOut]).finally(() => {
+      if (deadline !== null) clearTimeout(deadline);
+    });
+    return await shutdownPromise;
+  }
+  return { shutdown };
+}
+function createShutdownSignalHandler(coordinator, onComplete) {
+  let handled = false;
+  return (signal) => {
+    if (handled) return;
+    handled = true;
+    void coordinator.shutdown(signal).then(onComplete);
+  };
+}
+const DEFAULT_SHUTDOWN_DEADLINE_MS = 15e3;
+function shutdownDeadlineMs() {
+  const raw = process.env["AGENT_INSPECTOR_SHUTDOWN_TIMEOUT_MS"];
+  if (raw === void 0 || raw === "") return DEFAULT_SHUTDOWN_DEADLINE_MS;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) && parsed > 0 && parsed <= 3e5 ? parsed : DEFAULT_SHUTDOWN_DEADLINE_MS;
+}
+async function drainFinalizers() {
+  await flushAllRawStreamCaptures();
+  await flushSessionTasks();
+  await flushToolSchemaWarningAnalysis();
+}
+async function flushPersistence() {
+  await flushLogBuffer();
+  await flushSessionArchiveWrites();
+  await flushIndex();
+  await flushApplicationLog();
+}
+async function closeResources() {
+  await closeLogFinalizerWorkers();
+  destroyAllSessionProcesses();
+  closeSqliteLogIndex();
+  await flushApplicationLog();
+}
+function forceCloseResources() {
+  forceCloseLogFinalizerWorkers();
+  destroyAllSessionProcesses();
+  closeSqliteLogIndex();
+}
+const runtimeShutdownCoordinator = createShutdownCoordinator(
+  {
+    markShuttingDown: () => setRuntimeShuttingDown(true),
+    stopAdmission: stopRuntimeAdmission,
+    drainTraffic: waitForRuntimeTrafficDrain,
     drainFinalizers,
     flushPersistence,
     closeResources,
@@ -16899,7 +18727,50 @@ const runtimeShutdownCoordinator = createShutdownCoordinator(
   shutdownDeadlineMs()
 );
 let signalHandlersInstalled = false;
+let managedInstanceHandlersInstalled = false;
+function managedControlTokensMatch(received, expected) {
+  if (received.length === 0 || expected.length === 0) return false;
+  const receivedDigest = createHash("sha256").update(received).digest();
+  const expectedDigest = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(receivedDigest, expectedDigest);
+}
+function createManagedRuntimeShutdownController(options) {
+  let shutdownRequested = false;
+  const requestShutdown = () => {
+    if (shutdownRequested) return;
+    shutdownRequested = true;
+    void options.shutdown().then(
+      (result) => options.exit(result.forced ? 1 : 0),
+      () => options.exit(1)
+    );
+  };
+  return {
+    handleDisconnect: requestShutdown,
+    handleMessage: (message) => {
+      const parsed = parseManagedInstanceShutdownMessage(message);
+      if (parsed === null || !managedControlTokensMatch(parsed.controlToken, options.controlToken)) {
+        return;
+      }
+      requestShutdown();
+    }
+  };
+}
+function installRuntimeManagedInstanceShutdownHandlers() {
+  if (managedInstanceHandlersInstalled) return;
+  const launchResult = readManagedInstanceLaunch(process.env);
+  if (launchResult.kind !== "managed") return;
+  managedInstanceHandlersInstalled = true;
+  const controller = createManagedRuntimeShutdownController({
+    controlToken: launchResult.launch.controlToken,
+    shutdown: async () => await runtimeShutdownCoordinator.shutdown("manual"),
+    exit: (code) => process.exit(code)
+  });
+  process.on("message", controller.handleMessage);
+  process.once("disconnect", controller.handleDisconnect);
+  if (process.connected === false) process.nextTick(controller.handleDisconnect);
+}
 function installRuntimeShutdownSignalHandlers() {
+  installRuntimeManagedInstanceShutdownHandlers();
   if (signalHandlersInstalled) return;
   signalHandlersInstalled = true;
   const handleSignal = createShutdownSignalHandler(runtimeShutdownCoordinator, (result) => {
@@ -16910,7 +18781,7 @@ function installRuntimeShutdownSignalHandlers() {
 }
 installRuntimeShutdownSignalHandlers();
 logger.debug("Health endpoint loaded");
-const Route$B = createFileRoute("/api/health")({
+const Route$G = createFileRoute("/api/health")({
   server: {
     handlers: {
       GET: async () => {
@@ -16951,7 +18822,7 @@ function readDeleteEvidenceFlag$1(request) {
     return { ok: false };
   }
 }
-const Route$A = createFileRoute("/api/groups")({
+const Route$F = createFileRoute("/api/groups")({
   server: {
     handlers: {
       GET: () => Response.json(listInspectorGroups()),
@@ -16995,7 +18866,7 @@ const RuntimeConfigPatchSchema = object({
 }).strict().refine((v) => Object.keys(v).length > 0, {
   message: "At least one field must be provided"
 });
-const Route$z = createFileRoute("/api/config")({
+const Route$E = createFileRoute("/api/config")({
   server: {
     handlers: {
       GET: () => {
@@ -17090,23 +18961,23 @@ function listInspectorAlerts(options) {
 function getInspectorAlertSummary(options) {
   return getAlertSummary(options);
 }
-function parseFilters(url) {
-  const severityResult = AlertSeveritySchema.safeParse(url.searchParams.get("severity"));
-  const categoryResult = AlertCategorySchema.safeParse(url.searchParams.get("category"));
-  const sourceResult = AlertSourceSchema.safeParse(url.searchParams.get("source"));
+function parseFilters(url2) {
+  const severityResult = AlertSeveritySchema.safeParse(url2.searchParams.get("severity"));
+  const categoryResult = AlertCategorySchema.safeParse(url2.searchParams.get("category"));
+  const sourceResult = AlertSourceSchema.safeParse(url2.searchParams.get("source"));
   return {
     severity: severityResult.success ? severityResult.data : void 0,
     category: categoryResult.success ? categoryResult.data : void 0,
     source: sourceResult.success ? sourceResult.data : void 0
   };
 }
-const Route$y = createFileRoute("/api/alerts")({
+const Route$D = createFileRoute("/api/alerts")({
   server: {
     handlers: {
       GET: async ({ request }) => {
-        const url = new URL(request.url);
+        const url2 = new URL(request.url);
         const limitResult = parseBoundedIntegerParameter({
-          value: url.searchParams.get("limit"),
+          value: url2.searchParams.get("limit"),
           parameter: "limit",
           fallback: DEFAULT_ALERT_LIMIT,
           minimum: 1,
@@ -17115,7 +18986,7 @@ const Route$y = createFileRoute("/api/alerts")({
         });
         if (!limitResult.ok) return limitResult.response;
         const scanLimitResult = parseBoundedIntegerParameter({
-          value: url.searchParams.get("scanLimit"),
+          value: url2.searchParams.get("scanLimit"),
           parameter: "scanLimit",
           fallback: DEFAULT_ALERT_SCAN_LIMIT,
           minimum: 1,
@@ -17125,7 +18996,7 @@ const Route$y = createFileRoute("/api/alerts")({
         if (!scanLimitResult.ok) return scanLimitResult.response;
         return Response.json(
           await listInspectorAlerts({
-            ...parseFilters(url),
+            ...parseFilters(url2),
             limit: limitResult.value,
             scanLimit: scanLimitResult.value
           })
@@ -17143,7 +19014,7 @@ async function readJsonBody$4(request) {
     return { ok: false };
   }
 }
-const Route$x = createFileRoute("/api/runs/$runId")({
+const Route$C = createFileRoute("/api/runs/$runId")({
   server: {
     handlers: {
       GET: ({ params }) => {
@@ -17228,9 +19099,9 @@ const KNOWN_PROVIDER_NAMES = {
   lingyiwanwu: "LingyiWanwu",
   stepfun: "StepFun"
 };
-function deriveNameFromUrl(url) {
+function deriveNameFromUrl(url2) {
   try {
-    const hostname = new URL(url).hostname;
+    const hostname = new URL(url2).hostname;
     const parts = hostname.split(".");
     const domain = parts.length >= 2 ? parts[parts.length - 2] ?? hostname : hostname;
     const domainLower = domain.toLowerCase();
@@ -17599,8 +19470,8 @@ function scanExternalProviders() {
   }
   const allProviders = [...claudeProviders, ...opencodeProviders, ...mimoProviders];
   const filteredProviders = allProviders.filter((p) => {
-    const url = p.anthropicBaseUrl || p.openaiBaseUrl || p.openaiResponsesBaseUrl;
-    return !/(?:localhost|127\.0\.0\.1)/.test(url);
+    const url2 = p.anthropicBaseUrl || p.openaiBaseUrl || p.openaiResponsesBaseUrl;
+    return !/(?:localhost|127\.0\.0\.1)/.test(url2);
   });
   let existing = [];
   try {
@@ -17676,7 +19547,7 @@ function consumeProviderScan(scanId, selectionIds, now = Date.now()) {
   }
   return selected;
 }
-const Route$w = createFileRoute("/api/providers/scan")({
+const Route$B = createFileRoute("/api/providers/scan")({
   server: {
     handlers: {
       POST: () => {
@@ -17722,7 +19593,7 @@ const ProviderScanImportRequestSchema = object({
   selectionIds: array(string().uuid()).min(1).max(100)
 });
 const ProviderFileImportSchema = union([string(), object({ providers: unknown() })]);
-const Route$v = createFileRoute("/api/providers/import")({
+const Route$A = createFileRoute("/api/providers/import")({
   server: {
     handlers: {
       POST: async ({ request }) => {
@@ -17794,7 +19665,7 @@ function exportResponse(json, filename) {
     }
   });
 }
-const Route$u = createFileRoute("/api/providers/export")({
+const Route$z = createFileRoute("/api/providers/export")({
   server: {
     handlers: {
       GET: () => {
@@ -17837,7 +19708,7 @@ const ProviderUpdateSchema = object({
   modelMetadata: ProviderModelMetadataListSchema.optional(),
   source: _enum(["company", "personal"]).optional()
 });
-const Route$t = createFileRoute("/api/providers/$providerId")({
+const Route$y = createFileRoute("/api/providers/$providerId")({
   server: {
     handlers: {
       GET: ({ params }) => {
@@ -17905,8 +19776,8 @@ const Route$t = createFileRoute("/api/providers/$providerId")({
 const INITIAL_STREAM_LOG_LIMIT = 100;
 const UPDATE_COALESCE_MS = 50;
 const sseClientLimiter = createCapacityLimiter(MAX_SSE_CLIENTS);
-function streamIncludesBodies(url) {
-  return url.searchParams.get("compact") === "0";
+function streamIncludesBodies(url2) {
+  return url2.searchParams.get("compact") === "0";
 }
 function parseLastEventLogId(value) {
   if (value === null || !/^\d+$/.test(value)) return void 0;
@@ -17933,10 +19804,10 @@ function createLogsStreamResponse(request, clientLimiter = sseClientLimiter) {
       retryAfterSeconds: 1
     });
   }
-  const url = new URL(request.url);
-  const sessionId = url.searchParams.get("sessionId") ?? void 0;
-  const model = url.searchParams.get("model") ?? void 0;
-  const includeBodies = streamIncludesBodies(url);
+  const url2 = new URL(request.url);
+  const sessionId = url2.searchParams.get("sessionId") ?? void 0;
+  const model = url2.searchParams.get("model") ?? void 0;
+  const includeBodies = streamIncludesBodies(url2);
   const lastEventLogId = parseLastEventLogId(request.headers.get("last-event-id"));
   let controllerRef = null;
   let cleanedUp = false;
@@ -18024,7 +19895,7 @@ function createLogsStreamResponse(request, clientLimiter = sseClientLimiter) {
     }
   });
 }
-const Route$s = createFileRoute("/api/logs/stream")({
+const Route$x = createFileRoute("/api/logs/stream")({
   server: {
     handlers: {
       GET: ({ request }) => createLogsStreamResponse(request)
@@ -18714,7 +20585,7 @@ async function readBoundedLogImportUpload(request, options = {}) {
     data: new Uint8Array(await upload.arrayBuffer())
   };
 }
-const Route$r = createFileRoute("/api/logs/import")({
+const Route$w = createFileRoute("/api/logs/import")({
   server: {
     handlers: {
       POST: async ({ request }) => {
@@ -18745,7 +20616,7 @@ const Route$r = createFileRoute("/api/logs/import")({
     }
   }
 });
-const Route$q = createFileRoute("/api/logs/$id")({
+const Route$v = createFileRoute("/api/logs/$id")({
   server: {
     handlers: {
       GET: async ({ params }) => {
@@ -19128,20 +20999,20 @@ const OpenClawWriteResponseSchema = object({
   memoryId: string().optional()
 });
 function getLegacyEndpoint() {
-  const endpoint = process.env["OPENCLAW_MEMORY_URL"] ?? process.env["OPENCLAW_API_URL"];
-  if (endpoint === void 0 || endpoint.trim() === "") return null;
-  return endpoint.trim();
+  const endpoint2 = process.env["OPENCLAW_MEMORY_URL"] ?? process.env["OPENCLAW_API_URL"];
+  if (endpoint2 === void 0 || endpoint2.trim() === "") return null;
+  return endpoint2.trim();
 }
-function buildMemoryUrl(endpoint) {
-  return endpoint.endsWith("/memories") ? endpoint : `${endpoint.replace(/\/$/, "")}/memories`;
+function buildMemoryUrl(endpoint2) {
+  return endpoint2.endsWith("/memories") ? endpoint2 : `${endpoint2.replace(/\/$/, "")}/memories`;
 }
-function buildSearchUrl(endpoint, query, project) {
-  const url = new URL(`${endpoint.replace(/\/$/, "")}/search`);
-  url.searchParams.set("q", query);
+function buildSearchUrl(endpoint2, query, project) {
+  const url2 = new URL(`${endpoint2.replace(/\/$/, "")}/search`);
+  url2.searchParams.set("q", query);
   if (project !== void 0 && project !== "") {
-    url.searchParams.set("project", project);
+    url2.searchParams.set("project", project);
   }
-  return url.toString();
+  return url2.toString();
 }
 function authHeaders() {
   const headers = new Headers({ "content-type": "application/json" });
@@ -19172,15 +21043,15 @@ async function promoteToOpenClaw(candidate) {
     }
     return { success: false, error: result.error };
   }
-  const endpoint = getLegacyEndpoint();
-  if (endpoint === null) {
+  const endpoint2 = getLegacyEndpoint();
+  if (endpoint2 === null) {
     return {
       success: false,
       error: "OpenClaw memory backend is not configured. Set OPENCLAW_WORKSPACE_DIR for file-backed memory or OPENCLAW_MEMORY_URL for a legacy HTTP backend."
     };
   }
   const fetchResult = await safeFetch(
-    buildMemoryUrl(endpoint),
+    buildMemoryUrl(endpoint2),
     {
       method: "POST",
       headers: authHeaders(),
@@ -19204,8 +21075,8 @@ async function searchOpenClaw(query, project) {
   if (isOpenClawGatewayConfigured()) {
     return await searchOpenClawGateway(query, project);
   }
-  const endpoint = getLegacyEndpoint();
-  if (endpoint === null) {
+  const endpoint2 = getLegacyEndpoint();
+  if (endpoint2 === null) {
     const workspaceHint = isOpenClawFileBridgeConfigured() ? " OPENCLAW_WORKSPACE_DIR is configured for writes, but search requires OPENCLAW_GATEWAY_URL." : "";
     return {
       results: [],
@@ -19213,7 +21084,7 @@ async function searchOpenClaw(query, project) {
     };
   }
   const fetchResult = await safeFetch(
-    buildSearchUrl(endpoint, query, project),
+    buildSearchUrl(endpoint2, query, project),
     {
       method: "GET",
       headers: authHeaders()
@@ -19255,13 +21126,13 @@ function bodySearchQuery(value) {
   const query = descriptor.value;
   return typeof query === "string" ? query : null;
 }
-const Route$p = createFileRoute("/api/knowledge/search")({
+const Route$u = createFileRoute("/api/knowledge/search")({
   server: {
     handlers: {
       GET: async ({ request }) => {
-        const url = new URL(request.url);
-        const query = url.searchParams.get("q") ?? "";
-        const project = url.searchParams.get("project") ?? void 0;
+        const url2 = new URL(request.url);
+        const query = url2.searchParams.get("q") ?? "";
+        const project = url2.searchParams.get("project") ?? void 0;
         if (query === "") {
           return Response.json({ error: "Missing q search parameter" }, { status: 400 });
         }
@@ -19288,12 +21159,12 @@ const Route$p = createFileRoute("/api/knowledge/search")({
     }
   }
 });
-const Route$o = createFileRoute("/api/knowledge/project-context")({
+const Route$t = createFileRoute("/api/knowledge/project-context")({
   server: {
     handlers: {
       GET: async ({ request }) => {
-        const url = new URL(request.url);
-        const project = url.searchParams.get("project") ?? "";
+        const url2 = new URL(request.url);
+        const project = url2.searchParams.get("project") ?? "";
         if (project === "") {
           return Response.json({ error: "Missing project search parameter" }, { status: 400 });
         }
@@ -19313,13 +21184,20 @@ const Route$o = createFileRoute("/api/knowledge/project-context")({
     }
   }
 });
-const Route$n = createFileRoute("/api/knowledge/candidates")({
+const Route$s = createFileRoute("/api/knowledge/candidates")({
   server: {
     handlers: {
       GET: () => Response.json({ candidates: listCandidates() })
     }
   }
 });
+const Route$r = createFileRoute("/api/instances/$name")({
+  server: {
+    handlers: {
+      GET: async ({ params }) => instanceResultResponse(await getNamedInstance(params.name))
+    }
+  }
+});
 async function readJsonBody$3(request) {
   try {
     const raw = await request.text();
@@ -19348,7 +21226,7 @@ function readDeleteEvidenceFlag(request) {
     return { ok: false };
   }
 }
-const Route$m = createFileRoute("/api/groups/$groupId")({
+const Route$q = createFileRoute("/api/groups/$groupId")({
   server: {
     handlers: {
       GET: ({ params }) => {
@@ -19395,16 +21273,6 @@ const Route$m = createFileRoute("/api/groups/$groupId")({
     }
   }
 });
-function platformCommand(command, args, platform = process.platform) {
-  if (platform !== "win32") return { command, args: [...args] };
-  return { command: "cmd.exe", args: ["/d", "/s", "/c", command, ...args] };
-}
-function npmCommand(platform = process.platform) {
-  return platform === "win32" ? "npm.cmd" : "npm";
-}
-function npmSpawnCommand(args, platform = process.platform) {
-  return platformCommand(npmCommand(platform), args, platform);
-}
 const ECOSYSTEM_PACKAGES = [
   {
     id: "inspector",
@@ -19886,7 +21754,7 @@ ${error.message}
   });
   return task;
 }
-const Route$l = createFileRoute("/api/ecosystem/tasks")({
+const Route$p = createFileRoute("/api/ecosystem/tasks")({
   server: {
     handlers: {
       GET: () => {
@@ -19895,7 +21763,7 @@ const Route$l = createFileRoute("/api/ecosystem/tasks")({
     }
   }
 });
-const Route$k = createFileRoute("/api/ecosystem/packages")({
+const Route$o = createFileRoute("/api/ecosystem/packages")({
   server: {
     handlers: {
       GET: async () => {
@@ -19909,7 +21777,7 @@ const Route$k = createFileRoute("/api/ecosystem/packages")({
     }
   }
 });
-const Route$j = createFileRoute("/api/config/paths")({
+const Route$n = createFileRoute("/api/config/paths")({
   server: {
     handlers: {
       GET: () => {
@@ -19920,13 +21788,13 @@ const Route$j = createFileRoute("/api/config/paths")({
     }
   }
 });
-const Route$i = createFileRoute("/api/alerts/summary")({
+const Route$m = createFileRoute("/api/alerts/summary")({
   server: {
     handlers: {
       GET: async ({ request }) => {
-        const url = new URL(request.url);
+        const url2 = new URL(request.url);
         const scanLimitResult = parseBoundedIntegerParameter({
-          value: url.searchParams.get("scanLimit"),
+          value: url2.searchParams.get("scanLimit"),
           parameter: "scanLimit",
           fallback: DEFAULT_ALERT_SCAN_LIMIT,
           minimum: 1,
@@ -19952,7 +21820,7 @@ async function readJsonBody$2(request) {
     return { ok: false };
   }
 }
-const Route$h = createFileRoute("/api/runs/$runId/evidence")({
+const Route$l = createFileRoute("/api/runs/$runId/evidence")({
   server: {
     handlers: {
       GET: ({ params }) => {
@@ -20699,7 +22567,7 @@ async function testStreamingEndpoint(baseUrl, provider, path2, model, protocol)
     clearTimeout(timeoutId);
   }
 }
-const Route$g = createFileRoute("/api/providers/$providerId/test")({
+const Route$k = createFileRoute("/api/providers/$providerId/test")({
   server: {
     handlers: {
       POST: async ({ params }) => {
@@ -20882,7 +22750,7 @@ async function readRegistryJson(response) {
     return null;
   }
 }
-const Route$f = createFileRoute("/api/providers/$providerId/model-metadata")({
+const Route$j = createFileRoute("/api/providers/$providerId/model-metadata")({
   server: {
     handlers: {
       POST: async ({ params, request }) => {
@@ -20997,7 +22865,7 @@ const Route$f = createFileRoute("/api/providers/$providerId/model-metadata")({
 const ReplayRequestSchema = object({
   modifiedBody: string()
 });
-const Route$e = createFileRoute("/api/logs/$id/replay")({
+const Route$i = createFileRoute("/api/logs/$id/replay")({
   server: {
     handlers: {
       POST: async ({ params, request }) => {
@@ -21209,7 +23077,7 @@ const Route$e = createFileRoute("/api/logs/$id/replay")({
     }
   }
 });
-const Route$d = createFileRoute("/api/logs/$id/chunks")({
+const Route$h = createFileRoute("/api/logs/$id/chunks")({
   server: {
     handlers: {
       GET: async ({ params }) => {
@@ -21316,7 +23184,7 @@ function parseIntegerParam(value, fallback) {
   if (!Number.isInteger(parsed)) return fallback;
   return parsed;
 }
-const Route$c = createFileRoute("/api/logs/$id/body")({
+const Route$g = createFileRoute("/api/logs/$id/body")({
   server: {
     handlers: {
       GET: async ({ params, request }) => {
@@ -21324,13 +23192,13 @@ const Route$c = createFileRoute("/api/logs/$id/body")({
         if (!Number.isInteger(id) || id <= 0) {
           return Response.json({ error: "Invalid log ID" }, { status: 400 });
         }
-        const url = new URL(request.url);
-        const partResult = LogBodyPartSchema.safeParse(url.searchParams.get("part"));
+        const url2 = new URL(request.url);
+        const partResult = LogBodyPartSchema.safeParse(url2.searchParams.get("part"));
         if (!partResult.success) {
           return Response.json({ error: "Invalid body part" }, { status: 400 });
         }
         const limitResult = parseBoundedIntegerParameter({
-          value: url.searchParams.get("limit"),
+          value: url2.searchParams.get("limit"),
           parameter: "limit",
           fallback: DEFAULT_LOG_BODY_CHUNK_BYTES,
           minimum: 1,
@@ -21346,7 +23214,7 @@ const Route$c = createFileRoute("/api/logs/$id/body")({
           createLogBodyChunk({
             log,
             part: partResult.data,
-            offset: parseIntegerParam(url.searchParams.get("offset"), 0),
+            offset: parseIntegerParam(url2.searchParams.get("offset"), 0),
             limit: limitResult.value
           })
         );
@@ -21363,7 +23231,7 @@ const CandidateUpdateSchema = object({
 object({
   candidate: KnowledgeCandidateSchema
 });
-const Route$b = createFileRoute("/api/knowledge/candidates/$candidateId")({
+const Route$f = createFileRoute("/api/knowledge/candidates/$candidateId")({
   server: {
     handlers: {
       PATCH: async ({ params, request }) => {
@@ -21391,6 +23259,52 @@ const Route$b = createFileRoute("/api/knowledge/candidates/$candidateId")({
     }
   }
 });
+const Route$e = createFileRoute("/api/instances/$name/stop")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }) => {
+        const body = await parseInstanceBody(request, InstanceEmptyRequestSchema);
+        if (!body.ok) return body.response;
+        const selfError = selfLifecycleError(params.name);
+        if (selfError !== null) return instanceErrorResponse(selfError);
+        return instanceResultResponse(await stopNamedInstance(params.name));
+      }
+    }
+  }
+});
+const Route$d = createFileRoute("/api/instances/$name/start")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }) => {
+        const body = await parseInstanceBody(request, InstanceStartRequestSchema);
+        if (!body.ok) return body.response;
+        const result = await startNamedInstance(params.name, body.value);
+        const status = result.kind === "success" && result.value.outcome === "created" ? 201 : 200;
+        return instanceResultResponse(result, status);
+      }
+    }
+  }
+});
+const Route$c = createFileRoute("/api/instances/$name/restart")({
+  server: {
+    handlers: {
+      POST: async ({ params, request }) => {
+        const body = await parseInstanceBody(request, InstanceStartRequestSchema);
+        if (!body.ok) return body.response;
+        const selfError = selfLifecycleError(params.name);
+        if (selfError !== null) return instanceErrorResponse(selfError);
+        return instanceResultResponse(await restartNamedInstance(params.name, body.value));
+      }
+    }
+  }
+});
+const Route$b = createFileRoute("/api/instances/$name/connection")({
+  server: {
+    handlers: {
+      GET: async ({ params }) => instanceResultResponse(await getNamedInstanceConnection(params.name))
+    }
+  }
+});
 async function readJsonBody$1(request) {
   try {
     const raw = await request.text();
@@ -22271,201 +24185,231 @@ const Route = createFileRoute("/api/ecosystem/packages/$packageId/help")({
     }
   }
 });
-const ReadyzRoute = Route$N.update({
+const ReadyzRoute = Route$T.update({
   id: "/readyz",
   path: "/readyz",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const LivezRoute = Route$M.update({
+const LivezRoute = Route$S.update({
   id: "/livez",
   path: "/livez",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const IndexRoute = Route$L.update({
+const IndexRoute = Route$R.update({
   id: "/",
   path: "/",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const SessionSessionIdRoute = Route$K.update({
+const SessionSessionIdRoute = Route$Q.update({
   id: "/session/$sessionId",
   path: "/session/$sessionId",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ProxySplatRoute = Route$J.update({
+const ProxySplatRoute = Route$P.update({
   id: "/proxy/$",
   path: "/proxy/$",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiSessionsRoute = Route$I.update({
+const ApiSessionsRoute = Route$O.update({
   id: "/api/sessions",
   path: "/api/sessions",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiRunsRoute = Route$H.update({
+const ApiRunsRoute = Route$N.update({
   id: "/api/runs",
   path: "/api/runs",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiProvidersRoute = Route$G.update({
+const ApiProvidersRoute = Route$M.update({
   id: "/api/providers",
   path: "/api/providers",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiPiAgentRoute = Route$F.update({
+const ApiPiAgentRoute = Route$L.update({
   id: "/api/pi-agent",
   path: "/api/pi-agent",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiModelsRoute = Route$E.update({
+const ApiModelsRoute = Route$K.update({
   id: "/api/models",
   path: "/api/models",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiMcpRoute = Route$D.update({
+const ApiMcpRoute = Route$J.update({
   id: "/api/mcp",
   path: "/api/mcp",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiLogsRoute = Route$C.update({
+const ApiLogsRoute = Route$I.update({
   id: "/api/logs",
   path: "/api/logs",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
+});
+const ApiInstancesRoute = Route$H.update({
+  id: "/api/instances",
+  path: "/api/instances",
+  getParentRoute: () => Route$U
 });
-const ApiHealthRoute = Route$B.update({
+const ApiHealthRoute = Route$G.update({
   id: "/api/health",
   path: "/api/health",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiGroupsRoute = Route$A.update({
+const ApiGroupsRoute = Route$F.update({
   id: "/api/groups",
   path: "/api/groups",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiConfigRoute = Route$z.update({
+const ApiConfigRoute = Route$E.update({
   id: "/api/config",
   path: "/api/config",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiAlertsRoute = Route$y.update({
+const ApiAlertsRoute = Route$D.update({
   id: "/api/alerts",
   path: "/api/alerts",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiRunsRunIdRoute = Route$x.update({
+const ApiRunsRunIdRoute = Route$C.update({
   id: "/$runId",
   path: "/$runId",
   getParentRoute: () => ApiRunsRoute
 });
-const ApiProvidersScanRoute = Route$w.update({
+const ApiProvidersScanRoute = Route$B.update({
   id: "/scan",
   path: "/scan",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersImportRoute = Route$v.update({
+const ApiProvidersImportRoute = Route$A.update({
   id: "/import",
   path: "/import",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersExportRoute = Route$u.update({
+const ApiProvidersExportRoute = Route$z.update({
   id: "/export",
   path: "/export",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiProvidersProviderIdRoute = Route$t.update({
+const ApiProvidersProviderIdRoute = Route$y.update({
   id: "/$providerId",
   path: "/$providerId",
   getParentRoute: () => ApiProvidersRoute
 });
-const ApiLogsStreamRoute = Route$s.update({
+const ApiLogsStreamRoute = Route$x.update({
   id: "/stream",
   path: "/stream",
   getParentRoute: () => ApiLogsRoute
 });
-const ApiLogsImportRoute = Route$r.update({
+const ApiLogsImportRoute = Route$w.update({
   id: "/import",
   path: "/import",
   getParentRoute: () => ApiLogsRoute
 });
-const ApiLogsIdRoute = Route$q.update({
+const ApiLogsIdRoute = Route$v.update({
   id: "/$id",
   path: "/$id",
   getParentRoute: () => ApiLogsRoute
 });
-const ApiKnowledgeSearchRoute = Route$p.update({
+const ApiKnowledgeSearchRoute = Route$u.update({
   id: "/api/knowledge/search",
   path: "/api/knowledge/search",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiKnowledgeProjectContextRoute = Route$o.update({
+const ApiKnowledgeProjectContextRoute = Route$t.update({
   id: "/api/knowledge/project-context",
   path: "/api/knowledge/project-context",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiKnowledgeCandidatesRoute = Route$n.update({
+const ApiKnowledgeCandidatesRoute = Route$s.update({
   id: "/api/knowledge/candidates",
   path: "/api/knowledge/candidates",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiGroupsGroupIdRoute = Route$m.update({
+const ApiInstancesNameRoute = Route$r.update({
+  id: "/$name",
+  path: "/$name",
+  getParentRoute: () => ApiInstancesRoute
+});
+const ApiGroupsGroupIdRoute = Route$q.update({
   id: "/$groupId",
   path: "/$groupId",
   getParentRoute: () => ApiGroupsRoute
 });
-const ApiEcosystemTasksRoute = Route$l.update({
+const ApiEcosystemTasksRoute = Route$p.update({
   id: "/api/ecosystem/tasks",
   path: "/api/ecosystem/tasks",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiEcosystemPackagesRoute = Route$k.update({
+const ApiEcosystemPackagesRoute = Route$o.update({
   id: "/api/ecosystem/packages",
   path: "/api/ecosystem/packages",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
-const ApiConfigPathsRoute = Route$j.update({
+const ApiConfigPathsRoute = Route$n.update({
   id: "/paths",
   path: "/paths",
   getParentRoute: () => ApiConfigRoute
 });
-const ApiAlertsSummaryRoute = Route$i.update({
+const ApiAlertsSummaryRoute = Route$m.update({
   id: "/summary",
   path: "/summary",
   getParentRoute: () => ApiAlertsRoute
 });
-const ApiRunsRunIdEvidenceRoute = Route$h.update({
+const ApiRunsRunIdEvidenceRoute = Route$l.update({
   id: "/evidence",
   path: "/evidence",
   getParentRoute: () => ApiRunsRunIdRoute
 });
-const ApiProvidersProviderIdTestRoute = Route$g.update({
+const ApiProvidersProviderIdTestRoute = Route$k.update({
   id: "/test",
   path: "/test",
   getParentRoute: () => ApiProvidersProviderIdRoute
 });
-const ApiProvidersProviderIdModelMetadataRoute = Route$f.update({
+const ApiProvidersProviderIdModelMetadataRoute = Route$j.update({
   id: "/model-metadata",
   path: "/model-metadata",
   getParentRoute: () => ApiProvidersProviderIdRoute
 });
-const ApiLogsIdReplayRoute = Route$e.update({
+const ApiLogsIdReplayRoute = Route$i.update({
   id: "/replay",
   path: "/replay",
   getParentRoute: () => ApiLogsIdRoute
 });
-const ApiLogsIdChunksRoute = Route$d.update({
+const ApiLogsIdChunksRoute = Route$h.update({
   id: "/chunks",
   path: "/chunks",
   getParentRoute: () => ApiLogsIdRoute
 });
-const ApiLogsIdBodyRoute = Route$c.update({
+const ApiLogsIdBodyRoute = Route$g.update({
   id: "/body",
   path: "/body",
   getParentRoute: () => ApiLogsIdRoute
 });
-const ApiKnowledgeCandidatesCandidateIdRoute = Route$b.update({
+const ApiKnowledgeCandidatesCandidateIdRoute = Route$f.update({
   id: "/$candidateId",
   path: "/$candidateId",
   getParentRoute: () => ApiKnowledgeCandidatesRoute
 });
+const ApiInstancesNameStopRoute = Route$e.update({
+  id: "/stop",
+  path: "/stop",
+  getParentRoute: () => ApiInstancesNameRoute
+});
+const ApiInstancesNameStartRoute = Route$d.update({
+  id: "/start",
+  path: "/start",
+  getParentRoute: () => ApiInstancesNameRoute
+});
+const ApiInstancesNameRestartRoute = Route$c.update({
+  id: "/restart",
+  path: "/restart",
+  getParentRoute: () => ApiInstancesNameRoute
+});
+const ApiInstancesNameConnectionRoute = Route$b.update({
+  id: "/connection",
+  path: "/connection",
+  getParentRoute: () => ApiInstancesNameRoute
+});
 const ApiGroupsGroupIdSessionsRoute = Route$a.update({
   id: "/sessions",
   path: "/sessions",
@@ -22489,7 +24433,7 @@ const ApiProvidersProviderIdTestLogRoute = Route$7.update({
 const ApiKnowledgeSessionsSessionIdCandidatesRoute = Route$6.update({
   id: "/api/knowledge/sessions/$sessionId/candidates",
   path: "/api/knowledge/sessions/$sessionId/candidates",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
 const ApiKnowledgeCandidatesCandidateIdPromoteRoute = Route$5.update({
   id: "/promote",
@@ -22499,7 +24443,7 @@ const ApiKnowledgeCandidatesCandidateIdPromoteRoute = Route$5.update({
 const ApiEcosystemRecipesRecipeIdRunRoute = Route$4.update({
   id: "/api/ecosystem/recipes/$recipeId/run",
   path: "/api/ecosystem/recipes/$recipeId/run",
-  getParentRoute: () => Route$O
+  getParentRoute: () => Route$U
 });
 const ApiEcosystemPackagesPackageIdUpgradeRoute = Route$3.update({
   id: "/$packageId/upgrade",
@@ -22544,6 +24488,19 @@ const ApiGroupsRouteChildren = {
 const ApiGroupsRouteWithChildren = ApiGroupsRoute._addFileChildren(
   ApiGroupsRouteChildren
 );
+const ApiInstancesNameRouteChildren = {
+  ApiInstancesNameConnectionRoute,
+  ApiInstancesNameRestartRoute,
+  ApiInstancesNameStartRoute,
+  ApiInstancesNameStopRoute
+};
+const ApiInstancesNameRouteWithChildren = ApiInstancesNameRoute._addFileChildren(ApiInstancesNameRouteChildren);
+const ApiInstancesRouteChildren = {
+  ApiInstancesNameRoute: ApiInstancesNameRouteWithChildren
+};
+const ApiInstancesRouteWithChildren = ApiInstancesRoute._addFileChildren(
+  ApiInstancesRouteChildren
+);
 const ApiLogsIdRouteChildren = {
   ApiLogsIdBodyRoute,
   ApiLogsIdChunksRoute,
@@ -22621,6 +24578,7 @@ const rootRouteChildren = {
   ApiConfigRoute: ApiConfigRouteWithChildren,
   ApiGroupsRoute: ApiGroupsRouteWithChildren,
   ApiHealthRoute,
+  ApiInstancesRoute: ApiInstancesRouteWithChildren,
   ApiLogsRoute: ApiLogsRouteWithChildren,
   ApiMcpRoute,
   ApiModelsRoute,
@@ -22638,7 +24596,7 @@ const rootRouteChildren = {
   ApiEcosystemRecipesRecipeIdRunRoute,
   ApiKnowledgeSessionsSessionIdCandidatesRoute
 };
-const routeTree = Route$O._addFileChildren(rootRouteChildren)._addFileTypes();
+const routeTree = Route$U._addFileChildren(rootRouteChildren)._addFileTypes();
 function defaultRouterBasePath() {
   return getRouterBasePath(typeof process === "undefined" ? void 0 : process.env);
 }
@@ -22670,54 +24628,53 @@ const router = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProper
   getRouter
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  PATH_V1_RESPONSES as $,
+  formatContextWindowInput as $,
   AnthropicResponseSchema$1 as A,
   Button as B,
   CapturedLogSchema as C,
   DEFAULT_CAPTURE_MODE as D,
-  getStatusCategory as E,
-  stripClaudeCodeBillingHeader as F,
-  LazyFeatureBoundary as G,
-  AlertSummarySchema as H,
-  AlertListResponseSchema as I,
-  GroupEvidenceReadResponseSchema as J,
+  stripClaudeCodeBillingHeader as E,
+  LazyFeatureBoundary as F,
+  AlertSummarySchema as G,
+  AlertListResponseSchema as H,
+  GroupEvidenceReadResponseSchema as I,
+  InspectorGroupsListResponseSchema as J,
   KnowledgeCandidateSchema as K,
   LogBodyChunkSchema as L,
-  InspectorGroupsListResponseSchema as M,
-  DeleteInspectorGroupsResponseSchema as N,
+  DeleteInspectorGroupsResponseSchema as M,
+  GroupEvidenceExportResultSchema as N,
   OpenAIRequestSchema as O,
-  GroupEvidenceExportResultSchema as P,
-  DeleteInspectorGroupResponseSchema as Q,
-  Route$K as R,
+  DeleteInspectorGroupResponseSchema as P,
+  ProviderScanResponseSchema as Q,
+  Route$Q as R,
   SafeRouteError as S,
   THEME_MODE_STORAGE_KEY as T,
   UI_SCALE_STORAGE_KEY as U,
-  ProviderScanResponseSchema as V,
-  providerHasContextMetadata as W,
-  findProviderModelMetadata as X,
-  formatContextWindowTokens as Y,
-  PATH_V1_MESSAGES as Z,
-  PATH_V1_CHAT_COMPLETIONS as _,
+  providerHasContextMetadata as V,
+  findProviderModelMetadata as W,
+  formatContextWindowTokens as X,
+  PATH_V1_MESSAGES as Y,
+  PATH_V1_CHAT_COMPLETIONS as Z,
+  PATH_V1_RESPONSES as _,
   DEFAULT_SLOW_RESPONSE_THRESHOLD_SECONDS as a,
-  formatContextWindowInput as a0,
-  parseContextWindowTokensInput as a1,
-  previewUpstreamUrl as a2,
-  createPendingProviderTestResults as a3,
-  ProviderTestResultsSchema as a4,
-  createFailedProviderTestResults as a5,
-  MAX_SLOW_RESPONSE_THRESHOLD_SECONDS as a6,
-  MAX_PROVIDER_TEST_TIMEOUT_SECONDS as a7,
-  TimeDisplayFormatSchema as a8,
-  EcosystemPackagesResponseSchema as a9,
-  EcosystemTaskResponseSchema as aa,
-  EcosystemTasksResponseSchema as ab,
-  EcosystemExecutionConfirmationResponseSchema as ac,
-  CrabLogo as ad,
-  resolveProviderContextWindow as ae,
-  isPlainRecord as af,
-  formatUiScale as ag,
-  StreamingChunkSchema$1 as ah,
-  router as ai,
+  parseContextWindowTokensInput as a0,
+  previewUpstreamUrl as a1,
+  createPendingProviderTestResults as a2,
+  ProviderTestResultsSchema as a3,
+  createFailedProviderTestResults as a4,
+  MAX_SLOW_RESPONSE_THRESHOLD_SECONDS as a5,
+  MAX_PROVIDER_TEST_TIMEOUT_SECONDS as a6,
+  TimeDisplayFormatSchema as a7,
+  EcosystemPackagesResponseSchema as a8,
+  EcosystemTaskResponseSchema as a9,
+  EcosystemTasksResponseSchema as aa,
+  EcosystemExecutionConfirmationResponseSchema as ab,
+  CrabLogo as ac,
+  resolveProviderContextWindow as ad,
+  isPlainRecord as ae,
+  formatUiScale as af,
+  StreamingChunkSchema$1 as ag,
+  router as ah,
   DEFAULT_PROVIDER_TEST_TIMEOUT_SECONDS as b,
   DEFAULT_TIME_DISPLAY_FORMAT as c,
   RuntimeConfigSchema as d,
@@ -22725,7 +24682,7 @@ export {
   persistThemeMode as f,
   readStoredUiScalePreference as g,
   persistUiScalePreference as h,
-  isRecord as i,
+  isRecord$2 as i,
   applyUiScalePreference as j,
   normalizeUiScalePreference as k,
   RedactedProviderDtoSchema as l,
@@ -22739,8 +24696,8 @@ export {
   parseOpenAIResponsesResponse as t,
   OpenAIResponsesRequestSchema as u,
   apiFormatForPath as v,
-  withBasePath as w,
-  getSessionPath as x,
-  formatTokens as y,
-  copyTextToClipboard as z
+  getSessionPath as w,
+  formatTokens as x,
+  copyTextToClipboard as y,
+  getStatusCategory as z
 };