@namzu/sdk 63.1.0 → 64.0.0

package/src/public-runtime.ts

@@ -697,8 +697,13 @@ export {
 
 export {
 	attachShellHooks,
+	boundCompactionSummary,
 	boundHookContext,
 	boundHookReplacement,
+	boundLastAssistantMessage,
+	compactionHookInstructions,
+	MAX_COMPACTION_SUMMARY_HOOK_CHARS,
+	MAX_LAST_MESSAGE_HOOK_CHARS,
 	createShellHook,
 	DEFAULT_SHELL_HOOK_TIMEOUT_MS,
 	definePlugin,
@@ -716,8 +721,13 @@ export {
 	PluginResolver,
 	runShellHook,
 	SHELL_HOOK_EVENTS,
+	SHELL_HOOK_PASCAL_EVENT_NAMES,
+	SHELL_HOOK_WRITTEN_TOOL_NAMES,
 	SHELL_HOOKS_PLUGIN_ID,
+	shellHookToolName,
 	shellHookIfMatches,
+	shellHookIfProblem,
+	shellHookMatcherProblem,
 	shellHookMatches,
 	shellHookVerdict,
 } from './plugin/index.js'
@@ -1343,6 +1353,7 @@ export { assertTaskStatus, isTerminalTaskStatus } from './types/task/index.js'
 // offer "compact this conversation", could not shrink an idle session
 // between turns, and could not collapse a span it had chosen.
 export { compactNow, compactRegion } from './compaction/manual.js'
+export { CompactionRefusedError } from './compaction/hooks.js'
 // A host persisting manual compaction has to recognise the system message on
 // resume. Export the identity predicate rather than making every host copy the
 // marker string and eventually disagree with the writer.
@@ -1380,6 +1391,7 @@ export { isWorkingMemoryMessage } from './runtime/query/iteration/phases/working
 // `any` — and the first host to try (`@namzu/cli`'s `/compact`) did exactly
 // that before this line existed.
 export type { CompactNowInput, CompactionResult } from './compaction/manual.js'
+export type { CompactionHookHost, ManualCompactionHooks } from './compaction/hooks.js'
 export type {
 	CompactionSummaryRoute,
 	CompactionSummaryRouter,

package/src/public-types.ts

@@ -242,12 +242,14 @@ export type {
 	ShellHookHandler,
 	ShellHookJudge,
 	ShellHookOnFailure,
+	ShellHookCall,
 	ShellHookInput,
 	ShellHookOptions,
 	ShellHookPathFilter,
 	ShellHookOutcome,
 	ShellHooksConfig,
 } from './plugin/shell-hook.js'
+export type { ShellHookToolNames } from './plugin/shell-hook-tool-names.js'
 
 export type {
 	PlanApprovalHandler,

package/src/runtime/query/compact-session.ts

@@ -1,3 +1,4 @@
+import type { ManualCompactionHooks } from '../../compaction/hooks.js'
 import {
 	type CompactNowInput,
 	type CompactionResult,
@@ -13,8 +14,14 @@ import { generateMessageId } from '../../utils/id.js'
 import { type SessionLocatorOptions, locateSessionLog, withSessionLease } from './abandon-turn.js'
 
 /** A compaction a host asks for between turns. */
-export interface CompactSessionParams extends Omit<CompactNowInput, 'messages' | 'onShed'> {
+export interface CompactSessionParams
+	extends Omit<CompactNowInput, 'messages' | 'onShed' | 'hooks'> {
 	readonly sessionId: SessionId
+	/**
+	 * Fire `pre_compact` and `post_compact` around the pass. The session and
+	 * the trigger are this call's own. See {@link CompactNowInput.hooks}.
+	 */
+	readonly hooks?: Omit<ManualCompactionHooks, 'sessionId' | 'trigger'>
 	/**
 	 * Who asked. `'manual'` (the default) is a person's request; `'idle'` is a
 	 * host compacting a conversation nobody is using before its prompt cache
@@ -37,7 +44,7 @@ export interface CompactSessionParams extends Omit<CompactNowInput, 'messages' |
 export async function compactSession(
 	params: CompactSessionParams,
 ): Promise<CompactionResult | null> {
-	const { sessionId, locator = {}, trigger = 'manual', ...input } = params
+	const { sessionId, locator = {}, trigger = 'manual', hooks, ...input } = params
 	const log = await locateSessionLog(sessionId, locator)
 	return withSessionLease(log, locator.lease, async (lease) => {
 		const active = await log.activeTurn({ lease })
@@ -47,7 +54,11 @@ export async function compactSession(
 		const history = await readFoldedHistory(log)
 		const ids = new Map<Message, MessageId>()
 		for (const entry of history) if (entry.messageId) ids.set(entry.message, entry.messageId)
-		const result = await compactNow({ ...input, messages: history.map((entry) => entry.message) })
+		const result = await compactNow({
+			...input,
+			messages: history.map((entry) => entry.message),
+			...(hooks ? { hooks: { ...hooks, sessionId, trigger } } : {}),
+		})
 		if (!result) return null
 		const head = await log.head()
 		if (!head) {
@@ -105,7 +116,7 @@ export interface CompactSessionRangeParams extends CompactSessionParams {
 export async function compactSessionRange(
 	params: CompactSessionRangeParams,
 ): Promise<CompactionResult | null> {
-	const { sessionId, locator = {}, from, until, ...input } = params
+	const { sessionId, locator = {}, from, until, hooks, ...input } = params
 	const log = await locateSessionLog(sessionId, locator)
 	return withSessionLease(log, locator.lease, async (lease) => {
 		const active = await log.activeTurn({ lease })
@@ -134,6 +145,7 @@ export async function compactSessionRange(
 			messages: history.map((entry) => entry.message),
 			start,
 			end,
+			...(hooks ? { hooks: { ...hooks, sessionId, trigger: 'manual' as const } } : {}),
 		})
 		if (!result) return null
 		const head = await log.head()

package/src/runtime/query/executor/tool-call-admission.ts

@@ -78,6 +78,7 @@ export async function runPreToolHook(
 	toolName: string,
 	input: unknown,
 	signal: AbortSignal = host.config.abortSignal,
+	toolCallId?: string,
 ): Promise<PreToolHookOutcome> {
 	signal.throwIfAborted()
 	if (!host.config.pluginManager) return { kind: 'continue', input, modified: false }
@@ -88,6 +89,7 @@ export async function runPreToolHook(
 				sessionId: host.config.sessionId,
 				turnId: host.config.turnId,
 				toolName,
+				...(toolCallId !== undefined ? { toolCallId } : {}),
 				toolInput: input,
 				signal,
 			},
@@ -155,7 +157,7 @@ export async function prepareDirectCall(
 					: {}),
 			}
 		}
-		const preOutcome = await runPreToolHook(host, toolName, resolved.input)
+		const preOutcome = await runPreToolHook(host, toolName, resolved.input, undefined, toolCall.id)
 		if (preOutcome.kind === 'skip' || preOutcome.kind === 'error') {
 			return {
 				kind: 'synthetic',
@@ -297,7 +299,13 @@ export async function prepareDirectCall(
 		}
 	}
 
-	const preOutcome = await runPreToolHook(host, toolName, preparation.prepared.input)
+	const preOutcome = await runPreToolHook(
+		host,
+		toolName,
+		preparation.prepared.input,
+		undefined,
+		toolCall.id,
+	)
 	if (preOutcome.kind === 'skip' || preOutcome.kind === 'error') {
 		return {
 			kind: 'synthetic',

package/src/runtime/query/executor.ts

@@ -2790,7 +2790,7 @@ export class ToolExecutor {
 		// block had it discarded here — before the wire mapper that was
 		// built to carry it ever saw it.
 		let result: ToolResult = await this.runOnce(toolName, input, toolContext, prepared)
-		let post = await this.runPostToolHook(toolName, input, result)
+		let post = await this.runPostToolHook(toolName, input, result, toolCall.id)
 
 		// In-loop retry. A transient failure used to cost a full model round
 		// trip: the error went back as a `tool_result`, the model read it and
@@ -2873,7 +2873,7 @@ export class ToolExecutor {
 				break
 			}
 			result = await this.runOnce(toolName, input, toolContext, prepared)
-			post = await this.runPostToolHook(toolName, input, result)
+			post = await this.runPostToolHook(toolName, input, result, toolCall.id)
 		}
 		const durationMs = Date.now() - startMs
 
@@ -3515,6 +3515,7 @@ export class ToolExecutor {
 		toolName: string,
 		input: unknown,
 		toolResult: ToolResult,
+		toolCallId?: string,
 	): Promise<{
 		override: PostToolOverride | null
 		retry: boolean
@@ -3529,6 +3530,7 @@ export class ToolExecutor {
 					sessionId: this.config.sessionId,
 					turnId: this.config.turnId,
 					toolName,
+					...(toolCallId !== undefined ? { toolCallId } : {}),
 					toolInput: input,
 					toolResult,
 					signal: this.config.abortSignal,
@@ -3547,6 +3549,7 @@ export class ToolExecutor {
 							sessionId: this.config.sessionId,
 							turnId: this.config.turnId,
 							toolName,
+							...(toolCallId !== undefined ? { toolCallId } : {}),
 							toolInput: input,
 							toolResult,
 							signal: this.config.abortSignal,

package/src/runtime/query/finalize-turn.ts

@@ -8,7 +8,7 @@ import type { TurnContext } from './context.js'
 import type { EventTranslator } from './events.js'
 import { runOutputGuardrails } from './guardrails.js'
 import type { QueryParams } from './index.js'
-import { applyLifecycleHookResults } from './plugin-hooks.js'
+import { applyLifecycleHookResults, lastAssistantMessageField } from './plugin-hooks.js'
 import type { ResultAssembler } from './result.js'
 
 /**
@@ -86,7 +86,12 @@ export async function* finalizeTurn(
 	if (params.pluginManager && finalization.turnEndHooksFired?.() !== true) {
 		const hookResults = await params.pluginManager.executeHooks(
 			'turn_end',
-			{ sessionId: ctx.sessionId, turnId: ctx.turnId, signal: ctx.abortController.signal },
+			{
+				sessionId: ctx.sessionId,
+				turnId: ctx.turnId,
+				...lastAssistantMessageField(ctx.recorder.messages),
+				signal: ctx.abortController.signal,
+			},
 			eventTranslator.emitEvent,
 		)
 		applyLifecycleHookResults('turn_end', hookResults)
@@ -100,8 +105,10 @@ export async function* finalizeTurn(
 				{
 					sessionId: ctx.sessionId,
 					turnId: ctx.turnId,
+					...lastAssistantMessageField(ctx.recorder.messages),
 					parentSessionId: params.parentSessionId,
 					...(params.parentTurnId !== undefined ? { parentTurnId: params.parentTurnId } : {}),
+					agentType: params.agentType ?? params.agentName,
 					signal: ctx.abortController.signal,
 				},
 				eventTranslator.emitEvent,

package/src/runtime/query/iteration/index.ts

@@ -70,7 +70,7 @@ import { SandboxAcquisitionStopped } from '../deferred-sandbox.js'
 import { deliverDurableInbound } from '../durable-inbound.js'
 import type { ToolCallOutcome } from '../executor.js'
 import { projectObservationContext } from '../observation-context.js'
-import { applyLifecycleHookResults } from '../plugin-hooks.js'
+import { applyLifecycleHookResults, lastAssistantMessageField } from '../plugin-hooks.js'
 import {
 	type RequestContextSnapshot,
 	diffRequestContext,
@@ -419,6 +419,7 @@ export class IterationOrchestrator {
 					sessionId: recorder.sessionId,
 					turnId: recorder.turnId,
 					...extra,
+					...lastAssistantMessageField(recorder.messages),
 					...(this.stopHookActive ? { stopHookActive: true } : {}),
 					signal: this.ctx.abortController.signal,
 				},

package/src/runtime/query/iteration/phases/compaction.ts

@@ -3,6 +3,7 @@ import {
 	resolveTriggerThreshold,
 } from '../../../../compaction/context-window.js'
 import { findDanglingMessages } from '../../../../compaction/dangling.js'
+import { askPreCompact, postCompactSummary } from '../../../../compaction/hooks.js'
 import {
 	LOADED_SKILLS_ENTRY_KEY,
 	type RenderedSkills,
@@ -781,6 +782,10 @@ async function recordShed(
 interface CompactionPass {
 	attempted: boolean
 	reason: 'threshold' | 'overflow'
+	/** What the `pre_compact` hooks said the summary should keep. */
+	hookInstructions?: string
+	/** The summary the pass installed, for `post_compact`. */
+	summary?: string
 	tokensBefore: number
 	contextWindowTokens: number
 }
@@ -807,9 +812,11 @@ export async function runCompactionCheck(
 					iteration: ctx.recorder.currentIteration,
 					compaction: {
 						reason: pass.reason,
+						trigger: 'auto',
 						tokensBefore: pass.tokensBefore,
 						tokensAfter: estimateTokens(ctx),
 						contextWindowTokens: pass.contextWindowTokens,
+						...postCompactSummary(pass.summary),
 					},
 					signal: ctx.abortController.signal,
 				},
@@ -903,24 +910,29 @@ async function runCompactionCheckInner(
 	pass.tokensBefore = estimatedTokens
 	pass.contextWindowTokens = budget
 	if (ctx.pluginManager) {
-		const results = await ctx.pluginManager.executeHooks(
-			'pre_compact',
+		const answer = await askPreCompact(
+			ctx.pluginManager,
 			{
 				sessionId: ctx.recorder.sessionId,
 				turnId: ctx.recorder.turnId,
 				iteration: ctx.recorder.currentIteration,
-				compaction: {
-					reason: pass.reason,
-					tokensBefore: estimatedTokens,
-					contextWindowTokens: budget,
-				},
 				signal: ctx.abortController.signal,
+				emitEvent: ctx.emitEvent,
+			},
+			{
+				reason: pass.reason,
+				trigger: 'auto',
+				instructions: null,
+				tokensBefore: estimatedTokens,
+				contextWindowTokens: budget,
 			},
-			ctx.emitEvent,
 		)
-		applyLifecycleHookResults('pre_compact', results)
-		const refusal = results.find((result) => result.action === 'skip')
-		if (refusal?.action === 'skip') {
+		// What the hooks said the summary should keep is heard even when a
+		// forced pass overrides a refusal. A reducer or the extracted state
+		// alone has no place for it (see `docs/sdk/hooks.md`).
+		if (answer.instructions !== undefined) pass.hookInstructions = answer.instructions
+		const refusal = answer.refusal !== undefined ? { reason: answer.refusal } : undefined
+		if (refusal) {
 			// A threshold pass is the context's own housekeeping and a hook may
 			// postpone it. A forced pass runs because the provider rejected the
 			// prompt: a context it will reject is not something a hook may insist
@@ -1130,6 +1142,7 @@ async function runCompactionCheckInner(
 				olderMessages,
 				previousSummaries: replaceableSummaries(systemMessages),
 				config,
+				...(pass.hookInstructions !== undefined ? { hookInstructions: pass.hookInstructions } : {}),
 				resolveRoute: async (signal) => {
 					const route = await ctx.compactionSummaryRoute?.(signal)
 					if (route) {
@@ -1162,7 +1175,10 @@ async function runCompactionCheckInner(
 
 	if (modelWritten !== undefined) {
 		compactedContent = modelWritten
-	} else if (config.llmVerification && manager.slotCount() < config.richStateThreshold) {
+	} else if (
+		pass.hookInstructions !== undefined ||
+		(config.llmVerification && manager.slotCount() < config.richStateThreshold)
+	) {
 		// Named once and used twice on purpose. The model the summariser is
 		// asked for is also the model its tokens are priced at, and computing
 		// the two separately is how they drift — a router that sends compaction
@@ -1188,6 +1204,8 @@ async function runCompactionCheckInner(
 				// was added, and nothing ever consulted it.
 				compactionModel,
 				ctx.abortController.signal,
+				undefined,
+				pass.hookInstructions,
 			)
 		} catch (error) {
 			// The model step only ADDS to the extracted state, so a failed one (a
@@ -1308,6 +1326,7 @@ async function runCompactionCheckInner(
 	await recordShed(ctx, [...live], newMessages, options?.force ? 'overflow' : 'threshold')
 
 	installMessages(live, newMessages)
+	pass.summary = compactedContent
 
 	const newEstimate = estimateTokens(ctx)
 

package/src/runtime/query/iteration/phases/tool-review.ts

@@ -318,6 +318,7 @@ export async function* runToolReview(
 						sessionId: ctx.recorder.sessionId,
 						turnId: ctx.recorder.turnId,
 						toolName: summary.name,
+						toolCallId: summary.id,
 						toolInput: summary.input,
 						reason,
 						signal: ctx.abortController.signal,
@@ -854,6 +855,7 @@ export async function* runToolReview(
 					sessionId: ctx.recorder.sessionId,
 					turnId: ctx.recorder.turnId,
 					toolName: tc.name,
+					toolCallId: tc.id,
 					toolInput: tc.input,
 					signal: ctx.abortController.signal,
 				},

package/src/runtime/query/plugin-hooks.ts

@@ -1,5 +1,31 @@
+import { boundLastAssistantMessage } from '../../plugin/hook-context.js'
 import { NamzuError } from '../../types/errors/index.js'
+import type { Message } from '../../types/message/index.js'
 import type { PluginHookEvent, PluginHookResult } from '../../types/plugin/index.js'
+import { isOperatorUserMessage } from './steering.js'
+
+/**
+ * The model's last message of the turn, as a `turn_end` or `subagent_stop`
+ * hook receives it: the text of the last assistant message after the
+ * operator's latest prompt, bounded. A message that carries only tool calls,
+ * a turn that stopped before the model wrote anything, and a turn with no
+ * assistant message yet all give `undefined`: the field is then absent, and a
+ * hook never gets an earlier turn's words or an earlier step's narration in
+ * its place.
+ */
+export function lastAssistantMessageField(messages: readonly Message[]): {
+	lastAssistantMessage?: string
+} {
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index]
+		if (!message) continue
+		if (isOperatorUserMessage(message)) return {}
+		if (message.role !== 'assistant') continue
+		const text = boundLastAssistantMessage(message.content)
+		return text === undefined ? {} : { lastAssistantMessage: text }
+	}
+	return {}
+}
 
 /**
  * Interpret hook results from non-tool lifecycle events (run_start, run_end,
@@ -19,9 +45,13 @@ export function applyLifecycleHookResults(
 			case 'continue':
 				continue
 			case 'annotate':
-				if (event !== 'user_prompt_submit' && event !== 'subagent_start') {
+				if (
+					event !== 'user_prompt_submit' &&
+					event !== 'subagent_start' &&
+					event !== 'pre_compact'
+				) {
 					throw new Error(
-						`Plugin hook ${event} returned 'annotate', which only user_prompt_submit and subagent_start accept`,
+						`Plugin hook ${event} returned 'annotate', which only user_prompt_submit, subagent_start and pre_compact accept`,
 					)
 				}
 				if (result.text.trim().length > 0) annotations.push(result.text.trim())

package/src/types/agent/query.ts

@@ -25,6 +25,15 @@ export interface QueryAgentConfig extends BaseAgentConfig {
 
 	persona?: AgentPersona
 
+	/**
+	 * The name lifecycle hooks see for this agent (`agentType` on
+	 * `subagent_start` and `subagent_stop`, `agent_type` for a shell hook).
+	 * Absent, it is the agent's `type`, which for a host-defined class is the
+	 * class's marker rather than the agent's name: a host that names its
+	 * agents passes the name here.
+	 */
+	agentType?: string
+
 	/**
 	 * Channel a host uses to hand guidance to this turn's current turn.
 	 *

package/src/types/plugin/index.ts

@@ -246,12 +246,36 @@ export interface PluginModelResponse {
 
 /** What a compaction hook is shown about the pass. */
 export interface PluginCompactionInfo {
-	/** `threshold`: the estimate crossed the line. `overflow`: the provider rejected the prompt. */
-	readonly reason: 'threshold' | 'overflow'
+	/**
+	 * `threshold`: the estimate crossed the line. `overflow`: the provider
+	 * rejected the prompt. `manual`: a host asked for the pass outside a turn
+	 * (a person's `/compact`, a summarised span, an idle pass); test `trigger`
+	 * to tell a person's request from the kernel's own.
+	 */
+	readonly reason: 'threshold' | 'overflow' | 'manual'
 	readonly tokensBefore: number
 	/** Present on `post_compact`. */
 	readonly tokensAfter?: number
 	readonly contextWindowTokens: number
+	/**
+	 * Who started the pass: `manual` for one a person asked for (`/compact`,
+	 * summarising a span), `auto` for every pass the kernel or a host started
+	 * on its own (the threshold, a provider overflow, an idle pass). The
+	 * kernel always sets it; it is optional only so a host that builds this
+	 * context by hand keeps compiling. A matcher on these two events tests it.
+	 */
+	readonly trigger?: 'manual' | 'auto'
+	/**
+	 * On `pre_compact`: what the person typed with the command, or `null` when
+	 * they typed nothing or the pass is not one a person asked for.
+	 */
+	readonly instructions?: string | null
+	/**
+	 * On `post_compact`: the summary the pass wrote, cut to
+	 * `MAX_COMPACTION_SUMMARY_HOOK_CHARS`. Absent when the pass wrote none (a
+	 * context reducer shed the history, or the pass shed nothing).
+	 */
+	readonly summary?: string
 }
 
 /** One call in a `post_tool_batch` hook's context. */
@@ -275,19 +299,22 @@ export interface PluginNotificationInfo {
 }
 
 /**
- * Why a session started, on `session_start`: `startup` for a conversation
+ * Why a conversation began, on `session_start`: `startup` for a conversation
  * with no earlier turn, `resume` for one that already had turns (a resumed
- * conversation, a `--continue`, or a session rebuilt under a running one).
+ * conversation, a `--continue`, a fork, or a session rebuilt under a running
+ * one), `clear` for the empty conversation a host opens when the person
+ * clears the old one (`/clear`, `/new`).
  */
-export type PluginSessionSource = 'startup' | 'resume'
+export type PluginSessionSource = 'startup' | 'resume' | 'clear'
 
 /**
- * Why a session closed, on `session_end`: `exit` when the host is finishing
- * with it (the process ends, the person quits), `replaced` when the host
- * builds another session in its place (a model or account switch, another
- * conversation opened).
+ * Why a conversation ended, on `session_end`: `exit` when the host is
+ * finishing with it (the process ends, the person quits), `replaced` when the
+ * host moves to another session or conversation in its place (a model or
+ * account switch, another conversation opened or forked), `clear` when the
+ * person cleared it and a new, empty conversation begins (`/clear`, `/new`).
  */
-export type PluginSessionEndReason = 'exit' | 'replaced'
+export type PluginSessionEndReason = 'exit' | 'replaced' | 'clear'
 
 export interface PluginHookContext {
 	/** The turn the hook fired in. Absent on `session_start` and `session_end`. */
@@ -311,6 +338,14 @@ export interface PluginHookContext {
 	/** The pass, on `pre_compact` and `post_compact`. */
 	readonly compaction?: PluginCompactionInfo
 	readonly toolName?: string
+	/**
+	 * The id of the call, on `pre_tool_use`, `post_tool_use`,
+	 * `post_tool_use_failure`, `permission_request` and `permission_denied`: the
+	 * same id `post_tool_batch` carries as `toolCallId`, so a hook can pair a
+	 * before with an after. Absent on a call a tool makes through
+	 * `dispatchTool` (it has no model-issued id).
+	 */
+	readonly toolCallId?: string
 	readonly toolInput?: unknown
 	readonly toolResult?: ToolResult
 	/** The calls of one model step with their outcomes, on `post_tool_batch`. */
@@ -328,6 +363,13 @@ export interface PluginHookContext {
 	 * keep the model working until the turn's own limits stop it.
 	 */
 	readonly stopHookActive?: boolean
+	/**
+	 * On `turn_end` and `subagent_stop`: the text of the model's last message
+	 * of the turn, cut to `MAX_LAST_MESSAGE_HOOK_CHARS`. Absent when the turn
+	 * produced no text (it ended on a tool call, was interrupted before the
+	 * model wrote anything, or failed).
+	 */
+	readonly lastAssistantMessage?: string
 	readonly iteration?: number
 	/**
 	 * Why the turn was stopped, on `turn_interrupt`.
@@ -501,18 +543,20 @@ export type PluginHookResultFor<E extends PluginHookEvent> = E extends 'user_pro
 					? Extract<PluginHookResult, { action: 'continue' | 'error' }>
 					: E extends 'permission_request'
 						? Extract<PluginHookResult, { action: 'continue' | 'skip' }>
-						: E extends 'turn_end' | 'subagent_stop' | 'pre_compact'
-							? Extract<PluginHookResult, { action: 'continue' | 'skip' | 'error' }>
-							: E extends 'session_start'
-								? Extract<PluginHookResult, { action: 'continue' | 'annotate' }>
-								: E extends
-											| 'turn_interrupt'
-											| 'session_end'
-											| 'notification'
-											| 'turn_failure'
-											| 'permission_denied'
-									? Extract<PluginHookResult, { action: 'continue' }>
-									: Extract<PluginHookResult, { action: 'continue' | 'error' }>
+						: E extends 'pre_compact'
+							? Extract<PluginHookResult, { action: 'continue' | 'annotate' | 'skip' | 'error' }>
+							: E extends 'turn_end' | 'subagent_stop'
+								? Extract<PluginHookResult, { action: 'continue' | 'skip' | 'error' }>
+								: E extends 'session_start'
+									? Extract<PluginHookResult, { action: 'continue' | 'annotate' }>
+									: E extends
+												| 'turn_interrupt'
+												| 'session_end'
+												| 'notification'
+												| 'turn_failure'
+												| 'permission_denied'
+										? Extract<PluginHookResult, { action: 'continue' }>
+										: Extract<PluginHookResult, { action: 'continue' | 'error' }>
 
 /** The event and its handler verdict stay correlated, including in hook arrays. */
 export type PluginHookDefinition<E extends PluginHookEvent = PluginHookEvent> =