@wrongstack/webui-server 0.307.1 → 0.308.1

package/dist/server/entry.js

@@ -7290,11 +7290,11 @@ async function handleGitDiff(ws, projectRoot, path34) {
   try {
     const git = makeGit(cwd);
     const { readFile: readFile11 } = await import("node:fs/promises");
-    const { join: join15 } = await import("node:path");
+    const { join: join16 } = await import("node:path");
     const oldText = await git(["show", `HEAD:${path34}`]);
     let newText = "";
     try {
-      const abs = cwd ? join15(cwd, path34) : path34;
+      const abs = cwd ? join16(cwd, path34) : path34;
       const buf = await readFile11(abs);
       if (buf.includes(0)) {
         reply2({ oldText: "", newText: "", binary: true });
@@ -8889,7 +8889,7 @@ function verifyClient(input) {
 
 // src/server/http-server/api-router.ts
 import * as v8 from "node:v8";
-import { sanitizeApiError as sanitizeApiError2 } from "@wrongstack/core/security";
+import { sanitizeApiError as sanitizeApiError3 } from "@wrongstack/core/security";
 import { getIndexState as getIndexState2 } from "@wrongstack/tools";
 
 // src/server/codemap-handlers.ts
@@ -10316,6 +10316,297 @@ function strictDecodeParam(segment, res) {
   }
 }
 
+// src/server/http-server/vector-memory-handlers.ts
+import { getSageSurface } from "@wrongstack/sage";
+import { sanitizeApiError as sanitizeApiError2 } from "@wrongstack/core/security";
+function snapshotVectorMemory(store, opts = {}) {
+  const stats = store.stats();
+  return {
+    storePath: opts.projectRoot,
+    modelCacheDir: opts.modelCacheDir,
+    stats
+  };
+}
+function snapshotVectorMemoryCache(store) {
+  return store.cacheStats();
+}
+async function handleVectorMemoryStatus(res, getStore, opts = {}) {
+  const store = getStore();
+  if (!store) {
+    const body = { enabled: false };
+    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(body));
+    return;
+  }
+  try {
+    const snap = snapshotVectorMemory(store, opts);
+    const body = {
+      enabled: true,
+      storePath: snap.storePath,
+      modelCacheDir: snap.modelCacheDir,
+      providerId: snap.stats.modelId,
+      modelId: snap.stats.modelId,
+      dimensions: snap.stats.dimensions,
+      entries: snap.stats.entries,
+      vectors: snap.stats.vectors,
+      providers: snap.stats.providers,
+      cache: snapshotVectorMemoryCache(store)
+    };
+    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(body));
+  } catch (error2) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Vector memory status failed",
+        detail: sanitizeApiError2(error2)
+      })
+    );
+  }
+}
+function parseSearchParams(url) {
+  const query = url.searchParams.get("q") ?? "";
+  const rawLimit = Number.parseInt(url.searchParams.get("limit") ?? "10", 10);
+  const limit = Math.min(50, Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 10));
+  const rawThreshold = url.searchParams.get("threshold");
+  const threshold = rawThreshold !== null && rawThreshold !== "" ? Math.max(0, Math.min(1, Number.parseFloat(rawThreshold))) : void 0;
+  const similarity = url.searchParams.get("similarity") === "1";
+  return { query, limit, threshold: Number.isFinite(threshold) ? threshold : void 0, similarity };
+}
+function cosineMatrix(vectors) {
+  const n = vectors.length;
+  const out = new Array(n);
+  for (let i = 0; i < n; i++) {
+    out[i] = new Array(n).fill(0);
+  }
+  for (let i = 0; i < n; i++) {
+    out[i][i] = 1;
+    for (let j = i + 1; j < n; j++) {
+      const a = vectors[i];
+      const b = vectors[j];
+      let dot = 0;
+      const len = Math.min(a.length, b.length);
+      for (let k = 0; k < len; k++) dot += (a[k] ?? 0) * (b[k] ?? 0);
+      const score = Math.max(0, Math.min(1, dot));
+      out[i][j] = score;
+      out[j][i] = score;
+    }
+  }
+  return out;
+}
+async function handleVectorMemorySearch(res, url, getStore) {
+  const store = getStore();
+  if (!store) {
+    res.writeHead(503, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Vector memory not enabled in this host" }));
+    return;
+  }
+  const { query, limit, threshold, similarity } = parseSearchParams(url);
+  if (query.trim().length === 0) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Missing required query parameter `q`" }));
+    return;
+  }
+  try {
+    const hits = await store.search(query, {
+      limit,
+      ...threshold !== void 0 ? { threshold } : {},
+      includeVectors: similarity
+    });
+    const body = {
+      hits: hits.map((h) => ({
+        id: h.entry.id,
+        score: h.score,
+        text: h.entry.text,
+        ...h.entry.summary ? { summary: h.entry.summary } : {},
+        tags: h.entry.tags
+      })),
+      count: hits.length
+    };
+    if (similarity && hits.length > 1) {
+      const vecs = hits.map((h) => h.vector).filter((v) => v !== void 0);
+      if (vecs.length === hits.length) {
+        body.similarity = cosineMatrix(vecs);
+      }
+    }
+    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(body));
+  } catch (error2) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Vector memory search failed",
+        detail: sanitizeApiError2(error2)
+      })
+    );
+  }
+}
+function parseStoreBody(req) {
+  return new Promise((resolve19) => {
+    let raw = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      raw += chunk;
+      if (raw.length > 64 * 1024) {
+        req.destroy();
+        resolve19(null);
+      }
+    });
+    req.on("end", () => {
+      try {
+        resolve19(raw ? JSON.parse(raw) : {});
+      } catch {
+        resolve19(null);
+      }
+    });
+    req.on("error", () => resolve19(null));
+  });
+}
+async function handleVectorMemoryStore(res, req, getStore) {
+  const store = getStore();
+  if (!store) {
+    res.writeHead(503, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Vector memory not enabled in this host" }));
+    return;
+  }
+  const body = await parseStoreBody(req);
+  if (!body) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Malformed JSON body" }));
+    return;
+  }
+  const text = typeof body.text === "string" ? body.text.trim() : "";
+  if (text.length === 0) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Missing required field `text`" }));
+    return;
+  }
+  const tags = Array.isArray(body.tags) ? body.tags.filter((t) => typeof t === "string") : [];
+  try {
+    const entry = await store.remember({ text, tags });
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        id: entry.id,
+        hasVector: entry.vector !== void 0,
+        dimensions: entry.dimensions
+      })
+    );
+  } catch (error2) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Vector memory store failed",
+        detail: sanitizeApiError2(error2)
+      })
+    );
+  }
+}
+async function handleVectorMemoryForget(res, url, getStore) {
+  const store = getStore();
+  if (!store) {
+    res.writeHead(503, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Vector memory not enabled in this host" }));
+    return;
+  }
+  const match = /^\/api\/vector-memory\/store\/([^/]+)$/.exec(url.pathname);
+  const id = match ? strictDecodeParam(decodeSessionId(match[1]), res) : null;
+  if (id === null) return;
+  try {
+    const removed = await store.forget(id);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ removed }));
+  } catch (error2) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Vector memory forget failed",
+        detail: sanitizeApiError2(error2)
+      })
+    );
+  }
+}
+function parseMemorySearchParams(url) {
+  const query = url.searchParams.get("q") ?? "";
+  const rawLimit = Number.parseInt(url.searchParams.get("limit") ?? "20", 10);
+  const limit = Math.min(50, Math.max(1, Number.isFinite(rawLimit) ? rawLimit : 20));
+  const explain = url.searchParams.get("explain") === "1";
+  return { query, limit, explain };
+}
+async function handleMemorySearch(res, url, getStore) {
+  const store = getStore();
+  if (!store) {
+    res.writeHead(503, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Memory store not enabled in this host" }));
+    return;
+  }
+  const { query, limit, explain } = parseMemorySearchParams(url);
+  if (query.trim().length === 0) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Missing required query parameter `q`" }));
+    return;
+  }
+  const Sage = getSageSurface(store);
+  if (!Sage) {
+    res.writeHead(503, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Memory search requires the SAGE surface (this host does not expose it)."
+      })
+    );
+    return;
+  }
+  try {
+    let payload;
+    if (explain && typeof Sage.searchSageWithBreakdown === "function") {
+      const hits = await Sage.searchSageWithBreakdown(query, { limit });
+      payload = {
+        count: hits.length,
+        channel: "breakdown",
+        hits: hits.map((h) => ({
+          id: h.memory.id,
+          text: h.memory.text,
+          kind: h.memory.kind,
+          status: h.memory.status,
+          tags: h.memory.tags ?? [],
+          lexicalScore: h.lexicalScore,
+          vectorScore: h.vectorScore,
+          finalScore: h.finalScore,
+          source: h.source
+        }))
+      };
+    } else {
+      const rows = await Sage.searchSage(query, { limit });
+      const total = rows.length;
+      payload = {
+        count: total,
+        channel: "lexical",
+        hits: rows.map((memory, index) => ({
+          id: memory.id,
+          text: memory.text,
+          kind: memory.kind,
+          status: memory.status,
+          tags: memory.tags ?? [],
+          lexicalScore: total <= 1 ? 1 : 1 - index / Math.max(1, total - 1),
+          vectorScore: null,
+          finalScore: total <= 1 ? 1 : 1 - index / Math.max(1, total - 1),
+          source: "lexical"
+        }))
+      };
+    }
+    res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+    res.end(JSON.stringify(payload));
+  } catch (error2) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Memory search failed",
+        detail: sanitizeApiError2(error2)
+      })
+    );
+  }
+}
+
 // src/server/http-server/api-router.ts
 async function handleApiRoutes(req, res, url, deps2, requireAccessToken, accessTokenOk, getTechStackRuntime) {
   if (url.pathname === "/api/fleet/ping" && req.method === "POST") {
@@ -10654,7 +10945,7 @@ async function handleApiRoutes(req, res, url, deps2, requireAccessToken, accessT
       res.end(
         JSON.stringify({
           error: "TechStack store unavailable",
-          detail: sanitizeApiError2(error2)
+          detail: sanitizeApiError3(error2)
         })
       );
       return true;
@@ -10717,6 +11008,63 @@ async function handleApiRoutes(req, res, url, deps2, requireAccessToken, accessT
     );
     return true;
   }
+  const vectorForgetMatch = /^\/api\/vector-memory\/store\/([^/]+)$/.exec(url.pathname);
+  if (vectorForgetMatch && req.method === "DELETE") {
+    if (requireAccessToken && !accessTokenOk) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unauthorized" }));
+      return true;
+    }
+    await handleVectorMemoryForget(
+      res,
+      url,
+      () => deps2.getVectorMemoryStore?.()
+    );
+    return true;
+  }
+  if (url.pathname === "/api/vector-memory/status" && req.method === "GET") {
+    if (requireAccessToken && !accessTokenOk) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unauthorized" }));
+      return true;
+    }
+    await handleVectorMemoryStatus(
+      res,
+      () => deps2.getVectorMemoryStore?.(),
+      {
+        ...deps2.projectRoot ? { projectRoot: deps2.projectRoot } : {},
+        ...deps2.vectorMemoryModelCacheDir ? { modelCacheDir: deps2.vectorMemoryModelCacheDir } : {}
+      }
+    );
+    return true;
+  }
+  if (url.pathname === "/api/vector-memory/search" && req.method === "GET") {
+    if (requireAccessToken && !accessTokenOk) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unauthorized" }));
+      return true;
+    }
+    await handleVectorMemorySearch(res, url, () => deps2.getVectorMemoryStore?.());
+    return true;
+  }
+  if (url.pathname === "/api/vector-memory/store" && req.method === "POST") {
+    if (requireAccessToken && !accessTokenOk) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unauthorized" }));
+      return true;
+    }
+    await handleVectorMemoryStore(res, req, () => deps2.getVectorMemoryStore?.());
+    return true;
+  }
+  if (url.pathname === "/api/memory/search" && req.method === "GET") {
+    if (requireAccessToken && !accessTokenOk) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unauthorized" }));
+      return true;
+    }
+    await handleMemorySearch(res, url, () => deps2.getMemoryStore?.());
+    return true;
+  }
   if (url.pathname === "/api/deadcode/action-plan" && req.method === "POST") {
     await handleDeadCodeActionPlan(
       res,
@@ -10881,12 +11229,15 @@ function createHttpServer(opts) {
         distDir,
         url,
         opts,
-        port,
+        // Live port from the socket: the bind may have advanced past an
+        // EADDRINUSE (listenWithRetry) after this server was constructed,
+        // and the CSP must advertise the port actually serving this request.
+        res.socket?.localPort ?? port,
         shouldSetAuthCookie
       );
     } catch (err) {
       if (err.code === "ENOENT") {
-        await handleSpaFallback(res, distDir, opts, port);
+        await handleSpaFallback(res, distDir, opts, res.socket?.localPort ?? port);
       } else {
         console.error({ url: req.url, err });
         res.writeHead(500);
@@ -13671,13 +14022,13 @@ async function handleMcpRoute(ws, msg, handlers) {
 }
 
 // src/server/memory-handlers.ts
-import { getSageSurface } from "@wrongstack/sage";
+import { getSageSurface as getSageSurface2 } from "@wrongstack/sage";
 function requiresSage(command) {
   return `\`${command}\` requires the SAGE backend (Sage.enabled).`;
 }
 async function handleMemoryList(ws, memoryStore) {
   try {
-    const Sage = getSageSurface(memoryStore);
+    const Sage = getSageSurface2(memoryStore);
     if (Sage) {
       const [stats, memories] = await Promise.all([Sage.stats(), Sage.listSage()]);
       const text2 = memories.length === 0 ? "\u{1F9E0} SAGE is empty." : formatSageText(stats, memories);
@@ -13712,7 +14063,7 @@ function formatSageText(stats, memories) {
   return lines.join("\n");
 }
 async function handleSageList(ws, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.list",
@@ -13728,7 +14079,7 @@ async function handleSageList(ws, memoryStore) {
   }
 }
 async function handleSageListPage(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.listPage",
@@ -13778,8 +14129,50 @@ async function handleSageListPage(ws, msg, memoryStore) {
     send(ws, { type: "memory.sage.listPage", payload: { error: errMessage(err) } });
   }
 }
+async function handleSageSearchBreakdown(ws, msg, memoryStore) {
+  const Sage = getSageSurface2(memoryStore);
+  if (!Sage) {
+    send(ws, {
+      type: "memory.sage.searchBreakdown",
+      payload: { error: requiresSage("memory.sage.searchBreakdown") }
+    });
+    return;
+  }
+  try {
+    const payload = msg.payload ?? {};
+    const query = typeof payload["query"] === "string" ? payload["query"] : "";
+    if (query.trim().length === 0) {
+      send(ws, {
+        type: "memory.sage.searchBreakdown",
+        payload: { error: "Missing required field `query`" }
+      });
+      return;
+    }
+    const limit = typeof payload["limit"] === "number" ? payload["limit"] : 20;
+    const includeStale = payload["includeStale"] === true;
+    const includeStatuses = includeStale ? ["active", "stale"] : ["active"];
+    const options = { limit, includeStatuses };
+    if (typeof Sage.searchSageWithBreakdown === "function") {
+      const hits2 = await Sage.searchSageWithBreakdown(query, options);
+      send(ws, { type: "memory.sage.searchBreakdown", payload: { hits: hits2, source: "breakdown" } });
+      return;
+    }
+    const rows = await Sage.searchSage(query, options);
+    const total = rows.length;
+    const hits = rows.map((memory, index) => ({
+      memory,
+      vectorScore: null,
+      lexicalScore: total <= 1 ? 1 : 1 - index / Math.max(1, total - 1),
+      finalScore: total <= 1 ? 1 : 1 - index / Math.max(1, total - 1),
+      source: "lexical"
+    }));
+    send(ws, { type: "memory.sage.searchBreakdown", payload: { hits, source: "lexical" } });
+  } catch (err) {
+    send(ws, { type: "memory.sage.searchBreakdown", payload: { error: errMessage(err) } });
+  }
+}
 async function handleSageGet(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.get",
@@ -13804,7 +14197,7 @@ async function handleSageGet(ws, msg, memoryStore) {
   }
 }
 async function handleSageGraph(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage?.graphFor) {
     send(ws, {
       type: "memory.sage.graph",
@@ -13838,7 +14231,7 @@ async function handleSageGraph(ws, msg, memoryStore) {
   }
 }
 async function handleSageUpdate(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.update",
@@ -13866,7 +14259,7 @@ async function handleSageUpdate(ws, msg, memoryStore) {
   }
 }
 async function handleSageRemember(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.remember",
@@ -13900,7 +14293,7 @@ async function handleSageRemember(ws, msg, memoryStore) {
   }
 }
 async function handleSageDelete(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.delete",
@@ -13933,7 +14326,7 @@ async function handleSageDelete(ws, msg, memoryStore) {
   }
 }
 async function handleSageRecover(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage?.recoverSage) {
     send(ws, {
       type: "memory.sage.recover",
@@ -13977,7 +14370,7 @@ async function handleSageRecover(ws, msg, memoryStore) {
   }
 }
 async function handleSageListCandidates(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.listCandidates",
@@ -14005,7 +14398,7 @@ async function handleSageListCandidates(ws, msg, memoryStore) {
   }
 }
 async function handleSageCandidateResolve(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage) {
     send(ws, {
       type: "memory.sage.candidateResolve",
@@ -14062,7 +14455,7 @@ async function handleSageCandidateResolve(ws, msg, memoryStore) {
   }
 }
 async function handleSageBackfillRecoverable(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage?.backfillRecoverable) {
     send(ws, {
       type: "memory.sage.backfillRecoverable",
@@ -14102,7 +14495,7 @@ async function handleSageBackfillRecoverable(ws, msg, memoryStore) {
   }
 }
 async function handleSageForFile(ws, msg, memoryStore) {
-  const Sage = getSageSurface(memoryStore);
+  const Sage = getSageSurface2(memoryStore);
   if (!Sage?.findMemoriesForFile) {
     send(ws, {
       type: "memory.sage.forFile",
@@ -14194,6 +14587,9 @@ async function handleMemoryRoute(ctx, ws, message) {
     case "memory.sage.forFile":
       await handleSageForFile(ws, message, store);
       return true;
+    case "memory.sage.searchBreakdown":
+      await handleSageSearchBreakdown(ws, message, store);
+      return true;
     default:
       return false;
   }
@@ -14537,17 +14933,25 @@ function createModelOperations(context) {
 // src/server/port-utils.ts
 import * as net2 from "node:net";
 import { ToolValidationError as ToolValidationError4 } from "@wrongstack/core/types";
+var MAX_TCP_PORT = 65535;
+function isStrictPort() {
+  const value = process.env["WEBUI_STRICT_PORT"];
+  return value === "1" || value === "true";
+}
 function isPortFree(host, port) {
+  return probePort(host, port).then((err) => err === null);
+}
+function probePort(host, port) {
   return new Promise((resolve19) => {
     const srv = net2.createServer();
-    srv.once("error", () => resolve19(false));
+    srv.once("error", (err) => resolve19(err));
     srv.once("listening", () => {
-      srv.close(() => resolve19(true));
+      srv.close(() => resolve19(null));
     });
     try {
       srv.listen(port, host);
-    } catch {
-      resolve19(false);
+    } catch (err) {
+      resolve19(err);
     }
   });
 }
@@ -14556,7 +14960,7 @@ async function findFreePort(host, startPort, opts = {}) {
   const maxTries = opts.maxTries ?? 200;
   let port = startPort;
   for (let i = 0; i < maxTries; i++) {
-    if (port > 65535) port = 1024 + port % 5e4;
+    if (port > MAX_TCP_PORT) port = 1024 + port % 5e4;
     if (!exclude.has(port) && await isPortFree(host, port)) {
       return port;
     }
@@ -14567,6 +14971,50 @@ async function findFreePort(host, startPort, opts = {}) {
     field: "port"
   });
 }
+function listenWithRetry(server, host, port, opts = {}) {
+  const maxTries = opts.maxTries ?? 10;
+  return new Promise((resolve19, reject) => {
+    const canAdvance = (candidate) => candidate < MAX_TCP_PORT;
+    const probeable = (candidate) => Number.isInteger(candidate) && candidate >= 0 && candidate <= MAX_TCP_PORT;
+    const attempt = (candidate, remaining) => {
+      void (async () => {
+        if (probeable(candidate)) {
+          const probeErr = await probePort(host, candidate);
+          if (probeErr !== null) {
+            if (probeErr.code === "EADDRINUSE" && remaining > 1 && canAdvance(candidate)) {
+              attempt(candidate + 1, remaining - 1);
+              return;
+            }
+            reject(probeErr);
+            return;
+          }
+        }
+        const onError = (err) => {
+          server.off("listening", onListening);
+          server.off("error", onError);
+          if (err.code === "EADDRINUSE" && remaining > 1 && canAdvance(candidate)) {
+            attempt(candidate + 1, remaining - 1);
+            return;
+          }
+          reject(err);
+        };
+        const onListening = () => {
+          server.off("error", onError);
+          const address = server.address();
+          resolve19(address && typeof address === "object" ? address.port : candidate);
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        try {
+          server.listen(candidate, host);
+        } catch (err) {
+          onError(err);
+        }
+      })();
+    };
+    attempt(port, maxTries);
+  });
+}
 
 // src/server/intake-service.ts
 import { resolveWstackPaths as resolveWstackPaths5 } from "@wrongstack/core/utils";
@@ -16952,6 +17400,7 @@ var CLIENT_KNOWLEDGE_MESSAGE_TYPES = [
   "memory.sage.listPage",
   "memory.sage.recover",
   "memory.sage.remember",
+  "memory.sage.searchBreakdown",
   "memory.sage.update"
 ];
 var CLIENT_EXTENSION_MESSAGE_TYPES = [
@@ -17239,6 +17688,7 @@ var SERVER_KNOWLEDGE_MESSAGE_TYPES = [
   "memory.sage.listPage",
   "memory.sage.recover",
   "memory.sage.remember",
+  "memory.sage.searchBreakdown",
   "memory.sage.update"
 ];
 var SERVER_EXTENSION_MESSAGE_TYPES = [
@@ -17925,7 +18375,12 @@ function createSessionHandlers(ctx) {
       sessionScopedPath(sessionsDirectory(), next.id, ".tasks.json")
     );
     ctx.tokenCounter.reset?.();
-    if (usage) ctx.tokenCounter.account(usage, currentConfig().model, ctx.context.provider.id);
+    if (usage) {
+      ctx.tokenCounter.account(usage, currentConfig().model, ctx.context.provider.id);
+      if (typeof usage.input === "number" && usage.input > 0) {
+        ctx.context.lastRequestTokens = usage.input;
+      }
+    }
     ctx.setSessionStartedAt?.(Date.now());
     await ctx.onSessionSwapped?.(next.id);
   };
@@ -17958,6 +18413,10 @@ function createSessionHandlers(ctx) {
           return;
         }
       } else {
+        try {
+          ctx.abortActiveRun?.(clearedSessionId);
+        } catch {
+        }
         ctx.context.state.replaceMessages([]);
         ctx.context.state.replaceTodos([]);
         resetContextAccounting();
@@ -22081,6 +22540,11 @@ import {
   wstackGlobalRoot as wstackGlobalRoot2
 } from "@wrongstack/core/utils";
 import { ensureSessionShell } from "@wrongstack/tools";
+import {
+  TransformersEmbeddingProvider,
+  VectorMemoryStore,
+  startFirstBootSageSync
+} from "@wrongstack/vector-memory";
 
 // src/server/backend-services.ts
 import { join as join12 } from "node:path";
@@ -25033,7 +25497,7 @@ async function resolvePorts(opts) {
   const publicUrl = opts.publicUrl ?? process.env["WEBUI_PUBLIC_URL"];
   const publicWsUrl = opts.publicWsUrl ?? process.env["WEBUI_PUBLIC_WS_URL"];
   const requireToken = opts.requireToken ?? envFlag("WEBUI_REQUIRE_TOKEN");
-  const strictPort = process.env["WEBUI_STRICT_PORT"] === "1" || process.env["WEBUI_STRICT_PORT"] === "true";
+  const strictPort = isStrictPort();
   let httpPort = requestedHttpPort;
   if (!strictPort) {
     httpPort = await findFreePort(wsHost, requestedHttpPort);
@@ -25234,7 +25698,9 @@ function startHttpServer(opts) {
     getLlm: opts.getLlm,
     executePackageOperation: opts.executePackageOperation,
     projectRoot: opts.projectRoot,
-    intakeService
+    intakeService,
+    ...opts.getVectorMemoryStore ? { getVectorMemoryStore: opts.getVectorMemoryStore } : {},
+    ...opts.vectorMemoryModelCacheDir ? { vectorMemoryModelCacheDir: opts.vectorMemoryModelCacheDir } : {}
   });
   return httpServer;
 }
@@ -25250,7 +25716,7 @@ function registerShutdown(deps2) {
 
 // src/server/start-webui-companion.ts
 import * as http2 from "node:http";
-function setupCompanionServer(httpServer, wsHost, httpPort) {
+async function setupCompanionServer(httpServer, wsHost, httpPort) {
   const companion = wsHost === "127.0.0.1" ? "::1" : wsHost === "0.0.0.0" || wsHost === void 0 ? "::" : wsHost === "::" || wsHost === "[::]" ? "0.0.0.0" : null;
   if (!companion) return null;
   const companionLabel = companion.includes(":") ? `[${companion}]` : companion;
@@ -25261,16 +25727,23 @@ function setupCompanionServer(httpServer, wsHost, httpPort) {
     (req, socket, head2) => httpServer.emit("upgrade", req, socket, head2)
   );
   companionServer.on("error", (err) => {
-    const expected = err.code === "EAFNOSUPPORT" || err.code === "EADDRNOTAVAIL" || err.code === "EADDRINUSE";
+    const expected = err.code === "EAFNOSUPPORT" || err.code === "EADDRNOTAVAIL";
     if (!expected) {
       console.warn(
         `[WebUI] companion listener on ${companionLabel} failed (${err.code ?? "unknown"}): ${err.message}. The primary address is unaffected.`
       );
     }
   });
-  companionServer.listen(httpPort, companion, () => {
-    console.log(`[WebUI] HTTP server running on http://${companionLabel}:${httpPort}`);
-  });
+  try {
+    await listenWithRetry(companionServer, companion, httpPort, { maxTries: 1 });
+  } catch (err) {
+    const code = err?.code ?? "unknown";
+    console.warn(
+      `[WebUI] companion listener on ${companionLabel} not started (${code}): ${err?.message ?? err}. The primary address is unaffected.`
+    );
+    return null;
+  }
+  console.log(`[WebUI] HTTP server running on http://${companionLabel}:${httpPort}`);
   return companionServer;
 }
 
@@ -25465,6 +25938,7 @@ function setupWebuiShutdown(options) {
       await options.memoryStore.dispose().catch(
         (err) => options.logger.warn(`sage connection disposal failed: ${toErrorMessage15(err)}`)
       );
+      options.vectorMemoryStore?.close();
       await unregisterInstance(process.pid, path32.dirname(options.globalConfigPath));
     }
   });
@@ -25529,7 +26003,8 @@ function createStandaloneTodosCheckpointLifecycle(input) {
 async function startWebUI(opts = {}) {
   ensureSessionShell();
   const ports = await resolvePorts(opts);
-  const { wsHost, httpPort, publicUrl, publicWsUrl, requireToken } = ports;
+  const { wsHost, publicUrl, publicWsUrl, requireToken } = ports;
+  let httpPort = ports.httpPort;
   console.log("[WebUI] Starting backend services...");
   const boot = await bootConfig();
   const { config: baseConfig, globalConfigPath, wpaths, logger } = boot;
@@ -25557,6 +26032,27 @@ async function startWebUI(opts = {}) {
     );
   }
   const needsProvider = !config.provider || !config.model;
+  let vectorMemoryStore;
+  const vectorMemoryModelCacheDir = path33.join(
+    projectRoot,
+    ".wrongstack",
+    "cache",
+    "transformers-models"
+  );
+  try {
+    vectorMemoryStore = new VectorMemoryStore({
+      provider: new TransformersEmbeddingProvider({
+        cacheDir: vectorMemoryModelCacheDir
+      }),
+      projectRoot
+    });
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    logger.warn(
+      `vector memory store disabled: ${message} \u2014 standalone WebUI will run on the SAGE-only surface.`
+    );
+    vectorMemoryStore = void 0;
+  }
   const preContext = await createPreContextServices({
     config,
     wpaths,
@@ -25604,6 +26100,13 @@ async function startWebUI(opts = {}) {
   let sessionStartedAt = preContext.sessionStartedAt;
   let modeId = preContext.modeId;
   const needsSetup = preContext.needsSetup;
+  if (vectorMemoryStore) {
+    void startFirstBootSageSync({
+      store: vectorMemoryStore,
+      memoryStore,
+      logger
+    });
+  }
   const prefSnapshot2 = () => prefSnapshot(context.meta);
   const persistPrefsToConfig2 = async (payload) => persistPrefsToConfig(prefHelperDeps, configWriteLock, payload);
   const trustBoundary = opts.trustBoundary ?? createCompatibilityTrustBoundary3({ policyId: "webui-trusted-host-compat-v1" });
@@ -25724,7 +26227,12 @@ async function startWebUI(opts = {}) {
       events,
       permissionPolicy
     }),
-    distDir: opts.distDir
+    distDir: opts.distDir,
+    // Vector memory store — mirrors the CLI host. When `vectorMemoryStore`
+    // construction failed (read-only FS, etc.) we still pass the getter;
+    // it just resolves to `undefined` and the API router answers 503.
+    getVectorMemoryStore: () => vectorMemoryStore,
+    vectorMemoryModelCacheDir
   });
   const wsResult = createWsServers(httpServer, ports, accessToken);
   const { wssPrimary, wssSecondary, clients } = wsResult;
@@ -25779,7 +26287,25 @@ async function startWebUI(opts = {}) {
     },
     watcherMetricsRef
   );
-  httpServer.listen(httpPort, wsHost, () => {
+  const strictPort = isStrictPort();
+  const boundPort = await listenWithRetry(httpServer, wsHost, httpPort, {
+    maxTries: strictPort ? 1 : 10
+  });
+  if (boundPort !== httpPort) {
+    console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "webui.port_reassigned",
+        protocol: "HTTP",
+        requested: httpPort,
+        assigned: boundPort,
+        reason: "bind-time EADDRINUSE retry",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    httpPort = boundPort;
+  }
+  {
     const authHint = requireToken ? " (authentication required; configure WEBUI_TOKEN out of band)" : "";
     console.log(`[WebUI] HTTP server listening on http://${wsHost}:${httpPort}${authHint}`);
     const extraUrls = formatExternalAccessUrls({
@@ -25790,8 +26316,8 @@ async function startWebUI(opts = {}) {
     if (extraUrls.length > 0) {
       console.log("[WebUI] Protected endpoints on external interfaces:\n" + extraUrls.join("\n"));
     }
-  });
-  const companionServer = setupCompanionServer(httpServer, wsHost, httpPort);
+  }
+  const companionServer = await setupCompanionServer(httpServer, wsHost, httpPort);
   async function touchProjectEntry(root, workDir) {
     const resolved = path33.resolve(root);
     const manifest = await loadManifest(globalConfigPath);
@@ -26050,6 +26576,7 @@ projectRoot: ${ev.projectRoot ?? "?"}`,
     },
     codebaseIndexing,
     memoryStore,
+    vectorMemoryStore,
     globalConfigPath
   });
 }