@jxsuite/studio 3.0.0 → 4.0.0

package/src/services/ai-system-prompt.ts

@@ -29,6 +29,12 @@ interface BuildSystemPromptOptions {
    * prompt-shape tests — advertises the same list it always did.
    */
   treeEditable?: boolean | undefined;
+  /**
+   * Whether the platform can import a site. Defaults TRUE so this stays a pure function of what it
+   * is given — a caller that knows nothing about the platform gets the full list, and only
+   * `document-assistant.ts`, which does know, narrows it.
+   */
+  canImport?: boolean | undefined;
   /** Project-relative file paths for the inventory section (project modes; capped). */
   fileInventory?: string[] | undefined;
 }
@@ -52,13 +58,21 @@ const FILE_INVENTORY_CAP = 100;
  * a weaker test than `structurallyEditable`, so a repeater template or `$switch` case was removable
  * by the agent and not by the person.
  */
-export type AiToolTier = "no-project" | "project" | "document" | "document-tree";
+export type AiToolTier = "always" | "no-project" | "project" | "document" | "document-tree";
 
 export interface AiToolInfo {
   name: string;
   tier: AiToolTier;
   /** One-line signature + purpose shown in the system prompt's tool list. */
   blurb: string;
+  /**
+   * A PAL member the tool needs, beyond whatever its tier requires.
+   *
+   * The tier answers "what is open"; this answers "can this backend do it at all". Cloud ships no
+   * `importSite`, so `import_site` must not be advertised there — and a tier cannot express that,
+   * because "no project is open" is exactly as true on cloud as anywhere else.
+   */
+  capability?: "importSite";
 }
 
 /**
@@ -67,7 +81,27 @@ export interface AiToolInfo {
  * list cannot drift (a test asserts the names match the registered tools).
  */
 export const AI_TOOL_TIERS: AiToolInfo[] = [
+  // Always — a question is not gated on what happens to be open
+  {
+    name: "ask_user",
+    tier: "always",
+    blurb:
+      "ask_user(question, options?, context?) — pause and put a question to the user; the turn " +
+      "waits for their reply and resumes with it. Only for a judgement that is genuinely theirs.",
+  },
   // Bootstrap (no project open)
+  {
+    name: "import_site",
+    tier: "no-project",
+    capability: "importSite",
+    blurb:
+      "import_site(url, directory?, depth?, maxPages?, aiComponents?, maxBreakpoints?, " +
+      "breakpointWidths?, breakpointRounding?) — clone a live website into a new Jx project and " +
+      "open it: pages, styles, assets, a shared layout and recurring components. The project opens " +
+      "as soon as the destination exists, so the user watches it fill up while the crawl runs. " +
+      "When the user came through the New Project Import form the destination and options are " +
+      "already settled — pass the url alone.",
+  },
   {
     name: "create_project",
     tier: "no-project",
@@ -174,6 +208,8 @@ export const AI_TOOL_TIERS: AiToolInfo[] = [
 export interface AiToolState {
   hasProject: boolean;
   hasDocument: boolean;
+  /** Whether the platform implements `importSite`. Cloud does not. */
+  canImport?: boolean;
   /**
    * The open document is an element tree the canvas is editing — `editor.kind === "canvas"`.
    *
@@ -189,6 +225,9 @@ export interface AiToolState {
  * tools need an active document (even in single-file mode without a project).
  */
 export function tierActive(tier: AiToolTier, state: AiToolState): boolean {
+  if (tier === "always") {
+    return true;
+  }
   if (tier === "no-project") {
     return !state.hasProject;
   }
@@ -201,12 +240,56 @@ export function tierActive(tier: AiToolTier, state: AiToolState): boolean {
   return state.hasDocument;
 }
 
+/**
+ * Whether a tool is active: its tier, AND any capability it declares.
+ *
+ * The one predicate the prompt's tool list and the gating registry both run, which is the whole
+ * point of {@link AI_TOOL_TIERS} — a tool the model is told about and then refused is a surprise to
+ * it, and one it is refused without being told is invisible.
+ *
+ * @param {AiToolInfo} tool
+ * @param {AiToolState} state
+ * @returns {boolean}
+ */
+export function toolActive(tool: AiToolInfo, state: AiToolState): boolean {
+  if (tool.capability === "importSite" && state.canImport === false) {
+    return false;
+  }
+  return tierActive(tool.tier, state);
+}
+
 // ─── Jx Schema Reference (condensed) ────────────────────────────────────────
 
 /**
  * Condensed reference of Jx document structure rules. Included inline in the system prompt so the
  * LLM understands the schema without consuming excessive tokens.
  */
+/**
+ * When to stop and ask, and — more importantly — when not to.
+ *
+ * Rendered into the closing section of every prompt, because `ask_user` is an `always` tier tool.
+ * The prohibitions carry most of the weight: a tool that suspends a turn on a human is only worth
+ * having if the questions are ones a human actually wants. A model that asks what it could have
+ * read, or asks about a knob its answer cannot reach, trains the author to stop reading the
+ * questions.
+ */
+const ASKING_THE_USER = `## Asking the user
+
+You can stop and ask with ask_user; the turn waits and resumes with the reply. Waiting on a person
+is not free, so ask only when all three hold:
+
+1. It is genuinely THEIR judgement — taste, priority, or intent. "Which of these pages matter?",
+ "keep their brand colours or restyle?", "is this page close enough?"
+2. You could not answer it yourself with another tool. Read the file, list the directory, look at
+ the document. Asking what you could have discovered is the commonest way to waste the question.
+3. You can ACT on any answer they give. Never ask about an option you have no way to change.
+
+Ask one question at a time. Offer options when the sensible answers are a short list; the user can
+always reply in their own words instead. If they decline, decide yourself and say what you chose.
+
+Prefer doing to asking. On a vague prompt, make a defensible choice, do the work, and say what you
+assumed — one good question beats five, and beats none only when it changes what you build.`;
+
 const JX_SCHEMA_REFERENCE = `## Jx Document Format
 
 A Jx document is a JSON object. Key top-level fields:
@@ -560,6 +643,7 @@ export function buildSystemPrompt({
   projectRoot,
   hasProject = Boolean(projectRoot),
   treeEditable = true,
+  canImport = true,
   fileInventory,
 }: BuildSystemPromptOptions = {}) {
   const hasDocument = Boolean(document);
@@ -568,7 +652,7 @@ export function buildSystemPrompt({
   // The list the model is TOLD about and the list the gate will honour are the same filter, so a
   // Refusal is never a surprise to it.
   const toolList = AI_TOOL_TIERS.filter((t) =>
-    tierActive(t.tier, { hasDocument, hasProject, treeEditable }),
+    toolActive(t, { canImport, hasDocument, hasProject, treeEditable }),
   )
     .map((t) => `- ${t.blurb}`)
     .join("\n");
@@ -608,6 +692,8 @@ Your document edits apply to the live canvas immediately and are individually un
 
   const closing = `You have a limited number of tool-call rounds per message. On vague or open-ended prompts ("make it look better", "improve this"), prefer a small number of targeted, high-impact changes over attempting to rebuild the entire page. Explain what you changed and offer to do more.
 
+${ASKING_THE_USER}
+
 Be concise. Don't explain what Jx is unless asked. Just build.`;
 
   const sections = [`${role}\n\n${workflow}\n\n${closing}`];

package/src/services/ai-turn-signal.ts

@@ -0,0 +1,70 @@
+/**
+ * Ai-turn-signal.ts — what the agent loop knows that a tool needs and cannot be passed.
+ *
+ * `ToolRegistry.execute(name, args)` takes no signal, and its signature is fixed in the published
+ * `@jxsuite/ai`. So `runAgentLoop` could hand its signal to `streamChat` and to nothing else: a tool
+ * that ran for minutes (an import) could not be cancelled, and a tool that waits for a human
+ * (`ask_user`) would have hung on Stop forever, because the promise the loop is awaiting has no
+ * other way to learn the turn is over.
+ *
+ * An ambient slot rather than a parameter, for the same reason `services/ai-writes.ts` is one: the
+ * loop already brackets each turn with `beginTurn`/`endTurn` in a try/finally, and this rides that
+ * bracket. Only one turn runs at a time — `sendMessage` and `beginAssistantTurn` are both no-ops
+ * while streaming — so a module-level slot is the whole of the state.
+ *
+ * @license MIT
+ */
+
+let _signal: AbortSignal | undefined;
+
+/**
+ * Publish the turn's signal for the tools it will run. Called by `runAgentLoop`.
+ *
+ * @param {AbortSignal} [signal] - The turn's signal; `undefined` leaves tools uncancellable, which
+ *   is what a caller that passed no signal asked for.
+ */
+export function beginTurnSignal(signal?: AbortSignal): void {
+  _signal = signal;
+}
+
+/**
+ * The running turn's signal, or `undefined` outside a turn.
+ *
+ * A tool must treat `undefined` as "not cancellable" rather than as an error: the evals runner and
+ * several tests drive the loop with no signal at all.
+ *
+ * @returns {AbortSignal | undefined}
+ */
+export function turnSignal(): AbortSignal | undefined {
+  return _signal;
+}
+
+/** Clear the slots. Called from `runAgentLoop`'s `finally`, so it runs on every exit path. */
+export function endTurnSignal(): void {
+  _signal = undefined;
+  _toolCallId = "";
+}
+
+let _toolCallId = "";
+
+/**
+ * Publish the id of the call about to execute. Called by `runAgentLoop` per tool call.
+ *
+ * A tool that outlives its own execution — `ask_user`, whose question stays on screen until a human
+ * answers — needs the id to join what it registered to the chip the transcript is drawing. Without
+ * it a restored, permanently unanswered question is indistinguishable from the live one.
+ *
+ * @param {string} id
+ */
+export function beginToolCall(id: string): void {
+  _toolCallId = id;
+}
+
+/**
+ * The id of the tool call currently executing, or `""` outside one.
+ *
+ * @returns {string}
+ */
+export function currentToolCallId(): string {
+  return _toolCallId;
+}

package/src/services/connection.ts

@@ -0,0 +1,74 @@
+/**
+ * The backend connection, said out loud.
+ *
+ * Only one launcher can lose a backend mid-session: the chromium desktop shell holds a single
+ * long-lived WebSocket to its project server. When that socket died, every later call returned a
+ * promise that NEVER SETTLED — `WebSocket.send()` on a closed socket discards the frame instead of
+ * throwing, so nothing rejected, nothing resolved, and the visible symptom was **Open Project**
+ * doing nothing at all. No toast, no log, no failed state. Restarting Studio was the only
+ * recovery.
+ *
+ * The transport now rejects those calls, and this is the other half: a person needs to be told
+ * which of "it is broken" and "it is coming back" they are in. One keyed problem so a flapping
+ * connection cannot stack up a column of identical rows, dismissed on recovery so a fixed thing
+ * does not stay on the Problems list (§16.1's third tier, and §16.6's rule that a record is retired
+ * by whoever owns its life).
+ *
+ * A platform without `subscribeConnection` — the dev server, electrobun — installs nothing. There
+ * is no connection to lose there, and a notice about one would be a lie.
+ *
+ * @docs studio/interface/problems-and-progress
+ */
+
+import { getPlatform } from "../platform";
+import { dismiss, notify } from "./notify";
+import type { Notification } from "./notify";
+
+/** One key for every connection notice, so a flapping socket replaces rather than accumulates. */
+const CONNECTION_KEY = "platform:connection";
+
+/** The outstanding "we are disconnected" record, so recovery can retire it. */
+let outstanding: Notification | null = null;
+
+/**
+ * Start reporting the backend connection. Returns an unsubscribe, or null on a platform that has no
+ * connection to report.
+ *
+ * @returns {(() => void) | null}
+ */
+export function watchConnection(): (() => void) | null {
+  const subscribe = getPlatform().subscribeConnection;
+  if (!subscribe) {
+    return null;
+  }
+  const unsubscribe = subscribe(({ online, reason }) => {
+    if (online) {
+      if (outstanding) {
+        dismiss(outstanding.id);
+        outstanding = null;
+        notify.success("Reconnected to the Jx backend.", { source: "Backend" });
+      }
+      return;
+    }
+    /* Already reported. A reconnect attempt failing is the same state, not a new one. */
+    if (outstanding) {
+      return;
+    }
+    outstanding = notify.error(reason ?? "Lost connection to the Jx backend.", {
+      detail:
+        "Editing continues, but anything that reads or writes files will fail until it comes " +
+        "back. Studio is retrying.",
+      key: CONNECTION_KEY,
+      source: "Backend",
+    });
+  });
+  /* Unsubscribing retires the notice with it: the watcher is the only thing that would ever have
+     dismissed it, so leaving it on the Problems list would leave a report nobody can clear. */
+  return () => {
+    unsubscribe();
+    if (outstanding) {
+      dismiss(outstanding.id);
+      outstanding = null;
+    }
+  };
+}

package/src/services/context-manager.ts

@@ -198,3 +198,92 @@ export function trimContext(
 
   return { estimatedTokens: newTotal, droppedCount };
 }
+
+// ─── Orphaned tool calls ────────────────────────────────────────────────────
+
+/** What a synthesized result says, so a reader and the model see the same reason. */
+const UNANSWERED_TOOL_RESULT = JSON.stringify({
+  success: false,
+  error:
+    "This tool call was never completed — the session was reloaded or the history was trimmed.",
+});
+
+/**
+ * Repair tool-call pairing in place, and report how many messages it touched.
+ *
+ * `toMessagesArray()` serializes the array verbatim: an assistant message with `tool_calls` becomes
+ * a `tool_calls` request, and a `tool` message becomes a reply carrying `tool_call_id`. Providers
+ * require the two to come in pairs, and **three ordinary things break the pairing**:
+ *
+ * 1. `saveSession` persists `msgs.slice(-MAX_PERSIST_MESSAGES)` and `restoreChat` pushes the result
+ *    back, so a session longer than the cap can be restored starting mid-pair.
+ * 2. {@link trimContext} splices from the front for the token budget, with no more regard for pairs.
+ * 3. A turn that stopped while a tool was still running — which `ask_user` makes routine, because its
+ *    tool is _designed_ to be outstanding — leaves a request with no reply.
+ *
+ * Each of those produced a 400 on the NEXT send, from a conversation the user could see was fine.
+ * So the repair belongs on the send path, after trimming, rather than at any one of the three
+ * sites: a request with no reply gets a synthesized failure (keeping the assistant's text, which
+ * dropping the message would lose), and a reply with no request is dropped.
+ *
+ * @param {ReturnType<typeof createChatState>} chatState
+ * @returns {{ sealed: number; dropped: number }}
+ */
+export function pruneOrphanToolMessages(chatState: ReturnType<typeof createChatState>): {
+  sealed: number;
+  dropped: number;
+} {
+  const { messages } = chatState;
+
+  const requested = new Set<string>();
+  const answered = new Set<string>();
+  for (const msg of messages) {
+    if (msg.role === "assistant" && msg.toolCalls) {
+      for (const call of msg.toolCalls) {
+        requested.add(call.id);
+      }
+    } else if (msg.role === "tool" && msg.toolCallId) {
+      answered.add(msg.toolCallId);
+    }
+  }
+
+  // Replies with no request, and replies with no id at all — neither can be serialized into a
+  // Well-formed pair, and a reply is the half that carries no author text worth keeping.
+  let dropped = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]!;
+    if (msg.role === "tool" && (!msg.toolCallId || !requested.has(msg.toolCallId))) {
+      messages.splice(i, 1);
+      dropped += 1;
+    }
+  }
+
+  /* Requests with no reply. Walk backwards so each insertion is past the indices still to visit,
+     and seal immediately after the requesting message — `toMessagesArray` emits in array order, so
+     that is the only position the pair is adjacent in. */
+  let sealed = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]!;
+    if (msg.role !== "assistant" || !msg.toolCalls) {
+      continue;
+    }
+    const missing = msg.toolCalls.filter((call) => !answered.has(call.id));
+    if (missing.length === 0) {
+      continue;
+    }
+    messages.splice(
+      i + 1,
+      0,
+      ...missing.map((call, n) => ({
+        content: UNANSWERED_TOOL_RESULT,
+        id: `sealed_${call.id}_${n}`,
+        role: "tool" as const,
+        timestamp: msg.timestamp,
+        toolCallId: call.id,
+      })),
+    );
+    sealed += missing.length;
+  }
+
+  return { dropped, sealed };
+}

package/src/services/document-assistant.ts

@@ -20,15 +20,18 @@ import type { Tab } from "../tabs/tab";
 import { componentRegistry } from "../files/components";
 import { activeRegistry } from "../commands/active-registry";
 import { registerAiTools } from "./ai-tools";
+import { cancelAsk, registerAskTool, resetAsk } from "./ai-ask";
 import { registerProjectTools } from "./ai-project-tools";
+import { registerImportTools, resetImportGuard } from "./ai-import-tools";
 import { createGatedToolRegistry } from "./gated-registry";
 import type { ToolAvailability } from "./gated-registry";
 import { adoptProject } from "./project-adoption";
+import { abortImportRun, resetImportRuns } from "./import-run";
 import { runAgentLoop } from "./tool-executor";
-import { AI_TOOL_TIERS, buildSystemPrompt, tierActive } from "./ai-system-prompt";
+import { AI_TOOL_TIERS, buildSystemPrompt, toolActive } from "./ai-system-prompt";
 import { getBaseUrl, getOpenAiKey } from "./ai-settings";
 import { preferredModel } from "./ai-models";
-import { trimContext } from "./context-manager";
+import { pruneOrphanToolMessages, trimContext } from "./context-manager";
 import { renderCheck } from "./render-critic";
 import { openFileInTab, reloadFileInTab } from "../files/files";
 import { refreshExtensionUi } from "../format/format-host";
@@ -77,6 +80,8 @@ export function createDocumentAssistant() {
   };
 
   const innerRegistry = createToolRegistry();
+  // Ungated: a question is not a function of what happens to be open.
+  registerAskTool(innerRegistry);
   registerAiTools(innerRegistry, {
     getTab: () => activeTab.value,
     saveFile: async (relPath: string, content: string) => {
@@ -91,6 +96,17 @@ export function createDocumentAssistant() {
     findOpenTab,
     reloadTab: reloadFileInTab,
   });
+  registerImportTools(innerRegistry, {
+    adoptProject,
+    getTab: () => activeTab.value,
+    // Same re-keying as `create_project`: an import bootstraps a project, so the bootstrap
+    // Conversation has to follow it out of the unscoped store.
+    onProjectAdopted: (root: string) => {
+      if (sessionId) {
+        sessionStore.moveSession("", root, sessionId);
+      }
+    },
+  });
   registerProjectTools(innerRegistry, {
     getTab: () => activeTab.value,
     renderCheck: renderCheck as (
@@ -126,6 +142,9 @@ export function createDocumentAssistant() {
    * every agent-loop round, so a mid-loop create_project unlocks the higher tiers immediately.
    */
   const TIER_REQUIREMENTS = {
+    /* Never refused, so the sentence is unreachable — it exists because the map is derived from
+       the tier union, and a tier without one would not compile. */
+    always: "nothing",
     "no-project": "no project to be open (it bootstraps one)",
     project: "an open project",
     document: "an open document (use open_document first)",
@@ -155,12 +174,18 @@ export function createDocumentAssistant() {
       t.name,
       {
         when: () =>
-          tierActive(t.tier, {
+          toolActive(t, {
+            /* The platform's own answer, read live rather than captured: the assistant is
+               constructed at module load, before a platform is registered in some hosts. */
+            canImport: Boolean(getPlatform().importSite),
             hasDocument: Boolean(activeTab.value),
             hasProject: Boolean(workspace.projectRoot),
             treeEditable: treeEditable(),
           }),
-        requires: TIER_REQUIREMENTS[t.tier],
+        requires:
+          t.capability === "importSite"
+            ? "a platform with a site-import backend"
+            : TIER_REQUIREMENTS[t.tier],
       },
     ]),
   );
@@ -182,6 +207,7 @@ export function createDocumentAssistant() {
       components: componentRegistry.length > 0 ? componentRegistry : undefined,
       projectRoot: workspace.projectRoot || undefined,
       hasProject: Boolean(workspace.projectRoot),
+      canImport: Boolean(getPlatform().importSite),
       ...(inventory && inventory.length > 0 ? { fileInventory: inventory } : {}),
     });
   }
@@ -205,6 +231,11 @@ export function createDocumentAssistant() {
       chatState.setTokenCount(trimmed.estimatedTokens);
     }
 
+    /* AFTER the trim, not before: the trim splices from the front and is itself one of the three
+       ways a tool_calls request loses its reply (see pruneOrphanToolMessages). Repairing first
+       would leave the very pair the trim then broke. */
+    pruneOrphanToolMessages(chatState);
+
     // Persist after trimming so the saved history reflects what's actually sent.
     persistChat();
 
@@ -248,11 +279,19 @@ export function createDocumentAssistant() {
 
   function stop() {
     controller?.abort();
+    /* The abort settles an outstanding question through the turn signal, but only when the turn
+       HAS one — the evals runner and several tests drive the loop without. Settling here as well
+       is what makes Stop terminal in every case rather than in most of them. */
+    cancelAsk();
+    abortImportRun();
     chatState.cancelStream();
   }
 
   function newChat() {
     stop();
+    resetAsk();
+    resetImportRuns();
+    resetImportGuard();
     chatState.clearChat();
     sessionId = null;
     sessionStore.setActiveSession(projectRoot(), null);
@@ -272,6 +311,7 @@ export function createDocumentAssistant() {
       return;
     }
     stop();
+    resetAsk();
     chatState.clearChat();
     pushRestoredMessages(msgs);
     sessionId = id;
@@ -283,6 +323,7 @@ export function createDocumentAssistant() {
     sessionStore.deleteSession(projectRoot(), id);
     if (sessionId === id) {
       stop();
+      resetAsk();
       chatState.clearChat();
       sessionId = null;
     }

package/src/services/import-client.ts

@@ -3,11 +3,21 @@
  * streaming fetch to some URL" — the dev server posts to its own origin, the desktop platforms post
  * to their token-gated loopback servers — so the request/parse/settle logic lives here once.
  *
- * The endpoint emits one JSON object per line: `progress` lines (forwarded to onProgress),
- * `heartbeat` keep-alives (ignored), and a terminal `done` ({root, config}) or `error` line.
+ * The endpoint emits one JSON object per line: `progress` lines (forwarded to onProgress), a
+ * `ready` line the moment the destination is an openable project (forwarded to onReady),
+ * `heartbeat` keep-alives (ignored), and a terminal `done` ({root, config, result}) or `error`
+ * line. `result` is optional — a backend that does not send one is not broken, and every caller
+ * treats its absence as "the run happened, and it did not say what it found". `ready` is optional
+ * for the same reason: an older backend simply never sends one, and the caller opens the project at
+ * the end as it always did.
  */
 
-import type { ImportProgressEvent, ImportSiteOptions } from "../types";
+import type {
+  ImportProgressEvent,
+  ImportReadyEvent,
+  ImportSiteOptions,
+  ImportSiteSummary,
+} from "../types";
 import type { ProjectConfig } from "@jxsuite/schema/types";
 
 /**
@@ -27,6 +37,7 @@ interface StreamLine {
   total?: number;
   root?: string;
   config?: ProjectConfig;
+  result?: ImportSiteSummary;
   error?: string;
 }
 
@@ -37,13 +48,17 @@ interface StreamLine {
  * @param {ImportSiteOptions} opts — the import request; `apiKey`/`baseUrl` travel as headers
  * @param {(evt: ImportProgressEvent) => void} onProgress
  * @param {AbortSignal} [signal]
+ * @param {(evt: ImportReadyEvent) => void} [onReady] — fires once, as soon as the destination holds
+ *   an openable project. Minutes before `done` on a real crawl, which is the whole reason it
+ *   exists.
  */
 export async function streamImport(
   endpoint: string,
   opts: ImportSiteOptions,
   onProgress: (evt: ImportProgressEvent) => void,
   signal?: AbortSignal,
-): Promise<{ root: string; config: ProjectConfig }> {
+  onReady?: (evt: ImportReadyEvent) => void,
+): Promise<{ root: string; config: ProjectConfig; result?: ImportSiteSummary }> {
   const headers: Record<string, string> = { "Content-Type": "application/json" };
   if (opts.apiKey) {
     headers["X-Api-Key"] = opts.apiKey;
@@ -59,7 +74,13 @@ export async function streamImport(
       depth: opts.depth,
       maxPages: opts.maxPages,
       aiComponents: opts.aiComponents,
+      ...(opts.breakpoints === undefined ? {} : { breakpoints: opts.breakpoints }),
       ...(opts.model === undefined ? {} : { aiModel: opts.model }),
+      ...(opts.verify === undefined ? {} : { verify: opts.verify }),
+      ...(opts.verifyThreshold === undefined ? {} : { verifyThreshold: opts.verifyThreshold }),
+      ...(opts.verifyMinFidelity === undefined
+        ? {}
+        : { verifyMinFidelity: opts.verifyMinFidelity }),
     }),
     headers,
     method: "POST",
@@ -85,7 +106,7 @@ export async function streamImport(
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
-  let result: { root: string; config: ProjectConfig } | null = null;
+  let result: { root: string; config: ProjectConfig; result?: ImportSiteSummary } | null = null;
   /*
    * Lines the parser could not read. Tolerating one is right — an import that ran for two minutes
    * should not die on a garbled progress line — but doing it *silently* is not: the import then
@@ -113,8 +134,14 @@ export async function streamImport(
         ...(parsed.current === undefined ? {} : { current: parsed.current }),
         ...(parsed.total === undefined ? {} : { total: parsed.total }),
       });
+    } else if (parsed.type === "ready" && parsed.root !== undefined) {
+      onReady?.({ root: parsed.root });
     } else if (parsed.type === "done" && parsed.root !== undefined && parsed.config) {
-      result = { root: parsed.root, config: parsed.config };
+      result = {
+        root: parsed.root,
+        config: parsed.config,
+        ...(parsed.result === undefined ? {} : { result: parsed.result }),
+      };
     } else if (parsed.type === "error") {
       throw new Error(parsed.error || "Import failed");
     }