@jxsuite/studio 8.1.0 → 9.0.0

package/src/services/ai-writes.ts

@@ -25,6 +25,9 @@
 import type { LiveMessage } from "@jxsuite/ai/messages";
 import { createLedger } from "@jxsuite/ai/tools";
 import type { AiWrite, WriteLedger } from "@jxsuite/ai/tools";
+import { undo } from "../tabs/transact";
+import type { BatchReceipt } from "../tabs/transact";
+import type { Tab } from "../tabs/tab";
 
 export type { AiWrite } from "@jxsuite/ai/tools";
 
@@ -33,6 +36,8 @@ export interface AiTurn {
   /** The id of the assistant message the turn produced — how the panel finds its own ledger. */
   id: string;
   writes: AiWrite[];
+  /** Where each of the turn's undo steps landed, oldest first: what Restore takes back. */
+  batches: BatchReceipt[];
 }
 
 /** Completed turns, oldest first. Bounded: a session's history is the session store's job. */
@@ -70,13 +75,18 @@ export function openTurnLedger(turnId: string): TurnLedger {
  *
  * @param {string} anchor - The message the turn's changes are drawn under
  * @param {readonly AiWrite[]} writes - The turn's ledger
+ * @param {readonly BatchReceipt[]} [batches] - The receipts its batch lane returned on close
  * @returns {AiWrite[]} What was filed
  */
-export function fileTurn(anchor: string, writes: readonly AiWrite[]): AiWrite[] {
+export function fileTurn(
+  anchor: string,
+  writes: readonly AiWrite[],
+  batches: readonly BatchReceipt[] = [],
+): AiWrite[] {
   if (writes.length === 0) {
     return [];
   }
-  const turn: AiTurn = { id: anchor, writes: [...writes] };
+  const turn: AiTurn = { batches: [...batches], id: anchor, writes: [...writes] };
   turns.push(turn);
   while (turns.length > MAX_TURNS) {
     turns.shift();
@@ -95,6 +105,78 @@ export function writesForTurn(id: string): AiWrite[] {
   return turns.find((turn) => turn.id === id)?.writes ?? [];
 }
 
+/**
+ * Undo every step one turn left, across every document it wrote, or nothing at all.
+ *
+ * `ai.md` §3.2. The turn's batch lane closed one step per document it wrote (two when a person's
+ * edit split it), and each receipt names its entry. A step is taken back only while it is the top
+ * of its tab's history, newest first, so Restore never undoes an edit that is not the turn's: a
+ * person's edit made since, a step already undone, a closed tab or a shared document whose undo the
+ * session owns each refuse the whole Restore with a sentence naming the document. Every receipt is
+ * checked before anything is undone, because a Restore that took back SOME of a turn would be worse
+ * than one that refused.
+ *
+ * @param {string} id - The message the turn is filed under
+ * @returns {string | Tab[]} Why it refused, or the tabs it undid
+ */
+export function restoreTurn(id: string): string | Tab[] {
+  const turn = turns.find((filed) => filed.id === id);
+  const lost = "There is no longer a record of what that turn changed.";
+  if (!turn) {
+    return lost;
+  }
+  const disk = turn.writes.filter((w) => w.disk).map((w) => w.path);
+  if (disk.length > 0) {
+    return (
+      `Cannot restore: ${disk.join(", ")} ${disk.length === 1 ? "was" : "were"} written straight ` +
+      "to disk, which undo cannot reach."
+    );
+  }
+  if (turn.batches.length === 0) {
+    return lost;
+  }
+  const byTab = new Map<Tab, BatchReceipt[]>();
+  for (const receipt of turn.batches) {
+    byTab.set(receipt.tab, [...(byTab.get(receipt.tab) ?? []), receipt]);
+  }
+  for (const [tab, receipts] of byTab) {
+    const refusal = refuseTab(tab, receipts);
+    if (refusal) {
+      return refusal;
+    }
+  }
+  for (const [tab, receipts] of byTab) {
+    for (const _ of receipts) {
+      undo(tab);
+    }
+  }
+  return [...byTab.keys()];
+}
+
+/** Why `tab`'s steps from one turn cannot be undone, or null when they are its newest entries. */
+function refuseTab(tab: Tab, receipts: readonly BatchReceipt[]): string | null {
+  const path = tab.documentPath ?? "(untitled)";
+  if (tab.scope.active === false) {
+    return `Cannot restore: ${path} was closed after that turn.`;
+  }
+  if (receipts.some((receipt) => receipt.entry === null)) {
+    return (
+      `Cannot restore: ${path} is shared live, and Restore cannot check its undo history. ` +
+      "Undo it in the document instead."
+    );
+  }
+  const { index, snapshots } = tab.history;
+  const top = snapshots.slice(index - receipts.length + 1, index + 1);
+  const matches =
+    index - receipts.length >= 0 && receipts.every((receipt, at) => top[at] === receipt.entry);
+  if (matches) {
+    return null;
+  }
+  return snapshots.indexOf(receipts.at(-1)!.entry!) > index
+    ? `Cannot restore: that turn's change to ${path} was already undone.`
+    : `Cannot restore: ${path} has edits made since that turn began, which Restore would undo too.`;
+}
+
 /**
  * The one-line summary the panel puts above the expander.
  *

package/src/services/document-assistant.ts

@@ -22,21 +22,17 @@ 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 {
-  commandToolBlurbs,
-  composeToolRegistries,
-  createCommandToolRegistry,
-} from "./ai-command-tools";
+import { registerAskTool } from "./ai-ask";
+import { createInteractionStore } from "./harness/interaction-store";
+import { commandToolBlurbs, createCommandToolRegistry } from "./ai-command-tools";
 import { registerProjectTools } from "./ai-project-tools";
 import { registerImportTools } from "./ai-import-tools";
-import { createGatedToolRegistry } from "./gated-registry";
-import type { ToolAvailability } from "./gated-registry";
+import { assistantToolRegistry } from "./harness/assistant-tools";
 import { adoptProject } from "./project-adoption";
 import { resetAiWrites } from "./ai-writes";
 import { abortImportRun, resetImportRuns } from "./import-run";
 import { runAgentLoop } from "./tool-executor";
-import { AI_TOOL_TIERS, buildSystemPrompt, toolActive } from "./ai-system-prompt";
+import { buildSystemPrompt } from "./ai-system-prompt";
 import type { ExtensionCatalogSummary } from "./ai-system-prompt";
 import { getBaseUrl, getOpenAiKey } from "./ai-settings";
 import { preferredModel } from "./ai-models";
@@ -79,6 +75,7 @@ const probeRender = renderCheck as (doc: CandidateDocument) => Promise<RenderVer
  *
  * @returns {{
  *   chatState: ReturnType<typeof createChatState>;
+ *   interactions: import("./harness/interaction-store").InteractionStore;
  *   sendMessage: (text: string) => Promise<void>;
  *   stop: () => void;
  *   newChat: () => void;
@@ -111,12 +108,18 @@ export function createDocumentAssistant() {
     return null;
   };
 
+  /* Where a turn waits on the author: a question is put here, and the panel answers it. A question
+     suspends the turn for as long as they like, and the conversation is otherwise saved only when a
+     turn starts and ends; saving once it is pending is what lets a reload find the question to
+     restore as open rather than losing the whole unfinished turn. */
+  const interactions = createInteractionStore({ onPending: () => persistChat() });
+
   const innerRegistry = createToolRegistry();
   // Ungated: a question is not a function of what happens to be open.
   /* A question suspends the turn on the author, for as long as they like, and the conversation is
      otherwise saved only when a turn starts and ends. Saving here is what lets a reload find the
      question to restore as open rather than losing the whole unfinished turn. */
-  registerAskTool(innerRegistry, { onPending: () => persistChat() });
+  registerAskTool(innerRegistry);
   registerAiTools(innerRegistry, {
     getTab: () => activeTab.value,
     saveFile: async (relPath: string, content: string) => {
@@ -130,7 +133,6 @@ export function createDocumentAssistant() {
   });
   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) => {
@@ -140,7 +142,6 @@ export function createDocumentAssistant() {
     },
   });
   registerProjectTools(innerRegistry, {
-    getTab: () => activeTab.value,
     renderCheck: probeRender,
     getProjectStyle,
     findOpenTab,
@@ -169,24 +170,6 @@ export function createDocumentAssistant() {
     },
   });
 
-  /*
-   * Gate tool advertisement/execution on live studio state, derived from the same tier table the
-   * system prompt renders — the model is never shown a tool it cannot execute. listForLLM() runs
-   * 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)",
-    "document-tree":
-      "an open document whose element tree the canvas is editing — Project Settings and the " +
-      "grid editors are documents, but not trees to restructure, and a page left in Code view " +
-      "returns to the canvas with set_canvas_mode",
-  } as const;
-
   /**
    * The HUMAN's own gate, read rather than reimplemented.
    *
@@ -203,26 +186,6 @@ export function createDocumentAssistant() {
     // The agent than for the person is the divergence this is here to remove.
     return registry ? registry.context().editor.kind === "canvas" : true;
   };
-  const availability = new Map<string, ToolAvailability>(
-    AI_TOOL_TIERS.map((t) => [
-      t.name,
-      {
-        when: () =>
-          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:
-          t.capability === "importSite"
-            ? "a platform with a site-import backend"
-            : TIER_REQUIREMENTS[t.tier],
-      },
-    ]),
-  );
   /*
    * The other kind of tool: every command record that declares `aiTool`, as a VIEW over the active
    * registry (`services/ai-command-tools.ts`). Nothing is registered — the record IS the tool, its
@@ -237,10 +200,16 @@ export function createDocumentAssistant() {
     renderCheck: probeRender,
     validate: validateDoc,
   });
-  const toolRegistry = composeToolRegistries(
-    createGatedToolRegistry(innerRegistry, availability),
-    commandTools,
-  );
+  /* The hand tools gated on live studio state, then the command tools. The state is read on every
+     listing, so a mid-loop create_project unlocks the higher tiers the very next round. */
+  const toolRegistry = assistantToolRegistry(innerRegistry, commandTools, () => ({
+    /* 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(),
+  }));
 
   let controller: AbortController | null = null;
 
@@ -378,6 +347,7 @@ export function createDocumentAssistant() {
         signal,
         session: sessionFacts,
         getTab: () => activeTab.value,
+        interactions,
       });
     } catch (error) {
       /*
@@ -419,14 +389,14 @@ export function createDocumentAssistant() {
     /* 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();
+    interactions.cancel();
     abortImportRun();
     chatState.cancelStream();
   }
 
   function newChat() {
     stop();
-    resetAsk();
+    interactions.reset();
     resetImportRuns();
     /* The record of what each turn changed is drawn under that turn's message; with the messages
        gone there is nothing to draw it under, and a Restore offered from it would undo whatever
@@ -452,7 +422,7 @@ export function createDocumentAssistant() {
       return;
     }
     stop();
-    resetAsk();
+    interactions.reset();
     chatState.clearChat();
     pushRestoredMessages(msgs);
     sessionId = id;
@@ -464,7 +434,7 @@ export function createDocumentAssistant() {
     sessionStore.deleteSession(projectRoot(), id);
     if (sessionId === id) {
       stop();
-      resetAsk();
+      interactions.reset();
       chatState.clearChat();
       sessionId = null;
     }
@@ -527,6 +497,7 @@ export function createDocumentAssistant() {
 
   return {
     chatState,
+    interactions,
     isTurnActive,
     sendMessage,
     whenTurnEnds,

package/src/services/harness/assistant-tools.ts

@@ -0,0 +1,68 @@
+/**
+ * Assistant-tools.ts — the one registry the assistant's turn reads its tools from.
+ *
+ * Two kinds of tool reach the model: the hand-registered ones, gated by the tier table
+ * (`AI_TOOL_TIERS`), and the projections of every command record that declares `aiTool`, gated by
+ * the record (`services/ai-command-tools.ts`). This is where they meet, for the document assistant
+ * and for the eval runner alike, so both offer the model the same tools in the same state.
+ *
+ * @license MIT
+ */
+
+import { catalogRegistry, createCatalog } from "@jxsuite/ai/catalog";
+import type { ToolRegistry } from "@jxsuite/ai/tools";
+import type { CommandToolRegistry } from "../ai-command-tools";
+import { AI_TOOL_TIERS, toolActive } from "../ai-system-prompt";
+import type { AiToolState, AiToolTier } from "../ai-system-prompt";
+
+/**
+ * What each tier requires, as the sentence a refused call ends with. The model reads it, so it is
+ * phrased as what to do as much as what is missing.
+ */
+export const TIER_REQUIREMENTS: Readonly<Record<AiToolTier, string>> = {
+  /* 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)",
+  "document-tree":
+    "an open document whose element tree the canvas is editing — Project Settings and the " +
+    "grid editors are documents, but not trees to restructure, and a page left in Code view " +
+    "returns to the canvas with set_canvas_mode",
+};
+
+/**
+ * The assistant's tools as one catalog (specs/ai.md §3.10): the hand tools, then the command
+ * records' projections. Membership is every tool either side has, rebuilt per call because the
+ * command side is a view over whichever command registry is active. A hand tool is gated on live
+ * studio state by the same tier table the system prompt renders, so the model is never shown a tool
+ * it cannot execute; a command tool is offered while its record is, and its record refuses a call
+ * itself. The state is read on every listing, and `listForLLM()` runs every agent-loop round, so a
+ * mid-loop `create_project` unlocks the higher tiers immediately.
+ *
+ * @param {ToolRegistry} hand - The hand-registered tools
+ * @param {CommandToolRegistry} commands - The command records' projections
+ * @param {() => AiToolState} state - The studio facts a tier is decided by, read live
+ * @returns {ToolRegistry}
+ */
+export function assistantToolRegistry(
+  hand: ToolRegistry,
+  commands: CommandToolRegistry,
+  state: () => AiToolState,
+): ToolRegistry {
+  const tiers = new Map(AI_TOOL_TIERS.map((tool) => [tool.name, tool]));
+  return catalogRegistry(() => createCatalog(hand.list(), commands.members()), {
+    advertise: (entry) =>
+      hand.getDefinition(entry.name) !== undefined || commands.advertises(entry.name),
+    gate(entry) {
+      const tool = tiers.get(entry.name);
+      if (!tool || toolActive(tool, state())) {
+        return null;
+      }
+      return tool.capability === "importSite"
+        ? "a platform with a site-import backend"
+        : TIER_REQUIREMENTS[tool.tier];
+    },
+  });
+}

package/src/services/harness/interaction-store.ts

@@ -0,0 +1,118 @@
+/**
+ * Interaction-store.ts — where a turn waits on the author (specs/ai.md §3.4 and §3.11).
+ *
+ * A call that needs a person (`ask_user`'s question) never runs a tool body that awaits them: the
+ * invoker answers `needs_input`, the turn engine hands the request to this store's inline strategy,
+ * and the turn waits on the promise it returns. The panel reads `pending` to draw the question in
+ * its chip and the composer, and settles it with `answer`, `skip` or, on Stop, `cancel`. The answer
+ * goes back to the invoker, which gives it to the tool's `settle`, so it travels as the tool result
+ * and never as a user message.
+ *
+ * Exactly one interaction can be pending, because a turn runs its calls one at a time and a window
+ * runs one turn.
+ *
+ * @license MIT
+ */
+
+import type { InteractionStrategy } from "@jxsuite/ai/harness";
+import type { InteractionRequest, InteractionResponse } from "@jxsuite/ai/tools";
+import { reactive } from "../../reactivity";
+
+/** What a turn is waiting on. `callId` is the call's id, so the chip and the request agree. */
+export interface PendingInteraction {
+  readonly callId: string;
+  readonly request: InteractionRequest;
+}
+
+/** The author's side of a turn that is waiting on them. */
+export interface InteractionStore {
+  /** What the turn is waiting on, or null. Reactive: read it inside an `effect()`. */
+  readonly pending: PendingInteraction | null;
+  /** The strategy a turn resolves its interactions through. */
+  readonly strategy: InteractionStrategy;
+  /** Answer the pending question. False when nothing is pending. */
+  readonly answer: (text: string) => boolean;
+  /** Decline to answer ("you decide"), which settles as a success. False when nothing is pending. */
+  readonly skip: () => boolean;
+  /** Settle the pending interaction as unanswered, as a stopped turn does. */
+  readonly cancel: () => void;
+  /** Drop the pending interaction, settling its turn as unanswered. */
+  readonly reset: () => void;
+}
+
+/** What the host may hook. */
+export interface InteractionStoreOptions {
+  /**
+   * Called once a request is pending, before the turn waits on it. A host saves the conversation
+   * here: a turn waiting on a person may wait for as long as they like, and a reload in the
+   * meantime must still find the question to restore as open.
+   */
+  readonly onPending?: () => void;
+}
+
+/** The answer a stopped turn gives: a question unanswered and not skipped, an approval refused. */
+function unanswered(request: InteractionRequest): InteractionResponse {
+  return request.kind === "question"
+    ? { answer: null, kind: "question", skipped: false }
+    : { approved: false, kind: "approval" };
+}
+
+/**
+ * A store with nothing pending.
+ *
+ * @param {InteractionStoreOptions} [options]
+ * @returns {InteractionStore}
+ */
+export function createInteractionStore({
+  onPending,
+}: InteractionStoreOptions = {}): InteractionStore {
+  const state = reactive<{ pending: PendingInteraction | null }>({ pending: null });
+  /** The settler for the pending request, kept out of the reactive object (it is not render data). */
+  let settle: ((response: InteractionResponse) => void) | null = null;
+  /** Torn down with the request, so a stopped turn leaves no listener on a dead signal. */
+  let detachAbort: (() => void) | null = null;
+
+  /** Clear the pending request and settle its turn with `response`; false when none is pending. */
+  function finish(response: (request: InteractionRequest) => InteractionResponse): boolean {
+    const resolve = settle;
+    const { pending } = state;
+    if (!resolve || !pending) {
+      return false;
+    }
+    state.pending = null;
+    settle = null;
+    detachAbort?.();
+    detachAbort = null;
+    resolve(response(pending.request));
+    return true;
+  }
+
+  function cancel(): void {
+    finish(unanswered);
+  }
+
+  return {
+    get pending() {
+      return state.pending;
+    },
+    strategy: {
+      mode: "inline",
+      resolve: (request, { callId, signal }) =>
+        new Promise<InteractionResponse>((resolve) => {
+          if (signal.aborted) {
+            resolve(unanswered(request));
+            return;
+          }
+          state.pending = { callId, request };
+          settle = resolve;
+          signal.addEventListener("abort", cancel, { once: true });
+          detachAbort = () => signal.removeEventListener("abort", cancel);
+          onPending?.();
+        }),
+    },
+    answer: (text) => finish(() => ({ answer: text, kind: "question", skipped: false })),
+    skip: () => finish(() => ({ answer: null, kind: "question", skipped: true })),
+    cancel,
+    reset: cancel,
+  };
+}

package/src/services/harness/studio-documents.ts

@@ -0,0 +1,105 @@
+/**
+ * Studio-documents.ts — the open tab as a `DocumentHost` for the portable tree tools (specs/ai.md
+ * §3.9).
+ *
+ * The producers in `@jxsuite/ai/jx-tools` plan an edit as doc ops; this host resolves the call to
+ * the active tab, hands the producer the raw document, and applies its ops through
+ * `applyDocOpsAsUser`, so an assistant edit is an ordinary transaction: the gate, the turn's batch
+ * lane, history, the canvas patch and the collab observer all see it the way they see the
+ * person's.
+ *
+ * @license MIT
+ */
+
+import type { DocumentHost, DocumentRef, WriteReporter } from "@jxsuite/ai/jx-tools";
+import { FROZEN_SENTENCE } from "@jxsuite/ai/jx-tools";
+import { toRaw } from "../../reactivity";
+import type { Tab } from "../../tabs/tab";
+import { applyDocOpsAsUser } from "../../tabs/transact";
+import { reportDocumentWrite, snapshotBeforeWrite } from "../ai-write-report";
+import type { WriteReportDeps, WriteSnapshot } from "../ai-write-report";
+
+/** What a tree tool reads when no document is open. */
+export const NO_DOCUMENT_SENTENCE =
+  "No document is open — use open_document(path) to open one on the canvas, or " +
+  "read_file/write_file to work with project files directly.";
+
+/** A {@link DocumentHost} over Studio's tabs, which can also name the tab behind a ref. */
+export interface StudioDocumentHost extends DocumentHost {
+  /** The tab `ref` was resolved to, or null for a ref this host never issued. */
+  readonly tabOf: (ref: DocumentRef) => Tab | null;
+}
+
+/**
+ * The host the tree tools edit through. A call is pinned to the tab active when it began: a ref
+ * holds that tab for the whole call, so a person switching tabs during the call's validation does
+ * not redirect its write.
+ *
+ * @param {{ getTab: () => Tab | null }} deps
+ * @returns {StudioDocumentHost}
+ */
+export function studioDocumentHost({ getTab }: { getTab: () => Tab | null }): StudioDocumentHost {
+  const tabs = new WeakMap<DocumentRef, Tab>();
+
+  function tabOf(ref: DocumentRef): Tab | null {
+    return tabs.get(ref) ?? null;
+  }
+
+  return {
+    edit(ref, produce, { actor }) {
+      const tab = tabOf(ref);
+      if (!tab) {
+        return { applied: false, message: NO_DOCUMENT_SENTENCE, reason: "not-open" };
+      }
+      // Planned and applied in one synchronous step, against the raw tree (never the proxy).
+      const edit = produce(toRaw(tab.doc.document));
+      if (!edit.ok) {
+        return { applied: false, message: edit.error, reason: "refused" };
+      }
+      /* Named, not inferred: the write joins the turn's batch lane by its actor (specs/ai.md §3.3).
+         A refusal is the collab gate pausing structural edits while source is canonical, which the
+         model must be told rather than congratulated on. */
+      const outcome = applyDocOpsAsUser(tab, edit.ops, { actor, selection: edit.selection });
+      if (outcome === "refused") {
+        return { applied: false, message: FROZEN_SENTENCE, reason: "frozen" };
+      }
+      return { applied: true, changed: outcome === "applied" };
+    },
+    resolve() {
+      const tab = getTab();
+      if (!tab) {
+        return NO_DOCUMENT_SENTENCE;
+      }
+      const ref: DocumentRef = { id: tab.id, path: tab.documentPath ?? null };
+      tabs.set(ref, tab);
+      return ref;
+    },
+    snapshot(ref) {
+      /* SAFETY: every ref a tree tool snapshots came from `resolve` on this host in the same call,
+         and `resolve` registers the tab before it returns the ref. */
+      return toRaw(tabOf(ref)!.doc.document);
+    },
+    tabOf,
+    undoable: "document",
+  };
+}
+
+/**
+ * The write verdict (`ai-write-report.ts`) as a reporter: the schema errors and render state before
+ * the write, and the new errors, the render check and the token hints after it.
+ *
+ * @param {StudioDocumentHost} host
+ * @param {WriteReportDeps} deps
+ * @returns {WriteReporter<WriteSnapshot>}
+ */
+export function studioWriteReporter(
+  host: StudioDocumentHost,
+  deps: WriteReportDeps,
+): WriteReporter<WriteSnapshot> {
+  return {
+    /* SAFETY (both): the entries bracket only a write whose ref `resolve` issued in the same call,
+       so the host still holds its tab. */
+    after: (ref, before, summary) => reportDocumentWrite(host.tabOf(ref)!, before, summary, deps),
+    before: (ref) => snapshotBeforeWrite(host.tabOf(ref)!, deps),
+  };
+}

package/src/services/harness/turn-hooks.ts

@@ -13,8 +13,6 @@ export interface StudioTurnHookDeps {
   superseded: () => boolean;
   /** Called once a call settles into a transcript that replaced the turn's own. */
   onSuperseded: () => void;
-  /** Re-anchor the undo batch on the document the tools now edit (specs/ai.md §3.3). */
-  reanchor: () => void;
 }
 
 /**
@@ -22,8 +20,7 @@ export interface StudioTurnHookDeps {
  *
  * - **After each call**, a turn whose conversation has been replaced stops there: its reply belongs
  *   to a request that is no longer on screen, and writing it would land a stray `tool` message in
- *   the other conversation. Otherwise the undo batch follows the document the tools moved to, which
- *   a tool, project adoption or the author clicking another tab can each change.
+ *   the other conversation.
  * - **On a stream error**, a lapsed hosted grant (`cf_reconnect_required`) drops the model reading
  *   and re-probes (specs/ai.md §2.1): the probe settles once at boot, so without this every gate
  *   keeps offering an assistant that cannot answer, and the failed send is the only evidence.
@@ -36,9 +33,7 @@ export function studioTurnHooks(deps: StudioTurnHookDeps): TurnHooks {
     afterTool() {
       if (deps.superseded()) {
         deps.onSuperseded();
-        return;
       }
-      deps.reanchor();
     },
     onStreamError(error) {
       if (error.code === "cf_reconnect_required") {