@jskit-ai/assistant-core 0.2.16 → 0.2.18

package/src/server/conversation/openCodeTurn.js

@@ -478,9 +478,10 @@ export async function waitForOpenCodeFinalResponse(client, conversationId, turn,
 /**
  * Production detached-turn lifetime. Applications project the completed native
  * result before observation is closed, then publish/checkpoint their own state.
- * A turn the server's shutdown stopped (`turn.stoppedByShutdown`) ends
- * interrupted however its wait ended, and `afterClose` is told so: the
- * application leaves its checkpoint to the next server.
+ * A turn the server's shutdown stopped (`turn.stoppedByShutdown`), or that
+ * ends on its own once shutdown has begun, ends interrupted however its wait
+ * ended, and `afterClose` is told so: the application leaves its checkpoint to
+ * the next server.
  * @param {import("./openCodeProcessOwner.js").OpenCodeProcessOwner} processOwner
  */
 export async function observeOpenCodeTurnCompletion(processOwner, target, conversationId, turn, {
@@ -489,6 +490,10 @@ export async function observeOpenCodeTurnCompletion(processOwner, target, conver
   const turnAbort = turn.abortController;
   let stopped = true;
   let outcome = "completed";
+  const leftToNextServer = () => {
+    if (processOwner.closed) turn.stoppedByShutdown = true;
+    return turn.stoppedByShutdown === true;
+  };
   try {
     const options = { ...waitOptions, signal: AbortSignal.any([
       signal, ...(timeoutMs ? [AbortSignal.timeout(timeoutMs)] : [])
@@ -496,14 +501,14 @@ export async function observeOpenCodeTurnCompletion(processOwner, target, conver
     const completion = finalResponse
       ? await waitForOpenCodeFinalResponse(target.server.client, conversationId, turn, { ...finalResponse, ...options })
       : await waitForOpenCodeMessages(target.server.client, conversationId, () => turn.inputMessageId, options);
-    if (turn.stoppedByShutdown) {
+    if (leftToNextServer()) {
       outcome = "interrupted";
       return { interrupted: true };
     }
     return await projectResult(completion);
   } catch (error) {
     const failure = signal.aborted ? signal.reason : error;
-    outcome = turn.interrupted || turn.stoppedByShutdown ? "interrupted" : "failed";
+    outcome = leftToNextServer() || turn.interrupted ? "interrupted" : "failed";
     if (outcome === "interrupted") return { interrupted: true };
     if (!target.abortController.signal.aborted) {
       try {

package/src/server/conversation/openCodeTurnMonitor.js

@@ -355,8 +355,10 @@ export function createOpenCodeTurnMonitor({ processes, monitors, turns, processO
         // server: its saved run stays active and carries the shutdown's mark,
         // so that server's recovery records the turn interrupted and runs the
         // host's checkpoint. Run here, that checkpoint (a Git snapshot, say)
-        // would hold the host's bounded shutdown for as long as it takes. A
-        // user's Stop ends its turn as interrupted here.
+        // could be refused or hold the host's bounded shutdown for as long as
+        // it takes. A turn that ends on its own once shutdown has begun is left
+        // the same way. A user's Stop outside shutdown ends its turn here.
+        if (processOwner.closed && finalState !== "active") turn.stoppedByShutdown = true;
         const nextServerEnds = turn.stoppedByShutdown === true && finalState !== "active";
         // Claim retirement before awaited cleanup/checkpointing. A new Send
         // joins this monitor's cleanup instead of steering an unobserved turn.

package/src/server/conversation/providers/claudeDriver.js

@@ -346,6 +346,10 @@ export function createClaudeConversationDriver({
     return native.owner.closeProject(input, native.application);
   }
 
+  function beginShutdown({ native }) {
+    return native.owner.beginShutdown();
+  }
+
   function invalidateRuntimes({ native, input }) {
     return native.owner.invalidateRuntimes(input, native.application, native.account);
   }
@@ -568,6 +572,7 @@ export function createClaudeConversationDriver({
     listConversationStorage,
     retireConversationHistory,
     closeProject,
+    beginShutdown,
     invalidateRuntimes,
     reconcileSessions,
     createConversation,

package/src/server/conversation/providers/codexDriver.js

@@ -63,6 +63,10 @@ function nativeGoalChanged() {
   });
 }
 
+function beginShutdown({ native }) {
+  return native.runOwner.beginShutdown();
+}
+
 /**
  * Conversations own threads and observers on the account's shared native runtime.
  * @param {object} dependencies
@@ -653,6 +657,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
     deleteDetachedConversation,
     listConversationStorage,
     retireConversationHistory,
+    beginShutdown,
     invalidateRuntimes,
     reconcileSessions,
     unsubscribeSessions,

package/src/server/conversation/providers/opencodeDriver.js

@@ -126,6 +126,10 @@ export function createOpenCodeConversationDriver({
     return native.owner.closeProject(input, native.preparation.projectCleanup());
   }
 
+  function beginShutdown({ native }) {
+    return native.owner.beginShutdown();
+  }
+
   function invalidateRuntimes({ native, input }) {
     return native.owner.invalidateRuntimes(input, native.preparation);
   }
@@ -375,6 +379,7 @@ export function createOpenCodeConversationDriver({
     listConversationStorage,
     retireConversationHistory,
     closeProject,
+    beginShutdown,
     invalidateRuntimes,
     reconcileSessions,
     createConversation,

package/src/server/conversation/runtime.js

@@ -227,6 +227,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     runNativeDetachedConversation: lifecycle.runNativeDetachedConversation,
     open: handles.open,
     closeNativeProject: lifecycle.closeNativeProject,
+    beginNativeShutdown: lifecycle.beginNativeShutdown,
     invalidateNativeRuntimes: lifecycle.invalidateNativeRuntimes,
     reconcileNativeSessions: lifecycle.reconcileNativeSessions,
     unsubscribeNativeSessions: lifecycle.unsubscribeNativeSessions,

package/test/apiConversationDriver.test.js

@@ -6,7 +6,8 @@ import { createApiConversationDriver } from "../src/server/conversation/provider
 const CHECKS = checkTexts("the app");
 const frame = (delta, finish_reason) => `data: ${JSON.stringify({ choices: [{ index: 0, delta, finish_reason }] })}\n\n`;
 const schema = tool => ({ type: "function", function: { name: tool.name, parameters: tool.parameters } });
-const lastText = body => body.messages.at(-1).content;
+// The engine's state note ends every request's conversation; what the app sent last comes before it.
+const lastText = body => body.messages.at(-2).content;
 
 // One step of a streamed reply: words, an action call or both. Calls the engine
 // makes without streaming (accounts, checks, summaries) answer with `once`.
@@ -113,7 +114,10 @@ test("admission precedes every model call, the state note gives the time, and a
   await f.run("What day is it today?");
   assert.deepEqual(f.order, ["accept", "model"]);
   assert.deepEqual(f.executions, [], "No action runs before the model asks for one");
-  assert.match(f.requests[0].messages[0].content, /^Use the supplied actions\.\n\nCurrent state, from the system\. It is the truth; earlier messages may be out of date:\n- The time: .+ UTC\. The person may be in another time zone\.$/u);
+  assert.equal(f.requests[0].messages[0].content, "Use the supplied actions.", "The state note is not in the system prompt");
+  assert.equal(f.requests[0].messages.at(-1).role, "user");
+  assert.match(f.requests[0].messages.at(-1).content, /^Current state, from the system\. It is the truth; earlier messages may be out of date:\n- The time: .+ UTC\. The person may be in another time zone\.$/u,
+    "The state note follows the conversation, so the history before it stays in the provider's prompt cache");
   const denied = fixture({ authorize: () => { throw new Error("Connection access revoked"); } });
   await assert.rejects(denied.run(), /Connection access revoked/);
   assert.deepEqual(denied.requests, []);
@@ -223,7 +227,7 @@ test("a long history is compacted: the summary and its last turn are saved, and
   assert.ok(kept.length > 0 && kept.length < turns.length);
   const [request] = f.streamed;
   assert.match(request.messages[0].content, /Summary of the earlier part of this conversation[^]*The person asked six long questions\./u);
-  assert.deepEqual(request.messages.filter(message => message.role === "user").map(message => message.content),
+  assert.deepEqual(request.messages.slice(0, -1).filter(message => message.role === "user").map(message => message.content),
     [...kept.map(turn => turn.user.text), "Next question"]);
   assert.deepEqual(phases, ["compacting", "working"]);
 });
@@ -248,5 +252,5 @@ test("a short history is read whole with its stored summary, and nothing is save
   assert.deepEqual(saved, []);
   assert.equal(f.requests.length, 1);
   assert.match(f.requests[0].messages[0].content, /Summary of the earlier part of this conversation[^]*Earlier: hello\./u);
-  assert.deepEqual(f.requests[0].messages.slice(1).map(message => message.content), ["Hi", "Hello", "Next question"]);
+  assert.deepEqual(f.requests[0].messages.slice(1, -1).map(message => message.content), ["Hi", "Hello", "Next question"]);
 });

package/test/claudeLifecycle.test.js

@@ -242,6 +242,34 @@ test("Claude shutdown leaves a running turn's end and its checkpoint to the next
   assert.deepEqual(custody(JSON.parse(f.session("a").records.get(MAIN_IDS.a))), { executionId: "", state: "interrupted" });
 });
 
+test("once Claude's shutdown has begun, a turn that ends on its own is left to the next server, which runs its one checkpoint", { timeout: 5_000 }, async t => {
+  const f = await lifecycleFixture(t);
+  const a = await f.running("a");
+  const saved = f.session("a").records.get(MAIN_IDS.a);
+  f.owner.beginShutdown();
+  assert.deepEqual(f.calls.stops, [], "beginning the shutdown stopped nothing");
+  // The turn ends on its own.
+  await f.processes[0].options.onEvent({ type: "result", subtype: "success", result: "Done." });
+  assert.deepEqual(f.calls.checkpoints, [], "the turn's end ran no checkpoint");
+  assert.equal(f.session("a").records.get(MAIN_IDS.a), saved, "the saved record keeps the active turn");
+  assert.equal((await f.owner.invalidateRuntimes({ reason: "server-shutdown" }, f.application, f.account)).ok, true);
+  assert.equal(a.process, null, "the full stop still stopped the process");
+  assert.deepEqual(f.calls.checkpoints, []);
+  // The next server's close proves that exit, then interrupts the turn through its checkpoint, once.
+  f.restart();
+  assert.equal((await f.owner.closeSession({ sessionId: "a" }, f.application)).ok, true);
+  assert.equal((await f.owner.closeSession({ sessionId: "a" }, f.application)).ok, true);
+  assert.deepEqual(f.calls.checkpoints, ["a:interrupted"]);
+});
+
+test("outside shutdown a Claude turn that ends on its own still runs its checkpoint at once", { timeout: 5_000 }, async t => {
+  const f = await lifecycleFixture(t);
+  await f.running("a");
+  await f.processes[0].options.onEvent({ type: "result", subtype: "success", result: "Done." });
+  assert.deepEqual(f.calls.checkpoints, ["a:completed"]);
+  assert.equal(JSON.parse(f.session("a").records.get(MAIN_IDS.a)).state, "completed");
+});
+
 test("Claude project close releases its sessions from memory without reopening saved conversations", async t => {
   const f = await lifecycleFixture(t);
   await f.idle("a");

package/test/codexConversationsCheckpoint.test.js

@@ -20,6 +20,8 @@ function persistentConversationFixture() {
   };
   const commands = createCodexConversationCommands({
     async checkpoint(_sessionId, input) { checkpoints.push(input); },
+    // Outside shutdown, with no request contexts.
+    isClosing: () => false, captureContext: () => null, runInContext: (_context, operation) => operation(),
     conversationPreparation: { async context() { return { result: { provider } }; } },
     namespace: (sessionId) => sessionId,
     // The provider owner still holds the provider observing the conversation;

package/test/codexLifecycleIsolation.test.js

@@ -231,6 +231,8 @@ function conversationCommands({ context = async () => ({ result: { ok: false, co
   providerSessions = {} } = {}) {
   return createCodexConversationCommands({
     checkpoint: async () => {},
+    // Outside shutdown, with no request contexts.
+    isClosing: () => false, captureContext: () => null, runInContext: (_context, operation) => operation(),
     conversationPreparation: {
       context,
       scope,

package/test/codexShutdownStop.test.js

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createCodexConversationCommands } from "../src/server/conversation/codexConversations.js";
+import { createCodexRuntimeLifecycle } from "../src/server/conversation/codexRuntimeLifecycle.js";
+
+// A Temporary chat's Codex turn that the server's shutdown stops, or that ends
+// while the server is stopping, leaves its checkpoint to the next server: the
+// application records it as owed, and that server's next read makes it once.
+
+const turnOutcomes = { USER_CANCELLED: "user_cancelled", SERVICE_RESTART: "service_restart" };
+
+// One server's observed conversation. `latest` is the turn Codex's history
+// reports to a read; turn notifications reach the conversation's observer.
+function server({ closing = false, latest = { id: "turn-1", status: "inProgress", items: [] }, threadError = null } = {}) {
+  const checkpoints = [];
+  const deferred = [];
+  const listeners = new Set();
+  const emit = notification => listeners.forEach(listener => listener(notification));
+  const provider = {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async readThreadStatus(threadId) {
+      return { raw: { id: threadId, historyMode: "paginated", status: "idle", ...(threadError ? { error: threadError } : {}) } };
+    },
+    async listThreadTurns() { return { data: [latest] }; },
+    async readGoal() { return { goal: null }; },
+    async stopThreadForObservationLoss() {}
+  };
+  const lifecycle = { closing };
+  const commands = createCodexConversationCommands({
+    async checkpoint(sessionId, input) { checkpoints.push({ sessionId, ...input }); },
+    async deferCheckpoint(sessionId, input) { deferred.push({ sessionId, ...input }); },
+    isClosing: () => lifecycle.closing,
+    captureContext: () => null,
+    runInContext: (_context, operation) => operation(),
+    codexAppServerConversationMessageId: (...parts) => parts.join(":"),
+    conversationPreparation: { async context() { return { result: { provider } }; } },
+    namespace: sessionId => sessionId,
+    providerSessions: { owner: { providers: new Map([["provider", provider]]), holdProvider: () => () => {} } },
+    turnOutcomes
+  });
+  const startTurn = () => {
+    commands.observeCodexConversation("session", "thread", provider);
+    emit({ method: "turn/started", params: { threadId: "thread", turn: { id: "turn-1", status: "inProgress" } } });
+  };
+  const complete = status => emit({ method: "turn/completed", params: { threadId: "thread", turn: { id: "turn-1", status } } });
+  const read = stoppedByShutdown => commands.readPersistentCodexConversation("session", { conversationId: "thread", stoppedByShutdown },
+    { provider }).then(({ status, error, runId }) => ({ status, error, runId }));
+  return { checkpoints, deferred, commands, lifecycle, startTurn, complete, read };
+}
+
+const OWED = { sessionId: "session", outerTurnId: "codex:thread:turn-1", threadId: "thread", turnId: "turn-1" };
+
+test("shutdown leaves a running Temporary turn's interrupted checkpoint to the next server, which makes it once on its read", async () => {
+  const first = server();
+  first.startTurn();
+  first.lifecycle.closing = true;
+  await first.commands.leaveRunningTurnsToNextServer();
+  assert.deepEqual(first.checkpoints, [], "shutdown made no checkpoint");
+  assert.deepEqual(first.deferred, [{ ...OWED, status: "interrupted", turnOutcome: "service_restart" }]);
+
+  // The stopped process ends the turn natively as interrupted.
+  const next = server({ latest: { id: "turn-1", status: "interrupted", items: [] }, threadError: { message: "Turn aborted." } });
+  const ended = [];
+  const mark = runId => ({ runId, async ended() { ended.push(runId); } });
+  assert.deepEqual(await next.read(mark("turn-1")), { status: "interrupted", error: "", runId: "turn-1" });
+  assert.deepEqual(ended, ["turn-1"], "recording the stopped run lets the application make its checkpoint");
+  assert.deepEqual(await next.read(undefined), { status: "interrupted", error: "Turn aborted.", runId: "turn-1" },
+    "an unmarked interruption keeps Codex's own report");
+  await next.read(mark("turn-0"));
+  assert.deepEqual(ended, ["turn-1"], "only the marked run is recorded as ended");
+  assert.deepEqual(next.checkpoints, []);
+});
+
+test("a Temporary turn that ends on its own while the server stops leaves its checkpoint, with its own outcome, to the next server", async () => {
+  const f = server();
+  f.startTurn();
+  f.lifecycle.closing = true;
+  f.complete("completed");
+  await Promise.all(f.commands.deferredCheckpoints);
+  assert.deepEqual(f.checkpoints, []);
+  assert.deepEqual(f.deferred, [{ ...OWED, status: "completed", turnOutcome: "" }]);
+  assert.equal(f.commands.deferredCheckpoints.size, 0, "shutdown awaits each deferred record");
+
+  // The next server reads the completed turn as completed, and makes its checkpoint.
+  const next = server({ latest: { id: "turn-1", status: "completed", items: [] } });
+  const ended = [];
+  assert.equal((await next.read({ runId: "turn-1", async ended() { ended.push("turn-1"); } })).status, "completed");
+  assert.deepEqual(ended, ["turn-1"]);
+});
+
+test("outside shutdown a Temporary turn's end still makes its checkpoint at once", async () => {
+  const f = server();
+  f.startTurn();
+  f.complete("interrupted");
+  assert.deepEqual(f.checkpoints, [{ ...OWED, status: "interrupted", turnOutcome: "" }]);
+  assert.deepEqual(f.deferred, []);
+  await f.commands.leaveRunningTurnsToNextServer();
+  assert.deepEqual(f.deferred, [], "a finished turn owes nothing at shutdown");
+});
+
+// The run owner's runtime lifecycle, with the owner calls it makes recorded.
+function runtimeLifecycle(calls, leaveTurnsToNextServer) {
+  return createCodexRuntimeLifecycle({
+    pendingWork: { conversationTurnStarts: new Map(), messageDeliveries: new Map(), reasoningPersistQueues: new Map(),
+      resultFinalizations: new Map(), threadReconciliations: new Map(), notificationTasks: new Map(), deferredCheckpoints: new Set() },
+    observer: { eventSubscriptions: new Map() },
+    checkManagedConnection: async () => {},
+    providerSessions: { managed: new Map(), assertOpen() {}, owner: {
+      lifecycleTasks: new Set(), runtimeAcquisitions: new Set(),
+      beginShutdown() { calls.push("owner-shutdown"); },
+      async invalidateRuntimes() { calls.push("stop-runtimes"); return { failed: [], providerCount: 0, results: [], stopped: 0 }; }
+    } },
+    helperLifecycle: { projectOperations: new Map(), cleanups: new Map(), mutations: new Map(), restores: new Map(), turnStarts: new Map() },
+    captureContext: () => null,
+    runInContext: (_context, operation) => operation(),
+    debugLog() {},
+    debugError: error => error?.message,
+    leaveTurnsToNextServer
+  });
+}
+
+test("a Codex shutdown leaves the running turns to the next server before any runtime stops, and waits for their records", async () => {
+  const calls = [];
+  const recorded = Promise.withResolvers();
+  const lifecycle = runtimeLifecycle(calls, async () => {
+    calls.push("leave-turns");
+    await recorded.promise;
+    calls.push("turns-recorded");
+  });
+  const shutdown = lifecycle.invalidateRuntimes({ reason: "server-shutdown" }, { enabled: true });
+  assert.equal(lifecycle.closing, true);
+  await Promise.resolve();
+  recorded.resolve();
+  await shutdown;
+  assert.equal(calls[0], "leave-turns");
+  assert.ok(calls.indexOf("turns-recorded") < calls.lastIndexOf("stop-runtimes"), "shutdown waited for the records");
+});
+
+test("a begun Codex shutdown stops nothing, and a Temporary turn that then ends on its own leaves its checkpoint to the next server", async () => {
+  const f = server();
+  f.startTurn();
+  const calls = [];
+  const lifecycle = runtimeLifecycle(calls, () => f.commands.leaveRunningTurnsToNextServer());
+  Object.defineProperty(f.lifecycle, "closing", { get: () => lifecycle.closing });
+  lifecycle.beginShutdown();
+  assert.equal(lifecycle.closing, true, "the closing fence is set before the call returns");
+  assert.deepEqual(calls, ["owner-shutdown"], "beginning the shutdown stopped nothing");
+  f.complete("completed");
+  await Promise.all(f.commands.deferredCheckpoints);
+  assert.deepEqual(f.checkpoints, [], "the turn's end made no checkpoint");
+  assert.deepEqual(f.deferred.at(-1), { ...OWED, status: "completed", turnOutcome: "" }, "its own outcome is owed");
+
+  // The full stop that follows still stops the runtimes, and leaves the turns only once.
+  const deferred = f.deferred.length;
+  await lifecycle.invalidateRuntimes({ reason: "server-shutdown" }, { enabled: true });
+  assert.ok(calls.includes("stop-runtimes"));
+  assert.equal(f.deferred.length, deferred);
+  assert.deepEqual(f.checkpoints, []);
+
+  // The next server's read makes the owed checkpoint once.
+  const next = server({ latest: { id: "turn-1", status: "completed", items: [] } });
+  const ended = [];
+  assert.equal((await next.read({ runId: "turn-1", async ended() { ended.push("turn-1"); } })).status, "completed");
+  assert.deepEqual(ended, ["turn-1"]);
+});

package/test/codexTemporaryProviderRelease.test.js

@@ -53,6 +53,8 @@ function codexFixture(t, { idleMs = 20 } = {}) {
   });
   const commands = createCodexConversationCommands({
     async checkpoint() {},
+    // Outside shutdown, with no request contexts.
+    isClosing: () => false, captureContext: () => null, runInContext: (_context, operation) => operation(),
     codexAppServerConversationMessageId: (...parts) => parts.join(":"),
     codexAppServerStreamMessage: () => ({}),
     conversationPreparation: {

package/test/codexTurn.test.js

@@ -3856,3 +3856,60 @@ test("native history budget rejects unavailable dynamic limits before pending de
     assert.equal(sends, 0);
   }
 });
+
+test("a Main turn the previous server's shutdown stopped reads as interrupted by a restart, with one interrupted checkpoint", async () => {
+  const notices = [];
+  const checkpoints = [];
+  const f = await receiptFixture({
+    outcomeNotice(_runtime, _sessionId, _threadId, _turnId, outcome) { notices.push(outcome); },
+    checkpoint(_sessionId, input) { checkpoints.push(input); }
+  });
+  f.provider.interruptionOutcome = () => "";
+  // The shutdown marks the running turn and leaves the rest of its saved run as it was.
+  assert.deepEqual(await f.owner.markTurnStoppedByShutdown(f.sessionId, f.threadId), { marked: true });
+  assert.deepEqual({ state: f.run.state, stoppedByShutdownTurnId: f.run.stoppedByShutdownTurnId },
+    { state: "active", stoppedByShutdownTurnId: f.turnId });
+  assert.deepEqual(await f.owner.markTurnStoppedByShutdown(f.sessionId, "another-thread"), { marked: false });
+  // The next server reads the native turn as interrupted.
+  const result = await f.owner.stopTurnWithProviderFailure(f.sessionId, f.threadId, f.turnId, {
+    status: "interrupted", provider: f.provider, verifyInactive: false
+  });
+  assert.equal(result.status, "interrupted");
+  assert.match(result.error, /interrupted by a restart/u);
+  assert.deepEqual(notices, ["service_restart"]);
+  assert.deepEqual(checkpoints.map(({ status, turnOutcome }) => ({ status, turnOutcome })),
+    [{ status: "interrupted", turnOutcome: "service_restart" }]);
+  assert.equal(f.run.state, "interrupted");
+});
+
+test("an interrupted Main turn without the shutdown's mark keeps the plain interrupted outcome", async () => {
+  const notices = [];
+  const checkpoints = [];
+  const f = await receiptFixture({
+    outcomeNotice(_runtime, _sessionId, _threadId, _turnId, outcome) { notices.push(outcome); },
+    checkpoint(_sessionId, input) { checkpoints.push(input); }
+  });
+  f.provider.interruptionOutcome = () => "";
+  // A mark left by an earlier turn does not apply to this one.
+  f.run = { ...f.run, stoppedByShutdownTurnId: "an-earlier-turn" };
+  await f.owner.stopTurnWithProviderFailure(f.sessionId, f.threadId, f.turnId, {
+    status: "interrupted", provider: f.provider, verifyInactive: false
+  });
+  assert.deepEqual(notices, ["interrupted"]);
+  assert.deepEqual(checkpoints.map(({ turnOutcome }) => turnOutcome), ["interrupted"]);
+});
+
+test("a Main turn that ends once shutdown has begun is left to the next server, with no checkpoint now", async () => {
+  const f = await settlementFixture();
+  f.owner.runtimeLifecycle = { closing: true };
+  const before = structuredClone(f.run);
+  assert.deepEqual(await f.owner.markTurnIdle(f.sessionId, { status: "completed", threadId: f.threadId, turnId: f.turnId }),
+    { ok: true, processed: false, reason: "left_to_next_server" });
+  assert.deepEqual(f.run, before, "the saved run is unchanged");
+  assert.deepEqual(f.checkpoints, []);
+  // Outside shutdown the same end is recorded and checkpointed at once.
+  f.owner.runtimeLifecycle = { closing: false };
+  await f.owner.markTurnIdle(f.sessionId, { status: "completed", threadId: f.threadId, turnId: f.turnId });
+  assert.equal(f.run.state, "completed");
+  assert.deepEqual(f.checkpoints.map(({ status }) => status), ["completed"]);
+});

package/test/conversationApiFacilities.test.js

@@ -65,7 +65,7 @@ test("an existing API client keeps opaque receipts path-safe and selected histor
   assert.deepEqual(requests[0][1], { role: "user", content: [
     { type: "text", text: "Selected prior context" }, { type: "text", text: "Authorized historical bytes" }
   ] });
-  assert.deepEqual(requests[0].at(-1), { role: "user", content: [
+  assert.deepEqual(requests[0].at(-2), { role: "user", content: [
     { type: "text", text: "Current question" }, { type: "text", text: "Authorized current bytes" }
   ] });
   const files = await readdir(directory);
@@ -84,8 +84,9 @@ test("an existing API client keeps opaque receipts path-safe and selected histor
   context.history = [];
   await conversation.send({ messageId: "empty-context", text: "No prior model context" });
   const last = await conversation.wait();
-  assert.match(requests[2][0].content, /^Existing instructions\n\nCurrent state, from the system\./u);
-  assert.deepEqual(requests[2].slice(1).map(message => message.content), ["No prior model context"]);
+  assert.equal(requests[2][0].content, "Existing instructions");
+  assert.deepEqual(requests[2].slice(1, -1).map(message => message.content), ["No prior model context"]);
+  assert.match(requests[2].at(-1).content, /^Current state, from the system\./u, "The engine's state note follows the conversation");
   assert.equal(last.conversationLog.length, 3, "Explicitly empty model context never removes saved conversation history");
   await assert.rejects(conversation.send({ messageId: "x".repeat(129), text: "Must not dispatch" }), { code: "conversation_invalid_message" });
   assert.equal(requests.length, 3);

package/test/conversationAttachments.test.js

@@ -147,7 +147,7 @@ test("authorized image bytes reach the API once and only safe receipts enter sto
   assert.equal(f.reads[0].context, context);
   assert.equal(f.reads[0].conversationId, "one");
   assert.deepEqual(f.reads[0].attachmentIds, [receipt.attachmentId]);
-  assert.deepEqual(f.requests[0].messages.at(-1).content, [
+  assert.deepEqual(f.requests[0].messages.at(-2).content, [
     { type: "text", text: input.text }, { type: "image_url", image_url: { url: `data:image/png;base64,${image.toString("base64")}` } }
   ]);
   assert.deepEqual(state.conversationLog[0].user.attachments, [receipt]);
@@ -174,7 +174,7 @@ test("API history and continuity reauthorize files after reopen and renewal", as
   await resumed.conversation.replace({ operationId: "renew", reason: "renewal", expectedSegmentId: first.segmentId });
   await resumed.conversation.send({ messageId: "third", text: "Look again" });
   await resumed.conversation.wait();
-  assert.equal(resumed.requests[1].messages.at(-1).content[1].type, "image_url");
+  assert.equal(resumed.requests[1].messages.at(-2).content[1].type, "image_url");
   allowed = false;
   await assert.rejects(resumed.conversation.send({ messageId: "denied", text: "Look again" }), /attachment access/);
   assert.equal(resumed.requests.length, 2);
@@ -185,8 +185,8 @@ test("an image-only request is accepted without invented user text", async t =>
   const f = await fixture(t);
   await f.conversation.send({ ...input, text: "" });
   const state = await f.conversation.wait();
-  assert.equal(f.requests[0].messages.at(-1).content.length, 1);
-  assert.equal(f.requests[0].messages.at(-1).content[0].type, "image_url");
+  assert.equal(f.requests[0].messages.at(-2).content.length, 1);
+  assert.equal(f.requests[0].messages.at(-2).content[0].type, "image_url");
   assert.equal(state.conversationLog[0].user.text, "");
 });
 

package/test/conversationReplacement.test.js

@@ -60,7 +60,7 @@ test("renewal preserves logical history and receipts while subsequent inference
   assert.equal(f.requests.length, 1, "Replacement itself does not perform inference");
   await f.say("Continue", "second");
   const sent = f.requests[1].messages;
-  assert.equal(sent.at(-1).content, "Continue");
+  assert.equal(sent.at(-2).content, "Continue", "The request comes last, before the engine's state note");
   assert.match(sent[1].content, /Retain the agreed colour: blue/);
   assert.match(sent[1].content, /Keep my context/);
   assert.match(sent[1].content, /Reply 1/);

package/test/conversationSession.test.js

@@ -82,9 +82,9 @@ test("saved history and current instructions use the existing authorized model c
   await f.conversation.configure({ systemPrompt: "Use the new instructions." });
   await f.conversation.send({ messageId: "two", text: "Continue" });
   await f.conversation.wait();
-  assert.match(f.requests[1].messages[0].content, /^Use the new instructions\.\n\nCurrent state, from the system\./u,
-    "The current instructions lead the system prompt, before the engine's state note");
-  assert.deepEqual(f.requests[1].messages.slice(1).map(message => message.content), ["Hello", "Hello there.", "Continue"]);
+  assert.equal(f.requests[1].messages[0].content, "Use the new instructions.", "The current instructions are the system prompt");
+  assert.deepEqual(f.requests[1].messages.slice(1, -1).map(message => message.content), ["Hello", "Hello there.", "Continue"]);
+  assert.match(f.requests[1].messages.at(-1).content, /^Current state, from the system\./u, "The engine's state note follows the conversation");
   f.state.modelAllowed = false;
   await assert.rejects(f.conversation.send({ messageId: "three", text: "No longer authorized" }));
   assert.equal((await f.conversation.read()).conversationLog.length, 2);
@@ -114,7 +114,7 @@ test("opening an existing application transcript retains its context before and
   const f = await fixture(t, { storage });
   await f.conversation.send(input);
   const first = await f.conversation.wait();
-  assert.deepEqual(f.requests[0].messages.slice(1).map(message => message.content), [
+  assert.deepEqual(f.requests[0].messages.slice(1, -1).map(message => message.content), [
     "Our chosen colour is blue.", "I will remember blue.", "Hello"
   ]);
   assert.equal((await f.conversation.send({ messageId: "earlier", text: "Our chosen colour is blue." })).duplicate, true);
@@ -125,7 +125,7 @@ test("opening an existing application transcript retains its context before and
   assert.match(messages[1].content, /Our chosen colour is blue/);
   assert.match(messages[1].content, /I will remember blue/);
   assert.equal(messages.filter(message => message.content.includes("Our chosen colour is blue")).length, 1);
-  assert.equal(messages.at(-1).content, "Continue");
+  assert.equal(messages.at(-2).content, "Continue", "The request comes last, before the engine's state note");
   assert.equal((await transcript.readConversationLog("one"))[0].metadata?.runtime, undefined);
 });
 
@@ -143,7 +143,7 @@ test("application wakes retain their origin, reuse receipts and remain quoted da
   assert.equal(snapshot.conversationLog[0].metadata.runtime.origin, "application");
   assert.ok(operations.includes("wake"));
   assert.ok(events.filter(event => event.type === "message").every(event => event.origin === "application"));
-  assert.match(f.requests[0].messages.at(-1).content, /\[Application event\]/);
+  assert.match(f.requests[0].messages.at(-2).content, /\[Application event\]/);
   assert.equal((await f.conversation.wake(message)).duplicate, true);
   await assert.rejects(f.conversation.send(message), { code: "conversation_message_id_content_conflict" });
   await f.conversation.send(input);
@@ -170,7 +170,7 @@ test("per-request application data stays separate from visible text and particip
   const first = await f.conversation.wait();
   assert.equal(first.conversationLog[0].user.text, "Hello");
   assert.deepEqual(first.conversationLog[0].user.data, request.data);
-  const native = f.requests[0].messages.at(-1).content;
+  const native = f.requests[0].messages.at(-2).content;
   assert.match(native, /\[Application data\]/);
   assert.match(native, /not additional instructions or authorization/);
   assert.ok(native.endsWith("Hello"));
@@ -180,7 +180,7 @@ test("per-request application data stays separate from visible text and particip
   const next = await f.conversation.wait();
   assert.equal(next.conversationLog[1].system.text, "A watched session changed.");
   assert.equal(f.requests[1].messages[1].content, native);
-  assert.match(f.requests[1].messages.at(-1).content, /\[Application event\]/);
+  assert.match(f.requests[1].messages.at(-2).content, /\[Application event\]/);
   assert.deepEqual(next.configuration, configuration, "Application data never replaces the stable system prompt");
 });
 
@@ -219,7 +219,7 @@ test("API compaction stores its summary with the last turn it covers, and later
   const second = await f.conversation.wait();
   const last = f.requests.at(-1);
   assert.match(last.messages[0].content, /Summary of the earlier part of this conversation[^]*Six long questions so far\./u);
-  assert.deepEqual(last.messages.filter(message => message.role === "user").map(message => message.content),
+  assert.deepEqual(last.messages.slice(0, -1).filter(message => message.role === "user").map(message => message.content),
     [...second.conversationLog.filter(turn => after.includes(turn.turnId)).map(turn => turn.user.text), "Continue"]);
   assert.deepEqual(await storage.read("one", transaction => transaction.readSummary()), summary, "A short remainder is not compacted again");
   const later = (await storage.read("one", transaction => transaction.readMetadata())).runtime.seen;
@@ -265,7 +265,8 @@ test("cancellation aborts inference and leaves another conversation usable", asy
   const started = Promise.withResolvers();
   let aborted = false;
   const f = await fixture(t, { fetch: (_url, init) => {
-    if (JSON.parse(init.body).messages.at(-1).content === "Other") return response();
+    // The request comes last, before the engine's state note.
+    if (JSON.parse(init.body).messages.at(-2).content === "Other") return response();
     started.resolve();
     return new Promise((_resolve, reject) => init.signal.addEventListener("abort", () => {
       aborted = true; reject(init.signal.reason);
@@ -706,6 +707,35 @@ test("native invalidation preserves synchronous fences and failures without open
   await result;
 });
 
+test("beginning native shutdown reaches the configured owner synchronously and opens no conversation", async t => {
+  const input = { reason: "server-shutdown" };
+  const calls = [];
+  let asynchronousHost = true;
+  const native = { runOwner: {
+    beginShutdown() { calls.push("begin"); return "begun"; },
+    invalidateRuntimes() { assert.fail("Beginning shutdown stops nothing."); }
+  } };
+  const runtime = createConversationRuntime({
+    authorize() { assert.fail("Trusted shutdown must not acquire session authority."); },
+    storage: {
+      read() { assert.fail("Shutdown must not read a conversation."); },
+      write() { assert.fail("Shutdown must not allocate a conversation."); }
+    },
+    host: { conversation(request) {
+      calls.push("host");
+      assert.deepEqual(request, { context, input, operation: "beginShutdown" });
+      const prepared = { engine: "codex", native, context, input };
+      return asynchronousHost ? Promise.resolve(prepared) : prepared;
+    } }
+  });
+  t.after(() => runtime.close());
+  assert.throws(() => runtime.beginNativeShutdown({ context, input }), /synchronous configured host/);
+  assert.deepEqual(calls, ["host"]);
+  asynchronousHost = false;
+  assert.equal(runtime.beginNativeShutdown({ context, input }), "begun");
+  assert.deepEqual(calls, ["host", "host", "begin"], "the owner's fence is set before the call returns");
+});
+
 test("renewal proof cleanup preserves OpenCode failure, consumption and retry through the configured owner", async t => {
   const owner = createOpenCodeSharedRuntime({});
   const calls = [];