@namzu/sdk 0.1.5-rc.1-fix → 0.1.5

package/src/plugin/__tests__/enable-contributions.test.ts

@@ -0,0 +1,295 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { PluginRegistry } from '../../registry/plugin/index.js'
+import type { PluginId } from '../../types/ids/index.js'
+import type { PluginDefinition } from '../../types/plugin/index.js'
+import type { ToolDefinition, ToolRegistryContract } from '../../types/tool/index.js'
+import type { Logger } from '../../utils/logger.js'
+import { PluginLifecycleManager } from '../lifecycle.js'
+
+const mockConnect = vi.fn(async (): Promise<unknown> => undefined)
+const mockDisconnect = vi.fn(async (): Promise<void> => undefined)
+const mockListTools = vi.fn(async (): Promise<unknown[]> => [])
+
+vi.mock('../../connector/mcp/client.js', () => ({
+	MCPClient: vi.fn().mockImplementation(() => ({
+		id: 'mcp-client-mock',
+		connect: mockConnect,
+		disconnect: mockDisconnect,
+		listTools: mockListTools,
+	})),
+}))
+
+vi.mock('../../connector/mcp/adapter.js', () => ({
+	mcpToolToToolDefinition: vi.fn((mcpTool: { name: string }) => ({
+		name: mcpTool.name,
+		description: `mcp tool ${mcpTool.name}`,
+		inputSchema: { parse: vi.fn() } as any,
+		async execute() {
+			return { success: true, output: 'ok' }
+		},
+	})),
+}))
+
+function makeLogger(): Logger {
+	const s = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+	return { ...s, child: vi.fn(() => ({ ...s, child: vi.fn() })) } as unknown as Logger
+}
+
+function makePluginRegistry(base: Partial<PluginDefinition>): {
+	registry: PluginRegistry
+	state: { current: PluginDefinition }
+} {
+	const state = {
+		current: {
+			id: 'plugin_test' as PluginId,
+			manifest: base.manifest ?? {
+				name: 'test-plugin',
+				version: '0.0.1',
+				description: 'test',
+			},
+			scope: 'project',
+			status: 'installed',
+			rootDir: '/tmp/plugin',
+			installedAt: 0,
+			...base,
+		} as PluginDefinition,
+	}
+	const registry = {
+		register: vi.fn((def: PluginDefinition) => {
+			state.current = def
+		}),
+		unregister: vi.fn(),
+		getOrThrow: vi.fn(() => state.current),
+		findByName: vi.fn(),
+		getAll: vi.fn(() => [state.current]),
+	} as unknown as PluginRegistry
+	return { registry, state }
+}
+
+function makeToolRegistry(): ToolRegistryContract {
+	const names: string[] = []
+	return {
+		register: vi.fn((tool: ToolDefinition) => {
+			names.push(tool.name)
+		}),
+		unregister: vi.fn((name: string) => {
+			const i = names.indexOf(name)
+			if (i >= 0) names.splice(i, 1)
+		}),
+		listNames: vi.fn(() => [...names]),
+		has: vi.fn((name: string) => names.includes(name)),
+		get: vi.fn(),
+		execute: vi.fn(),
+		getAvailability: vi.fn(),
+	} as unknown as ToolRegistryContract
+}
+
+describe('PluginLifecycleManager enable() contribution types', () => {
+	const pluginId = 'plugin_test' as PluginId
+
+	beforeEach(() => {
+		mockConnect.mockReset()
+		mockDisconnect.mockReset()
+		mockListTools.mockReset()
+	})
+
+	describe('unsupported contribution types', () => {
+		it('throws when manifest declares skills', async () => {
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'p',
+					version: '0.0.1',
+					description: 't',
+					skills: ['./s'],
+				},
+			})
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry: makeToolRegistry(),
+				log: makeLogger(),
+			})
+			await expect(mgr.enable(pluginId)).rejects.toThrow(/\[skills\]/)
+		})
+
+		it('throws when manifest declares connectors', async () => {
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'p',
+					version: '0.0.1',
+					description: 't',
+					connectors: ['./c'],
+				},
+			})
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry: makeToolRegistry(),
+				log: makeLogger(),
+			})
+			await expect(mgr.enable(pluginId)).rejects.toThrow(/\[connectors\]/)
+		})
+
+		it('throws when manifest declares personas', async () => {
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'p',
+					version: '0.0.1',
+					description: 't',
+					personas: ['./pp'],
+				},
+			})
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry: makeToolRegistry(),
+				log: makeLogger(),
+			})
+			await expect(mgr.enable(pluginId)).rejects.toThrow(/\[personas\]/)
+		})
+
+		it('lists all unsupported types together when multiple declared', async () => {
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'p',
+					version: '0.0.1',
+					description: 't',
+					skills: ['./s'],
+					connectors: ['./c'],
+					personas: ['./pp'],
+				},
+			})
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry: makeToolRegistry(),
+				log: makeLogger(),
+			})
+			await expect(mgr.enable(pluginId)).rejects.toThrow(/skills, connectors, personas/)
+		})
+	})
+
+	describe('mcpServers wiring', () => {
+		it('registers namespaced tools for each MCP server tool', async () => {
+			mockConnect.mockResolvedValue(undefined)
+			mockListTools.mockResolvedValue([
+				{ name: 'read_file', inputSchema: { type: 'object' } },
+				{ name: 'write_file', inputSchema: { type: 'object' } },
+			])
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'fs-plugin',
+					version: '0.0.1',
+					description: 't',
+					mcpServers: [{ name: 'fs', command: '/bin/true' }],
+				},
+			})
+			const toolRegistry = makeToolRegistry()
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry,
+				log: makeLogger(),
+			})
+
+			await mgr.enable(pluginId)
+
+			expect(mockConnect).toHaveBeenCalledOnce()
+			expect(mockListTools).toHaveBeenCalledOnce()
+			expect(toolRegistry.listNames()).toEqual([
+				'fs-plugin:mcp__fs__read_file',
+				'fs-plugin:mcp__fs__write_file',
+			])
+		})
+
+		it('disconnects MCP clients and unregisters tools on disable', async () => {
+			mockConnect.mockResolvedValue(undefined)
+			mockDisconnect.mockResolvedValue(undefined)
+			mockListTools.mockResolvedValue([{ name: 'ping', inputSchema: { type: 'object' } }])
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'net',
+					version: '0.0.1',
+					description: 't',
+					mcpServers: [{ name: 'srv', command: '/bin/true' }],
+				},
+			})
+			const toolRegistry = makeToolRegistry()
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry,
+				log: makeLogger(),
+			})
+
+			await mgr.enable(pluginId)
+			expect(toolRegistry.listNames()).toContain('net:mcp__srv__ping')
+
+			await mgr.disable(pluginId)
+			expect(mockDisconnect).toHaveBeenCalledOnce()
+			expect(toolRegistry.listNames()).toEqual([])
+		})
+
+		it('disconnects MCP clients before unregistering tools on disable', async () => {
+			mockConnect.mockResolvedValue(undefined)
+			mockDisconnect.mockResolvedValue(undefined)
+			mockListTools.mockResolvedValue([{ name: 'ping', inputSchema: { type: 'object' } }])
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'net',
+					version: '0.0.1',
+					description: 't',
+					mcpServers: [{ name: 'srv', command: '/bin/true' }],
+				},
+			})
+			const events: string[] = []
+			const toolRegistry = {
+				register: vi.fn(),
+				unregister: vi.fn(() => events.push('unregister')),
+				listNames: vi.fn(() => []),
+				has: vi.fn(),
+				get: vi.fn(),
+				execute: vi.fn(),
+				getAvailability: vi.fn(),
+			} as unknown as ToolRegistryContract
+			mockDisconnect.mockImplementation(async () => {
+				events.push('disconnect')
+			})
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry,
+				log: makeLogger(),
+			})
+
+			await mgr.enable(pluginId)
+			await mgr.disable(pluginId)
+
+			expect(events).toEqual(['disconnect', 'unregister'])
+		})
+
+		it('rolls back tools and MCP clients when connect fails mid-enable', async () => {
+			mockConnect
+				.mockResolvedValueOnce(undefined) // first server connects
+				.mockRejectedValueOnce(new Error('connect refused')) // second fails
+			mockDisconnect.mockResolvedValue(undefined)
+			mockListTools.mockResolvedValue([{ name: 't', inputSchema: { type: 'object' } }])
+			const { registry } = makePluginRegistry({
+				manifest: {
+					name: 'multi',
+					version: '0.0.1',
+					description: 't',
+					mcpServers: [
+						{ name: 'a', command: '/bin/true' },
+						{ name: 'b', command: '/bin/false' },
+					],
+				},
+			})
+			const toolRegistry = makeToolRegistry()
+			const mgr = new PluginLifecycleManager({
+				pluginRegistry: registry,
+				toolRegistry,
+				log: makeLogger(),
+			})
+
+			await expect(mgr.enable(pluginId)).rejects.toThrow(/connect refused/)
+
+			// Rollback: first server's tools unregistered, first client disconnected.
+			expect(toolRegistry.listNames()).toEqual([])
+			expect(mockDisconnect).toHaveBeenCalledOnce()
+		})
+	})
+})

package/src/plugin/__tests__/lifecycle.test.ts

@@ -426,5 +426,49 @@ describe('PluginLifecycleManager', () => {
 				await expect(executePromise).resolves.not.toThrow()
 			})
 		})
+
+		describe('RunEvent emission', () => {
+			it('should emit plugin_hook_executing and plugin_hook_completed when emitRunEvent provided', async () => {
+				const emitted: any[] = []
+				const emitRunEvent = vi.fn(async (event: any) => {
+					emitted.push(event)
+				})
+
+				const handler = vi.fn(
+					async (): Promise<PluginHookResult> => ({ action: 'modify', input: { x: 1 } }),
+				)
+
+				manager['hookHandlers'].set('pre_tool_use', [{ pluginId: mockPluginId, handler }])
+
+				await manager.executeHooks(
+					'pre_tool_use',
+					{ runId: mockRunId, toolName: 't', toolInput: {} },
+					emitRunEvent,
+				)
+
+				expect(emitted).toHaveLength(2)
+				expect(emitted[0]).toMatchObject({
+					type: 'plugin_hook_executing',
+					runId: mockRunId,
+					pluginId: mockPluginId,
+					hookEvent: 'pre_tool_use',
+				})
+				expect(emitted[1]).toMatchObject({
+					type: 'plugin_hook_completed',
+					runId: mockRunId,
+					pluginId: mockPluginId,
+					hookEvent: 'pre_tool_use',
+				})
+				expect(emitted[1].result).toEqual({ action: 'modify', input: { x: 1 } })
+			})
+
+			it('should not emit RunEvents when emitRunEvent omitted', async () => {
+				const handler = vi.fn(async (): Promise<PluginHookResult> => ({ action: 'continue' }))
+				manager['hookHandlers'].set('run_start', [{ pluginId: mockPluginId, handler }])
+				await expect(manager.executeHooks('run_start', { runId: mockRunId })).resolves.toHaveLength(
+					1,
+				)
+			})
+		})
 	})
 })

package/src/plugin/lifecycle.ts

@@ -1,5 +1,7 @@
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
+import { mcpToolToToolDefinition } from '../connector/mcp/adapter.js'
+import { MCPClient } from '../connector/mcp/client.js'
 import { HOOK_TIMEOUT_MS, PLUGIN_NAMESPACE_SEPARATOR } from '../constants/plugin/index.js'
 import type { PluginRegistry } from '../registry/plugin/index.js'
 import type { PluginId } from '../types/ids/index.js'
@@ -11,14 +13,21 @@ import type {
 	PluginHookEvent,
 	PluginHookResult,
 	PluginLifecycleEvent,
+	PluginMCPServerConfig,
 	PluginScope,
 } from '../types/plugin/index.js'
+import type { RunEvent } from '../types/run/index.js'
 import type { ToolDefinition, ToolRegistryContract } from '../types/tool/index.js'
 import { toErrorMessage } from '../utils/error.js'
 import { generatePluginId } from '../utils/id.js'
 import type { Logger } from '../utils/logger.js'
 import { loadPluginManifest } from './loader.js'
 
+interface PluginContributionRecord {
+	toolNames: string[]
+	mcpClients: MCPClient[]
+}
+
 export interface PluginLifecycleManagerConfig {
 	pluginRegistry: PluginRegistry
 	toolRegistry: ToolRegistryContract
@@ -34,7 +43,7 @@ export class PluginLifecycleManager {
 		PluginHookEvent,
 		Array<{ pluginId: PluginId; handler: PluginHookDefinition['handler'] }>
 	> = new Map()
-	private pluginContributions: Map<PluginId, string[]> = new Map()
+	private pluginContributions: Map<PluginId, PluginContributionRecord> = new Map()
 	private hookTimeoutMs: number
 	private log: Logger
 
@@ -99,70 +108,80 @@ export class PluginLifecycleManager {
 			)
 		}
 
-		const registeredToolNames: string[] = []
 		const { manifest } = plugin
 
-		// Load tools
-		if (manifest.tools && manifest.tools.length > 0) {
-			for (const toolPath of manifest.tools) {
-				const absolutePath = join(plugin.rootDir, toolPath)
-				const fileUrl = pathToFileURL(absolutePath).href
-				const mod = (await import(fileUrl)) as { tools?: ToolDefinition[] }
-
-				if (!mod.tools || !Array.isArray(mod.tools)) {
-					throw new Error(
-						`Plugin "${manifest.name}": tool module "${toolPath}" must export a "tools" array`,
-					)
-				}
+		// Unsupported contribution types must fail fast (Convention #0, #5).
+		// SDK lacks removable registries / instance factories / persona loader design
+		// for these categories. Remove from manifest or upgrade runtime.
+		const unsupported: string[] = []
+		if (manifest.skills?.length) unsupported.push('skills')
+		if (manifest.connectors?.length) unsupported.push('connectors')
+		if (manifest.personas?.length) unsupported.push('personas')
+		if (unsupported.length > 0) {
+			throw new Error(
+				`Plugin "${manifest.name}": contribution type(s) [${unsupported.join(', ')}] not yet supported by the runtime. Remove from manifest or upgrade @namzu/sdk.`,
+			)
+		}
 
-				for (const tool of mod.tools) {
-					const namespacedName = manifest.name + PLUGIN_NAMESPACE_SEPARATOR + tool.name
-					const namespacedTool: ToolDefinition = { ...tool, name: namespacedName }
-					this.toolRegistry.register(namespacedTool, 'deferred')
-					registeredToolNames.push(namespacedName)
+		const contributions: PluginContributionRecord = { toolNames: [], mcpClients: [] }
+
+		try {
+			// Load tools
+			if (manifest.tools && manifest.tools.length > 0) {
+				for (const toolPath of manifest.tools) {
+					const absolutePath = join(plugin.rootDir, toolPath)
+					const fileUrl = pathToFileURL(absolutePath).href
+					const mod = (await import(fileUrl)) as { tools?: ToolDefinition[] }
+
+					if (!mod.tools || !Array.isArray(mod.tools)) {
+						throw new Error(
+							`Plugin "${manifest.name}": tool module "${toolPath}" must export a "tools" array`,
+						)
+					}
+
+					for (const tool of mod.tools) {
+						const namespacedName = manifest.name + PLUGIN_NAMESPACE_SEPARATOR + tool.name
+						const namespacedTool: ToolDefinition = { ...tool, name: namespacedName }
+						this.toolRegistry.register(namespacedTool, 'deferred')
+						contributions.toolNames.push(namespacedName)
+					}
 				}
 			}
-		}
 
-		// Load hooks
-		if (manifest.hooks && manifest.hooks.length > 0) {
-			for (const hookPath of manifest.hooks) {
-				const absolutePath = join(plugin.rootDir, hookPath)
-				const fileUrl = pathToFileURL(absolutePath).href
-				const mod = (await import(fileUrl)) as { hooks?: PluginHookDefinition[] }
-
-				if (!mod.hooks || !Array.isArray(mod.hooks)) {
-					throw new Error(
-						`Plugin "${manifest.name}": hook module "${hookPath}" must export a "hooks" array`,
-					)
+			// Load hooks
+			if (manifest.hooks && manifest.hooks.length > 0) {
+				for (const hookPath of manifest.hooks) {
+					const absolutePath = join(plugin.rootDir, hookPath)
+					const fileUrl = pathToFileURL(absolutePath).href
+					const mod = (await import(fileUrl)) as { hooks?: PluginHookDefinition[] }
+
+					if (!mod.hooks || !Array.isArray(mod.hooks)) {
+						throw new Error(
+							`Plugin "${manifest.name}": hook module "${hookPath}" must export a "hooks" array`,
+						)
+					}
+
+					for (const hook of mod.hooks) {
+						const handlers = this.hookHandlers.get(hook.event) ?? []
+						handlers.push({ pluginId, handler: hook.handler })
+						this.hookHandlers.set(hook.event, handlers)
+					}
 				}
+			}
 
-				for (const hook of mod.hooks) {
-					const handlers = this.hookHandlers.get(hook.event) ?? []
-					handlers.push({ pluginId, handler: hook.handler })
-					this.hookHandlers.set(hook.event, handlers)
+			// Start MCP servers and adapt their tools
+			if (manifest.mcpServers && manifest.mcpServers.length > 0) {
+				for (const serverConfig of manifest.mcpServers) {
+					await this.attachMCPServer(manifest.name, serverConfig, contributions)
 				}
 			}
+		} catch (err) {
+			await this.rollbackContributions(pluginId, contributions)
+			throw err
 		}
 
-		// Log unsupported contribution types
-		if (manifest.skills && manifest.skills.length > 0) {
-			this.log.info(`Plugin "${manifest.name}": skills contribution not yet supported`)
-		}
-		if (manifest.mcpServers && manifest.mcpServers.length > 0) {
-			this.log.info(`Plugin "${manifest.name}": MCP servers contribution not yet supported`)
-		}
-		if (manifest.connectors && manifest.connectors.length > 0) {
-			this.log.info(`Plugin "${manifest.name}": connectors contribution not yet supported`)
-		}
-		if (manifest.personas && manifest.personas.length > 0) {
-			this.log.info(`Plugin "${manifest.name}": personas contribution not yet supported`)
-		}
-
-		// Track contributions for cleanup
-		this.pluginContributions.set(pluginId, registeredToolNames)
+		this.pluginContributions.set(pluginId, contributions)
 
-		// Update status to enabled
 		const enabled: PluginDefinition = {
 			...plugin,
 			status: 'enabled',
@@ -178,10 +197,76 @@ export class PluginLifecycleManager {
 
 		this.log.info(`Plugin enabled: ${manifest.name}`, {
 			pluginId,
-			toolCount: registeredToolNames.length,
+			toolCount: contributions.toolNames.length,
+			mcpServerCount: contributions.mcpClients.length,
 		})
 	}
 
+	private async attachMCPServer(
+		pluginName: string,
+		config: PluginMCPServerConfig,
+		contributions: PluginContributionRecord,
+	): Promise<void> {
+		const client = new MCPClient({
+			serverName: config.name,
+			transport: {
+				type: 'stdio',
+				command: config.command,
+				args: config.args ? [...config.args] : undefined,
+				env: config.env ? { ...config.env } : undefined,
+			},
+		})
+
+		await client.connect()
+		contributions.mcpClients.push(client)
+
+		const mcpTools = await client.listTools()
+		for (const mcpTool of mcpTools) {
+			const baseDef = mcpToolToToolDefinition(mcpTool, client, config.name)
+			// Double-underscore between serverName and toolName so that e.g.
+			// (server="fs", tool="read_file") and (server="fs_read", tool="file")
+			// produce distinct final names.
+			const namespacedName = `${pluginName}${PLUGIN_NAMESPACE_SEPARATOR}mcp__${config.name}__${mcpTool.name}`
+			const namespacedTool: ToolDefinition = { ...baseDef, name: namespacedName }
+			this.toolRegistry.register(namespacedTool, 'deferred')
+			contributions.toolNames.push(namespacedName)
+		}
+	}
+
+	private async rollbackContributions(
+		pluginId: PluginId,
+		contributions: PluginContributionRecord,
+	): Promise<void> {
+		for (const name of contributions.toolNames) {
+			try {
+				this.toolRegistry.unregister(name)
+			} catch (unregErr) {
+				this.log.warn('Rollback: tool unregister failed', {
+					tool: name,
+					error: toErrorMessage(unregErr),
+				})
+			}
+		}
+		for (const client of contributions.mcpClients) {
+			try {
+				await client.disconnect()
+			} catch (discErr) {
+				this.log.warn('Rollback: MCP disconnect failed', {
+					clientId: client.id,
+					error: toErrorMessage(discErr),
+				})
+			}
+		}
+		for (const [event, handlers] of this.hookHandlers) {
+			const filtered = handlers.filter((h) => h.pluginId !== pluginId)
+			if (filtered.length === 0) {
+				this.hookHandlers.delete(event)
+			} else {
+				this.hookHandlers.set(event, filtered)
+			}
+		}
+	}
+
 	async disable(pluginId: PluginId): Promise<void> {
 		const plugin = this.pluginRegistry.getOrThrow(pluginId)
 
@@ -191,9 +276,25 @@ export class PluginLifecycleManager {
 			)
 		}
 
-		// Unregister contributed tools
-		const toolNames = this.pluginContributions.get(pluginId) ?? []
-		for (const name of toolNames) {
+		const contributions = this.pluginContributions.get(pluginId) ?? {
+			toolNames: [],
+			mcpClients: [],
+		}
+
+		// Disconnect MCP clients first so no new tool calls can reach them mid-teardown.
+		for (const client of contributions.mcpClients) {
+			try {
+				await client.disconnect()
+			} catch (err) {
+				this.log.warn('MCP client disconnect failed during disable', {
+					clientId: client.id,
+					error: toErrorMessage(err),
+				})
+			}
+		}
+
+		// Unregister contributed tools (plugin tools + MCP-adapted tools)
+		for (const name of contributions.toolNames) {
 			this.toolRegistry.unregister(name)
 		}
 
@@ -207,7 +308,6 @@ export class PluginLifecycleManager {
 			}
 		}
 
-		// Clear contributions tracking
 		this.pluginContributions.delete(pluginId)
 
 		// Update status to disabled
@@ -248,6 +348,7 @@ export class PluginLifecycleManager {
 	async executeHooks(
 		event: PluginHookEvent,
 		context: Omit<PluginHookContext, 'pluginId' | 'event'>,
+		emitRunEvent?: (event: RunEvent) => Promise<void>,
 	): Promise<PluginHookResult[]> {
 		const handlers = this.hookHandlers.get(event)
 		if (!handlers || handlers.length === 0) {
@@ -271,16 +372,30 @@ export class PluginLifecycleManager {
 			}
 		}
 
+		// Track input overlay so chained `modify` actions compose: each subsequent
+		// hook sees the input produced by the previous hook's modify.
+		let toolInputOverlay = context.toolInput
+
 		for (const idx of indicesToProcess) {
 			const hookEntry = handlers[idx]
 			if (!hookEntry) continue
 			const { pluginId, handler: handlerFn } = hookEntry
 			const hookContext: PluginHookContext = {
 				...context,
+				toolInput: toolInputOverlay,
 				pluginId,
 				event,
 			}
 
+			if (emitRunEvent) {
+				await emitRunEvent({
+					type: 'plugin_hook_executing',
+					runId: context.runId,
+					pluginId,
+					hookEvent: event,
+				})
+			}
+
 			const start = performance.now()
 			let result: PluginHookResult
 
@@ -305,8 +420,22 @@ export class PluginLifecycleManager {
 				durationMs,
 			})
 
+			if (emitRunEvent) {
+				await emitRunEvent({
+					type: 'plugin_hook_completed',
+					runId: context.runId,
+					pluginId,
+					hookEvent: event,
+					result,
+				})
+			}
+
 			results.push(result)
 
+			if (result.action === 'modify') {
+				toolInputOverlay = result.input
+			}
+
 			// Handle flow control: check priority order: error > skip > retry > resume > modify > continue
 			// Short-circuit on error or skip; return immediately on resume or retry
 			if (result.action === 'error' || result.action === 'skip') {