@jxsuite/studio 3.0.0 → 4.1.0

package/src/services/ai-project-tools.ts

@@ -20,8 +20,9 @@ import type { ToolRegistry, ToolResult } from "@jxsuite/ai/tools";
 import type { JxMutableNode, ProjectConfig } from "@jxsuite/schema/types";
 import { getPlatform } from "../platform";
 import { workspace } from "../workspace/workspace";
+import { projectState } from "../store";
 import type { Tab } from "../tabs/tab";
-import { beginBatch, endBatch, isBatching } from "../tabs/transact";
+import { adoptCreatedProject } from "./project-adoption";
 import { translateValidationError } from "./ai-tools";
 import { validateDoc, validateProjectConfig } from "./jx-validate";
 import { recordWrite } from "./ai-writes";
@@ -355,8 +356,16 @@ export function registerProjectTools(
           /* The per-project entry document closes the composition over every enabled extension
              (extensions.md §5.2), so this is what catches a typo'd section key or a misshapen
              extension section. Without it the model shipped config its own tool call called clean
-             and Monaco flagged the moment a human opened the file. */
-          const configErrors = await validateProject(parsedConfig);
+             and Monaco flagged the moment a human opened the file.
+
+             Errors the file ALREADY had are subtracted, the same way `services/ai-tools.ts`
+             subtracts them from a document edit: a project whose config was written by something
+             else — an importer, a hand edit, an extension that was removed — would otherwise refuse
+             every write the model attempted, blaming it for a violation it did not introduce and
+             cannot reach from the edit it was asked to make. */
+          const before = new Set(await validateProject(projectState?.projectConfig ?? {}));
+          const found = await validateProject(parsedConfig);
+          const configErrors = found.filter((error) => !before.has(error));
           if (configErrors.length > 0) {
             const formatted = configErrors
               .map((e) => `- ${translateValidationError(e)}`)
@@ -585,30 +594,15 @@ export function registerProjectTools(
         }
 
         /*
-         * Adoption runs the full project-open flow (closes all tabs, opens the home page). The
-         * agent loop may hold an undo batch on the pre-adoption tab — flush it first and re-open
-         * one on whatever tab adoption leaves active, mirroring open_document's batch dance.
-         */
-        const wasBatching = isBatching();
-        if (wasBatching) {
-          endBatch();
-        }
-        let adoptionError: string | null = null;
-        try {
-          await adoptProject(result.root);
-        } catch (error) {
-          adoptionError = error instanceof Error ? error.message : String(error);
-        }
-        if (wasBatching) {
-          beginBatch(getTab());
-        }
-
-        /*
-         * The adopter (openRecentProject) swallows failures into a status message, so a resolved
-         * promise is not proof of adoption — verify against the workspace before re-keying the
-         * chat session.
+         * Git init, then the full project-open flow, then a check that it landed — all three in
+         * `services/project-adoption.ts`, because `import_site` is the same act with a different
+         * backend. Git init in particular was missing here: `specs/desktop.md` §4.5 promises every
+         * create path initialises a repository, and only the New Project modal was keeping it.
          */
-        const adopted = workspace.projectRoot === result.root;
+        const { adopted, error: adoptionError } = await adoptCreatedProject(result.root, {
+          adopt: adoptProject,
+          getTab,
+        });
         if (adopted) {
           onProjectAdopted?.(result.root);
           return {

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

@@ -12,6 +12,7 @@
  */
 
 import type { createChatState } from "@jxsuite/ai/chat-state";
+import { modelContextWindow } from "./ai-models";
 
 /** Shape of a single entry returned by `chatState.toMessagesArray()`. */
 interface MessageArrayEntry {
@@ -52,7 +53,13 @@ const BUDGET_FRACTION = 0.8;
 const WARN_FRACTION = 0.5;
 
 /**
- * Resolve the context window (tokens) for a model id via longest-prefix match.
+ * Resolve the context window (tokens) for a model id: what the backend reported, else a
+ * longest-prefix match on the table above, else the conservative default.
+ *
+ * The backend's number goes first because the table can only ever know the names it was written
+ * with. Every `@cf/*` model missed it and was budgeted at {@link DEFAULT_CONTEXT_WINDOW}, so a
+ * managed 128k model started dropping the oldest turns at about 25.6k — a fifth of what it could
+ * hold, on the one backend that actually publishes the figure.
  *
  * @param {string | undefined} model
  * @returns {number}
@@ -61,6 +68,10 @@ function contextWindowFor(model: string | undefined): number {
   if (!model) {
     return DEFAULT_CONTEXT_WINDOW;
   }
+  const reported = modelContextWindow(model);
+  if (reported !== undefined && reported > 0) {
+    return reported;
+  }
   const id = model.toLowerCase();
   let best = 0;
   let window = DEFAULT_CONTEXT_WINDOW;
@@ -198,3 +209,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;
     }