@caplets/core 0.26.1 → 0.28.0

package/dist/attach/api.d.ts

@@ -1,4 +1,11 @@
 import type { CapletsEngine } from "../engine";
+import type { CapletShadowingPolicy } from "../config";
+import type { NativeCapletsService } from "../native/service";
+export declare const CAPLETS_ATTACH_SESSION_HEADER = "caplets-attach-session-id";
+export type AttachSessionMetadata = {
+    projectRoot?: string | undefined;
+    projectConfigPath?: string | undefined;
+};
 export type AttachExportKind = "caplet" | "tool" | "resource" | "resourceTemplate" | "prompt" | "completion";
 export type AttachInvokeRequest = {
     revision: string;
@@ -26,7 +33,7 @@ export type AttachManifestExport = {
     annotations?: unknown;
     schemaHash: string | null;
     capletId: string;
-    shadowing: "forbid" | "allow";
+    shadowing: CapletShadowingPolicy;
 };
 export type AttachProgressiveCapletExport = AttachManifestExport & {
     kind: "caplet";
@@ -104,6 +111,8 @@ export type AttachProjection = {
     routes: Map<string, AttachRoute>;
 };
 export declare function buildAttachProjection(engine: CapletsEngine): Promise<AttachProjection>;
+export declare function buildNativeAttachProjection(service: NativeCapletsService): Promise<AttachProjection>;
+export declare function invokeNativeAttachExport(service: NativeCapletsService, projection: AttachProjection, request: AttachInvokeRequest): Promise<unknown>;
 export declare function invokeAttachExport(engine: CapletsEngine, projection: AttachProjection, request: AttachInvokeRequest): Promise<unknown>;
 export declare function attachErrorResponse(error: unknown): {
     status: 400 | 404 | 409 | 500;

package/dist/caplet-files-bundle.d.ts

@@ -454,6 +454,7 @@ export declare const capletFileSchema: z.ZodObject<{
     shadowing: z.ZodOptional<z.ZodEnum<{
         forbid: "forbid";
         allow: "allow";
+        namespace: "namespace";
     }>>;
 }, z.core.$strict>;
 export declare function capletJsonSchema(): unknown;

package/dist/caplet-source.js

@@ -10031,6 +10031,7 @@ function superRefine(fn, params) {
 //#endregion
 //#region src/config/validation.ts
 const SERVER_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
+const NAMESPACE_ALIAS_LABEL_PATTERN = /^[a-z](?:[a-z0-9-]{0,30}[a-z0-9])?$/;
 const HEADER_NAME_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
 const HTTP_BASE_URL_PATTERN = /^(?![a-zA-Z][a-zA-Z0-9+.-]*:\/\/[^/?#]*@)[^?#]*$/;
 const FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
@@ -10169,7 +10170,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({ type: literal("none") }).strict(),
 	object({
@@ -10849,7 +10854,11 @@ const exposureSchema = _enum([
 	"direct_and_code_mode",
 	"progressive_and_code_mode"
 ]);
-const shadowingSchema = _enum(["forbid", "allow"]).default("forbid");
+const shadowingSchema = _enum([
+	"forbid",
+	"allow",
+	"namespace"
+]).default("forbid");
 const commonSchema = {
 	name: string().trim().min(1).max(80),
 	description: string().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"),
@@ -10988,6 +10997,28 @@ const capletSetSchema = object({
 	maxSearchLimit: number().int().positive().max(50).default(50),
 	toolCacheTtlMs: number().int().nonnegative().default(3e4)
 }).strict();
+const namespaceAliasLabelSchema = string().regex(NAMESPACE_ALIAS_LABEL_PATTERN, "namespace alias labels must be lowercase DNS-style labels using letters, numbers, or hyphens");
+const namespaceAliasesSchema = object({
+	local: namespaceAliasLabelSchema.optional(),
+	upstreams: record(string().trim().min(1), namespaceAliasLabelSchema).default({})
+}).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]);
+});
 const configSchema = object({
 	version: literal(1).default(1),
 	defaultSearchLimit: number().int().positive().default(20),
@@ -11018,7 +11049,8 @@ const configSchema = object({
 	graphqlEndpoints: record(string().regex(SERVER_ID_PATTERN), graphQlEndpointSchema).default({}),
 	httpApis: record(string().regex(SERVER_ID_PATTERN), httpApiSchema).default({}),
 	cliTools: record(string().regex(SERVER_ID_PATTERN), cliToolsSchema).default({}),
-	capletSets: record(string().regex(SERVER_ID_PATTERN), capletSetSchema).default({})
+	capletSets: record(string().regex(SERVER_ID_PATTERN), capletSetSchema).default({}),
+	namespaceAliases: namespaceAliasesSchema
 }).strict().superRefine((config, ctx) => {
 	if (config.defaultSearchLimit > config.maxSearchLimit) ctx.addIssue({
 		code: "custom",
@@ -11041,6 +11073,10 @@ function parseConfig(input) {
 			exposureDiscoveryConcurrency: config.options.exposureDiscoveryConcurrency,
 			completion: config.completion
 		},
+		namespaceAliases: stripUndefined({
+			local: config.namespaceAliases.local,
+			upstreams: config.namespaceAliases.upstreams
+		}),
 		mcpServers: mapBackend(config.mcpServers, "mcp", (id, raw) => {
 			const server = raw;
 			return {

package/dist/cli/code-mode.d.ts

@@ -3,6 +3,7 @@ export type CodeModeCliOptions = {
     configPath?: string | undefined;
     projectConfigPath?: string | undefined;
     authDir?: string | undefined;
+    telemetryStateDir?: string | undefined;
     inlineCode?: string | undefined;
     file?: string | undefined;
     timeoutMs?: number | undefined;
@@ -14,6 +15,6 @@ export type CodeModeCliOptions = {
     setExitCode: (code: number) => void;
 };
 export declare function runCodeModeCli(options: CodeModeCliOptions): Promise<void>;
-export declare function runCodeModeReplCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "sessionId" | "recoveryRef" | "json" | "writeOut" | "setExitCode">): Promise<void>;
-export declare function codeModeTypesCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "json" | "writeOut">): Promise<void>;
+export declare function runCodeModeReplCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "telemetryStateDir" | "sessionId" | "recoveryRef" | "json" | "writeOut" | "setExitCode">): Promise<void>;
+export declare function codeModeTypesCli(options: Pick<CodeModeCliOptions, "env" | "configPath" | "projectConfigPath" | "authDir" | "telemetryStateDir" | "json" | "writeOut">): Promise<void>;
 export declare function readCodeModeCliCode(options: Pick<CodeModeCliOptions, "inlineCode" | "file" | "readStdin">): Promise<string>;

package/dist/cli/commands.d.ts

@@ -32,8 +32,9 @@ export declare const cliCommands: {
     readonly config: "config";
     readonly auth: "auth";
     readonly vault: "vault";
+    readonly telemetry: "telemetry";
 };
-export declare const topLevelCommandNames: readonly ["serve", "daemon", "code-mode", "attach", "remote", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "vault", "completion"];
+export declare const topLevelCommandNames: readonly ["serve", "daemon", "code-mode", "attach", "remote", "cloud", "init", "setup", "doctor", "list", "install", "add", "inspect", "check-backend", "list-tools", "search-tools", "get-tool", "call-tool", "list-resources", "search-resources", "list-resource-templates", "read-resource", "list-prompts", "search-prompts", "get-prompt", "complete", "config", "auth", "vault", "telemetry", "completion"];
 export declare const cliSubcommands: {
     readonly add: readonly ["cli", "mcp", "openapi", "google-discovery", "graphql", "http"];
     readonly auth: readonly ["login", "logout", "list", "refresh"];
@@ -44,6 +45,7 @@ export declare const cliSubcommands: {
     readonly config: readonly ["path", "paths"];
     readonly daemon: readonly ["install", "uninstall", "start", "restart", "stop", "status", "logs"];
     readonly setup: readonly ["codex", "claude-code", "opencode", "pi", "mcp-client"];
+    readonly telemetry: readonly ["status", "enable", "disable", "delete-id", "rotate-id", "debug"];
     readonly vault: readonly ["set", "get", "list", "delete", "access"];
 };
 export declare const cliNestedSubcommands: {

package/dist/cli/inspection.d.ts

@@ -1,4 +1,4 @@
-import { type CapletConfig, type ConfigSource, type ConfigWithSources } from "../config";
+import { type CapletConfig, type CapletShadowingPolicy, type ConfigSource, type ConfigWithSources } from "../config";
 import type { ServerStatus } from "../registry";
 type CapletListRow = {
     server: string;
@@ -10,6 +10,7 @@ type CapletListRow = {
     source: ConfigSource["kind"] | "remote" | "unknown";
     path: string | null;
     shadows: ConfigSource[];
+    shadowing?: CapletShadowingPolicy | undefined;
 };
 type ConfigPaths = {
     userConfig: string;

package/dist/cli.d.ts

@@ -4,6 +4,7 @@ import { type AttachServeOptions } from "./attach/options";
 import type { ProjectBindingWebSocketFactory } from "./project-binding/transport";
 import { type DaemonOperationOptions } from "./daemon";
 import { type ServeOptions } from "./serve";
+import { TelemetryDebugSink } from "./telemetry";
 export { initConfig, starterConfig } from "./cli/init";
 export { installCaplets, normalizeGitRepo } from "./cli/install";
 export { addCliCaplet, addGoogleDiscoveryCaplet, addGraphqlCaplet, addHttpCaplet, addMcpCaplet, addOpenApiCaplet, } from "./cli/add";
@@ -15,6 +16,9 @@ type CliIO = {
     signal?: AbortSignal;
     projectBindingWebSocketFactory?: ProjectBindingWebSocketFactory;
     authDir?: string;
+    telemetryStateDir?: string;
+    stderrIsTTY?: boolean;
+    telemetryDebugSink?: TelemetryDebugSink;
     version?: string;
     setExitCode?: (code: number) => void;
     serve?: (options: ServeOptions) => Promise<void>;

package/dist/code-mode/types.d.ts

@@ -6,7 +6,7 @@ export type CodeModeCallableCaplet = {
     id: string;
     name: string;
     description: string;
-    shadowing?: "forbid" | "allow";
+    shadowing?: "forbid" | "allow" | "namespace";
     useWhen?: string;
     avoidWhen?: string;
 };
@@ -35,6 +35,7 @@ export type CodeModeRunMeta = {
     durationMs: number;
     timeoutMs: number;
     maxTimeoutMs: number;
+    anyCapletInvoked: boolean;
     sessionId?: string | null;
     sessionStatus?: CodeModeSessionStatus | null;
     recoveryRef?: string | null;

package/dist/{completion-CFOJucl5.js → completion-CjE0EnbF.js}

@@ -1,5 +1,6 @@
-import { Hn as __exportAll, It as DEFAULT_AUTH_DIR, Kt as resolveProjectConfigPath, Lt as DEFAULT_COMPLETION_CACHE_DIR, Ut as resolveCapletsRoot, Wt as resolveConfigPath, lt as loadConfigWithSources } from "./service-aBIn4nrw.js";
-import { u as CapletsError } from "./validation-GD2x5HW1.js";
+import { r as __exportAll } from "./rolldown-runtime-CE-6LUnI.js";
+import { Dt as loadConfigWithSources, cn as resolveCapletsRoot, dn as resolveProjectConfigPath, en as DEFAULT_AUTH_DIR, ln as resolveConfigPath, tn as DEFAULT_COMPLETION_CACHE_DIR } from "./service-BfPCRxQ9.js";
+import { d as CapletsError } from "./validation-CWzd2gtn.js";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
@@ -42,7 +43,8 @@ const cliCommands = {
 	complete: "complete",
 	config: "config",
 	auth: "auth",
-	vault: "vault"
+	vault: "vault",
+	telemetry: "telemetry"
 };
 const topLevelCommandNames = [
 	cliCommands.serve,
@@ -74,6 +76,7 @@ const topLevelCommandNames = [
 	cliCommands.config,
 	cliCommands.auth,
 	cliCommands.vault,
+	cliCommands.telemetry,
 	cliCommands.completion
 ];
 const cliSubcommands = {
@@ -117,6 +120,14 @@ const cliSubcommands = {
 		"pi",
 		"mcp-client"
 	],
+	[cliCommands.telemetry]: [
+		"status",
+		"enable",
+		"disable",
+		"delete-id",
+		"rotate-id",
+		"debug"
+	],
 	[cliCommands.vault]: [
 		"set",
 		"get",
@@ -165,7 +176,8 @@ function listCaplets(configWithSources, options) {
 		status: initialServerStatus(server),
 		source: sources[server.server]?.kind ?? "unknown",
 		path: sources[server.server]?.path ?? null,
-		shadows: shadows[server.server] ?? []
+		shadows: shadows[server.server] ?? [],
+		shadowing: server.shadowing
 	})).sort((left, right) => left.server.localeCompare(right.server));
 }
 function initialServerStatus(server) {

package/dist/config/paths.d.ts

@@ -5,17 +5,26 @@ export declare function defaultStateBaseDir(env?: PathEnv, home?: string, platfo
 export declare function defaultCacheBaseDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultConfigPath(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultAuthDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultTelemetryStateDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultTelemetryIdentityPath(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultTelemetryNoticePath(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultTelemetryDeliveryHealthPath(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultArtifactDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultCompletionCacheDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultObservedOutputShapeCacheDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare const DEFAULT_CONFIG_PATH: string;
 export declare const DEFAULT_AUTH_DIR: string;
 export declare const DEFAULT_ARTIFACT_DIR: string;
+export declare const DEFAULT_TELEMETRY_STATE_DIR: string;
+export declare const DEFAULT_TELEMETRY_IDENTITY_PATH: string;
+export declare const DEFAULT_TELEMETRY_NOTICE_PATH: string;
+export declare const DEFAULT_TELEMETRY_DELIVERY_HEALTH_PATH: string;
 export declare const DEFAULT_COMPLETION_CACHE_DIR: string;
 export declare const DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR: string;
 export declare const PROJECT_CONFIG_FILE: string;
 export declare function resolveConfigPath(path?: string): string;
 export declare function resolveProjectConfigPath(cwd?: string): string;
 export declare function resolveCapletsRoot(configPath?: string): string;
+export declare function resolveTelemetryStateDir(path?: string): string;
 export declare function resolveProjectCapletsRoot(cwd?: string): string;
 export {};

package/dist/config/validation.d.ts

@@ -1,4 +1,5 @@
 export declare const SERVER_ID_PATTERN: RegExp;
+export declare const NAMESPACE_ALIAS_LABEL_PATTERN: RegExp;
 export declare const HEADER_NAME_PATTERN: RegExp;
 export declare const HTTP_BASE_URL_PATTERN: RegExp;
 export declare const FORBIDDEN_HEADERS: Set<string>;
@@ -10,6 +11,7 @@ type ValidationIssueSink = {
     }): void;
 };
 export declare function validateHttpActionHeaders(headers: Record<string, unknown>, ctx: ValidationIssueSink, path: Array<string>): void;
+export declare function isValidNamespaceAliasLabel(value: string): boolean;
 export declare function isAllowedRemoteUrl(value: string): boolean;
 export declare function isAllowedHttpBaseUrl(value: string): boolean;
 export declare function isUrl(value: string): boolean;

package/dist/config-runtime.d.ts

@@ -49,7 +49,7 @@ export type AgentSelectionHintsConfig = {
     avoidWhen?: string | undefined;
 };
 export type CapletExposure = "direct" | "progressive" | "code_mode" | "direct_and_code_mode" | "progressive_and_code_mode";
-export type CapletShadowingPolicy = "forbid" | "allow";
+export type CapletShadowingPolicy = "forbid" | "allow" | "namespace";
 export type CapletServerConfig = CommonCapletConfig & {
     backend: "mcp";
     transport: "stdio" | "http" | "sse";
@@ -157,6 +157,10 @@ export type CapletSetConfig = CommonCapletConfig & {
     toolCacheTtlMs: number;
 };
 export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GoogleDiscoveryApiConfig | GraphQlEndpointConfig | HttpApiConfig | CliToolsConfig | CapletSetConfig;
+export type NamespaceAliasesConfig = {
+    local?: string | undefined;
+    upstreams: Record<string, string>;
+};
 export type CapletsConfig = {
     version: 1;
     options: {
@@ -172,6 +176,7 @@ export type CapletsConfig = {
             negativeCacheTtlMs: number;
         };
     };
+    namespaceAliases: NamespaceAliasesConfig;
     mcpServers: Record<string, CapletServerConfig>;
     openapiEndpoints: Record<string, OpenApiEndpointConfig>;
     googleDiscoveryApis: Record<string, GoogleDiscoveryApiConfig>;

package/dist/config-runtime.js

@@ -1,5 +1,5 @@
 import { _ as record, b as unknown, d as literal, l as discriminatedUnion, m as object, o as array, p as number, r as _enum, s as boolean, v as string, y as union } from "./schemas-BoqMu4MG.js";
-import { a as isAllowedHttpBaseUrl, c as validateHttpActionHeaders, i as SERVER_ID_PATTERN, n as HEADER_NAME_PATTERN, o as isAllowedRemoteUrl, 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, i as NAMESPACE_ALIAS_LABEL_PATTERN, l as validateHttpActionHeaders, n as HEADER_NAME_PATTERN, o as isAllowedHttpBaseUrl, r as HTTP_BASE_URL_PATTERN, s as isAllowedRemoteUrl, t as FORBIDDEN_HEADERS } from "./validation-CWzd2gtn.js";
 //#region src/config-runtime.ts
 const stringMapSchema = record(string(), string());
 const authSchema = discriminatedUnion("type", [
@@ -49,7 +49,11 @@ const exposureSchema = _enum([
 	"direct_and_code_mode",
 	"progressive_and_code_mode"
 ]);
-const shadowingSchema = _enum(["forbid", "allow"]).default("forbid");
+const shadowingSchema = _enum([
+	"forbid",
+	"allow",
+	"namespace"
+]).default("forbid");
 const commonSchema = {
 	name: string().trim().min(1).max(80),
 	description: string().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"),
@@ -188,6 +192,28 @@ const capletSetSchema = object({
 	maxSearchLimit: number().int().positive().max(50).default(50),
 	toolCacheTtlMs: number().int().nonnegative().default(3e4)
 }).strict();
+const namespaceAliasLabelSchema = string().regex(NAMESPACE_ALIAS_LABEL_PATTERN, "namespace alias labels must be lowercase DNS-style labels using letters, numbers, or hyphens");
+const namespaceAliasesSchema = object({
+	local: namespaceAliasLabelSchema.optional(),
+	upstreams: record(string().trim().min(1), namespaceAliasLabelSchema).default({})
+}).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]);
+});
 const configSchema = object({
 	version: literal(1).default(1),
 	defaultSearchLimit: number().int().positive().default(20),
@@ -218,7 +244,8 @@ const configSchema = object({
 	graphqlEndpoints: record(string().regex(SERVER_ID_PATTERN), graphQlEndpointSchema).default({}),
 	httpApis: record(string().regex(SERVER_ID_PATTERN), httpApiSchema).default({}),
 	cliTools: record(string().regex(SERVER_ID_PATTERN), cliToolsSchema).default({}),
-	capletSets: record(string().regex(SERVER_ID_PATTERN), capletSetSchema).default({})
+	capletSets: record(string().regex(SERVER_ID_PATTERN), capletSetSchema).default({}),
+	namespaceAliases: namespaceAliasesSchema
 }).strict().superRefine((config, ctx) => {
 	if (config.defaultSearchLimit > config.maxSearchLimit) ctx.addIssue({
 		code: "custom",
@@ -241,6 +268,10 @@ function parseConfig(input) {
 			exposureDiscoveryConcurrency: config.options.exposureDiscoveryConcurrency,
 			completion: config.completion
 		},
+		namespaceAliases: stripUndefined({
+			local: config.namespaceAliases.local,
+			upstreams: config.namespaceAliases.upstreams
+		}),
 		mcpServers: mapBackend(config.mcpServers, "mcp", (id, raw) => {
 			const server = raw;
 			return {

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { FileVaultStore, type VaultConfigOrigin } from "./vault";
-export { DEFAULT_AUTH_DIR, DEFAULT_COMPLETION_CACHE_DIR, DEFAULT_CONFIG_PATH, PROJECT_CONFIG_FILE, defaultCacheBaseDir, defaultCompletionCacheDir, resolveCapletsRoot, resolveConfigPath, resolveProjectCapletsRoot, resolveProjectConfigPath, } from "./config/paths";
+export { DEFAULT_AUTH_DIR, DEFAULT_COMPLETION_CACHE_DIR, DEFAULT_CONFIG_PATH, DEFAULT_TELEMETRY_STATE_DIR, PROJECT_CONFIG_FILE, defaultCacheBaseDir, defaultCompletionCacheDir, defaultTelemetryStateDir, resolveCapletsRoot, resolveConfigPath, resolveProjectCapletsRoot, resolveProjectConfigPath, resolveTelemetryStateDir, } from "./config/paths";
 export type RemoteAuthConfig = {
     type: "none";
 } | {
@@ -64,7 +64,7 @@ export type AgentSelectionHintsConfig = {
     useWhen?: string | undefined;
     avoidWhen?: string | undefined;
 };
-export type CapletShadowingPolicy = "forbid" | "allow";
+export type CapletShadowingPolicy = "forbid" | "allow" | "namespace";
 export type CapletExposure = "direct" | "progressive" | "code_mode" | "direct_and_code_mode" | "progressive_and_code_mode";
 export type CapletServerConfig = AgentSelectionHintsConfig & {
     server: string;
@@ -261,6 +261,10 @@ export type CapletSetConfig = AgentSelectionHintsConfig & {
     runtime?: RuntimeRequirementsConfig | undefined;
 };
 export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GoogleDiscoveryApiConfig | GraphQlEndpointConfig | HttpApiConfig | CliToolsConfig | CapletSetConfig;
+export type NamespaceAliasesConfig = {
+    local?: string | undefined;
+    upstreams: Record<string, string>;
+};
 export type CapletsOptions = {
     defaultSearchLimit: number;
     maxSearchLimit: number;
@@ -277,7 +281,9 @@ export type CompletionConfig = {
 };
 export type CapletsConfig = {
     version: 1;
+    telemetry?: boolean | undefined;
     options: CapletsOptions;
+    namespaceAliases: NamespaceAliasesConfig;
     mcpServers: Record<string, CapletServerConfig>;
     openapiEndpoints: Record<string, OpenApiEndpointConfig>;
     googleDiscoveryApis: Record<string, GoogleDiscoveryApiConfig>;
@@ -333,6 +339,7 @@ export declare const configFileSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodLiteral<1>>;
     defaultSearchLimit: z.ZodDefault<z.ZodNumber>;
     maxSearchLimit: z.ZodDefault<z.ZodNumber>;
+    telemetry: z.ZodOptional<z.ZodBoolean>;
     completion: z.ZodDefault<z.ZodObject<{
         discoveryTimeoutMs: z.ZodDefault<z.ZodNumber>;
         overallTimeoutMs: z.ZodDefault<z.ZodNumber>;
@@ -350,6 +357,10 @@ export declare const configFileSchema: z.ZodObject<{
         exposureDiscoveryTimeoutMs: z.ZodDefault<z.ZodNumber>;
         exposureDiscoveryConcurrency: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    namespaceAliases: z.ZodDefault<z.ZodObject<{
+        local: z.ZodOptional<z.ZodString>;
+        upstreams: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
     mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     openapiEndpoints: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     googleDiscoveryApis: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;

package/dist/engine.d.ts

@@ -1,6 +1,8 @@
 import { type CapletConfig, type CapletsConfig, type LocalOverlayConfigWarning } from "./config";
 import { type ObservedOutputShapeKey, type ObservedOutputShapeStore } from "./observed-output-shapes";
 import { type ExposureSnapshot } from "./exposure/discovery";
+import { type RuntimeMode } from "./telemetry";
+import type { TelemetryDebugSink, TelemetryDispatcher, TelemetrySurface, TelemetryVisibility } from "./telemetry";
 export type CapletsEngineOptions = {
     configPath?: string;
     projectConfigPath?: string;
@@ -18,6 +20,14 @@ export type CapletsEngineOptions = {
     observedOutputShapeCacheDir?: string | undefined;
     projectFingerprint?: string | undefined;
     vaultRecoveryTarget?: "global" | "remote" | undefined;
+    telemetryStateDir?: string | undefined;
+    telemetryEnv?: NodeJS.ProcessEnv | undefined;
+    telemetrySurface?: TelemetrySurface | undefined;
+    telemetryVisibility?: TelemetryVisibility | undefined;
+    telemetryRuntimeMode?: RuntimeMode | undefined;
+    telemetryIntegration?: "opencode" | "pi" | "native" | "unknown" | undefined;
+    telemetryDebugSink?: TelemetryDebugSink | undefined;
+    telemetryDispatcher?: TelemetryDispatcher | undefined;
 };
 export type CapletsEngineReloadEvent = {
     previous: CapletsConfig;
@@ -41,6 +51,8 @@ export declare class CapletsEngine {
     private readonly observedOutputShapeStore;
     private readonly observedOutputShapeScope;
     private readonly projectFingerprint;
+    private readonly telemetry;
+    private readonly telemetryExecuteExposureMode;
     private readonly reloadListeners;
     private lastExposureSnapshot;
     private watchers;
@@ -65,6 +77,10 @@ export declare class CapletsEngine {
     readDirectResource(serverId: string, downstreamUri: string): Promise<unknown>;
     getDirectPrompt(serverId: string, promptName: string, args: Record<string, unknown>): Promise<unknown>;
     completeCliWords(words: string[]): Promise<string[]>;
+    captureCodeModeOutcome(envelope: unknown, options: {
+        started: number;
+        timeoutMs?: number | undefined;
+    }): Promise<void>;
     close(): Promise<void>;
     private listCompletionTools;
     private listTools;
@@ -80,4 +96,6 @@ export declare class CapletsEngine {
     private watchEntry;
     private watchDirectoryTree;
     private scheduleWatcherRefresh;
+    private captureReliabilityError;
+    private captureToolActivation;
 }

package/dist/errors.d.ts

@@ -1,4 +1,4 @@
-export declare const CAPLETS_ERROR_CODES: readonly ["CONFIG_NOT_FOUND", "CONFIG_EXISTS", "CONFIG_INVALID", "REQUEST_INVALID", "SERVER_NOT_FOUND", "SERVER_UNAVAILABLE", "SERVER_START_TIMEOUT", "UNKNOWN_OPERATION", "TOOL_NOT_FOUND", "TOOL_CALL_TIMEOUT", "AUTH_REQUIRED", "AUTH_FAILED", "REMOTE_CREDENTIALS_REVOKED", "AUTH_REFRESH_FAILED", "DOWNSTREAM_PROTOCOL_ERROR", "DOWNSTREAM_TOOL_ERROR", "UNSUPPORTED_OPERATION", "UNSUPPORTED_CAPABILITY", "PROMPT_NOT_FOUND", "DOWNSTREAM_RESOURCE_ERROR", "DOWNSTREAM_PROMPT_ERROR", "DOWNSTREAM_COMPLETION_ERROR", "ATTACH_MANIFEST_STALE", "ATTACH_EXPORT_NOT_FOUND", "UNSUPPORTED_TRANSPORT", "INTERNAL_ERROR"];
+export declare const CAPLETS_ERROR_CODES: readonly ["CONFIG_NOT_FOUND", "CONFIG_EXISTS", "CONFIG_INVALID", "REQUEST_INVALID", "SERVER_NOT_FOUND", "SERVER_UNAVAILABLE", "SERVER_START_TIMEOUT", "UNKNOWN_OPERATION", "CAPLET_NAMESPACE_COLLISION", "TOOL_NOT_FOUND", "TOOL_CALL_TIMEOUT", "AUTH_REQUIRED", "AUTH_FAILED", "REMOTE_CREDENTIALS_REVOKED", "AUTH_REFRESH_FAILED", "DOWNSTREAM_PROTOCOL_ERROR", "DOWNSTREAM_TOOL_ERROR", "UNSUPPORTED_OPERATION", "UNSUPPORTED_CAPABILITY", "PROMPT_NOT_FOUND", "DOWNSTREAM_RESOURCE_ERROR", "DOWNSTREAM_PROMPT_ERROR", "DOWNSTREAM_COMPLETION_ERROR", "ATTACH_MANIFEST_STALE", "ATTACH_EXPORT_NOT_FOUND", "UNSUPPORTED_TRANSPORT", "INTERNAL_ERROR"];
 export type CapletsErrorCode = (typeof CAPLETS_ERROR_CODES)[number];
 export type SafeErrorSummary = {
     code: CapletsErrorCode;