@namzu/sdk 27.0.0 → 28.0.0

package/src/run/reporter.ts

@@ -1,6 +1,8 @@
+import { GENAI, NAMZU } from '../constants/telemetry/index.js'
 import type { Run, RunEvent, RunEventListener } from '../types/run/index.js'
 import { formatCost } from '../utils/cost.js'
-import { type Logger, getRootLogger } from '../utils/logger.js'
+import { SCOPE_ATTRIBUTE } from '../utils/log/types.js'
+import { type Logger, resolveLogger } from '../utils/logger.js'
 
 function formatDuration(ms: number): string {
 	if (ms < 1000) return `${ms}ms`
@@ -17,73 +19,85 @@ export interface RunReporter {
 }
 
 export function createRunReporter(parentLogger?: Logger): RunReporter {
-	const log = (parentLogger ?? getRootLogger()).child({
-		component: 'RunReporter',
+	const log = resolveLogger(parentLogger).child({
+		[SCOPE_ATTRIBUTE]: 'run/reporter',
 	})
 
 	const listener: RunEventListener = (event: RunEvent) => {
 		switch (event.type) {
 			case 'run_started':
 				log.info('Run started', {
-					runId: event.runId,
-					hasSystemPrompt: !!event.systemPrompt,
-					systemPromptLength: event.systemPrompt?.length ?? 0,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.run.has_system_prompt': !!event.systemPrompt,
+					'namzu.run.system_prompt_length': event.systemPrompt?.length ?? 0,
+				})
+				break
+
+			case 'approval_policy_changed':
+				// `warn`, not `info`. Every change here is a change in how
+				// closely this run is supervised, and the one worth seeing in a
+				// scrolling log is the loosening nobody meant to leave on.
+				log.warn('Approval policy changed', {
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.approval.policy.from': event.from,
+					'namzu.approval.policy.to': event.to,
+					'namzu.approval.policy.reason': event.reason,
 				})
 				break
 
 			case 'iteration_started':
-				log.info(`Iteration ${event.iteration} started`, {
-					runId: event.runId,
-					iteration: event.iteration,
+				log.info('Iteration started', {
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
 				})
 				break
 
 			case 'iteration_completed':
-				log.info(`Iteration ${event.iteration} completed`, {
-					runId: event.runId,
-					iteration: event.iteration,
-					hasToolCalls: event.hasToolCalls,
+				log.info('Iteration completed', {
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.run.has_tool_calls': event.hasToolCalls,
 				})
 				break
 
 			case 'tool_executing':
-				log.info(`Tool executing: ${event.toolName}`, {
-					runId: event.runId,
-					tool: event.toolName,
+				log.info('Tool executing', {
+					[NAMZU.RUN_ID]: event.runId,
+					[GENAI.TOOL_NAME]: event.toolName,
 				})
 				break
 
 			case 'tool_completed':
-				log.info(`Tool completed: ${event.toolName}`, {
-					runId: event.runId,
-					tool: event.toolName,
+				log.info('Tool completed', {
+					[NAMZU.RUN_ID]: event.runId,
+					[GENAI.TOOL_NAME]: event.toolName,
 				})
 				break
 
 			case 'token_usage_updated':
 				log.info('Token usage updated', {
-					runId: event.runId,
-					promptTokens: event.usage.promptTokens,
-					completionTokens: event.usage.completionTokens,
-					totalTokens: event.usage.totalTokens,
-					totalCost: event.cost.totalCost,
+					[NAMZU.RUN_ID]: event.runId,
+					[GENAI.USAGE_INPUT_TOKENS]: event.usage.promptTokens,
+					[GENAI.USAGE_OUTPUT_TOKENS]: event.usage.completionTokens,
+					'namzu.usage.total_tokens': event.usage.totalTokens,
+					'namzu.run.total_cost': event.cost.totalCost,
 				})
 				break
 
 			case 'run_completed':
-				log.info('Run completed', { runId: event.runId })
+				log.info('Run completed', { [NAMZU.RUN_ID]: event.runId })
 				break
 
 			case 'run_failed':
 				log.error('Run failed', {
-					runId: event.runId,
-					error: event.error,
+					[NAMZU.RUN_ID]: event.runId,
+					'exception.message': event.error,
 					// A greppable id and a sentence saying what to change,
 					// where before there was only whatever prose the vendor
 					// SDK happened to write.
-					code: event.failure?.code,
-					reason: event.explanation?.id,
-					hint: event.explanation?.hint,
+					'namzu.run.code': event.failure?.code,
+					'namzu.run.reason': event.explanation?.id,
+					'namzu.run.hint': event.explanation?.hint,
 				})
 				break
 
@@ -113,123 +127,125 @@ export function createRunReporter(parentLogger?: Logger): RunReporter {
 				break
 
 			case 'agent_pending':
-				log.info(`Agent task pending: ${event.childAgentId}`, {
-					runId: event.runId,
-					taskId: event.taskId,
-					parentAgentId: event.parentAgentId,
-					childAgentId: event.childAgentId,
-					depth: event.depth,
+				log.info('Agent task pending', {
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.task.id': event.taskId,
+					'namzu.run.parent_agent_id': event.parentAgentId,
+					'namzu.run.child_agent_id': event.childAgentId,
+					'namzu.agent.depth': event.depth,
 				})
 				break
 
 			case 'agent_completed':
 				log.info('Agent task completed', {
-					runId: event.runId,
-					taskId: event.taskId,
-					status: event.result.status,
-					iterations: event.result.iterations,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.task.id': event.taskId,
+					[NAMZU.RUN_STATUS]: event.result.status,
+					'namzu.run.iterations': event.result.iterations,
 				})
 				break
 
 			case 'agent_failed':
 				log.error('Agent task failed', {
-					runId: event.runId,
-					taskId: event.taskId,
-					error: event.error,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.task.id': event.taskId,
+					'exception.message': event.error,
 				})
 				break
 
 			case 'agent_canceled':
 				log.info('Agent task canceled', {
-					runId: event.runId,
-					taskId: event.taskId,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.task.id': event.taskId,
 				})
 				break
 
 			case 'task_created':
-				log.info(`Task created: ${event.subject}`, {
-					runId: event.runId,
-					taskId: event.taskId,
-					status: event.status,
+				log.info('Task created', {
+					'namzu.task.subject': event.subject,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.task.id': event.taskId,
+					[NAMZU.RUN_STATUS]: event.status,
 				})
 				break
 
 			case 'task_updated':
-				log.info(`Task updated: ${event.subject}`, {
-					runId: event.runId,
-					taskId: event.taskId,
-					status: event.status,
-					owner: event.owner,
+				log.info('Task updated', {
+					'namzu.task.subject': event.subject,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.task.id': event.taskId,
+					[NAMZU.RUN_STATUS]: event.status,
+					'namzu.run.owner': event.owner,
 				})
 				break
 
 			case 'plugin_hook_executing':
 				log.debug('Plugin hook executing', {
-					runId: event.runId,
-					pluginId: event.pluginId,
-					hookEvent: event.hookEvent,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.plugin.id': event.pluginId,
+					'namzu.run.hook_event': event.hookEvent,
 				})
 				break
 
 			case 'plugin_hook_completed':
 				log.debug('Plugin hook completed', {
-					runId: event.runId,
-					pluginId: event.pluginId,
-					hookEvent: event.hookEvent,
-					action: event.result.action,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.plugin.id': event.pluginId,
+					'namzu.run.hook_event': event.hookEvent,
+					'namzu.run.action': event.result.action,
 				})
 				break
 
 			case 'sandbox_created':
 				log.info('Sandbox created', {
-					runId: event.runId,
-					sandboxId: event.sandboxId,
-					environment: event.environment,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.sandbox.id': event.sandboxId,
+					'namzu.execution.environment': event.environment,
 				})
 				break
 
 			case 'sandbox_exec':
 				log.debug('Sandbox exec', {
-					runId: event.runId,
-					sandboxId: event.sandboxId,
-					command: event.command,
-					exitCode: event.exitCode,
-					durationMs: event.durationMs,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.sandbox.id': event.sandboxId,
+					'namzu.run.command': event.command,
+					'namzu.run.exit_code': event.exitCode,
+					'namzu.duration_ms': event.durationMs,
 				})
 				break
 
 			case 'sandbox_destroyed':
 				log.info('Sandbox destroyed', {
-					runId: event.runId,
-					sandboxId: event.sandboxId,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.sandbox.id': event.sandboxId,
 				})
 				break
 
 			case 'subsession_spawned':
 				log.debug('Sub-session spawned', {
-					runId: event.runId,
-					subSessionId: event.subSessionId,
-					parentSessionId: event.parentSessionId,
-					depth: event.lineage.depth,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.sub_session.id': event.subSessionId,
+					'namzu.run.parent_session_id': event.parentSessionId,
+					'namzu.agent.depth': event.lineage.depth,
 				})
 				break
 
 			case 'subsession_messaged':
 				log.debug('Sub-session message', {
-					runId: event.runId,
-					subSessionId: event.subSessionId,
-					parentSessionId: event.parentSessionId,
-					messageId: event.messageId,
-					depth: event.lineage.depth,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.sub_session.id': event.subSessionId,
+					'namzu.run.parent_session_id': event.parentSessionId,
+					'namzu.run.message_id': event.messageId,
+					'namzu.agent.depth': event.lineage.depth,
 				})
 				break
 
 			case 'subsession_idled':
 				log.debug('Sub-session idled', {
-					runId: event.runId,
-					subSessionId: event.subSessionId,
-					parentSessionId: event.parentSessionId,
-					depth: event.lineage.depth,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.sub_session.id': event.subSessionId,
+					'namzu.run.parent_session_id': event.parentSessionId,
+					'namzu.agent.depth': event.lineage.depth,
 				})
 				break
 
@@ -241,34 +257,68 @@ export function createRunReporter(parentLogger?: Logger): RunReporter {
 
 			case 'reasoning_completed':
 				log.debug('Reasoning block completed', {
-					runId: event.runId,
-					iteration: event.iteration,
-					blockIndex: event.blockIndex,
-					signed: event.signed,
-					chars: event.text?.length ?? 0,
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.run.block_index': event.blockIndex,
+					'namzu.run.signed': event.signed,
+					'namzu.run.chars': event.text?.length ?? 0,
 				})
 				break
 
 			case 'guardrail_triggered':
 				log.warn('Guardrail triggered', {
-					runId: event.runId,
-					stage: event.stage,
-					action: event.action,
-					guardrail: event.guardrail,
-					reason: event.reason,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.run.stage': event.stage,
+					'namzu.run.action': event.action,
+					'namzu.guardrail.name': event.guardrail,
+					'namzu.run.reason': event.reason,
 				})
 				break
 
 			case 'compaction_completed':
 				log.info('Context compacted', {
-					runId: event.runId,
-					iteration: event.iteration,
-					messagesDropped: event.messagesBefore - event.messagesAfter,
-					tokensBefore: event.tokensBefore,
-					tokensAfter: event.tokensAfter,
-					measuredBy: event.measuredBy,
-					contextWindowTokens: event.contextWindowTokens,
-					windowSource: event.windowSource,
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.run.messages_dropped': event.messagesBefore - event.messagesAfter,
+					'namzu.run.tokens_before': event.tokensBefore,
+					'namzu.run.tokens_after': event.tokensAfter,
+					'namzu.run.measured_by': event.measuredBy,
+					'namzu.run.context_window_tokens': event.contextWindowTokens,
+					'namzu.run.window_source': event.windowSource,
+				})
+				break
+
+			case 'request_envelope':
+				// `debug`, not `info`. It fires only when something changed, so
+				// it is never noise — but it carries a whole system prompt, and
+				// a default-level start that printed one would bury everything
+				// else the way the registry's `info` registrations did.
+				log.debug('Request envelope changed', {
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.request.model': event.model,
+					'namzu.request.tool_count': event.toolNames.length,
+					'namzu.request.tool_schema_digest': event.toolSchemaDigest,
+				})
+				break
+
+			case 'compaction_tool_results_cleared':
+				// `info` on both branches. The relieved case is the run
+				// avoiding a summarization, which is good news worth stating;
+				// the unrelieved case is the history taking two edits in one
+				// pass, and a reader who saw only the `compaction_completed`
+				// below would attribute the whole loss to it.
+				// Namespaced, unlike its neighbours above. Those are the standing
+				// inventory the `namespacedAttributeKeyViolationCount` ratchet
+				// froze; NEW keys have no reason to join it, and adding six
+				// would have moved a number LOG-22 exists to drive to zero.
+				log.info('Cleared oversized tool results', {
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.compaction.cleared_count': event.clearedCount,
+					'namzu.compaction.chars_reclaimed': event.charsReclaimed,
+					'namzu.compaction.reclaimed_tokens': event.reclaimedTokens,
+					'namzu.compaction.relief_was_enough': event.reliefWasEnough,
 				})
 				break
 
@@ -276,80 +326,85 @@ export function createRunReporter(parentLogger?: Logger): RunReporter {
 				// warn rather than info: the run is now continuing at a context
 				// size it had already decided was too large.
 				log.warn('Context compaction shed nothing', {
-					runId: event.runId,
-					iteration: event.iteration,
-					cause: event.cause,
-					messages: event.messages,
-					...(event.error !== undefined ? { error: event.error } : {}),
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.run.cause': event.cause,
+					'namzu.run.messages': event.messages,
+					...(event.error !== undefined ? { 'exception.message': event.error } : {}),
 				})
 				break
 
 			case 'capability_warning':
 				log.warn('Provider capability mismatch', {
-					runId: event.runId,
-					capability: event.capability,
-					providerId: event.providerId,
-					message: event.message,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.run.capability': event.capability,
+					[GENAI.SYSTEM]: event.providerId,
+					'namzu.run.message': event.message,
 				})
 				break
 
 			case 'tool_progress':
 				// Debug, not info: a long tool can emit many of these and they
 				// are a live-view signal, not a run milestone.
-				log.debug(`Tool progress: ${event.toolName}`, {
-					runId: event.runId,
-					tool: event.toolName,
-					message: event.message,
+				log.debug('Tool progress', {
+					[NAMZU.RUN_ID]: event.runId,
+					[GENAI.TOOL_NAME]: event.toolName,
+					'namzu.run.message': event.message,
 				})
 				break
 
 			case 'user_question_asked':
 				log.info('Question asked — the run is parked on an answer', {
-					runId: event.runId,
-					checkpointId: event.checkpointId,
-					questionId: event.questionId,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.checkpoint.id': event.checkpointId,
+					'namzu.run.question_id': event.questionId,
 				})
 				break
 
 			case 'user_question_answered':
 				log.info(event.answered ? 'Question answered' : 'Question closed unanswered', {
-					runId: event.runId,
-					checkpointId: event.checkpointId,
+					[NAMZU.RUN_ID]: event.runId,
+					'namzu.checkpoint.id': event.checkpointId,
 				})
 				break
 
 			case 'provider_retry':
 				// `warn`, not debug: this is the run going quiet for a
 				// measurable stretch, and the delay it names is still ahead.
-				log.warn(`Model call failed — retrying in ${event.delayMs}ms`, {
-					runId: event.runId,
-					iteration: event.iteration,
-					attempt: event.attempt,
-					maxRetries: event.maxRetries,
-					code: event.code,
-					status: event.status,
-					serverDirected: event.serverDirected,
+				log.warn('Model call failed — retrying', {
+					'namzu.provider.retry_delay_ms': event.delayMs,
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.retry.attempt': event.attempt,
+					'namzu.run.max_retries': event.maxRetries,
+					'namzu.run.code': event.code,
+					[NAMZU.RUN_STATUS]: event.status,
+					'namzu.run.server_directed': event.serverDirected,
 				})
 				break
 
 			case 'provider_fallback':
 				// `warn` for the same reason as a retry, and one stronger: the rest
 				// of this run is being served by a provider the caller did not pick.
-				log.warn(
-					`Provider ${event.fromProviderId} could not serve — continuing on ${event.toProviderId}`,
-					{
-						runId: event.runId,
-						iteration: event.iteration,
-						fromIndex: event.fromIndex,
-						fromProviderId: event.fromProviderId,
-						fromModel: event.fromModel,
-						toIndex: event.toIndex,
-						toProviderId: event.toProviderId,
-						toModel: event.toModel,
-						code: event.code,
-						status: event.status,
-					},
-				)
+				log.warn('Provider could not serve — continuing on the fallback', {
+					[NAMZU.RUN_ID]: event.runId,
+					[NAMZU.ITERATION]: event.iteration,
+					'namzu.run.from_index': event.fromIndex,
+					'namzu.run.from_provider_id': event.fromProviderId,
+					'namzu.run.from_model': event.fromModel,
+					'namzu.run.to_index': event.toIndex,
+					'namzu.run.to_provider_id': event.toProviderId,
+					'namzu.run.to_model': event.toModel,
+					'namzu.run.code': event.code,
+					[NAMZU.RUN_STATUS]: event.status,
+				})
+				break
+
+			case 'compaction_shed':
+				// Deliberately silent. The report is what a human reads about a
+				// run; replaying every shed message into it would bury the
+				// summary line that says the pass happened, in exactly the
+				// content the pass existed to remove.
 				break
 
 			default: {
@@ -364,16 +419,16 @@ export function createRunReporter(parentLogger?: Logger): RunReporter {
 		const { tokenUsage, costInfo, currentIteration, stopReason } = run
 
 		log.info('Run summary', {
-			runId: run.id,
-			agent: run.metadata.agentName,
-			status: run.status,
-			stopReason: stopReason ?? 'unknown',
-			iterations: currentIteration,
-			promptTokens: tokenUsage.promptTokens,
-			completionTokens: tokenUsage.completionTokens,
-			totalTokens: tokenUsage.totalTokens,
-			cost: formatCost(costInfo.totalCost),
-			duration: formatDuration(elapsed),
+			[NAMZU.RUN_ID]: run.id,
+			'namzu.run.agent': run.metadata.agentName,
+			[NAMZU.RUN_STATUS]: run.status,
+			'namzu.run.stop_reason': stopReason ?? 'unknown',
+			'namzu.run.iterations': currentIteration,
+			[GENAI.USAGE_INPUT_TOKENS]: tokenUsage.promptTokens,
+			[GENAI.USAGE_OUTPUT_TOKENS]: tokenUsage.completionTokens,
+			'namzu.usage.total_tokens': tokenUsage.totalTokens,
+			'namzu.run.cost': formatCost(costInfo.totalCost),
+			'namzu.run.duration': formatDuration(elapsed),
 		})
 	}
 

package/src/run-query/index.ts

@@ -0,0 +1,108 @@
+import { ReadModelRegistry } from '../read-model/registry.js'
+import { RUN_STATUS_READ_MODEL_ID, createRunStatusReadModel } from '../read-model/run-status.js'
+import type { RunStatusState } from '../read-model/run-status.js'
+import type { Message } from '../types/message/index.js'
+import type { PersistedRunEvent, RunStatus, RunStore } from '../types/run/index.js'
+
+/**
+ * Asking a finished run what happened.
+ *
+ * The stores could each answer part of it and nothing could answer the
+ * question: `readEvents` gives a log, `writeMessages` persisted a history,
+ * and the two disagree by design once compaction has run — the persisted
+ * history is what SURVIVED, and what compaction removed lives only in the
+ * event log. So "show me this conversation" had two plausible answers and a
+ * caller picked one by accident.
+ *
+ * The compacted-away half is the reason this exists. `compaction_shed`
+ * carries "exactly the messages the pass removed, in their original order",
+ * shadowed to the transcript by NZ-RUNREC-06 precisely so it would not be
+ * lost — and until now nothing read it back. Evidence nobody can retrieve
+ * is evidence nobody kept.
+ */
+
+export interface RunQueryOptions {
+	readonly store: RunStore
+	/** Injectable for the same reason the read model injects it. */
+	readonly now?: () => number
+}
+
+/** What one compaction pass removed. */
+export interface ShedPass {
+	readonly iteration: number
+	readonly reason: 'threshold' | 'overflow'
+	readonly messages: readonly Message[]
+	/** Where in the log the pass sits, for a caller correlating with events. */
+	readonly seq: number
+}
+
+export class RunQuery {
+	constructor(private readonly options: RunQueryOptions) {}
+
+	/** The run's durable log, oldest first. */
+	async events(): Promise<readonly PersistedRunEvent[]> {
+		return await this.options.store.readEvents()
+	}
+
+	/**
+	 * Every message compaction removed, one entry per pass, oldest first.
+	 *
+	 * Reads the log rather than any separate store, because the log is where
+	 * the shed content already is — a second copy would be a second thing to
+	 * keep in agreement, and the one that drifted would be the one somebody
+	 * was reading during an incident.
+	 */
+	async shedHistory(): Promise<readonly ShedPass[]> {
+		const passes: ShedPass[] = []
+		for (const event of await this.events()) {
+			if (event.type !== 'compaction_shed') continue
+			passes.push({
+				iteration: event.iteration,
+				reason: event.reason,
+				messages: event.messages,
+				seq: event.seq,
+			})
+		}
+		return passes
+	}
+
+	/**
+	 * Everything that was ever in this conversation.
+	 *
+	 * Shed passes oldest first, then the run's surviving history — and the
+	 * ordering claim is exactly that, no more. This does NOT reconstruct the
+	 * original interleaving, and it cannot: the log records what each pass
+	 * removed, not where the summary that replaced it was inserted relative
+	 * to what came after. A caller wanting to know where a summary sits
+	 * reads it in `messages`, where it still is.
+	 *
+	 * What it DOES guarantee is completeness: no message that was ever in
+	 * the conversation is missing from this list, which is the question
+	 * somebody reconstructing an incident is actually asking.
+	 */
+	async fullTranscript(messages: readonly Message[]): Promise<readonly Message[]> {
+		const shed = await this.shedHistory()
+		if (shed.length === 0) return messages
+		return [...shed.flatMap((pass) => pass.messages), ...messages]
+	}
+
+	/**
+	 * The run's session-layer status, folded from its own log.
+	 *
+	 * Through the read model rather than a second projection: two folds of
+	 * one log are two chances to disagree, and a run that reads differently
+	 * depending on which surface asked is the defect this seam exists to
+	 * remove.
+	 */
+	async status(): Promise<RunStatus> {
+		return (await this.statusState()).status
+	}
+
+	/** The whole projected state, for a caller that wants the park too. */
+	async statusState(): Promise<RunStatusState> {
+		const registry = new ReadModelRegistry()
+		registry.register(createRunStatusReadModel(this.options.now ? { now: this.options.now } : {}))
+		registry.replay(await this.events())
+		return registry.get<RunStatusState>(RUN_STATUS_READ_MODEL_ID)
+	}
+}