@jskit-ai/assistant-runtime 0.2.9 → 0.2.10

package/test/chatServiceLifecycle.test.js

@@ -4,6 +4,7 @@ import test from "node:test";
 import { createChatService } from "../src/server/services/chatService.js";
 import { createAssistantConversationRuntime } from "../src/server/createAssistantRuntime.js";
 import { createMemoryAssistantRows } from "./support/memoryAssistantRows.js";
+import { createScriptedModel } from "./support/scriptedModel.js";
 
 const APP_CONFIG = Object.freeze({
   surfaceDefinitions: {
@@ -73,7 +74,8 @@ async function* completionStream(completion = {}) {
   yield { choices: [{ delta: {}, finish_reason: completion.toolCall ? "tool_calls" : "stop" }] };
 }
 
-function createHarness(completions, { executeToolCall = null, tools: configuredTools = null, attachments, supportsAttachments = true, wrapRuntime = (runtime) => runtime } = {}) {
+function createHarness(completions, { executeToolCall = null, tools: configuredTools = null, attachments, supportsAttachments = true, wrapRuntime = (runtime) => runtime,
+  once } = {}) {
   const pendingCompletions = [...completions];
   const completionRequests = [];
   const transcriptMessages = [];
@@ -102,15 +104,15 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
           supportsAttachments,
           provider: "test",
           defaultModel: "test-model",
-          async createChatCompletionStream(request) {
+          model: createScriptedModel(body => {
             completionRequests.push({
-              messages: structuredClone(request.messages),
-              tools: structuredClone(request.tools)
+              messages: structuredClone(body.messages),
+              tools: structuredClone(body.tools)
             });
             const completion = pendingCompletions.shift();
             assert.ok(completion, "Expected a queued assistant completion.");
             return completion[Symbol.asyncIterator] ? completion : completionStream(completion);
-          }
+          }, { once })
         };
       }
     },
@@ -212,6 +214,11 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
   };
 }
 
+function messageText(message) {
+  return typeof message?.content === "string" ? message.content
+    : (message?.content || []).filter(part => part.type === "text").map(part => part.text).join("");
+}
+
 function assistantMessages(events) {
   return events
     .filter((event) => event.method === "sendAssistantMessage" && event.payload.status !== "streaming")
@@ -261,12 +268,12 @@ test("an empty authorized tool set does not advertise discovery or collection ac
   await harness.run("List the available records.");
 
   const request = harness.completionRequests[0];
-  assert.deepEqual(request.tools, []);
+  assert.equal(request.tools, undefined, "The model is offered no tools");
   assert.match(request.messages[0].content, /No tools are currently available for this user\/session/u);
   assert.doesNotMatch(request.messages[0].content, /assistant_action_search|collection action/u);
 });
 
-test("progress-only output is replaced on retry and current-time prompts require a workspace clock", async () => {
+test("a reply that only announces work carries on once, and the state note gives the time without a clock action", async () => {
   const harness = createHarness(
     [
       textCompletion("Let me query the current time."),
@@ -280,17 +287,10 @@ test("progress-only output is replaced on retry and current-time prompts require
           additionalProperties: false,
           properties: {}
         },
-        outputSchema: { type: "object" },
-        preflight: ["current-time"]
+        outputSchema: { type: "object" }
       }],
       executeToolCall() {
-        return {
-          ok: true,
-          result: {
-            localDateTime: "2026-08-25T11:15:00+08:00",
-            timeZone: "Australia/Perth"
-          }
-        };
+        return { ok: true, result: { localDateTime: "2026-08-25T11:15:00+08:00", timeZone: "Australia/Perth" } };
       }
     }
   );
@@ -298,27 +298,16 @@ test("progress-only output is replaced on retry and current-time prompts require
   const result = await harness.run("What day is it today?");
 
   assert.equal(result.status, "completed");
-  assert.deepEqual(harness.executedTools.map((request) => request.toolName), ["workspace_clock"]);
-  assert.equal(
-    harness.completionRequests[0].messages.some((message) => (
-      message.role === "tool" && /Australia\/Perth/u.test(message.content)
-    )),
-    true
-  );
+  assert.deepEqual(harness.executedTools, [], "No clock action runs before the model asks for one");
+  const system = harness.completionRequests[0].messages[0];
+  assert.equal(system.role, "system");
+  assert.match(system.content, /use the current time in the system's state note/u);
+  assert.match(system.content, /\n\nCurrent state, from the system\. It is the truth; earlier messages may be out of date:\n- The time: .+ UTC\./u,
+    "The state note at the end of the system prompt tells the model the current time");
+  assert.match(messageText(harness.completionRequests[1].messages.at(-1)), /^\(Check from the app: your reply ended by saying what you'd do next/u,
+    "The reply that only announced work carries on once with the engine's check");
   assert.deepEqual(assistantMessages(harness.streamEvents), ["It is Tuesday in the workspace timezone."]);
   assert.ok(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"));
-  assert.match(
-    harness.completionRequests[0].messages[0].content,
-    /first use any available authoritative workspace clock action/u
-  );
-  assert.equal(
-    harness.completionRequests[1].messages.some((message) => message.content === "Let me query the current time."),
-    false
-  );
-  assert.equal(
-    harness.completionRequests[1].messages.some((message) => /Either call the required available tool now/u.test(message.content)),
-    true
-  );
   assert.deepEqual(
     harness.transcriptMessages
       .filter((message) => message.kind === "chat")
@@ -327,50 +316,6 @@ test("progress-only output is replaced on retry and current-time prompts require
   );
 });
 
-test("current-time preflight does not run for unrelated prompts", async () => {
-  const harness = createHarness(
-    [textCompletion("There are three active bookings.")],
-    {
-      tools: [{
-        name: "workspace_clock",
-        parameters: { type: "object", properties: {} },
-        outputSchema: { type: "object" },
-        preflight: ["current-time"]
-      }]
-    }
-  );
-
-  await harness.run("How many active bookings are there?");
-
-  assert.deepEqual(harness.executedTools, []);
-  assert.deepEqual(assistantMessages(harness.streamEvents), ["There are three active bookings."]);
-});
-
-test("current-time preflight does not invent required tool input", async () => {
-  const harness = createHarness(
-    [textCompletion("Choose a timezone before asking for its local time.")],
-    {
-      tools: [{
-        name: "timezone_clock",
-        parameters: {
-          type: "object",
-          required: ["timeZone"],
-          properties: {
-            timeZone: { type: "string" }
-          }
-        },
-        outputSchema: { type: "object" },
-        preflight: ["current-time"]
-      }]
-    }
-  );
-
-  await harness.run("What time is it now?");
-
-  assert.deepEqual(harness.executedTools, []);
-  assert.deepEqual(assistantMessages(harness.streamEvents), ["Choose a timezone before asking for its local time."]);
-});
-
 test("native search, contract, and execution workflows stream progress across more than four tool rounds", async () => {
   const harness = createHarness([
     toolCompletion("action_search", 1, { text: "I'll search first." }),
@@ -389,88 +334,47 @@ test("native search, contract, and execution workflows stream progress across mo
   );
   assert.deepEqual(assistantMessages(harness.streamEvents), ["The requested operation completed successfully."]);
   assert.ok(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"));
-  const assistantToolMessages = harness.completionRequests
-    .flatMap((request) => request.messages)
-    .filter((message) => Array.isArray(message.tool_calls));
-  assert.ok(assistantToolMessages.length > 0);
-  assert.equal(assistantToolMessages.every((message) => message.content === ""), true);
+  const lastRequest = harness.completionRequests.at(-1).messages;
+  const assistantToolMessages = lastRequest.filter((message) => Array.isArray(message.tool_calls));
+  assert.equal(assistantToolMessages.length, 5);
+  assert.deepEqual(assistantToolMessages.map(message => message.content || ""),
+    ["I'll search first.", "Let me inspect that contract.", "I'll execute it now.", "", ""],
+    "Each step's words stay with its action calls in the model's history");
 });
 
-test("tool-loop exhaustion gives the concise new-conversation instruction", async () => {
-  const mainRounds = Array.from({ length: 16 }, (_, index) =>
-    toolCompletion("action_execute", index + 1)
-  );
+test("at the step limit the model gives its own account of where it got to", async () => {
   const harness = createHarness(
-    [
-      ...mainRounds,
-      textCompletion("Let me prepare the answer."),
-      textCompletion("I'll summarize the result."),
-      textCompletion("Checking the final output.")
-    ],
-    {
-      executeToolCall(_request, sequence) {
-        return {
-          ok: true,
-          result: {
-            sequence,
-            payload: sequence === 16 ? "x".repeat(10_000) : "ok"
-          }
-        };
-      }
-    }
+    Array.from({ length: 32 }, (_, index) => toolCompletion("action_execute", index + 1)),
+    { once: body => /personal assistant/u.test(JSON.stringify(body.messages)) ? "I ran 32 actions and stopped before the last check." : "" }
   );
 
   await harness.run();
 
-  const finalMessages = assistantMessages(harness.streamEvents);
-  assert.equal(harness.executedTools.length, 16);
-  assert.equal(harness.completionRequests.length, 19);
-  assert.deepEqual(finalMessages, ["Limit reached. Start a new conversation."]);
-  assert.ok(harness.streamEvents.some((event) => event.method === "sendAssistantDelta"));
+  assert.equal(harness.executedTools.length, 32, "The step limit stays within the turn's 32 application action calls");
+  assert.equal(harness.completionRequests.length, 32);
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["I ran 32 actions and stopped before the last check."]);
+  assert.doesNotMatch(JSON.stringify(harness.streamEvents), /Limit reached/u);
 });
 
-test("tool-failure recovery retains the bounded latest successful result", async () => {
-  const mainRounds = Array.from({ length: 16 }, (_, index) =>
-    toolCompletion(index === 1 ? "action_search" : "action_execute", index + 1)
-  );
+test("a failed action's error goes back to the model, and the action stays available", async () => {
   const harness = createHarness(
-    [
-      ...mainRounds,
-      textCompletion("Let me prepare the answer."),
-      textCompletion("I'll summarize the result."),
-      textCompletion("Checking the final output.")
-    ],
+    [toolCompletion("action_search", 1), toolCompletion("action_search", 2), textCompletion("The second search found it.")],
     {
-      executeToolCall(request, sequence) {
-        if (request.toolName === "action_search") {
-          return {
-            ok: false,
-            error: {
-              code: "assistant_tool_failed",
-              message: "Tool call failed."
-            }
-          };
-        }
-        return {
-          ok: true,
-          result: {
-            sequence,
-            payload: sequence === 16 ? "x".repeat(10_000) : "ok"
-          }
-        };
+      executeToolCall(_request, sequence) {
+        return sequence === 1
+          ? { ok: false, error: { code: "assistant_tool_failed", message: "Tool call failed." } }
+          : { ok: true, result: { found: 1 } };
       }
     }
   );
 
   await harness.run();
 
-  const [fallback] = assistantMessages(harness.streamEvents);
-  assert.equal(harness.executedTools.length, 16);
-  assert.ok(fallback.length <= 4000);
-  assert.match(fallback, /Latest successful result from action_execute/u);
-  assert.match(fallback, /"sequence": 16/u);
-  assert.match(fallback, /…\[truncated\]$/u);
-  assert.doesNotMatch(fallback, /Limit reached/u);
+  assert.deepEqual(harness.executedTools.map(request => request.toolName), ["action_search", "action_search"]);
+  assert.deepEqual(JSON.parse(harness.completionRequests[1].messages.at(-1).content),
+    { error: { code: "assistant_tool_failed", message: "Tool call failed." } });
+  assert.ok(harness.completionRequests[1].tools.some(tool => tool.function.name === "action_search"), "The failed action is not hidden");
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["The second search found it."]);
 });
 
 
@@ -487,6 +391,8 @@ test("answer text reaches the client before the provider finishes, then persists
   const harness = createHarness([response()]);
   const running = harness.run();
   await firstChunk.promise;
+  const deltas = () => harness.streamEvents.filter(event => event.method === "sendAssistantDelta");
+  for (let tries = 0; tries < 200 && !deltas().length; tries += 1) await new Promise(resolve => setTimeout(resolve, 5));
   try {
     assert.deepEqual(harness.streamEvents.filter(event => event.method === "sendAssistantDelta").map(event => event.payload.delta), ["The first sentence."]);
     assert.deepEqual(harness.completedConversations, []);
@@ -500,7 +406,7 @@ test("answer text reaches the client before the provider finishes, then persists
   assert.deepEqual(harness.transcriptMessages.filter(message => message.role === "assistant").map(message => message.contentText), ["The first sentence. The second sentence."]);
 });
 
-test("split internal tags and tool arguments never become answer deltas", async () => {
+test("tool calls written as text never run, never become answer deltas, and the model carries on once", async () => {
   async function* response() {
     for (const content of ["<th", "ink>private reasoning", "</thi", "nk>", "<｜DSML｜function_", "calls><｜DSML｜invoke name=\"action_search\">", '{"secret":"private arguments"}', "</｜DSML｜invoke></｜DSML｜function_calls>"]) {
       yield { choices: [{ delta: { content } }] };
@@ -509,13 +415,13 @@ test("split internal tags and tool arguments never become answer deltas", async
   }
   const harness = createHarness([response(), textCompletion("The search is complete.")]);
   await harness.run();
-  assert.deepEqual(harness.executedTools.map(request => request.toolName), ["action_search"]);
-  assert.deepEqual(harness.streamEvents.filter(event => event.method === "sendAssistantDelta").map(event => event.payload.delta), ["The search is complete."]);
+  assert.deepEqual(harness.executedTools, [], "A tool call written as text is not run");
+  assert.match(messageText(harness.completionRequests[1].messages.at(-1)), /^\(Check from the app: your last message contained raw markup/u);
+  assert.doesNotMatch(JSON.stringify(harness.streamEvents), /DSML|private reasoning|private arguments/u);
   assert.deepEqual(assistantMessages(harness.streamEvents), ["The search is complete."]);
 });
 
-
-test("application-authorized attachments reach the model and survive transcript restore", async () => {
+test("application-authorized attachments reach the model and are authorized again from saved history", async () => {
   const calls = [];
   const receipt = { attachmentId: "file-one", fileName: "notes.txt", size: 12 };
   const attachments = { async resolve(request) {
@@ -525,15 +431,17 @@ test("application-authorized attachments reach the model and survive transcript
     if (request.attachmentIds[0] !== "file-one") throw new Error("Attachment access denied");
     return { attachments: [receipt], content: [{ type: "text", text: "Authorized file bytes" }] };
   } };
-  const harness = createHarness([textCompletion("I read your notes.")], { attachments });
-  await harness.run("Read this", { attachmentIds: ["file-one"], history: [
-    { role: "user", content: "Previous file", attachmentIds: ["file-one"] }
-  ] });
-  assert.equal(calls.length, 2, "Both current and historical files must be authorized");
+  const harness = createHarness([textCompletion("I read your notes."), textCompletion("They mention the plan.")], { attachments });
+  await harness.run("Read this", { attachmentIds: ["file-one"] });
+  assert.equal(calls.length, 1, "The new message's file is authorized before admission");
   assert.deepEqual(harness.transcriptMessages[0].metadata.attachments, [receipt]);
   assert.deepEqual(harness.completionRequests[0].messages.at(-1).content, [
     { type: "text", text: "Read this" }, { type: "text", text: "Authorized file bytes" }
   ]);
+  await harness.run("What do they say?", { messageId: "message_2" });
+  assert.equal(calls.length, 2, "The saved file is authorized again when the next turn reads its history");
+  assert.ok(harness.completionRequests[1].messages.some(message => message.role === "user" && Array.isArray(message.content) &&
+    message.content.some(part => part.text === "Authorized file bytes")), "The saved history gives the model the earlier file");
   const denied = createHarness([textCompletion("Must not run")], { attachments });
   await assert.rejects(denied.run("Read this", { attachmentIds: ["another-users-file"] }), /access denied/);
   assert.deepEqual(denied.completionRequests, []);

package/test/createSurfaceAwareToolCatalog.test.js

@@ -77,3 +77,8 @@ test("surface-aware tool catalog applies per-surface skip and barred configurati
     skipActionPrefixes: ["assistant.", "demo.admin."]
   });
 });
+
+test("an application reaches the surface-aware tool catalog through the package's server entry", async () => {
+  const server = await import("@jskit-ai/assistant-runtime/server");
+  assert.equal(server.createSurfaceAwareToolCatalog, createSurfaceAwareToolCatalog);
+});

package/test/featureRuntime.test.js

@@ -4,7 +4,9 @@ import { spawnSync } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { createSchema } from "json-rest-schema";
 
-import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { ActionProvider } from "@jskit-ai/kernel/server/actions";
+import { EventProvider } from "@jskit-ai/kernel/server/runtime";
+import { silentLogger } from "@jskit-ai/kernel/server/runtime/logger";
 import { attachDirectRequestActionExecutor } from "@jskit-ai/kernel/server/http";
 import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
 import { AssistantFeature } from "../src/server/AssistantProvider.js";
@@ -36,8 +38,9 @@ test("AssistantFeature composes chat, transcripts, settings, routes, and action
     }
   };
   const runtime = createCapabilityRuntime({
+    inputs: { "runtime.logger": silentLogger },
     providers: [
-      createActionProvider(),
+      EventProvider, ActionProvider,
       valueProvider("test.config", "runtime.config", config),
       valueProvider("test.database", "runtime.database", { knex: Object.assign(() => {}, {}) }),
       valueProvider("test.env", "runtime.env", {}),
@@ -100,7 +103,8 @@ test("AssistantFeature uses a supplied file runtime without loading database or
     }
     const { AssistantFeature } = await import("@jskit-ai/assistant-runtime/server");
     const { createConversationRuntime, createFileConversationStorage } = await import("@jskit-ai/assistant-core/server/conversation");
-    const { createActionProvider } = await import("@jskit-ai/kernel/server/actions");
+    const { ActionProvider } = await import("@jskit-ai/kernel/server/actions");
+    const { silentLogger } = await import("@jskit-ai/kernel/server/runtime/logger");
     const { createCapabilityRuntime, defineProvider } = await import("@jskit-ai/kernel/shared/capabilities");
     const directory = await mkdtemp(join(tmpdir(), "assistant-feature-"));
     const runtime = createConversationRuntime({ storage: createFileConversationStorage({ directory }),
@@ -118,7 +122,7 @@ test("AssistantFeature uses a supplied file runtime without loading database or
       for (const unrelatedDatabase of [false, true]) {
         const routes = [];
         let assistant, actions;
-        const host = createCapabilityRuntime({ providers: [createActionProvider(),
+        const host = createCapabilityRuntime({ inputs: { "runtime.logger": silentLogger }, providers: [ActionProvider,
           valueProvider("runtime.config", config), valueProvider("runtime.env", {}),
           valueProvider("runtime.http", { router: { register(...route) { routes.push(route); } } }),
           valueProvider("assistant.conversations", runtime),
@@ -207,7 +211,7 @@ test("one AssistantFeature composes host access and declared data while settings
     requestPolicy: "host"
   };
   const host = createCapabilityRuntime({
-    providers: [createActionProvider(), AssistantFeature, defineProvider({
+    providers: [ActionProvider, AssistantFeature, defineProvider({
       id: "test.host.observer", requires: { catalogue: "runtime.actions", assistant: "assistant.runtime" },
       setup({ catalogue, assistant }) {
         actions = catalogue;
@@ -216,6 +220,7 @@ test("one AssistantFeature composes host access and declared data while settings
       }
     })],
     inputs: {
+      "runtime.logger": silentLogger,
       "runtime.config": config, "runtime.env": {}, "runtime.http": { router },
       "assistant.conversations": conversationRuntime, "assistant.conversation.access": access,
       "assistant.settings": {}, "runtime.events": { async publish() {} },
@@ -302,7 +307,8 @@ test("AssistantFeature rejects incomplete host access before registering routes
     [null, validAccess]
   ]) {
     let registrations = 0;
-    const host = createCapabilityRuntime({ providers: [createActionProvider(), AssistantFeature], inputs: {
+    const host = createCapabilityRuntime({ providers: [EventProvider, ActionProvider, AssistantFeature], inputs: {
+      "runtime.logger": silentLogger,
       "runtime.config": {}, "runtime.env": {},
       "runtime.http": { router: { register() { registrations++; } } },
       "assistant.conversation.access": access,

package/test/lazyAppConfig.test.js

@@ -311,8 +311,7 @@ test("registerRoutes returns clear AppError payload for pre-stream assistant fai
         },
         body: {
           messageId: "msg_1",
-          input: "hello",
-          history: []
+          input: "hello"
         }
       },
       executeAction: async ({ input }) => {
@@ -333,8 +332,7 @@ test("registerRoutes returns clear AppError payload for pre-stream assistant fai
     targetSurfaceId: "admin",
     workspaceSlug: "dogandgroom",
     messageId: "msg_1",
-    input: "hello",
-    history: []
+    input: "hello"
   });
 
   // Coded conversation failures keep their per-sentence messageCode, like the kernel payload.
@@ -351,7 +349,7 @@ test("registerRoutes returns clear AppError payload for pre-stream assistant fai
     await route.handler({
       raw: { on() {}, off() {} },
       headers: { "x-jskit-surface": "admin" },
-      input: { params: { workspaceSlug: "dogandgroom", surfaceId: "admin" }, body: { messageId: "msg_2", input: "hello", history: [] } },
+      input: { params: { workspaceSlug: "dogandgroom", surfaceId: "admin" }, body: { messageId: "msg_2", input: "hello" } },
       executeAction: async () => { throw failure; }
     }, reply);
     assert.equal(reply.statusCode, status);

package/test/packageMetadata.test.js

@@ -23,7 +23,13 @@ test("assistant-runtime registers providers without install-time authoring machi
   assert.deepEqual((await readdir(path.join(PACKAGE_ROOT, "migrations"))).sort(), [
     "assistant_config_initial.cjs",
     "assistant_transcripts_initial.cjs",
-    "assistant_turn_requests.cjs"
+    "assistant_transcripts_summary.cjs",
+    "assistant_turn_requests.cjs",
+    "constraints"
+  ]);
+  assert.deepEqual((await readdir(path.join(PACKAGE_ROOT, "migrations", "constraints"))).sort(), [
+    "assistant_users_foreign_keys.cjs",
+    "assistant_workspaces_foreign_keys.cjs"
   ]);
 
   const publicConfig = await readFile(

package/test/sqlConversationStorage.mysql.test.js

@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import knex from "knex";
+import { verifyConversationStorageContract } from "@jskit-ai/assistant-core/testing/conversation-storage";
+import transcriptsMigration from "../migrations/assistant_transcripts_initial.cjs";
+import summaryMigration from "../migrations/assistant_transcripts_summary.cjs";
+import { createRepository as createConversationsRepository } from "../src/server/repositories/conversationsRepository.js";
+import { createRepository as createMessagesRepository } from "../src/server/repositories/messagesRepository.js";
+import { createSqlConversationStorage } from "../src/server/sqlConversationStorage.js";
+
+test("the SQL conversation storage keeps its contract, cache and summary on MySQL", {
+  skip: !process.env.TEST_DB_NAME || !process.env.DB_HOST
+}, async () => {
+  const environment = process.env;
+  const databaseName = `${environment.TEST_DB_NAME}_assistant_transcripts`;
+  const connection = { host: environment.DB_HOST, port: Number(environment.DB_PORT), user: environment.DB_USER,
+    password: environment.DB_PASSWORD };
+  const admin = knex({ client: "mysql2", connection });
+  const clients = [];
+  const connect = () => {
+    const db = knex({ client: "mysql2", connection: { ...connection, database: databaseName } });
+    clients.push(db);
+    const repositories = { conversationsRepository: createConversationsRepository(db), messagesRepository: createMessagesRepository(db) };
+    return { db, ...repositories, storage: createSqlConversationStorage(repositories) };
+  };
+  try {
+    await admin.raw("DROP DATABASE IF EXISTS ??", [databaseName]);
+    await admin.raw("CREATE DATABASE ??", [databaseName]);
+    const f = connect();
+    await transcriptsMigration.up(f.db);
+    await summaryMigration.up(f.db);
+    await summaryMigration.up(f.db);
+    const conversation = actor => f.conversationsRepository.create({ createdByUserId: actor, surfaceId: "assistant", metadata: {} });
+
+    const first = await conversation("1");
+    const other = await conversation("2");
+    const scopes = new Map([["actor-a:workspace-a:conversation-a", first.id], ["actor-b:workspace-a:conversation-a", other.id]]);
+    await verifyConversationStorageContract({
+      read: (scope, callback) => f.storage.read(scopes.get(scope), callback),
+      write: (scope, callback) => f.storage.write(scopes.get(scope), callback)
+    }, { runtime: true });
+
+    const long = await conversation("1");
+    await f.storage.write(long.id, async transaction => {
+      for (let index = 0; index < 100; index += 1) {
+        const turnId = await transaction.nextTurnId();
+        const at = new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString();
+        await transaction.appendMessage(turnId, { role: "user", messageId: `question-${index}`, text: `Question ${index}`, at });
+        await transaction.appendMessage(turnId, { role: "assistant", messageId: `answer-${index}`, text: `Answer ${index}`, at });
+      }
+    });
+    const servers = [connect(), connect()];
+    for (const server of servers) await server.storage.read(long.id, transaction => transaction.listTurnIds());
+    const queries = [];
+    const listener = query => queries.push(query.sql);
+    servers[0].db.on("query", listener);
+    const appended = await Promise.all(servers.map((server, index) => server.storage.write(long.id, async transaction => {
+      const turnId = await transaction.nextTurnId();
+      await transaction.appendMessage(turnId, { role: "user", messageId: `concurrent-${index}`, text: `Concurrent ${index}`,
+        at: "2026-02-01T00:00:00.000Z" });
+      return turnId;
+    })));
+    servers[0].db.removeListener("query", listener);
+    assert.deepEqual(appended.sort(), ["000101", "000102"], "Concurrent servers allocate distinct turns under the conversation lock");
+    const wholeReads = queries.filter(sql => /from `assistant_messages`/u.test(sql) && /order by/u.test(sql));
+    assert.ok(wholeReads.length <= 1, "Only a server that lost the race to the other's save reads the conversation again");
+    for (const server of servers) {
+      assert.deepEqual((await server.storage.read(long.id, transaction => transaction.listTurnIds())).slice(-2), ["000101", "000102"]);
+    }
+
+    const text = "A long summary. ".repeat(8_000);
+    await servers[1].storage.write(long.id, transaction => transaction.writeSummary({ text, throughTurnId: "000100" }));
+    const summarised = await servers[0].storage.read(long.id, async transaction => ({
+      summary: await transaction.readSummary(), after: (await transaction.readTurnsAfter("000100")).map(turn => turn.turnId)
+    }));
+    assert.deepEqual(summarised, { summary: { text, throughTurnId: "000100" }, after: ["000101", "000102"] });
+
+    await summaryMigration.down(f.db);
+    for (const column of ["summary_text", "summary_through_turn_id", "transcript_revision"]) {
+      assert.equal(await f.db.schema.hasColumn("assistant_conversations", column), false);
+    }
+    await summaryMigration.up(f.db);
+    assert.equal(await f.db.schema.hasColumn("assistant_conversations", "transcript_revision"), true);
+  } finally {
+    for (const client of clients) await client.destroy();
+    await admin.raw("DROP DATABASE IF EXISTS ??", [databaseName]);
+    await admin.destroy();
+  }
+});