zidane 7.2.5 → 8.0.4

package/dist/{src-CkNQKFKr.js → src-BRMYRJib.js}

@@ -1,19 +1,16 @@
-import { t as defineSkill } from "./skills-BC3dodWp.js";
-import { h as McpOAuthProvider, m as sseToJsonFetchIfNeeded, o as expandMcpConfigEnv, p as createTolerantClient, v as isOAuthTokenRejectionError } from "./mcp-CgNd-f3F.js";
-import { createRequire } from "node:module";
+import { g as McpOAuthProvider, h as createTolerantClient, l as expandMcpConfigEnv, s as sseToJsonFetchIfNeeded, y as isOAuthTokenRejectionError } from "./mcp-_wecH9Qe.js";
+import { readdirSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
 //#region src/behaviors/local-reliability.ts
 const DEFAULT_LOCAL_RELIABILITY = {
 	maxConcurrentTools: 3,
 	readFileDefaults: {
 		limit: 400,
-		maxBytes: 64 * 1024
+		maxBytes: 65536
 	},
-	toolOutputBudget: 32 * 1024,
+	toolOutputBudget: 32768,
 	textToolCallRescue: { mode: "steer" },
 	thinkingOverrunPolicy: {
 		mode: "steer-next-turn",
@@ -105,6 +102,39 @@ function commandSteps(command) {
 	return [];
 }
 /**
+* The one `/` command merge every host uses: builtins, then extension
+* commands, then markdown file commands. First registration wins,
+* case-insensitive; aliases reserve names so a later command named like an
+* earlier alias stays unreachable rather than ambiguous.
+*/
+function mergeCommands(layers, onDrop) {
+	const merged = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (command, layer) => {
+		const key = command.name.toLowerCase();
+		if (seen.has(key)) {
+			if (layer !== "builtin") onDrop?.(command, layer);
+			return;
+		}
+		seen.add(key);
+		for (const alias of command.aliases ?? []) seen.add(alias.toLowerCase());
+		merged.push(command);
+	};
+	for (const command of layers.builtins) add(command, "builtin");
+	for (const command of layers.extension) add(command, "extension");
+	for (const command of layers.file ?? []) add(command, "file");
+	return merged;
+}
+/**
+* Daemon-mode routing: does a resolved command run HOST-SIDE? Every command
+* that is not a TUI builtin (extension or markdown file) does; builtins and
+* an unresolved name stay local. Pass the command resolved from the MERGED
+* registry, so a builtin shadowing an extension of the same name stays local.
+*/
+function routesToDaemon(resolved, builtins) {
+	return resolved !== void 0 && !builtins.includes(resolved);
+}
+/**
 * Parse a prompt as a command invocation, but only when the command token is
 * the LEADING token of the whole prompt and names a known command. This is
 * what keeps mid-prompt `/skill` mentions routed to the skills provider:
@@ -142,6 +172,36 @@ function parseCommandInvocation(prompt, known) {
 		argv: args.length > 0 ? args.split(/\s+/) : []
 	};
 }
+function createCommandRunRecord(session, invocation) {
+	let runId;
+	const persist = async () => {
+		const record = runId ? session.runs.find((r) => r.id === runId) : void 0;
+		if (record) await session.updateRun(record).catch(() => void 0);
+	};
+	return {
+		async ensure() {
+			if (runId) return runId;
+			runId = `cmd_${crypto.randomUUID()}`;
+			session.startRun(runId, `/${invocation.name}${invocation.args ? ` ${invocation.args}` : ""}`, { depth: 0 });
+			const record = session.runs.find((r) => r.id === runId);
+			if (record) record.origin = { kind: "command" };
+			await persist();
+			return runId;
+		},
+		async finish(outcome) {
+			if (!runId) return;
+			const stats = {
+				turns: 0,
+				tokensIn: 0,
+				tokensOut: 0
+			};
+			if (outcome.error !== void 0) session.errorRun(runId, outcome.error, stats);
+			else if (outcome.aborted) session.abortRun(runId, stats);
+			else session.completeRun(runId, stats);
+			await persist();
+		}
+	};
+}
 /**
 * Run a command's steps in order, threading `ctx.data`. Stops at the first
 * step that throws (error isolated + returned, not rethrown) or when the
@@ -195,12 +255,12 @@ function isStandardSchema(value) {
 async function resolveSchemaInput(schema) {
 	if (!isStandardSchema(schema)) return schema;
 	const vendor = schema["~standard"].vendor;
-	if (vendor !== "zod") throw new Error(`unsupported schema vendor "${vendor}" — pass a zod v4 schema or a plain JSON Schema object`);
+	if (vendor !== "zod") throw new Error(`unsupported schema vendor "${vendor}". Pass a zod v4 schema or a plain JSON Schema object.`);
 	let toJSONSchema;
 	try {
 		toJSONSchema = (await import("zod")).z.toJSONSchema;
 	} catch {
-		throw new Error("a zod schema was passed but the \"zod\" package could not be imported — install zod >= 4");
+		throw new Error("a zod schema was passed but the \"zod\" package could not be imported. Install zod >= 4");
 	}
 	return zodToJsonSchema(toJSONSchema(schema));
 }
@@ -422,7 +482,7 @@ function cleanTitle(raw) {
 	if (s.length === 0) throw new Error("Model returned an empty title.");
 	if (/^\[.*\]$/.test(s)) throw new Error("Model returned a placeholder instead of a title.");
 	if (ANSWER_SHAPED_OPENER.test(s)) throw new Error("Model answered the conversation instead of titling it.");
-	return s.length > TITLE_MAX_CHARS ? `${s.slice(0, TITLE_MAX_CHARS - 1)}…` : s;
+	return s.length > TITLE_MAX_CHARS ? `${s.slice(0, 59)}…` : s;
 }
 function clip(text, max) {
 	return text.length > max ? `${text.slice(0, max)}…` : text;
@@ -581,429 +641,6 @@ function createPathAutocompleteProvider(opts = {}) {
 		}
 	};
 }
-/**
-* Optimistically transform the current ghost across a buffer edit so it
-* stays visible while the debounced provider re-query is in flight —
-* without this, every keystroke inside a completable token blinks the
-* ghost (hide → 120 ms → reshow).
-*
-* Two edits are reconcilable (everything else returns null and waits for
-* the authoritative result):
-*   - typing FORWARD along the suggestion (`bi` → `bin` with ghost
-*     `n/`): candidates are filtered to those starting with the typed
-*     chars and trimmed;
-*   - deleting BACKWARD within the token (`bin` → `bi` with ghost `/`):
-*     the deleted chars are re-prepended to every candidate. Guarded to
-*     non-whitespace so crossing a token boundary drops the ghost.
-*
-* The patched ghost is provisional — the provider's answer replaces it
-* (and may add candidates the patch couldn't know about).
-*/
-function patchInlineGhost(prev, text, cursor) {
-	if (!prev) return null;
-	if (text === prev.text && cursor === prev.cursor) return prev;
-	if (text.slice(cursor) !== prev.text.slice(prev.cursor)) return null;
-	if (cursor > prev.cursor) {
-		if (text.slice(0, prev.cursor) !== prev.text.slice(0, prev.cursor)) return null;
-		const typed = text.slice(prev.cursor, cursor);
-		const shown = prev.suffixes[prev.index];
-		const suffixes = prev.suffixes.filter((s) => s.startsWith(typed) && s.length > typed.length).map((s) => s.slice(typed.length));
-		if (suffixes.length === 0) return null;
-		const shownTrimmed = shown.startsWith(typed) ? shown.slice(typed.length) : null;
-		return {
-			suffixes,
-			index: shownTrimmed !== null ? Math.max(0, suffixes.indexOf(shownTrimmed)) : 0,
-			text,
-			cursor
-		};
-	}
-	if (prev.text.slice(0, cursor) !== text.slice(0, cursor)) return null;
-	const deleted = prev.text.slice(cursor, prev.cursor);
-	if (deleted.length === 0 || /\s/.test(deleted)) return null;
-	return {
-		suffixes: prev.suffixes.map((s) => deleted + s),
-		index: prev.index,
-		text,
-		cursor
-	};
-}
-//#endregion
-//#region src/extension-authoring.ts
-/**
-* Session-metadata key marking an "edit / create extension" session. The value
-* is an {@link ExtensionEditMarker}. Both hosts stamp it at session creation so
-* the agent build can scope the docs skill to exactly these sessions (and it
-* survives reload because metadata is persisted).
-*/
-const EXTENSION_EDIT_METADATA_KEY = "zidane.extensionEdit";
-/** Name of the inline docs skill auto-activated in extension edit sessions. */
-const ZIDANE_EXTENSION_SKILL_NAME = "zidane-extension";
-/**
-* Session-metadata key marking an "edit skill" session — the skill-editing
-* counterpart of {@link EXTENSION_EDIT_METADATA_KEY}. The value is a
-* {@link SkillEditMarker}. Stamped at session creation by both hosts (via
-* {@link editSessionMetadata}); persisted metadata means it survives reload.
-*/
-const SKILL_EDIT_METADATA_KEY = "zidane.skillEdit";
-/** Name of the inline preset skill auto-activated in skill edit sessions. */
-const ZIDANE_SKILL_EDIT_SKILL_NAME = "zidane-skill";
-/**
-* THE canonical seed for "open an editing session with preset context" —
-* the session metadata both hosts stamp at creation time. The engines read
-* the marker back and inject + auto-activate the matching inline preset
-* skill ({@link buildZidaneExtensionSkill} / {@link buildZidaneSkillEditSkill}),
-* so the preset rides as real conversation context from turn one.
-*/
-function editSessionMetadata(target) {
-	return target.kind === "extension" ? { [EXTENSION_EDIT_METADATA_KEY]: { dir: target.dir } } : { [SKILL_EDIT_METADATA_KEY]: {
-		dir: target.dir,
-		name: target.name
-	} };
-}
-/**
-* Parse a persisted {@link SkillEditMarker} back out of session metadata.
-* Tolerant: anything that isn't `{ dir: string, name: string }` → `null`
-* (older sessions, manual metadata edits, type drift).
-*/
-function readSkillEditMarker(raw) {
-	if (typeof raw !== "object" || raw === null) return null;
-	const { dir, name } = raw;
-	if (typeof dir !== "string" || dir.length === 0 || typeof name !== "string" || name.length === 0) return null;
-	return {
-		dir,
-		name
-	};
-}
-/**
-* Minimal valid extension module for a freshly-created extension. `name` MUST
-* equal the folder name or the loader rejects it (see `src/extensions/discovery`).
-* Does nothing by default — the author registers contributions via `ctx.*`
-* inside `setup`; the auto-activated docs skill guides them from there.
-*/
-function extensionScaffold(name) {
-	return `import { defineExtension } from 'zidane'
-
-/**
- * ${name} — a zidane extension.
- *
- * Register tools / hooks / skills / MCP servers / subagents / config / themes /
- * agents / keybindings via the \`ctx\` surface inside \`setup\`.
- *
- * Authoring reference: activate the \`${ZIDANE_EXTENSION_SKILL_NAME}\` skill — it carries
- * the full \`ctx\` API + invariants and is available whenever you open this
- * folder in zidane (or run \`zidane\` from inside it).
- */
-export default defineExtension({
-  name: '${name}',
-  setup(ctx) {
-    // e.g. ctx.registerTool('${name}_hello', {
-    //   spec: { name: '${name}_hello', description: 'say hi', inputSchema: { type: 'object', properties: {} } },
-    //   isConcurrencySafe: true,
-    //   async execute() { return 'hello from ${name}' },
-    // })
-  },
-})
-`;
-}
-/**
-* Locate the shipped `docs/` directory (`docs/EXTENSIONS.md` + siblings).
-*
-* The docs ship via `package.json` `files`, so an installed consumer has
-* `<root>/node_modules/zidane/docs` and the repo itself has `<repo>/docs`.
-* Returns the first existing candidate, or `null` (the skill then falls back to
-* the literal `node_modules/zidane/docs` hint, which the model's file tools can
-* still attempt from cwd).
-*/
-function resolveExtensionDocsDir(cwd = process.cwd()) {
-	const candidates = [];
-	try {
-		const req = createRequire(import.meta.url);
-		candidates.push(join(dirname(req.resolve("zidane/package.json")), "docs"));
-	} catch {}
-	try {
-		let dir = dirname(fileURLToPath(import.meta.url));
-		for (let i = 0; i < 6; i++) {
-			if (existsSync(join(dir, "docs", "EXTENSIONS.md"))) {
-				candidates.push(join(dir, "docs"));
-				break;
-			}
-			dir = dirname(dir);
-		}
-	} catch {}
-	candidates.push(join(cwd, "node_modules", "zidane", "docs"));
-	for (const candidate of candidates) if (existsSync(join(candidate, "EXTENSIONS.md"))) return candidate;
-	return null;
-}
-/** Entry-file probe order for an extension dir (mirrors the loader's discovery). */
-const EXTENSION_ENTRY_FILES = [
-	"index.ts",
-	"index.tsx",
-	"index.mjs",
-	"index.js"
-];
-/**
-* If `cwd` sits inside a zidane extension, return that extension's root dir,
-* else `null`. Mirrors the discovery layout
-* `<scope>/.{agents,zidane}/extensions/<name>/` — the root is the `<name>` dir
-* (parent `extensions`, grandparent `.agents` / `.zidane`) holding an entry
-* file. Walks up from `cwd`, so the nearest enclosing extension wins. Lets the
-* hosts surface the authoring skill for a plain `zidane` launched from an
-* extension folder, not just sessions opened through the edit/create flow.
-*/
-function extensionDirForCwd(cwd = process.cwd()) {
-	let dir = resolve(cwd);
-	for (let i = 0; i < 64; i++) {
-		const parent = dirname(dir);
-		if (basename(parent) === "extensions" && (basename(dirname(parent)) === ".agents" || basename(dirname(parent)) === ".zidane") && EXTENSION_ENTRY_FILES.some((f) => existsSync(join(dir, f)))) return dir;
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return null;
-}
-/**
-* The authoring reference embedded into the skill body. Kept INLINE (not a
-* filesystem path) on purpose: a `bun build --compile` TUI binary has no
-* resolvable `node_modules/zidane/docs`, no real `import.meta.url`, and the
-* edited extension's own cwd has no `node_modules` — so a path reference dead-
-* ends there. The model gets the API verbatim on activation regardless of host.
-*
-* Mirrors `ExtensionContext` (src/extensions/types.ts) — keep in sync when the
-* `ctx.*` surface changes.
-*/
-const EXTENSION_AUTHORING_CHEATSHEET = `## defineExtension
-
-A zidane extension is a module at \`<scope>/.{agents,zidane}/extensions/<name>/index.{ts,tsx,mjs,js}\`
-that default-exports \`defineExtension({ ... })\`. It runs in-process in the host (TUI / GUI / SDK).
-
-\`\`\`ts
-import { defineExtension } from 'zidane'
-
-export default defineExtension({
-  name: 'my-ext',          // MUST equal the folder name
-  apiVersion: 1,           // optional; omitted means v1
-  version: '0.1.0',        // optional — shown in Settings → Extensions
-  displayName: 'My Ext',   // optional UI label
-  description: 'what it does',
-  capabilities: ['tools'], // optional descriptive manifest labels
-  permissions: [],         // optional descriptive labels; not a sandbox
-  setup(ctx) { /* register everything here; may be async */ },
-  teardown() {},           // optional, reserved (no hot-reload yet)
-})
-\`\`\`
-
-Zero-import form — required INSIDE compiled binaries, which can't \`import 'zidane'\` at runtime:
-\`\`\`ts
-import type { ExtensionContext } from 'zidane' // type-only: erased at runtime
-export default {
-  name: 'my-ext',
-  setup(ctx: ExtensionContext) { /* ... */ },
-}
-\`\`\`
-
-## ctx surface (call everything inside setup)
-
-Identity / utilities:
-- ctx.name / ctx.version / ctx.dir / ctx.scope ('project' | 'user' | 'inline' | 'builtin')
-- ctx.logger          — Logger namespaced \`extension:<name>\`
-- ctx.config          — read THIS extension's config, default-first: \`ctx.config.get(key)\`
-- ctx.paths           — cwd/projectRoot/dataDir/cacheDir/configDir/stateDir
-- ctx.storage.path(scope, ...segments) — extension-scoped storage path
-- ctx.session         — JSON-only per-session state: get / set / delete
-
-Renderer-agnostic registration:
-- ctx.registerTool(name, toolDef)
-- ctx.registerHook(event, handler)             — an AgentHooks event; fires on the PARENT agent (use child:* for subagents)
-- ctx.registerMcpServer(config)
-- ctx.registerSkill(skillConfig)               — a defineSkill() shape
-- ctx.registerCompletionProvider(provider)     — single-char '/' '@' '!' trigger
-- ctx.tui.notify(text, { tone? })              — one-shot transcript line (info/warn/error); buffered pre-mount
-- ctx.tui.setStatus(text | null, { loader?, timeout? }) — single dim status line (transcript-tail slot); loader glyph, auto-clear ms
-- ctx.tui.setBanner(lines | null, { timeout? }) — short block above the prompt (stacked with the todo indicator); auto-clear ms
-- ctx.submitPrompt(text, { delivery? })        — submit as the user: 'auto' (run-or-queue), 'steer', 'followUp'; false when detached
-- ctx.registerToolPolicy({ tools?, decide })   — gate tool calls: allow / { block } / { patch } (patches re-validated by the loop)
-- ctx.registerToolResultTransform(fn)          — middleware over finished tool results (chained)
-- ctx.registerContextTransform(fn)             — rewrite wire messages before each provider call
-- ctx.registerPromptTransform(fn)              — transform or consume submitted prompts (after / commands, before skills)
-- ctx.runtime / ctx.sessions                   — late-bound host controls: model()/thinking()/setThinking(), sessions list/switch/create
-- ctx.appendNote(blocks)                       — durable display-only transcript note (command-output block vocabulary)
-- ctx.workspace.exec/readFile/writeFile/listFiles/fileSize — shell + files through the SESSION'S execution context (sandbox-correct; host child_process silently targets the wrong filesystem under docker/e2b). Detached ⇒ rejects; guard with \`await ctx.workspace.available()\`.
-- ctx.tui.registerToolRenderer({ tools?, render }) — custom view for tool-result rows; return null to fall through to the default. View-layer only: never persisted, error-bounded per row, TUI-scoped.
-- ctx.tui.registerRenderer(id, render) + emit/appendNote \`custom: { renderer, data }\` blocks — custom components in the transcript. \`data\` must be JSON-safe (it persists); the block's \`text\` is the MANDATORY markdown fallback (disabled extension, headless host, GUI, renderer throw). appendNote auto-prefixes bare ids; command emit needs \`<ext>/<id>\`.
-- Renderer components: import \`react\` / \`@opentui/react\` BARE (never as your own dependency) — the host maps them to its live instances at load time, so hooks work. Async data: render() stays sync; return a component that fetches with useState/useEffect.
-- Renderer async caching: \`useSessionState(id, initial)\` (per-row, session-persisted — rehydrates on reload) + \`useRowVisible()\` (latched viewport gate) from \`zidane/tui\` — fetch once, only when scrolled in.
-- ctx.registerCommand(command)                 — a '/<name>' workflow (handler or steps[]); step ctx: emit (local output),
-                                                 runAgent (interactive sub-run), generateData (silent zod/JSON-Schema JSON),
-                                                 session? (read-only turns/runs view), interaction? (confirm / askUser forms /
-                                                 presentPlan approval — both optional; guard for bare hosts)
-- ctx.registerTheme(theme)
-- ctx.registerAgent(profile)                   — extra agent profile in the picker
-- ctx.registerSubagent(def)                    — spawnable subagent (the spawn tool's subagent_type)
-- ctx.registerSubagentOverride(name, fn)       — edit/delete an existing subagent
-- ctx.registerProvider(descriptor)
-- ctx.registerSystemPromptFragment(text)
-- ctx.registerContextBreakdownSection(fn)      — render extension-owned rows in the context panel
-- ctx.registerContextPanelSection(section)     — richer context panel section with rows/load
-- ctx.registerToolResultMetadata(registration) — project namespaced tool-result metadata into context
-- ctx.registerRunTransform(fn)                 — sync rewrite of agent.run options
-- ctx.registerBehaviorTransform(fn)            — sync rewrite of resolved behavior
-- ctx.registerProviderMiddleware(fn)           — wrap provider instances
-- ctx.registerToolCatalogTransform(fn)         — shape/hide/rename tools before disclosure/execution
-- ctx.registerMcpConfigTransform(fn)           — rewrite MCP server configs before connect
-- ctx.registerSkillPolicy(policy)              — auto-activate skills by run context
-- ctx.registerConfigCategory(category)
-- ctx.registerConfigItem([categoryId,] item)   — typed setting; supports scope/onChange metadata
-
-TUI-only (ctx.tui.* — silently ignored on non-TUI hosts):
-- ctx.tui.registerKeybinding(binding)
-- ctx.tui.registerFooterHint(hint)
-- ctx.tui.registerModal(modal)                 — keep UI lazy: \`node: () => import('./panel')\`
-
-GUI-only:
-- ctx.gui.registerPanel(panel)                  — collected, not rendered yet
-
-Completion providers may also implement submit hooks:
-- resolveReferences(refs, ctx, signal)
-- onSubmit({ text, cursor, references }, signal)
-Both TUI and GUI call these before dispatching a submitted prompt.
-
-## ToolDef shape
-\`\`\`ts
-ctx.registerTool('my_tool', {
-  spec: { name: 'my_tool', description: '...', inputSchema: { type: 'object', properties: {} } },
-  isConcurrencySafe: true,   // default false (barrier/write); true = read-only, fans out in parallel
-  async execute(args) { return 'result' },
-})
-\`\`\`
-
-## Invariants
-- The folder name MUST equal \`name\`, or the loader rejects the extension.
-- Optional metadata lives in \`extension.json\` or \`package.json#zidane\`; unsupported \`apiVersion\` is rejected.
-- Export as \`default\` (or a named \`extension\` export).
-- Register ONLY inside \`setup\` — calls after it resolves are dropped (logger.warn).
-- A throw in \`setup\` is caught and shown on the extension's Settings row; the rest of boot continues.
-- Discovery order, first per name wins: project \`.agents\` → project \`.zidane\` → \`~/.agents\` → \`~/.zidane\`.
-- \`/reload\` is a TRUE hot-reload: re-discover + re-run setup, and each extension's module graph is re-imported fresh — code edits (deep imports included) apply live. Module-level state resets; clean up external resources in \`teardown\`.
-
-## Distribution
-- Users install via Settings → Extensions → \`ctrl+g\` (source input + scope picker) — GitHub (\`owner/repo[#ref][:sub/dir]\`, tree URLs) or npm (\`pkg[@version]\`, exact versions / dist-tags).
-- Update / remove: Settings → Extensions, \`ctrl+u\` / \`ctrl+x\` on the focused row (update replays the recorded \`.install.json\` provenance in place, skipping when the recorded commit/version still matches the remote).
-- Shape your repo/package as a root \`index.ts\` (single extension) or \`extensions/<name>/index.*\` dirs (collection).
-- Reference packages to copy: \`extensions/git-flow\` in the zidane repo (zero-dep \`/commit\` command) and \`extensions/headroom\` (hooks + tool + config).
-- Declare runtime deps in \`package.json#dependencies\` — installed with bun/npm/… WITHOUT lifecycle scripts; don't rely on postinstall.
-- The installed folder is named from your exported \`definition.name\` — pick it to be folder-safe ([A-Za-z0-9_.-]).`;
-/** Preset preamble for "edit / create extension" sessions. */
-const EXTENSION_EDIT_PRESET = "You are authoring / editing a zidane extension. Authoritative API reference:";
-/** Preset preamble for "edit skill" sessions — same spirit, skill-flavored. */
-function skillEditPreset(marker) {
-	return `We are going to work on ${marker.name}, in ${marker.dir} directory, next messages will be requests at modifying and improving the skill or understanding how it works better.`;
-}
-/**
-* The inline `zidane-extension` skill. Carries the authoring reference IN its
-* body ({@link EXTENSION_AUTHORING_CHEATSHEET}) so it works in every host —
-* incl. compiled binaries where the on-disk docs aren't resolvable. The shipped
-* `EXTENSIONS.md` (prose long-form) is appended as a "see also" only when found
-* on disk. `source: 'inline'` (the `defineSkill` default) survives the
-* project-trust gate.
-*/
-function buildZidaneExtensionSkill(opts = {}) {
-	const docsDir = resolveExtensionDocsDir(opts.cwd);
-	const seeAlso = docsDir ? `\n\n---\nFull prose reference on disk: ${join(docsDir, "EXTENSIONS.md")}\nSibling docs cover related surfaces (ARCHITECTURE.md, CHAT.md, TUI.md, SKILL.md, HEADLESS.md, …).` : "\n\n---\nFuller prose reference, when present: node_modules/zidane/docs/EXTENSIONS.md (often absent in compiled binaries — the API above is authoritative).";
-	return defineSkill({
-		name: ZIDANE_EXTENSION_SKILL_NAME,
-		description: "Authoring or editing a zidane extension (a module calling defineExtension, under .zidane/extensions/** or .agents/extensions/**). Carries the extension authoring reference.",
-		instructions: `${EXTENSION_EDIT_PRESET}\n\n${EXTENSION_AUTHORING_CHEATSHEET}${seeAlso}`
-	});
-}
-/**
-* Inject the `zidane-extension` skill into an already-merged {@link SkillsConfig}.
-*
-* Call this on the FINAL merged skills object (after folding extension / preset
-* skills): `composePresets` is last-wins on `catalog`, so injecting earlier
-* would be silently dropped whenever an extension also contributes skills.
-*
-* Adds the skill to the catalog and, when an `enabled` allowlist is in force,
-* force-includes the name so the allowlist filter can't hide it (mirrors how
-* extension-contributed skill names are force-included). When skills are fully
-* disabled (`enabled === false`), the edit session still gets just this skill.
-*/
-function withZidaneExtensionSkill(skills, opts = {}) {
-	return injectInlineSkill(skills, buildZidaneExtensionSkill(opts));
-}
-/**
-* Compact skill-authoring reference embedded into the skill-edit skill body.
-* Inline for the same reason as {@link EXTENSION_AUTHORING_CHEATSHEET}: works
-* in compiled binaries where on-disk docs don't resolve.
-*/
-const SKILL_AUTHORING_CHEATSHEET = `## SKILL.md anatomy
-
-A skill is a directory holding a \`SKILL.md\` (YAML frontmatter + markdown body)
-per the Agent Skills standard (agentskills.io/specification):
-
-\`\`\`md
----
-name: my-skill            # 1-64 chars, lowercase alphanumeric + hyphens; SHOULD match the directory name
-description: what it does AND when to use it (drives activation — 1-1024 chars)
-license: MIT              # optional
-compatibility: …          # optional environment requirements
-allowed-tools:            # optional — restricts the agent to these tools while active
-  - read_file
-metadata:                 # optional flat string map; zidane-specific keys use the \`zidane.\` prefix
-  some-key: value
----
-The body is the skill's instructions — injected into context when the skill
-is activated. Keep it token-lean: move depth into references/.
-\`\`\`
-
-## Bundled resources (all optional, discovered automatically)
-- \`references/\` — docs loaded on demand via \`skills_read\`
-- \`scripts/\`    — executables run via \`skills_run_script\` (honor shebangs)
-- \`assets/\`     — templates / static files
-
-## Guidance
-- The description is the activation trigger — write it for the ROUTER ("use when …"), the body for the ACTIVATED agent.
-- Prefer small bodies + lazy references over one giant SKILL.md.
-- Shell interpolation (exclamation mark + backtick-quoted command) in the body runs at activation — use sparingly; hosts may gate or disable it.
-- Validate names: mismatched frontmatter name vs directory loads with a warning diagnostic.`;
-/**
-* The inline skill auto-activated in "edit skill" sessions. Body = the
-* session preset (which skill, which directory, what the next messages will
-* be about) + a compact SKILL.md authoring reference — the skill-editing
-* counterpart of {@link buildZidaneExtensionSkill}.
-*/
-function buildZidaneSkillEditSkill(marker, opts = {}) {
-	const docsDir = resolveExtensionDocsDir(opts.cwd);
-	const seeAlso = docsDir && existsSync(join(docsDir, "SKILL.md")) ? `\n\n---\nFull prose reference on disk: ${join(docsDir, "SKILL.md")}` : "";
-	return defineSkill({
-		name: ZIDANE_SKILL_EDIT_SKILL_NAME,
-		description: `Editing or improving the "${marker.name}" agent skill (its SKILL.md, references, scripts, and assets). Carries the skill-authoring reference for this edit session.`,
-		instructions: `${skillEditPreset(marker)}\n\n${SKILL_AUTHORING_CHEATSHEET}${seeAlso}`
-	});
-}
-/**
-* Inject the skill-edit preset skill into an already-merged {@link SkillsConfig}.
-* Same contract as {@link withZidaneExtensionSkill} — call on the FINAL merged
-* skills object.
-*/
-function withZidaneSkillEditSkill(skills, marker, opts = {}) {
-	return injectInlineSkill(skills, buildZidaneSkillEditSkill(marker, opts));
-}
-/**
-* Shared injector: add `skill` to the catalog and, when an `enabled`
-* allowlist is in force, force-include its name so the filter can't hide it
-* (mirrors how extension-contributed skill names are force-included). When
-* skills are fully disabled (`enabled === false`), the edit session still
-* gets just this skill.
-*/
-function injectInlineSkill(skills, skill) {
-	const catalog = [...skills.catalog ?? [], skill];
-	const enabled = skills.enabled;
-	const nextEnabled = enabled === void 0 ? void 0 : Array.isArray(enabled) ? enabled.includes(skill.name) ? enabled : [...enabled, skill.name] : [skill.name];
-	return {
-		...skills,
-		catalog,
-		...nextEnabled !== void 0 ? { enabled: nextEnabled } : {}
-	};
-}
 //#endregion
 //#region src/mcp/oauth-callback.ts
 const DEFAULT_PATH = "/callback";
@@ -1148,7 +785,7 @@ async function startOAuthCallback(opts = {}) {
 }
 //#endregion
 //#region src/mcp/login.ts
-const DEFAULT_LOGIN_TIMEOUT_MS = 5 * 6e4;
+const DEFAULT_LOGIN_TIMEOUT_MS = 3e5;
 const DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
 /**
 * Run the full interactive OAuth flow for `config`. Only supports `sse` and
@@ -1165,13 +802,13 @@ const DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
 * failure.
 */
 async function loginMcpServer(config, options) {
-	if (config.transport !== "sse" && config.transport !== "streamable-http") throw new Error(`MCP OAuth: cannot login for transport "${config.transport}" — only sse / streamable-http are supported`);
+	if (config.transport !== "sse" && config.transport !== "streamable-http") throw new Error(`MCP OAuth: can't sign in over "${config.transport}". Only sse and streamable-http support it.`);
 	if (!config.url) throw new Error(`MCP OAuth: server "${config.name}" is missing a url`);
 	const hooks = options.hooks;
 	let settled = false;
 	let callback;
 	try {
-		callback = await startOAuthCallback({
+		callback = options.callback ?? await startOAuthCallback({
 			signal: options.signal,
 			path: options.callbackPath,
 			...options.renderCallbackPage ? { renderPage: options.renderCallbackPage } : {},
@@ -1184,6 +821,7 @@ async function loginMcpServer(config, options) {
 			redirectUri: handle.redirectUri,
 			clientName: options.clientName,
 			scope: options.scope,
+			...options.state !== void 0 ? { state: options.state } : {},
 			onAuthorizationUrl: async (url) => {
 				if (settled || options.signal?.aborted) return;
 				await hooks?.callHook("mcp:auth:url", {
@@ -1201,7 +839,7 @@ async function loginMcpServer(config, options) {
 		let needsAuth = false;
 		const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
 		for (let attempt = 0;; attempt++) try {
-			await raceAbort(client.connect(transport), options.signal, connectTimeoutMs, `MCP OAuth: "${config.name}" did not respond within ${connectTimeoutMs}ms — the server may be unreachable`);
+			await raceAbort(client.connect(transport), options.signal, connectTimeoutMs, `MCP OAuth: "${config.name}" did not respond within ${connectTimeoutMs}ms. The server may be unreachable.`);
 			break;
 		} catch (err) {
 			if (isUnauthorizedError(err)) {
@@ -1325,10 +963,7 @@ async function raceLoginCallback(handle, timeoutMs, signal) {
 	}
 }
 //#endregion
-//#region src/metrics.ts
-function prefixed$1(prefix, name) {
-	return prefix ? `${prefix}${name}` : name;
-}
+//#region src/metrics-hooks.ts
 /**
 * Drop `undefined` entries before handing attributes to a metrics
 * backend. OTel's `@opentelemetry/api` rejects `undefined` attribute
@@ -1345,6 +980,215 @@ function mergeAttrs(base, extra) {
 	for (const [k, v] of Object.entries(extra)) if (v !== void 0) out[k] = v;
 	return out;
 }
+/** Build the per-install state: fresh start-time maps + guarded emitters. */
+function createMetricsInstallState(base, onError) {
+	const turnStart = /* @__PURE__ */ new Map();
+	const toolStart = /* @__PURE__ */ new Map();
+	const mcpStart = /* @__PURE__ */ new Map();
+	const record = (instrument, value, attrs, kind) => {
+		if (!instrument) return;
+		try {
+			instrument.record(value, mergeAttrs(base, attrs));
+		} catch (err) {
+			try {
+				onError(kind, err);
+			} catch {}
+		}
+	};
+	const add = (instrument, value, attrs, kind) => {
+		if (!instrument) return;
+		try {
+			instrument.add(value, mergeAttrs(base, attrs));
+		} catch (err) {
+			try {
+				onError(kind, err);
+			} catch {}
+		}
+	};
+	return {
+		turnStart,
+		toolStart,
+		mcpStart,
+		record,
+		add
+	};
+}
+/** Agent lifecycle + turn / stream metrics. */
+function installMetricsRunHooks(hooks, unregisters, m, state) {
+	const { turnDuration, tokenUsage, ttft, runsStarted, runsCompleted, aborts, streamErrors, costMeter, runsActive } = m;
+	const { turnStart, toolStart, mcpStart, record, add } = state;
+	unregisters.push(hooks.hook("agent:start", (ctx) => {
+		const attrs = {
+			"gen_ai.agent.depth": ctx.depth,
+			...ctx.agentName ? { "gen_ai.agent.name": ctx.agentName } : {}
+		};
+		add(runsStarted, 1, attrs, "runs");
+		add(runsActive, 1, attrs, "runs.active");
+	}));
+	unregisters.push(hooks.hook("agent:done", () => {
+		add(runsCompleted, 1, {}, "runs.completed");
+		add(runsActive, -1, {}, "runs.active");
+		turnStart.clear();
+		toolStart.clear();
+		mcpStart.clear();
+	}));
+	unregisters.push(hooks.hook("agent:abort", () => {
+		add(aborts, 1, {}, "aborts");
+	}));
+	unregisters.push(hooks.hook("turn:before", (ctx) => {
+		turnStart.set(ctx.turnId, Date.now());
+	}));
+	unregisters.push(hooks.hook("turn:after", (ctx) => {
+		const started = turnStart.get(ctx.turnId);
+		turnStart.delete(ctx.turnId);
+		const tagsBase = {
+			"gen_ai.operation.name": "chat",
+			...ctx.usage.modelId ? { "gen_ai.response.model": ctx.usage.modelId } : {},
+			...ctx.usage.finishReason ? { "gen_ai.response.finish_reason": ctx.usage.finishReason } : {}
+		};
+		if (typeof started === "number") record(turnDuration, Date.now() - started, tagsBase, "turn.duration");
+		if (typeof ctx.usage.timeToFirstTokenMs === "number") record(ttft, ctx.usage.timeToFirstTokenMs, tagsBase, "ttft");
+		record(tokenUsage, ctx.usage.input, {
+			...tagsBase,
+			"gen_ai.token.type": "input"
+		}, "token.input");
+		record(tokenUsage, ctx.usage.output, {
+			...tagsBase,
+			"gen_ai.token.type": "output"
+		}, "token.output");
+		if (typeof ctx.usage.cacheRead === "number" && ctx.usage.cacheRead > 0) record(tokenUsage, ctx.usage.cacheRead, {
+			...tagsBase,
+			"gen_ai.token.type": "cache_read"
+		}, "token.cache_read");
+		if (typeof ctx.usage.cacheCreation === "number" && ctx.usage.cacheCreation > 0) record(tokenUsage, ctx.usage.cacheCreation, {
+			...tagsBase,
+			"gen_ai.token.type": "cache_creation"
+		}, "token.cache_creation");
+		if (typeof ctx.usage.cost === "number" && ctx.usage.cost > 0) add(costMeter, ctx.usage.cost, tagsBase, "cost");
+	}));
+	unregisters.push(hooks.hook("stream:error", (ctx) => {
+		add(streamErrors, 1, {
+			"http.response.status_code": ctx.statusCode,
+			"error.type": ctx.err instanceof Error ? ctx.err.name : "unknown"
+		}, "stream.error");
+	}));
+}
+/** Native tool, validation, budget, pairing and OAuth metrics. */
+function installMetricsToolHooks(hooks, unregisters, m, state) {
+	const { toolDuration, toolOutput, toolCalls, toolErrors, validationRejects, validationCoercions, gateBlocks, budgetExceeded, toolBudgetExceeded, pairingRepairs, oauthRefreshes } = m;
+	const { toolStart, record, add } = state;
+	unregisters.push(hooks.hook("tool:before", (ctx) => {
+		toolStart.set(ctx.callId, Date.now());
+	}));
+	unregisters.push(hooks.hook("tool:after", (ctx) => {
+		const started = toolStart.get(ctx.callId);
+		toolStart.delete(ctx.callId);
+		const tags = { "gen_ai.tool.name": ctx.name };
+		if (typeof started === "number") record(toolDuration, Date.now() - started, tags, "tool.duration");
+		record(toolOutput, ctx.outputBytes, tags, "tool.output_bytes");
+	}));
+	unregisters.push(hooks.hook("tool:error", (ctx) => {
+		add(toolErrors, 1, {
+			"gen_ai.tool.name": ctx.name,
+			"error.type": ctx.error.name
+		}, "tool.errors");
+	}));
+	unregisters.push(hooks.hook("tool:cancelled", (ctx) => {
+		toolStart.delete(ctx.callId);
+	}));
+	unregisters.push(hooks.hook("tool:dispatched", (ctx) => {
+		add(toolCalls, 1, {
+			"gen_ai.tool.name": ctx.name,
+			"outcome": ctx.outcome
+		}, "tool.calls");
+		if (ctx.outcome === "gate-block") add(gateBlocks, 1, {
+			"gen_ai.tool.name": ctx.name,
+			...ctx.reason ? { reason: ctx.reason } : {}
+		}, "gate.blocks");
+		if (ctx.outcome === "unknown") toolStart.delete(ctx.callId);
+	}));
+	unregisters.push(hooks.hook("validation:reject", (ctx) => {
+		add(validationRejects, 1, { "gen_ai.tool.name": ctx.name }, "validation.rejects");
+	}));
+	unregisters.push(hooks.hook("validation:coerce", (ctx) => {
+		add(validationCoercions, 1, {
+			"gen_ai.tool.name": ctx.name,
+			"coercions": ctx.coercions.length
+		}, "validation.coercions");
+	}));
+	unregisters.push(hooks.hook("budget:exceeded", (ctx) => {
+		add(budgetExceeded, 1, {
+			bytes: ctx.bytes,
+			budget: ctx.budget
+		}, "budget.exceeded");
+	}));
+	unregisters.push(hooks.hook("tool-budget:exceeded", (ctx) => {
+		add(toolBudgetExceeded, 1, {
+			"gen_ai.tool.name": ctx.tool,
+			"mode": ctx.mode,
+			"count": ctx.count,
+			"max": ctx.max
+		}, "tool_budget.exceeded");
+	}));
+	unregisters.push(hooks.hook("pairing:repair", (ctx) => {
+		add(pairingRepairs, 1, { mode: ctx.mode }, "pairing.repairs");
+	}));
+	unregisters.push(hooks.hook("oauth:refresh", (ctx) => {
+		add(oauthRefreshes, 1, {
+			provider: ctx.provider,
+			source: ctx.source
+		}, "oauth.refreshes");
+	}));
+}
+/** MCP tool / bootstrap / server metrics. */
+function installMetricsMcpHooks(hooks, unregisters, m, state) {
+	const { mcpToolDuration, mcpBootstrapDuration, mcpToolErrors, mcpErrors, mcpAuthRequired } = m;
+	const { mcpStart, record, add } = state;
+	unregisters.push(hooks.hook("mcp:tool:before", (ctx) => {
+		mcpStart.set(ctx.callId, Date.now());
+	}));
+	unregisters.push(hooks.hook("mcp:tool:after", (ctx) => {
+		const started = mcpStart.get(ctx.callId);
+		mcpStart.delete(ctx.callId);
+		const tags = {
+			"gen_ai.mcp.server": ctx.server,
+			"gen_ai.tool.name": ctx.displayName
+		};
+		if (typeof started === "number") record(mcpToolDuration, Date.now() - started, tags, "mcp.tool.duration");
+	}));
+	unregisters.push(hooks.hook("mcp:tool:error", (ctx) => {
+		mcpStart.delete(ctx.callId);
+		add(mcpToolErrors, 1, {
+			"gen_ai.mcp.server": ctx.server,
+			"gen_ai.tool.name": ctx.displayName,
+			"error.type": ctx.error.name
+		}, "mcp.tool.errors");
+	}));
+	unregisters.push(hooks.hook("mcp:bootstrap:end", (ctx) => {
+		record(mcpBootstrapDuration, ctx.durationMs, {
+			"gen_ai.mcp.server": ctx.name,
+			"ok": ctx.ok
+		}, "mcp.bootstrap.duration");
+	}));
+	unregisters.push(hooks.hook("mcp:error", (ctx) => {
+		add(mcpErrors, 1, {
+			"gen_ai.mcp.server": ctx.name,
+			"error.type": ctx.error.name
+		}, "mcp.errors");
+	}));
+	unregisters.push(hooks.hook("mcp:auth:required", (ctx) => {
+		add(mcpAuthRequired, 1, {
+			"gen_ai.mcp.server": ctx.name,
+			"transport": ctx.transport,
+			"reason": ctx.reason
+		}, "mcp.auth.required");
+	}));
+}
+//#endregion
+//#region src/metrics.ts
+function prefixed$1(prefix, name) {
+	return prefix ? `${prefix}${name}` : name;
+}
 /**
 * Build a set of metrics hook handlers that can be installed on an agent.
 *
@@ -1417,186 +1261,39 @@ function createMetricsHooks(options) {
 	});
 	const runsActive = make.upDown("gen_ai.agent.runs.active", { description: "In-flight agent runs." });
 	return { install(hooks) {
-		const turnStart = /* @__PURE__ */ new Map();
-		const toolStart = /* @__PURE__ */ new Map();
-		const mcpStart = /* @__PURE__ */ new Map();
-		const unregisters = [];
-		const record = (instrument, value, attrs, kind) => {
-			if (!instrument) return;
-			try {
-				instrument.record(value, mergeAttrs(base, attrs));
-			} catch (err) {
-				try {
-					onError(kind, err);
-				} catch {}
-			}
-		};
-		const add = (instrument, value, attrs, kind) => {
-			if (!instrument) return;
-			try {
-				instrument.add(value, mergeAttrs(base, attrs));
-			} catch (err) {
-				try {
-					onError(kind, err);
-				} catch {}
-			}
+		const state = createMetricsInstallState(base, onError);
+		const { turnStart, toolStart, mcpStart } = state;
+		const instruments = {
+			turnDuration,
+			tokenUsage,
+			ttft,
+			toolDuration,
+			toolOutput,
+			mcpToolDuration,
+			mcpBootstrapDuration,
+			runsStarted,
+			runsCompleted,
+			aborts,
+			toolCalls,
+			toolErrors,
+			mcpToolErrors,
+			streamErrors,
+			validationRejects,
+			validationCoercions,
+			gateBlocks,
+			budgetExceeded,
+			toolBudgetExceeded,
+			pairingRepairs,
+			oauthRefreshes,
+			mcpErrors,
+			mcpAuthRequired,
+			costMeter,
+			runsActive
 		};
-		unregisters.push(hooks.hook("agent:start", (ctx) => {
-			const attrs = {
-				"gen_ai.agent.depth": ctx.depth,
-				...ctx.agentName ? { "gen_ai.agent.name": ctx.agentName } : {}
-			};
-			add(runsStarted, 1, attrs, "runs");
-			add(runsActive, 1, attrs, "runs.active");
-		}));
-		unregisters.push(hooks.hook("agent:done", () => {
-			add(runsCompleted, 1, {}, "runs.completed");
-			add(runsActive, -1, {}, "runs.active");
-			turnStart.clear();
-			toolStart.clear();
-			mcpStart.clear();
-		}));
-		unregisters.push(hooks.hook("agent:abort", () => {
-			add(aborts, 1, {}, "aborts");
-		}));
-		unregisters.push(hooks.hook("turn:before", (ctx) => {
-			turnStart.set(ctx.turnId, Date.now());
-		}));
-		unregisters.push(hooks.hook("turn:after", (ctx) => {
-			const started = turnStart.get(ctx.turnId);
-			turnStart.delete(ctx.turnId);
-			const tagsBase = {
-				"gen_ai.operation.name": "chat",
-				...ctx.usage.modelId ? { "gen_ai.response.model": ctx.usage.modelId } : {},
-				...ctx.usage.finishReason ? { "gen_ai.response.finish_reason": ctx.usage.finishReason } : {}
-			};
-			if (typeof started === "number") record(turnDuration, Date.now() - started, tagsBase, "turn.duration");
-			if (typeof ctx.usage.timeToFirstTokenMs === "number") record(ttft, ctx.usage.timeToFirstTokenMs, tagsBase, "ttft");
-			record(tokenUsage, ctx.usage.input, {
-				...tagsBase,
-				"gen_ai.token.type": "input"
-			}, "token.input");
-			record(tokenUsage, ctx.usage.output, {
-				...tagsBase,
-				"gen_ai.token.type": "output"
-			}, "token.output");
-			if (typeof ctx.usage.cacheRead === "number" && ctx.usage.cacheRead > 0) record(tokenUsage, ctx.usage.cacheRead, {
-				...tagsBase,
-				"gen_ai.token.type": "cache_read"
-			}, "token.cache_read");
-			if (typeof ctx.usage.cacheCreation === "number" && ctx.usage.cacheCreation > 0) record(tokenUsage, ctx.usage.cacheCreation, {
-				...tagsBase,
-				"gen_ai.token.type": "cache_creation"
-			}, "token.cache_creation");
-			if (typeof ctx.usage.cost === "number" && ctx.usage.cost > 0) add(costMeter, ctx.usage.cost, tagsBase, "cost");
-		}));
-		unregisters.push(hooks.hook("stream:error", (ctx) => {
-			add(streamErrors, 1, {
-				"http.response.status_code": ctx.statusCode,
-				"error.type": ctx.err instanceof Error ? ctx.err.name : "unknown"
-			}, "stream.error");
-		}));
-		unregisters.push(hooks.hook("tool:before", (ctx) => {
-			toolStart.set(ctx.callId, Date.now());
-		}));
-		unregisters.push(hooks.hook("tool:after", (ctx) => {
-			const started = toolStart.get(ctx.callId);
-			toolStart.delete(ctx.callId);
-			const tags = { "gen_ai.tool.name": ctx.name };
-			if (typeof started === "number") record(toolDuration, Date.now() - started, tags, "tool.duration");
-			record(toolOutput, ctx.outputBytes, tags, "tool.output_bytes");
-		}));
-		unregisters.push(hooks.hook("tool:error", (ctx) => {
-			add(toolErrors, 1, {
-				"gen_ai.tool.name": ctx.name,
-				"error.type": ctx.error.name
-			}, "tool.errors");
-		}));
-		unregisters.push(hooks.hook("tool:cancelled", (ctx) => {
-			toolStart.delete(ctx.callId);
-		}));
-		unregisters.push(hooks.hook("tool:dispatched", (ctx) => {
-			add(toolCalls, 1, {
-				"gen_ai.tool.name": ctx.name,
-				"outcome": ctx.outcome
-			}, "tool.calls");
-			if (ctx.outcome === "gate-block") add(gateBlocks, 1, {
-				"gen_ai.tool.name": ctx.name,
-				...ctx.reason ? { reason: ctx.reason } : {}
-			}, "gate.blocks");
-			if (ctx.outcome === "unknown") toolStart.delete(ctx.callId);
-		}));
-		unregisters.push(hooks.hook("validation:reject", (ctx) => {
-			add(validationRejects, 1, { "gen_ai.tool.name": ctx.name }, "validation.rejects");
-		}));
-		unregisters.push(hooks.hook("validation:coerce", (ctx) => {
-			add(validationCoercions, 1, {
-				"gen_ai.tool.name": ctx.name,
-				"coercions": ctx.coercions.length
-			}, "validation.coercions");
-		}));
-		unregisters.push(hooks.hook("budget:exceeded", (ctx) => {
-			add(budgetExceeded, 1, {
-				bytes: ctx.bytes,
-				budget: ctx.budget
-			}, "budget.exceeded");
-		}));
-		unregisters.push(hooks.hook("tool-budget:exceeded", (ctx) => {
-			add(toolBudgetExceeded, 1, {
-				"gen_ai.tool.name": ctx.tool,
-				"mode": ctx.mode,
-				"count": ctx.count,
-				"max": ctx.max
-			}, "tool_budget.exceeded");
-		}));
-		unregisters.push(hooks.hook("pairing:repair", (ctx) => {
-			add(pairingRepairs, 1, { mode: ctx.mode }, "pairing.repairs");
-		}));
-		unregisters.push(hooks.hook("oauth:refresh", (ctx) => {
-			add(oauthRefreshes, 1, {
-				provider: ctx.provider,
-				source: ctx.source
-			}, "oauth.refreshes");
-		}));
-		unregisters.push(hooks.hook("mcp:tool:before", (ctx) => {
-			mcpStart.set(ctx.callId, Date.now());
-		}));
-		unregisters.push(hooks.hook("mcp:tool:after", (ctx) => {
-			const started = mcpStart.get(ctx.callId);
-			mcpStart.delete(ctx.callId);
-			const tags = {
-				"gen_ai.mcp.server": ctx.server,
-				"gen_ai.tool.name": ctx.displayName
-			};
-			if (typeof started === "number") record(mcpToolDuration, Date.now() - started, tags, "mcp.tool.duration");
-		}));
-		unregisters.push(hooks.hook("mcp:tool:error", (ctx) => {
-			mcpStart.delete(ctx.callId);
-			add(mcpToolErrors, 1, {
-				"gen_ai.mcp.server": ctx.server,
-				"gen_ai.tool.name": ctx.displayName,
-				"error.type": ctx.error.name
-			}, "mcp.tool.errors");
-		}));
-		unregisters.push(hooks.hook("mcp:bootstrap:end", (ctx) => {
-			record(mcpBootstrapDuration, ctx.durationMs, {
-				"gen_ai.mcp.server": ctx.name,
-				"ok": ctx.ok
-			}, "mcp.bootstrap.duration");
-		}));
-		unregisters.push(hooks.hook("mcp:error", (ctx) => {
-			add(mcpErrors, 1, {
-				"gen_ai.mcp.server": ctx.name,
-				"error.type": ctx.error.name
-			}, "mcp.errors");
-		}));
-		unregisters.push(hooks.hook("mcp:auth:required", (ctx) => {
-			add(mcpAuthRequired, 1, {
-				"gen_ai.mcp.server": ctx.name,
-				"transport": ctx.transport,
-				"reason": ctx.reason
-			}, "mcp.auth.required");
-		}));
+		const unregisters = [];
+		installMetricsRunHooks(hooks, unregisters, instruments, state);
+		installMetricsToolHooks(hooks, unregisters, instruments, state);
+		installMetricsMcpHooks(hooks, unregisters, instruments, state);
 		let disposed = false;
 		return function uninstall() {
 			if (disposed) return;
@@ -1693,7 +1390,7 @@ function createMutationValidationHooks(options) {
 	};
 }
 //#endregion
-//#region src/tracing.ts
+//#region src/tracing-attrs.ts
 /**
 * Stable keys we emit unconditionally — present in BOTH Sentry and OTel
 * conventions with identical semantics, so no `conventions` branching is
@@ -1894,6 +1591,572 @@ function buildUsageAttrs(usage, conventions) {
 	}
 	return out;
 }
+//#endregion
+//#region src/tracing-mcp-hooks.ts
+/** MCP `execute_tool` span. */
+function installTracingMcpToolHooks(hooks, unregisters, rt) {
+	const { legacy, conventions, wantSentry, captureContent, mcpSpans, safeStartSpan, safeSetAttrs, safeEnd, redact } = rt;
+	unregisters.push(hooks.hook("mcp:tool:before", (ctx) => {
+		const span = safeStartSpan(`execute_tool ${ctx.server}.${ctx.tool}`, {
+			[GEN_AI.operationName]: "execute_tool",
+			[GEN_AI.system]: rt.activeSystem,
+			[GEN_AI.toolName]: ctx.displayName,
+			[GEN_AI.toolType]: "extension",
+			[GEN_AI.toolCallId]: ctx.callId,
+			[GEN_AI.mcpServer]: ctx.server,
+			"sentry.op": "gen_ai.execute_tool",
+			"gen_ai.mcp.tool": ctx.tool,
+			"gen_ai.agent.turn_id": ctx.turnId,
+			"gen_ai.agent.run.id": ctx.runId,
+			...legacy ? {
+				server: ctx.server,
+				tool: ctx.tool,
+				displayName: ctx.displayName,
+				turnId: ctx.turnId,
+				callId: ctx.callId
+			} : {}
+		});
+		if (span) {
+			mcpSpans.set(ctx.callId, span);
+			if (captureContent) try {
+				const redacted = redact("mcp-tool-input", JSON.stringify(ctx.input), {
+					server: ctx.server,
+					tool: ctx.tool,
+					callId: ctx.callId
+				});
+				const attrs = {};
+				if (wantSentry) attrs[GEN_AI.toolCallArguments] = redacted;
+				if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolInputDeprecated] = redacted;
+				safeSetAttrs(span, attrs);
+			} catch {}
+		}
+	}));
+	unregisters.push(hooks.hook("mcp:tool:after", (ctx) => {
+		const span = mcpSpans.get(ctx.callId);
+		safeSetAttrs(span, { "gen_ai.tool.output_bytes": ctx.outputBytes });
+		if (captureContent && typeof ctx.result === "string") {
+			const redacted = redact("mcp-tool-result", ctx.result, {
+				server: ctx.server,
+				tool: ctx.tool,
+				callId: ctx.callId
+			});
+			const attrs = {};
+			if (wantSentry) attrs[GEN_AI.toolCallResult] = redacted;
+			if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolOutputDeprecated] = redacted;
+			safeSetAttrs(span, attrs);
+		}
+		safeEnd(mcpSpans, ctx.callId);
+	}));
+	unregisters.push(hooks.hook("mcp:tool:error", (ctx) => {
+		safeSetAttrs(mcpSpans.get(ctx.callId), {
+			"error.type": ctx.error.name,
+			"error.message": ctx.error.message
+		});
+		safeEnd(mcpSpans, ctx.callId);
+	}));
+}
+/** MCP server bootstrap span + server-level events. */
+function installTracingMcpServerHooks(hooks, unregisters, rt) {
+	const { bootstrapSpans, safeStartSpan, safeSetAttrs, safeEnd, safeAddEvent } = rt;
+	unregisters.push(hooks.hook("mcp:bootstrap:start", (ctx) => {
+		const span = safeStartSpan(`mcp.bootstrap ${ctx.name}`, {
+			[GEN_AI.operationName]: "mcp.bootstrap",
+			[GEN_AI.system]: rt.activeSystem,
+			[GEN_AI.mcpServer]: ctx.name,
+			"gen_ai.mcp.transport": ctx.transport
+		});
+		if (span) bootstrapSpans.set(ctx.name, span);
+	}));
+	unregisters.push(hooks.hook("mcp:bootstrap:end", (ctx) => {
+		const span = bootstrapSpans.get(ctx.name);
+		const ok = ctx.ok;
+		safeSetAttrs(span, {
+			"gen_ai.mcp.bootstrap.duration_ms": ctx.durationMs,
+			"gen_ai.mcp.bootstrap.ok": ok,
+			...ok ? {
+				[GEN_AI.mcpToolCount]: ctx.toolCount,
+				"gen_ai.mcp.lazy": ctx.lazy,
+				"gen_ai.mcp.cached": ctx.cached
+			} : {
+				"error.type": ctx.error.name,
+				"error.message": ctx.error.message
+			}
+		});
+		safeEnd(bootstrapSpans, ctx.name);
+	}));
+	unregisters.push(hooks.hook("mcp:auth:required", (ctx) => {
+		const span = bootstrapSpans.get(ctx.name);
+		safeAddEvent(span ?? rt.activeRunSpan, "gen_ai.mcp.auth.required", {
+			server: ctx.name,
+			transport: ctx.transport,
+			reason: ctx.reason
+		});
+	}));
+	unregisters.push(hooks.hook("mcp:error", (ctx) => {
+		safeAddEvent(rt.activeRunSpan, "gen_ai.mcp.error", {
+			"server": ctx.name,
+			"error.type": ctx.error.name,
+			"error.message": ctx.error.message
+		});
+	}));
+}
+//#endregion
+//#region src/tracing-run-hooks.ts
+/** `invoke_agent` root span: `agent:start` / `agent:done` / `agent:abort`. */
+function installTracingAgentHooks(hooks, unregisters, rt) {
+	const { legacy, conventions, runSpans, turnSpans, toolSpans, mcpSpans, spawnSpans, bootstrapSpans, turnTrack, safeStartSpan, safeSetAttrs, endAll } = rt;
+	unregisters.push(hooks.hook("agent:start", (ctx) => {
+		rt.activeSystem = ctx.providerName;
+		const displayName = ctx.agentName && ctx.agentName.length > 0 ? ctx.agentName : "agent";
+		const span = safeStartSpan(`invoke_agent ${displayName}`, {
+			[GEN_AI.operationName]: "invoke_agent",
+			[GEN_AI.system]: rt.activeSystem,
+			[GEN_AI.agentName]: ctx.agentName,
+			[GEN_AI.agentRunId]: ctx.runId,
+			[GEN_AI.agentParentRunId]: ctx.parentRunId,
+			[GEN_AI.agentDepth]: ctx.depth,
+			"sentry.op": "gen_ai.invoke_agent",
+			...legacy ? {
+				runId: ctx.runId,
+				parentRunId: ctx.parentRunId,
+				agentName: ctx.agentName,
+				depth: ctx.depth
+			} : {}
+		}, ctx.tracingContext);
+		if (span) {
+			runSpans.set(ctx.runId, span);
+			rt.activeRunSpan = span;
+		}
+	}));
+	unregisters.push(hooks.hook("agent:done", (stats) => {
+		const usageAttrs = buildUsageAttrs({
+			input: stats.totalIn,
+			output: stats.totalOut,
+			cacheRead: stats.totalCacheRead,
+			cacheCreation: stats.totalCacheCreation,
+			cost: stats.cost,
+			timeToFirstTokenMs: stats.timeTillFirstTokenMs
+		}, conventions);
+		for (const [, span] of runSpans) safeSetAttrs(span, {
+			...usageAttrs,
+			[GEN_AI.turn]: stats.turns,
+			"gen_ai.agent.elapsed_ms": stats.elapsed,
+			...legacy ? {
+				totalIn: stats.totalIn,
+				totalOut: stats.totalOut,
+				totalCacheRead: stats.totalCacheRead,
+				totalCacheCreation: stats.totalCacheCreation,
+				cost: stats.cost,
+				turns: stats.turns,
+				elapsed: stats.elapsed
+			} : {}
+		});
+		endAll(runSpans);
+		endAll(turnSpans);
+		endAll(toolSpans);
+		endAll(mcpSpans);
+		endAll(spawnSpans);
+		endAll(bootstrapSpans);
+		rt.activeRunSpan = void 0;
+		rt.activeSystem = void 0;
+		turnTrack.clear();
+	}));
+	unregisters.push(hooks.hook("agent:abort", () => {
+		for (const [, span] of runSpans) safeSetAttrs(span, { "gen_ai.agent.status": "aborted" });
+	}));
+}
+/** `chat` turn span + stream events. */
+function installTracingTurnHooks(hooks, unregisters, rt) {
+	const { legacy, conventions, wantSentry, captureContent, turnSpans, turnTrack, safeStartSpan, safeSetAttrs, safeEnd, safeAddEvent, redact } = rt;
+	unregisters.push(hooks.hook("turn:before", (ctx) => {
+		const requestedModel = ctx.options.model;
+		const baseAttrs = {
+			[GEN_AI.operationName]: "chat",
+			[GEN_AI.system]: rt.activeSystem,
+			[GEN_AI.requestModel]: requestedModel,
+			[GEN_AI.turn]: ctx.turn,
+			[GEN_AI.responseStreaming]: true,
+			[GEN_AI.requestMaxTokens]: ctx.options.maxTokens,
+			"sentry.op": "gen_ai.chat",
+			"gen_ai.agent.turn_id": ctx.turnId,
+			...legacy ? {
+				turnId: ctx.turnId,
+				turn: ctx.turn
+			} : {}
+		};
+		if (captureContent) {
+			const systemText = ctx.options.system;
+			if (systemText) baseAttrs[GEN_AI.systemInstructions] = redact("system", systemText, {
+				turnId: ctx.turnId,
+				turn: ctx.turn
+			});
+			const inputMsgs = stringifyMessages(ctx.options.messages);
+			if (inputMsgs) baseAttrs[GEN_AI.inputMessages] = redact("prompt", inputMsgs, {
+				turnId: ctx.turnId,
+				turn: ctx.turn
+			});
+			const toolDefs = stringifyToolDefs(ctx.options.tools);
+			if (toolDefs) baseAttrs[GEN_AI.toolDefinitions] = toolDefs;
+		}
+		const span = safeStartSpan(`chat${requestedModel ? ` ${requestedModel}` : ""}`, baseAttrs);
+		if (span) {
+			turnSpans.set(ctx.turnId, span);
+			turnTrack.set(ctx.turnId, { startedAt: Date.now() });
+		}
+	}));
+	unregisters.push(hooks.hook("stream:start", (ctx) => {
+		safeAddEvent(turnSpans.get(ctx.turnId), "gen_ai.stream.start", { startedAt: ctx.startedAt });
+	}));
+	unregisters.push(hooks.hook("turn:after", (ctx) => {
+		const span = turnSpans.get(ctx.turnId);
+		const tracked = turnTrack.get(ctx.turnId);
+		turnTrack.delete(ctx.turnId);
+		let tokensPerSecond;
+		if (tracked && ctx.usage.output > 0) {
+			const elapsedMs = Date.now() - tracked.startedAt;
+			if (elapsedMs > 0) tokensPerSecond = ctx.usage.output / elapsedMs * 1e3;
+		}
+		const usageAttrs = buildUsageAttrs(ctx.usage, conventions);
+		const cumInputTokens = wantSentry ? ctx.cumulativeUsage.input + ctx.cumulativeUsage.cacheRead + ctx.cumulativeUsage.cacheCreation : ctx.cumulativeUsage.input;
+		const attrs = {
+			...usageAttrs,
+			[GEN_AI.responseTokensPerSecond]: tokensPerSecond,
+			"gen_ai.agent.cumulative.input_tokens": cumInputTokens,
+			"gen_ai.agent.cumulative.output_tokens": ctx.cumulativeUsage.output,
+			"gen_ai.agent.cumulative.total_tokens": cumInputTokens + ctx.cumulativeUsage.output,
+			"gen_ai.agent.cumulative.cache_read_input_tokens": ctx.cumulativeUsage.cacheRead,
+			"gen_ai.agent.cumulative.cache_creation_input_tokens": ctx.cumulativeUsage.cacheCreation,
+			"gen_ai.agent.cumulative.cost_usd": ctx.cumulativeUsage.cost,
+			"gen_ai.agent.cumulative.turns": ctx.cumulativeUsage.turns,
+			...legacy ? {
+				inputTokens: ctx.usage.input,
+				outputTokens: ctx.usage.output,
+				finishReason: ctx.usage.finishReason,
+				modelId: ctx.usage.modelId
+			} : {}
+		};
+		if (captureContent && ctx.message && ctx.message.role !== "system" && ctx.message.role !== "command") {
+			const outputMsgs = stringifyMessages([{
+				role: ctx.message.role,
+				content: ctx.message.content
+			}]);
+			if (outputMsgs) attrs[GEN_AI.outputMessages] = redact("stream-text", outputMsgs, {
+				turnId: ctx.turnId,
+				turn: ctx.turn
+			});
+		}
+		safeSetAttrs(span, attrs);
+		safeEnd(turnSpans, ctx.turnId);
+	}));
+	unregisters.push(hooks.hook("stream:error", (ctx) => {
+		const span = turnSpans.get(ctx.turnId);
+		const message = ctx.err instanceof Error ? ctx.err.message : String(ctx.err);
+		safeSetAttrs(span, {
+			"error.type": ctx.err instanceof Error ? ctx.err.name : "unknown",
+			"error.message": message,
+			"http.response.status_code": ctx.statusCode,
+			"gen_ai.request.id": ctx.requestId
+		});
+		safeAddEvent(span, "gen_ai.stream.error", {
+			"error.type": ctx.err instanceof Error ? ctx.err.name : "unknown",
+			"error.message": message,
+			"http.response.status_code": ctx.statusCode,
+			"gen_ai.request.id": ctx.requestId
+		});
+	}));
+}
+//#endregion
+//#region src/tracing-runtime.ts
+/** Build a fresh runtime — called once per `install()`. */
+function createTracingRuntime(options, config) {
+	const { namespace, legacy, conventions, wantSentry, captureContent, onError } = config;
+	function safeStartSpan(name, attrs, parentContext) {
+		try {
+			return options.startSpan(prefixed(namespace, name), compact(attrs), parentContext);
+		} catch (err) {
+			try {
+				onError("startSpan", err);
+			} catch {}
+			return;
+		}
+	}
+	function safeSetAttrs(span, attrs) {
+		if (!span?.setAttributes) return;
+		try {
+			span.setAttributes(compact(attrs));
+		} catch (err) {
+			try {
+				onError("setAttributes", err);
+			} catch {}
+		}
+	}
+	function safeEnd(map, key) {
+		const span = map.get(key);
+		if (!span) return;
+		try {
+			span.end();
+		} catch (err) {
+			try {
+				onError("end", err);
+			} catch {}
+		}
+		map.delete(key);
+	}
+	function endAll(map) {
+		for (const [, span] of map) try {
+			span.end();
+		} catch (err) {
+			try {
+				onError("end", err);
+			} catch {}
+		}
+		map.clear();
+	}
+	function safeAddEvent(span, name, attrs) {
+		if (!span) return;
+		if (typeof span.addEvent === "function") {
+			try {
+				span.addEvent(name, compact(attrs));
+			} catch (err) {
+				try {
+					onError("addEvent", err);
+				} catch {}
+			}
+			return;
+		}
+		safeSetAttrs(span, Object.fromEntries(Object.entries(compact(attrs)).map(([k, v]) => [`event.${name}.${k}`, v])));
+	}
+	function redact(kind, value, meta) {
+		if (typeof options.redact !== "function") return value;
+		try {
+			return options.redact(kind, value, meta);
+		} catch (err) {
+			try {
+				onError("redact", err);
+			} catch {}
+			return value;
+		}
+	}
+	return {
+		options,
+		legacy,
+		conventions,
+		wantSentry,
+		captureContent,
+		onError,
+		runSpans: /* @__PURE__ */ new Map(),
+		turnSpans: /* @__PURE__ */ new Map(),
+		toolSpans: /* @__PURE__ */ new Map(),
+		mcpSpans: /* @__PURE__ */ new Map(),
+		spawnSpans: /* @__PURE__ */ new Map(),
+		bootstrapSpans: /* @__PURE__ */ new Map(),
+		activeSystem: void 0,
+		turnTrack: /* @__PURE__ */ new Map(),
+		activeRunSpan: void 0,
+		safeStartSpan,
+		safeSetAttrs,
+		safeEnd,
+		endAll,
+		safeAddEvent,
+		redact
+	};
+}
+//#endregion
+//#region src/tracing-spawn-hooks.ts
+/** `handoff` spawn span + child trace-context injection. */
+function installTracingSpawnHooks(hooks, unregisters, rt) {
+	const { options, conventions, onError, spawnSpans, safeStartSpan, safeSetAttrs, safeEnd } = rt;
+	unregisters.push(hooks.hook("spawn:before", (ctx) => {
+		const toAgent = ctx.task.length > 60 ? `${ctx.task.slice(0, 57)}…` : ctx.task;
+		const span = safeStartSpan(`handoff to ${toAgent}`, {
+			[GEN_AI.operationName]: "handoff",
+			[GEN_AI.system]: rt.activeSystem,
+			"sentry.op": "gen_ai.handoff",
+			"gen_ai.agent.spawn.id": ctx.id,
+			"gen_ai.agent.spawn.task": ctx.task,
+			"gen_ai.agent.depth": ctx.depth
+		});
+		if (span) spawnSpans.set(ctx.id, span);
+		if (typeof options.getActiveTraceContext === "function" && ctx.tracingContext) {
+			let carrier;
+			try {
+				carrier = options.getActiveTraceContext();
+			} catch (err) {
+				try {
+					onError("getActiveTraceContext", err);
+				} catch {}
+			}
+			if (carrier) for (const [k, v] of Object.entries(carrier)) ctx.tracingContext[k] = v;
+		}
+	}));
+	unregisters.push(hooks.hook("spawn:complete", (ctx) => {
+		const span = spawnSpans.get(ctx.id);
+		const childUsage = buildUsageAttrs({
+			input: ctx.stats.totalIn,
+			output: ctx.stats.totalOut,
+			cacheRead: ctx.stats.totalCacheRead,
+			cacheCreation: ctx.stats.totalCacheCreation,
+			cost: ctx.stats.cost
+		}, conventions);
+		safeSetAttrs(span, {
+			"gen_ai.agent.spawn.status": ctx.status ?? "completed",
+			"gen_ai.agent.spawn.depth": ctx.depth,
+			...childUsage
+		});
+		safeEnd(spawnSpans, ctx.id);
+	}));
+	unregisters.push(hooks.hook("spawn:error", (ctx) => {
+		safeSetAttrs(spawnSpans.get(ctx.id), {
+			"error.type": ctx.error.name,
+			"error.message": ctx.error.message
+		});
+		safeEnd(spawnSpans, ctx.id);
+	}));
+}
+//#endregion
+//#region src/tracing-tool-hooks.ts
+/** Native `execute_tool` span. */
+function installTracingToolHooks(hooks, unregisters, rt) {
+	const { legacy, conventions, wantSentry, captureContent, toolSpans, safeStartSpan, safeSetAttrs, safeEnd, redact } = rt;
+	unregisters.push(hooks.hook("tool:before", (ctx) => {
+		const span = safeStartSpan(`execute_tool ${ctx.displayName}`, {
+			[GEN_AI.operationName]: "execute_tool",
+			[GEN_AI.system]: rt.activeSystem,
+			[GEN_AI.toolName]: ctx.name,
+			[GEN_AI.toolType]: "function",
+			[GEN_AI.toolCallId]: ctx.callId,
+			"sentry.op": "gen_ai.execute_tool",
+			"gen_ai.tool.display_name": ctx.displayName,
+			"gen_ai.agent.turn_id": ctx.turnId,
+			"gen_ai.agent.depth": ctx.depth,
+			"gen_ai.agent.run.id": ctx.runId,
+			"gen_ai.agent.parent_run.id": ctx.parentRunId,
+			...legacy ? {
+				toolName: ctx.name,
+				displayName: ctx.displayName,
+				turnId: ctx.turnId,
+				callId: ctx.callId
+			} : {}
+		});
+		if (span) {
+			toolSpans.set(ctx.callId, span);
+			if (captureContent) try {
+				const serialized = JSON.stringify(ctx.input);
+				const redacted = redact("tool-input", serialized, {
+					toolName: ctx.name,
+					displayName: ctx.displayName,
+					callId: ctx.callId,
+					turnId: ctx.turnId
+				});
+				const attrs = {};
+				if (wantSentry) attrs[GEN_AI.toolCallArguments] = redacted;
+				if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolInputDeprecated] = redacted;
+				safeSetAttrs(span, attrs);
+			} catch {}
+		}
+	}));
+	unregisters.push(hooks.hook("tool:after", (ctx) => {
+		const span = toolSpans.get(ctx.callId);
+		safeSetAttrs(span, {
+			"gen_ai.tool.output_bytes": ctx.outputBytes,
+			"gen_ai.tool.coercions": ctx.coercions?.length ?? 0
+		});
+		if (captureContent && typeof ctx.result === "string") {
+			const redacted = redact("tool-result", ctx.result, {
+				toolName: ctx.name,
+				callId: ctx.callId
+			});
+			const attrs = {};
+			if (wantSentry) attrs[GEN_AI.toolCallResult] = redacted;
+			if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolOutputDeprecated] = redacted;
+			safeSetAttrs(span, attrs);
+		}
+		safeEnd(toolSpans, ctx.callId);
+	}));
+	unregisters.push(hooks.hook("tool:error", (ctx) => {
+		safeSetAttrs(toolSpans.get(ctx.callId), {
+			"error.type": ctx.error.name,
+			"error.message": ctx.error.message
+		});
+		safeEnd(toolSpans, ctx.callId);
+	}));
+	unregisters.push(hooks.hook("tool:cancelled", (ctx) => {
+		safeSetAttrs(toolSpans.get(ctx.callId), {
+			"gen_ai.tool.status": "cancelled",
+			"gen_ai.tool.cancel_reason": ctx.reason
+		});
+		safeEnd(toolSpans, ctx.callId);
+	}));
+}
+/** Gate / validation / budget / pairing / OAuth events on the run span. */
+function installTracingPolicyEventHooks(hooks, unregisters, rt) {
+	const { safeAddEvent } = rt;
+	unregisters.push(hooks.hook("tool:dispatched", (ctx) => {
+		if (ctx.outcome === "gate-block") safeAddEvent(rt.activeRunSpan, "gen_ai.gate.block", {
+			[GEN_AI.toolName]: ctx.name,
+			[GEN_AI.toolCallId]: ctx.callId,
+			reason: ctx.reason
+		});
+		else if (ctx.outcome === "gate-substitute") safeAddEvent(rt.activeRunSpan, "gen_ai.gate.substitute", {
+			[GEN_AI.toolName]: ctx.name,
+			[GEN_AI.toolCallId]: ctx.callId
+		});
+		else if (ctx.outcome === "unknown") safeAddEvent(rt.activeRunSpan, "gen_ai.tool.unknown", {
+			[GEN_AI.toolName]: ctx.name,
+			[GEN_AI.toolCallId]: ctx.callId
+		});
+		else if (ctx.outcome === "invalid-input") safeAddEvent(rt.activeRunSpan, "gen_ai.tool.invalid_input", {
+			[GEN_AI.toolName]: ctx.name,
+			[GEN_AI.toolCallId]: ctx.callId
+		});
+	}));
+	unregisters.push(hooks.hook("validation:reject", (ctx) => {
+		safeAddEvent(rt.activeRunSpan, "gen_ai.validation.reject", {
+			[GEN_AI.toolName]: ctx.name,
+			[GEN_AI.toolCallId]: ctx.callId,
+			reason: ctx.reason
+		});
+	}));
+	unregisters.push(hooks.hook("validation:coerce", (ctx) => {
+		safeAddEvent(rt.activeRunSpan, "gen_ai.validation.coerce", {
+			[GEN_AI.toolName]: ctx.name,
+			[GEN_AI.toolCallId]: ctx.callId,
+			coercions: ctx.coercions
+		});
+	}));
+	unregisters.push(hooks.hook("budget:exceeded", (ctx) => {
+		safeAddEvent(rt.activeRunSpan, "gen_ai.budget.exceeded", {
+			turnId: ctx.turnId,
+			bytes: ctx.bytes,
+			budget: ctx.budget
+		});
+	}));
+	unregisters.push(hooks.hook("tool-budget:exceeded", (ctx) => {
+		safeAddEvent(rt.activeRunSpan, "gen_ai.tool_budget.exceeded", {
+			[GEN_AI.toolName]: ctx.tool,
+			turnId: ctx.turnId,
+			count: ctx.count,
+			max: ctx.max,
+			mode: ctx.mode
+		});
+	}));
+	unregisters.push(hooks.hook("pairing:repair", (ctx) => {
+		safeAddEvent(rt.activeRunSpan, "gen_ai.pairing.repair", {
+			mode: ctx.mode,
+			callId: ctx.callId,
+			turnId: ctx.turnId
+		});
+	}));
+	unregisters.push(hooks.hook("oauth:refresh", (ctx) => {
+		safeAddEvent(rt.activeRunSpan, "gen_ai.oauth.refresh", {
+			provider: ctx.provider,
+			providerId: ctx.providerId,
+			source: ctx.source
+		});
+	}));
+}
+//#endregion
+//#region src/tracing.ts
 /**
 * Build a set of tracing hook handlers that can be installed on an agent.
 *
@@ -1933,504 +2196,23 @@ function createTracingHooks(options) {
 	const captureContent = options.captureMessageContent !== false;
 	const onError = options.onError ?? (() => {});
 	return { install(hooks) {
-		const runSpans = /* @__PURE__ */ new Map();
-		const turnSpans = /* @__PURE__ */ new Map();
-		const toolSpans = /* @__PURE__ */ new Map();
-		const mcpSpans = /* @__PURE__ */ new Map();
-		const spawnSpans = /* @__PURE__ */ new Map();
-		const bootstrapSpans = /* @__PURE__ */ new Map();
-		let activeSystem;
-		const turnTrack = /* @__PURE__ */ new Map();
-		let activeRunSpan;
-		function safeStartSpan(name, attrs, parentContext) {
-			try {
-				return options.startSpan(prefixed(namespace, name), compact(attrs), parentContext);
-			} catch (err) {
-				try {
-					onError("startSpan", err);
-				} catch {}
-				return;
-			}
-		}
-		function safeSetAttrs(span, attrs) {
-			if (!span?.setAttributes) return;
-			try {
-				span.setAttributes(compact(attrs));
-			} catch (err) {
-				try {
-					onError("setAttributes", err);
-				} catch {}
-			}
-		}
-		function safeEnd(map, key) {
-			const span = map.get(key);
-			if (!span) return;
-			try {
-				span.end();
-			} catch (err) {
-				try {
-					onError("end", err);
-				} catch {}
-			}
-			map.delete(key);
-		}
-		function endAll(map) {
-			for (const [, span] of map) try {
-				span.end();
-			} catch (err) {
-				try {
-					onError("end", err);
-				} catch {}
-			}
-			map.clear();
-		}
-		function safeAddEvent(span, name, attrs) {
-			if (!span) return;
-			if (typeof span.addEvent === "function") {
-				try {
-					span.addEvent(name, compact(attrs));
-				} catch (err) {
-					try {
-						onError("addEvent", err);
-					} catch {}
-				}
-				return;
-			}
-			safeSetAttrs(span, Object.fromEntries(Object.entries(compact(attrs)).map(([k, v]) => [`event.${name}.${k}`, v])));
-		}
-		function redact(kind, value, meta) {
-			if (typeof options.redact !== "function") return value;
-			try {
-				return options.redact(kind, value, meta);
-			} catch (err) {
-				try {
-					onError("redact", err);
-				} catch {}
-				return value;
-			}
-		}
+		const rt = createTracingRuntime(options, {
+			namespace,
+			legacy,
+			conventions,
+			wantSentry,
+			captureContent,
+			onError
+		});
+		const { runSpans, turnSpans, toolSpans, mcpSpans, spawnSpans, bootstrapSpans, endAll } = rt;
 		const unregisters = [];
-		unregisters.push(hooks.hook("agent:start", (ctx) => {
-			activeSystem = ctx.providerName;
-			const span = safeStartSpan(`invoke_agent ${ctx.agentName && ctx.agentName.length > 0 ? ctx.agentName : "agent"}`, {
-				[GEN_AI.operationName]: "invoke_agent",
-				[GEN_AI.system]: activeSystem,
-				[GEN_AI.agentName]: ctx.agentName,
-				[GEN_AI.agentRunId]: ctx.runId,
-				[GEN_AI.agentParentRunId]: ctx.parentRunId,
-				[GEN_AI.agentDepth]: ctx.depth,
-				"sentry.op": "gen_ai.invoke_agent",
-				...legacy ? {
-					runId: ctx.runId,
-					parentRunId: ctx.parentRunId,
-					agentName: ctx.agentName,
-					depth: ctx.depth
-				} : {}
-			}, ctx.tracingContext);
-			if (span) {
-				runSpans.set(ctx.runId, span);
-				activeRunSpan = span;
-			}
-		}));
-		unregisters.push(hooks.hook("agent:done", (stats) => {
-			const usageAttrs = buildUsageAttrs({
-				input: stats.totalIn,
-				output: stats.totalOut,
-				cacheRead: stats.totalCacheRead,
-				cacheCreation: stats.totalCacheCreation,
-				cost: stats.cost,
-				timeToFirstTokenMs: stats.timeTillFirstTokenMs
-			}, conventions);
-			for (const [, span] of runSpans) safeSetAttrs(span, {
-				...usageAttrs,
-				[GEN_AI.turn]: stats.turns,
-				"gen_ai.agent.elapsed_ms": stats.elapsed,
-				...legacy ? {
-					totalIn: stats.totalIn,
-					totalOut: stats.totalOut,
-					totalCacheRead: stats.totalCacheRead,
-					totalCacheCreation: stats.totalCacheCreation,
-					cost: stats.cost,
-					turns: stats.turns,
-					elapsed: stats.elapsed
-				} : {}
-			});
-			endAll(runSpans);
-			endAll(turnSpans);
-			endAll(toolSpans);
-			endAll(mcpSpans);
-			endAll(spawnSpans);
-			endAll(bootstrapSpans);
-			activeRunSpan = void 0;
-			activeSystem = void 0;
-			turnTrack.clear();
-		}));
-		unregisters.push(hooks.hook("agent:abort", () => {
-			for (const [, span] of runSpans) safeSetAttrs(span, { "gen_ai.agent.status": "aborted" });
-		}));
-		unregisters.push(hooks.hook("turn:before", (ctx) => {
-			const requestedModel = ctx.options.model;
-			const baseAttrs = {
-				[GEN_AI.operationName]: "chat",
-				[GEN_AI.system]: activeSystem,
-				[GEN_AI.requestModel]: requestedModel,
-				[GEN_AI.turn]: ctx.turn,
-				[GEN_AI.responseStreaming]: true,
-				[GEN_AI.requestMaxTokens]: ctx.options.maxTokens,
-				"sentry.op": "gen_ai.chat",
-				"gen_ai.agent.turn_id": ctx.turnId,
-				...legacy ? {
-					turnId: ctx.turnId,
-					turn: ctx.turn
-				} : {}
-			};
-			if (captureContent) {
-				const systemText = ctx.options.system;
-				if (systemText) baseAttrs[GEN_AI.systemInstructions] = redact("system", systemText, {
-					turnId: ctx.turnId,
-					turn: ctx.turn
-				});
-				const inputMsgs = stringifyMessages(ctx.options.messages);
-				if (inputMsgs) baseAttrs[GEN_AI.inputMessages] = redact("prompt", inputMsgs, {
-					turnId: ctx.turnId,
-					turn: ctx.turn
-				});
-				const toolDefs = stringifyToolDefs(ctx.options.tools);
-				if (toolDefs) baseAttrs[GEN_AI.toolDefinitions] = toolDefs;
-			}
-			const span = safeStartSpan(`chat${requestedModel ? ` ${requestedModel}` : ""}`, baseAttrs);
-			if (span) {
-				turnSpans.set(ctx.turnId, span);
-				turnTrack.set(ctx.turnId, { startedAt: Date.now() });
-			}
-		}));
-		unregisters.push(hooks.hook("stream:start", (ctx) => {
-			safeAddEvent(turnSpans.get(ctx.turnId), "gen_ai.stream.start", { startedAt: ctx.startedAt });
-		}));
-		unregisters.push(hooks.hook("turn:after", (ctx) => {
-			const span = turnSpans.get(ctx.turnId);
-			const tracked = turnTrack.get(ctx.turnId);
-			turnTrack.delete(ctx.turnId);
-			let tokensPerSecond;
-			if (tracked && ctx.usage.output > 0) {
-				const elapsedMs = Date.now() - tracked.startedAt;
-				if (elapsedMs > 0) tokensPerSecond = ctx.usage.output / elapsedMs * 1e3;
-			}
-			const usageAttrs = buildUsageAttrs(ctx.usage, conventions);
-			const cumInputTokens = wantSentry ? ctx.cumulativeUsage.input + ctx.cumulativeUsage.cacheRead + ctx.cumulativeUsage.cacheCreation : ctx.cumulativeUsage.input;
-			const attrs = {
-				...usageAttrs,
-				[GEN_AI.responseTokensPerSecond]: tokensPerSecond,
-				"gen_ai.agent.cumulative.input_tokens": cumInputTokens,
-				"gen_ai.agent.cumulative.output_tokens": ctx.cumulativeUsage.output,
-				"gen_ai.agent.cumulative.total_tokens": cumInputTokens + ctx.cumulativeUsage.output,
-				"gen_ai.agent.cumulative.cache_read_input_tokens": ctx.cumulativeUsage.cacheRead,
-				"gen_ai.agent.cumulative.cache_creation_input_tokens": ctx.cumulativeUsage.cacheCreation,
-				"gen_ai.agent.cumulative.cost_usd": ctx.cumulativeUsage.cost,
-				"gen_ai.agent.cumulative.turns": ctx.cumulativeUsage.turns,
-				...legacy ? {
-					inputTokens: ctx.usage.input,
-					outputTokens: ctx.usage.output,
-					finishReason: ctx.usage.finishReason,
-					modelId: ctx.usage.modelId
-				} : {}
-			};
-			if (captureContent && ctx.message && ctx.message.role !== "system" && ctx.message.role !== "command") {
-				const outputMsgs = stringifyMessages([{
-					role: ctx.message.role,
-					content: ctx.message.content
-				}]);
-				if (outputMsgs) attrs[GEN_AI.outputMessages] = redact("stream-text", outputMsgs, {
-					turnId: ctx.turnId,
-					turn: ctx.turn
-				});
-			}
-			safeSetAttrs(span, attrs);
-			safeEnd(turnSpans, ctx.turnId);
-		}));
-		unregisters.push(hooks.hook("stream:error", (ctx) => {
-			const span = turnSpans.get(ctx.turnId);
-			const message = ctx.err instanceof Error ? ctx.err.message : String(ctx.err);
-			safeSetAttrs(span, {
-				"error.type": ctx.err instanceof Error ? ctx.err.name : "unknown",
-				"error.message": message,
-				"http.response.status_code": ctx.statusCode,
-				"gen_ai.request.id": ctx.requestId
-			});
-			safeAddEvent(span, "gen_ai.stream.error", {
-				"error.type": ctx.err instanceof Error ? ctx.err.name : "unknown",
-				"error.message": message,
-				"http.response.status_code": ctx.statusCode,
-				"gen_ai.request.id": ctx.requestId
-			});
-		}));
-		unregisters.push(hooks.hook("tool:before", (ctx) => {
-			const span = safeStartSpan(`execute_tool ${ctx.displayName}`, {
-				[GEN_AI.operationName]: "execute_tool",
-				[GEN_AI.system]: activeSystem,
-				[GEN_AI.toolName]: ctx.name,
-				[GEN_AI.toolType]: "function",
-				[GEN_AI.toolCallId]: ctx.callId,
-				"sentry.op": "gen_ai.execute_tool",
-				"gen_ai.tool.display_name": ctx.displayName,
-				"gen_ai.agent.turn_id": ctx.turnId,
-				"gen_ai.agent.depth": ctx.depth,
-				"gen_ai.agent.run.id": ctx.runId,
-				"gen_ai.agent.parent_run.id": ctx.parentRunId,
-				...legacy ? {
-					toolName: ctx.name,
-					displayName: ctx.displayName,
-					turnId: ctx.turnId,
-					callId: ctx.callId
-				} : {}
-			});
-			if (span) {
-				toolSpans.set(ctx.callId, span);
-				if (captureContent) try {
-					const redacted = redact("tool-input", JSON.stringify(ctx.input), {
-						toolName: ctx.name,
-						displayName: ctx.displayName,
-						callId: ctx.callId,
-						turnId: ctx.turnId
-					});
-					const attrs = {};
-					if (wantSentry) attrs[GEN_AI.toolCallArguments] = redacted;
-					if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolInputDeprecated] = redacted;
-					safeSetAttrs(span, attrs);
-				} catch {}
-			}
-		}));
-		unregisters.push(hooks.hook("tool:after", (ctx) => {
-			const span = toolSpans.get(ctx.callId);
-			safeSetAttrs(span, {
-				"gen_ai.tool.output_bytes": ctx.outputBytes,
-				"gen_ai.tool.coercions": ctx.coercions?.length ?? 0
-			});
-			if (captureContent && typeof ctx.result === "string") {
-				const redacted = redact("tool-result", ctx.result, {
-					toolName: ctx.name,
-					callId: ctx.callId
-				});
-				const attrs = {};
-				if (wantSentry) attrs[GEN_AI.toolCallResult] = redacted;
-				if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolOutputDeprecated] = redacted;
-				safeSetAttrs(span, attrs);
-			}
-			safeEnd(toolSpans, ctx.callId);
-		}));
-		unregisters.push(hooks.hook("tool:error", (ctx) => {
-			safeSetAttrs(toolSpans.get(ctx.callId), {
-				"error.type": ctx.error.name,
-				"error.message": ctx.error.message
-			});
-			safeEnd(toolSpans, ctx.callId);
-		}));
-		unregisters.push(hooks.hook("tool:dispatched", (ctx) => {
-			if (ctx.outcome === "gate-block") safeAddEvent(activeRunSpan, "gen_ai.gate.block", {
-				[GEN_AI.toolName]: ctx.name,
-				[GEN_AI.toolCallId]: ctx.callId,
-				reason: ctx.reason
-			});
-			else if (ctx.outcome === "gate-substitute") safeAddEvent(activeRunSpan, "gen_ai.gate.substitute", {
-				[GEN_AI.toolName]: ctx.name,
-				[GEN_AI.toolCallId]: ctx.callId
-			});
-			else if (ctx.outcome === "unknown") safeAddEvent(activeRunSpan, "gen_ai.tool.unknown", {
-				[GEN_AI.toolName]: ctx.name,
-				[GEN_AI.toolCallId]: ctx.callId
-			});
-			else if (ctx.outcome === "invalid-input") safeAddEvent(activeRunSpan, "gen_ai.tool.invalid_input", {
-				[GEN_AI.toolName]: ctx.name,
-				[GEN_AI.toolCallId]: ctx.callId
-			});
-		}));
-		unregisters.push(hooks.hook("validation:reject", (ctx) => {
-			safeAddEvent(activeRunSpan, "gen_ai.validation.reject", {
-				[GEN_AI.toolName]: ctx.name,
-				[GEN_AI.toolCallId]: ctx.callId,
-				reason: ctx.reason
-			});
-		}));
-		unregisters.push(hooks.hook("validation:coerce", (ctx) => {
-			safeAddEvent(activeRunSpan, "gen_ai.validation.coerce", {
-				[GEN_AI.toolName]: ctx.name,
-				[GEN_AI.toolCallId]: ctx.callId,
-				coercions: ctx.coercions
-			});
-		}));
-		unregisters.push(hooks.hook("budget:exceeded", (ctx) => {
-			safeAddEvent(activeRunSpan, "gen_ai.budget.exceeded", {
-				turnId: ctx.turnId,
-				bytes: ctx.bytes,
-				budget: ctx.budget
-			});
-		}));
-		unregisters.push(hooks.hook("tool-budget:exceeded", (ctx) => {
-			safeAddEvent(activeRunSpan, "gen_ai.tool_budget.exceeded", {
-				[GEN_AI.toolName]: ctx.tool,
-				turnId: ctx.turnId,
-				count: ctx.count,
-				max: ctx.max,
-				mode: ctx.mode
-			});
-		}));
-		unregisters.push(hooks.hook("pairing:repair", (ctx) => {
-			safeAddEvent(activeRunSpan, "gen_ai.pairing.repair", {
-				mode: ctx.mode,
-				callId: ctx.callId,
-				turnId: ctx.turnId
-			});
-		}));
-		unregisters.push(hooks.hook("oauth:refresh", (ctx) => {
-			safeAddEvent(activeRunSpan, "gen_ai.oauth.refresh", {
-				provider: ctx.provider,
-				providerId: ctx.providerId,
-				source: ctx.source
-			});
-		}));
-		unregisters.push(hooks.hook("mcp:tool:before", (ctx) => {
-			const span = safeStartSpan(`execute_tool ${ctx.server}.${ctx.tool}`, {
-				[GEN_AI.operationName]: "execute_tool",
-				[GEN_AI.system]: activeSystem,
-				[GEN_AI.toolName]: ctx.displayName,
-				[GEN_AI.toolType]: "extension",
-				[GEN_AI.toolCallId]: ctx.callId,
-				[GEN_AI.mcpServer]: ctx.server,
-				"sentry.op": "gen_ai.execute_tool",
-				"gen_ai.mcp.tool": ctx.tool,
-				"gen_ai.agent.turn_id": ctx.turnId,
-				"gen_ai.agent.run.id": ctx.runId,
-				...legacy ? {
-					server: ctx.server,
-					tool: ctx.tool,
-					displayName: ctx.displayName,
-					turnId: ctx.turnId,
-					callId: ctx.callId
-				} : {}
-			});
-			if (span) {
-				mcpSpans.set(ctx.callId, span);
-				if (captureContent) try {
-					const redacted = redact("mcp-tool-input", JSON.stringify(ctx.input), {
-						server: ctx.server,
-						tool: ctx.tool,
-						callId: ctx.callId
-					});
-					const attrs = {};
-					if (wantSentry) attrs[GEN_AI.toolCallArguments] = redacted;
-					if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolInputDeprecated] = redacted;
-					safeSetAttrs(span, attrs);
-				} catch {}
-			}
-		}));
-		unregisters.push(hooks.hook("mcp:tool:after", (ctx) => {
-			const span = mcpSpans.get(ctx.callId);
-			safeSetAttrs(span, { "gen_ai.tool.output_bytes": ctx.outputBytes });
-			if (captureContent && typeof ctx.result === "string") {
-				const redacted = redact("mcp-tool-result", ctx.result, {
-					server: ctx.server,
-					tool: ctx.tool,
-					callId: ctx.callId
-				});
-				const attrs = {};
-				if (wantSentry) attrs[GEN_AI.toolCallResult] = redacted;
-				if (conventions === "otel" || conventions === "both") attrs[GEN_AI.toolOutputDeprecated] = redacted;
-				safeSetAttrs(span, attrs);
-			}
-			safeEnd(mcpSpans, ctx.callId);
-		}));
-		unregisters.push(hooks.hook("mcp:tool:error", (ctx) => {
-			safeSetAttrs(mcpSpans.get(ctx.callId), {
-				"error.type": ctx.error.name,
-				"error.message": ctx.error.message
-			});
-			safeEnd(mcpSpans, ctx.callId);
-		}));
-		unregisters.push(hooks.hook("mcp:bootstrap:start", (ctx) => {
-			const span = safeStartSpan(`mcp.bootstrap ${ctx.name}`, {
-				[GEN_AI.operationName]: "mcp.bootstrap",
-				[GEN_AI.system]: activeSystem,
-				[GEN_AI.mcpServer]: ctx.name,
-				"gen_ai.mcp.transport": ctx.transport
-			});
-			if (span) bootstrapSpans.set(ctx.name, span);
-		}));
-		unregisters.push(hooks.hook("mcp:bootstrap:end", (ctx) => {
-			const span = bootstrapSpans.get(ctx.name);
-			const ok = ctx.ok;
-			safeSetAttrs(span, {
-				"gen_ai.mcp.bootstrap.duration_ms": ctx.durationMs,
-				"gen_ai.mcp.bootstrap.ok": ok,
-				...ok ? {
-					[GEN_AI.mcpToolCount]: ctx.toolCount,
-					"gen_ai.mcp.lazy": ctx.lazy,
-					"gen_ai.mcp.cached": ctx.cached
-				} : {
-					"error.type": ctx.error.name,
-					"error.message": ctx.error.message
-				}
-			});
-			safeEnd(bootstrapSpans, ctx.name);
-		}));
-		unregisters.push(hooks.hook("mcp:auth:required", (ctx) => {
-			safeAddEvent(bootstrapSpans.get(ctx.name) ?? activeRunSpan, "gen_ai.mcp.auth.required", {
-				server: ctx.name,
-				transport: ctx.transport,
-				reason: ctx.reason
-			});
-		}));
-		unregisters.push(hooks.hook("mcp:error", (ctx) => {
-			safeAddEvent(activeRunSpan, "gen_ai.mcp.error", {
-				"server": ctx.name,
-				"error.type": ctx.error.name,
-				"error.message": ctx.error.message
-			});
-		}));
-		unregisters.push(hooks.hook("spawn:before", (ctx) => {
-			const span = safeStartSpan(`handoff to ${ctx.task.length > 60 ? `${ctx.task.slice(0, 57)}…` : ctx.task}`, {
-				[GEN_AI.operationName]: "handoff",
-				[GEN_AI.system]: activeSystem,
-				"sentry.op": "gen_ai.handoff",
-				"gen_ai.agent.spawn.id": ctx.id,
-				"gen_ai.agent.spawn.task": ctx.task,
-				"gen_ai.agent.depth": ctx.depth
-			});
-			if (span) spawnSpans.set(ctx.id, span);
-			if (typeof options.getActiveTraceContext === "function" && ctx.tracingContext) {
-				let carrier;
-				try {
-					carrier = options.getActiveTraceContext();
-				} catch (err) {
-					try {
-						onError("getActiveTraceContext", err);
-					} catch {}
-				}
-				if (carrier) for (const [k, v] of Object.entries(carrier)) ctx.tracingContext[k] = v;
-			}
-		}));
-		unregisters.push(hooks.hook("spawn:complete", (ctx) => {
-			const span = spawnSpans.get(ctx.id);
-			const childUsage = buildUsageAttrs({
-				input: ctx.stats.totalIn,
-				output: ctx.stats.totalOut,
-				cacheRead: ctx.stats.totalCacheRead,
-				cacheCreation: ctx.stats.totalCacheCreation,
-				cost: ctx.stats.cost
-			}, conventions);
-			safeSetAttrs(span, {
-				"gen_ai.agent.spawn.status": ctx.status ?? "completed",
-				"gen_ai.agent.spawn.depth": ctx.depth,
-				...childUsage
-			});
-			safeEnd(spawnSpans, ctx.id);
-		}));
-		unregisters.push(hooks.hook("spawn:error", (ctx) => {
-			safeSetAttrs(spawnSpans.get(ctx.id), {
-				"error.type": ctx.error.name,
-				"error.message": ctx.error.message
-			});
-			safeEnd(spawnSpans, ctx.id);
-		}));
+		installTracingAgentHooks(hooks, unregisters, rt);
+		installTracingTurnHooks(hooks, unregisters, rt);
+		installTracingToolHooks(hooks, unregisters, rt);
+		installTracingPolicyEventHooks(hooks, unregisters, rt);
+		installTracingMcpToolHooks(hooks, unregisters, rt);
+		installTracingMcpServerHooks(hooks, unregisters, rt);
+		installTracingSpawnHooks(hooks, unregisters, rt);
 		let disposed = false;
 		return function uninstall() {
 			if (disposed) return;
@@ -2444,7 +2226,7 @@ function createTracingHooks(options) {
 			endAll(mcpSpans);
 			endAll(spawnSpans);
 			endAll(bootstrapSpans);
-			activeRunSpan = void 0;
+			rt.activeRunSpan = void 0;
 		};
 	} };
 }
@@ -2456,6 +2238,6 @@ function createTracingHooks(options) {
 */
 const GEN_AI_ATTRIBUTES = GEN_AI;
 //#endregion
-export { zodToJsonSchema as A, tokenEndingAtCursor as C, shouldAutoGenerateTitle as D, generateSessionTitle as E, parseCommandInvocation as F, localReliabilityBehavior as I, commandBlocksToContent as M, commandSteps as N, isStandardSchema as O, executeCommand as P, resolveInlineSuggestion as S, cleanTitle as T, resolveExtensionDocsDir as _, loginMcpServer as a, createPathAutocompleteProvider as b, SKILL_EDIT_METADATA_KEY as c, buildZidaneExtensionSkill as d, buildZidaneSkillEditSkill as f, readSkillEditMarker as g, extensionScaffold as h, createMetricsHooks as i, commandBlockToEvent as j, resolveSchemaInput as k, ZIDANE_EXTENSION_SKILL_NAME as l, extensionDirForCwd as m, createTracingHooks as n, startOAuthCallback as o, editSessionMetadata as p, createMutationValidationHooks as r, EXTENSION_EDIT_METADATA_KEY as s, GEN_AI_ATTRIBUTES as t, ZIDANE_SKILL_EDIT_SKILL_NAME as u, withZidaneExtensionSkill as v, generateStructuredData as w, patchInlineGhost as x, withZidaneSkillEditSkill as y };
+export { parseCommandInvocation as C, mergeCommands as S, localReliabilityBehavior as T, commandBlockToEvent as _, loginMcpServer as a, createCommandRunRecord as b, resolveInlineSuggestion as c, cleanTitle as d, generateSessionTitle as f, zodToJsonSchema as g, resolveSchemaInput as h, createMetricsHooks as i, tokenEndingAtCursor as l, isStandardSchema as m, createTracingHooks as n, startOAuthCallback as o, shouldAutoGenerateTitle as p, createMutationValidationHooks as r, createPathAutocompleteProvider as s, GEN_AI_ATTRIBUTES as t, generateStructuredData as u, commandBlocksToContent as v, routesToDaemon as w, executeCommand as x, commandSteps as y };
 
-//# sourceMappingURL=src-CkNQKFKr.js.map
+//# sourceMappingURL=src-BRMYRJib.js.map