@roj-ai/sdk 0.1.36 → 0.2.1

package/src/plugins/user-chat/plugin.ts

@@ -16,6 +16,7 @@ import { ValidationErrors } from "~/core/errors.js";
 import { createEventsFactory } from "~/core/events/types.js";
 import { estimateTokens, truncateByTokens } from "~/core/llm/tokens.js";
 import { definePlugin } from "~/core/plugins/plugin-builder.js";
+import { selectPluginState } from "~/core/sessions/reducer.js";
 import { sessionIdSchema } from "~/core/sessions/schema.js";
 import { getEntryAgentId } from "~/core/sessions/state.js";
 import { createTool } from "~/core/tools/definition.js";
@@ -67,6 +68,7 @@ export const userChatEvents = createEventsFactory({
 		user_chat_messages_consumed: z.object({
 			agentId: agentIdSchema,
 			messageIds: z.array(chatMessageIdSchema),
+			ordinals: z.array(z.number().int().positive()).optional(),
 		}),
 	},
 });
@@ -124,15 +126,18 @@ export type ChatMessage =
 // ============================================================================
 
 export interface PendingInboundMessage {
+	ordinal: number;
 	messageId: ChatMessageId;
 	agentId: AgentId;
-	content: string;
-	timestamp: number;
-	consumed: boolean;
+	/** Stable index into visible message history for user messages. */
+	messageIndex?: number;
 	/** For answers: the question's message ID */
 	questionId?: ChatMessageId;
-	/** The answer value, only present for answers */
-	answerValue?: unknown;
+}
+
+export interface PendingAnswerRecord {
+	questionId: ChatMessageId;
+	answerValue: unknown;
 }
 
 // ============================================================================
@@ -143,6 +148,14 @@ export interface UserChatState {
 	messages: ChatMessage[];
 	counter: number;
 	pendingInbound: PendingInboundMessage[];
+	/** Immutable answer payloads retained only until dequeue consumption. */
+	pendingAnswers?: Map<number, PendingAnswerRecord>;
+	/** Highest reducer-assigned inbound occurrence. */
+	nextInboundOrdinal?: number;
+}
+
+interface UserChatPluginContext {
+	nextMessageSequence: number;
 }
 
 // ============================================================================
@@ -293,18 +306,84 @@ const MESSAGE_TRUNCATION_TARGET = 5_000;
 // Helpers
 // ============================================================================
 
+function findQuestion(
+	messages: ChatMessage[],
+	questionId: ChatMessageId,
+): AskUserChatMessage | undefined {
+	for (const message of messages) {
+		if (message.type === "ask_user" && message.questionId === questionId) {
+			return message;
+		}
+	}
+	return undefined;
+}
+
+function findUserMessage(
+	messages: ChatMessage[],
+	messageId: ChatMessageId,
+): UserChatMessage | undefined {
+	for (const message of messages) {
+		if (message.type === "user_message" && message.messageId === messageId) {
+			return message;
+		}
+	}
+	return undefined;
+}
+
+function messageSequence(messageId: ChatMessageId): number {
+	const match = /^m(\d+)$/.exec(messageId);
+	return match ? Number(match[1]) : 0;
+}
+
+function nextStateCounter(state: UserChatState, messageId: ChatMessageId): number {
+	return Math.max(state.counter + 1, messageSequence(messageId));
+}
+
+function nextMessageSequence(state: UserChatState | undefined): number {
+	if (!state) return 1;
+	let highest = state.counter;
+	for (const message of state.messages) {
+		const messageId = message.type === "ask_user" ? message.questionId : message.messageId;
+		highest = Math.max(highest, messageSequence(messageId));
+	}
+	for (const pending of state.pendingInbound) {
+		highest = Math.max(highest, messageSequence(pending.messageId));
+	}
+	return highest + 1;
+}
+
+function reserveMessageSequence(context: UserChatPluginContext): number {
+	const sequence = context.nextMessageSequence;
+	context.nextMessageSequence++;
+	return sequence;
+}
+
 /**
  * Format pending inbound messages for the LLM.
  */
-function formatPendingForLLM(pending: PendingInboundMessage[]): string {
+function formatPendingForLLM(
+	messages: ChatMessage[],
+	pending: PendingInboundMessage[],
+	pendingAnswers: ReadonlyMap<number, PendingAnswerRecord> | undefined,
+): string {
 	const parts: string[] = [];
 	for (const msg of pending) {
 		if (msg.questionId !== undefined) {
+			const answer = pendingAnswers?.get(msg.ordinal);
+			const answerValue = answer
+				? answer.answerValue
+				: findQuestion(messages, msg.questionId)?.answer;
 			parts.push(
-				`[User answered question ${msg.questionId}]: ${JSON.stringify(msg.answerValue)}`,
+				`[User answered question ${msg.questionId}]: ${JSON.stringify(answerValue)}`,
 			);
 		} else {
-			parts.push(`[User]: ${msg.content}`);
+			const indexedMessage = msg.messageIndex === undefined
+				? undefined
+				: messages[msg.messageIndex];
+			const userMessage = indexedMessage?.type === "user_message"
+				? indexedMessage
+				: findUserMessage(messages, msg.messageId);
+			if (userMessage) parts.push(`[User]: ${userMessage.content}`);
 		}
 	}
 	return parts.join("\n");
@@ -365,18 +444,27 @@ function decodeAskUserDisplayStrings(input: AskUserInputType): AskUserInputType
 // ============================================================================
 
 export const userChatPlugin = definePlugin("user-chat")
+	.order(60)
 	.pluginConfig<UserChatPresetConfig>()
 	.events([userChatEvents])
+	.context(async (ctx): Promise<UserChatPluginContext> => ({
+		nextMessageSequence: nextMessageSequence(
+			selectPluginState<UserChatState>(ctx.sessionState, "messages"),
+		),
+	}))
 	.state<UserChatState>({
 		key: "messages",
 		initial: (): UserChatState => ({
 			messages: [],
 			counter: 0,
 			pendingInbound: [],
+			pendingAnswers: new Map(),
+			nextInboundOrdinal: 0,
 		}),
 		reduce: (state, event) => {
 			switch (event.type) {
 				case "user_chat_message_received": {
+					const ordinal = (state.nextInboundOrdinal ?? 0) + 1;
 					const userMessage: UserChatMessage = {
 						type: "user_message",
 						messageId: event.messageId,
@@ -384,20 +472,22 @@ export const userChatPlugin = definePlugin("user-chat")
 						timestamp: event.timestamp,
 					};
 					const pending: PendingInboundMessage = {
+						ordinal,
 						messageId: event.messageId,
 						agentId: event.agentId,
-						content: event.content,
-						timestamp: event.timestamp,
-						consumed: false,
+						messageIndex: state.messages.length,
 					};
 					return {
 						messages: [...state.messages, userMessage],
-						counter: state.counter + 1,
+						counter: nextStateCounter(state, event.messageId),
 						pendingInbound: [...state.pendingInbound, pending],
+						pendingAnswers: state.pendingAnswers,
+						nextInboundOrdinal: ordinal,
 					};
 				}
 
 				case "user_chat_answer_received": {
+					const ordinal = (state.nextInboundOrdinal ?? 0) + 1;
 					// Update the question in messages as answered
 					const updatedMessages = state.messages.map((msg) =>
 						msg.type === "ask_user" && msg.questionId === event.questionId
@@ -405,31 +495,61 @@ export const userChatPlugin = definePlugin("user-chat")
 							: msg,
 					);
 					const pending: PendingInboundMessage = {
+						ordinal,
 						messageId: event.messageId,
 						agentId: event.agentId,
-						content: JSON.stringify(event.answerValue),
-						timestamp: event.timestamp,
-						consumed: false,
 						questionId: event.questionId,
-						answerValue: event.answerValue,
 					};
+					const pendingAnswers = new Map(state.pendingAnswers ?? []);
+					pendingAnswers.set(ordinal, {
+						questionId: event.questionId,
+						answerValue: event.answerValue,
+					});
 					return {
 						messages: updatedMessages,
-						counter: state.counter + 1,
+						counter: nextStateCounter(state, event.messageId),
 						pendingInbound: [...state.pendingInbound, pending],
+						pendingAnswers,
+						nextInboundOrdinal: ordinal,
 					};
 				}
 
 				case "user_chat_messages_consumed": {
-					const consumedSet = new Set(event.messageIds.map(String));
+					const consumedOrdinals = new Set<number>();
+					if (event.ordinals) {
+						for (const ordinal of event.ordinals) consumedOrdinals.add(ordinal);
+					} else {
+						const remainingById = new Map<string, number>();
+						for (const messageId of event.messageIds) {
+							const key = String(messageId);
+							remainingById.set(key, (remainingById.get(key) ?? 0) + 1);
+						}
+						for (const pending of state.pendingInbound) {
+							if (pending.agentId !== event.agentId) continue;
+							const key = String(pending.messageId);
+							const remaining = remainingById.get(key) ?? 0;
+							if (remaining === 0) continue;
+							consumedOrdinals.add(pending.ordinal);
+							remainingById.set(key, remaining - 1);
+						}
+					}
+					const pendingAnswers = new Map(state.pendingAnswers ?? []);
+					for (const pending of state.pendingInbound) {
+						if (
+							pending.agentId === event.agentId &&
+							consumedOrdinals.has(pending.ordinal)
+						) {
+							pendingAnswers.delete(pending.ordinal);
+						}
+					}
 					return {
 						...state,
-						pendingInbound: state.pendingInbound.map((msg) =>
-							consumedSet.has(String(msg.messageId)) &&
-							msg.agentId === event.agentId
-								? { ...msg, consumed: true }
-								: msg,
+						pendingInbound: state.pendingInbound.filter(
+							(msg) =>
+								msg.agentId !== event.agentId ||
+								!consumedOrdinals.has(msg.ordinal),
 						),
+						pendingAnswers,
 					};
 				}
 
@@ -445,7 +565,7 @@ export const userChatPlugin = definePlugin("user-chat")
 					return {
 						...state,
 						messages: [...state.messages, askMessage],
-						counter: state.counter + 1,
+						counter: nextStateCounter(state, event.messageId),
 					};
 				}
 
@@ -460,7 +580,7 @@ export const userChatPlugin = definePlugin("user-chat")
 					return {
 						...state,
 						messages: [...state.messages, agentMessage],
-						counter: state.counter + 1,
+						counter: nextStateCounter(state, event.messageId),
 					};
 				}
 
@@ -497,7 +617,9 @@ export const userChatPlugin = definePlugin("user-chat")
 			messageId: z.string(),
 		}),
 		handler: async (ctx, input) => {
-			const messageId = generateChatMessageId(ctx.pluginState.counter + 1);
+			const messageId = generateChatMessageId(
+				reserveMessageSequence(ctx.pluginContext),
+			);
 			const timestamp = Date.now();
 			await ctx.emitEvent(
 				userChatEvents.create("user_question_asked", {
@@ -528,7 +650,9 @@ export const userChatPlugin = definePlugin("user-chat")
 			messageId: z.string(),
 		}),
 		handler: async (ctx, input) => {
-			const messageId = generateChatMessageId(ctx.pluginState.counter + 1);
+			const messageId = generateChatMessageId(
+				reserveMessageSequence(ctx.pluginContext),
+			);
 			const timestamp = Date.now();
 			await ctx.emitEvent(
 				userChatEvents.create("user_message_sent", {
@@ -572,7 +696,9 @@ export const userChatPlugin = definePlugin("user-chat")
 				);
 			}
 
-			const messageId = generateChatMessageId(ctx.pluginState.counter + 1);
+			const messageId = generateChatMessageId(
+				reserveMessageSequence(ctx.pluginContext),
+			);
 
 			// Soft truncation — save full content to file, pass truncated + reference
 			let content = input.content;
@@ -582,7 +708,18 @@ export const userChatPlugin = definePlugin("user-chat")
 					: null;
 			if (truncation) {
 				const filePath = `.user-messages/${messageId}.md`;
-				await ctx.files.session.write(filePath, input.content);
+				const writeResult = await ctx.files.session.write(
+					filePath,
+					input.content,
+				);
+				if (!writeResult.ok) {
+					// Without the full copy on disk the truncated message would silently lose content.
+					return Err(
+						ValidationErrors.invalid(
+							`Failed to store full message: ${writeResult.error}`,
+						),
+					);
+				}
 				content = `${truncation.content}\n\n[Full message saved to: ${filePath} — use read_file to access it]`;
 			}
 
@@ -606,7 +743,15 @@ export const userChatPlugin = definePlugin("user-chat")
 		}),
 		output: z.object({}),
 		handler: async (ctx, input) => {
-			const messageId = generateChatMessageId(ctx.pluginState.counter + 1);
+			// A retried batch resubmits answers that already landed; the agent must see one.
+			const asked = ctx.pluginState.messages.find(
+				(msg) => msg.type === "ask_user" && msg.questionId === input.questionId,
+			);
+			if (asked?.type === "ask_user" && asked.answered) return Ok({});
+
+			const messageId = generateChatMessageId(
+				reserveMessageSequence(ctx.pluginContext),
+			);
 			await ctx.emitEvent(
 				userChatEvents.create("user_chat_answer_received", {
 					agentId: input.agentId,
@@ -633,18 +778,28 @@ export const userChatPlugin = definePlugin("user-chat")
 	})
 	.dequeue({
 		hasPendingMessages: (ctx) =>
-			ctx.pluginState.pendingInbound.some(
-				(m) => !m.consumed && m.agentId === ctx.agentId,
-			),
+			ctx.pluginState.pendingInbound.some((m) => m.agentId === ctx.agentId),
 
 		getPendingMessages: (ctx) => {
 			const pending = ctx.pluginState.pendingInbound.filter(
-				(m) => !m.consumed && m.agentId === ctx.agentId,
+				(m) => m.agentId === ctx.agentId,
 			);
 			if (pending.length === 0) return null;
 			return {
-				messages: [{ role: "user", content: formatPendingForLLM(pending) }],
-				token: pending.map((m) => m.messageId),
+				messages: [
+					{
+						role: "user",
+						content: formatPendingForLLM(
+							ctx.pluginState.messages,
+							pending,
+							ctx.pluginState.pendingAnswers,
+						),
+					},
+				],
+				token: pending.map((message) => ({
+					messageId: message.messageId,
+					ordinal: message.ordinal,
+				})),
 			};
 		},
 
@@ -652,7 +807,8 @@ export const userChatPlugin = definePlugin("user-chat")
 			await ctx.emitEvent(
 				userChatEvents.create("user_chat_messages_consumed", {
 					agentId: ctx.agentId,
-					messageIds: token,
+					messageIds: token.map((item) => item.messageId),
+					ordinals: token.map((item) => item.ordinal),
 				}),
 			);
 		},
@@ -666,12 +822,12 @@ export const userChatPlugin = definePlugin("user-chat")
 
 		const userTagRegex = /<user>([\s\S]*?)<\/user>/g;
 		let match: RegExpExecArray | null;
-		let localCounter = ctx.pluginState.counter;
 		while ((match = userTagRegex.exec(responseContent)) !== null) {
 			const content = match[1].trim();
 			if (!content) continue;
-			localCounter++;
-			const chatMessageId = generateChatMessageId(localCounter);
+			const chatMessageId = generateChatMessageId(
+				reserveMessageSequence(ctx.pluginContext),
+			);
 			await ctx.emitEvent(
 				userChatEvents.create("user_message_sent", {
 					agentId: ctx.agentId,

package/src/plugins/workers/context.ts

@@ -12,13 +12,12 @@ import type { AgentId } from '~/core/agents/schema.js'
 import type { FileStore } from '~/core/file-store/types.js'
 import type { SessionId } from '~/core/sessions/schema.js'
 import type { SessionState } from '~/core/sessions/state.js'
-import { getNextMessageSeq, selectMailboxState } from '~/plugins/mailbox/query.js'
 import { generateMessageId } from '~/plugins/mailbox/schema.js'
 import { mailboxEvents } from '~/plugins/mailbox/state.js'
 import type { Logger } from '../../lib/logger/logger.js'
 import type { WorkerSubEvent } from './definition.js'
-import type { EmitEvent } from './plugin.js'
-import { workerEvents } from './plugin.js'
+import type { EmitEvent } from './state.js'
+import { workerEvents } from './state.js'
 import { WorkerId } from './worker.js'
 
 // ============================================================================
@@ -47,6 +46,14 @@ export interface WorkerContext<TState, TSubEvent extends WorkerSubEvent> {
 	/** File store for reading/writing files */
 	readonly files: FileStore
 
+	/**
+	 * True when `execute()` is re-entered for a worker that already ran — after a
+	 * runtime rebuild or a `resume`. The state handed to this run is already
+	 * reconstructed from the event log, so a resumed worker must continue from
+	 * `getState()` rather than start over.
+	 */
+	readonly resumed: boolean
+
 	/**
 	 * Get current worker state (reconstructed from events).
 	 */
@@ -54,7 +61,10 @@ export interface WorkerContext<TState, TSubEvent extends WorkerSubEvent> {
 
 	/**
 	 * Emit a worker-specific event.
-	 * The event is persisted and applied to state.
+	 *
+	 * Applies the event to local state and persists it — but only while this run is
+	 * live: once the run has been stopped (pause, cancel, session close) the emit is
+	 * skipped and nothing is persisted.
 	 */
 	emit(event: TSubEvent): Promise<void>
 
@@ -65,8 +75,9 @@ export interface WorkerContext<TState, TSubEvent extends WorkerSubEvent> {
 	shouldContinue(): boolean
 
 	/**
-	 * Check if worker is paused.
-	 * Workers should pause their work when this returns true.
+	 * Check if a pause was requested for this worker.
+	 * A pause also stops execution — `shouldContinue()` goes false and `resume`
+	 * re-enters `execute()` — so this only tells a pause from a cancellation.
 	 */
 	isPaused(): boolean
 
@@ -102,11 +113,16 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 	readonly agentId: AgentId
 	readonly logger: Logger
 	readonly files: FileStore
+	readonly resumed: boolean
 
 	private readonly workerType: string
 	private readonly emitEvent: EmitEvent
 	private readonly getSessionStateCallback: () => SessionState
 	private readonly reducer: (state: TState, event: TSubEvent) => TState
+	private readonly reserveMailboxMessageSequence: () => number
+	private readonly acquireEffectLease: () => (() => void) | null
+	private readonly inFlightEffects = new Set<Promise<void>>()
+	private readonly effectLeases = new Set<() => void>()
 	private localState: TState
 
 	/**
@@ -115,10 +131,7 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 	 */
 	private _cancelled = false
 
-	/**
-	 * Local pause flag - provides immediate signal before event is persisted.
-	 * This is set by pause() and checked by isPaused() for fast response.
-	 */
+	/** Set by pause() so a winding-down run can tell a pause from a cancellation. */
 	private _paused = false
 
 	/**
@@ -126,6 +139,7 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 	 * Aborted when cancel() is called.
 	 */
 	private readonly abortController = new AbortController()
+	private active = true
 
 	private readonly scheduleCallback?: () => void
 
@@ -137,8 +151,11 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 		files: FileStore
 		emitEvent: EmitEvent
 		getSessionState: () => SessionState
+		reserveMailboxMessageSequence: () => number
+		acquireEffectLease: () => (() => void) | null
 		reducer: (state: TState, event: TSubEvent) => TState
 		initialState: TState
+		resumed: boolean
 		logger: Logger
 		schedule?: () => void
 	}) {
@@ -149,8 +166,11 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 		this.files = params.files
 		this.emitEvent = params.emitEvent
 		this.getSessionStateCallback = params.getSessionState
+		this.reserveMailboxMessageSequence = params.reserveMailboxMessageSequence
+		this.acquireEffectLease = params.acquireEffectLease
 		this.reducer = params.reducer
 		this.localState = params.initialState
+		this.resumed = params.resumed
 		this.logger = params.logger
 		this.scheduleCallback = params.schedule
 	}
@@ -167,12 +187,21 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 	 * Applies the event to local state before persisting.
 	 */
 	async emit(event: TSubEvent): Promise<void> {
-		this.localState = this.reducer(this.localState, event)
-		await this.emitEvent(workerEvents.create('worker_sub_event', {
-			workerId: this.workerId,
-			workerType: this.workerType,
-			subEvent: event,
-		}))
+		await this.runEffect(async () => {
+			this.localState = this.reducer(this.localState, event)
+			await this.emitEvent(workerEvents.create('worker_sub_event', {
+				workerId: this.workerId,
+				workerType: this.workerType,
+				subEvent: event,
+			}))
+		})
+	}
+
+	/** Persist a terminal worker event within the context effect lifecycle. */
+	async persistTerminal(event: Parameters<EmitEvent>[0]): Promise<boolean> {
+		return this.runEffect(async () => {
+			await this.emitEvent(event)
+		})
 	}
 
 	/**
@@ -180,7 +209,7 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 	 * Returns false if cancelled.
 	 */
 	shouldContinue(): boolean {
-		return !this._cancelled
+		return this.active && !this._cancelled
 	}
 
 	/**
@@ -197,20 +226,24 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 	 * as sender, but workers need to send as WorkerId. Migrate when mailbox.send supports WorkerId.
 	 */
 	async notifyAgent(message: string): Promise<void> {
-		const messageId = generateMessageId(getNextMessageSeq(selectMailboxState(this.getSessionStateCallback())))
-
-		await this.emitEvent(mailboxEvents.create('mailbox_message', {
-			toAgentId: this.agentId,
-			message: {
-				id: messageId,
-				from: this.workerId,
-				content: message,
-				timestamp: Date.now(),
-				consumed: false,
-			},
-		}))
-
-		this.scheduleCallback?.()
+		await this.runEffect(async () => {
+			const sequence = this.reserveMailboxMessageSequence()
+			const messageId = generateMessageId(sequence)
+
+			await this.emitEvent(mailboxEvents.create('mailbox_message', {
+				toAgentId: this.agentId,
+				sequence,
+				message: {
+					id: messageId,
+					from: this.workerId,
+					content: message,
+					timestamp: Date.now(),
+					consumed: false,
+				},
+			}))
+
+			if (this.active) this.scheduleCallback?.()
+		})
 	}
 
 	/**
@@ -235,17 +268,47 @@ export class WorkerContextImpl<TState, TSubEvent extends WorkerSubEvent> impleme
 		this.abortController.abort()
 	}
 
-	/**
-	 * Mark worker as paused.
-	 */
-	pause(): void {
-		this._paused = true
+	/** Permanently disable callbacks — the worker is stopping and will never resume this run. */
+	invalidate(): void {
+		this.active = false
+		this.cancel()
+	}
+
+	/** Wait for effects that started before invalidation. */
+	async waitForEffects(): Promise<void> {
+		await Promise.allSettled([...this.inFlightEffects])
+	}
+
+	/** Give back the leases of effects that outlived their drain deadline, so a stalled write cannot pin the runtime forever. */
+	releaseEffectLeases(): void {
+		for (const release of this.effectLeases) release()
+		this.effectLeases.clear()
+	}
+
+	private async runEffect(effect: () => Promise<void>): Promise<boolean> {
+		if (!this.active) return false
+		// The runtime can start unloading between the check above and here — skip the
+		// effect rather than throw a lease error into worker code.
+		const releaseLease = this.acquireEffectLease()
+		if (!releaseLease) return false
+		this.effectLeases.add(releaseLease)
+		let promise: Promise<void> | undefined
+		try {
+			promise = effect()
+			this.inFlightEffects.add(promise)
+			await promise
+		} finally {
+			if (promise) this.inFlightEffects.delete(promise)
+			this.effectLeases.delete(releaseLease)
+			releaseLease()
+		}
+		return true
 	}
 
 	/**
-	 * Resume worker.
+	 * Record that this run is stopping because of a pause, not a cancellation.
 	 */
-	resume(): void {
-		this._paused = false
+	pause(): void {
+		this._paused = true
 	}
 }

package/src/plugins/workers/definition.ts

@@ -101,6 +101,13 @@ export interface WorkerDefinition<
 	/**
 	 * Main execution logic.
 	 * The worker runs until completion, failure, or cancellation.
+	 *
+	 * Re-entrant, and must be idempotent: a rebuilt session runtime and
+	 * `workers.resume` both call this again from the top, with `context.resumed`
+	 * true and the state already replayed from the event log. Drive the loop from
+	 * `context.getState()` and emit the event that records a side effect before
+	 * performing it — never from local variables seeded at entry, which a re-entry
+	 * resets while the persisted state moves on.
 	 */
 	execute(
 		config: TConfig,

package/src/plugins/workers/index.ts

@@ -1,10 +1,10 @@
 // Plugin
-export { workerPlugin } from './plugin.js'
+export { MAX_CONCURRENT_WORKERS, WORKER_EFFECT_DRAIN_TIMEOUT_MS, WORKER_STOP_TIMEOUT_MS, workerPlugin } from './plugin.js'
 export type { WorkerAgentConfig, WorkerPresetConfig } from './plugin.js'
 
 // Events (now in plugin.ts)
-export { workerEvents } from './plugin.js'
-export type { WorkerCompletedEvent, WorkerFailedEvent, WorkerStartedEvent, WorkerStatusChangedEvent, WorkerSubEventEmittedEvent } from './plugin.js'
+export { workerEvents } from './state.js'
+export type { WorkerCompletedEvent, WorkerFailedEvent, WorkerStartedEvent, WorkerStatusChangedEvent, WorkerSubEventEmittedEvent } from './state.js'
 
 // Definition
 export type { WorkerDefinition, WorkerSubEvent } from './definition.js'
@@ -18,4 +18,4 @@ export { WorkerContextImpl } from './context.js'
 export type { WorkerError, WorkerResult } from './worker.js'
 
 // Types
-export type { EmitEvent } from './plugin.js'
+export type { EmitEvent } from './state.js'