@inspecto-dev/plugin 0.3.7 → 0.3.9

package/dist/webpack.cjs

@@ -34,14 +34,16 @@ __export(src_exports, {
   esbuildPlugin: () => esbuildPlugin,
   rollupPlugin: () => rollupPlugin,
   rspackPlugin: () => rspackPlugin,
+  transformAstro: () => transformAstro,
   transformJsx: () => transformJsx,
+  transformRouter: () => transformRouter,
   unplugin: () => unplugin,
   vitePlugin: () => vitePlugin,
   webpackPlugin: () => webpackPlugin
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.9_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.10_typescript@5.9.3_yaml@2.8.3/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
@@ -120,14 +122,14 @@ function extractTransformFilePath(requestId) {
     wrapped: filePath !== requestId
   };
 }
-function shouldTransform(filePath, options) {
+function shouldTransform(filePath, _options) {
   const resolvedFilePath = extractTransformFilePath(filePath).filePath;
   if (process.env["NODE_ENV"] === "production") return false;
   if (resolvedFilePath.includes("node_modules")) return false;
   if (resolvedFilePath.startsWith("\0")) return false;
   if (/[/\\](dist|build|\.next|\.nuxt)[/\\]/.test(resolvedFilePath)) return false;
   const ext = resolvedFilePath.split(".").pop()?.toLowerCase();
-  if (ext && !["js", "jsx", "ts", "tsx", "mjs", "mts", "vue"].includes(ext)) {
+  if (ext && !["js", "jsx", "ts", "tsx", "mjs", "mts", "vue", "svelte", "astro"].includes(ext)) {
     return false;
   }
   return true;
@@ -288,7 +290,7 @@ function transformVue(options) {
     if (escapeTagsSet.has(tagName)) return;
     if (tagName === "template" && node === ast.children[0]) return;
     const alreadyHasAttr = node.props.some(
-      (p) => p.type === import_compiler_core.NodeTypes.ATTRIBUTE && p.name === attributeName
+      (p2) => p2.type === import_compiler_core.NodeTypes.ATTRIBUTE && p2.name === attributeName
     );
     if (alreadyHasAttr) return;
     const loc = node.loc;
@@ -325,6 +327,387 @@ function walkElement(node, visitor) {
   }
 }
 
+// src/transform/transform-svelte.ts
+var import_magic_string3 = __toESM(require("magic-string"), 1);
+var import_compiler = require("svelte/compiler");
+function walk(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  visitor.enter(node);
+  for (const key in node) {
+    if (key === "parent" || key === "prev" || key === "next") continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      value.forEach((child) => {
+        if (child && typeof child === "object") walk(child, visitor);
+      });
+    } else if (value && typeof value === "object") {
+      walk(value, visitor);
+    }
+  }
+}
+function transformSvelte(options) {
+  const { filePath, source, escapeTags, attributeName = "data-inspecto" } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  let replacedContent = source;
+  const scriptRegex = /<script(?:\s+[a-zA-Z-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]*))?)?>[\s\S]*?<\/script>/gi;
+  const styleRegex = /<style(?:\s+[a-zA-Z-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^>\s]*))?)?>[\s\S]*?<\/style>/gi;
+  const scriptMatches = source.match(scriptRegex) || [];
+  const styleMatches = source.match(styleRegex) || [];
+  [...scriptMatches, ...styleMatches].forEach((match) => {
+    replacedContent = replacedContent.replace(match, " ".repeat(match.length));
+  });
+  let ast;
+  try {
+    ast = (0, import_compiler.parse)(replacedContent);
+  } catch {
+    return { code: source, map: null, changed: false };
+  }
+  const s2 = new import_magic_string3.default(source);
+  let changed = false;
+  function countLines(text, position) {
+    let lines = 0;
+    for (let i2 = 0; i2 < position; i2++) {
+      if (text[i2] === "\n") lines++;
+    }
+    return lines;
+  }
+  const root = ast.html || ast.fragment || ast;
+  walk(root, {
+    enter(node) {
+      if (node.type === "Element" || node.type === "RegularElement" || node.type === "InlineComponent" || node.type === "Component") {
+        const tagName = node.name || "";
+        if (tagName && !escapeTagsSet.has(tagName.toLowerCase()) && !node.attributes?.some((attr) => attr.name === attributeName)) {
+          const insertPosition = node.start + tagName.length + 1;
+          const line = countLines(source, node.start) + 1;
+          const lastNewLine = source.lastIndexOf("\n", node.start - 1);
+          const column = lastNewLine === -1 ? node.start + 1 : node.start - lastNewLine;
+          const attrValue = formatAttrValue(filePath, line, column);
+          const addition = ` ${attributeName}="${attrValue}"`;
+          s2.appendLeft(insertPosition, addition);
+          changed = true;
+        }
+      }
+    }
+  });
+  return {
+    code: s2.toString(),
+    map: changed ? s2.generateMap({ source: filePath, includeContent: true }) : null,
+    changed
+  };
+}
+
+// src/transform/transform-astro.ts
+var import_magic_string4 = __toESM(require("magic-string"), 1);
+
+// ../../node_modules/.pnpm/@astrojs+compiler@3.0.1/node_modules/@astrojs/compiler/dist/chunk-W5DTLHV4.js
+var import_crypto = __toESM(require("crypto"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_util = require("util");
+globalThis.fs || Object.defineProperty(globalThis, "fs", { value: import_fs.default });
+globalThis.process || Object.defineProperties(globalThis, "process", { value: process });
+globalThis.crypto || Object.defineProperty(globalThis, "crypto", { value: import_crypto.default.webcrypto ? import_crypto.default.webcrypto : { getRandomValues(m2) {
+  return import_crypto.default.randomFillSync(m2);
+} } });
+globalThis.performance || Object.defineProperty(globalThis, "performance", { value: { now() {
+  let [m2, o] = process.hrtime();
+  return m2 * 1e3 + o / 1e6;
+} } });
+var y = new import_util.TextEncoder("utf-8");
+var w = new import_util.TextDecoder("utf-8");
+var d = class {
+  constructor() {
+    this.argv = ["js"], this.env = {}, this.exit = (t) => {
+      t !== 0 && console.warn("exit code:", t);
+    }, this._exitPromise = new Promise((t) => {
+      this._resolveExitPromise = t;
+    }), this._pendingEvent = null, this._scheduledTimeouts = /* @__PURE__ */ new Map(), this._nextCallbackTimeoutID = 1;
+    let o = (t, e) => {
+      this.mem.setUint32(t + 0, e, true), this.mem.setUint32(t + 4, Math.floor(e / 4294967296), true);
+    }, n = (t) => {
+      let e = this.mem.getUint32(t + 0, true), s2 = this.mem.getInt32(t + 4, true);
+      return e + s2 * 4294967296;
+    }, r = (t) => {
+      let e = this.mem.getFloat64(t, true);
+      if (e === 0) return;
+      if (!isNaN(e)) return e;
+      let s2 = this.mem.getUint32(t, true);
+      return this._values[s2];
+    }, l = (t, e) => {
+      if (typeof e == "number" && e !== 0) {
+        if (isNaN(e)) {
+          this.mem.setUint32(t + 4, 2146959360, true), this.mem.setUint32(t, 0, true);
+          return;
+        }
+        this.mem.setFloat64(t, e, true);
+        return;
+      }
+      if (e === void 0) {
+        this.mem.setFloat64(t, 0, true);
+        return;
+      }
+      let i2 = this._ids.get(e);
+      i2 === void 0 && (i2 = this._idPool.pop(), i2 === void 0 && (i2 = this._values.length), this._values[i2] = e, this._goRefCounts[i2] = 0, this._ids.set(e, i2)), this._goRefCounts[i2]++;
+      let a = 0;
+      switch (typeof e) {
+        case "object":
+          e !== null && (a = 1);
+          break;
+        case "string":
+          a = 2;
+          break;
+        case "symbol":
+          a = 3;
+          break;
+        case "function":
+          a = 4;
+          break;
+      }
+      this.mem.setUint32(t + 4, 2146959360 | a, true), this.mem.setUint32(t, i2, true);
+    }, c = (t) => {
+      let e = n(t + 0), s2 = n(t + 8);
+      return new Uint8Array(this._inst.exports.mem.buffer, e, s2);
+    }, f2 = (t) => {
+      let e = n(t + 0), s2 = n(t + 8), i2 = new Array(s2);
+      for (let a = 0; a < s2; a++) i2[a] = r(e + a * 8);
+      return i2;
+    }, u = (t) => {
+      let e = n(t + 0), s2 = n(t + 8);
+      return w.decode(new DataView(this._inst.exports.mem.buffer, e, s2));
+    }, h = Date.now() - performance.now();
+    this.importObject = { gojs: { "runtime.wasmExit": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      this.exited = true, delete this._inst, delete this._values, delete this._goRefCounts, delete this._ids, delete this._idPool, this.exit(e);
+    }, "runtime.wasmWrite": (t) => {
+      t >>>= 0;
+      let e = n(t + 8), s2 = n(t + 16), i2 = this.mem.getInt32(t + 24, true);
+      import_fs.default.writeSync(e, new Uint8Array(this._inst.exports.mem.buffer, s2, i2));
+    }, "runtime.resetMemoryDataView": (t) => {
+      t >>>= 0, this.mem = new DataView(this._inst.exports.mem.buffer);
+    }, "runtime.nanotime1": (t) => {
+      t >>>= 0, o(t + 8, (h + performance.now()) * 1e6);
+    }, "runtime.walltime": (t) => {
+      t >>>= 0;
+      let e = (/* @__PURE__ */ new Date()).getTime();
+      o(t + 8, e / 1e3), this.mem.setInt32(t + 16, e % 1e3 * 1e6, true);
+    }, "runtime.scheduleTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this._nextCallbackTimeoutID;
+      this._nextCallbackTimeoutID++, this._scheduledTimeouts.set(e, setTimeout(() => {
+        for (this._resume(); this._scheduledTimeouts.has(e); ) console.warn("scheduleTimeoutEvent: missed timeout event"), this._resume();
+      }, n(t + 8) + 1)), this.mem.setInt32(t + 16, e, true);
+    }, "runtime.clearTimeoutEvent": (t) => {
+      t >>>= 0;
+      let e = this.mem.getInt32(t + 8, true);
+      clearTimeout(this._scheduledTimeouts.get(e)), this._scheduledTimeouts.delete(e);
+    }, "runtime.getRandomData": (t) => {
+      t >>>= 0, globalThis.crypto.getRandomValues(c(t + 8));
+    }, "syscall/js.finalizeRef": (t) => {
+      t >>>= 0;
+      let e = this.mem.getUint32(t + 8, true);
+      if (this._goRefCounts[e]--, this._goRefCounts[e] === 0) {
+        let s2 = this._values[e];
+        this._values[e] = null, this._ids.delete(s2), this._idPool.push(e);
+      }
+    }, "syscall/js.stringVal": (t) => {
+      t >>>= 0, l(t + 24, u(t + 8));
+    }, "syscall/js.valueGet": (t) => {
+      t >>>= 0;
+      let e = Reflect.get(r(t + 8), u(t + 16));
+      t = this._inst.exports.getsp() >>> 0, l(t + 32, e);
+    }, "syscall/js.valueSet": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), u(t + 16), r(t + 32));
+    }, "syscall/js.valueDelete": (t) => {
+      t >>>= 0, Reflect.deleteProperty(r(t + 8), u(t + 16));
+    }, "syscall/js.valueIndex": (t) => {
+      t >>>= 0, l(t + 24, Reflect.get(r(t + 8), n(t + 16)));
+    }, "syscall/js.valueSetIndex": (t) => {
+      t >>>= 0, Reflect.set(r(t + 8), n(t + 16), r(t + 24));
+    }, "syscall/js.valueCall": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s2 = Reflect.get(e, u(t + 16)), i2 = f2(t + 32), a = Reflect.apply(s2, e, i2);
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, a), this.mem.setUint8(t + 64, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 56, e), this.mem.setUint8(t + 64, 0);
+      }
+    }, "syscall/js.valueInvoke": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s2 = f2(t + 16), i2 = Reflect.apply(e, void 0, s2);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i2), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueNew": (t) => {
+      t >>>= 0;
+      try {
+        let e = r(t + 8), s2 = f2(t + 16), i2 = Reflect.construct(e, s2);
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, i2), this.mem.setUint8(t + 48, 1);
+      } catch (e) {
+        t = this._inst.exports.getsp() >>> 0, l(t + 40, e), this.mem.setUint8(t + 48, 0);
+      }
+    }, "syscall/js.valueLength": (t) => {
+      t >>>= 0, o(t + 16, Number.parseInt(r(t + 8).length));
+    }, "syscall/js.valuePrepareString": (t) => {
+      t >>>= 0;
+      let e = y.encode(String(r(t + 8)));
+      l(t + 16, e), o(t + 24, e.length);
+    }, "syscall/js.valueLoadString": (t) => {
+      t >>>= 0;
+      let e = r(t + 8);
+      c(t + 16).set(e);
+    }, "syscall/js.valueInstanceOf": (t) => {
+      t >>>= 0, this.mem.setUint8(t + 24, r(t + 8) instanceof r(t + 16) ? 1 : 0);
+    }, "syscall/js.copyBytesToGo": (t) => {
+      t >>>= 0;
+      let e = c(t + 8), s2 = r(t + 32);
+      if (!(s2 instanceof Uint8Array || s2 instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i2 = s2.subarray(0, e.length);
+      e.set(i2), o(t + 40, i2.length), this.mem.setUint8(t + 48, 1);
+    }, "syscall/js.copyBytesToJS": (t) => {
+      t >>>= 0;
+      let e = r(t + 8), s2 = c(t + 16);
+      if (!(e instanceof Uint8Array || e instanceof Uint8ClampedArray)) {
+        this.mem.setUint8(t + 48, 0);
+        return;
+      }
+      let i2 = s2.subarray(0, e.length);
+      e.set(i2), o(t + 40, i2.length), this.mem.setUint8(t + 48, 1);
+    }, debug: (t) => {
+      console.log(t);
+    } } };
+  }
+  async run(o) {
+    if (!(o instanceof WebAssembly.Instance)) throw new Error("Go.run: WebAssembly.Instance expected");
+    this._inst = o, this.mem = new DataView(this._inst.exports.mem.buffer), this._values = [Number.NaN, 0, null, true, false, globalThis, this], this._goRefCounts = new Array(this._values.length).fill(Number.POSITIVE_INFINITY), this._ids = /* @__PURE__ */ new Map([[0, 1], [null, 2], [true, 3], [false, 4], [globalThis, 5], [this, 6]]), this._idPool = [], this.exited = false;
+    let n = 4096, r = (h) => {
+      let t = n, e = y.encode(`${h}\0`);
+      return new Uint8Array(this.mem.buffer, n, e.length).set(e), n += e.length, n % 8 !== 0 && (n += 8 - n % 8), t;
+    }, l = this.argv.length, c = [];
+    this.argv.forEach((h) => {
+      c.push(r(h));
+    }), c.push(0), Object.keys(this.env).sort().forEach((h) => {
+      c.push(r(`${h}=${this.env[h]}`));
+    }), c.push(0);
+    let u = n;
+    c.forEach((h) => {
+      this.mem.setUint32(n, h, true), this.mem.setUint32(n + 4, 0, true), n += 8;
+    }), this._inst.exports.run(l, u), this.exited && this._resolveExitPromise(), await this._exitPromise;
+  }
+  _resume() {
+    if (this.exited) throw new Error("Go program has already exited");
+    this._inst.exports.resume(), this.exited && this._resolveExitPromise();
+  }
+  _makeFuncWrapper(o) {
+    let n = this;
+    return function() {
+      let r = { id: o, this: this, args: arguments };
+      return n._pendingEvent = r, n._resume(), r.result;
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/@astrojs+compiler@3.0.1/node_modules/@astrojs/compiler/dist/node/sync.js
+var import_fs2 = require("fs");
+var import_url = require("url");
+function i() {
+  return s || (s = f()), s;
+}
+var s;
+var w2 = (e, t) => i().parse(e, t);
+function f() {
+  let e = new d(), t = v2((0, import_url.fileURLToPath)(new URL("../astro.wasm", importMetaUrl)), e.importObject);
+  e.run(t);
+  let o = globalThis["@astrojs/compiler"];
+  return { transform: (n, a) => {
+    try {
+      return o.transform(n, a || {});
+    } catch (r) {
+      throw s = void 0, r;
+    }
+  }, parse: (n, a) => {
+    try {
+      let r = o.parse(n, a || {});
+      return { ...r, ast: JSON.parse(r.ast) };
+    } catch (r) {
+      throw s = void 0, r;
+    }
+  }, convertToTSX: (n, a) => {
+    try {
+      let r = o.convertToTSX(n, a || {});
+      return { ...r, map: JSON.parse(r.map) };
+    } catch (r) {
+      throw s = void 0, r;
+    }
+  } };
+}
+function v2(e, t) {
+  let o = (0, import_fs2.readFileSync)(e);
+  return new WebAssembly.Instance(new WebAssembly.Module(o), t);
+}
+
+// src/transform/transform-astro.ts
+function walk2(node, visitor) {
+  if (!node || typeof node !== "object") return;
+  visitor.enter(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walk2(child, visitor);
+    }
+  }
+}
+function transformAstro(options) {
+  const { filePath, source, escapeTags, attributeName = "data-inspecto" } = options;
+  const escapeTagsSet = buildEscapeTagsSet(escapeTags);
+  let ast;
+  try {
+    ast = w2(source, { position: true }).ast;
+  } catch (_err) {
+    return { code: source, map: null, changed: false };
+  }
+  const s2 = new import_magic_string4.default(source);
+  let changed = false;
+  walk2(ast, {
+    enter(node) {
+      if (node.type === "element" || node.type === "component") {
+        const tagName = node.name;
+        if (tagName && !escapeTagsSet.has(tagName) && !node.attributes?.some((attr) => attr.name === attributeName)) {
+          const startOffset = node.position?.start?.offset ?? -1;
+          if (startOffset === -1) return;
+          let tagStartIndex = startOffset;
+          while (tagStartIndex >= 0 && source[tagStartIndex] !== "<") {
+            tagStartIndex--;
+          }
+          if (tagStartIndex >= 0) {
+            const substringAfterTag = source.substring(tagStartIndex);
+            const escapedTagName = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const strictRegex = new RegExp(`^<\\s*${escapedTagName}(?=\\s|/|>)`, "i");
+            const strictMatch = substringAfterTag.match(strictRegex);
+            if (strictMatch) {
+              const insertPosition = tagStartIndex + strictMatch[0].length;
+              const line = node.position.start.line;
+              const column = node.position.start.column;
+              const attrValue = formatAttrValue(filePath, line, column);
+              const addition = ` ${attributeName}="${attrValue}"`;
+              s2.appendLeft(insertPosition, addition);
+              changed = true;
+            }
+          }
+        }
+      }
+    }
+  });
+  return {
+    code: s2.toString(),
+    map: changed ? s2.generateMap({ source: filePath, includeContent: true }) : null,
+    changed
+  };
+}
+
 // src/transform/index.ts
 function transformRouter(options) {
   const { filePath, source, projectRoot, pluginOptions } = options;
@@ -349,6 +732,25 @@ function transformRouter(options) {
       attributeName: pluginOptions.attributeName
     });
   }
+  if (ext === ".svelte") {
+    return transformSvelte({
+      filePath,
+      source,
+      projectRoot,
+      escapeTags: pluginOptions.escapeTags,
+      pathType: pluginOptions.pathType,
+      attributeName: pluginOptions.attributeName
+    });
+  }
+  if (ext === ".astro") {
+    return transformAstro({
+      filePath,
+      source,
+      escapeTags: pluginOptions.escapeTags,
+      pathType: pluginOptions.pathType,
+      attributeName: pluginOptions.attributeName
+    });
+  }
   return null;
 }
 
@@ -487,7 +889,7 @@ function isDebugEnabled(namespace) {
   if (typeof process === "undefined" || !process.env) return false;
   const debugEnv = process.env.DEBUG;
   if (!debugEnv) return false;
-  const namespaces = debugEnv.split(",").map((s) => s.trim());
+  const namespaces = debugEnv.split(",").map((s2) => s2.trim());
   for (const ns of namespaces) {
     if (ns === "*") return true;
     if (ns.endsWith("*")) {
@@ -643,7 +1045,7 @@ function readJsonSafely(filePath) {
   }
   return null;
 }
-function resolveTargetTool(config, ide = "vscode") {
+function resolveTargetTool(config, _ide = "vscode") {
   const defaultProvider = config["provider.default"];
   if (defaultProvider) {
     const tool = defaultProvider.split(".")[0];
@@ -751,7 +1153,7 @@ function resolveIntents(serverPrompts) {
         configLogger.warn(`Intent "${item.id}" is missing required "aiIntent".`);
         continue;
       }
-      const existingIdx = merged.findIndex((i) => i.id === item.id);
+      const existingIdx = merged.findIndex((i2) => i2.id === item.id);
       if (existingIdx !== -1) {
         if (item.enabled === false) {
           merged.splice(existingIdx, 1);
@@ -795,7 +1197,7 @@ function watchConfig(onReload, cwd = process.cwd(), gitRoot) {
       });
       watcher.unref();
       watchers.push(watcher);
-    } catch (e) {
+    } catch (_e) {
     }
   }
 }
@@ -863,7 +1265,6 @@ function dispatchPromptThroughIde(runtime, payload) {
     line: payload.line,
     column: payload.column,
     snippet: payload.snippet,
-    ...payload.screenshotContext ? { screenshotContext: payload.screenshotContext } : {},
     overrides: runtime.overrides,
     autoSend: runtime.autoSend
   });
@@ -997,6 +1398,188 @@ function assertPathWithinIdeOpenScope(file, projectRoot) {
   }
 }
 
+// src/server/session-store.ts
+var DEFAULT_STATUS = "pending";
+function createAnnotationSessionStore(options = {}) {
+  const sessions = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const now = options.now ?? (() => Date.now());
+  const createId = options.createId ?? createRandomId;
+  function findNewestMatchingSession(statuses) {
+    return [...sessions.values()].filter((session) => statuses ? statuses.has(session.status) : true).sort((left, right) => right.updatedAt - left.updatedAt)[0] ?? null;
+  }
+  function updateSessionStatus(id, status) {
+    const session = sessions.get(id);
+    if (!session) return null;
+    const timestamp = now();
+    session.status = status;
+    session.updatedAt = timestamp;
+    if (status === "acknowledged") {
+      session.acknowledgedAt = timestamp;
+    }
+    if (status === "resolved") {
+      session.resolvedAt = timestamp;
+    }
+    emit({ type: "session-status-updated", session });
+    return cloneSession(session);
+  }
+  function claimSession(id, statuses) {
+    const session = sessions.get(id);
+    if (!session || statuses && !statuses.has(session.status)) return null;
+    if (session.status === "acknowledged") return cloneSession(session);
+    return updateSessionStatus(id, "acknowledged");
+  }
+  function emit(event) {
+    const snapshot = cloneSession(event.session);
+    for (const listener of listeners) {
+      listener({ type: event.type, session: snapshot });
+    }
+  }
+  const store = {
+    createSession(input) {
+      const timestamp = now();
+      const session = {
+        id: createId(),
+        instruction: input.instruction?.trim() ?? "",
+        annotations: cloneArray(input.annotations),
+        ...input.deliveryMode ? { deliveryMode: input.deliveryMode } : {},
+        status: DEFAULT_STATUS,
+        messages: cloneArray(input.messages ?? []),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        ...input.runtimeContext ? { runtimeContext: cloneValue(input.runtimeContext) } : {},
+        ...input.cssContextPrompt?.trim() ? { cssContextPrompt: input.cssContextPrompt.trim() } : {},
+        ...input.pageUrl ? { pageUrl: input.pageUrl } : {},
+        ...input.route ? { route: input.route } : {}
+      };
+      sessions.set(session.id, session);
+      emit({ type: "session-created", session });
+      return cloneSession(session);
+    },
+    getSession(id) {
+      const session = sessions.get(id);
+      return session ? cloneSession(session) : null;
+    },
+    listSessions(options2 = {}) {
+      const statuses = normalizeStatuses(options2.status);
+      return [...sessions.values()].filter((session) => statuses ? statuses.has(session.status) : true).sort((left, right) => right.updatedAt - left.updatedAt).map((session) => cloneSession(session));
+    },
+    async claimNextSession(options2 = {}) {
+      const statuses = normalizeStatuses(DEFAULT_STATUS);
+      const existingSession = findNewestMatchingSession(statuses);
+      if (existingSession) {
+        return {
+          session: claimSession(existingSession.id, statuses),
+          timedOut: false,
+          matchedExisting: true
+        };
+      }
+      const timeoutMs = normalizeTimeoutMs(options2.timeoutMs);
+      if (timeoutMs === 0) {
+        return {
+          session: null,
+          timedOut: true,
+          matchedExisting: false
+        };
+      }
+      return await new Promise((resolve2) => {
+        let settled = false;
+        let timeout = null;
+        const finish = (result) => {
+          if (settled) return;
+          settled = true;
+          unsubscribe();
+          if (timeout) {
+            clearTimeout(timeout);
+          }
+          resolve2(result);
+        };
+        const unsubscribe = this.subscribe((event) => {
+          const session = claimSession(event.session.id, statuses);
+          if (!session) return;
+          finish({
+            session,
+            timedOut: false,
+            matchedExisting: false,
+            event: event.type
+          });
+        });
+        if (timeoutMs !== null) {
+          timeout = setTimeout(() => {
+            finish({
+              session: null,
+              timedOut: true,
+              matchedExisting: false
+            });
+          }, timeoutMs);
+        }
+      });
+    },
+    appendMessage(id, input) {
+      const session = sessions.get(id);
+      if (!session) return null;
+      const timestamp = now();
+      session.messages.push({
+        id: createId(),
+        role: input.role,
+        text: input.text,
+        createdAt: timestamp
+      });
+      session.updatedAt = timestamp;
+      if (input.role === "agent" && isPendingLikeStatus(session.status)) {
+        session.status = "in_progress";
+      }
+      emit({ type: "session-message-appended", session });
+      return cloneSession(session);
+    },
+    updateStatus(id, status) {
+      return updateSessionStatus(id, status);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    clear() {
+      sessions.clear();
+      listeners.clear();
+    }
+  };
+  return store;
+}
+var annotationSessionStore = createAnnotationSessionStore();
+function normalizeStatuses(status) {
+  if (!status) return null;
+  return new Set(Array.isArray(status) ? status : [status]);
+}
+function normalizeTimeoutMs(value) {
+  if (value === void 0) return null;
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.floor(value));
+}
+function isPendingLikeStatus(status) {
+  return status === "pending" || status === "acknowledged";
+}
+function hasAgentReply(session) {
+  return session.messages.some((message) => message.role === "agent" && Boolean(message.text?.trim()));
+}
+function createRandomId() {
+  return `annotation-session-${Math.random().toString(36).slice(2, 10)}`;
+}
+function cloneSession(session) {
+  return cloneValue(session);
+}
+function cloneArray(value) {
+  return cloneValue(value);
+}
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
 // src/server/annotation-dispatch.ts
 var AnnotationDispatchError = class extends Error {
   constructor(message, errorCode) {
@@ -1005,20 +1588,30 @@ var AnnotationDispatchError = class extends Error {
     this.errorCode = errorCode;
   }
 };
-async function dispatchAnnotationsToAi(req, state) {
+async function dispatchAnnotationsToAi(req, state, store = annotationSessionStore) {
   try {
     validateAnnotationDispatchRequest(req, state);
     const batch = normalizeAnnotationBatch(req);
     const prompt = buildAnnotationBatchPrompt(batch);
+    const deliveryMode = normalizeDeliveryMode(req.deliveryMode);
+    const session = store.createSession({
+      instruction: batch.instruction,
+      annotations: toSessionAnnotations(batch.annotations),
+      deliveryMode,
+      ...batch.runtimeContext ? { runtimeContext: batch.runtimeContext } : {},
+      ...batch.cssContextPrompt ? { cssContextPrompt: batch.cssContextPrompt } : {}
+    });
     const representativeTarget = batch.annotations[0]?.targets[0];
-    const runtime = resolvePromptDispatchRuntime(state);
-    return dispatchPromptThroughIde(runtime, {
+    const dispatchResult = deliveryMode === "ide" ? dispatchPromptThroughIde(resolvePromptDispatchRuntime(state), {
       prompt,
       ...representativeTarget?.file ? { filePath: representativeTarget.file } : {},
       ...representativeTarget?.line ? { line: representativeTarget.line } : {},
-      ...representativeTarget?.column ? { column: representativeTarget.column } : {},
-      ...batch.screenshotContext ? { screenshotContext: batch.screenshotContext } : {}
-    });
+      ...representativeTarget?.column ? { column: representativeTarget.column } : {}
+    }) : { success: true };
+    return {
+      ...dispatchResult,
+      session: toSessionSummary(session)
+    };
   } catch (error) {
     return {
       success: false,
@@ -1027,6 +1620,41 @@ async function dispatchAnnotationsToAi(req, state) {
     };
   }
 }
+function normalizeDeliveryMode(input) {
+  return input === "agent" ? "agent" : "ide";
+}
+function toSessionAnnotations(annotations) {
+  return annotations.map((annotation) => ({
+    id: `annotation-${annotation.index}`,
+    note: annotation.note,
+    intent: annotation.intent,
+    targets: annotation.targets.map((target, targetIndex) => ({
+      id: `annotation-${annotation.index}-target-${targetIndex + 1}`,
+      label: target.label ?? "Unknown target",
+      location: {
+        file: target.file,
+        line: target.line,
+        column: target.column
+      },
+      ...target.selector ? { selector: target.selector } : {},
+      ...target.snippet ? { snippet: target.snippet } : {},
+      rect: {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      }
+    }))
+  }));
+}
+function toSessionSummary(session) {
+  return {
+    id: session.id,
+    status: session.status,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt
+  };
+}
 function validateAnnotationDispatchRequest(req, state) {
   if (!req.annotations.length) {
     throw new AnnotationDispatchError("At least one annotation is required.", "INVALID_REQUEST");
@@ -1047,9 +1675,7 @@ function validateAnnotationDispatchRequest(req, state) {
 function normalizeAnnotationBatch(req) {
   return {
     instruction: req.instruction?.trim() ?? "",
-    responseMode: req.responseMode ?? "unified",
     ...req.runtimeContext ? { runtimeContext: req.runtimeContext } : {},
-    ...req.screenshotContext ? { screenshotContext: req.screenshotContext } : {},
     ...req.cssContextPrompt?.trim() ? { cssContextPrompt: req.cssContextPrompt.trim() } : {},
     annotations: req.annotations.map((annotation, index) => ({
       index: index + 1,
@@ -1071,12 +1697,9 @@ function buildAnnotationBatchPrompt(batch) {
   const prompt = batch.instruction ? `${batch.instruction}
 
 ${body}` : body;
-  return appendScreenshotContextSection(
-    appendCssContextSection(
-      appendRuntimeContextSection(prompt, batch.runtimeContext),
-      batch.cssContextPrompt
-    ),
-    batch.screenshotContext
+  return appendCssContextSection(
+    appendRuntimeContextSection(prompt, batch.runtimeContext),
+    batch.cssContextPrompt
   );
 }
 function appendCssContextSection(prompt, cssContextPrompt) {
@@ -1103,20 +1726,6 @@ function buildSelectedElementsPrompt(annotations) {
   }
   return lines.join("\n");
 }
-function appendScreenshotContextSection(prompt, screenshotContext) {
-  if (!screenshotContext || !screenshotContext.imageDataUrl && !screenshotContext.imageAssetId) {
-    return prompt;
-  }
-  const lines = [
-    "Visual screenshot context attached:",
-    `- capturedAt=${screenshotContext.capturedAt}`,
-    `- mimeType=${screenshotContext.mimeType}`,
-    ...screenshotContext.imageAssetId ? [`- imageAssetId=${screenshotContext.imageAssetId}`] : []
-  ];
-  return `${prompt}
-
-${lines.join("\n")}`;
-}
 function appendRuntimeContextSection(prompt, runtimeContext) {
   if (!runtimeContext?.records.length) {
     return prompt;
@@ -1164,7 +1773,7 @@ async function buildClientConfig(serverState2) {
     ...info,
     prompts: resolveIntents(promptsConfig),
     hotKeys: userConfig["inspector.hotKey"] ?? "alt",
-    theme: userConfig["inspector.theme"] ?? "auto",
+    annotateDeliveryMode: userConfig["annotate.deliveryMode"] ?? "both",
     includeSnippet: userConfig["prompt.includeSnippet"] ?? false,
     runtimeContext: {
       enabled: true,
@@ -1172,10 +1781,6 @@ async function buildClientConfig(serverState2) {
       maxRuntimeErrors: 3,
       maxFailedRequests: 2
     },
-    screenshotContext: {
-      enabled: false
-    },
-    annotationResponseMode: userConfig["prompt.annotationResponseMode"] ?? "unified",
     autoSend: userConfig["prompt.autoSend"] ?? false
   };
 }
@@ -1220,7 +1825,7 @@ function handleOpenFileRequest(body, serverState2) {
   else if (rawEditorHint === "vscodium") editorHint = "codium";
   else if (rawEditorHint === "trae-cn" || rawEditorHint === "trae") editorHint = "trae";
   serverLogger2.debug(
-    `IDE_OPEN: activeIde=${activeIde}, activeIdeScheme=${activeIdeScheme}, configuredIde=${configuredIde} -> rawEditorHint=${rawEditorHint}, finalEditorHint=${editorHint}`
+    `SOURCE_OPEN: activeIde=${activeIde}, activeIdeScheme=${activeIdeScheme}, configuredIde=${configuredIde} -> rawEditorHint=${rawEditorHint}, finalEditorHint=${editorHint}`
   );
   if (VSCODE_FAMILY_SCHEMES.includes(rawEditorHint)) {
     let normalizedPath = absolutePath.replace(/\\/g, "/");
@@ -1229,7 +1834,7 @@ function handleOpenFileRequest(body, serverState2) {
     }
     const encodedPath = encodeURI(normalizedPath);
     const uri = `${rawEditorHint}://file${encodedPath}:${body.line}:${body.column}`;
-    serverLogger2.debug(`IDE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
+    serverLogger2.debug(`SOURCE_OPEN: Bypassing launchIDE, using URI scheme directly: ${uri}`);
     try {
       if (process.platform === "darwin") {
         (0, import_node_child_process2.execFileSync)("open", [uri]);
@@ -1239,7 +1844,7 @@ function handleOpenFileRequest(body, serverState2) {
         (0, import_node_child_process2.execFileSync)("xdg-open", [uri]);
       }
     } catch (e) {
-      serverLogger2.error(`Failed to launch URI for IDE_OPEN (${uri}):`, e);
+      serverLogger2.error(`Failed to launch URI for SOURCE_OPEN (${uri}):`, e);
       (0, import_launch_ide2.launchIDE)({
         file: absolutePath,
         line: body.line,
@@ -1296,6 +1901,7 @@ function resolveProjectRoot() {
 
 // src/server/index.ts
 var serverLogger4 = createLogger("inspecto:server", { logLevel: getGlobalLogLevel() });
+var PORT_FILE_NAME = "inspecto.port.json";
 var serverState = {
   port: null,
   running: false,
@@ -1304,6 +1910,42 @@ var serverState = {
   cwd: process.cwd()
 };
 var serverInstance = null;
+function getPortFilePath() {
+  return import_node_path7.default.join(import_node_os2.default.tmpdir(), PORT_FILE_NAME);
+}
+function getProjectRootHash() {
+  if (!serverState.projectRoot) return null;
+  return import_node_crypto2.default.createHash("md5").update(serverState.projectRoot).digest("hex");
+}
+function readPortData(portFile) {
+  if (!import_node_fs4.default.existsSync(portFile)) return {};
+  try {
+    return JSON.parse(import_node_fs4.default.readFileSync(portFile, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeProjectPort(port) {
+  const rootHash = getProjectRootHash();
+  if (!rootHash) return;
+  const portFile = getPortFilePath();
+  const portData = readPortData(portFile);
+  portData[rootHash] = port;
+  import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+}
+function removeProjectPort() {
+  const rootHash = getProjectRootHash();
+  if (!rootHash) return;
+  const portFile = getPortFilePath();
+  if (!import_node_fs4.default.existsSync(portFile)) return;
+  const portData = readPortData(portFile);
+  delete portData[rootHash];
+  if (Object.keys(portData).length === 0) {
+    import_node_fs4.default.unlinkSync(portFile);
+  } else {
+    import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
+  }
+}
 async function startServer() {
   if (serverState.running && serverState.port !== null) {
     return serverState.port;
@@ -1337,7 +1979,7 @@ async function startServer() {
     });
   });
   await new Promise((resolve2, reject) => {
-    serverInstance.listen(port, "127.0.0.1", () => {
+    serverInstance.listen(port, "0.0.0.0", () => {
       serverInstance.unref();
       resolve2();
     });
@@ -1348,37 +1990,18 @@ async function startServer() {
   });
   serverState.port = port;
   serverState.running = true;
-  const portFile = import_node_path7.default.join(import_node_os2.default.tmpdir(), "inspecto.port.json");
   try {
-    let portData = {};
-    if (import_node_fs4.default.existsSync(portFile)) {
-      try {
-        portData = JSON.parse(import_node_fs4.default.readFileSync(portFile, "utf-8"));
-      } catch (e) {
-      }
-    }
-    const rootHash = import_node_crypto2.default.createHash("md5").update(serverState.projectRoot).digest("hex");
-    portData[rootHash] = port;
-    import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
-  } catch (e) {
-    serverLogger4.warn("Failed to write port file:", e);
+    writeProjectPort(port);
+  } catch (_e) {
+    serverLogger4.warn("Failed to write port file:", _e);
   }
   process.once("exit", () => {
     try {
-      if (import_node_fs4.default.existsSync(portFile)) {
-        const portData = JSON.parse(import_node_fs4.default.readFileSync(portFile, "utf-8"));
-        const rootHash = import_node_crypto2.default.createHash("md5").update(serverState.projectRoot).digest("hex");
-        delete portData[rootHash];
-        if (Object.keys(portData).length === 0) {
-          import_node_fs4.default.unlinkSync(portFile);
-        } else {
-          import_node_fs4.default.writeFileSync(portFile, JSON.stringify(portData, null, 2), "utf-8");
-        }
-      }
+      removeProjectPort();
     } catch {
     }
   });
-  serverLogger4.info(`server running at http://127.0.0.1:${port}`);
+  serverLogger4.info(`server running at http://0.0.0.0:${port}`);
   return port;
 }
 async function readBody(req) {
@@ -1430,11 +2053,11 @@ async function handleRequest(url, req, res) {
     }
     return;
   }
-  if (pathname === import_types2.INSPECTO_API_PATHS.IDE_OPEN && req.method === "POST") {
+  if ((pathname === import_types2.INSPECTO_API_PATHS.SOURCE_OPEN || pathname === import_types2.INSPECTO_API_PATHS.IDE_OPEN) && req.method === "POST") {
     let body;
     try {
       body = JSON.parse(await readBody(req));
-    } catch (e) {
+    } catch (_e) {
       res.writeHead(400, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Invalid JSON body" }));
       return;
@@ -1443,7 +2066,7 @@ async function handleRequest(url, req, res) {
       handleOpenFileRequest(body, serverState);
     } catch (err) {
       serverLogger4.warn(
-        `Security: Blocked path traversal attempt in IDE_OPEN: ${body.file}. Reason: ${err.message}`
+        `Security: Blocked path traversal attempt in SOURCE_OPEN: ${body.file}. Reason: ${err.message}`
       );
       res.writeHead(403, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Access denied: File is outside of project workspace" }));
@@ -1517,6 +2140,212 @@ async function handleRequest(url, req, res) {
     }
     return;
   }
+  if (pathname === import_types2.INSPECTO_API_PATHS.SESSION_CLAIM_NEXT && req.method === "POST") {
+    try {
+      const rawBody = await readBody(req);
+      const body = rawBody ? JSON.parse(rawBody) : {};
+      const timeoutMs = normalizeSessionClaimTimeout(
+        body.timeoutMs === void 0 ? null : String(body.timeoutMs)
+      );
+      const result = await annotationSessionStore.claimNextSession({
+        ...timeoutMs !== void 0 ? { timeoutMs } : {}
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          success: true,
+          timedOut: result.timedOut,
+          matchedExisting: result.matchedExisting,
+          ...result.event ? { event: result.event } : {},
+          ...result.session ? { session: result.session } : {}
+        })
+      );
+    } catch (e) {
+      serverLogger4.error(`Error parsing session claim request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname === import_types2.INSPECTO_API_PATHS.SESSION_EVENTS && req.method === "GET") {
+    const statusParam = url.searchParams.getAll("status");
+    const statuses = statusParam.length ? new Set(statusParam) : null;
+    const sessionId = url.searchParams.get("sessionId")?.trim() || null;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    res.write(`event: ready
+data: ${JSON.stringify({ ok: true })}
+
+`);
+    const unsubscribe = annotationSessionStore.subscribe((event) => {
+      if (sessionId && event.session.id !== sessionId) {
+        return;
+      }
+      if (statuses && !statuses.has(event.session.status)) {
+        return;
+      }
+      res.write(formatSessionSseEvent(event));
+    });
+    req.on("close", () => {
+      unsubscribe();
+      res.end();
+    });
+    return;
+  }
+  if (pathname === import_types2.INSPECTO_API_PATHS.SESSIONS && req.method === "GET") {
+    const statusParam = url.searchParams.getAll("status");
+    const sessions = annotationSessionStore.listSessions(
+      statusParam.length ? {
+        status: statusParam
+      } : void 0
+    );
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true, sessions }));
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && req.method === "GET") {
+    const sessionId = pathname.substring(import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1);
+    const session = annotationSessionStore.getSession(sessionId);
+    if (!session) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Session not found" }));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: true, session }));
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && pathname.endsWith(import_types2.INSPECTO_API_PATHS.SESSION_REPLY_SUFFIX) && req.method === "POST") {
+    const sessionId = pathname.slice(
+      import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1,
+      -import_types2.INSPECTO_API_PATHS.SESSION_REPLY_SUFFIX.length
+    );
+    try {
+      const rawBody = await readBody(req);
+      const body = JSON.parse(rawBody);
+      if (!isAnnotationThreadRole(body.role)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Reply role is invalid." }));
+        return;
+      }
+      if (!body.text?.trim()) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Reply text is required." }));
+        return;
+      }
+      const session = annotationSessionStore.appendMessage(sessionId, {
+        role: body.role,
+        text: body.text.trim()
+      });
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, session }));
+    } catch (e) {
+      serverLogger4.error(`Error parsing session reply request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && pathname.endsWith(import_types2.INSPECTO_API_PATHS.SESSION_RESOLVE_SUFFIX) && req.method === "POST") {
+    const sessionId = pathname.slice(
+      import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1,
+      -import_types2.INSPECTO_API_PATHS.SESSION_RESOLVE_SUFFIX.length
+    );
+    try {
+      const rawBody = await readBody(req);
+      const body = rawBody ? JSON.parse(rawBody) : {};
+      const message = body.message?.trim();
+      const existingSession = annotationSessionStore.getSession(sessionId);
+      if (!existingSession) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      if (!message && !hasAgentReply(existingSession)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            success: false,
+            error: "Resolve message is required until an agent reply is recorded."
+          })
+        );
+        return;
+      }
+      if (message) {
+        const repliedSession = annotationSessionStore.appendMessage(sessionId, {
+          role: "agent",
+          text: message
+        });
+        if (!repliedSession) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: false, error: "Session not found" }));
+          return;
+        }
+      }
+      const session = annotationSessionStore.updateStatus(sessionId, "resolved");
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, session }));
+    } catch (e) {
+      serverLogger4.error(`Error parsing session resolve request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
+  if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.SESSIONS}/`) && pathname.endsWith(import_types2.INSPECTO_API_PATHS.SESSION_DISMISS_SUFFIX) && req.method === "POST") {
+    const sessionId = pathname.slice(
+      import_types2.INSPECTO_API_PATHS.SESSIONS.length + 1,
+      -import_types2.INSPECTO_API_PATHS.SESSION_DISMISS_SUFFIX.length
+    );
+    try {
+      const rawBody = await readBody(req);
+      const body = rawBody ? JSON.parse(rawBody) : {};
+      const message = body.message?.trim();
+      const existingSession = annotationSessionStore.getSession(sessionId);
+      if (!existingSession) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      if (message) {
+        const repliedSession = annotationSessionStore.appendMessage(sessionId, {
+          role: "agent",
+          text: message
+        });
+        if (!repliedSession) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: false, error: "Session not found" }));
+          return;
+        }
+      }
+      const session = annotationSessionStore.updateStatus(sessionId, "dismissed");
+      if (!session) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ success: false, error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: true, session }));
+    } catch (e) {
+      serverLogger4.error(`Error parsing session dismiss request:`, e);
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ success: false, error: "Invalid JSON body" }));
+    }
+    return;
+  }
   if (pathname.startsWith(`${import_types2.INSPECTO_API_PATHS.AI_TICKET}/`) && req.method === "GET") {
     const ticketId = pathname.substring(import_types2.INSPECTO_API_PATHS.AI_TICKET.length + 1);
     const payloadStr = readTicket(ticketId);
@@ -1533,7 +2362,7 @@ async function handleRequest(url, req, res) {
   res.end(JSON.stringify({ error: "not found" }));
 }
 async function dispatchToAi(req) {
-  const { location, snippet, prompt, screenshotContext } = req;
+  const { location, snippet, prompt } = req;
   const formattedPrompt = prompt ?? `Please help me with this code from \`${location.file}\` (line ${location.line}):
 
 \`\`\`
@@ -1546,8 +2375,7 @@ ${snippet}
     filePath: location.file,
     line: location.line,
     column: location.column,
-    snippet,
-    ...screenshotContext ? { screenshotContext } : {}
+    snippet
   });
 }
 function getBatchDispatchStatusCode(errorCode, success) {
@@ -1556,6 +2384,21 @@ function getBatchDispatchStatusCode(errorCode, success) {
   if (errorCode === "FORBIDDEN_PATH") return 403;
   return 500;
 }
+function isAnnotationThreadRole(value) {
+  return value === "user" || value === "agent" || value === "system";
+}
+function formatSessionSseEvent(event) {
+  return `event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+}
+function normalizeSessionClaimTimeout(value) {
+  if (!value?.trim()) return 3e4;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) return 3e4;
+  return Math.max(0, Math.min(parsed, 3e5));
+}
 
 // src/injectors/utils.ts
 var import_node_module = require("module");
@@ -1578,13 +2421,13 @@ var resolveClientModule = () => {
 function getWebpackHtmlScript(serverPort) {
   return `
 window.__AI_INSPECTOR_PORT__ = ${serverPort};
-window.addEventListener('load', () => {
-  if (window.InspectoClient) {
-    window.InspectoClient.mountInspector({
-      serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
-    });
-  }
-});
+  window.addEventListener('load', () => {
+    if (window.InspectoClient) {
+      window.InspectoClient.mountInspector({
+        serverUrl: 'http://0.0.0.0:' + window.__AI_INSPECTOR_PORT__,
+      });
+    }
+  });
 `;
 }
 function getWebpackAssetScript(serverPort) {
@@ -1594,7 +2437,7 @@ if (typeof window !== 'undefined') {
   const _initInspecto = () => {
     if (window.InspectoClient) {
       window.InspectoClient.mountInspector({
-        serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+        serverUrl: 'http://0.0.0.0:' + window.__AI_INSPECTOR_PORT__,
       });
     } else {
       setTimeout(_initInspecto, 100);
@@ -1617,7 +2460,7 @@ function injectWebpack(compiler, serverPortFn, resolveClientModule2) {
   }
   compiler.hooks.compilation.tap("inspecto-overlay", (compilation) => {
     const HtmlWebpackPlugin = compiler.options.plugins.find(
-      (p) => p && p.constructor && p.constructor.name === "HtmlWebpackPlugin"
+      (p2) => p2 && p2.constructor && p2.constructor.name === "HtmlWebpackPlugin"
     );
     if (HtmlWebpackPlugin) {
       const hooks = HtmlWebpackPlugin.constructor.getHooks(compilation);
@@ -1661,7 +2504,7 @@ function injectRspack(compiler, serverPortFn, resolveClientModule2) {
   new compiler.webpack.EntryPlugin(compiler.context, inspectoClientPath, {}).apply(compiler);
   compiler.hooks.compilation.tap("inspecto-overlay", (compilation) => {
     const HtmlRspackPlugin = compiler.options.plugins.find(
-      (p) => p && p.constructor && p.constructor.name === "HtmlRspackPlugin"
+      (p2) => p2 && p2.constructor && p2.constructor.name === "HtmlRspackPlugin"
     );
     if (HtmlRspackPlugin) {
       const hooks = HtmlRspackPlugin.constructor.getHooks(compilation);
@@ -1685,7 +2528,7 @@ function getViteVirtualModuleScript(serverPort) {
 import { mountInspector } from '@inspecto-dev/core';
 window.__AI_INSPECTOR_PORT__ = ${serverPort};
 mountInspector({
-  serverUrl: 'http://127.0.0.1:' + window.__AI_INSPECTOR_PORT__,
+  serverUrl: 'http://0.0.0.0:' + window.__AI_INSPECTOR_PORT__,
 });
 `;
 }
@@ -1819,7 +2662,9 @@ var src_default = InspectoPlugin;
   esbuildPlugin,
   rollupPlugin,
   rspackPlugin,
+  transformAstro,
   transformJsx,
+  transformRouter,
   unplugin,
   vitePlugin,
   webpackPlugin