@namzu/sdk 30.2.0 → 31.1.0

package/src/manager/goal/activation.ts

@@ -0,0 +1,52 @@
+import type { GoalRef, SessionGoal } from '../../types/goal/index.js'
+import type { SessionId } from '../../types/ids/index.js'
+
+export interface ActiveSessionGoal extends GoalRef {
+	readonly sessionId: SessionId
+}
+
+function sameGoal(left: GoalRef, right: GoalRef): boolean {
+	return left.id === right.id && left.revision === right.revision
+}
+
+/**
+ * Process-local permission for automatic goal continuation.
+ *
+ * Durable `phase: active` describes goal state; it does not grant a restarted
+ * process permission to spend another model turn. Hosts arm explicitly after
+ * direct create/resume and use exact disarm to keep an old turn from revoking
+ * a newer activation.
+ */
+export class SessionGoalActivation {
+	private readonly active = new Map<SessionId, ActiveSessionGoal>()
+
+	arm(goal: Pick<SessionGoal, 'sessionId' | 'id' | 'revision'>): ActiveSessionGoal {
+		const armed = Object.freeze({
+			sessionId: goal.sessionId,
+			id: goal.id,
+			revision: goal.revision,
+		})
+		this.active.set(goal.sessionId, armed)
+		return armed
+	}
+
+	get(sessionId: SessionId): ActiveSessionGoal | null {
+		return this.active.get(sessionId) ?? null
+	}
+
+	isArmed(sessionId: SessionId, ref: GoalRef): boolean {
+		const active = this.active.get(sessionId)
+		return Boolean(active && sameGoal(active, ref))
+	}
+
+	/** Disarm unconditionally, or only if the caller still owns the exact ref. */
+	disarm(sessionId: SessionId, expected?: GoalRef): boolean {
+		const active = this.active.get(sessionId)
+		if (!active || (expected && !sameGoal(active, expected))) return false
+		return this.active.delete(sessionId)
+	}
+
+	clear(): void {
+		this.active.clear()
+	}
+}

package/src/manager/index.ts

@@ -14,7 +14,11 @@ export type {
 } from './connector/environment.js'
 
 export { PlanManager } from './plan/lifecycle.js'
-export type { PlanEvent, PlanEventListener, PlanApprovalHandler } from './plan/lifecycle.js'
+export type {
+	PlanEvent,
+	PlanEventListener,
+	PlanApprovalHandler,
+} from './plan/lifecycle.js'
 
 export {
 	TopicManager,
@@ -23,6 +27,7 @@ export {
 export type { TopicManagerDeps } from './topic/lifecycle.js'
 
 export { AgentManager } from './agent/lifecycle.js'
+export type { AgentManagerDeps } from './agent/lifecycle.js'
 
 export { ProjectManager, requireOpenProject } from './project/lifecycle.js'
 export type { ProjectManagerDeps } from './project/lifecycle.js'
@@ -35,4 +40,7 @@ export {
 	advanceObjective,
 	driveObjective,
 } from './topic/objective.js'
-export type { AdvanceObjectiveParams, DriveObjectiveParams } from './topic/objective.js'
+export type {
+	AdvanceObjectiveParams,
+	DriveObjectiveParams,
+} from './topic/objective.js'

package/src/manager/run/persistence.ts

@@ -312,6 +312,11 @@ export class RunPersistence {
 		this.run.messages.push(message)
 	}
 
+	/** Replace the durable conversation projection without replacing the Run. */
+	replaceMessages(messages: readonly Message[]): void {
+		this.run.messages.splice(0, this.run.messages.length, ...messages)
+	}
+
 	/**
 	 * Who served the tokens being accumulated, so a rate can be found for them.
 	 *
@@ -669,7 +674,7 @@ export class RunPersistence {
 
 	async persist(): Promise<void> {
 		await this.runStore.writeRunMeta(this.run)
-		await this.runStore.writeMessages(this.run)
+		await this.runStore.writeMessages(this.run, this._lastEventSeq)
 		// Optional on the contract: a backend whose runs are already queryable
 		// has no browsable directory to add a row to.
 		await this.runStore.addToIndex?.(this.run)

package/src/manager/topic/dependency.ts

@@ -0,0 +1,39 @@
+import type { TopicManager } from './lifecycle.js'
+
+/**
+ * A dependency on the Topic lifecycle gate during the `threadManager` rename
+ * window.
+ *
+ * At least one spelling is required. Supplying both is accepted only when
+ * they name the same manager instance; choosing one of two different gates by
+ * property order would make archive enforcement depend on object shape.
+ */
+export type TopicManagerDependency =
+	| {
+			readonly topicManager: TopicManager
+			/** @deprecated Use {@link topicManager}. */
+			readonly threadManager?: TopicManager
+	  }
+	| {
+			readonly topicManager?: never
+			/** @deprecated Use `topicManager`. */
+			readonly threadManager: TopicManager
+	  }
+
+/** Resolve the canonical manager or refuse an ambiguous/missing runtime input. */
+export function resolveTopicManager(dependency: {
+	readonly topicManager?: TopicManager
+	readonly threadManager?: TopicManager
+}): TopicManager {
+	const { topicManager, threadManager } = dependency
+	if (topicManager && threadManager && topicManager !== threadManager) {
+		throw new TypeError(
+			'topicManager and deprecated threadManager refer to different TopicManager instances; provide one manager, or pass the same instance under both names during migration.',
+		)
+	}
+	const resolved = topicManager ?? threadManager
+	if (!resolved) {
+		throw new TypeError('A TopicManager is required as topicManager.')
+	}
+	return resolved
+}

package/src/manager/topic/lifecycle.ts

@@ -19,29 +19,17 @@
  * why the gate lives at the manager layer rather than as a universal store
  * interceptor (see `archive` JSDoc for the direct-store-bypass boundary).
  *
- * NZ-TOPIC-01 renamed this class from `ThreadManager` (moved from
- * `manager/thread/lifecycle.ts`). NZ-TOPIC-04 deleted the `ThreadManager`
- * alias entirely (see AGENTS.md's deprecate-before-remove note in the
- * changeset for why a major, not a minor, was the right call here) — the
- * class only lives under `TopicManager` now. NZ-TOPIC-03 renamed the
- * `threadId` parameter on every method below to `topicId` — the FK-field
- * rename that release deliberately deferred, now landed with its own data
- * migration in `store/session/disk.ts`. `threadStore` (a DI dependency,
- * not the FK) stayed `topicStore` from that same release. The thrown
- * error classes (`ThreadClosedError`/`ThreadNotEmptyError`) are STILL
- * unchanged in name, and so is their `details.threadId` field's NAME —
- * `session/errors.ts` remains deliberately out of scope for the class and
- * field renames (a clean follow-up), though NZ-TOPIC-04 did narrow the
- * TYPE backing that field from `ThreadId` to `TopicId` since the former no
- * longer exists. Constructing one from a `topicId` local below therefore
- * still spells the key out (`{ threadId: topicId, ... }`) rather than
- * using shorthand.
+ * The former Thread vocabulary has been removed from this public lifecycle:
+ * manager names, method parameters, error classes, and structured error
+ * details all use Topic. Persistence migrations may still recognize legacy
+ * field names, but live manager behavior never asks a caller to translate
+ * back to a deleted domain term.
  */
 
 import {
-	THREAD_NOT_EMPTY_SAMPLE_LIMIT,
-	ThreadClosedError,
-	ThreadNotEmptyError,
+	TOPIC_NOT_EMPTY_SAMPLE_LIMIT,
+	TopicArchivedError,
+	TopicNotEmptyError,
 } from '../../session/errors.js'
 import type { TenantId } from '../../types/ids/index.js'
 import type { Session, SessionStatus } from '../../types/session/entity.js'
@@ -91,7 +79,7 @@ export class TopicManager {
 	}
 
 	/**
-	 * CAS update on a Topic. Propagates {@link import('../../session/errors.js').StaleThreadError}
+	 * CAS update on a Topic. Propagates {@link import('../../session/errors.js').StaleTopicError}
 	 * from the store on `ownerVersion` mismatch — callers re-read, re-apply,
 	 * and retry.
 	 */
@@ -119,7 +107,7 @@ export class TopicManager {
 			throw new Error(`Topic ${topicId} not found`)
 		}
 		if (topic.status === 'archived') {
-			throw new ThreadClosedError({ threadId: topicId, op: 'require-open' })
+			throw new TopicArchivedError({ topicId, op: 'require-open' })
 		}
 		return topic
 	}
@@ -133,14 +121,14 @@ export class TopicManager {
 	 *      {@link ARCHIVAL_BLOCKING_STATUSES}). The presence check runs
 	 *      **before** the idempotent-archive short-circuit so that an already
 	 *      archived topic harboring a live session still surfaces as
-	 *      {@link ThreadNotEmptyError} rather than a silent success.
+	 *      {@link TopicNotEmptyError} rather than a silent success.
 	 *   3. If the topic is already `'archived'` the method short-circuits
 	 *      without an `updateTopic` write (idempotent re-archival). The
 	 *      returned record reflects the current persisted state.
 	 *
 	 * On a fresh archive transition the underlying
 	 * {@link TopicStore.updateTopic} call commits with `ownerVersion + 1`.
-	 * A {@link import('../../session/errors.js').StaleThreadError} from a
+	 * A {@link import('../../session/errors.js').StaleTopicError} from a
 	 * concurrent writer propagates unchanged — the caller is expected to
 	 * re-read + retry (mirrors the `updateTopic` contract).
 	 *
@@ -166,13 +154,13 @@ export class TopicManager {
 		// Always enforce the blocking-session invariant — even on re-archival.
 		// If the topic is already archived but somehow gained a live session
 		// (direct store mutation, concurrent spawn before a write-barrier
-		// existed), surfacing that via ThreadNotEmptyError is more useful to
+		// existed), surfacing that via TopicNotEmptyError is more useful to
 		// operators than a silent idempotent success.
 		const sessions = await this.deps.sessionStore.listSessionsByTopic(topicId, tenantId)
 		const blocking = sessions.filter((s) => ARCHIVAL_BLOCKING_STATUSES.has(s.status))
 		if (blocking.length > 0) {
-			throw new ThreadNotEmptyError({
-				threadId: topicId,
+			throw new TopicNotEmptyError({
+				topicId,
 				tenantId,
 				op: 'archive',
 				blockingSessions: summarizeBlocking(blocking),
@@ -199,7 +187,7 @@ export class TopicManager {
 	}
 
 	/**
-	 * Hard-delete a Topic record. Rejects with {@link ThreadNotEmptyError}
+	 * Hard-delete a Topic record. Rejects with {@link TopicNotEmptyError}
 	 * (`op: 'delete'`) when ANY Session still references the Topic —
 	 * deletion is stricter than archival, which tolerates quiescent sessions.
 	 * Callers must first delete or archive-and-tombstone every attached
@@ -214,8 +202,8 @@ export class TopicManager {
 	async delete(topicId: TopicId, tenantId: TenantId): Promise<void> {
 		const sessions = await this.deps.sessionStore.listSessionsByTopic(topicId, tenantId)
 		if (sessions.length > 0) {
-			throw new ThreadNotEmptyError({
-				threadId: topicId,
+			throw new TopicNotEmptyError({
+				topicId,
 				tenantId,
 				op: 'delete',
 				blockingSessions: summarizeBlocking(sessions),
@@ -230,6 +218,6 @@ function summarizeBlocking(
 	sessions: readonly Session[],
 ): ReadonlyArray<{ sessionId: Session['id']; status: SessionStatus }> {
 	return sessions
-		.slice(0, THREAD_NOT_EMPTY_SAMPLE_LIMIT)
+		.slice(0, TOPIC_NOT_EMPTY_SAMPLE_LIMIT)
 		.map((s) => ({ sessionId: s.id, status: s.status }))
 }

package/src/plugin/index.ts

@@ -1,3 +1,4 @@
 export { discoverPlugins, loadPluginManifest, discoverAllPluginDirs } from './loader.js'
+export type { PluginDiscoveryOptions, PluginEnablementCapabilities } from './loader.js'
 export { PluginLifecycleManager } from './lifecycle.js'
 export { PluginResolver } from './resolver.js'

package/src/plugin/lifecycle.ts

@@ -54,9 +54,50 @@ interface PluginContributionRecord {
 	mcpSupervisors: MCPReconnectSupervisor[]
 }
 
+interface PluginAdmission {
+	readonly id: PluginId
+	readonly manifest: PluginDefinition['manifest']
+	readonly scope: PluginScope
+	readonly rootDir: string
+	readonly installedAt: number
+}
+
+function immutableManifest(manifest: PluginDefinition['manifest']): PluginDefinition['manifest'] {
+	const mcpServers = manifest.mcpServers?.map((server) =>
+		Object.freeze({
+			name: server.name,
+			command: server.command,
+			...(server.args ? { args: Object.freeze([...server.args]) } : {}),
+			...(server.env ? { env: Object.freeze({ ...server.env }) } : {}),
+		}),
+	)
+	return Object.freeze({
+		name: manifest.name,
+		version: manifest.version,
+		description: manifest.description,
+		...(manifest.author !== undefined ? { author: manifest.author } : {}),
+		...(manifest.tools ? { tools: Object.freeze([...manifest.tools]) } : {}),
+		...(manifest.skills ? { skills: Object.freeze([...manifest.skills]) } : {}),
+		...(manifest.hooks ? { hooks: Object.freeze([...manifest.hooks]) } : {}),
+		...(mcpServers ? { mcpServers: Object.freeze(mcpServers) } : {}),
+		...(manifest.connectors ? { connectors: Object.freeze([...manifest.connectors]) } : {}),
+		...(manifest.personas ? { personas: Object.freeze([...manifest.personas]) } : {}),
+	})
+}
+
 export interface PluginLifecycleManagerConfig {
 	pluginRegistry: PluginRegistry
 	toolRegistry: ToolRegistryContract
+	/**
+	 * Filesystem authorities for each plugin scope.
+	 *
+	 * Required because `scope` is not an authority by itself. The manager
+	 * canonicalizes a plugin against the matching root before reading its
+	 * manifest and repeats that admission for legacy registry records before
+	 * enabling them. A project manager normally uses the trusted working
+	 * directory; a user manager normally uses the user's home directory.
+	 */
+	scopeRoots: Readonly<Record<PluginScope, string>>
 	/**
 	 * Where a plugin's declared skills land.
 	 *
@@ -121,8 +162,11 @@ export class PluginLifecycleManager {
 		}>
 	> = new Map()
 	private pluginContributions: Map<PluginId, PluginContributionRecord> = new Map()
+	/** Immutable executable admissions owned by this manager, never by the mutable registry. */
+	private pluginAdmissions: Map<PluginId, PluginAdmission> = new Map()
 	private hookTimeoutMs: number
 	private readonly configRegistry: ConfigRegistry | undefined
+	private readonly scopeRoots: Readonly<Record<PluginScope, string>>
 	private log: Logger
 	/**
 	 * The admission boundary for everything a plugin's MCP servers advertise.
@@ -146,6 +190,7 @@ export class PluginLifecycleManager {
 		this.pluginRegistry = config.pluginRegistry
 		this.toolRegistry = config.toolRegistry
 		this.skillRegistry = config.skillRegistry
+		this.scopeRoots = Object.freeze({ ...config.scopeRoots })
 		this.hookTimeoutMs = config.hookTimeoutMs ?? HOOK_TIMEOUT_MS
 		this.configRegistry = config.configRegistry
 		this.log = config.log.child({ [SCOPE_ATTRIBUTE]: 'plugin/lifecycle' })
@@ -195,7 +240,15 @@ export class PluginLifecycleManager {
 	}
 
 	async install(pluginDir: string, scope: PluginScope): Promise<PluginDefinition> {
-		const manifest = await loadPluginManifest(pluginDir)
+		// Admission and enable read the same constructor-owned capability. The
+		// loader defaults this to false for direct callers; a manager that really
+		// owns the registry is the authority that can opt the manifest in.
+		const rootDir = await resolveWithinReal(this.scopeRoots[scope], pluginDir)
+		const manifest = immutableManifest(
+			await loadPluginManifest(rootDir, {
+				skillsSupported: Boolean(this.skillRegistry),
+			}),
+		)
 
 		const existing = this.pluginRegistry.findByName(manifest.name)
 		if (existing) {
@@ -203,16 +256,17 @@ export class PluginLifecycleManager {
 		}
 
 		const pluginId = generatePluginId()
-		const definition: PluginDefinition = {
+		const admission: PluginAdmission = Object.freeze({
 			id: pluginId,
 			manifest,
 			scope,
-			status: 'installed',
-			rootDir: pluginDir,
+			rootDir,
 			installedAt: Date.now(),
-		}
+		})
+		const definition = this.definitionFrom(admission, 'installed')
 
 		this.pluginRegistry.register(definition)
+		this.pluginAdmissions.set(pluginId, admission)
 
 		this.emit({
 			type: 'plugin_installed',
@@ -231,16 +285,81 @@ export class PluginLifecycleManager {
 		return definition
 	}
 
+	private definitionFrom(
+		admission: PluginAdmission,
+		status: PluginDefinition['status'],
+		enabledAt?: number,
+	): PluginDefinition {
+		return Object.freeze({
+			...admission,
+			status,
+			...(enabledAt !== undefined ? { enabledAt } : {}),
+		})
+	}
+
+	private async readLegacyAdmission(plugin: PluginDefinition): Promise<PluginAdmission> {
+		const rootDir = await resolveWithinReal(this.scopeRoots[plugin.scope], plugin.rootDir)
+		const manifest = immutableManifest(
+			await loadPluginManifest(rootDir, {
+				skillsSupported: Boolean(this.skillRegistry),
+			}),
+		)
+		if (manifest.name !== plugin.manifest.name) {
+			throw new Error(
+				`Plugin registry record "${plugin.id}" names "${plugin.manifest.name}", but its admitted manifest names "${manifest.name}". Reinstall the plugin from its declared scope root.`,
+			)
+		}
+		const duplicate = this.pluginRegistry
+			.getAll()
+			.find((candidate) => candidate.id !== plugin.id && candidate.manifest.name === manifest.name)
+		if (duplicate) {
+			throw new Error(
+				`Plugin "${manifest.name}" is already installed (id: ${duplicate.id}); legacy record ${plugin.id} cannot be re-admitted.`,
+			)
+		}
+		return Object.freeze({
+			id: plugin.id,
+			manifest,
+			scope: plugin.scope,
+			rootDir,
+			installedAt: plugin.installedAt,
+		})
+	}
+
 	async enable(pluginId: PluginId): Promise<void> {
 		const plugin = this.pluginRegistry.getOrThrow(pluginId)
+		let admission = this.pluginAdmissions.get(pluginId)
 
-		if (plugin.status !== 'installed' && plugin.status !== 'disabled') {
+		// The registry is a public projection and can be overwritten by a host.
+		// Contribution ownership is the executable lifecycle truth: trusting a
+		// forged `disabled` status here would register every hook/tool/MCP client
+		// twice and lose teardown ownership of the first set.
+		if (this.pluginContributions.has(pluginId)) {
 			throw new Error(
-				`Cannot enable plugin "${plugin.manifest.name}": status is "${plugin.status}" (expected "installed" or "disabled")`,
+				`Cannot enable plugin "${admission?.manifest.name ?? plugin.manifest.name}": status is "enabled" (expected "installed" or "disabled")`,
 			)
 		}
 
-		const { manifest } = plugin
+		if (!admission) {
+			if (plugin.status !== 'installed' && plugin.status !== 'disabled') {
+				throw new Error(
+					`Cannot enable plugin "${plugin.manifest.name}": status is "${plugin.status}" (expected "installed" or "disabled")`,
+				)
+			}
+			try {
+				admission = await this.readLegacyAdmission(plugin)
+				this.pluginAdmissions.set(pluginId, admission)
+			} catch (error) {
+				this.pluginRegistry.register({
+					...plugin,
+					status: 'error',
+					error: toErrorMessage(error),
+				})
+				throw error
+			}
+		}
+
+		const { manifest } = admission
 
 		// The same refusal the loader applies at install, kept here as the
 		// backstop for a plugin that reached this point another way — a
@@ -252,7 +371,10 @@ export class PluginLifecycleManager {
 		try {
 			assertEnableable(manifest, { skillsSupported: Boolean(this.skillRegistry) })
 		} catch (err) {
-			this.pluginRegistry.register({ ...plugin, status: 'error' })
+			this.pluginRegistry.register({
+				...this.definitionFrom(admission, 'error'),
+				error: toErrorMessage(err),
+			})
 			throw err
 		}
 
@@ -267,7 +389,7 @@ export class PluginLifecycleManager {
 			// Load tools
 			if (manifest.tools && manifest.tools.length > 0) {
 				for (const toolPath of manifest.tools) {
-					const absolutePath = await resolveWithinReal(plugin.rootDir, toolPath)
+					const absolutePath = await resolveWithinReal(admission.rootDir, toolPath)
 					const fileUrl = pathToFileURL(absolutePath).href
 					const mod = (await import(fileUrl)) as { tools?: ToolDefinition[] }
 
@@ -302,7 +424,7 @@ export class PluginLifecycleManager {
 					)
 				}
 				for (const skillPath of manifest.skills) {
-					const absolutePath = await resolveWithinReal(plugin.rootDir, skillPath)
+					const absolutePath = await resolveWithinReal(admission.rootDir, skillPath)
 					const { skill } = await loadSkill(absolutePath, 'metadata', this.log)
 					const namespacedName = manifest.name + PLUGIN_NAMESPACE_SEPARATOR + skill.metadata.name
 					skillRegistry.add(namespacedName, {
@@ -316,7 +438,7 @@ export class PluginLifecycleManager {
 			// Load hooks
 			if (manifest.hooks && manifest.hooks.length > 0) {
 				for (const hookPath of manifest.hooks) {
-					const absolutePath = await resolveWithinReal(plugin.rootDir, hookPath)
+					const absolutePath = await resolveWithinReal(admission.rootDir, hookPath)
 					const fileUrl = pathToFileURL(absolutePath).href
 					const mod = (await import(fileUrl)) as { hooks?: PluginHookDefinition[] }
 
@@ -345,11 +467,7 @@ export class PluginLifecycleManager {
 
 		this.pluginContributions.set(pluginId, contributions)
 
-		const enabled: PluginDefinition = {
-			...plugin,
-			status: 'enabled',
-			enabledAt: Date.now(),
-		}
+		const enabled = this.definitionFrom(admission, 'enabled', Date.now())
 		this.pluginRegistry.register(enabled)
 
 		this.emit({
@@ -490,20 +608,15 @@ export class PluginLifecycleManager {
 
 	async disable(pluginId: PluginId): Promise<void> {
 		const plugin = this.pluginRegistry.getOrThrow(pluginId)
+		const admission = this.pluginAdmissions.get(pluginId)
+		const contributions = this.pluginContributions.get(pluginId)
 
-		if (plugin.status !== 'enabled') {
+		if (!contributions) {
 			throw new Error(
-				`Cannot disable plugin "${plugin.manifest.name}": status is "${plugin.status}" (expected "enabled")`,
+				`Cannot disable plugin "${admission?.manifest.name ?? plugin.manifest.name}": status is not "enabled"`,
 			)
 		}
 
-		const contributions = this.pluginContributions.get(pluginId) ?? {
-			toolNames: [],
-			mcpClients: [],
-			skillNames: [],
-			mcpSupervisors: [],
-		}
-
 		// Stop supervising first, for the same reason as the rollback path: the
 		// disconnect below emits the event the supervisor treats as a fault.
 		for (const supervisor of contributions.mcpSupervisors) supervisor.stop()
@@ -545,42 +658,42 @@ export class PluginLifecycleManager {
 		this.pluginContributions.delete(pluginId)
 
 		// Update status to disabled
-		const disabled: PluginDefinition = {
-			...plugin,
-			status: 'disabled',
-			enabledAt: undefined,
-		}
+		const disabled: PluginDefinition = admission
+			? this.definitionFrom(admission, 'disabled')
+			: { ...plugin, status: 'disabled', enabledAt: undefined }
 		this.pluginRegistry.register(disabled)
 
 		this.emit({
 			type: 'plugin_disabled',
 			pluginId,
-			name: plugin.manifest.name,
+			name: disabled.manifest.name,
 		})
 
 		this.log.info('Plugin disabled', {
-			'namzu.plugin.name': plugin.manifest.name,
+			'namzu.plugin.name': disabled.manifest.name,
 			'namzu.plugin.id': pluginId,
 		})
 	}
 
 	async uninstall(pluginId: PluginId): Promise<void> {
 		const plugin = this.pluginRegistry.getOrThrow(pluginId)
+		const admission = this.pluginAdmissions.get(pluginId)
 
-		if (plugin.status === 'enabled') {
+		if (this.pluginContributions.has(pluginId)) {
 			await this.disable(pluginId)
 		}
 
 		this.pluginRegistry.unregister(pluginId)
+		this.pluginAdmissions.delete(pluginId)
 
 		this.emit({
 			type: 'plugin_uninstalled',
 			pluginId,
-			name: plugin.manifest.name,
+			name: admission?.manifest.name ?? plugin.manifest.name,
 		})
 
 		this.log.info('Plugin uninstalled', {
-			'namzu.plugin.name': plugin.manifest.name,
+			'namzu.plugin.name': admission?.manifest.name ?? plugin.manifest.name,
 			'namzu.plugin.id': pluginId,
 		})
 	}
@@ -590,6 +703,8 @@ export class PluginLifecycleManager {
 		context: Omit<PluginHookContext, 'pluginId' | 'event'>,
 		emitRunEvent?: (event: RunEvent) => Promise<void>,
 	): Promise<PluginHookResult[]> {
+		const callerSignal = context.signal
+		callerSignal?.throwIfAborted()
 		const handlers = this.hookHandlers.get(event)
 		if (!handlers || handlers.length === 0) {
 			return []
@@ -634,6 +749,7 @@ export class PluginLifecycleManager {
 					pluginId,
 					hookEvent: event,
 				})
+				callerSignal?.throwIfAborted()
 			}
 
 			const start = performance.now()
@@ -647,11 +763,15 @@ export class PluginLifecycleManager {
 			// until the last one expired. Nothing failed — it just hung, for
 			// up to the timeout, every time.
 			const deadline = new AbortController()
+			const hookSignal = callerSignal
+				? AbortSignal.any([callerSignal, deadline.signal])
+				: deadline.signal
 			let timer: ReturnType<typeof setTimeout> | undefined
+			let onCallerAbort: (() => void) | undefined
 
 			try {
-				result = await Promise.race([
-					handlerFn({ ...hookContext, signal: deadline.signal }),
+				const races: Promise<PluginHookResult>[] = [
+					Promise.resolve().then(() => handlerFn({ ...hookContext, signal: hookSignal })),
 					new Promise<PluginHookResult>((_, reject) => {
 						timer = setTimeout(() => {
 							// Told, not just abandoned: a hook holding a socket
@@ -660,14 +780,33 @@ export class PluginLifecycleManager {
 							reject(new Error('Hook timeout'))
 						}, this.hookTimeoutMs)
 					}),
-				])
+				]
+				if (callerSignal) {
+					races.push(
+						new Promise<PluginHookResult>((_, reject) => {
+							onCallerAbort = () => reject(callerSignal.reason)
+							callerSignal.addEventListener('abort', onCallerAbort, {
+								once: true,
+							})
+							if (callerSignal.aborted) onCallerAbort()
+						}),
+					)
+				}
+				result = await Promise.race(races)
+				callerSignal?.throwIfAborted()
 			} catch (err) {
+				// Cancellation belongs to the run, not to the plugin. Turning it
+				// into a hook error would let the query continue after its caller
+				// withdrew authority and would report Stop as a plugin failure.
+				if (callerSignal?.aborted) throw callerSignal.reason
 				const message = toErrorMessage(err)
 				result = { action: 'error', message }
 			} finally {
 				if (timer !== undefined) clearTimeout(timer)
+				if (onCallerAbort) callerSignal?.removeEventListener('abort', onCallerAbort)
 			}
 
+			callerSignal?.throwIfAborted()
 			const durationMs = Math.round(performance.now() - start)
 
 			this.emit({
@@ -678,6 +817,7 @@ export class PluginLifecycleManager {
 			})
 
 			if (emitRunEvent) {
+				callerSignal?.throwIfAborted()
 				await emitRunEvent({
 					type: 'plugin_hook_completed',
 					runId: context.runId,
@@ -685,6 +825,7 @@ export class PluginLifecycleManager {
 					hookEvent: event,
 					result,
 				})
+				callerSignal?.throwIfAborted()
 			}
 
 			results.push(result)