@caplets/core 0.26.1 → 0.28.0

package/dist/{service-aBIn4nrw.js → service-BfPCRxQ9.js}

@@ -1,53 +1,20 @@
+import { i as __require, o as __toESM, t as __commonJSMin } from "./rolldown-runtime-CE-6LUnI.js";
 import { A as safeParseAsync$1, C as toJSONSchema, D as parse$3, E as $ZodType, F as NEVER, M as defineLazy, N as normalizeParams, O as parseAsync, P as $constructor, S as datetime, T as $ZodObject, _ as record, a as any, b as unknown, c as custom, d as literal, f as looseObject, g as preprocess, h as optional, i as _null, j as clone, k as safeParse$1, l as discriminatedUnion, m as object$1, o as array, p as number$1, r as _enum, s as boolean, t as ZodNumber$1, u as intersection, v as string, w as _coercedNumber, x as url, y as union } from "./schemas-BoqMu4MG.js";
-import { a as isAllowedHttpBaseUrl, c as validateHttpActionHeaders, d as errorResult, f as redactSecrets, i as SERVER_ID_PATTERN, n as HEADER_NAME_PATTERN, o as isAllowedRemoteUrl, p as toSafeError, r as HTTP_BASE_URL_PATTERN, s as isUrl, t as FORBIDDEN_HEADERS, u as CapletsError } from "./validation-GD2x5HW1.js";
+import { a as SERVER_ID_PATTERN, c as isUrl, d as CapletsError, f as errorResult, i as NAMESPACE_ALIAS_LABEL_PATTERN, l as validateHttpActionHeaders, m as toSafeError, n as HEADER_NAME_PATTERN, o as isAllowedHttpBaseUrl, p as redactSecrets, r as HTTP_BASE_URL_PATTERN, s as isAllowedRemoteUrl, t as FORBIDDEN_HEADERS } from "./validation-CWzd2gtn.js";
 import { generatedToolInputJsonSchema, generatedToolInputJsonSchemaForCaplet, generatedToolInputSchemaForCaplet, mcpOperations, operations } from "./generated-tool-input-schema.js";
-import { f as observedOutputShapeKey, i as observeOutputShape, r as normalizedObservableValue, t as usefulOutputSchema, u as FileObservedOutputShapeStore } from "./observed-output-shapes-DuP7mJQf.js";
-import { createRequire } from "node:module";
-import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
+import { f as observedOutputShapeKey, g as stableJsonStringify, h as schemaHash, i as observeOutputShape, r as normalizedObservableValue, t as usefulOutputSchema, u as FileObservedOutputShapeStore } from "./observed-output-shapes-DuP7mJQf.js";
+import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, extname, isAbsolute, join, parse, posix, relative, resolve, sep, win32 } from "node:path";
 import { spawn } from "node:child_process";
 import process$1 from "node:process";
 import { PassThrough } from "node:stream";
 import { createServer } from "node:http";
 import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
-import { homedir } from "node:os";
+import { arch, homedir, platform } from "node:os";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { readFile } from "node:fs/promises";
 import ts from "typescript";
 import { getQuickJS, shouldInterruptAfterDeadline } from "quickjs-emscripten";
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
-//#endregion
 //#region ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v3/helpers/util.js
 var util$1;
 (function(util) {
@@ -17242,6 +17209,18 @@ function defaultConfigPath(env = process.env, home = homedir(), platform = proce
 function defaultAuthDir(env = process.env, home = homedir(), platform = process.platform) {
 	return (platform === "win32" ? win32.join : posix.join)(defaultStateBaseDir(env, home, platform), "caplets", "auth");
 }
+function defaultTelemetryStateDir(env = process.env, home = homedir(), platform = process.platform) {
+	return (platform === "win32" ? win32.join : posix.join)(defaultStateBaseDir(env, home, platform), "caplets", "telemetry");
+}
+function defaultTelemetryIdentityPath(env = process.env, home = homedir(), platform = process.platform) {
+	return (platform === "win32" ? win32.join : posix.join)(defaultTelemetryStateDir(env, home, platform), "identity.json");
+}
+function defaultTelemetryNoticePath(env = process.env, home = homedir(), platform = process.platform) {
+	return (platform === "win32" ? win32.join : posix.join)(defaultTelemetryStateDir(env, home, platform), "notice.json");
+}
+function defaultTelemetryDeliveryHealthPath(env = process.env, home = homedir(), platform = process.platform) {
+	return (platform === "win32" ? win32.join : posix.join)(defaultTelemetryStateDir(env, home, platform), "delivery-health.json");
+}
 function defaultArtifactDir(env = process.env, home = homedir(), platform = process.platform) {
 	return (platform === "win32" ? win32.join : posix.join)(defaultStateBaseDir(env, home, platform), "caplets", "artifacts");
 }
@@ -17256,6 +17235,10 @@ function defaultObservedOutputShapeCacheDir(env = process.env, home = homedir(),
 const DEFAULT_CONFIG_PATH = defaultConfigPath();
 const DEFAULT_AUTH_DIR = defaultAuthDir();
 const DEFAULT_ARTIFACT_DIR = defaultArtifactDir();
+const DEFAULT_TELEMETRY_STATE_DIR = defaultTelemetryStateDir();
+defaultTelemetryIdentityPath();
+defaultTelemetryNoticePath();
+defaultTelemetryDeliveryHealthPath();
 const DEFAULT_COMPLETION_CACHE_DIR = defaultCompletionCacheDir();
 const DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR = defaultObservedOutputShapeCacheDir();
 const PROJECT_CONFIG_FILE = join(".caplets", "config.json");
@@ -18627,8 +18610,8 @@ function compactToolSafetyHints(tool) {
 	};
 }
 function compactToolSchemaHints(tool) {
-	const schema = isRecord$7(tool.inputSchema) ? tool.inputSchema : void 0;
-	const properties = isRecord$7(schema?.properties) ? schema.properties : {};
+	const schema = isRecord$9(tool.inputSchema) ? tool.inputSchema : void 0;
+	const properties = isRecord$9(schema?.properties) ? schema.properties : {};
 	const acceptedArgs = Object.keys(properties).sort();
 	const requiredArgs = Array.isArray(schema?.required) ? schema.required.filter((value) => typeof value === "string").sort() : [];
 	const argsTemplate = compactArgsTemplate(properties, requiredArgs, acceptedArgs);
@@ -18652,7 +18635,7 @@ function compactArgsTemplate(properties, requiredArgs, acceptedArgs) {
 	if (templateArgs.length === 0 || templateArgs.length > 4) return void 0;
 	if (requiredArgs.length === 0 && acceptedArgs.length > 3) return void 0;
 	const entries = templateArgs.flatMap((name) => {
-		const value = placeholderForSchema(isRecord$7(properties[name]) ? properties[name] : void 0);
+		const value = placeholderForSchema(isRecord$9(properties[name]) ? properties[name] : void 0);
 		return value === void 0 ? [] : [[name, value]];
 	});
 	return entries.length === templateArgs.length ? Object.fromEntries(entries) : void 0;
@@ -18672,13 +18655,13 @@ function placeholderForSchema(schema) {
 	}
 }
 function compactToolSelectionHints(tool) {
-	if (!isRecord$7(tool)) return {};
+	if (!isRecord$9(tool)) return {};
 	return {
 		...typeof tool.useWhen === "string" && tool.useWhen.trim() ? { useWhen: tool.useWhen.trim() } : {},
 		...typeof tool.avoidWhen === "string" && tool.avoidWhen.trim() ? { avoidWhen: tool.avoidWhen.trim() } : {}
 	};
 }
-function isRecord$7(value) {
+function isRecord$9(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function sameServerConfig(left, right) {
@@ -18753,7 +18736,7 @@ function markdownCallToolResultContent(result, context = {}) {
 	return textContent(renderStructuredMarkdown(result, context));
 }
 function hasRenderableStructuredContent(value) {
-	if (!isRecord$6(value)) return false;
+	if (!isRecord$8(value)) return false;
 	return Object.keys(value).some((key) => key !== "caplets" && key !== "elapsedMs");
 }
 function renderStructuredMarkdown(value, context) {
@@ -18887,13 +18870,13 @@ function renderErrorMarkdown(value, title) {
 	].join("\n");
 }
 function isDiscoveryWrapper(value) {
-	return isRecord$6(value) && "result" in value;
+	return isRecord$8(value) && "result" in value;
 }
 function isErrorStructuredContent(value) {
-	return isRecord$6(value) && "error" in value;
+	return isRecord$8(value) && "error" in value;
 }
 function isHttpLikeResult(value) {
-	return isRecord$6(value) && ("status" in value || "statusText" in value || "body" in value);
+	return isRecord$8(value) && ("status" in value || "statusText" in value || "body" in value);
 }
 function isGraphQlHttpResult(value) {
 	if (!isHttpLikeResult(value)) return false;
@@ -18901,7 +18884,7 @@ function isGraphQlHttpResult(value) {
 	return Boolean(body && ("data" in body || "errors" in body));
 }
 function isCliResult(value) {
-	return isRecord$6(value) && ("exitCode" in value || "stdout" in value || "stderr" in value);
+	return isRecord$8(value) && ("exitCode" in value || "stdout" in value || "stderr" in value);
 }
 function renderBodyValue(value) {
 	if (value === void 0) return "_No response body._";
@@ -18969,8 +18952,8 @@ function compactListHints(record) {
 	const acceptedArgs = stringArrayValue(record.acceptedArgs);
 	if (requiredArgs.length > 0) hints.push(`required args: ${requiredArgs.join(", ")}`);
 	else if (acceptedArgs.length > 0) hints.push(`args: ${acceptedArgs.join(", ")}`);
-	if (isRecord$6(record.argsTemplate)) hints.push(`args template: ${compactJsonText(record.argsTemplate, 160)}`);
-	if (isRecord$6(record.callTemplate)) hints.push(`call: ${compactJsonText(record.callTemplate, 220)}`);
+	if (isRecord$8(record.argsTemplate)) hints.push(`args template: ${compactJsonText(record.argsTemplate, 160)}`);
+	if (isRecord$8(record.callTemplate)) hints.push(`call: ${compactJsonText(record.callTemplate, 220)}`);
 	if (record.supportsFields === true) hints.push("supports fields");
 	if (record.readOnlyHint === true) hints.push("read-only");
 	if (record.destructiveHint === true) hints.push("destructive");
@@ -19040,9 +19023,9 @@ function humanizeKey(key) {
 	return key.replace(/([A-Z])/gu, " $1").replace(/^./u, (char) => char.toUpperCase());
 }
 function asRecord$3(value) {
-	return isRecord$6(value) ? value : void 0;
+	return isRecord$8(value) ? value : void 0;
 }
-function isRecord$6(value) {
+function isRecord$8(value) {
 	return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 //#endregion
@@ -26005,7 +25988,11 @@ const capletExposureSchema = _enum([
 	"direct_and_code_mode",
 	"progressive_and_code_mode"
 ]).describe("How this Caplet is exposed to agents.");
-const capletShadowingSchema = _enum(["forbid", "allow"]).describe("Whether attached local Caplets may shadow this remote Caplet ID.");
+const capletShadowingSchema = _enum([
+	"forbid",
+	"allow",
+	"namespace"
+]).describe("Whether attached local Caplets may shadow this remote Caplet ID.");
 const capletEndpointAuthSchema = discriminatedUnion("type", [
 	object$1({ type: literal("none") }).strict(),
 	object$1({
@@ -27288,7 +27275,33 @@ const exposureSchema = _enum([
 	"direct_and_code_mode",
 	"progressive_and_code_mode"
 ]).describe("How this Caplet is exposed to agents.");
-const shadowingSchema = _enum(["forbid", "allow"]).default("forbid").describe("Whether attached local Caplets may shadow this remote Caplet ID.");
+const shadowingSchema = _enum([
+	"forbid",
+	"allow",
+	"namespace"
+]).default("forbid").describe("Whether attached local Caplets may shadow this remote Caplet ID.");
+const namespaceAliasLabelSchema = string().regex(NAMESPACE_ALIAS_LABEL_PATTERN, "namespace alias labels must be lowercase DNS-style labels using letters, numbers, or hyphens").describe("Namespace label used when qualifying colliding Caplet IDs.");
+const namespaceAliasesSchema = object$1({
+	local: namespaceAliasLabelSchema.optional(),
+	upstreams: record(string().trim().min(1), namespaceAliasLabelSchema).default({}).describe("Namespace aliases keyed by durable upstream source identity.")
+}).strict().default({ upstreams: {} }).superRefine((aliases, ctx) => {
+	const seen = /* @__PURE__ */ new Map();
+	const addAlias = (value, path) => {
+		if (!value) return;
+		const existing = seen.get(value);
+		if (existing) {
+			ctx.addIssue({
+				code: "custom",
+				path,
+				message: `namespace alias '${value}' is already used at ${existing.join(".")}`
+			});
+			return;
+		}
+		seen.set(value, path);
+	};
+	addAlias(aliases.local, ["local"]);
+	for (const [selector, alias] of Object.entries(aliases.upstreams)) addAlias(alias, ["upstreams", selector]);
+}).describe("Source-level namespace aliases for hash-qualified Caplet IDs.");
 const publicServerSchema = object$1({
 	name: string().trim().min(1).max(80).describe("Human-readable server display name."),
 	description: string().describe("Capability description shown to agents before downstream tools are disclosed.").refine((value) => value.trim().length >= 10, "description must contain at least 10 non-whitespace characters").refine((value) => value.length <= 1500, "description must be at most 1500 characters"),
@@ -27525,6 +27538,7 @@ function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, googleDi
 		version: literal(1).default(1).describe("Caplets config schema version."),
 		defaultSearchLimit: number$1().int().positive().default(20).describe("Default maximum number of same-server search results."),
 		maxSearchLimit: number$1().int().positive().max(50).default(50).describe("Maximum accepted search_tools limit."),
+		telemetry: boolean().optional().describe("Set false to disable anonymous Caplets telemetry for this user config."),
 		completion: object$1({
 			discoveryTimeoutMs: number$1().int().positive().default(750),
 			overallTimeoutMs: number$1().int().positive().default(1500),
@@ -27545,6 +27559,7 @@ function configSchemaFor(serverValueSchema, openApiEndpointValueSchema, googleDi
 			exposureDiscoveryTimeoutMs: 15e3,
 			exposureDiscoveryConcurrency: 4
 		}).describe("Global Caplets runtime options."),
+		namespaceAliases: namespaceAliasesSchema,
 		mcpServers: record(string().regex(SERVER_ID_PATTERN), serverValueSchema).default({}).describe("Downstream MCP servers keyed by stable server ID."),
 		openapiEndpoints: record(string().regex(SERVER_ID_PATTERN), openApiEndpointValueSchema).default({}).describe("OpenAPI endpoints keyed by stable Caplet ID."),
 		googleDiscoveryApis: record(string().regex(SERVER_ID_PATTERN), googleDiscoveryApiValueSchema).default({}).describe("Google Discovery APIs keyed by stable Caplet ID."),
@@ -28321,6 +28336,8 @@ function mergeConfigInputs(...inputs) {
 		merged = {
 			...merged,
 			...input,
+			telemetry: input.telemetry === void 0 ? merged?.telemetry : input.telemetry,
+			namespaceAliases: mergeNamespaceAliases(merged?.namespaceAliases, input.namespaceAliases),
 			mcpServers: {
 				...merged?.mcpServers,
 				...input.mcpServers
@@ -28353,19 +28370,37 @@ function mergeConfigInputs(...inputs) {
 	}
 	return merged;
 }
+function mergeNamespaceAliases(left, right) {
+	if (right !== void 0 && !isPlainObject$5(right)) return right;
+	if (left !== void 0 && !isPlainObject$5(left)) return left;
+	if (!isPlainObject$5(left) && !isPlainObject$5(right)) return;
+	const leftRecord = isPlainObject$5(left) ? left : void 0;
+	const rightRecord = isPlainObject$5(right) ? right : void 0;
+	const leftUpstreams = isPlainObject$5(leftRecord?.upstreams) ? leftRecord.upstreams : void 0;
+	const rightUpstreams = isPlainObject$5(rightRecord?.upstreams) ? rightRecord.upstreams : void 0;
+	return stripUndefined({
+		...leftRecord,
+		...rightRecord,
+		upstreams: {
+			...leftUpstreams,
+			...rightUpstreams
+		}
+	});
+}
 function mergeConfigInputsWithSources(...inputs) {
 	let merged = {};
 	const sources = {};
 	const shadows = {};
 	for (const entry of inputs) {
 		if (entry?.input === void 0) continue;
-		for (const id of capletIds(entry.input)) {
+		const entryInput = entry.source.kind === "global-config" ? entry.input : stripUserOnlyConfig(entry.input);
+		for (const id of capletIds(entryInput)) {
 			const source = sourceForId(entry.source, id);
 			if (sources[id]) shadows[id] = [...shadows[id] ?? [], sources[id]];
 			sources[id] = source;
 			merged = removeCapletId(merged, id);
 		}
-		merged = mergeConfigInputs(merged, entry.input) ?? {};
+		merged = mergeConfigInputs(merged, entryInput) ?? {};
 	}
 	return {
 		input: merged,
@@ -28373,6 +28408,10 @@ function mergeConfigInputsWithSources(...inputs) {
 		shadows
 	};
 }
+function stripUserOnlyConfig(input) {
+	const { telemetry: _telemetry, ...rest } = input;
+	return rest;
+}
 function removeCapletBackendId(input, backend, id) {
 	const caplets = input[backend];
 	if (!isPlainObject$5(caplets)) return input;
@@ -28469,6 +28508,7 @@ function parseConfig(input, options = {}) {
 	});
 	return {
 		version: parsed.data.version,
+		telemetry: parsed.data.telemetry,
 		options: {
 			defaultSearchLimit: parsed.data.defaultSearchLimit,
 			maxSearchLimit: parsed.data.maxSearchLimit,
@@ -28477,6 +28517,10 @@ function parseConfig(input, options = {}) {
 			exposureDiscoveryConcurrency: parsed.data.options.exposureDiscoveryConcurrency,
 			completion: parsed.data.completion
 		},
+		namespaceAliases: stripUndefined({
+			local: parsed.data.namespaceAliases.local,
+			upstreams: parsed.data.namespaceAliases.upstreams
+		}),
 		mcpServers: servers,
 		openapiEndpoints,
 		googleDiscoveryApis,
@@ -28609,17 +28653,17 @@ function googleDiscoveryScopesForOperations(operations) {
 	return [...new Set(operations.flatMap((operation) => operation.scopes))].sort();
 }
 function validateGoogleDiscoveryDocument(value) {
-	if (!isRecord$5(value)) throw new Error("Invalid Google Discovery document: expected an object");
+	if (!isRecord$7(value)) throw new Error("Invalid Google Discovery document: expected an object");
 	if (value.kind !== void 0 && value.kind !== "discovery#restDescription") throw new Error("Invalid Google Discovery document: expected kind discovery#restDescription");
-	if (value.resources !== void 0 && !isRecord$5(value.resources)) throw new Error("Invalid Google Discovery document: expected resources object");
-	if (value.methods !== void 0 && !isRecord$5(value.methods)) throw new Error("Invalid Google Discovery document: expected methods object");
-	if (!isRecord$5(value.resources) && !isRecord$5(value.methods)) throw new Error("Invalid Google Discovery document: expected resources or methods object");
-	if (value.schemas !== void 0 && !isRecord$5(value.schemas)) throw new Error("Invalid Google Discovery document: expected schemas object");
-	if (value.parameters !== void 0 && !isRecord$5(value.parameters)) throw new Error("Invalid Google Discovery document: expected parameters object");
+	if (value.resources !== void 0 && !isRecord$7(value.resources)) throw new Error("Invalid Google Discovery document: expected resources object");
+	if (value.methods !== void 0 && !isRecord$7(value.methods)) throw new Error("Invalid Google Discovery document: expected methods object");
+	if (!isRecord$7(value.resources) && !isRecord$7(value.methods)) throw new Error("Invalid Google Discovery document: expected resources or methods object");
+	if (value.schemas !== void 0 && !isRecord$7(value.schemas)) throw new Error("Invalid Google Discovery document: expected schemas object");
+	if (value.parameters !== void 0 && !isRecord$7(value.parameters)) throw new Error("Invalid Google Discovery document: expected parameters object");
 	return value;
 }
 function collectDocumentMethods(document) {
-	return [...Object.entries(document.methods ?? {}).filter((entry) => isRecord$5(entry[1])).map(([methodKey, method]) => ({
+	return [...Object.entries(document.methods ?? {}).filter((entry) => isRecord$7(entry[1])).map(([methodKey, method]) => ({
 		resourcePath: [],
 		methodKey,
 		method
@@ -28628,9 +28672,9 @@ function collectDocumentMethods(document) {
 function collectMethods(resources, resourcePath = []) {
 	const entries = [];
 	for (const [resourceName, resource] of Object.entries(resources)) {
-		if (!isRecord$5(resource)) continue;
+		if (!isRecord$7(resource)) continue;
 		const nextPath = [...resourcePath, resourceName];
-		for (const [methodKey, method] of Object.entries(resource.methods ?? {})) if (isRecord$5(method)) entries.push({
+		for (const [methodKey, method] of Object.entries(resource.methods ?? {})) if (isRecord$7(method)) entries.push({
 			resourcePath: nextPath,
 			methodKey,
 			method
@@ -28803,7 +28847,7 @@ function globMatches(pattern, name) {
 function isJsonSchemaObject(value) {
 	return value.type === "object" || "properties" in value || "additionalProperties" in value;
 }
-function isRecord$5(value) {
+function isRecord$7(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function collapseWhitespace(value) {
@@ -63892,6 +63936,746 @@ async function withTimeout(promise, timeoutMs) {
 	}
 }
 //#endregion
+//#region src/telemetry/state.ts
+function telemetryStateDir(options = {}) {
+	return options.stateDir ?? DEFAULT_TELEMETRY_STATE_DIR;
+}
+function telemetryIdentityPath(options = {}) {
+	return join(telemetryStateDir(options), "identity.json");
+}
+function telemetryNoticePath(options = {}) {
+	return join(telemetryStateDir(options), "notice.json");
+}
+function telemetryDeliveryHealthPath(options = {}) {
+	return join(telemetryStateDir(options), "delivery-health.json");
+}
+function readTelemetryIdentity(options = {}) {
+	const path = telemetryIdentityPath(options);
+	const existing = readJson(path);
+	if (typeof existing?.id === "string" && /^anon_[a-f0-9]{32}$/u.test(existing.id)) return {
+		kind: "stable",
+		id: existing.id
+	};
+	if (!options.create) return {
+		kind: "ephemeral",
+		id: ephemeralId(),
+		reason: "state-unavailable"
+	};
+	const identity = {
+		id: stableId(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (!writePrivateJson(path, identity)) return {
+		kind: "ephemeral",
+		id: ephemeralId(),
+		reason: "state-unavailable"
+	};
+	return {
+		kind: "stable",
+		id: identity.id
+	};
+}
+function rotateTelemetryIdentity(options = {}) {
+	const identity = {
+		id: stableId(),
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (!writePrivateJson(telemetryIdentityPath(options), identity)) return {
+		kind: "ephemeral",
+		id: ephemeralId(),
+		reason: "state-unavailable"
+	};
+	return {
+		kind: "stable",
+		id: identity.id
+	};
+}
+function deleteTelemetryIdentity(options = {}) {
+	try {
+		rmSync(telemetryIdentityPath(options), { force: true });
+	} catch {}
+}
+function readTelemetryNotice(options = {}) {
+	const existing = readJson(telemetryNoticePath(options));
+	if (existing?.shown === true && typeof existing.shownAt === "string" && isTelemetrySurface(existing.surface)) return {
+		shown: true,
+		shownAt: existing.shownAt,
+		surface: existing.surface
+	};
+	return { shown: false };
+}
+function recordTelemetryNoticeShown(options) {
+	const notice = {
+		shown: true,
+		shownAt: (/* @__PURE__ */ new Date()).toISOString(),
+		surface: options.surface
+	};
+	writePrivateJson(telemetryNoticePath(options), notice);
+	return notice;
+}
+function readTelemetryDeliveryHealth(options = {}) {
+	const existing = readJson(telemetryDeliveryHealthPath(options));
+	if (!isDeliveryHealth(existing)) return {};
+	return existing;
+}
+function recordTelemetryDrop(options) {
+	const health = readTelemetryDeliveryHealth(options);
+	health[options.provider] = health[options.provider] ?? {};
+	health[options.provider][options.reason] = (health[options.provider][options.reason] ?? 0) + 1;
+	writePrivateJson(telemetryDeliveryHealthPath(options), health);
+}
+function writePrivateJson(path, value) {
+	try {
+		mkdirSync(dirname(path), {
+			recursive: true,
+			mode: 448
+		});
+		const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+		renameSync(tmp, path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function readJson(path) {
+	if (!existsSync(path)) return void 0;
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+function stableId() {
+	return `anon_${randomBytes(16).toString("hex")}`;
+}
+function ephemeralId() {
+	return `ephemeral_${randomBytes(16).toString("hex")}`;
+}
+function isTelemetrySurface(value) {
+	return value === "cli" || value === "serve" || value === "attach" || value === "daemon" || value === "native" || value === "code_mode";
+}
+function isDeliveryHealth(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	for (const provider of Object.values(value)) {
+		if (!provider || typeof provider !== "object" || Array.isArray(provider)) return false;
+		for (const count of Object.values(provider)) if (typeof count !== "number" || !Number.isInteger(count) || count < 0) return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/telemetry/context.ts
+function resolveTelemetryState(options) {
+	const env = options.env ?? process.env;
+	const executionContext = classifyExecutionContext(env);
+	const notice = readTelemetryNotice(options);
+	const base = {
+		surface: options.surface,
+		visibility: options.visibility,
+		executionContext,
+		notice,
+		stateDir: options.stateDir
+	};
+	if (options.debug) return {
+		...base,
+		status: "debug",
+		decider: "debug"
+	};
+	if (env.CAPLETS_DISABLE_TELEMETRY === "1") return {
+		...base,
+		status: "disabled",
+		decider: "env"
+	};
+	if (options.config?.telemetry === false) return {
+		...base,
+		status: "disabled",
+		decider: "config"
+	};
+	if (isTestEnv(env)) return {
+		...base,
+		status: "disabled",
+		decider: "test"
+	};
+	if (executionContext !== "ci" && !notice.shown && !options.allowWithoutNotice) return {
+		...base,
+		status: "suppressed",
+		decider: "notice"
+	};
+	return {
+		...base,
+		status: "enabled",
+		decider: "default",
+		identity: readTelemetryIdentity({
+			...options,
+			create: options.createIdentity !== false
+		})
+	};
+}
+function classifyExecutionContext(env = process.env) {
+	if (env.CI === "true" || env.GITHUB_ACTIONS === "true" || env.BUILDKITE === "true") return "ci";
+	return process.stdout.isTTY || process.stderr.isTTY ? "interactive" : "noninteractive";
+}
+function isTestEnv(env) {
+	return env.NODE_ENV === "test" || env.VITEST === "true" || env.VITEST_WORKER_ID !== void 0 || env.CAPLETS_TEST === "1";
+}
+//#endregion
+//#region src/telemetry/notice.ts
+const TELEMETRY_NOTICE = "Caplets collects anonymous telemetry for product usage and reliability. Disable it with CAPLETS_DISABLE_TELEMETRY=1 or `caplets telemetry disable`.\n";
+function maybePrintTelemetryNotice(options) {
+	if (!options.stderrIsTTY) return false;
+	if (readTelemetryNotice(options).shown) return false;
+	options.writeErr(TELEMETRY_NOTICE);
+	recordTelemetryNoticeShown({
+		...options,
+		surface: options.surface
+	});
+	return true;
+}
+//#endregion
+//#region src/telemetry/privacy.ts
+const ALLOWED_PROPERTY_KEYS = /* @__PURE__ */ new Set([
+	"$process_person_profile",
+	"$geoip_disable",
+	"package",
+	"version",
+	"surface",
+	"runtime_mode",
+	"execution_context",
+	"command_family",
+	"operation_family",
+	"outcome",
+	"duration_bucket",
+	"timeout_bucket",
+	"integration",
+	"exposure_mode",
+	"backend_mcp_count",
+	"backend_openapi_count",
+	"backend_google_discovery_count",
+	"backend_graphql_count",
+	"backend_http_count",
+	"backend_cli_count",
+	"backend_caplets_count",
+	"direct_count",
+	"progressive_count",
+	"code_mode_count",
+	"session_category",
+	"any_caplet_invoked",
+	"provider",
+	"reason",
+	"count_bucket",
+	"error_code",
+	"diagnostic_category",
+	"os_family",
+	"arch",
+	"node_major"
+]);
+const SAFE_STRING = /^[a-zA-Z0-9@._:-]{1,80}$/u;
+const SAFE_PACKAGE = /^@?[a-zA-Z0-9._-]+(?:\/[a-zA-Z0-9._-]+)?$/u;
+const SUSPICIOUS_VALUE = [
+	/^\/|^[A-Za-z]:\\/u,
+	/^https?:\/\//iu,
+	/[a-z0-9-]+\.[a-z]{2,}/iu,
+	/(?:^|[_.-])token(?:$|[_.=-])/iu,
+	/(?:^|[_.-])secret(?:$|[_.=-])/iu,
+	/(?:^|[_.-])key(?:$|[_.=-])/iu,
+	/^sk-[a-z0-9]/iu,
+	/^gh[pousr]_[a-z0-9]/iu,
+	/^[A-Z_]{3,}=.+/u
+];
+const COMMAND_FAMILIES = /* @__PURE__ */ new Set([
+	"init",
+	"setup",
+	"add",
+	"install",
+	"auth",
+	"remote",
+	"doctor",
+	"serve",
+	"attach",
+	"daemon",
+	"inspect",
+	"check",
+	"tools",
+	"resources",
+	"prompts",
+	"complete",
+	"code_mode",
+	"native",
+	"telemetry",
+	"unknown"
+]);
+const STRING_VALUE_ALLOWLISTS = {
+	surface: /* @__PURE__ */ new Set([
+		"cli",
+		"serve",
+		"attach",
+		"daemon",
+		"native",
+		"code_mode"
+	]),
+	runtime_mode: /* @__PURE__ */ new Set([
+		"local",
+		"remote",
+		"cloud",
+		"unknown"
+	]),
+	execution_context: /* @__PURE__ */ new Set([
+		"interactive",
+		"noninteractive",
+		"ci"
+	]),
+	command_family: COMMAND_FAMILIES,
+	operation_family: COMMAND_FAMILIES,
+	outcome: /* @__PURE__ */ new Set([
+		"success",
+		"failure",
+		"cancelled",
+		"timeout",
+		"suppressed"
+	]),
+	duration_bucket: /* @__PURE__ */ new Set([
+		"lt_100ms",
+		"lt_1s",
+		"lt_5s",
+		"lt_30s",
+		"gte_30s"
+	]),
+	timeout_bucket: /* @__PURE__ */ new Set([
+		"none",
+		"lt_1s",
+		"lt_10s",
+		"lt_60s",
+		"gte_60s"
+	]),
+	integration: /* @__PURE__ */ new Set([
+		"opencode",
+		"pi",
+		"native",
+		"unknown"
+	]),
+	exposure_mode: /* @__PURE__ */ new Set([
+		"direct",
+		"progressive",
+		"code_mode",
+		"mixed",
+		"unknown"
+	]),
+	session_category: /* @__PURE__ */ new Set([
+		"created",
+		"reused",
+		"none",
+		"unknown"
+	]),
+	provider: /* @__PURE__ */ new Set(["posthog", "sentry"]),
+	reason: /* @__PURE__ */ new Set(["not_configured", "send_failed"]),
+	diagnostic_category: /* @__PURE__ */ new Set([
+		"config",
+		"auth",
+		"network",
+		"runtime",
+		"validation",
+		"code_mode",
+		"provider",
+		"unknown"
+	])
+};
+function assertTelemetrySafeProperties(properties) {
+	for (const [key, value] of Object.entries(properties)) {
+		if (!ALLOWED_PROPERTY_KEYS.has(key)) throw new Error(`unknown telemetry property: ${key}`);
+		if (typeof value === "string") {
+			const valueAllowlist = STRING_VALUE_ALLOWLISTS[key];
+			if (valueAllowlist && !valueAllowlist.has(value)) throw new Error(`unsafe telemetry property ${key}`);
+			if (key === "error_code" && !/^[A-Z_]{2,80}$/u.test(value)) throw new Error(`unsafe telemetry property ${key}`);
+			if (!(key === "package" ? SAFE_PACKAGE.test(value) : SAFE_STRING.test(value)) || key !== "package" && key !== "version" && SUSPICIOUS_VALUE.some((pattern) => pattern.test(value))) throw new Error(`unsafe telemetry property ${key}`);
+			continue;
+		}
+		if (typeof value === "number") {
+			if (!Number.isFinite(value) || value < 0 || !Number.isInteger(value)) throw new Error(`unsafe telemetry property ${key}`);
+			continue;
+		}
+		if (typeof value === "boolean") continue;
+		throw new Error(`unsafe telemetry property ${key}`);
+	}
+}
+function stripSentryEvent(event) {
+	const stripped = {};
+	if (event.tags && typeof event.tags === "object" && !Array.isArray(event.tags)) stripped.tags = event.tags;
+	if (Array.isArray(event.fingerprint)) stripped.fingerprint = event.fingerprint;
+	if (event.level) stripped.level = event.level;
+	return stripped;
+}
+//#endregion
+//#region src/telemetry/events.ts
+const PRODUCT_EVENTS = /* @__PURE__ */ new Set([
+	"caplets_cli_command",
+	"caplets_tool_activation",
+	"caplets_code_mode_outcome"
+]);
+const RELIABILITY_EVENTS = /* @__PURE__ */ new Set(["caplets_reliability_error"]);
+function buildProductTelemetryEvent(input) {
+	if (!PRODUCT_EVENTS.has(input.name)) throw new Error(`unknown telemetry event: ${input.name}`);
+	assertTelemetrySafeProperties(input.properties);
+	return {
+		provider: "posthog",
+		name: input.name,
+		distinctId: input.distinctId,
+		properties: {
+			...input.properties,
+			$process_person_profile: false
+		}
+	};
+}
+function buildReliabilityTelemetryEvent(input) {
+	if (!RELIABILITY_EVENTS.has(input.name)) throw new Error(`unknown telemetry event: ${input.name}`);
+	assertTelemetrySafeProperties(input.properties);
+	const tags = tagsFor(input.properties);
+	return {
+		provider: "sentry",
+		name: input.name,
+		tags,
+		fingerprint: [
+			tags.package ?? "unknown",
+			tags.surface ?? "unknown",
+			tags.command_family ?? "unknown",
+			tags.runtime_mode ?? "unknown",
+			tags.error_code ?? "unknown",
+			tags.diagnostic_category ?? "unknown"
+		]
+	};
+}
+function durationBucket(ms) {
+	if (ms < 100) return "lt_100ms";
+	if (ms < 1e3) return "lt_1s";
+	if (ms < 5e3) return "lt_5s";
+	if (ms < 3e4) return "lt_30s";
+	return "gte_30s";
+}
+function timeoutBucket(ms) {
+	if (ms === void 0) return "none";
+	if (ms < 1e3) return "lt_1s";
+	if (ms < 1e4) return "lt_10s";
+	if (ms < 6e4) return "lt_60s";
+	return "gte_60s";
+}
+function tagsFor(properties) {
+	return Object.fromEntries(Object.entries(properties).map(([key, value]) => [key, String(value)]));
+}
+//#endregion
+//#region src/telemetry/debug.ts
+var TelemetryDebugSink = class {
+	records = [];
+	capture(state, event) {
+		this.records.push({
+			state,
+			event
+		});
+	}
+	toJSON() {
+		return this.records;
+	}
+};
+//#endregion
+//#region src/telemetry/providers.ts
+function createTelemetryDispatcher(options = {}) {
+	let posthog;
+	let sentry;
+	async function posthogClient() {
+		const token = options.posthogToken ?? process.env.CAPLETS_POSTHOG_TOKEN ?? "phc_pUZ2ZCRtFkC5qCGDNYcoYEhxxjTaooH57Cj4PTRXovyB";
+		if (!token) return void 0;
+		posthog ??= Promise.resolve((options.factories?.createPostHog ?? defaultPostHogFactory)(token));
+		return posthog;
+	}
+	async function sentryClient() {
+		const dsn = options.sentryDsn ?? process.env.CAPLETS_SENTRY_DSN ?? "https://c66cfd76aad69209bcf44be4cd79f9b5@o4508042228006912.ingest.us.sentry.io/4511620382392320";
+		if (!dsn) return void 0;
+		sentry ??= Promise.resolve((options.factories?.createSentry ?? defaultSentryFactory)(dsn));
+		return sentry;
+	}
+	return {
+		async capture(state, event) {
+			if (state.status !== "enabled") return;
+			try {
+				if (event.provider === "posthog") {
+					await capturePostHog(await posthogClient(), event, state.stateDir ?? options.stateDir);
+					return;
+				}
+				await captureSentry(await sentryClient(), event, state.stateDir ?? options.stateDir);
+			} catch {
+				recordTelemetryDrop({
+					stateDir: state.stateDir ?? options.stateDir,
+					provider: event.provider,
+					reason: "send_failed"
+				});
+			}
+		},
+		async shutdown() {
+			const clients = await Promise.allSettled([posthog, sentry]);
+			for (const client of clients) {
+				if (client.status !== "fulfilled" || !client.value) continue;
+				if ("shutdown" in client.value) await Promise.resolve(client.value.shutdown()).catch(() => void 0);
+				if ("flush" in client.value) await Promise.resolve(client.value.flush(2e3)).catch(() => void 0);
+			}
+		}
+	};
+}
+async function capturePostHog(client, event, stateDir) {
+	if (!client) {
+		recordTelemetryDrop({
+			stateDir,
+			provider: "posthog",
+			reason: "not_configured"
+		});
+		return;
+	}
+	client.capture({
+		distinctId: event.distinctId,
+		event: event.name,
+		properties: {
+			...event.properties,
+			$geoip_disable: true
+		}
+	});
+}
+async function captureSentry(client, event, stateDir) {
+	if (!client) {
+		recordTelemetryDrop({
+			stateDir,
+			provider: "sentry",
+			reason: "not_configured"
+		});
+		return;
+	}
+	client.captureEvent({
+		level: "error",
+		tags: event.tags,
+		fingerprint: event.fingerprint
+	});
+}
+async function defaultPostHogFactory(token) {
+	const { PostHog } = await import("./node-BgWIvSVP.js");
+	return new PostHog(token, {
+		flushAt: 20,
+		flushInterval: 1e4,
+		disableGeoip: true,
+		historicalMigration: false
+	});
+}
+async function defaultSentryFactory(dsn) {
+	const sentry = await import("./esm-Db9dhnIG.js");
+	const options = {
+		dsn,
+		sendDefaultPii: false,
+		defaultIntegrations: false,
+		integrations: [],
+		tracesSampleRate: 0,
+		transport: sentry.makeNodeTransport,
+		stackParser: sentry.defaultStackParser,
+		beforeSend(event) {
+			return stripSentryEvent(event);
+		}
+	};
+	return new sentry.NodeClient(options);
+}
+//#endregion
+//#region package.json
+var version = "0.28.0";
+//#endregion
+//#region src/telemetry/runtime.ts
+function createRuntimeTelemetryContext(options) {
+	return {
+		...options,
+		dispatcher: options.dispatcher ?? createTelemetryDispatcher({ stateDir: options.stateDir })
+	};
+}
+async function captureRuntimeTelemetryEvent(context, name, properties) {
+	const state = resolveTelemetryState({
+		config: context.config,
+		env: context.env,
+		stateDir: context.stateDir,
+		surface: context.surface,
+		visibility: context.visibility,
+		debug: context.debugSink !== void 0
+	});
+	if (state.status !== "enabled" && state.status !== "debug") return;
+	const event = buildProductTelemetryEvent({
+		name,
+		distinctId: (state.identity ?? readTelemetryIdentity({
+			stateDir: context.stateDir,
+			create: false
+		})).id,
+		properties: {
+			package: "@caplets/core",
+			version,
+			surface: context.surface,
+			runtime_mode: context.runtimeMode ?? "unknown",
+			execution_context: state.executionContext,
+			...context.integration ? { integration: context.integration } : {},
+			...properties
+		}
+	});
+	if (state.status === "debug") {
+		context.debugSink?.capture("debug", event);
+		return;
+	}
+	await context.dispatcher.capture(state, event);
+}
+async function captureRuntimeReliabilityEvent(context, properties) {
+	const state = resolveTelemetryState({
+		config: context.config,
+		env: context.env,
+		stateDir: context.stateDir,
+		surface: context.surface,
+		visibility: context.visibility,
+		debug: context.debugSink !== void 0
+	});
+	if (state.status !== "enabled" && state.status !== "debug") return;
+	const event = buildReliabilityTelemetryEvent({
+		name: "caplets_reliability_error",
+		properties: {
+			package: "@caplets/core",
+			version,
+			surface: context.surface,
+			runtime_mode: context.runtimeMode ?? "unknown",
+			execution_context: state.executionContext,
+			...context.integration ? { integration: context.integration } : {},
+			os_family: platform(),
+			arch: arch(),
+			node_major: Number(process.versions.node.split(".")[0] ?? 0),
+			...properties
+		}
+	});
+	if (state.status === "debug") {
+		context.debugSink?.capture("debug", event);
+		return;
+	}
+	await context.dispatcher.capture(state, event);
+}
+function backendFamilyCounts(config) {
+	return {
+		backend_mcp_count: enabledCount(config.mcpServers),
+		backend_openapi_count: enabledCount(config.openapiEndpoints),
+		backend_google_discovery_count: enabledCount(config.googleDiscoveryApis),
+		backend_graphql_count: enabledCount(config.graphqlEndpoints),
+		backend_http_count: enabledCount(config.httpApis),
+		backend_cli_count: enabledCount(config.cliTools),
+		backend_caplets_count: enabledCount(config.capletSets)
+	};
+}
+function exposureModeCounts(config) {
+	let direct = 0;
+	let progressive = 0;
+	let codeMode = 0;
+	for (const caplet of allCaplets$1(config)) {
+		if (caplet.disabled || caplet.setup || caplet.projectBinding?.required) continue;
+		const exposure = resolveExposure(caplet.exposure, config.options.exposure);
+		if (exposure.direct) direct += 1;
+		if (exposure.progressive) progressive += 1;
+		if (exposure.codeMode) codeMode += 1;
+	}
+	return {
+		direct_count: direct,
+		progressive_count: progressive,
+		code_mode_count: codeMode
+	};
+}
+function operationFamilyFromOperation(operation) {
+	if (operation === "inspect") return "inspect";
+	if (operation === "check") return "check";
+	if (operation === "tools" || operation === "search_tools" || operation === "get_tool" || operation === "describe_tool" || operation === "call_tool") return "tools";
+	if (operation === "resources" || operation === "resource_templates" || operation === "read_resource" || operation === "search_resources" || operation === "list_resources" || operation === "list_resource_templates" || operation === "search_resource_templates") return "resources";
+	if (operation === "prompts" || operation === "get_prompt" || operation === "list_prompts" || operation === "search_prompts") return "prompts";
+	if (operation === "complete") return "complete";
+	if (operation === "code_mode") return "code_mode";
+	return "unknown";
+}
+function outcomeFromResult(result) {
+	if (isRecord$6(result) && result.isError === true) {
+		if (errorCodeFromResult$1(result).toLowerCase().includes("timeout")) return "timeout";
+		return "failure";
+	}
+	if (isRecord$6(result) && result.ok === false) {
+		const code = errorCodeFromResult$1(result);
+		if (typeof code === "string" && code.toLowerCase().includes("timeout")) return "timeout";
+		return "failure";
+	}
+	return "success";
+}
+function codeModeTelemetryProperties(envelope, durationMs, timeoutMs) {
+	const record = isRecord$6(envelope) ? envelope : {};
+	const meta = isRecord$6(record.meta) ? record.meta : {};
+	const sessionStatus = meta.sessionStatus;
+	const effectiveTimeoutMs = timeoutMs ?? (typeof meta.timeoutMs === "number" ? meta.timeoutMs : void 0);
+	return {
+		command_family: "code_mode",
+		outcome: outcomeFromResult(record),
+		duration_bucket: durationBucket(durationMs),
+		timeout_bucket: timeoutBucket(effectiveTimeoutMs),
+		session_category: sessionStatus === "created" || sessionStatus === "reused" ? sessionStatus : sessionStatus === null ? "none" : "unknown",
+		any_caplet_invoked: codeModeEnvelopeInvokedCaplet(record)
+	};
+}
+function toolActivationProperties(input) {
+	return {
+		operation_family: operationFamilyFromOperation(input.operation),
+		exposure_mode: input.exposureMode,
+		outcome: outcomeFromResult(input.result),
+		duration_bucket: durationBucket(input.durationMs),
+		...backendFamilyCounts(input.config),
+		...exposureModeCounts(input.config)
+	};
+}
+function enabledCount(record) {
+	return Object.values(record).filter((caplet) => !caplet.disabled).length;
+}
+function allCaplets$1(config) {
+	return [
+		...Object.values(config.mcpServers),
+		...Object.values(config.openapiEndpoints),
+		...Object.values(config.googleDiscoveryApis),
+		...Object.values(config.graphqlEndpoints),
+		...Object.values(config.httpApis),
+		...Object.values(config.cliTools),
+		...Object.values(config.capletSets)
+	];
+}
+function isRecord$6(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function runtimeFailureTelemetryProperties(input) {
+	const errorCode = errorCodeFromResult$1(input.result);
+	return {
+		operation_family: operationFamilyFromOperation(input.operation),
+		exposure_mode: input.exposureMode,
+		error_code: errorCode,
+		diagnostic_category: diagnosticCategoryFromCode(errorCode)
+	};
+}
+function errorCodeFromResult$1(result) {
+	if (!isRecord$6(result)) return "UNKNOWN";
+	const error = isRecord$6(result.error) ? result.error : isRecord$6(result.structuredContent) && isRecord$6(result.structuredContent.error) ? result.structuredContent.error : void 0;
+	if (isRecord$6(error) && typeof error.code === "string") return error.code;
+	return "UNKNOWN";
+}
+function diagnosticCategoryFromCode(code) {
+	if (code.startsWith("CONFIG")) return "config";
+	if (code.startsWith("AUTH")) return "auth";
+	if (code.includes("NETWORK") || code.includes("UNAVAILABLE")) return "network";
+	if (code.includes("VALID") || code.includes("REQUEST")) return "validation";
+	if (code.includes("CODE_MODE") || code.includes("SANDBOX")) return "code_mode";
+	return "runtime";
+}
+function codeModeEnvelopeInvokedCaplet(record) {
+	const meta = isRecord$6(record.meta) ? record.meta : void 0;
+	return hasBooleanTrue(meta, "anyCapletInvoked") || hasBooleanTrue(meta, "capletInvoked") || hasPositiveNumber(meta, "capletInvocationCount") || hasPositiveNumber(meta, "toolCallCount");
+}
+function hasBooleanTrue(record, key) {
+	return record?.[key] === true;
+}
+function hasPositiveNumber(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" && value > 0;
+}
+//#endregion
 //#region src/engine.ts
 var CapletsEngine = class {
 	registry;
@@ -63910,6 +64694,8 @@ var CapletsEngine = class {
 	observedOutputShapeStore;
 	observedOutputShapeScope;
 	projectFingerprint;
+	telemetry;
+	telemetryExecuteExposureMode;
 	reloadListeners = /* @__PURE__ */ new Set();
 	lastExposureSnapshot;
 	watchers = [];
@@ -63927,6 +64713,18 @@ var CapletsEngine = class {
 		this.configLoader = options.configLoader ?? runtimeConfigLoader(options.authDir, options.vaultRecoveryTarget);
 		const config = this.loadConfigWithWarnings();
 		this.registry = new ServerRegistry(config);
+		this.telemetry = createRuntimeTelemetryContext({
+			config: this.registry.config,
+			env: options.telemetryEnv,
+			stateDir: options.telemetryStateDir,
+			surface: options.telemetrySurface ?? "serve",
+			visibility: options.telemetryVisibility ?? "unknown",
+			runtimeMode: options.telemetryRuntimeMode ?? runtimeModeFromEnv(options.telemetryEnv),
+			integration: options.telemetryIntegration,
+			debugSink: options.telemetryDebugSink,
+			dispatcher: options.telemetryDispatcher
+		});
+		this.telemetryExecuteExposureMode = options.telemetrySurface === "code_mode" ? "code_mode" : "progressive";
 		this.downstream = new DownstreamManager(this.registry, selectAuthOptions(options.authDir));
 		this.openapi = new OpenApiManager(this.registry, selectHttpLikeOptions(options));
 		this.googleDiscovery = new GoogleDiscoveryManager(this.registry, selectHttpLikeOptions(options));
@@ -63991,44 +64789,73 @@ var CapletsEngine = class {
 		return await this.reloading;
 	}
 	async execute(serverId, request) {
+		const started = Date.now();
+		let caplet;
 		try {
-			return await handleServerTool(this.registry.require(serverId), request, this.registry, this.downstream, this.openapi, this.graphql, this.http, this.cli, this.capletSets, {
+			caplet = this.registry.require(serverId);
+			const result = await handleServerTool(caplet, request, this.registry, this.downstream, this.openapi, this.graphql, this.http, this.cli, this.capletSets, {
 				observedOutputShapeStore: this.observedOutputShapeStore,
 				observedOutputShapeScope: this.observedOutputShapeScope,
 				projectFingerprint: this.projectFingerprint
 			}, this.googleDiscovery);
+			this.captureToolActivation(caplet, operationFromRequest(request), this.telemetryExecuteExposureMode, result, started);
+			return result;
 		} catch (error) {
-			return errorResult(error);
+			const result = errorResult(error);
+			this.captureReliabilityError(operationFromRequest(request), this.telemetryExecuteExposureMode, result);
+			this.captureToolActivation(caplet, operationFromRequest(request), this.telemetryExecuteExposureMode, result, started);
+			return result;
 		}
 	}
 	async executeDirectTool(serverId, toolName, args) {
+		const started = Date.now();
+		let caplet;
 		try {
-			const caplet = this.registry.require(serverId);
-			return annotateDirectResult(await this.callTool(caplet, toolName, args), caplet, toolName);
+			caplet = this.registry.require(serverId);
+			const annotated = annotateDirectResult(await this.callTool(caplet, toolName, args), caplet, toolName);
+			this.captureToolActivation(caplet, "call_tool", "direct", annotated, started);
+			return annotated;
 		} catch (error) {
-			return errorResult(error);
+			const result = errorResult(error);
+			this.captureReliabilityError("call_tool", "direct", result);
+			this.captureToolActivation(caplet, "call_tool", "direct", result, started);
+			return result;
 		}
 	}
 	async readDirectResource(serverId, downstreamUri) {
+		const started = Date.now();
+		let caplet;
 		try {
-			const caplet = this.registry.require(serverId);
+			caplet = this.registry.require(serverId);
 			if (caplet.backend !== "mcp") throw new Error(`Caplet ${serverId} has no MCP resources`);
-			return annotateDirectResult(await this.downstream.readResource(caplet, downstreamUri), caplet, "read_resource");
+			const annotated = annotateDirectResult(await this.downstream.readResource(caplet, downstreamUri), caplet, "read_resource");
+			this.captureToolActivation(caplet, "read_resource", "direct", annotated, started);
+			return annotated;
 		} catch (error) {
-			return errorResult(error);
+			const result = errorResult(error);
+			this.captureReliabilityError("read_resource", "direct", result);
+			this.captureToolActivation(caplet, "read_resource", "direct", result, started);
+			return result;
 		}
 	}
 	async getDirectPrompt(serverId, promptName, args) {
+		const started = Date.now();
+		let caplet;
 		try {
-			const caplet = this.registry.require(serverId);
+			caplet = this.registry.require(serverId);
 			if (caplet.backend !== "mcp") throw new Error(`Caplet ${serverId} has no MCP prompts`);
-			return annotateDirectResult(await this.downstream.getPrompt(caplet, promptName, args), caplet, promptName);
+			const annotated = annotateDirectResult(await this.downstream.getPrompt(caplet, promptName, args), caplet, promptName);
+			this.captureToolActivation(caplet, "get_prompt", "direct", annotated, started);
+			return annotated;
 		} catch (error) {
-			return errorResult(error);
+			const result = errorResult(error);
+			this.captureReliabilityError("get_prompt", "direct", result);
+			this.captureToolActivation(caplet, "get_prompt", "direct", result, started);
+			return result;
 		}
 	}
 	async completeCliWords(words) {
-		const { completeCliWords } = await import("./completion-CFOJucl5.js").then((n) => n.r);
+		const { completeCliWords } = await import("./completion-CjE0EnbF.js").then((n) => n.r);
 		return await completeCliWords(words, {
 			config: this.registry.config,
 			managers: {
@@ -64059,6 +64886,9 @@ var CapletsEngine = class {
 			}
 		});
 	}
+	async captureCodeModeOutcome(envelope, options) {
+		await captureRuntimeTelemetryEvent(this.telemetry, "caplets_code_mode_outcome", codeModeTelemetryProperties(envelope, Date.now() - options.started, options.timeoutMs));
+	}
 	async close() {
 		this.closed = true;
 		try {
@@ -64075,6 +64905,7 @@ var CapletsEngine = class {
 			this.closeWatchers();
 			await this.downstream.close();
 			await this.capletSets.close();
+			await this.telemetry.dispatcher.shutdown();
 			this.reloadListeners.clear();
 		}
 	}
@@ -64112,6 +64943,7 @@ var CapletsEngine = class {
 		const previousConfig = this.registry.config;
 		const nextRegistry = new ServerRegistry(nextConfig);
 		this.registry = nextRegistry;
+		this.telemetry.config = nextConfig;
 		this.downstream.updateRegistry(nextRegistry);
 		this.openapi.updateRegistry(nextRegistry);
 		this.googleDiscovery.updateRegistry(nextRegistry);
@@ -64229,6 +65061,29 @@ var CapletsEngine = class {
 			if (!this.closed) this.resetWatchers();
 		}, this.watchDebounceMs);
 	}
+	captureReliabilityError(operation, exposureMode, result) {
+		captureRuntimeReliabilityEvent(this.telemetry, {
+			command_family: commandFamilyForTelemetrySurface(this.telemetry.surface),
+			...runtimeFailureTelemetryProperties({
+				operation,
+				exposureMode,
+				result
+			})
+		}).catch(() => void 0);
+	}
+	captureToolActivation(caplet, operation, exposureMode, result, started) {
+		captureRuntimeTelemetryEvent(this.telemetry, "caplets_tool_activation", {
+			command_family: commandFamilyForTelemetrySurface(this.telemetry.surface),
+			...toolActivationProperties({
+				config: this.registry.config,
+				caplet,
+				operation,
+				exposureMode,
+				result,
+				durationMs: Date.now() - started
+			})
+		}).catch(() => void 0);
+	}
 };
 function runtimeConfigLoader(authDir, vaultRecoveryTarget) {
 	const vaultResolver = vaultResolverForAuthDir(authDir);
@@ -64331,7 +65186,7 @@ function annotateDirectResult(result, caplet, operation) {
 	return {
 		...result,
 		_meta: {
-			...isRecord$4(existingMeta) ? existingMeta : {},
+			...isRecord$5(existingMeta) ? existingMeta : {},
 			caplets: {
 				capletId: caplet.server,
 				backend: caplet.backend,
@@ -64344,9 +65199,25 @@ function annotateDirectResult(result, caplet, operation) {
 function isUnsupportedCapability(error) {
 	return error instanceof CapletsError && error.code === "UNSUPPORTED_CAPABILITY";
 }
-function isRecord$4(value) {
+function isRecord$5(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function operationFromRequest(request) {
+	return isRecord$5(request) ? request.operation : void 0;
+}
+function runtimeModeFromEnv(env) {
+	const mode = env?.CAPLETS_MODE ?? process.env.CAPLETS_MODE;
+	if (mode === "local" || mode === "remote" || mode === "cloud") return mode;
+	return "unknown";
+}
+function commandFamilyForTelemetrySurface(surface) {
+	if (surface === "serve") return "serve";
+	if (surface === "attach") return "attach";
+	if (surface === "daemon") return "daemon";
+	if (surface === "code_mode") return "code_mode";
+	if (surface === "native") return "native";
+	return "tools";
+}
 //#endregion
 //#region src/code-mode/runtime-api.generated.ts
 const CODE_MODE_RUNTIME_API_DECLARATION = "type JsonPrimitive=string|number|boolean|null;type JsonValue=JsonPrimitive|JsonValue[]|{[key:string]:JsonValue};interface CapletHandle<Id extends string>{readonly id:Id;/** Show this Caplet card,without tool/resource/prompt schemas. */ inspect():Promise<CapletCard<Id>>;/** Check backend readiness/auth;expected unavailable states return ok:false. */ check():Promise<CapletsResult<BackendCheckResult>>;/** List tool summaries for the discovery pass;may be empty. */ tools(input?:PageInput):Promise<Page<ToolSummary>>;/** Search tool summaries for the discovery pass;may be empty. */ searchTools(query:string,input?:PageInput):Promise<Page<ToolSummary>>;/** Get schema,callSignature,types,examples;prefer outputSchema/outputTypeScript over observed hints. */ describeTool(name:string):Promise<CapletsResult<ToolDescriptor>>;/** Call one tool;expected failures return ok:false. Filter bulky data in script before returning. */ callTool(name:string,args?:unknown):Promise<CapletsResult<unknown>>;/** List readable resources for the discovery pass;many backends expose none. */ resources(input?:PageInput):Promise<Page<ResourceSummary>>;/** Search readable resources for the discovery pass;many backends expose none. */ searchResources(query:string,input?:PageInput):Promise<Page<ResourceSummary>>;/** List resource templates for the discovery pass;many backends expose none. */ resourceTemplates(input?:PageInput):Promise<Page<ResourceTemplateSummary>>;/** Read one resource by URI;unsupported/missing resources return ok:false. */ readResource(uri:string):Promise<CapletsResult<ResourceReadResult>>;/** List reusable prompts for the discovery pass;many backends expose none. */ prompts(input?:PageInput):Promise<Page<PromptSummary>>;/** Search reusable prompts for the discovery pass;many backends expose none. */ searchPrompts(query:string,input?:PageInput):Promise<Page<PromptSummary>>;/** Get one prompt by name and args;unsupported/missing prompts return ok:false. */ getPrompt(name:string,args?:unknown):Promise<CapletsResult<PromptResult>>;/** Complete a prompt or resource-template argument. */ complete(input:CompleteInput):Promise<CapletsResult<CompleteResult>>;}interface DebugApi{readLogs(input:ReadLogsInput):Promise<ReadLogsResult>;readRecovery(input:ReadCodeModeRecoveryInput):Promise<ReadCodeModeRecoveryResult>;}type CapletCard<Id extends string>={id:Id;name:string;description:string;useWhen?:string;avoidWhen?:string;tags?:string[];backend?:unknown;};type PageInput={limit?:number;cursor?:string};type Page<T>={items:T[];nextCursor?:string;truncated?:boolean};type CapletsResult<T>=|{ok:true;data:T;meta?:CapletsMeta}|{ok:false;error:CapletsError;meta?:CapletsMeta};type CapletsMeta={[key:string]:unknown};type CapletsError={code:string;message:string;details?:unknown};type BackendCheckResult=unknown;type ToolSummary={/** Exact downstream tool identifier for describeTool(name)and callTool(name,args). */ name:string;title?:string;description?:string;/** Optional author-supplied hint for when to prefer this tool. */ useWhen?:string;/** Optional author-supplied hint for when to avoid this tool. */ avoidWhen?:string;/** True when the tool declares that it only reads data. */ readOnlyHint?:boolean;/** True when the tool declares that it may perform destructive writes. */ destructiveHint?:boolean;};type ToolDescriptor={id?:string;tool?:unknown;inputSchema?:unknown;outputSchema?:unknown;callSignature?:string;inputTypeScript?:string;outputTypeScript?:string;observedOutputShape?:ObservedOutputShape;examples?:unknown[];};type ObservedOutputShape={version:1;source:\"observed\";observedAt:string;sampleCount:number;typeScript:string;jsonShape:JsonShape;truncated:boolean;};type JsonShape=|{kind:\"null\"}|{kind:\"boolean\"}|{kind:\"number\"}|{kind:\"string\"}|{kind:\"unknown\"}|{kind:\"array\";element?:JsonShape;truncated?:boolean}|{kind:\"object\";fields:Record<string,{optional:boolean;shape:JsonShape}>;truncated?:boolean;}|{kind:\"union\";variants:JsonShape[]};type ResourceSummary={uri?:string;name?:string;title?:string;description?:string};type ResourceTemplateSummary={uriTemplate?:string;name?:string;title?:string;description?:string;};type ResourceReadResult=unknown;type PromptSummary={name?:string;title?:string;description?:string};type PromptResult=unknown;type CompleteInput={ref:{type:\"prompt\";name:string}|{type:\"resourceTemplate\";uri:string};argument:{name:string;value:string};};type CompleteResult=unknown;type ReadLogsInput={logRef:string;cursor?:string;limit?:number};type ReadLogsResult={entries:CodeModeLogEntry[];nextCursor?:string};type ReadCodeModeRecoveryInput={recoveryRef:string;cursor?:string;limit?:number};type CodeModeDiagnostic={code:string;message:string;severity:\"error\"|\"warning\"|\"info\";line?:number;column?:number;};type CodeModeRecoveryClassification=\"setup_like\"|\"side_effecting\"|\"unknown\";type CodeModeRecoveryEntry={timestamp:string;code:string;declarationHash:string;outcome:{ok:true}|{ok:false;code:string;message:string};diagnostics:Array<Pick<CodeModeDiagnostic,\"code\"|\"severity\"|\"message\">>;recoveryClassification:CodeModeRecoveryClassification;logsStored?:boolean;summary?:string;};type ReadCodeModeRecoveryResult={entries:CodeModeRecoveryEntry[];nextCursor?:string};type CodeModeLogEntry={level:\"log\"|\"info\"|\"warn\"|\"error\"|\"debug\";message:string;timestamp:string;};type CodeModeSessionStatus=\"created\"|\"reused\";type CodeModeRunMeta={runId:string;traceId:string;declarationHash:string;durationMs:number;timeoutMs:number;maxTimeoutMs:number;sessionId?:string|null;sessionStatus?:CodeModeSessionStatus|null;recoveryRef?:string|null;};interface Console{log(...values:unknown[]):void;info(...values:unknown[]):void;warn(...values:unknown[]):void;error(...values:unknown[]):void;debug(...values:unknown[]):void;}declare const console:Console;";
@@ -79871,9 +80742,11 @@ async function runCodeMode(input) {
 	const callable = listCodeModeCallableCaplets(input.service);
 	const declaration = generateCodeModeDeclarations({ caplets: callable });
 	const declarationHash = codeModeDeclarationHash(declaration);
+	const platformRuntimeHash = codeModeDeclarationHash(CODE_MODE_PLATFORM_RUNTIME_SOURCE);
+	let invokedCaplet = false;
 	const sessionCompatibility = {
 		declarationHash,
-		platformRuntimeHash: codeModeDeclarationHash(CODE_MODE_PLATFORM_RUNTIME_SOURCE),
+		platformRuntimeHash,
 		runtimeScope: input.runtimeScope ?? "",
 		version: 1
 	};
@@ -79890,7 +80763,8 @@ async function runCodeMode(input) {
 	};
 	const meta = () => ({
 		...metaBase,
-		durationMs: Date.now() - startedAt
+		durationMs: Date.now() - startedAt,
+		anyCapletInvoked: invokedCaplet
 	});
 	if (input.sessionId !== void 0 && !input.sessionManager) return {
 		ok: false,
@@ -79977,7 +80851,6 @@ async function runCodeMode(input) {
 		};
 	}
 	const capturedLogs = [];
-	let invokedCaplet = false;
 	const api = createCodeModeCapletsApi({
 		service: input.service,
 		readLogs: async (readInput) => input.logStore?.read(readInput) ?? { entries: [] },
@@ -80283,6 +81156,7 @@ function emptyCodeModeRunMeta() {
 		durationMs: 0,
 		timeoutMs: 0,
 		maxTimeoutMs: 0,
+		anyCapletInvoked: false,
 		sessionId: null,
 		sessionStatus: null,
 		recoveryRef: null
@@ -80542,18 +81416,28 @@ function resolveNativeCapletsServiceOptions(input = {}, env = process.env) {
 		...remoteFetch ? { fetch: remoteFetch } : {}
 	}, env);
 	const cloud = resolveNativeCloudPresence(input.remote?.cloud, env);
+	const requestInit = mode.mode === "cloud" && cloud ? { headers: { Authorization: `Bearer ${cloud.accessToken}` } } : server.requestInit;
 	return {
 		mode: mode.mode,
 		remote: {
 			url: server.attachUrl,
 			auth: nativeAuthFromRemoteAuth$1(server.auth),
 			pollIntervalMs: parsePollInterval(input.remote?.pollIntervalMs),
-			requestInit: mode.mode === "cloud" && cloud ? { headers: { Authorization: `Bearer ${cloud.accessToken}` } } : server.requestInit,
+			requestInit: withRequestHeaders(requestInit, input.remote?.requestHeaders),
 			...cloud ? { cloud } : {},
 			...server.fetch ? { fetch: server.fetch } : {}
 		}
 	};
 }
+function withRequestHeaders(requestInit, requestHeaders) {
+	if (!requestHeaders) return requestInit;
+	const headers = new Headers(requestInit.headers);
+	for (const [name, value] of Object.entries(requestHeaders)) headers.set(name, value);
+	return {
+		...requestInit,
+		headers
+	};
+}
 function resolveNativeHostedCloudRemote(url, workspace, fetch) {
 	return resolveHostedCloudRemote({
 		url,
@@ -80968,7 +81852,382 @@ function projectSyncFiles(projectRoot) {
 	}));
 }
 //#endregion
+//#region src/attach/api.ts
+const CAPLETS_ATTACH_SESSION_HEADER = "caplets-attach-session-id";
+async function buildAttachProjection(engine) {
+	const snapshot = await engine.exposureSnapshot();
+	const partial = sortAttachProjectionInput({
+		caplets: snapshot.progressiveCaplets.map(progressiveCapletExport),
+		tools: snapshot.directTools.map(toolExport),
+		resources: snapshot.directResources.map(resourceExport),
+		resourceTemplates: snapshot.directResourceTemplates.map(resourceTemplateExport),
+		prompts: snapshot.directPrompts.map(promptExport),
+		completions: completionExports(snapshot),
+		codeModeCaplets: snapshot.codeModeCaplets.map(codeModeCapletExport),
+		diagnostics: snapshot.hiddenCaplets.map((hidden) => ({
+			code: `ATTACH_CAPLET_${hidden.reason.toUpperCase()}`,
+			message: `Caplet ${hidden.capletId} is not exported: ${hidden.reason}.`,
+			capletId: hidden.capletId,
+			...hidden.error ? { details: hidden.error } : {}
+		}))
+	});
+	const revision = revisionFor(partial);
+	const manifest = {
+		version: 1,
+		revision,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...withRevisionExportIds(revision, partial)
+	};
+	return {
+		manifest,
+		routes: routesFor(manifest)
+	};
+}
+async function buildNativeAttachProjection(service) {
+	const tools = service.listTools();
+	const partial = sortAttachProjectionInput({
+		caplets: nativeProgressiveCaplets(tools),
+		tools: nativeDirectTools(tools),
+		resources: [],
+		resourceTemplates: [],
+		prompts: [],
+		completions: [],
+		codeModeCaplets: nativeCodeModeCaplets(tools),
+		diagnostics: []
+	});
+	const revision = revisionFor(partial);
+	const manifest = {
+		version: 1,
+		revision,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...withRevisionExportIds(revision, partial)
+	};
+	return {
+		manifest,
+		routes: routesFor(manifest)
+	};
+}
+function nativeProgressiveCaplets(tools) {
+	return tools.filter((tool) => tool.codeModeRun !== true && !nativeDirectToolOperation(tool)).map((tool) => ({
+		stableId: `native:${tool.caplet}`,
+		kind: "caplet",
+		name: tool.caplet,
+		title: tool.title,
+		description: tool.description,
+		inputSchema: tool.inputSchema,
+		outputSchema: tool.outputSchema,
+		annotations: tool.annotations,
+		schemaHash: schemaHash(tool.inputSchema ?? null),
+		capletId: tool.caplet,
+		shadowing: tool.shadowing ?? "forbid"
+	}));
+}
+function nativeDirectTools(tools) {
+	return tools.flatMap((tool) => {
+		const operation = nativeDirectToolOperation(tool);
+		if (!operation || tool.codeModeRun === true || !tool.sourceCaplet) return [];
+		return [{
+			stableId: `native-tool:${tool.caplet}`,
+			kind: "tool",
+			name: tool.caplet,
+			downstreamName: operation,
+			title: tool.title,
+			description: tool.description,
+			inputSchema: tool.inputSchema,
+			outputSchema: tool.outputSchema,
+			annotations: tool.annotations,
+			schemaHash: schemaHash({
+				input: tool.inputSchema,
+				output: tool.outputSchema
+			}),
+			capletId: tool.sourceCaplet,
+			shadowing: tool.shadowing ?? "forbid"
+		}];
+	});
+}
+function nativeDirectToolOperation(tool) {
+	if (!tool.sourceCaplet || !tool.caplet.startsWith(`${tool.sourceCaplet}__`)) return;
+	return tool.caplet.slice(tool.sourceCaplet.length + 2);
+}
+function nativeCodeModeCaplets(tools) {
+	return tools.flatMap((tool) => (tool.codeModeCaplets ?? []).map((caplet) => ({
+		stableId: `native-code-mode:${caplet.id}`,
+		kind: "caplet",
+		name: caplet.name,
+		title: caplet.name,
+		description: caplet.description,
+		schemaHash: null,
+		capletId: caplet.id,
+		shadowing: caplet.shadowing ?? "forbid"
+	})));
+}
+async function invokeNativeAttachExport(service, projection, request) {
+	if (request.revision !== projection.manifest.revision) throw new CapletsError("ATTACH_MANIFEST_STALE", "Attach manifest revision is stale.");
+	const route = projection.routes.get(request.exportId);
+	if (!route || route.kind !== request.kind) throw new CapletsError("ATTACH_EXPORT_NOT_FOUND", "Attach export was not found.");
+	if (route.kind !== "caplet") {
+		if (route.kind === "tool") return await service.execute(`${route.capletId}__${route.downstreamName}`, request.input);
+		throw new CapletsError("REQUEST_INVALID", "Native attach sessions only support Caplet and tool exports.");
+	}
+	return await service.execute(route.capletId, request.input);
+}
+async function invokeAttachExport$1(engine, projection, request) {
+	if (request.revision !== projection.manifest.revision) throw new CapletsError("ATTACH_MANIFEST_STALE", "Attach manifest revision is stale.");
+	const route = projection.routes.get(request.exportId);
+	if (!route || route.kind !== request.kind) throw new CapletsError("ATTACH_EXPORT_NOT_FOUND", "Attach export was not found.");
+	if (route.kind === "caplet") return await engine.execute(route.capletId, request.input);
+	if (route.kind === "tool") return await engine.executeDirectTool(route.capletId, route.downstreamName, isRecord$4(request.input) ? request.input : {});
+	if (route.kind === "resource") return await engine.readDirectResource(route.capletId, route.downstreamUri);
+	if (route.kind === "resourceTemplate") {
+		const uri = isRecord$4(request.input) && typeof request.input.uri === "string" ? request.input.uri : void 0;
+		if (!uri) throw new CapletsError("REQUEST_INVALID", "Attach resource template invoke requires input.uri.");
+		const downstreamUri = downstreamResourceUri$1(route.capletId, uri);
+		if (!directResourceUriMatchesTemplate(downstreamUri, route.downstreamUriTemplate)) throw new CapletsError("ATTACH_EXPORT_NOT_FOUND", "Attach resource URI does not match the exported resource template.");
+		return await engine.readDirectResource(route.capletId, downstreamUri);
+	}
+	if (route.kind === "prompt") return await engine.getDirectPrompt(route.capletId, route.downstreamName, isRecord$4(request.input) ? stringifyRecord(request.input) : {});
+	if (route.kind === "completion") return await engine.execute(route.capletId, {
+		...normalizeCompletionInput(projection.manifest, route.capletId, request.input),
+		operation: "complete"
+	});
+	throw new CapletsError("REQUEST_INVALID", "Attach export kind is not invokable via /v1/attach/invoke.");
+}
+function attachErrorResponse(error) {
+	const safe = toSafeError(error, "INTERNAL_ERROR");
+	return {
+		status: safe.code === "ATTACH_MANIFEST_STALE" ? 409 : safe.code === "ATTACH_EXPORT_NOT_FOUND" ? 404 : safe.code === "REQUEST_INVALID" ? 400 : 500,
+		body: {
+			ok: false,
+			error: safe
+		}
+	};
+}
+function progressiveCapletExport(entry) {
+	const inputSchema = generatedToolInputJsonSchemaForCaplet(entry.caplet);
+	return {
+		stableId: `progressive:${entry.caplet.server}`,
+		kind: "caplet",
+		name: entry.caplet.server,
+		title: entry.caplet.name,
+		description: entry.caplet.description,
+		inputSchema,
+		schemaHash: schemaHash(inputSchema),
+		capletId: entry.caplet.server,
+		shadowing: shadowingPolicy(entry.caplet)
+	};
+}
+function codeModeCapletExport(entry) {
+	return {
+		stableId: `code_mode:${entry.caplet.server}`,
+		kind: "caplet",
+		name: entry.caplet.name,
+		title: entry.caplet.name,
+		description: entry.caplet.description,
+		schemaHash: null,
+		capletId: entry.caplet.server,
+		shadowing: shadowingPolicy(entry.caplet)
+	};
+}
+function toolExport(entry) {
+	return {
+		stableId: `tool:${entry.caplet.server}:${entry.downstreamName}`,
+		kind: "tool",
+		name: entry.name,
+		downstreamName: entry.downstreamName,
+		title: entry.tool.name,
+		description: entry.tool.description,
+		inputSchema: entry.tool.inputSchema,
+		outputSchema: entry.tool.outputSchema,
+		annotations: entry.tool.annotations,
+		schemaHash: schemaHash({
+			input: entry.tool.inputSchema,
+			output: entry.tool.outputSchema
+		}),
+		capletId: entry.caplet.server,
+		shadowing: shadowingPolicy(entry.caplet)
+	};
+}
+function resourceExport(entry) {
+	return {
+		stableId: `resource:${entry.caplet.server}:${entry.downstreamUri}`,
+		kind: "resource",
+		uri: entry.uri,
+		downstreamUri: entry.downstreamUri,
+		title: entry.resource.name,
+		description: entry.resource.description,
+		...entry.resource.mimeType ? { mimeType: entry.resource.mimeType } : {},
+		...typeof entry.resource.size === "number" ? { size: entry.resource.size } : {},
+		schemaHash: null,
+		capletId: entry.caplet.server,
+		shadowing: shadowingPolicy(entry.caplet)
+	};
+}
+function resourceTemplateExport(entry) {
+	return {
+		stableId: `resourceTemplate:${entry.caplet.server}:${entry.downstreamUriTemplate}`,
+		kind: "resourceTemplate",
+		uriTemplate: entry.uriTemplate,
+		downstreamUriTemplate: entry.downstreamUriTemplate,
+		title: entry.resourceTemplate.name,
+		description: entry.resourceTemplate.description,
+		...entry.resourceTemplate.mimeType ? { mimeType: entry.resourceTemplate.mimeType } : {},
+		schemaHash: null,
+		capletId: entry.caplet.server,
+		shadowing: shadowingPolicy(entry.caplet)
+	};
+}
+function promptExport(entry) {
+	const inputSchema = { arguments: entry.prompt.arguments ?? [] };
+	return {
+		stableId: `prompt:${entry.caplet.server}:${entry.downstreamName}`,
+		kind: "prompt",
+		name: entry.name,
+		downstreamName: entry.downstreamName,
+		title: entry.prompt.name,
+		description: entry.prompt.description,
+		inputSchema,
+		schemaHash: schemaHash(inputSchema),
+		capletId: entry.caplet.server,
+		shadowing: shadowingPolicy(entry.caplet)
+	};
+}
+function completionExports(snapshot) {
+	return [...new Map([...snapshot.directPrompts, ...snapshot.directResourceTemplates].map((entry) => [entry.caplet.server, entry.caplet])).entries()].sort(([left], [right]) => left.localeCompare(right)).map(([capletId, caplet]) => ({
+		stableId: `completion:${capletId}`,
+		kind: "completion",
+		name: `${capletId}:complete`,
+		title: "Complete",
+		description: `MCP completion for ${capletId}.`,
+		schemaHash: null,
+		capletId,
+		shadowing: shadowingPolicy(caplet)
+	}));
+}
+function shadowingPolicy(caplet) {
+	return caplet.shadowing ?? "forbid";
+}
+function sortAttachProjectionInput(partial) {
+	return {
+		caplets: sortByStableId(partial.caplets),
+		tools: sortByStableId(partial.tools),
+		resources: sortByStableId(partial.resources),
+		resourceTemplates: sortByStableId(partial.resourceTemplates),
+		prompts: sortByStableId(partial.prompts),
+		completions: sortByStableId(partial.completions),
+		codeModeCaplets: sortByStableId(partial.codeModeCaplets),
+		diagnostics: [...partial.diagnostics].sort((left, right) => diagnosticSortKey(left).localeCompare(diagnosticSortKey(right)))
+	};
+}
+function sortByStableId(entries) {
+	return [...entries].sort((left, right) => left.stableId.localeCompare(right.stableId));
+}
+function diagnosticSortKey(diagnostic) {
+	return stableJsonStringify({
+		code: diagnostic.code,
+		capletId: diagnostic.capletId ?? "",
+		message: diagnostic.message
+	});
+}
+function revisionFor(value) {
+	return `sha256:${createHash("sha256").update(stableJsonStringify(value)).digest("hex")}`;
+}
+function withRevisionExportIds(revision, partial) {
+	return {
+		...partial,
+		caplets: partial.caplets.map((entry) => withExportId(revision, entry)),
+		tools: partial.tools.map((entry) => withExportId(revision, entry)),
+		resources: partial.resources.map((entry) => withExportId(revision, entry)),
+		resourceTemplates: partial.resourceTemplates.map((entry) => withExportId(revision, entry)),
+		prompts: partial.prompts.map((entry) => withExportId(revision, entry)),
+		completions: partial.completions.map((entry) => withExportId(revision, entry)),
+		codeModeCaplets: partial.codeModeCaplets.map((entry) => withExportId(revision, entry))
+	};
+}
+function withExportId(revision, entry) {
+	return {
+		...entry,
+		exportId: `${revision}:${entry.stableId}`
+	};
+}
+function routesFor(manifest) {
+	const routes = /* @__PURE__ */ new Map();
+	for (const entry of manifest.caplets) routes.set(entry.exportId, {
+		kind: "caplet",
+		capletId: entry.capletId
+	});
+	for (const entry of manifest.tools) routes.set(entry.exportId, {
+		kind: "tool",
+		capletId: entry.capletId,
+		downstreamName: entry.downstreamName
+	});
+	for (const entry of manifest.resources) routes.set(entry.exportId, {
+		kind: "resource",
+		capletId: entry.capletId,
+		downstreamUri: entry.downstreamUri
+	});
+	for (const entry of manifest.resourceTemplates) routes.set(entry.exportId, {
+		kind: "resourceTemplate",
+		capletId: entry.capletId,
+		downstreamUriTemplate: entry.downstreamUriTemplate
+	});
+	for (const entry of manifest.prompts) routes.set(entry.exportId, {
+		kind: "prompt",
+		capletId: entry.capletId,
+		downstreamName: entry.downstreamName
+	});
+	for (const entry of manifest.completions) routes.set(entry.exportId, {
+		kind: "completion",
+		capletId: entry.capletId
+	});
+	for (const entry of manifest.codeModeCaplets) routes.set(entry.exportId, {
+		kind: "caplet",
+		capletId: entry.capletId
+	});
+	return routes;
+}
+function normalizeCompletionInput(manifest, capletId, input) {
+	if (!isRecord$4(input)) return {};
+	const ref = input.ref;
+	if (!isRecord$4(ref)) return input;
+	if (ref.type === "prompt" && typeof ref.name === "string") {
+		const prompt = manifest.prompts.find((entry) => entry.capletId === capletId && (entry.name === ref.name || entry.downstreamName === ref.name));
+		if (!prompt) return input;
+		return {
+			...input,
+			ref: {
+				...ref,
+				name: prompt.downstreamName
+			}
+		};
+	}
+	if (ref.type === "resourceTemplate" && typeof ref.uri === "string") {
+		const resourceTemplate = manifest.resourceTemplates.find((entry) => entry.capletId === capletId && (entry.uriTemplate === ref.uri || entry.downstreamUriTemplate === ref.uri));
+		if (!resourceTemplate) return input;
+		return {
+			...input,
+			ref: {
+				...ref,
+				uri: resourceTemplate.downstreamUriTemplate
+			}
+		};
+	}
+	return input;
+}
+function isRecord$4(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringifyRecord(record) {
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, typeof value === "string" ? value : JSON.stringify(value)]));
+}
+function downstreamResourceUri$1(capletId, uri) {
+	if (!uri.startsWith("caplets://")) return uri;
+	const decoded = decodeDirectResourceUri(uri);
+	if (decoded.capletId !== capletId) throw new CapletsError("ATTACH_EXPORT_NOT_FOUND", "Attach resource template URI belongs to a different Caplet.");
+	return decoded.downstreamUri;
+}
+//#endregion
 //#region src/native/remote.ts
+const ATTACH_SESSION_UNSUPPORTED_RETRY_MS = 6e4;
 function createSdkRemoteCapletsClient(options) {
 	const listeners = /* @__PURE__ */ new Set();
 	let manifest;
@@ -80976,18 +82235,50 @@ function createSdkRemoteCapletsClient(options) {
 	let eventsAbort;
 	let eventsStartInFlight;
 	let eventsReconnectTimer;
+	let attachSessionId;
+	let attachSessionInFlight;
+	let attachSessionsUnsupportedUntil = 0;
 	let closed = false;
 	const resolveRuntimeOptions = async () => {
 		return options.resolveRuntimeOptions ? await options.resolveRuntimeOptions() : options;
 	};
 	const fetchFor = (runtimeOptions) => runtimeOptions.fetch ?? fetch;
 	const fetchCurrentManifest = async () => {
-		const runtimeOptions = await resolveRuntimeOptions();
-		return await fetchAttachManifest(runtimeOptions.url, runtimeOptions.requestInit, fetchFor(runtimeOptions));
+		return await withAttachSessionRetry(async (runtimeOptions, sessionId) => {
+			return await fetchAttachManifest(runtimeOptions.url, runtimeOptions.requestInit, sessionId, fetchFor(runtimeOptions));
+		});
 	};
 	const invokeCurrentExport = async (body) => {
+		return await withAttachSessionRetry(async (runtimeOptions, sessionId) => {
+			return await invokeAttachExport(runtimeOptions.url, runtimeOptions.requestInit, sessionId, fetchFor(runtimeOptions), body);
+		});
+	};
+	const ensureAttachSession = async (runtimeOptions) => {
+		if (!options.attachSessionMetadata) return void 0;
+		if (attachSessionsUnsupportedUntil > Date.now()) return void 0;
+		attachSessionsUnsupportedUntil = 0;
+		if (attachSessionId) return attachSessionId;
+		if (attachSessionInFlight) return await attachSessionInFlight;
+		attachSessionInFlight = createAttachSession(runtimeOptions.url, runtimeOptions.requestInit, fetchFor(runtimeOptions), options.attachSessionMetadata);
+		try {
+			attachSessionId = await attachSessionInFlight;
+			if (!attachSessionId) attachSessionsUnsupportedUntil = Date.now() + ATTACH_SESSION_UNSUPPORTED_RETRY_MS;
+			return attachSessionId;
+		} finally {
+			attachSessionInFlight = void 0;
+		}
+	};
+	const withAttachSessionRetry = async (operation) => {
 		const runtimeOptions = await resolveRuntimeOptions();
-		return await invokeAttachExport(runtimeOptions.url, runtimeOptions.requestInit, fetchFor(runtimeOptions), body);
+		const sessionId = await ensureAttachSession(runtimeOptions);
+		if (closed) throw new CapletsError("SERVER_UNAVAILABLE", "Remote Caplets client is closed.");
+		try {
+			return await operation(runtimeOptions, sessionId);
+		} catch (error) {
+			if (!options.attachSessionMetadata || attachSessionsUnsupportedUntil > Date.now() || !sessionId || !isAttachSessionNotFound(error)) throw error;
+			if (attachSessionId === sessionId) attachSessionId = void 0;
+			return await operation(runtimeOptions, await ensureAttachSession(runtimeOptions));
+		}
 	};
 	const clearEventsReconnectTimer = () => {
 		if (eventsReconnectTimer) {
@@ -81007,7 +82298,9 @@ function createSdkRemoteCapletsClient(options) {
 		try {
 			const runtimeOptions = await resolveRuntimeOptions();
 			if (closed || eventsAbort || listeners.size === 0) return;
-			eventsAbort = startAttachEvents(runtimeOptions.url, runtimeOptions.requestInit, fetchFor(runtimeOptions), listeners, (closedAbort, retry) => {
+			const sessionId = await ensureAttachSession(runtimeOptions);
+			if (closed || eventsAbort || listeners.size === 0) return;
+			eventsAbort = startAttachEvents(runtimeOptions.url, runtimeOptions.requestInit, sessionId, fetchFor(runtimeOptions), listeners, (closedAbort, retry) => {
 				if (eventsAbort !== closedAbort) return;
 				eventsAbort = void 0;
 				if (!retry || closedAbort.signal.aborted || listeners.size === 0) return;
@@ -81089,6 +82382,13 @@ function createSdkRemoteCapletsClient(options) {
 			eventsAbort?.abort();
 			eventsAbort = void 0;
 			listeners.clear();
+			const pendingSessionId = await attachSessionInFlight?.catch(() => void 0);
+			const sessionId = attachSessionId ?? pendingSessionId;
+			attachSessionId = void 0;
+			if (sessionId) await (async () => {
+				const runtimeOptions = await resolveRuntimeOptions();
+				await closeAttachSession(runtimeOptions.url, runtimeOptions.requestInit, fetchFor(runtimeOptions), sessionId);
+			})().catch(() => void 0);
 		}
 	};
 }
@@ -81285,16 +82585,62 @@ function remoteCodeModeCallableNativeTools$1(tools) {
 function nativeToolRouteId(tool) {
 	return tool.codeModeRun ? nativeCodeModeToolId : tool.name;
 }
-async function fetchAttachManifest(attachUrl, requestInit, fetchImpl) {
+async function fetchAttachManifest(attachUrl, requestInit, attachSessionId, fetchImpl) {
+	const headers = attachHeaders(requestInit, attachSessionId);
 	const response = await fetchImpl(new URL("manifest", slashUrl(attachUrl)), {
 		...requestInit,
-		method: "GET"
+		method: "GET",
+		headers
 	});
-	if (!response.ok) throw new CapletsError("SERVER_UNAVAILABLE", `Caplets attach manifest returned HTTP ${response.status}.`);
+	if (!response.ok) {
+		let payload;
+		try {
+			payload = await response.json();
+		} catch {
+			payload = { error: { message: `Caplets attach manifest returned HTTP ${response.status}.` } };
+		}
+		throw attachPayloadError(payload, response.status, "manifest");
+	}
 	return await response.json();
 }
-async function invokeAttachExport(attachUrl, requestInit, fetchImpl, body) {
+async function createAttachSession(attachUrl, requestInit, fetchImpl, metadata) {
+	const headers = new Headers(requestInit?.headers);
+	headers.set("content-type", "application/json");
+	const response = await fetchImpl(new URL("sessions", slashUrl(attachUrl)), {
+		...requestInit,
+		method: "POST",
+		headers,
+		body: JSON.stringify(metadata)
+	});
+	if (!response.ok) {
+		if (response.status === 404) return void 0;
+		let payload;
+		try {
+			payload = await response.json();
+		} catch {
+			payload = void 0;
+		}
+		if (response.status === 400 && isAttachSessionProjectContextRejected(payload)) return;
+		throw new CapletsError("SERVER_UNAVAILABLE", `Caplets attach session returned HTTP ${response.status}.`);
+	}
+	const payload = await response.json();
+	if (!isPlainObject(payload) || typeof payload.sessionId !== "string") throw new CapletsError("SERVER_UNAVAILABLE", "Caplets attach session response was invalid.");
+	return payload.sessionId;
+}
+async function closeAttachSession(attachUrl, requestInit, fetchImpl, attachSessionId) {
+	await fetchImpl(new URL(`sessions/${encodeURIComponent(attachSessionId)}`, slashUrl(attachUrl)), {
+		...requestInit,
+		method: "DELETE",
+		headers: attachHeaders(requestInit, attachSessionId)
+	});
+}
+function attachHeaders(requestInit, attachSessionId) {
 	const headers = new Headers(requestInit?.headers);
+	if (attachSessionId) headers.set(CAPLETS_ATTACH_SESSION_HEADER, attachSessionId);
+	return headers;
+}
+async function invokeAttachExport(attachUrl, requestInit, attachSessionId, fetchImpl, body) {
+	const headers = attachHeaders(requestInit, attachSessionId);
 	headers.set("content-type", "application/json");
 	const response = await fetchImpl(new URL("invoke", slashUrl(attachUrl)), {
 		...requestInit,
@@ -81306,10 +82652,10 @@ async function invokeAttachExport(attachUrl, requestInit, fetchImpl, body) {
 	try {
 		payload = await response.json();
 	} catch (error) {
-		if (!response.ok) throw attachPayloadError({ error: { message: `Caplets attach invoke returned HTTP ${response.status}.` } }, response.status);
+		if (!response.ok) throw attachPayloadError({ error: { message: `Caplets attach invoke returned HTTP ${response.status}.` } }, response.status, "invoke");
 		throw error;
 	}
-	if (!response.ok) throw attachPayloadError(payload, response.status);
+	if (!response.ok) throw attachPayloadError(payload, response.status, "invoke");
 	if (isPlainObject(payload) && payload.ok === true && "data" in payload) return payload.data;
 	return payload;
 }
@@ -81409,7 +82755,7 @@ function primitiveInvokeInput(capletId, operation, input) {
 function toolsFromManifest(manifest) {
 	const codeModeCaplets = manifest.codeModeCaplets ?? [];
 	const codeModeMarker = attachCodeModeMarker(codeModeCaplets);
-	const codeModeShadowing = codeModeCaplets.some((entry) => entry.shadowing === "forbid") ? "forbid" : "allow";
+	const codeModeShadowing = codeModeCaplets.some((entry) => entry.shadowing === "forbid") ? "forbid" : codeModeCaplets.some((entry) => entry.shadowing === "namespace") ? "namespace" : "allow";
 	return [
 		...manifest.caplets.map((entry) => ({
 			name: entry.capletId,
@@ -81566,9 +82912,9 @@ function slashUrl(url) {
 	next.pathname = next.pathname.endsWith("/") ? next.pathname : `${next.pathname}/`;
 	return next;
 }
-function attachPayloadError(payload, status) {
+function attachPayloadError(payload, status, endpoint) {
 	const error = isPlainObject(payload) && isPlainObject(payload.error) ? payload.error : void 0;
-	const message = typeof error?.message === "string" ? error.message : `Caplets attach invoke returned HTTP ${status}.`;
+	const message = typeof error?.message === "string" ? error.message : `Caplets attach ${endpoint} returned HTTP ${status}.`;
 	const thrown = new Error(message);
 	thrown.status = status;
 	if (error && "code" in error) thrown.code = error.code;
@@ -81577,14 +82923,23 @@ function attachPayloadError(payload, status) {
 function isAttachManifestStale(error) {
 	return isPlainObject(error) && error.code === "ATTACH_MANIFEST_STALE";
 }
-function startAttachEvents(attachUrl, requestInit, fetchImpl, listeners, onClose) {
+function isAttachSessionNotFound(error) {
+	return error.code === "REQUEST_INVALID" && /\battach session was not found\b/iu.test(errorMessage$1(error));
+}
+function isAttachSessionProjectContextRejected(payload) {
+	const error = isPlainObject(payload) && isPlainObject(payload.error) ? payload.error : void 0;
+	return error?.code === "REQUEST_INVALID" && typeof error.message === "string" && /\bproject context is only accepted by loopback runtimes\b/iu.test(error.message);
+}
+function startAttachEvents(attachUrl, requestInit, attachSessionId, fetchImpl, listeners, onClose) {
 	const abort = new AbortController();
 	let retry = true;
 	(async () => {
 		try {
+			const headers = attachHeaders(requestInit, attachSessionId);
 			const response = await fetchImpl(new URL("events", slashUrl(attachUrl)), {
 				...requestInit,
 				method: "GET",
+				headers,
 				signal: abort.signal
 			});
 			if (!response.ok) {
@@ -81711,6 +83066,119 @@ function isPermanentRemoteCredentialsCode(code) {
 	return code === "remote_credentials_required" || code === "remote_credentials_revoked" || code === "remote_auth_failed";
 }
 //#endregion
+//#region src/exposure/namespace.ts
+function resolveNamespaceExposure(entries, options = {}) {
+	const hashLength = options.hashLength ?? 4;
+	const maxHashLength = options.maxHashLength ?? 8;
+	const groups = groupByBaseId(entries);
+	const visibleRecords = [];
+	const suppressedBareIds = /* @__PURE__ */ new Map();
+	const unavailableDiagnostics = [];
+	const reservedBareIds = new Set(groups.keys());
+	for (const [baseId, group] of groups) {
+		if (group.length === 1) {
+			visibleRecords.push(visibleRecord(group[0], baseId, false));
+			continue;
+		}
+		if (!isNamespaceCollisionGroup(group)) {
+			visibleRecords.push(visibleRecord(nonNamespaceWinner(group), baseId, false));
+			continue;
+		}
+		const diagnostics = validateNamespaceGroup(baseId, group);
+		if (diagnostics.length > 0) {
+			unavailableDiagnostics.push(...diagnostics);
+			continue;
+		}
+		const resolved = qualifyNamespaceGroup(group, {
+			baseId,
+			hashLength,
+			maxHashLength,
+			reservedBareIds
+		});
+		if ("diagnostic" in resolved) {
+			unavailableDiagnostics.push(resolved.diagnostic);
+			continue;
+		}
+		visibleRecords.push(...resolved.records);
+		suppressedBareIds.set(baseId, diagnostic(baseId, "namespace_collision", group, resolved.records.map((record) => record.id)));
+	}
+	return {
+		visibleRecords,
+		routes: new Map(visibleRecords.map((record) => [record.id, record.route])),
+		suppressedBareIds,
+		unavailableDiagnostics
+	};
+}
+function groupByBaseId(entries) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) groups.set(entry.baseId, [...groups.get(entry.baseId) ?? [], entry]);
+	return groups;
+}
+function isNamespaceCollisionGroup(group) {
+	const upstreams = group.filter((entry) => entry.sourceKind === "upstream");
+	return upstreams.length > 0 && upstreams.every((entry) => entry.shadowing === "namespace");
+}
+function nonNamespaceWinner(group) {
+	const forbiddingUpstream = group.find((entry) => entry.sourceKind === "upstream" && entry.shadowing === "forbid");
+	if (forbiddingUpstream) return forbiddingUpstream;
+	const local = group.find((entry) => entry.sourceKind === "local");
+	if (local) return local;
+	return group.find((entry) => entry.sourceKind === "upstream") ?? group[0];
+}
+function validateNamespaceGroup(baseId, group) {
+	const diagnostics = [];
+	for (const entry of group) {
+		if (!entry.durableSourceIdentity) {
+			diagnostics.push(diagnostic(baseId, "missing_durable_source_identity", group, []));
+			break;
+		}
+		if (entry.namespaceAlias && !NAMESPACE_ALIAS_LABEL_PATTERN.test(entry.namespaceAlias)) {
+			diagnostics.push(diagnostic(baseId, "namespace_alias_invalid", group, []));
+			break;
+		}
+	}
+	return diagnostics;
+}
+function qualifyNamespaceGroup(group, options) {
+	const ids = group.map((entry) => qualifiedId(entry, options.baseId, options.hashLength));
+	if (!(new Set(ids).size !== ids.length || ids.some((id) => options.reservedBareIds.has(id) || !SERVER_ID_PATTERN.test(id)))) return { records: group.map((entry, index) => visibleRecord(entry, ids[index], true)) };
+	return { diagnostic: diagnostic(options.baseId, "generated_id_collision", group, []) };
+}
+function qualifiedId(entry, baseId, hashLength) {
+	return `${namespaceLabel(entry)}-${createHash("sha256").update(entry.durableSourceIdentity ?? "").digest("hex").slice(0, hashLength)}__${baseId}`;
+}
+function visibleRecord(entry, id, namespaced) {
+	return {
+		...entry,
+		id,
+		label: namespaceLabel(entry),
+		namespaced
+	};
+}
+function namespaceLabel(entry) {
+	return entry.namespaceAlias ?? entry.sourceLabel ?? entry.sourceKind;
+}
+function diagnostic(requestedId, reason, group, alternatives) {
+	return {
+		requestedId,
+		reason,
+		alternatives,
+		sources: group.map((entry) => ({
+			sourceKind: entry.sourceKind,
+			label: namespaceLabel(entry),
+			...entry.durableSourceIdentity ? { durableSourceIdentity: entry.durableSourceIdentity } : {}
+		})),
+		hint: diagnosticHint(requestedId, reason, alternatives)
+	};
+}
+function diagnosticHint(requestedId, reason, alternatives) {
+	if (reason === "namespace_collision") return `Caplet '${requestedId}' is unavailable because namespace shadowing exposes qualified alternatives: ${alternatives.join(", ")}.`;
+	if (reason === "missing_durable_source_identity") return `Caplet '${requestedId}' could not be namespaced because at least one source has no durable identity.`;
+	if (reason === "namespace_alias_invalid") return `Caplet '${requestedId}' could not be namespaced because an alias label is invalid.`;
+	if (reason === "unsupported_protocol") return `Caplet '${requestedId}' could not be namespaced because a source protocol cannot represent namespace metadata.`;
+	return `Caplet '${requestedId}' could not be namespaced because generated qualified IDs were not unique.`;
+}
+//#endregion
 //#region src/cloud-auth/errors.ts
 const SECRET_PATTERN = /(cap_access_[a-z0-9._~+/=-]+|cap_refresh_[a-z0-9._~+/=-]+|one_time_code_[a-z0-9._~+/=-]+|Bearer\s+)[^\s"]*/giu;
 function redactCloudAuthSecrets(value) {
@@ -82852,7 +84320,11 @@ var DefaultNativeCapletsService = class {
 		this.writeErr = options.writeErr ?? (() => void 0);
 		this.engine = new CapletsEngine({
 			...options,
-			writeErr: this.writeErr
+			writeErr: this.writeErr,
+			telemetrySurface: options.telemetrySurface ?? "native",
+			telemetryVisibility: options.telemetryVisibility ?? "hidden",
+			telemetryRuntimeMode: options.telemetryRuntimeMode ?? runtimeModeFromNativeOptions(options),
+			telemetryIntegration: options.telemetryIntegration ?? "native"
 		});
 		this.postReloadRefresh = this.refreshExposureSnapshot({ emitToolsChanged: this.hasSnapshotBackedDirectExposure() });
 		this.unsubscribeEngineReload = this.engine.onReload(() => {
@@ -82883,7 +84355,16 @@ var DefaultNativeCapletsService = class {
 		];
 	}
 	async execute(capletId, request) {
-		if (capletId === "code_mode") return await executeCodeModeRunNative(this.codeModeDelegate(), request, this.codeModeSessions);
+		if (capletId === "code_mode") {
+			const started = Date.now();
+			const envelope = await executeCodeModeRunNative(this.codeModeDelegate(), request, this.codeModeSessions);
+			const parsed = codeModeRunInputSchema.safeParse(request);
+			this.engine.captureCodeModeOutcome(envelope, {
+				started,
+				...parsed.success && parsed.data.timeoutMs !== void 0 ? { timeoutMs: parsed.data.timeoutMs } : {}
+			}).catch(() => void 0);
+			return envelope;
+		}
 		const route = this.directToolRoutes.get(capletId);
 		if (route) {
 			if (isMcpPrimitiveRoute(route.operationName)) return await this.engine.execute(route.capletId, nativeMcpPrimitiveRequest(route.operationName, request));
@@ -82891,6 +84372,9 @@ var DefaultNativeCapletsService = class {
 		}
 		return await this.engine.execute(capletId, request);
 	}
+	async captureCodeModeOutcome(envelope, options) {
+		await this.engine.captureCodeModeOutcome(envelope, options);
+	}
 	codeModeService() {
 		return this.codeModeDelegate();
 	}
@@ -83111,9 +84595,39 @@ function nativeMcpPrimitiveRequest(operationName, request) {
 	};
 	return { operation: operationName };
 }
+function operationFromNativeRequest(request) {
+	return isRecord(request) ? request.operation : void 0;
+}
 function isRecord(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function runtimeModeFromNativeOptions(options) {
+	if (options.mode === "local") return "local";
+	if (options.mode === "remote") return "remote";
+	if (options.mode === "cloud") return "cloud";
+	if (options.remote?.url) return "remote";
+	const envMode = options.telemetryEnv?.CAPLETS_MODE ?? process.env.CAPLETS_MODE;
+	if (envMode === "remote" || envMode === "cloud" || envMode === "local") return envMode;
+	return "local";
+}
+function telemetryConfigFromNativeOptions(options) {
+	const configPath = resolveConfigPath(options.configPath);
+	const config = createLocalOverlayConfigLoader(options)(configPath, options.projectConfigPath ?? resolveProjectConfigPath());
+	const explicitTelemetry = readTelemetryOnlyConfig(configPath);
+	return explicitTelemetry === void 0 ? config : {
+		...config,
+		telemetry: explicitTelemetry
+	};
+}
+function readTelemetryOnlyConfig(path) {
+	if (!existsSync(path)) return void 0;
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? typeof parsed.telemetry === "boolean" ? parsed.telemetry : void 0 : void 0;
+	} catch {
+		return;
+	}
+}
 function codeModeRunNativeTool(capletTools) {
 	const codeModeCaplets = capletTools.map((tool) => ({
 		id: tool.caplet,
@@ -83197,7 +84711,7 @@ function createLocalOverlayService(options) {
 }
 function createCompositeRemoteService(remoteOptions, local, options, authKind) {
 	const { remote, presence } = createCompositeRemoteParts(remoteOptions, local, options, authKind);
-	return new CompositeNativeCapletsService(remote, local, options, presence);
+	return new CompositeNativeCapletsService(remote, local, options, remoteOptions.url.toString(), presence);
 }
 function createCompositeRemoteParts(remoteOptions, local, options, authKind, resolveRuntimeRemoteOptions) {
 	const remote = new RemoteNativeCapletsService({
@@ -83207,7 +84721,7 @@ function createCompositeRemoteParts(remoteOptions, local, options, authKind, res
 		authKind,
 		...options.writeErr ? { writeErr: options.writeErr } : {}
 	});
-	const presence = createProjectBindingSessionManager(remoteOptions.cloud, local, options);
+	const presence = createProjectBindingSessionManager(remoteOptions.cloud, remoteOptions, local, options);
 	return {
 		remote,
 		...presence ? { presence } : {}
@@ -83215,13 +84729,33 @@ function createCompositeRemoteParts(remoteOptions, local, options, authKind, res
 }
 function createRemoteClient(remoteOptions, options, authKind, resolveRuntimeRemoteOptions) {
 	if (options.remoteClientFactory) return options.remoteClientFactory(remoteOptions);
+	const attachSessionMetadata = isLoopbackRemote(remoteOptions) ? attachSessionMetadataForOptions(options) : void 0;
 	return createSdkRemoteCapletsClient({
 		...remoteOptions,
 		authKind,
 		...options.writeErr ? { writeErr: options.writeErr } : {},
+		...attachSessionMetadata ? { attachSessionMetadata } : {},
 		...resolveRuntimeRemoteOptions ? { resolveRuntimeOptions: resolveRuntimeRemoteOptions } : {}
 	});
 }
+function attachSessionMetadataForOptions(options) {
+	if (!options.projectRoot) return void 0;
+	const projectRoot = canonicalProjectRootForMetadata(options.projectRoot);
+	return {
+		projectRoot,
+		projectConfigPath: resolve(projectRoot, ".caplets", "config.json")
+	};
+}
+function canonicalProjectRootForMetadata(projectRoot) {
+	try {
+		return realpathSync(projectRoot);
+	} catch {
+		return projectRoot;
+	}
+}
+function isLoopbackRemote(remoteOptions) {
+	return remoteOptions.url.protocol === "http:" && isLoopbackHost(remoteOptions.url.hostname);
+}
 var ProfileBackedNativeCapletsService = class {
 	options;
 	baseRemote;
@@ -83289,7 +84823,7 @@ var ProfileBackedNativeCapletsService = class {
 			const signature = remoteOptionsSignature(remoteOptions);
 			if (!this.delegate) {
 				const { remote, presence } = createCompositeRemoteParts(remoteOptions, this.local, this.options, this.authKind, () => this.resolveProfileRemoteOptions());
-				this.delegate = new CompositeNativeCapletsService(remote, this.local, this.options, presence);
+				this.delegate = new CompositeNativeCapletsService(remote, this.local, this.options, remoteOptions.url.toString(), presence);
 				this.unsubscribeDelegate = this.delegate.onToolsChanged((tools) => this.emit(tools));
 				this.remoteSignature = signature;
 				this.credentialExpiresAt = remoteOptions.credentialExpiresAt;
@@ -83301,7 +84835,7 @@ var ProfileBackedNativeCapletsService = class {
 				await Promise.all([remote.close(), presence?.close()]);
 				return;
 			}
-			await this.delegate.replaceRemote(remote, presence);
+			await this.delegate.replaceRemote(remote, remoteOptions.url.toString(), presence);
 			this.remoteSignature = signature;
 			this.credentialExpiresAt = remoteOptions.credentialExpiresAt;
 		} catch (error) {
@@ -83386,23 +84920,44 @@ var CompositeNativeCapletsService = class {
 	remote;
 	local;
 	options;
+	remoteIdentity;
 	presence;
 	listeners = /* @__PURE__ */ new Set();
 	unsubscribeRemote;
 	unsubscribeLocal;
 	warnedShadowedLocalCaplets = /* @__PURE__ */ new Set();
 	tools = [];
+	routes = /* @__PURE__ */ new Map();
+	namespaceDiagnostics = /* @__PURE__ */ new Map();
 	closed = false;
 	batchingReload = false;
 	codeModeSessions = new CodeModeSessionManager();
-	constructor(remote, local, options, presence) {
+	telemetry;
+	ownsTelemetryDispatcher;
+	constructor(remote, local, options, remoteIdentity, presence) {
 		this.remote = remote;
 		this.local = local;
 		this.options = options;
+		this.remoteIdentity = remoteIdentity;
 		this.presence = presence;
 		this.unsubscribeRemote = this.remote.onToolsChanged(() => this.updateMergedTools());
 		this.unsubscribeLocal = this.local.onToolsChanged(() => this.updateMergedTools());
-		this.tools = this.mergeTools();
+		this.ownsTelemetryDispatcher = options.telemetryDispatcher === void 0;
+		this.telemetry = createRuntimeTelemetryContext({
+			config: telemetryConfigFromNativeOptions(options),
+			env: options.telemetryEnv,
+			stateDir: options.telemetryStateDir,
+			surface: options.telemetrySurface ?? "native",
+			visibility: options.telemetryVisibility ?? "hidden",
+			runtimeMode: options.telemetryRuntimeMode ?? runtimeModeFromNativeOptions(options),
+			integration: options.telemetryIntegration ?? "native",
+			debugSink: options.telemetryDebugSink,
+			dispatcher: options.telemetryDispatcher
+		});
+		const merged = this.mergeTools();
+		this.tools = merged.tools;
+		this.routes = merged.routes;
+		this.namespaceDiagnostics = merged.namespaceDiagnostics;
 		this.startPresence();
 	}
 	listTools() {
@@ -83410,8 +84965,12 @@ var CompositeNativeCapletsService = class {
 	}
 	async execute(capletId, request) {
 		if (capletId === "code_mode") return await executeCodeModeRunNative(this, request, this.codeModeSessions);
-		if (this.localCanExecute(capletId)) return await this.local.execute(capletId, request);
-		return await this.remote.execute(capletId, request);
+		const route = this.routes.get(capletId);
+		if (route?.service === "local") return await this.local.execute(route.capletId, request);
+		if (route?.service === "remote") return await this.executeRemote(route.capletId, request);
+		const diagnostic = this.namespaceDiagnostics.get(capletId);
+		if (diagnostic) throw new CapletsError("CAPLET_NAMESPACE_COLLISION", diagnostic.hint, diagnostic);
+		return await this.executeRemote(capletId, request);
 	}
 	codeModeService() {
 		return {
@@ -83431,6 +84990,8 @@ var CompositeNativeCapletsService = class {
 		this.batchingReload = false;
 		if (remoteReloaded === void 0 || localReloaded === void 0) return false;
 		if (localReloaded) await this.presence?.updateAllowedCapletIds(this.local.listTools().map((tool) => tool.caplet));
+		this.telemetry.config = telemetryConfigFromNativeOptions(this.options);
+		this.startPresence();
 		this.updateMergedTools();
 		return remoteReloaded || localReloaded;
 	}
@@ -83448,19 +85009,23 @@ var CompositeNativeCapletsService = class {
 		await Promise.all([
 			this.remote.close(),
 			this.local.close(),
-			this.presence?.close()
+			this.presence?.close(),
+			this.ownsTelemetryDispatcher ? this.telemetry.dispatcher.shutdown() : void 0
 		]);
 	}
-	async replaceRemote(remote, presence) {
+	async replaceRemote(remote, remoteIdentityOrPresence, presence) {
+		const remoteIdentity = typeof remoteIdentityOrPresence === "string" ? remoteIdentityOrPresence : this.remoteIdentity;
+		const nextPresence = typeof remoteIdentityOrPresence === "string" ? presence : remoteIdentityOrPresence;
 		if (this.closed) {
-			await Promise.all([remote.close(), presence?.close()]);
+			await Promise.all([remote.close(), nextPresence?.close()]);
 			return;
 		}
 		const previousRemote = this.remote;
 		const previousPresence = this.presence;
 		this.unsubscribeRemote();
 		this.remote = remote;
-		this.presence = presence;
+		this.remoteIdentity = remoteIdentity;
+		this.presence = nextPresence;
 		this.unsubscribeRemote = this.remote.onToolsChanged(() => this.updateMergedTools());
 		await Promise.all([previousRemote.close(), previousPresence?.close()]);
 		if (this.closed) return;
@@ -83469,30 +85034,145 @@ var CompositeNativeCapletsService = class {
 	}
 	updateMergedTools() {
 		if (this.closed || this.batchingReload) return;
-		const tools = this.mergeTools();
-		if (JSON.stringify(tools) === JSON.stringify(this.tools)) return;
-		this.tools = tools;
+		const merged = this.mergeTools();
+		if (JSON.stringify(merged.tools) === JSON.stringify(this.tools)) {
+			this.routes = merged.routes;
+			this.namespaceDiagnostics = merged.namespaceDiagnostics;
+			return;
+		}
+		this.tools = merged.tools;
+		this.routes = merged.routes;
+		this.namespaceDiagnostics = merged.namespaceDiagnostics;
 		for (const listener of this.listeners) try {
 			listener(this.listTools());
 		} catch (error) {
 			writeErr(this.options, `Caplets tools-changed listener failed: ${errorMessage(error)}\n`);
 		}
 	}
+	async executeRemote(capletId, request) {
+		const started = Date.now();
+		try {
+			const result = await this.remote.execute(capletId, request);
+			this.captureRemoteToolActivation(request, result, started);
+			return result;
+		} catch (error) {
+			const result = errorResult(error);
+			this.captureRemoteReliabilityError(request, result);
+			this.captureRemoteToolActivation(request, result, started);
+			throw error;
+		}
+	}
+	captureRemoteToolActivation(request, result, started) {
+		captureRuntimeTelemetryEvent(this.telemetry, "caplets_tool_activation", {
+			command_family: "native",
+			...toolActivationProperties({
+				config: this.telemetry.config,
+				caplet: void 0,
+				operation: operationFromNativeRequest(request),
+				exposureMode: "direct",
+				result,
+				durationMs: Date.now() - started
+			})
+		}).catch(() => void 0);
+	}
+	captureRemoteReliabilityError(request, result) {
+		captureRuntimeReliabilityEvent(this.telemetry, {
+			command_family: "native",
+			...runtimeFailureTelemetryProperties({
+				operation: operationFromNativeRequest(request),
+				exposureMode: "direct",
+				result
+			})
+		}).catch(() => void 0);
+	}
 	mergeTools() {
 		const allLocalTools = this.local.listTools();
 		const allRemoteTools = this.remote.listTools();
 		const remoteCodeModeTools = remoteCodeModeCallableNativeTools(allRemoteTools);
 		const remoteIds = remoteSuppressedCapletIds(allRemoteTools, remoteCodeModeTools);
-		const localTools = allLocalTools.filter((tool) => tool.codeModeRun !== true && !remoteIds.has(tool.sourceCaplet ?? tool.caplet));
+		const unsuppressedLocalTools = allLocalTools.filter((tool) => tool.codeModeRun !== true && !remoteIds.has(tool.sourceCaplet ?? tool.caplet));
 		this.warnShadowedLocalCaplets(allLocalTools, remoteIds);
-		const localCodeModeTools = codeModeCallableNativeTools(allLocalTools, { fallbackToVisible: false }).filter((tool) => !remoteIds.has(tool.caplet));
-		const mergedTools = [...allRemoteTools.filter((tool) => tool.codeModeRun !== true), ...localTools];
-		const codeModeTools = [...remoteCodeModeTools, ...localCodeModeTools];
-		return [...mergedTools, ...codeModeTools.length > 0 ? [codeModeRunNativeTool(codeModeTools)] : []];
+		const unsuppressedLocalCodeModeTools = codeModeCallableNativeTools(allLocalTools, { fallbackToVisible: false }).filter((tool) => !remoteIds.has(tool.caplet));
+		const remoteTools = allRemoteTools.filter((tool) => tool.codeModeRun !== true);
+		const resolved = this.resolveVisibleToolIds(remoteTools, unsuppressedLocalTools, remoteCodeModeTools, unsuppressedLocalCodeModeTools);
+		const codeModeTools = [...resolved.remoteCodeModeTools, ...resolved.localCodeModeTools];
+		return {
+			tools: [
+				...resolved.remoteTools,
+				...resolved.localTools,
+				...codeModeTools.length > 0 ? [codeModeRunNativeTool(codeModeTools)] : []
+			],
+			routes: resolved.routes,
+			namespaceDiagnostics: resolved.namespaceDiagnostics
+		};
 	}
-	localCanExecute(capletId) {
-		const remoteIds = remoteSuppressedCapletIds(this.remote.listTools());
-		return localExecutionKeys(this.local.listTools(), capletId).some((key) => !remoteIds.has(key));
+	resolveVisibleToolIds(remoteTools, localTools, remoteCodeModeTools, localCodeModeTools) {
+		const resolution = resolveNamespaceExposure(nativeNamespaceEntries([{
+			service: "remote",
+			tools: [...remoteTools, ...remoteCodeModeTools]
+		}, {
+			service: "local",
+			tools: [...localTools, ...localCodeModeTools]
+		}], {
+			...nativeNamespaceContext(this.options),
+			remoteIdentity: this.remoteIdentity
+		}));
+		const namespacedRecords = resolution.visibleRecords.filter((record) => record.namespaced);
+		const namespacedBaseIds = new Set(namespacedRecords.map((record) => record.baseId));
+		const diagnosticBaseIds = new Set(resolution.unavailableDiagnostics.map((diagnostic) => diagnostic.requestedId));
+		const routes = /* @__PURE__ */ new Map();
+		const namespaceDiagnostics = new Map(resolution.suppressedBareIds);
+		for (const diagnostic of resolution.unavailableDiagnostics) namespaceDiagnostics.set(diagnostic.requestedId, diagnostic);
+		const alternativesByBaseId = /* @__PURE__ */ new Map();
+		const staleIdsByBaseId = /* @__PURE__ */ new Map();
+		const setRoute = (visibleCapletId, route, overwrite) => {
+			if (overwrite || !routes.has(visibleCapletId)) routes.set(visibleCapletId, route);
+		};
+		const rewrite = (service, tools, overwrite) => {
+			const rewritten = [];
+			for (const tool of tools) {
+				const baseId = sourceBaseId(tool);
+				if (diagnosticBaseIds.has(baseId)) continue;
+				if (!namespacedBaseIds.has(baseId)) {
+					rewritten.push(tool);
+					setRoute(tool.caplet, {
+						service,
+						capletId: tool.caplet
+					}, overwrite);
+					continue;
+				}
+				const record = namespacedRecords.find((candidate) => candidate.baseId === baseId && candidate.route.service === service);
+				if (!record) continue;
+				const visibleTool = renameNativeTool(tool, record.id);
+				rewritten.push(visibleTool);
+				addMapSetValue(alternativesByBaseId, baseId, visibleTool.caplet);
+				if (tool.caplet !== visibleTool.caplet) addMapSetValue(staleIdsByBaseId, baseId, tool.caplet);
+				setRoute(visibleTool.caplet, {
+					service,
+					capletId: tool.caplet
+				}, overwrite);
+			}
+			return rewritten;
+		};
+		const remoteVisibleTools = rewrite("remote", remoteTools, false);
+		const localVisibleTools = rewrite("local", localTools, true);
+		const remoteVisibleCodeModeTools = rewrite("remote", remoteCodeModeTools, false);
+		const localVisibleCodeModeTools = rewrite("local", localCodeModeTools, true);
+		for (const [baseId, alternatives] of alternativesByBaseId) {
+			const baseDiagnostic = resolution.suppressedBareIds.get(baseId);
+			if (!baseDiagnostic) continue;
+			const alternativeList = [...alternatives];
+			namespaceDiagnostics.set(baseId, namespaceDiagnosticWithAlternatives(baseId, baseDiagnostic, alternativeList));
+			for (const staleId of staleIdsByBaseId.get(baseId) ?? []) namespaceDiagnostics.set(staleId, namespaceDiagnosticWithAlternatives(staleId, baseDiagnostic, alternativeList));
+		}
+		return {
+			remoteTools: remoteVisibleTools,
+			localTools: localVisibleTools,
+			remoteCodeModeTools: remoteVisibleCodeModeTools,
+			localCodeModeTools: localVisibleCodeModeTools,
+			routes,
+			namespaceDiagnostics
+		};
 	}
 	warnShadowedLocalCaplets(localTools, remoteIds) {
 		const localIds = /* @__PURE__ */ new Set([...localTools.filter((tool) => tool.codeModeRun !== true).map((tool) => tool.sourceCaplet ?? tool.caplet), ...codeModeCallableNativeTools(localTools, { fallbackToVisible: false }).map((tool) => tool.caplet)]);
@@ -83513,47 +85193,256 @@ var CompositeNativeCapletsService = class {
 	}
 	startPresence() {
 		this.presence?.start().catch((error) => {
-			writeErr(this.options, `Could not register Caplets Cloud Project Binding: ${errorMessage(error)}\n`);
+			writeErr(this.options, `Could not start upstream Project Binding: ${errorMessage(error)}\n`);
 		});
 	}
 };
+function addMapSetValue(map, key, value) {
+	let values = map.get(key);
+	if (!values) {
+		values = /* @__PURE__ */ new Set();
+		map.set(key, values);
+	}
+	values.add(value);
+}
+function namespaceDiagnosticWithAlternatives(requestedId, diagnostic, alternatives) {
+	return {
+		...diagnostic,
+		requestedId,
+		alternatives,
+		hint: `Caplet '${requestedId}' is unavailable because namespace shadowing exposes qualified alternatives: ${alternatives.join(", ")}.`
+	};
+}
+function nativeNamespaceContext(options) {
+	const configPath = options.configPath ?? resolveConfigPath();
+	const projectConfigPath = options.projectConfigPath ?? resolveProjectConfigPath();
+	let namespaceAliases = parseConfig({}).namespaceAliases;
+	try {
+		namespaceAliases = loadLocalOverlayConfigWithSources(configPath, projectConfigPath).config.namespaceAliases;
+	} catch {}
+	return {
+		localIdentity: `local:${configPath}\0${projectConfigPath}`,
+		namespaceAliases
+	};
+}
+function nativeNamespaceEntries(groups, identities) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const group of groups) {
+		const byBaseId = /* @__PURE__ */ new Map();
+		for (const tool of group.tools) {
+			const baseId = sourceBaseId(tool);
+			byBaseId.set(baseId, [...byBaseId.get(baseId) ?? [], tool]);
+		}
+		for (const [baseId, tools] of byBaseId) {
+			const service = group.service;
+			entries.set(`${service}:${baseId}`, {
+				baseId,
+				sourceKind: service === "local" ? "local" : "upstream",
+				sourceLabel: service === "local" ? "local" : "remote",
+				namespaceAlias: service === "local" ? identities.namespaceAliases.local : identities.namespaceAliases.upstreams[identities.remoteIdentity],
+				durableSourceIdentity: service === "local" ? identities.localIdentity : identities.remoteIdentity,
+				shadowing: aggregateShadowing(tools),
+				route: {
+					service,
+					baseId
+				}
+			});
+		}
+	}
+	return [...entries.values()];
+}
+function aggregateShadowing(tools) {
+	if (tools.some((tool) => (tool.shadowing ?? "forbid") === "forbid")) return "forbid";
+	if (tools.some((tool) => tool.shadowing === "namespace")) return "namespace";
+	return "allow";
+}
+function sourceBaseId(tool) {
+	return tool.sourceCaplet ?? tool.caplet;
+}
+function renameNativeTool(tool, visibleBaseId) {
+	const baseId = sourceBaseId(tool);
+	const visibleCapletId = tool.sourceCaplet && tool.caplet.startsWith(`${baseId}__`) ? `${visibleBaseId}${tool.caplet.slice(baseId.length)}` : visibleBaseId;
+	const operationName = tool.sourceCaplet && tool.caplet.startsWith(`${baseId}__`) ? tool.caplet.slice(baseId.length + 2) : void 0;
+	const toolName = operationName ? nativeDirectToolName(visibleBaseId, operationName) : nativeCapletToolName(visibleCapletId);
+	return {
+		...tool,
+		caplet: visibleCapletId,
+		...tool.sourceCaplet ? { sourceCaplet: visibleBaseId } : {},
+		toolName
+	};
+}
 function remoteCodeModeCallableNativeTools(tools) {
 	return codeModeCallableNativeTools(tools, { fallbackToVisible: true });
 }
 function remoteSuppressedCapletIds(allRemoteTools, remoteCodeModeTools = remoteCodeModeCallableNativeTools(allRemoteTools)) {
-	return new Set([...allRemoteTools.filter((tool) => tool.codeModeRun !== true && tool.shadowing !== "allow").map((tool) => tool.sourceCaplet ?? tool.caplet), ...remoteCodeModeTools.filter((tool) => tool.shadowing !== "allow").map((tool) => tool.caplet)].filter((caplet) => caplet !== nativeCodeModeToolId));
+	return new Set([...allRemoteTools.filter((tool) => tool.codeModeRun !== true && (tool.shadowing ?? "forbid") === "forbid").map((tool) => tool.sourceCaplet ?? tool.caplet), ...remoteCodeModeTools.filter((tool) => (tool.shadowing ?? "forbid") === "forbid").map((tool) => tool.caplet)].filter((caplet) => caplet !== nativeCodeModeToolId));
+}
+function createProjectBindingSessionManager(cloud, remoteOptions, local, options) {
+	const allowedCapletIds = local.listTools().map((tool) => tool.caplet);
+	if (cloud) {
+		const projectRoot = cloud.projectRoot ?? findProjectRoot();
+		const cloudFetch = options.remote?.fetch;
+		return new ProjectBindingSessionManager({
+			client: new CapletsCloudClient({
+				baseUrl: cloud.url,
+				accessToken: cloud.accessToken,
+				...cloudFetch ? { fetch: cloudFetch } : {}
+			}),
+			workspaceId: cloud.workspaceId,
+			projectRoot,
+			projectFingerprint: fingerprintProjectRoot(projectRoot),
+			projectFiles: projectSyncFiles(projectRoot),
+			allowedCapletIds,
+			heartbeatIntervalMs: cloud.heartbeatIntervalMs,
+			onError: (error) => {
+				writeErr(options, `Caplets Cloud Project Binding heartbeat failed: ${errorMessage(error)}\n`);
+			}
+		});
+	}
+	if (!options.projectRoot || !isLoopbackRemote(remoteOptions)) return;
+	return new RemoteProjectBindingSessionManager({
+		attachUrl: remoteOptions.url,
+		requestInit: remoteOptions.requestInit,
+		fetch: remoteOptions.fetch,
+		projectRoot: options.projectRoot,
+		allowedCapletIds,
+		heartbeatIntervalMs: 3e4,
+		writeErr: options.writeErr
+	});
 }
-function localExecutionKeys(tools, capletId) {
-	const keys = [];
-	for (const tool of tools) {
-		if (tool.codeModeRun) {
-			for (const caplet of tool.codeModeCaplets ?? []) if (caplet.id === capletId) keys.push(caplet.id);
-			continue;
+var RemoteProjectBindingSessionManager = class {
+	options;
+	bindingId;
+	sessionId;
+	allowedCapletIds;
+	heartbeatTimer;
+	startPromise;
+	unsupported = false;
+	constructor(options) {
+		this.options = options;
+		this.allowedCapletIds = [...options.allowedCapletIds];
+	}
+	async start() {
+		if (this.unsupported) return;
+		if (!this.startPromise) {
+			const start = this.register();
+			this.startPromise = start;
+			start.catch((error) => {
+				if (isUnsupportedProjectBinding(error)) this.unsupported = true;
+				if (this.startPromise === start) this.startPromise = void 0;
+			});
 		}
-		if (tool.caplet === capletId || tool.sourceCaplet === capletId) keys.push(tool.sourceCaplet ?? tool.caplet);
+		return await this.startPromise;
 	}
-	return keys;
-}
-function createProjectBindingSessionManager(cloud, local, options) {
-	if (!cloud) return;
-	const projectRoot = cloud.projectRoot ?? findProjectRoot();
-	const cloudFetch = options.remote?.fetch;
-	return new ProjectBindingSessionManager({
-		client: new CapletsCloudClient({
-			baseUrl: cloud.url,
-			accessToken: cloud.accessToken,
-			...cloudFetch ? { fetch: cloudFetch } : {}
-		}),
-		workspaceId: cloud.workspaceId,
-		projectRoot,
-		projectFingerprint: fingerprintProjectRoot(projectRoot),
-		projectFiles: projectSyncFiles(projectRoot),
-		allowedCapletIds: local.listTools().map((tool) => tool.caplet),
-		heartbeatIntervalMs: cloud.heartbeatIntervalMs,
-		onError: (error) => {
-			writeErr(options, `Caplets Cloud Project Binding heartbeat failed: ${errorMessage(error)}\n`);
+	async close() {
+		await this.startPromise?.catch(() => void 0);
+		this.stopHeartbeat();
+		const bindingId = this.bindingId;
+		this.bindingId = void 0;
+		const sessionId = this.sessionId;
+		this.sessionId = void 0;
+		if (!bindingId || !sessionId) return;
+		await this.fetchJson(projectBindingUrl(this.options.attachUrl, bindingId, "session"), {
+			method: "DELETE",
+			body: {
+				sessionId,
+				terminalReason: {
+					code: "completed",
+					message: "Binding Session completed."
+				}
+			}
+		}).catch(() => void 0);
+	}
+	async updateAllowedCapletIds(allowedCapletIds) {
+		this.allowedCapletIds = [...allowedCapletIds];
+		await this.startPromise?.catch(() => void 0);
+		if (!this.bindingId || !this.sessionId) return;
+		await this.heartbeat().catch(() => void 0);
+	}
+	async register() {
+		const projectFingerprint = fingerprintProjectRoot(this.options.projectRoot);
+		const response = await this.fetchJson(projectBindingUrl(this.options.attachUrl, "sessions"), {
+			method: "POST",
+			body: {
+				projectRoot: this.options.projectRoot,
+				projectFingerprint,
+				allowedCapletIds: this.allowedCapletIds
+			}
+		});
+		if (!response.binding?.bindingId || !response.sessionId) throw new CapletsError("SERVER_UNAVAILABLE", "Project Binding session response was invalid.");
+		this.bindingId = response.binding.bindingId;
+		this.sessionId = response.sessionId;
+		this.startHeartbeat();
+	}
+	startHeartbeat() {
+		this.stopHeartbeat();
+		this.heartbeatTimer = setInterval(() => {
+			this.heartbeat().catch((error) => {
+				this.disconnect();
+				this.options.writeErr?.(`Remote Project Binding heartbeat failed: ${errorMessage(error)}\n`);
+			});
+		}, this.options.heartbeatIntervalMs);
+		this.heartbeatTimer.unref?.();
+	}
+	stopHeartbeat() {
+		if (!this.heartbeatTimer) return;
+		clearInterval(this.heartbeatTimer);
+		this.heartbeatTimer = void 0;
+	}
+	disconnect() {
+		this.stopHeartbeat();
+		this.bindingId = void 0;
+		this.sessionId = void 0;
+		this.startPromise = void 0;
+	}
+	async heartbeat() {
+		if (!this.bindingId || !this.sessionId) return;
+		await this.fetchJson(projectBindingUrl(this.options.attachUrl, this.bindingId, "heartbeat"), {
+			method: "POST",
+			body: {
+				sessionId: this.sessionId,
+				state: "ready",
+				syncState: "idle",
+				allowedCapletIds: this.allowedCapletIds
+			}
+		});
+	}
+	async fetchJson(url, input) {
+		const headers = new Headers(this.options.requestInit.headers);
+		headers.set("content-type", "application/json");
+		const response = await (this.options.fetch ?? fetch)(url, {
+			...this.options.requestInit,
+			method: input.method,
+			headers,
+			body: JSON.stringify(input.body)
+		});
+		if (!response.ok) {
+			let payload;
+			try {
+				payload = await response.json();
+			} catch {
+				payload = void 0;
+			}
+			const error = isRecord(payload) && isRecord(payload.error) ? payload.error : void 0;
+			if (error?.code === "UNSUPPORTED_CAPABILITY" && typeof error.message === "string") throw new CapletsError("UNSUPPORTED_CAPABILITY", error.message);
+			throw new CapletsError("SERVER_UNAVAILABLE", `Project Binding request failed (${response.status}).`);
 		}
-	});
+		return await response.json().catch(() => ({}));
+	}
+};
+function isUnsupportedProjectBinding(error) {
+	return isRecord(error) && error.code === "UNSUPPORTED_CAPABILITY";
+}
+function projectBindingUrl(attachUrl, ...segments) {
+	const url = new URL(attachUrl);
+	url.pathname = [
+		url.pathname.replace(/\/+$/u, ""),
+		"project-bindings",
+		...segments.map(encodeURIComponent)
+	].join("/");
+	url.search = "";
+	url.hash = "";
+	return url;
 }
 function createLocalOverlayConfigLoader(options) {
 	let hasLoaded = false;
@@ -83591,4 +85480,4 @@ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-export { resolveExposure as $, mergeCapabilities as $t, nativeCapletPromptGuidance as A, isJSONRPCRequest as An, runOAuthFlow as At, CodeModeSessionManager as B, safeParse as Bn, defaultConfigBaseDir as Bt, resolveHostedCloudRemote as C, ReadResourceRequestSchema as Cn, validateCapletFile as Ct, isLoopbackHost as D, assertCompleteRequestResourceTemplate as Dn, markdownStructuredContent as Dt, controlUrlForBase as E, assertCompleteRequestPrompt as En, markdownCallToolResultContent as Et, nativeCodeModeToolName as F, getSchemaDescription as Fn, readTokenBundle as Ft, CodeModeJournalStore as G, resolveProjectCapletsRoot as Gt, diagnoseCodeModeTypeScript as H, __exportAll as Hn, defaultStateBaseDir as Ht, codeModeRunInputSchema as I, isSchemaOptional as In, DEFAULT_AUTH_DIR as It, codeModeDeclarationHash as J, serializeMessage as Jt, CodeModeLogStore as K, resolveProjectConfigPath as Kt, codeModeRunParamsSchema as L, isZ4Schema as Ln, DEFAULT_COMPLETION_CACHE_DIR as Lt, nativeCapletToolName as M, getLiteralValue as Mn, startOAuthFlow as Mt, nativeCapletsSystemGuidance as N, getObjectShape as Nn, deleteTokenBundle as Nt, parseServerBaseUrl as O, isInitializeRequest as On, refreshOAuthTokenBundle as Ot, nativeCodeModeToolId as P, getParseErrorMessage as Pn, isTokenBundleExpired as Pt, CapletsEngine as Q, Protocol as Qt, emptyCodeModeRunMeta as R, normalizeObjectSchema as Rn, DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR as Rt, resolveCapletsRemote as S, McpError as Sn, discoverCapletFiles as St, appendBasePath as T, SetLevelRequestSchema as Tn, hasRenderableStructuredContent as Tt, createCodeModeCapletsApi as U, resolveCapletsRoot as Ut, QuickJsCodeModeSandbox as V, safeParseAsync as Vn, defaultConfigPath as Vt, listCodeModeCallableCaplets as W, resolveConfigPath as Wt, generateCodeModeRunToolDescription as X, assertToolsCallTaskCapability as Xt, generateCodeModeDeclarations as Y, assertClientRequestTaskCapability as Yt, minifyCodeModeDeclarationText as Z, AjvJsonSchemaValidator as Zt, CapletsCloudClient as _, ListResourceTemplatesRequestSchema as _n, FileVaultStore as _t, CloudAuthStore as a, CreateMessageResultWithToolsSchema as an, ServerRegistry as at, isCapletsCloudUrl as b, ListToolsRequestSchema as bn, decryptVaultValue as bt, redactedCloudAuthStatus as c, ElicitResultSchema as cn, loadConfig as ct, projectBindingError as d, GetPromptRequestSchema as dn, loadLocalOverlayConfigWithSources as dt, toJsonSchemaCompat as en, decodeDirectResourceUri as et, projectBindingRecovery as f, InitializeRequestSchema as fn, loadProjectConfig as ft, buildProjectSyncManifest as g, ListPromptsRequestSchema as gn, vaultStoreForAuthDir as gt, createSdkRemoteCapletsClient as h, LATEST_PROTOCOL_VERSION as hn, vaultResolverForAuthDir as ht, createRemoteProfileStore as i, CreateMessageResultSchema as in, handleServerTool as it, nativeCapletToolDescription as j, isJSONRPCResultResponse as jn, startGenericOAuthFlow as jt, resolveCapletsServer as k, isJSONRPCErrorResponse as kn, runGenericOAuthFlow as kt, PROJECT_BINDING_ERROR_CODES as l, EmptyResultSchema as ln, loadConfigWithSources as lt, RemoteNativeCapletsService as m, JSONRPCMessageSchema as mn, vaultBootstrapResolver as mt, resolveRemoteSelection as n, CallToolResultSchema as nn, findProjectRoot as nt, cloudAuthPath as o, CreateTaskResultSchema as on, capabilityDescription as ot, CloudAuthClient as p, InitializedNotificationSchema as pn, parseConfig as pt, redactCodeModeLogText as q, ReadBuffer as qt, cloudCredentialsFromRemoteProfile as r, CompleteRequestSchema as rn, fingerprintProjectRoot as rt, migrateCredentials as s, DEFAULT_NEGOTIATED_PROTOCOL_VERSION as sn, GoogleDiscoveryManager as st, createNativeCapletsService as t, CallToolRequestSchema as tn, directResourceUriMatchesTemplate as tt, ProjectBindingError as u, ErrorCode as un, loadGlobalConfig as ut, resolveNativeCapletsServiceOptions as v, ListResourcesRequestSchema as vn, VAULT_MAX_VALUE_BYTES as vt, resolveRemoteMode as w, SUPPORTED_PROTOCOL_VERSIONS as wn, loadCapletFilesFromMap as wt, normalizeRemoteProfileHostUrl as x, LoggingLevelSchema as xn, encryptVaultValue as xt, hostedCloudWorkspaceFromRemoteUrl as y, ListRootsResultSchema as yn, validateVaultKeyName as yt, runCodeMode as z, objectFromShape as zn, defaultCacheBaseDir as zt };
+export { redactCodeModeLogText as $, getParseErrorMessage as $n, readTokenBundle as $t, resolveRemoteMode as A, GetPromptRequestSchema as An, loadProjectConfig as At, nativeCodeModeToolId as B, LoggingLevelSchema as Bn, discoverCapletFiles as Bt, CapletsCloudClient as C, CreateMessageResultSchema as Cn, ServerRegistry as Ct, normalizeRemoteProfileHostUrl as D, ElicitResultSchema as Dn, loadConfigWithSources as Dt, isCapletsCloudUrl as E, DEFAULT_NEGOTIATED_PROTOCOL_VERSION as En, loadConfig as Et, resolveCapletsServer as F, ListPromptsRequestSchema as Fn, FileVaultStore as Ft, runCodeMode as G, assertCompleteRequestPrompt as Gn, markdownStructuredContent as Gt, codeModeRunInputSchema as H, ReadResourceRequestSchema as Hn, loadCapletFilesFromMap as Ht, nativeCapletPromptGuidance as I, ListResourceTemplatesRequestSchema as In, VAULT_MAX_VALUE_BYTES as It, diagnoseCodeModeTypeScript as J, isJSONRPCErrorResponse as Jn, runOAuthFlow as Jt, CodeModeSessionManager as K, assertCompleteRequestResourceTemplate as Kn, refreshOAuthTokenBundle as Kt, nativeCapletToolDescription as L, ListResourcesRequestSchema as Ln, validateVaultKeyName as Lt, controlUrlForBase as M, InitializedNotificationSchema as Mn, vaultBootstrapResolver as Mt, isLoopbackHost as N, JSONRPCMessageSchema as Nn, vaultResolverForAuthDir as Nt, resolveCapletsRemote as O, EmptyResultSchema as On, loadGlobalConfig as Ot, parseServerBaseUrl as P, LATEST_PROTOCOL_VERSION as Pn, vaultStoreForAuthDir as Pt, CodeModeLogStore as Q, getObjectShape as Qn, isTokenBundleExpired as Qt, nativeCapletToolName as R, ListRootsResultSchema as Rn, decryptVaultValue as Rt, buildProjectSyncManifest as S, CompleteRequestSchema as Sn, handleServerTool as St, hostedCloudWorkspaceFromRemoteUrl as T, CreateTaskResultSchema as Tn, GoogleDiscoveryManager as Tt, codeModeRunParamsSchema as U, SUPPORTED_PROTOCOL_VERSIONS as Un, hasRenderableStructuredContent as Ut, nativeCodeModeToolName as V, McpError as Vn, validateCapletFile as Vt, emptyCodeModeRunMeta as W, SetLevelRequestSchema as Wn, markdownCallToolResultContent as Wt, listCodeModeCallableCaplets as X, isJSONRPCResultResponse as Xn, startOAuthFlow as Xt, createCodeModeCapletsApi as Y, isJSONRPCRequest as Yn, startGenericOAuthFlow as Yt, CodeModeJournalStore as Z, getLiteralValue as Zn, deleteTokenBundle as Zt, attachErrorResponse as _, Protocol as _n, rotateTelemetryIdentity as _t, CloudAuthStore as a, defaultConfigPath as an, safeParse as ar, version as at, invokeAttachExport$1 as b, CallToolRequestSchema as bn, findProjectRoot as bt, redactedCloudAuthStatus as c, resolveCapletsRoot as cn, buildProductTelemetryEvent as ct, projectBindingError as d, resolveProjectConfigPath as dn, maybePrintTelemetryNotice as dt, DEFAULT_AUTH_DIR as en, getSchemaDescription as er, codeModeDeclarationHash as et, projectBindingRecovery as f, ReadBuffer as fn, resolveTelemetryState as ft, CAPLETS_ATTACH_SESSION_HEADER as g, AjvJsonSchemaValidator as gn, readTelemetryNotice as gt, createSdkRemoteCapletsClient as h, assertToolsCallTaskCapability as hn, readTelemetryIdentity as ht, createRemoteProfileStore as i, defaultConfigBaseDir as in, objectFromShape as ir, CapletsEngine as it, appendBasePath as j, InitializeRequestSchema as jn, parseConfig as jt, resolveHostedCloudRemote as k, ErrorCode as kn, loadLocalOverlayConfigWithSources as kt, PROJECT_BINDING_ERROR_CODES as l, resolveConfigPath as ln, buildReliabilityTelemetryEvent as lt, RemoteNativeCapletsService as m, assertClientRequestTaskCapability as mn, readTelemetryDeliveryHealth as mt, resolveRemoteSelection as n, DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR as nn, isZ4Schema as nr, generateCodeModeRunToolDescription as nt, cloudAuthPath as o, defaultStateBaseDir as on, safeParseAsync as or, createTelemetryDispatcher as ot, CloudAuthClient as p, serializeMessage as pn, deleteTelemetryIdentity as pt, QuickJsCodeModeSandbox as q, isInitializeRequest as qn, runGenericOAuthFlow as qt, cloudCredentialsFromRemoteProfile as r, defaultCacheBaseDir as rn, normalizeObjectSchema as rr, minifyCodeModeDeclarationText as rt, migrateCredentials as s, defaultTelemetryStateDir as sn, TelemetryDebugSink as st, createNativeCapletsService as t, DEFAULT_COMPLETION_CACHE_DIR as tn, isSchemaOptional as tr, generateCodeModeDeclarations as tt, ProjectBindingError as u, resolveProjectCapletsRoot as un, durationBucket as ut, buildAttachProjection as v, mergeCapabilities as vn, resolveExposure as vt, resolveNativeCapletsServiceOptions as w, CreateMessageResultWithToolsSchema as wn, capabilityDescription as wt, invokeNativeAttachExport as x, CallToolResultSchema as xn, fingerprintProjectRoot as xt, buildNativeAttachProjection as y, toJsonSchemaCompat as yn, decodeDirectResourceUri as yt, nativeCapletsSystemGuidance as z, ListToolsRequestSchema as zn, encryptVaultValue as zt };