@@ -287,14 +287,14 @@ The checker applies every event except the seven turn events in every reachable
 
 The checker also requires:
 
-- the seven turn events (`turnStarted`, `firstChunkAwaitStarted`, `firstChunkAwaitEnded`, `toolRejected`, `toolUsed`, `toolFailed`, `streamReadCompleted`) to be accepted and to match the table in each of the 32 turn states. A shape is a group of reachable states with the same phase, stream, ask, latches and completion marker. The states in one shape also agree on whether a stream started, and whether the generation and the ask count are below their caps. The checker takes one state of each shape and gives it each of the 32 turn states. It applies every event to each of these states. Thus every other event must change the turn only as the table allows. The known-unsafe kernel runs use only two turn states: all false and all true. The search does not include the turn events, because they would make the state count 32 times larger;
+- the seven turn events (`turnStarted`, `firstChunkAwaitStarted`, `firstChunkAwaitEnded`, `toolRejected`, `toolUsed`, `toolFailed`, `streamReadCompleted`) to be accepted and to match the table in each of the 32 turn states. A shape is a group of reachable states with the same phase, stream, ask tag and timestamp, latches and completion marker. The states in one shape also agree on whether a stream started, and whether the generation and the ask count are below their caps. The checker takes one state of each shape and gives it each of the 32 turn states. It applies every event to each of these states. Thus every other event must change the turn only as the table allows. The known-unsafe kernel runs use only two turn states, all false and all true, except for a mixed-turn-only mutant that requires all 32. Separate mutants check that starting an ask preserves the turn after pending approvals with timestamps 1 and 2, before any stream or cancellation. The search does not include the turn events, because they would make the state count 32 times larger;
 - the event tags in `runState.ts` to equal the event tags in the table (once, at startup, as a text scan of `case` labels);
 - every event to be reachable, with the `askSettledStale` no-op, a settle for an ask that a newer pending ask replaced, as its own action;
 - every guard clause to be the only failing clause in some rejected event;
 - named witnesses, each tied to an event and the states around it: abort during a pending approval in a live stream, an ask after the stream ends, abandon after the stream ends, dispose after completion, a new stream after a failure cleanup without abort, a stream that starts without user input, an approval before the first stream, and a rejected late completion accept after a newer ask;
 - every ordered pair of the stream, ask, cancel, and dispose event sources to follow each other, where both events change the state;
 - no unseen successor at the depth bound;
-- thirty-nine known-unsafe kernels. The checker must reject each of them. They include a throwing kernel, a kernel that returns nothing and a kernel that returns both `ok` and `rejected`. There is also one kernel for each check that runs at every search step without the table; and
+- forty-two known-unsafe kernels. The checker must reject each of them. They include a throwing kernel, a kernel that returns nothing and a kernel that returns both `ok` and `rejected`. There is also one kernel for each check that runs at every search step without the table; and
 - self-tests that a small depth bound and a small state budget each fail the checker.
 
 The kernel has no resume event. A resumed task is `initialized` followed by `streamStarted` or `askStarted`. The witnesses `first-stream-without-ask` and `approval-before-first-stream` cover those paths.
 
@@ -480,6 +480,7 @@ const shapeOf = ({ run, askCount }: ModelState) =>
 		belowAskCap: askCount < MAX_ASK_TS,
 		stream: run.stream.tag === "live" ? run.stream.cleanupFinished : "none",
 		ask: run.ask.tag,
+		askTs: run.ask.tag === "none" ? undefined : run.ask.askTs,
 		latches: run.latches,
 		lastCompletionAskTs: run.lastCompletionAskTs !== undefined,
 	})
@@ -638,6 +639,7 @@ interface UnsafeKernel {
 	step: Step
 	caughtBy: RegExp
 	useTable: boolean
+	allTurnStates?: boolean
 }
 
 const differsFor = (tag: EventTag) =>
@@ -849,6 +851,38 @@ const unsafeKernels: Record<string, UnsafeKernel> = {
 		caughtBy: differsFor("askStarted"),
 		useTable: true,
 	},
+	"ask-start-resets-mixed-turn": {
+		step: (state, event) => {
+			const result = nextRunState(state, event)
+			return event.tag === "askStarted" && "ok" in result && state.turn.toolUsed && !state.turn.toolFailed
+				? { ok: { ...result.ok, turn: { ...result.ok.turn, toolUsed: false } } }
+				: result
+		},
+		caughtBy: differsFor("askStarted"),
+		useTable: true,
+		allTurnStates: true,
+	},
+	...Object.fromEntries(
+		[1, 2].map((askTs): [string, UnsafeKernel] => [
+			`ask-start-resets-turn-after-approval-${askTs}`,
+			{
+				step: (state, event) => {
+					const result = nextRunState(state, event)
+					return event.tag === "askStarted" &&
+						"ok" in result &&
+						state.ask.tag === "approval" &&
+						state.ask.askTs === askTs &&
+						state.generation === 0 &&
+						!state.latches.abort &&
+						state.latches.reason === undefined
+						? { ok: { ...result.ok, turn: { ...result.ok.turn, toolUsed: false } } }
+						: result
+				},
+				caughtBy: differsFor("askStarted"),
+				useTable: true,
+			},
+		]),
+	),
 	"later-stream-start-resets-turn": {
 		step: (state, event) => {
 			const result = nextRunState(state, event)
@@ -973,8 +1007,8 @@ const unsafeKernels: Record<string, UnsafeKernel> = {
 }
 
 function runUnsafeKernels(): void {
-	for (const [name, { step, caughtBy, useTable }] of Object.entries(unsafeKernels)) {
-		const options = { step, useTable, maxDepth: MAX_DEPTH, maxStates: MAX_STATES, allTurnStates: false }
+	for (const [name, { step, caughtBy, useTable, allTurnStates = false }] of Object.entries(unsafeKernels)) {
+		const options = { step, useTable, maxDepth: MAX_DEPTH, maxStates: MAX_STATES, allTurnStates }
 		assert.throws(() => runModelCheck(options), caughtBy, `unsafe kernel not caught as expected: ${name}`)
 	}
 }