unbrowse 2.12.0 → 2.12.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbrowse",
-  "version": "2.12.0",
+  "version": "2.12.2",
   "description": "Reverse-engineer any website into reusable API skills. Zero-dep single binary with embedded browser engine.",
   "type": "module",
   "bin": {

package/runtime-src/analytics-session.ts

@@ -10,30 +10,15 @@ export interface AnalyticsSessionPayload {
   cached_skill_calls: number;
   fresh_index_calls: number;
   browser_mode: "default" | "replaced" | "manual" | "unknown";
-  success?: boolean;
-  source?: string;
-  time_saved_ms?: number;
-  time_saved_pct?: number;
-  tokens_saved?: number;
-  tokens_saved_pct?: number;
-  cost_saved_uc?: number;
 }
 
 export function buildAnalyticsSessionPayload(
   sessionId: string,
   startedAt: string,
-  source: OrchestrationTiming["source"] | "first-pass",
-  trace: Pick<ExecutionTrace, "completed_at" | "trace_version" | "success" | "tokens_saved" | "tokens_saved_pct"> & {
-    network_events?: unknown[];
-  },
-  timing?: Pick<OrchestrationTiming, "time_saved_ms" | "time_saved_pct" | "cost_saved_uc">,
+  source: OrchestrationTiming["source"],
+  trace: Pick<ExecutionTrace, "completed_at" | "network_events" | "trace_version">,
 ): AnalyticsSessionPayload {
-  const cacheLike = source === "marketplace" || source === "route-cache";
-  const browserMode = source === "live-capture" || source === "browser-action"
-    ? "default"
-    : source === "first-pass"
-      ? "default"
-      : "replaced";
+  const cacheLike = source === "marketplace" || source === "route-cache" || source === "first-pass";
   return {
     session_id: sessionId,
     started_at: startedAt,
@@ -42,14 +27,7 @@ export function buildAnalyticsSessionPayload(
     api_calls: Math.max(1, trace.network_events?.length ?? 0),
     discovery_queries: cacheLike ? 1 : 0,
     cached_skill_calls: cacheLike ? 1 : 0,
-    fresh_index_calls: source === "live-capture" || source === "first-pass" || source === "browser-action" ? 1 : 0,
-    browser_mode: browserMode,
-    success: trace.success ?? true,
-    source,
-    time_saved_ms: timing?.time_saved_ms,
-    time_saved_pct: timing?.time_saved_pct,
-    tokens_saved: trace.tokens_saved,
-    tokens_saved_pct: trace.tokens_saved_pct,
-    cost_saved_uc: timing?.cost_saved_uc,
+    fresh_index_calls: source === "live-capture" ? 1 : 0,
+    browser_mode: "unknown",
   };
 }

package/runtime-src/api/browse-session.ts

@@ -50,6 +50,7 @@ async function createBrowseSession(
 ): Promise<BrowseSession> {
   await client.start().catch(() => {});
   const tabId = await client.newTab();
+  if (!tabId) throw new Error("Failed to create browser tab");
   await client.harStart(tabId).catch(() => {});
   await injectInterceptor(tabId);
   const session: BrowseSession = { tabId, url: "about:blank", harActive: true, domain: "" };
@@ -80,7 +81,8 @@ async function adoptExistingBrowseTab(
         const domain = extractDomain(tab.url);
         return !!domain && !!normalizedPreferred && domain === normalizedPreferred;
       }) ??
-      tabs.find((tab) => /^https?:\/\//.test(tab.url ?? ""));
+      tabs.find((tab) => /^(about:blank|chrome:\/\/newtab\/?)$/i.test(tab.url ?? "")) ??
+      (!normalizedPreferred ? tabs.find((tab) => /^https?:\/\//.test(tab.url ?? "")) : undefined);
 
     if (!candidate?.id) return null;
     await client.harStart(candidate.id).catch(() => {});

package/runtime-src/api/browse-submit.ts

@@ -19,20 +19,10 @@ export interface BrowseSubmitClient {
 export interface BrowseSubmitDeps {
   client: BrowseSubmitClient;
   session: BrowseSession;
-  flushCapture?: (session: BrowseSession) => Promise<BrowseSubmitCaptureSyncResult | null>;
   restartCapture: (session: BrowseSession) => Promise<void>;
   rehydratePlugins: (tabId: string) => Promise<unknown>;
 }
 
-export interface BrowseSubmitCaptureSyncResult {
-  indexed: boolean;
-  mode: "http" | "dom" | "none";
-  skill_id?: string | null;
-  endpoint_count: number;
-  request_count?: number;
-  background_publish_queued?: boolean;
-}
-
 export interface BrowseSubmitResult {
   ok: boolean;
   url: string;
@@ -44,12 +34,12 @@ export interface BrowseSubmitResult {
   status?: number;
   wait_for?: string;
   submit_meta?: Record<string, unknown> | null;
-  capture_sync?: BrowseSubmitCaptureSyncResult | null;
   rehydrate?: unknown;
 }
 
 const DEFAULT_SUBMIT_TIMEOUT_MS = 8_000;
 const SUBMIT_POLL_INTERVAL_MS = 250;
+const SUBMIT_SETTLE_WINDOW_MS = 1_000;
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -300,6 +290,27 @@ function parseJsonString(value: unknown): Record<string, unknown> | null {
   }
 }
 
+async function settleSubmitDestination(
+  client: BrowseSubmitClient,
+  tabId: string,
+  url: string,
+  html: string,
+): Promise<{ url: string; html: string }> {
+  let settledUrl = url;
+  let settledHtml = html;
+  const deadline = Date.now() + SUBMIT_SETTLE_WINDOW_MS;
+
+  while (Date.now() < deadline) {
+    await sleep(Math.min(SUBMIT_POLL_INTERVAL_MS, Math.max(50, deadline - Date.now())));
+    const nextUrl = await client.getCurrentUrl(tabId).catch(() => "");
+    const nextHtml = await client.getPageHtml(tabId).catch(() => "");
+    if (nextUrl && !nextUrl.startsWith("about:blank")) settledUrl = nextUrl;
+    if (nextHtml) settledHtml = nextHtml;
+  }
+
+  return { url: settledUrl, html: settledHtml };
+}
+
 async function waitForSubmitOutcome(
   client: BrowseSubmitClient,
   tabId: string,
@@ -317,7 +328,7 @@ async function waitForSubmitOutcome(
       if (waitResult?.status === "found" || waitResult?.status === "ready") {
         const url = await client.getCurrentUrl(tabId).catch(() => beforeUrl);
         const html = await client.getPageHtml(tabId).catch(() => beforeHtml);
-        return { ok: true, url, html };
+        return { ok: true, ...await settleSubmitDestination(client, tabId, url, html) };
       }
     } catch {
       // fall through to polling
@@ -329,13 +340,13 @@ async function waitForSubmitOutcome(
     const html = await client.getPageHtml(tabId).catch(() => "");
 
     if (waitFor && isUrlWaitHint(waitFor) && url.includes(waitFor)) {
-      return { ok: true, url, html };
+      return { ok: true, ...await settleSubmitDestination(client, tabId, url, html) };
     }
     if (url && url !== beforeUrl && !url.startsWith("about:blank")) {
-      return { ok: true, url, html };
+      return { ok: true, ...await settleSubmitDestination(client, tabId, url, html) };
     }
     if (hasMeaningfulPageChange(beforeHtml, html)) {
-      return { ok: true, url: url || beforeUrl, html };
+      return { ok: true, ...await settleSubmitDestination(client, tabId, url || beforeUrl, html) };
     }
 
     await sleep(SUBMIT_POLL_INTERVAL_MS);
@@ -348,7 +359,7 @@ export async function submitBrowseForm(
   deps: BrowseSubmitDeps,
   options: BrowseSubmitOptions = {},
 ): Promise<BrowseSubmitResult> {
-  const { client, session, flushCapture, restartCapture, rehydratePlugins } = deps;
+  const { client, session, restartCapture, rehydratePlugins } = deps;
   const sameOriginFetchFallback = options.sameOriginFetchFallback !== false;
   const beforeUrl = await client.getCurrentUrl(session.tabId).catch(() => session.url);
   const beforeHtml = await client.getPageHtml(session.tabId).catch(() => "");
@@ -377,14 +388,6 @@ export async function submitBrowseForm(
   const domOutcome = await waitForSubmitOutcome(client, session.tabId, beforeUrl, beforeHtml, options);
   if (domOutcome.ok) {
     session.url = domOutcome.url || beforeUrl || session.url;
-    let captureSync: BrowseSubmitCaptureSyncResult | null = null;
-    if (flushCapture) {
-      try {
-        captureSync = await flushCapture(session);
-      } catch {
-        captureSync = null;
-      }
-    }
     await restartCapture(session);
     return {
       ok: true,
@@ -394,7 +397,6 @@ export async function submitBrowseForm(
       same_origin_html_rehydrated: false,
       wait_for: options.waitFor,
       submit_meta: submitMeta,
-      capture_sync: captureSync,
     };
   }
 
@@ -438,14 +440,6 @@ export async function submitBrowseForm(
     rehydrate = await rehydratePlugins(session.tabId).catch(() => null);
   }
 
-  let captureSync: BrowseSubmitCaptureSyncResult | null = null;
-  if (flushCapture) {
-    try {
-      captureSync = await flushCapture(session);
-    } catch {
-      captureSync = null;
-    }
-  }
   await restartCapture(session);
   return {
     ok: true,
@@ -456,7 +450,6 @@ export async function submitBrowseForm(
     status: typeof fallbackPayload.status === "number" ? fallbackPayload.status as number : undefined,
     wait_for: options.waitFor,
     submit_meta: submitMeta,
-    capture_sync: captureSync,
     rehydrate,
   };
 }

package/runtime-src/api/routes.ts

@@ -19,12 +19,11 @@ import { getSkill } from "../marketplace/index.js";
 import { executeSkill, rankEndpoints } from "../execution/index.js";
 import { interactiveLogin, extractBrowserAuth } from "../auth/index.js";
 import { publishSkill } from "../marketplace/index.js";
-import { recordFeedback, recordDiagnostics, recordExecution, getApiKey, getRecentLocalSkill, recordAnalyticsSession, type AnalyticsSessionPayload } from "../client/index.js";
+import { recordFeedback, recordDiagnostics, recordExecution, getApiKey, getRecentLocalSkill, recordAnalyticsSession, waitForBackgroundRegistration, type AnalyticsSessionPayload } from "../client/index.js";
 import { ROUTE_LIMITS } from "../ratelimit/index.js";
 import { getSkillChunk, toAgentSkillChunkView } from "../graph/index.js";
 import { listRecentSessionsForDomain } from "../session-logs.js";
 import { mergeAgentReview } from "../indexer/index.js";
-import { attachAgentOutcomeHints } from "../agent-outcome.js";
 import { writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { type BrowseSession, getOrCreateBrowseSession, isRecoverableBrowseFailure, withRecoveredBrowseSession } from "./browse-session.js";
@@ -36,15 +35,15 @@ const BETA_API_URL = process.env.UNBROWSE_BACKEND_URL || "https://beta-api.unbro
 const TRACES_DIR = process.env.TRACES_DIR ?? join(process.cwd(), "traces");
 
 type AnalyticsSessionResult = {
-  trace: Pick<ExecutionTrace, "trace_id" | "started_at" | "completed_at" | "endpoint_id" | "trace_version" | "success" | "tokens_saved" | "tokens_saved_pct">;
-  timing?: Pick<OrchestrationTiming, "source" | "time_saved_ms" | "time_saved_pct" | "cost_saved_uc" | "tokens_saved" | "tokens_saved_pct">;
+  trace: Pick<ExecutionTrace, "trace_id" | "started_at" | "completed_at" | "endpoint_id" | "trace_version">;
+  timing?: Pick<OrchestrationTiming, "source">;
   source?: OrchestratorResult["source"];
 };
 
 export function buildAnalyticsSessionPayload(
   result: AnalyticsSessionResult,
   opts: {
-    browser_mode?: AnalyticsSessionPayload["browser_mode"];
+    browser_mode: AnalyticsSessionPayload["browser_mode"];
     discovery_queries: number;
     cached_skill_calls?: number;
     fresh_index_calls?: number;
@@ -52,11 +51,6 @@ export function buildAnalyticsSessionPayload(
 ): AnalyticsSessionPayload {
   const source = result.timing?.source ?? result.source;
   const apiCalls = result.trace.endpoint_id ? 1 : 0;
-  const browserMode = opts.browser_mode ?? (
-    source === "live-capture" || source === "first-pass" || source === "browser-action"
-      ? "default"
-      : "replaced"
-  );
   const cachedSkillCalls = opts.cached_skill_calls ?? (
     apiCalls > 0 && source !== "live-capture" && source !== "first-pass" ? 1 : 0
   );
@@ -73,14 +67,7 @@ export function buildAnalyticsSessionPayload(
     discovery_queries: opts.discovery_queries,
     cached_skill_calls: cachedSkillCalls,
     fresh_index_calls: freshIndexCalls,
-    browser_mode: browserMode,
-    success: result.trace.success ?? true,
-    source,
-    time_saved_ms: result.timing?.time_saved_ms,
-    time_saved_pct: result.timing?.time_saved_pct,
-    tokens_saved: result.trace.tokens_saved ?? result.timing?.tokens_saved,
-    tokens_saved_pct: result.trace.tokens_saved_pct ?? result.timing?.tokens_saved_pct,
-    cost_saved_uc: result.timing?.cost_saved_uc,
+    browser_mode: opts.browser_mode ?? "unknown",
   };
 }
 
@@ -328,7 +315,11 @@ export async function registerRoutes(app: FastifyInstance) {
   app.addHook("onRequest", async (req, reply) => {
     if (req.url === "/health" || req.url === "/v1/stats") return;
 
-    const key = getApiKey();
+    let key = getApiKey();
+    if (!key) {
+      await waitForBackgroundRegistration(15_000);
+      key = getApiKey();
+    }
     if (!key) {
       return reply.code(401).send({
         error: "api_key_required",
@@ -355,11 +346,7 @@ export async function registerRoutes(app: FastifyInstance) {
       const result = await resolveAndExecute(intent, params ?? {}, context, projection, { confirm_unsafe, dry_run, force_capture, client_scope: clientScope });
 
       // Surface timing breakdown
-      const res = attachAgentOutcomeHints({ ...result } as Record<string, unknown>, {
-        skill: result.skill,
-        endpointId: result.trace.endpoint_id,
-        timing: result.timing,
-      });
+      const res = result as unknown as Record<string, unknown>;
       if (result.timing) {
         res.timing = result.timing;
       }
@@ -372,10 +359,11 @@ export async function registerRoutes(app: FastifyInstance) {
       }
 
       await recordAnalyticsSession(buildAnalyticsSessionPayload(result, {
+        browser_mode: "replaced",
         discovery_queries: 1,
       })).catch(() => {});
 
-      return reply.send(res);
+      return reply.send(result);
     } catch (err) {
       return reply.code(500).send({ error: (err as Error).message });
     }
@@ -646,22 +634,16 @@ export async function registerRoutes(app: FastifyInstance) {
             recordExecution(freshResult.trace.skill_id, freshResult.trace.endpoint_id, freshResult.trace, skill).catch(() => {});
           }
           await recordAnalyticsSession(buildAnalyticsSessionPayload(freshResult, {
+            browser_mode: "manual",
             discovery_queries: 1,
           })).catch(() => {});
-          const recovered = attachAgentOutcomeHints({
+          return reply.send({
             ...freshResult,
             _recovery: {
               reason: "stale_endpoint_404",
               original_skill_id: skill_id,
               message: "Original endpoint returned 404. Auto-recovered with fresh capture.",
             },
-          } as Record<string, unknown>, {
-            skill: freshResult.skill ?? skill,
-            endpointId: freshResult.trace.endpoint_id,
-            timing: freshResult.timing,
-          });
-          return reply.send({
-            ...recovered,
           });
         } catch {
           // Recovery failed — return original 404 with guidance
@@ -669,14 +651,13 @@ export async function registerRoutes(app: FastifyInstance) {
       }
 
       await recordAnalyticsSession(buildAnalyticsSessionPayload(execResult, {
+        browser_mode: "manual",
         discovery_queries: 0,
+        cached_skill_calls: execResult.trace.endpoint_id ? 1 : 0,
+        fresh_index_calls: 0,
       })).catch(() => {});
 
-      const response = attachAgentOutcomeHints({ ...execResult } as Record<string, unknown>, {
-        skill,
-        endpointId: execResult.trace.endpoint_id,
-      });
-      return reply.send(response);
+      return reply.send(execResult);
     } catch (err) {
       return reply.code(500).send({ error: (err as Error).message });
     }
@@ -880,96 +861,6 @@ export async function registerRoutes(app: FastifyInstance) {
     await injectInterceptor(session.tabId).catch(() => {});
   }
 
-  async function flushBrowseCapture(
-    session: BrowseSession,
-    options: { queueBackgroundPublish?: boolean } = {},
-  ): Promise<{
-    indexed: boolean;
-    mode: "http" | "dom" | "none";
-    domain: string;
-    skill_id: string | null;
-    endpoint_count: number;
-    endpoints: Array<{
-      endpoint_id: string;
-      method: string;
-      url_template: string;
-      description?: string;
-      trigger_url?: string;
-      action_kind?: string;
-      resource_kind?: string;
-    }>;
-    request_count: number;
-    background_publish_queued: boolean;
-  }> {
-    let intercepted: RawRequest[] = [];
-    try {
-      const raw = await collectInterceptedRequests(session.tabId);
-      intercepted = raw.map((request) => ({
-        url: request.url,
-        method: request.method,
-        request_headers: request.request_headers ?? {},
-        request_body: request.request_body,
-        response_status: request.response_status,
-        response_headers: request.response_headers ?? {},
-        response_body: request.response_body,
-        timestamp: request.timestamp,
-      }));
-    } catch { /* non-fatal */ }
-
-    let harEntries: KuriHarEntry[] = [];
-    if (session.harActive) {
-      try {
-        const { entries } = await kuri.harStop(session.tabId);
-        harEntries = entries;
-      } catch { /* non-fatal */ }
-    }
-    session.harActive = false;
-
-    const allRequests = mergeBrowseRequests(intercepted, harEntries, session.url);
-    const syncResult = await cacheBrowseRequests({
-      sessionUrl: session.url,
-      sessionDomain: session.domain,
-      requests: allRequests,
-      getPageHtml: () => kuri.getPageHtml(session.tabId),
-    });
-
-    let backgroundPublishQueued = false;
-    if (options.queueBackgroundPublish) {
-      if (allRequests.length > 0) {
-        passiveIndexFromRequests(allRequests, session.url);
-        backgroundPublishQueued = true;
-      } else if (syncResult.skill) {
-        queueBackgroundIndex({
-          skill: { ...syncResult.skill },
-          domain: syncResult.domain,
-          intent: syncResult.skill.intent_signature || `browse ${syncResult.domain}`,
-          contextUrl: session.url,
-          cacheKey: `browse-submit:${syncResult.domain}:${Date.now()}`,
-        });
-        backgroundPublishQueued = true;
-      }
-    }
-
-    return {
-      indexed: syncResult.indexed,
-      mode: syncResult.mode,
-      domain: syncResult.domain,
-      skill_id: syncResult.skill?.skill_id ?? null,
-      endpoint_count: syncResult.skill?.endpoints.length ?? 0,
-      endpoints: (syncResult.skill?.endpoints ?? []).map((endpoint) => ({
-        endpoint_id: endpoint.endpoint_id,
-        method: endpoint.method,
-        url_template: endpoint.url_template,
-        description: endpoint.description,
-        trigger_url: endpoint.trigger_url,
-        action_kind: endpoint.semantic?.action_kind,
-        resource_kind: endpoint.semantic?.resource_kind,
-      })),
-      request_count: allRequests.length,
-      background_publish_queued: backgroundPublishQueued,
-    };
-  }
-
   // POST /v1/browse/go — navigate to URL
   app.post("/v1/browse/go", async (req, reply) => {
     const { url } = req.body as { url: string };
@@ -1060,7 +951,6 @@ export async function registerRoutes(app: FastifyInstance) {
         {
           client: kuri,
           session,
-          flushCapture: async (session) => await flushBrowseCapture(session, { queueBackgroundPublish: true }),
           restartCapture: restartBrowseCapture,
           rehydratePlugins: kuri.bestEffortRehydratePlugins,
         },
@@ -1079,14 +969,8 @@ export async function registerRoutes(app: FastifyInstance) {
     session.domain = profileName(session.url);
 
     const statusCode = result.ok ? 200 : (result.recoverable ? 502 : 400);
-    const nextStep = result.ok
-      ? (result.capture_sync?.background_publish_queued
-          ? "Background publish queued for this step. Continue the flow, then run `unbrowse close` when you're done to save auth and finalize any remaining capture."
-          : "If more UI steps remain, continue the flow. Run `unbrowse close` when you're done to save auth and finalize capture.")
-      : "Inspect the page state with `unbrowse snap --filter interactive`, then retry submit with selectors or a wait hint if needed.";
     return reply.code(statusCode).send({
       ...result,
-      next_step: nextStep,
       recovered,
       tab_id: session.tabId,
       url: session.url,
@@ -1254,9 +1138,44 @@ export async function registerRoutes(app: FastifyInstance) {
   app.post("/v1/browse/sync", async (_req, reply) => {
     const session = browseSessions.get("default");
     if (!session) return reply.send({ ok: false, error: "no active session" });
-    const syncResult = await flushBrowseCapture(session);
 
-    await restartBrowseCapture(session);
+    let intercepted: RawRequest[] = [];
+    try {
+      const raw = await collectInterceptedRequests(session.tabId);
+      intercepted = raw.map((request) => ({
+        url: request.url,
+        method: request.method,
+        request_headers: request.request_headers ?? {},
+        request_body: request.request_body,
+        response_status: request.response_status,
+        response_headers: request.response_headers ?? {},
+        response_body: request.response_body,
+        timestamp: request.timestamp,
+      }));
+    } catch { /* non-fatal */ }
+
+    let harEntries: KuriHarEntry[] = [];
+    if (session.harActive) {
+      try {
+        const { entries } = await kuri.harStop(session.tabId);
+        harEntries = entries;
+      } catch { /* non-fatal */ }
+    }
+    session.harActive = false;
+
+    const allRequests = mergeBrowseRequests(intercepted, harEntries, session.url);
+    const syncResult = await cacheBrowseRequests({
+      sessionUrl: session.url,
+      sessionDomain: session.domain,
+      requests: allRequests,
+      getPageHtml: () => kuri.getPageHtml(session.tabId),
+    });
+
+    await kuri.networkEnable(session.tabId).catch(() => {});
+    await kuri.harStart(session.tabId).catch(() => {});
+    await kuri.scriptInject(session.tabId, INTERCEPTOR_SCRIPT).catch(() => {});
+    session.harActive = true;
+    await injectInterceptor(session.tabId).catch(() => {});
 
     return reply.send({
       ok: true,
@@ -1264,10 +1183,17 @@ export async function registerRoutes(app: FastifyInstance) {
       indexed: syncResult.indexed,
       mode: syncResult.mode,
       domain: syncResult.domain,
-      skill_id: syncResult.skill_id,
-      endpoint_count: syncResult.endpoint_count,
-      endpoints: syncResult.endpoints,
-      request_count: syncResult.request_count,
+      skill_id: syncResult.skill?.skill_id ?? null,
+      endpoint_count: syncResult.skill?.endpoints.length ?? 0,
+      endpoints: (syncResult.skill?.endpoints ?? []).map((endpoint) => ({
+        endpoint_id: endpoint.endpoint_id,
+        method: endpoint.method,
+        url_template: endpoint.url_template,
+        description: endpoint.description,
+        trigger_url: endpoint.trigger_url,
+        action_kind: endpoint.semantic?.action_kind,
+        resource_kind: endpoint.semantic?.resource_kind,
+      })),
     });
   });
 
@@ -1281,16 +1207,48 @@ export async function registerRoutes(app: FastifyInstance) {
       await kuri.authProfileSave(session.tabId, session.domain).catch(() => {});
     }
 
-    const syncResult = await flushBrowseCapture(session, { queueBackgroundPublish: true });
+    // Collect intercepted fetch/XHR requests (has response bodies HAR misses)
+    let intercepted: RawRequest[] = [];
+    try {
+      const raw = await collectInterceptedRequests(session.tabId);
+      intercepted = raw.map(r => ({
+        url: r.url,
+        method: r.method,
+        request_headers: r.request_headers ?? {},
+        request_body: r.request_body,
+        response_status: r.response_status,
+        response_headers: r.response_headers ?? {},
+        response_body: r.response_body,
+        timestamp: r.timestamp,
+      }));
+    } catch { /* non-fatal */ }
+
+    // Also collect HAR entries
+    let harEntries: KuriHarEntry[] = [];
+    if (session.harActive) {
+      try {
+        const { entries } = await kuri.harStop(session.tabId);
+        harEntries = entries;
+      } catch { /* non-fatal */ }
+    }
+
+    const allRequests = mergeBrowseRequests(intercepted, harEntries, session.url);
+    const syncResult = await cacheBrowseRequests({
+      sessionUrl: session.url,
+      sessionDomain: session.domain,
+      requests: allRequests,
+      getPageHtml: () => kuri.getPageHtml(session.tabId),
+    });
+
+    // Run full async enrichment pipeline (agent augmentation, graph, marketplace publish)
+    passiveIndexFromRequests(allRequests, session.url);
     await kuri.closeTab(session.tabId).catch(() => {});
     browseSessions.delete("default");
     return reply.send({
       ok: true,
       indexed: syncResult.indexed,
       mode: syncResult.mode,
-      endpoint_count: syncResult.endpoint_count,
-      request_count: syncResult.request_count,
-      background_publish_queued: syncResult.background_publish_queued,
+      endpoint_count: syncResult.skill?.endpoints.length ?? 0,
       auth_saved: session.domain || null,
     });
   });