@namzu/sdk 1.0.0 → 1.2.0

package/src/runtime/query/__tests__/orphan-task-turn-end.test.ts

@@ -0,0 +1,127 @@
+import { rm } from 'node:fs/promises'
+import { mkdtemp } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { ToolRegistry } from '../../../registry/tool/execute.js'
+import type { TaskGateway, TaskHandle } from '../../../types/agent/gateway.js'
+import type { SessionId, TaskId, TenantId } from '../../../types/ids/index.js'
+import { createUserMessage } from '../../../types/message/index.js'
+import type { LLMProvider, StreamChunk } from '../../../types/provider/index.js'
+import type { RunEvent } from '../../../types/run/index.js'
+import type { ProjectId, ThreadId } from '../../../types/session/ids.js'
+import { drainQuery } from '../index.js'
+
+const ZERO_USAGE = {
+	promptTokens: 0,
+	completionTokens: 0,
+	totalTokens: 0,
+	cachedTokens: 0,
+	cacheWriteTokens: 0,
+}
+
+/** Ends its turn with plain text on the first (and only) call. */
+class SingleTurnProvider implements LLMProvider {
+	readonly id = 'single-turn'
+	readonly name = 'Single Turn Provider'
+	calls = 0
+
+	async *chatStream(): AsyncIterable<StreamChunk> {
+		this.calls += 1
+		yield {
+			id: `msg_${this.calls}`,
+			delta: { content: 'Final answer.' },
+		}
+		yield {
+			id: `msg_${this.calls}`,
+			delta: {},
+			finishReason: 'stop',
+			usage: ZERO_USAGE,
+		}
+	}
+}
+
+/**
+ * Gateway that permanently reports one running task. Every dispatch
+ * tool is blocking, so a running task at end-of-turn is an orphan —
+ * there is no notification producer that could ever deliver its
+ * result (the listener was removed in dc16d58). The run must NOT
+ * busy-wait on it.
+ */
+function orphanTaskGateway(): TaskGateway {
+	const handle: TaskHandle = {
+		taskId: 'task_orphan' as TaskId,
+		agentId: 'agent_worker',
+		state: 'running',
+		createdAt: Date.now(),
+	}
+	return {
+		createTask: async () => handle,
+		waitForTask: () => new Promise<TaskHandle>(() => {}),
+		continueTask: async () => {},
+		cancelTask: () => {},
+		getTask: () => handle,
+		listTasks: () => [handle],
+		onTaskCompleted: () => () => {},
+	}
+}
+
+describe('end of turn with running agent tasks', () => {
+	let workdirs: string[] = []
+
+	afterEach(async () => {
+		await Promise.all(workdirs.map((dir) => rm(dir, { recursive: true, force: true })))
+		workdirs = []
+	})
+
+	// Regression: the loop used to poll `pendingNotifications` every
+	// 250ms for up to `runConfig.timeoutMs` (120s default) whenever the
+	// turn ended while the gateway still listed a running task — but
+	// nothing has pushed onto that queue since dc16d58 removed the
+	// onTaskCompleted producer, so the wait always injected nothing and
+	// the run hung for minutes. The vitest per-test timeout is the
+	// hang detector here: with the busy-wait present this test times
+	// out instead of completing.
+	it('ends the run promptly instead of busy-waiting on orphan tasks', async () => {
+		const provider = new SingleTurnProvider()
+		const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-orphan-task-'))
+		workdirs.push(workingDirectory)
+		const events: RunEvent[] = []
+
+		const run = await drainQuery(
+			{
+				provider,
+				tools: new ToolRegistry(),
+				runConfig: {
+					model: 'mock-model',
+					// Deliberately longer than the vitest timeout: the old
+					// code waited min(timeoutMs, …) polling the dead queue.
+					timeoutMs: 120_000,
+					tokenBudget: 100_000,
+					maxIterations: 3,
+					maxResponseTokens: 256,
+				},
+				agentId: 'agent_test',
+				agentName: 'Test Agent',
+				messages: [createUserMessage('do the thing')],
+				workingDirectory,
+				taskGateway: orphanTaskGateway(),
+				sessionId: 'ses_orphan_task' as SessionId,
+				threadId: 'thd_orphan_task' as ThreadId,
+				projectId: 'prj_orphan_task' as ProjectId,
+				tenantId: 'tnt_orphan_task' as TenantId,
+			},
+			(event) => {
+				events.push(event)
+			},
+		)
+
+		expect(run.status).toBe('completed')
+		expect(run.stopReason).toBe('end_turn')
+		expect(run.result).toBe('Final answer.')
+		// One turn only — no futile re-invocation loop on the orphan.
+		expect(provider.calls).toBe(1)
+		expect(events.some((event) => event.type === 'run_failed')).toBe(false)
+	}, 10_000)
+})

package/src/runtime/query/__tests__/prompt.test.ts

@@ -43,18 +43,21 @@ describe('PromptBuilder runtime context', () => {
 			skills: [
 				{
 					metadata: {
-						name: 'project-documents',
-						description: 'Draft and edit project documents from grounded inputs.',
+						name: 'delivery-briefing',
+						description: 'Draft and edit delivery briefings from grounded inputs.',
 					},
-					dirPath: '/repo/.agents/skills/project-documents',
+					dirPath: '/repo/.agents/skills/delivery-briefing',
 				},
 			],
 		}).build('full', '/tmp/work')
 
 		expect(prompt).toContain('You are a project assistant.')
 		expect(prompt).toContain('## Available Skills')
-		expect(prompt).toContain('project-documents')
-		expect(prompt).toContain('Draft and edit project documents')
+		expect(prompt).toContain('<available_skills>')
+		expect(prompt).toContain('delivery-briefing')
+		expect(prompt).toContain('Draft and edit delivery briefings')
+		expect(prompt).toContain('<location>/repo/.agents/skills/delivery-briefing/SKILL.md</location>')
+		expect(prompt).toContain('The following block is a manifest')
 		expect(prompt).not.toContain('## Loaded Skills')
 	})
 
@@ -65,22 +68,23 @@ describe('PromptBuilder runtime context', () => {
 			skills: [
 				{
 					metadata: {
-						name: 'long-form-files',
-						description: 'Create long files with bounded edit chunks.',
+						name: 'structured-file-authoring',
+						description: 'Create structured files with bounded edit chunks.',
 						license: 'MIT',
 						compatibility: 'Requires file tools',
 						allowedTools: 'read write edit',
 					},
 					body: 'Use skeleton-first writes and bounded edit chunks.',
-					dirPath: '/repo/.agents/skills/long-form-files',
+					dirPath: '/repo/.agents/skills/structured-file-authoring',
 				},
 			],
 		}).build('full', '/tmp/work')
 
 		expect(prompt).toContain('## Available Skills')
-		expect(prompt).toContain('license: MIT')
-		expect(prompt).toContain('compatibility: Requires file tools')
-		expect(prompt).toContain('allowed-tools: read write edit')
+		expect(prompt).toContain('<license>MIT</license>')
+		expect(prompt).toContain('<compatibility>Requires file tools</compatibility>')
+		expect(prompt).toContain('<allowed_tools>read write edit</allowed_tools>')
+		expect(prompt).toContain('read the SKILL.md at its <location> before writing code')
 		expect(prompt).toContain('## Loaded Skills')
 		expect(prompt).toContain('Use skeleton-first writes')
 	})

package/src/runtime/query/checkpoint.ts

@@ -1,5 +1,4 @@
 import type { RunPersistence } from '../../manager/run/persistence.js'
-import type { RunDiskStore } from '../../store/run/disk.js'
 import type {
 	ActiveNodeInfo,
 	BranchStackEntry,
@@ -8,13 +7,19 @@ import type {
 	IterationCheckpoint,
 } from '../../types/hitl/index.js'
 import type { AssistantMessage } from '../../types/message/index.js'
+import type { CheckpointRunScope, CheckpointStore } from '../../types/run/checkpoint-store.js'
 import type { EmergencySaveData } from '../../types/run/emergency.js'
 import type { CheckpointListEntry } from '../../types/run/replay.js'
 import { ZERO_COST } from '../../utils/cost.js'
 import { buildToolResultHashes } from '../../utils/hash.js'
 import { generateCheckpointId } from '../../utils/id.js'
 
-function toCheckpointListEntry(cp: IterationCheckpoint): CheckpointListEntry {
+/**
+ * Projection from a full checkpoint payload to the public listing entry.
+ * Exported for the replay `listCheckpoints` entry point, which projects
+ * store results without constructing a `CheckpointManager`.
+ */
+export function toCheckpointListEntry(cp: IterationCheckpoint): CheckpointListEntry {
 	return {
 		id: cp.id,
 		runId: cp.runId,
@@ -55,10 +60,19 @@ export function projectEmergencyToCheckpoint(dump: EmergencySaveData): Iteration
 }
 
 export class CheckpointManager {
-	private store: RunDiskStore
+	private store: CheckpointStore
+	private scope: CheckpointRunScope
 
-	constructor(store: RunDiskStore) {
+	/**
+	 * @param store scope-keyed checkpoint persistence. The default query
+	 *   pipeline passes the run's disk-backed store
+	 *   ({@link import('../../store/run/checkpoint-disk.js').DiskCheckpointStore});
+	 *   hosts inject their own via `QueryParams.checkpointStore`.
+	 * @param scope the run every operation of this manager is keyed to.
+	 */
+	constructor(store: CheckpointStore, scope: CheckpointRunScope) {
 		this.store = store
+		this.scope = scope
 	}
 
 	async create(
@@ -87,12 +101,12 @@ export class CheckpointManager {
 			activeNode: extra?.activeNode,
 		}
 
-		await this.store.writeCheckpoint(checkpoint)
+		await this.store.writeCheckpoint(this.scope, checkpoint)
 		return checkpoint
 	}
 
 	async restore(checkpointId: CheckpointId): Promise<IterationCheckpoint> {
-		const checkpoint = await this.store.readCheckpoint(checkpointId)
+		const checkpoint = await this.store.readCheckpoint(this.scope, checkpointId)
 		if (!checkpoint) {
 			throw new Error(`Checkpoint not found: ${checkpointId}`)
 		}
@@ -100,7 +114,7 @@ export class CheckpointManager {
 	}
 
 	async list(): Promise<IterationCheckpoint[]> {
-		return this.store.listCheckpoints()
+		return this.store.listCheckpoints(this.scope)
 	}
 
 	/**
@@ -110,7 +124,7 @@ export class CheckpointManager {
 	 * full checkpoint payload. See ses_005-deterministic-replay design §3.1.
 	 */
 	async listEntries(): Promise<CheckpointListEntry[]> {
-		const checkpoints = await this.store.listCheckpoints()
+		const checkpoints = await this.store.listCheckpoints(this.scope)
 		return checkpoints.map(toCheckpointListEntry)
 	}
 
@@ -121,7 +135,7 @@ export class CheckpointManager {
 		const toDelete = all.sort((a, b) => a.createdAt - b.createdAt).slice(0, all.length - keepLast)
 
 		for (const cp of toDelete) {
-			await this.store.deleteCheckpoint(cp.id)
+			await this.store.deleteCheckpoint(this.scope, cp.id)
 		}
 	}
 

package/src/runtime/query/context.ts

@@ -15,6 +15,7 @@ import type { RunId, SessionId, TenantId } from '../../types/ids/index.js'
 import type { Message } from '../../types/message/index.js'
 import type { PermissionMode } from '../../types/permission/index.js'
 import type { LLMProvider } from '../../types/provider/index.js'
+import type { CheckpointStore } from '../../types/run/checkpoint-store.js'
 import type { AgentRunConfig } from '../../types/run/index.js'
 import type { ProjectId, ThreadId } from '../../types/session/ids.js'
 import type { ModelPricing } from '../../utils/cost.js'
@@ -55,6 +56,13 @@ export interface RunContextConfig {
 
 	pathBuilder?: PathBuilder
 
+	/**
+	 * Optional checkpoint persistence override, threaded through to
+	 * {@link RunPersistence}. Absent ⇒ disk default under the run's
+	 * output directory.
+	 */
+	checkpointStore?: CheckpointStore
+
 	/**
 	 * Optional injected migrator — tests pass a stub; production code relies
 	 * on the {@link DefaultFilesystemMigrator}. See session-hierarchy.md
@@ -162,6 +170,7 @@ export class RunContextFactory {
 			projectId: config.projectId,
 			parentRunId: config.parentRunId,
 			depth: config.depth,
+			checkpointStore: config.checkpointStore,
 		})
 
 		const trackingConfig = resolveActivityTracking(permissionMode, config.enableActivityTracking)

package/src/runtime/query/index.ts

@@ -7,6 +7,7 @@ import {
 import { extractFromUserMessage } from '../../compaction/extractor.js'
 import { WorkingStateManager } from '../../compaction/manager.js'
 import type { CompactionConfig } from '../../config/runtime.js'
+import { resolveProviderCapabilities } from '../../provider/capabilities.js'
 import type { PathBuilder } from '../../session/workspace/path-builder.js'
 import { GENAI, NAMZU, agentRunSpanName } from '../../telemetry/attributes.js'
 import { getTracer } from '../../telemetry/runtime-accessors.js'
@@ -16,6 +17,7 @@ import { buildTaskTools } from '../../tools/task/index.js'
 import type { AdvisoryConfig } from '../../types/advisory/index.js'
 import type { AgentRuntimeContext, RuntimeToolOverrides } from '../../types/agent/base.js'
 import type { AgentContextLevel } from '../../types/agent/factory.js'
+import type { WorkingMemoryProvider } from '../../types/agent/working-memory.js'
 import {
 	type CheckpointId,
 	type ResumeHandler,
@@ -27,6 +29,7 @@ import { type Message, createSystemMessage } from '../../types/message/index.js'
 import type { AgentPersona } from '../../types/persona/index.js'
 import type { LLMProvider } from '../../types/provider/index.js'
 import type { TaskRouterConfig } from '../../types/router/index.js'
+import type { CheckpointStore } from '../../types/run/checkpoint-store.js'
 import type { AgentRunConfig, Run, RunEvent, RunEventListener } from '../../types/run/index.js'
 import type { Sandbox, SandboxProvider } from '../../types/sandbox/index.js'
 import type { ProjectId, ThreadId } from '../../types/session/ids.js'
@@ -42,6 +45,8 @@ import { RunContextFactory } from './context.js'
 import { EventTranslator } from './events.js'
 import { GuardCoordinator } from './guard.js'
 import { IterationOrchestrator } from './iteration/index.js'
+import { isCompactionMessage } from './iteration/phases/compaction.js'
+import { isWorkingMemoryMessage } from './iteration/phases/working-memory.js'
 import { applyLifecycleHookResults } from './plugin-hooks.js'
 import { PromptBuilder } from './prompt.js'
 import type { PromptSegments } from './prompt.js'
@@ -92,6 +97,15 @@ export interface QueryParams {
 	 */
 	pathBuilder?: PathBuilder
 
+	/**
+	 * Optional checkpoint persistence override. Absent ⇒ iteration
+	 * checkpoints go to the disk layout under the run's output directory
+	 * (today's behavior). A host injects a scope-keyed
+	 * {@link CheckpointStore} (e.g. Postgres-backed) so mid-turn resume
+	 * survives machines that lose their local disk.
+	 */
+	checkpointStore?: CheckpointStore
+
 	runId?: RunId
 
 	parentRunId?: RunId
@@ -127,6 +141,15 @@ export interface QueryParams {
 
 	compactionConfig?: CompactionConfig
 
+	/**
+	 * Optional neutral working-memory seam. When set, the iteration loop
+	 * re-renders the provider's string into a single pinned leading system
+	 * message every turn (the primacy-edge, compaction-preserved slot).
+	 * Absent ⇒ `refreshWorkingMemory` early-returns and the run path is
+	 * byte-identical.
+	 */
+	workingMemoryProvider?: WorkingMemoryProvider
+
 	agentBus?: import('../../bus/index.js').AgentBus
 
 	verificationGate?: VerificationGateConfig
@@ -136,6 +159,18 @@ export interface QueryParams {
 	sandboxProvider?: SandboxProvider
 
 	invocationState?: InvocationState
+
+	/**
+	 * Capability-mismatch handling. Default `false`: when the request asks
+	 * for something the provider driver declared it cannot do (tools
+	 * registered against a `supportsTools: false` driver, image
+	 * attachments against a `supportsVision: false` driver), the runtime
+	 * warns loudly, emits a `capability_warning` run event, and degrades
+	 * explicitly (tool surfaces stripped from prompt + request;
+	 * attachments left unmapped by the driver). `true`: throw instead of
+	 * degrading.
+	 */
+	strictCapabilities?: boolean
 }
 
 export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run> {
@@ -162,6 +197,7 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		projectId: params.projectId,
 		tenantId: params.tenantId,
 		pathBuilder: params.pathBuilder,
+		checkpointStore: params.checkpointStore,
 		runId: params.runId,
 		parentRunId: params.parentRunId,
 		depth: params.depth,
@@ -187,7 +223,15 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		})
 
 		if (decision.action === 'approve_plan') {
-			return { approved: true }
+			// Optional approve-with-edits channel: the host may attach
+			// feedback to an approval. `PlanApprovalResponse.feedback`
+			// already exists on the type; threading it through lets the
+			// coordinator's approve_plan tool surface the user's edits in
+			// the same tool_result that unblocks the park. Bare approvals
+			// stay byte-identical (`{ approved: true }`).
+			return decision.feedback
+				? { approved: true, feedback: decision.feedback }
+				: { approved: true }
 		}
 		if (decision.action === 'reject_plan') {
 			return { approved: false, feedback: decision.feedback }
@@ -224,7 +268,45 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		}
 	}
 
-	const effectiveAllowedTools = withDeferredDiscoveryTool(params.tools, params.allowedTools)
+	// ─── Provider capability negotiation (before tooling bootstrap) ────────
+	// Compare what the request asks for with what the DRIVER declared it
+	// does. Undeclared capabilities resolve permissively (today's behavior
+	// for third-party providers); declared gaps degrade loudly instead of
+	// silently.
+	const capabilities = resolveProviderCapabilities(params.provider)
+	const registeredToolCount = params.tools.listNames().length
+	const stripToolSurfaces = !capabilities.supportsTools && registeredToolCount > 0
+	const attachmentMessageCount = capabilities.supportsVision
+		? 0
+		: params.messages.filter(
+				(m) => m.role === 'user' && m.attachments !== undefined && m.attachments.length > 0,
+			).length
+
+	if (stripToolSurfaces) {
+		const message = `Provider '${params.provider.id}' declares supportsTools: false but ${registeredToolCount} tool(s) are registered — stripping all tool surfaces from the prompt and request so the model is never told about tools it cannot call. Pass strictCapabilities: true to fail instead, or use a tools-capable provider.`
+		if (params.strictCapabilities) {
+			throw new Error(message)
+		}
+		ctx.log.warn(`CAPABILITY MISMATCH: ${message}`, {
+			providerId: params.provider.id,
+			registeredToolCount,
+		})
+	}
+
+	if (attachmentMessageCount > 0) {
+		const message = `Provider '${params.provider.id}' declares supportsVision: false but ${attachmentMessageCount} user message(s) carry image attachments — the driver will not map them, so the model never sees the images. Pass strictCapabilities: true to fail instead, or use a vision-capable provider.`
+		if (params.strictCapabilities) {
+			throw new Error(message)
+		}
+		ctx.log.warn(`CAPABILITY MISMATCH: ${message}`, {
+			providerId: params.provider.id,
+			attachmentMessageCount,
+		})
+	}
+
+	const effectiveAllowedTools = stripToolSurfaces
+		? []
+		: withDeferredDiscoveryTool(params.tools, params.allowedTools)
 
 	const toolExecutor = ToolingBootstrap.init(
 		{
@@ -266,7 +348,10 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		maxIterations: params.runConfig.maxIterations,
 	})
 
-	const checkpointMgr = new CheckpointManager(ctx.runMgr.getRunStore())
+	const checkpointMgr = new CheckpointManager(
+		ctx.runMgr.getCheckpointStore(),
+		ctx.runMgr.getRunScope(),
+	)
 
 	const resultAssembler = new ResultAssembler({
 		runMgr: ctx.runMgr,
@@ -310,34 +395,33 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		? new VerificationGate(params.verificationGate, ctx.log)
 		: undefined
 
-	const iterationOrchestrator = new IterationOrchestrator(
-		{
-			provider: params.provider,
-			runConfig: params.runConfig,
-			tools: params.tools,
-			allowedTools: effectiveAllowedTools,
-			taskGateway: params.taskGateway,
-			taskStore: params.taskStore,
-			launchedTasks: params.launchedTasks,
-			advisoryCtx,
-			compactionConfig: params.compactionConfig,
-			workingStateManager,
-			agentBus: params.agentBus,
-			verificationGate: verificationGate,
-			pluginManager: params.pluginManager,
-		},
-		ctx.runMgr,
+	const iterationOrchestrator = new IterationOrchestrator({
+		provider: params.provider,
+		runConfig: params.runConfig,
+		tools: params.tools,
+		allowedTools: effectiveAllowedTools,
+		runMgr: ctx.runMgr,
 		toolExecutor,
 		guard,
-		ctx.activityStore,
-		eventTranslator.emitEvent,
-		() => eventTranslator.drainPending(),
-		ctx.abortController,
-		ctx.log,
-		params.resumeHandler,
+		activityStore: ctx.activityStore,
+		emitEvent: eventTranslator.emitEvent,
+		drainPending: () => eventTranslator.drainPending(),
+		abortController: ctx.abortController,
+		log: ctx.log,
+		resumeHandler: params.resumeHandler,
 		checkpointMgr,
-		ctx.planManager,
-	)
+		planManager: ctx.planManager,
+		taskGateway: params.taskGateway,
+		taskStore: params.taskStore,
+		launchedTasks: params.launchedTasks ?? new Map(),
+		compactionConfig: params.compactionConfig,
+		workingStateManager,
+		workingMemoryProvider: params.workingMemoryProvider,
+		advisoryCtx,
+		agentBus: params.agentBus,
+		verificationGate,
+		pluginManager: params.pluginManager,
+	})
 
 	const tracer = getTracer()
 
@@ -408,7 +492,18 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 
 				pushSystemMessages()
 				for (const msg of checkpoint.messages) {
-					if (msg.role === 'system') continue
+					if (msg.role === 'system') {
+						// Re-push the FRESH static/dynamic floor (done above) but PRESERVE
+						// the two system messages that carry irreplaceable run state: the
+						// `[COMPACTED CONTEXT]` summary is the only surviving record of the
+						// older history a compaction pass deleted, and the working-memory
+						// slot pins the produced-artifact ledger. Dropping every system
+						// message on restore silently lost both on resume.
+						if (isCompactionMessage(msg.content) || isWorkingMemoryMessage(msg.content)) {
+							ctx.runMgr.pushMessage(msg)
+						}
+						continue
+					}
 					ctx.runMgr.pushMessage(msg)
 				}
 			} else if (params.continuationMode) {
@@ -442,6 +537,30 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 			})
 			yield* eventTranslator.drainPending()
 
+			// Surface capability degradation to the host as run events —
+			// explicit, not silent (the log.warn above fires at setup time;
+			// this is the machine-readable channel).
+			if (stripToolSurfaces) {
+				await eventTranslator.emitEvent({
+					type: 'capability_warning',
+					runId: ctx.runMgr.id,
+					capability: 'tools',
+					providerId: params.provider.id,
+					message: `Provider '${params.provider.id}' does not support tools — ${registeredToolCount} registered tool(s) were stripped from the prompt and request.`,
+				})
+				yield* eventTranslator.drainPending()
+			}
+			if (attachmentMessageCount > 0) {
+				await eventTranslator.emitEvent({
+					type: 'capability_warning',
+					runId: ctx.runMgr.id,
+					capability: 'vision',
+					providerId: params.provider.id,
+					message: `Provider '${params.provider.id}' does not support vision — image attachments on ${attachmentMessageCount} user message(s) will not reach the model.`,
+				})
+				yield* eventTranslator.drainPending()
+			}
+
 			if (params.pluginManager) {
 				const hookResults = await params.pluginManager.executeHooks(
 					'run_start',