@yaklabs-ai/plugin-protocol 0.14.1 → 0.15.1

package/dist/index.js

@@ -136,38 +136,8 @@ var JsonSchema = z2.record(z2.string(), JsonValue);
 // packages/plugin-protocol/dist/common.js
 var KAY_PLUGIN_PROTOCOL_VERSION = "kay.plugin.v1";
 var KAY_PLUGIN_PROTOCOL_PACKAGE_NAME = "@bonsai/plugin-protocol";
-var KAY_PLUGIN_SDK_VERSION = "0.14.1";
-var KAY_PLUGIN_COMPATIBLE_SDK_VERSIONS = [
-  "0.8.0",
-  "0.8.1",
-  "0.8.2",
-  "0.8.3",
-  "0.8.4",
-  "0.8.5",
-  "0.9.0",
-  "0.9.1",
-  "0.10.0",
-  "0.11.0",
-  "0.11.1",
-  "0.12.0",
-  "0.12.1",
-  "0.12.2",
-  "0.12.3",
-  "0.12.4",
-  "0.12.5",
-  "0.13.0",
-  "0.13.1",
-  "0.13.2",
-  "0.13.3",
-  "0.13.4",
-  "0.13.5",
-  "0.13.6",
-  "0.13.7",
-  "0.13.8",
-  "0.13.9",
-  "0.13.10",
-  "0.14.0"
-];
+var KAY_PLUGIN_SDK_VERSION = "0.15.1";
+var KAY_PLUGIN_COMPATIBLE_SDK_VERSIONS = ["0.15.0"];
 var KAY_PLUGIN_TARGET_NAMES = [
   "kay.agent",
   "kay.app",
@@ -324,15 +294,7 @@ var SessionCreator = z5.discriminatedUnion("kind", [
     door: SdkSessionDoor,
     callerSessionId: SessionId.optional()
   }),
-  /**
-   * An automation binding that fired.
-   *
-   * `triggerKind` names what the binding matched on, and `uri-change` is in the list because a
-   * durable watcher is a real condition kind (`@bonsai/automations`'s `AutomationMatch`) with no
-   * spelling among the other four: it watches the world OUTSIDE the session, so it is neither a
-   * schedule nor a session-fact occurrence. Added 2026-08-19, when the automation producers
-   * landed and a watcher's report session had nothing honest to stamp.
-   */
+  /** An automation binding that fired; the run id links its durable execution. */
   z5.strictObject({
     kind: z5.literal("trigger"),
     automationId: NonEmptyString2,
@@ -344,7 +306,14 @@ var SessionCreator = z5.discriminatedUnion("kind", [
      */
     runId: NonEmptyString2.optional(),
     bindingName: NonEmptyString2,
-    triggerKind: z5.enum(["cron", "time", "occurrence", "uri-change", "manual"])
+    triggerKind: z5.enum([
+      "cron",
+      "time",
+      "occurrence",
+      "uri-change",
+      "plugin-event",
+      "manual"
+    ])
   }),
   /** The daemon itself, for one of its own capabilities. */
   z5.strictObject({ kind: z5.literal("daemon"), capability: NonEmptyString2 })
@@ -2350,31 +2319,83 @@ function checkKayPluginHostCompatibility(compatibility, host) {
   return { refusal: void 0, advisories };
 }
 
-// packages/plugin-protocol/dist/contributions.js
+// packages/plugin-protocol/dist/plugin-events.js
 import { z as z9 } from "zod";
+var PluginEventLocalId = z9.string().regex(/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/);
+var PluginEventUri = z9.string().refine((value) => {
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(value) || /[\s\p{Cc}\\<>"{}|^`]/u.test(value) || /%(?![a-f0-9]{2})/i.test(value))
+    return false;
+  try {
+    return new URL(value).protocol.length > 1;
+  } catch {
+    return false;
+  }
+}, { message: "Expected an absolute resource URI" });
+var PluginEventTimestamp = z9.iso.datetime().refine((value) => !/\.\d{10}/.test(value), {
+  message: "Expected an ISO instant with at most nanosecond precision"
+});
+var PluginEventRelated = z9.record(NonEmptyString, z9.union([PluginEventUri, z9.array(PluginEventUri)]));
+var PluginEventPublishSource = z9.strictObject({
+  poller: NonEmptyString.optional(),
+  runId: NonEmptyString.optional()
+});
+var PluginEventSource = z9.strictObject({
+  layer: z9.literal("runtime"),
+  pluginId: NonEmptyString,
+  sessionId: NonEmptyString.optional(),
+  ...PluginEventPublishSource.shape
+});
+var PLUGIN_EVENT_ID_MAX_BYTES = 1024;
+var PluginEventId = z9.string().min(1).refine((value) => value === value.trim() && !/\p{Cc}/u.test(value) && new TextEncoder().encode(value).length <= PLUGIN_EVENT_ID_MAX_BYTES, {
+  message: "Event identity must be control-free, unpadded, and at most 1024 UTF-8 bytes"
+});
+var PluginEventPublishInput = z9.strictObject({
+  uri: PluginEventUri,
+  related: PluginEventRelated.optional(),
+  key: PluginEventId.optional(),
+  occurredAt: PluginEventTimestamp.optional(),
+  source: PluginEventPublishSource.optional(),
+  payload: JsonValue.optional()
+});
+var PluginEventEnvelope = z9.strictObject({
+  id: PluginEventId,
+  localId: PluginEventLocalId,
+  type: GlobalContributionId,
+  version: z9.number().int().positive(),
+  uri: PluginEventUri,
+  related: PluginEventRelated.optional(),
+  key: PluginEventPublishInput.shape.key,
+  occurredAt: PluginEventTimestamp,
+  publishedAt: PluginEventTimestamp,
+  source: PluginEventSource,
+  payload: JsonValue.optional()
+});
+
+// packages/plugin-protocol/dist/contributions.js
+import { z as z10 } from "zod";
 var OptionalDisplayName = NonEmptyString.optional();
-var UriFilesystemBacking = z9.strictObject({
-  root: z9.literal("dataDir")
+var UriFilesystemBacking = z10.strictObject({
+  root: z10.literal("dataDir")
 });
-var ToolContribution = z9.strictObject({
+var ToolContribution = z10.strictObject({
   localId: LocalContributionId,
   toolName: PluginToolName,
   displayName: OptionalDisplayName,
   description: NonEmptyString.optional()
 });
-var ConverterContribution = z9.strictObject({
+var ConverterContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
   description: NonEmptyString.optional(),
   /** MIME types this converter claims — contract data for introspection and
    *  collision checks; runtime match behavior stays the converter's `matches()`. */
-  mimeTypes: z9.array(MimeTypeString).min(1),
+  mimeTypes: z10.array(MimeTypeString).min(1),
   /** Extension fallbacks (no dot) used when a probe has no usable MIME type. */
-  extensions: z9.array(FileExtensionToken).min(1).optional()
+  extensions: z10.array(FileExtensionToken).min(1).optional()
 });
-var UriModuleContribution = z9.strictObject({
+var UriModuleContribution = z10.strictObject({
   localId: LocalContributionId,
-  schemes: z9.array(UriScheme).min(1),
+  schemes: z10.array(UriScheme).min(1),
   displayName: OptionalDisplayName,
   // The plugin only requests a projection. The daemon binds the effective root
   // and retains access control at finalization.
@@ -2393,30 +2414,30 @@ var UriModuleContribution = z9.strictObject({
   // `knownResources` permission grant (`api.knownResources`). Present-means-on
   // (`true` or absent; `false` is not a state). Decision record:
   // `lab/user-plugins/decisions/014-known-resources-ledger.md`.
-  knownResources: z9.literal(true).optional()
+  knownResources: z10.literal(true).optional()
 });
 var AppUriModuleContribution = UriModuleContribution.omit({
   authService: true,
   filesystemBacking: true,
   knownResources: true
 });
-var AppDataSourceContribution = z9.strictObject({
+var AppDataSourceContribution = z10.strictObject({
   localId: LocalContributionId,
-  scope: z9.enum(["runtime", "account", "session"]),
-  snapshot: z9.strictObject({
-    version: z9.number().int().positive(),
+  scope: z10.enum(["runtime", "account", "session"]),
+  snapshot: z10.strictObject({
+    version: z10.number().int().positive(),
     schema: JsonSchema
   }),
-  change: z9.strictObject({
-    version: z9.number().int().positive(),
+  change: z10.strictObject({
+    version: z10.number().int().positive(),
     schema: JsonSchema,
     /** Review-only claim; source schemas and behavioral tests enforce it because the daemon treats changes as opaque. */
-    semantics: z9.discriminatedUnion("kind", [
-      z9.strictObject({ kind: z9.literal("incremental") }),
-      z9.strictObject({
-        kind: z9.literal("snapshot-replacement"),
-        maxEncodedBytes: z9.number().int().positive(),
-        rationale: z9.string().trim().min(1).max(1024)
+    semantics: z10.discriminatedUnion("kind", [
+      z10.strictObject({ kind: z10.literal("incremental") }),
+      z10.strictObject({
+        kind: z10.literal("snapshot-replacement"),
+        maxEncodedBytes: z10.number().int().positive(),
+        rationale: z10.string().trim().min(1).max(1024)
       })
     ]).optional()
   }),
@@ -2430,28 +2451,28 @@ var AppDataSourceContribution = z9.strictObject({
     });
   }
 });
-var WhiteboardTypeStorage = z9.discriminatedUnion("kind", [
-  z9.strictObject({ kind: z9.literal("json") }),
-  z9.strictObject({ kind: z9.literal("payload") }),
-  z9.strictObject({
-    kind: z9.literal("markdown"),
+var WhiteboardTypeStorage = z10.discriminatedUnion("kind", [
+  z10.strictObject({ kind: z10.literal("json") }),
+  z10.strictObject({ kind: z10.literal("payload") }),
+  z10.strictObject({
+    kind: z10.literal("markdown"),
     bodyField: NonEmptyString
   })
 ]);
-var WhiteboardTypeContribution = z9.strictObject({
+var WhiteboardTypeContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: NonEmptyString,
-  schemaVersion: z9.number().int().positive(),
+  schemaVersion: z10.number().int().positive(),
   storage: WhiteboardTypeStorage,
   valueSchema: JsonSchema,
-  presentation: z9.strictObject({
+  presentation: z10.strictObject({
     app: LocalContributionId
   }).optional()
 });
-var AppDataMaterializerContribution = z9.strictObject({
+var AppDataMaterializerContribution = z10.strictObject({
   source: LocalContributionId
 });
-var ArtifactUriModuleContribution = z9.strictObject({
+var ArtifactUriModuleContribution = z10.strictObject({
   localId: LocalContributionId,
   /** The single `scheme://` this module owns; also the on-disk artifact kind. */
   scheme: UriScheme,
@@ -2465,17 +2486,17 @@ var ArtifactUriModuleContribution = z9.strictObject({
    * composes its description from the plugin's own display name + scheme — a per-scheme label
    * would have no path to matter, so it is intentionally omitted rather than accepted-and-ignored.
    */
-  editable: z9.boolean().optional(),
+  editable: z10.boolean().optional(),
   /** Opt in to `list` over the kind's stored names. Default false. Mirrors
    * `CreateArtifactUriModuleOptions.listable`. */
-  listable: z9.boolean().optional(),
+  listable: z10.boolean().optional(),
   /**
    * Opt in to `delete` for same-session entries. Default false. Deletion
    * unlinks the stored file — no trash tier; a kind that wants recoverable
    * deletion is not artifact-backed. Mirrors
    * `CreateArtifactUriModuleOptions.deletable`.
    */
-  deletable: z9.boolean().optional(),
+  deletable: z10.boolean().optional(),
   /**
    * Opt in to the `{ content, mode: "append" }` write envelope, which extends
    * stored text instead of replacing it (concurrent-appender-safe: the host
@@ -2483,7 +2504,7 @@ var ArtifactUriModuleContribution = z9.strictObject({
    * keep their verbatim round-trip. Mirrors
    * `CreateArtifactUriModuleOptions.appendable`.
    */
-  appendable: z9.boolean().optional(),
+  appendable: z10.boolean().optional(),
   /**
    * Which sessions share one storage namespace. Default `"session"` — the existing
    * per-session behavior (each session gets its own kind directory; other sessions'
@@ -2494,14 +2515,14 @@ var ArtifactUriModuleContribution = z9.strictObject({
    * the scope; the host derives the family root from provenance it already holds, so
    * family identity never crosses the SDK boundary.
    */
-  storageScope: z9.enum(["session", "family"]).optional()
+  storageScope: z10.enum(["session", "family"]).optional()
 });
-var CliBindingContribution = z9.strictObject({
+var CliBindingContribution = z10.strictObject({
   localId: LocalContributionId,
   binary: CliBinaryName,
-  aliases: z9.array(CliBinaryName).optional(),
+  aliases: z10.array(CliBinaryName).optional(),
   /** Where the binary comes from. Omitted ⇒ `"vendored"` (decision 007). */
-  provider: z9.enum(["vendored", "path"]).optional(),
+  provider: z10.enum(["vendored", "path"]).optional(),
   // A local ref (no dot) must name an auth service declared in this same
   // manifest; a qualified ref (dotted, e.g. `google.account`) names another
   // plugin's already-minted global id and is recorded, not resolved, here (see
@@ -2514,20 +2535,20 @@ var CliBindingContribution = z9.strictObject({
    * MUST be absent for a `path` binding, which can never receive a token.
    */
   authEnvVar: CliAuthEnvVarName.optional(),
-  readOnly: z9.array(NonEmptyString),
-  write: z9.array(NonEmptyString)
+  readOnly: z10.array(NonEmptyString),
+  write: z10.array(NonEmptyString)
 });
-var GitHostContribution = z9.strictObject({
+var GitHostContribution = z10.strictObject({
   host: GitHostName,
   authService: LocalContributionId,
   basicAuthUser: GitBasicAuthUser
 });
-var ResourceContribution = z9.strictObject({
+var ResourceContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
   description: NonEmptyString.optional()
 });
-var SkillContribution = z9.strictObject({
+var SkillContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
   /** Model-visible one-liner: when to reach for this skill. */
@@ -2535,18 +2556,18 @@ var SkillContribution = z9.strictObject({
   /** The SKILL.md-style file inside the package carrying the full instructions. */
   path: PackageAssetPath
 });
-var PluginSkillSourceDeclaration = z9.discriminatedUnion("channel", [
-  z9.strictObject({
-    channel: z9.literal("installer"),
+var PluginSkillSourceDeclaration = z10.discriminatedUnion("channel", [
+  z10.strictObject({
+    channel: z10.literal("installer"),
     localId: LocalContributionId,
     displayName: OptionalDisplayName,
     /** The package-runner executable, e.g. `npx` — checked against the daemon's allowlist. */
     command: NonEmptyString,
     /** Its argv, e.g. `["skills", "add", "clerk/skills"]`. */
-    args: z9.array(NonEmptyString)
+    args: z10.array(NonEmptyString)
   }),
-  z9.strictObject({
-    channel: z9.literal("git-clone"),
+  z10.strictObject({
+    channel: z10.literal("git-clone"),
     localId: LocalContributionId,
     displayName: OptionalDisplayName,
     /** The repository locator — canonicalized and hygiene-checked by the daemon. */
@@ -2557,17 +2578,17 @@ var PluginSkillSourceDeclaration = z9.discriminatedUnion("channel", [
     subdir: NonEmptyString.optional()
   })
 ]);
-var SearchProviderContribution = z9.strictObject({
+var SearchProviderContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
-  schemes: z9.array(UriScheme).optional()
+  schemes: z10.array(UriScheme).optional()
 });
-var InteractionDriverContribution = z9.strictObject({
+var InteractionDriverContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
-  kind: z9.enum(["browser", "computer-use"])
+  kind: z10.enum(["browser", "computer-use"])
 });
-var EntityResolverContribution = z9.strictObject({
+var EntityResolverContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
   /** The `kay.agent` URI module (this manifest's own `contributes.uriModules[].localId`) whose
@@ -2575,24 +2596,24 @@ var EntityResolverContribution = z9.strictObject({
   uriModule: LocalContributionId,
   /** `person` | `channel` | `repo` | `pull-request` | ... -- drives avatar-first vs glyph-first row
    *  anatomy (N10-R2) and lets the renderer request a narrower `entityTypes` filter. */
-  entityTypes: z9.array(NonEmptyString).min(1),
+  entityTypes: z10.array(NonEmptyString).min(1),
   /** The URI namespace/route `search()` is called against, e.g. `slack://directory` or
    *  `github://search/repositories` -- the resolver's fixed search scope; the live user query is
    *  the `search()` call's `query` param, never concatenated into this string. */
   uriHint: NonEmptyString
 });
-var AgentRenderContribution = z9.strictObject({
+var AgentRenderContribution = z10.strictObject({
   localId: LocalContributionId,
-  resultKinds: z9.array(NonEmptyString).min(1)
+  resultKinds: z10.array(NonEmptyString).min(1)
 });
-var EndpointContribution = z9.strictObject({
+var EndpointContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
   requestSchema: JsonSchema.optional(),
   responseSchema: JsonSchema.optional()
 });
 var MCP_SERVER_LOCAL_HTTP_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
-var McpServerUrl = z9.string().trim().min(1).refine((value) => {
+var McpServerUrl = z10.string().trim().min(1).refine((value) => {
   let parsed;
   try {
     parsed = new URL(value);
@@ -2605,8 +2626,12 @@ var McpServerUrl = z9.string().trim().min(1).refine((value) => {
 }, {
   message: "mcp server url must be https://, or http:// only for localhost/127.0.0.1 test servers"
 });
-var McpServerAuthMode = z9.enum(["oauth", "none"]);
-var McpServerContribution = z9.strictObject({
+var McpServerAuthMode = z10.enum(["oauth", "api-key", "none"]);
+var MCP_SIGN_IN_SCHEME_KIND = {
+  oauth: "delegated",
+  "api-key": "api-key"
+};
+var McpServerContribution = z10.strictObject({
   url: McpServerUrl,
   auth: McpServerAuthMode.optional(),
   authService: LocalContributionId.optional()
@@ -2615,32 +2640,34 @@ var McpServerContribution = z9.strictObject({
     ctx.addIssue({
       code: "custom",
       path: ["authService"],
-      message: "oauth mcp servers must name an authService"
+      message: `${server.auth ?? "oauth"} mcp servers must name an authService`
     });
   }
 });
-var McpServerContributions = z9.record(LocalContributionId, McpServerContribution);
-var AppEventSubscription = z9.strictObject({
+var McpServerContributions = z10.record(LocalContributionId, McpServerContribution);
+var AppEventSubscription = z10.strictObject({
   localId: LocalContributionId,
   event: NonEmptyString
 });
-var ContextContributorContribution = z9.strictObject({
+var ContextContributorContribution = z10.strictObject({
   localId: LocalContributionId.max(64),
   displayName: OptionalDisplayName,
   description: NonEmptyString.optional()
 });
-var PluginEventDefinitionContribution = z9.strictObject({
-  localId: LocalContributionId,
+var PluginEventDefinitionContribution = z10.strictObject({
+  localId: PluginEventLocalId,
   displayName: OptionalDisplayName,
   description: NonEmptyString.optional(),
-  version: z9.number().int().positive().default(1),
-  payloadSchema: JsonSchema
+  version: z10.number().int().positive().default(1),
+  uriScheme: UriScheme,
+  relatedKeys: z10.array(NonEmptyString).readonly().optional(),
+  payloadSchema: JsonSchema.optional()
 });
-var PluginNotificationRuleContribution = z9.strictObject({
+var PluginNotificationRuleContribution = z10.strictObject({
   localId: LocalContributionId,
   /** The same-plugin `eventDefinitions` local id this rule matches. */
-  event: LocalContributionId,
-  where: z9.array(JsonObject).optional(),
+  event: PluginEventLocalId,
+  where: z10.array(JsonObject).optional(),
   rule: JsonObject
 });
 var PLUGIN_NOTIFICATION_RULE_HOST_KEYS = [
@@ -2648,67 +2675,67 @@ var PLUGIN_NOTIFICATION_RULE_HOST_KEYS = [
   "match",
   "sender"
 ];
-var UiEventSubscriptionContribution = z9.strictObject({
+var UiEventSubscriptionContribution = z10.strictObject({
   localId: LocalContributionId,
   event: NonEmptyString
 });
-var DeviceDelegationContribution = z9.strictObject({
+var DeviceDelegationContribution = z10.strictObject({
   localId: LocalContributionId,
-  device: z9.enum(["microphone"]),
-  delegateAs: z9.enum(["clip", "stream", "status"])
+  device: z10.enum(["microphone"]),
+  delegateAs: z10.enum(["clip", "stream", "status"])
 });
-var CorpusContribution = z9.strictObject({
+var CorpusContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
-  access: z9.enum(["read"]).default("read")
+  access: z10.enum(["read"]).default("read")
 });
-var UiCommandContribution = z9.strictObject({
+var UiCommandContribution = z10.strictObject({
   localId: LocalContributionId,
   title: NonEmptyString,
   icon: NonEmptyString.optional(),
   placement: NonEmptyString.optional()
 });
-var UiSlotContribution = z9.strictObject({
+var UiSlotContribution = z10.strictObject({
   localId: LocalContributionId,
   slot: NonEmptyString,
   title: NonEmptyString.optional()
 });
-var SettingsPanelContribution = z9.strictObject({
+var SettingsPanelContribution = z10.strictObject({
   localId: LocalContributionId,
   title: NonEmptyString,
   configSection: NonEmptyString.optional()
 });
-var ResultRendererContribution = z9.strictObject({
+var ResultRendererContribution = z10.strictObject({
   localId: LocalContributionId,
-  resultKinds: z9.array(NonEmptyString).min(1)
+  resultKinds: z10.array(NonEmptyString).min(1)
 });
-var ReferenceOpenBehavior = z9.discriminatedUnion("kind", [
-  z9.strictObject({ kind: z9.literal("working-document") }),
-  z9.strictObject({ kind: z9.literal("browser-pane") }),
+var ReferenceOpenBehavior = z10.discriminatedUnion("kind", [
+  z10.strictObject({ kind: z10.literal("working-document") }),
+  z10.strictObject({ kind: z10.literal("browser-pane") }),
   /**
    * Open one of the presenting plugin's OWN registered pages (`registerPage`'s
    * descriptor id) with the reference's canonical URI as the page's `objectId`.
    * Needs no web address, so a plugin-only resource (`user-todo://items/3`) can pill.
    */
-  z9.strictObject({ kind: z9.literal("page"), pageId: NonEmptyString })
+  z10.strictObject({ kind: z10.literal("page"), pageId: NonEmptyString })
 ]);
-var ReferencePresentationVariant = z9.strictObject({
+var ReferencePresentationVariant = z10.strictObject({
   resourceKind: NonEmptyString,
   presentationPluginId: PluginId.optional()
 });
-var ReferencePresentationVariants = z9.record(MimeTypeString, ReferencePresentationVariant);
-var InlineSvg = z9.string().max(64 * 1024).refine((value) => /^\s*(?:<\?xml[^>]*>\s*)?(?:<!--[\s\S]*?-->\s*)*(?:<!DOCTYPE[^>]*>\s*)?<svg[\s>]/iu.test(value), { message: "brandIcon must be inline SVG markup." });
-var ReferencePresentationUrlClaim = z9.strictObject({
-  kind: z9.literal("urlPattern"),
-  pattern: z9.strictObject({
-    protocol: z9.enum(["http", "https"]),
+var ReferencePresentationVariants = z10.record(MimeTypeString, ReferencePresentationVariant);
+var InlineSvg = z10.string().max(64 * 1024).refine((value) => /^\s*(?:<\?xml[^>]*>\s*)?(?:<!--[\s\S]*?-->\s*)*(?:<!DOCTYPE[^>]*>\s*)?<svg[\s>]/iu.test(value), { message: "brandIcon must be inline SVG markup." });
+var ReferencePresentationUrlClaim = z10.strictObject({
+  kind: z10.literal("urlPattern"),
+  pattern: z10.strictObject({
+    protocol: z10.enum(["http", "https"]),
     hostname: NonEmptyString,
-    pathname: z9.string().optional(),
-    search: z9.string().optional()
+    pathname: z10.string().optional(),
+    search: z10.string().optional()
   }),
   brandIcon: InlineSvg.optional()
 });
-var ReferencePresentationContribution = z9.strictObject({
+var ReferencePresentationContribution = z10.strictObject({
   localId: LocalContributionId,
   uriModule: LocalContributionId,
   resourceKind: NonEmptyString,
@@ -2716,7 +2743,7 @@ var ReferencePresentationContribution = z9.strictObject({
   /** MIME-specific resource kinds; absent keys use the base presentation. */
   variants: ReferencePresentationVariants.optional(),
   /** Lexical public URL claims used only for host-rendered browser presentations. */
-  claims: z9.array(ReferencePresentationUrlClaim).optional()
+  claims: z10.array(ReferencePresentationUrlClaim).optional()
 }).superRefine((value, ctx) => {
   if (value.claims !== void 0 && value.claims.length > 0 && value.open.kind !== "browser-pane") {
     ctx.addIssue({
@@ -2726,13 +2753,15 @@ var ReferencePresentationContribution = z9.strictObject({
     });
   }
 });
-var RichViewContribution = z9.strictObject({
+var RichViewContribution = z10.strictObject({
   localId: LocalContributionId,
   title: NonEmptyString,
   route: NonEmptyString.optional()
 });
-var KayUiAppHostCapability = z9.enum([
+var KayUiAppHostCapability = z10.enum([
   "navigation.open-session",
+  "artifacts.read",
+  "artifacts.preview",
   "cost.read",
   // Server-rated organization billing, distinct from local/provider cost.
   "billing.read",
@@ -2762,9 +2791,9 @@ var KayUiAppHostCapability = z9.enum([
   // rearrange the workspace but never remove something the user would have to notice going missing.
   "workspace.arrange"
 ]);
-var UiAppCapabilities = z9.strictObject({
-  endpoints: z9.array(LocalContributionId).optional(),
-  host: z9.array(KayUiAppHostCapability).optional()
+var UiAppCapabilities = z10.strictObject({
+  endpoints: z10.array(LocalContributionId).optional(),
+  host: z10.array(KayUiAppHostCapability).optional()
 }).superRefine((capabilities, ctx) => {
   for (const field of ["endpoints", "host"]) {
     const seen = /* @__PURE__ */ new Set();
@@ -2780,47 +2809,53 @@ var UiAppCapabilities = z9.strictObject({
     }
   }
 });
-var UiAppContribution = z9.strictObject({
+var UiAppActivityRail = z10.strictObject({
+  section: z10.enum(["primary", "plugins"]).optional(),
+  order: z10.number().finite().optional(),
+  icon: z10.union([NonEmptyString, z10.strictObject({ svg: NonEmptyString })]).optional()
+});
+var UiAppContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: NonEmptyString,
   description: NonEmptyString.optional(),
   icon: PackageAssetPath.optional(),
-  runtime: z9.literal("kay.react-app.v1"),
-  sdk: z9.strictObject({ range: NonEmptyString }),
+  runtime: z10.literal("kay.react-app.v1"),
+  sdk: z10.strictObject({ range: NonEmptyString }),
   entrypoint: TargetEntrypoint,
-  styles: z9.array(PackageAssetPath).optional(),
-  assets: z9.array(PackageAssetPath).optional(),
-  capabilities: UiAppCapabilities.optional()
+  styles: z10.array(PackageAssetPath).optional(),
+  assets: z10.array(PackageAssetPath).optional(),
+  capabilities: UiAppCapabilities.optional(),
+  activityRail: UiAppActivityRail.optional()
 });
-var ThemeContribution = z9.strictObject({
+var ThemeContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: NonEmptyString,
-  appearance: z9.enum(["light", "dark"]),
+  appearance: z10.enum(["light", "dark"]),
   tokens: PackageAssetPath
 });
-var CommandHandler = z9.discriminatedUnion("kind", [
-  z9.strictObject({ kind: z9.literal("skill"), skill: LocalContributionId }),
-  z9.strictObject({
-    kind: z9.literal("tool"),
+var CommandHandler = z10.discriminatedUnion("kind", [
+  z10.strictObject({ kind: z10.literal("skill"), skill: LocalContributionId }),
+  z10.strictObject({
+    kind: z10.literal("tool"),
     tool: PluginToolName,
     /** Positional mapping from tokenized `argsText` onto the tool's own input fields — see this
      *  union's doc for the exact tokenize/map/last-field-absorbs rule. */
-    argumentFields: z9.array(NonEmptyString)
+    argumentFields: z10.array(NonEmptyString)
   }),
-  z9.strictObject({
-    kind: z9.literal("endpoint"),
+  z10.strictObject({
+    kind: z10.literal("endpoint"),
     endpoint: LocalContributionId
   })
 ]);
-var CommandContribution = z9.strictObject({
+var CommandContribution = z10.strictObject({
   localId: LocalContributionId,
   displayName: OptionalDisplayName,
   description: NonEmptyString,
-  aliases: z9.array(LocalContributionId).optional(),
+  aliases: z10.array(LocalContributionId).optional(),
   argumentHint: NonEmptyString.optional(),
   handler: CommandHandler
 });
-var PluginContributionKind = z9.enum([
+var PluginContributionKind = z10.enum([
   "tool",
   "converter",
   "uriModule",
@@ -2875,7 +2910,7 @@ function pluginIconShape(svg) {
 }
 
 // packages/plugin-protocol/dist/manifest.js
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // packages/plugin-protocol/dist/synthetic-contributions.js
 function resolveConfigSectionContributionLocalId(section) {
@@ -2895,34 +2930,34 @@ var KAY_UI_NATIVE_EVENT_SUBSCRIPTIONS = [
   "native:renderer.contributions.changed"
 ];
 var KAY_UI_NATIVE_EVENT_ALLOWLIST = new Set(KAY_UI_NATIVE_EVENT_SUBSCRIPTIONS);
-var KayAgentTargetManifest = z10.strictObject({
+var KayAgentTargetManifest = z11.strictObject({
   entrypoint: TargetEntrypoint,
-  contributes: z10.strictObject({
-    tools: z10.array(ToolContribution).optional(),
-    converters: z10.array(ConverterContribution).optional(),
-    uriModules: z10.array(UriModuleContribution).optional(),
+  contributes: z11.strictObject({
+    tools: z11.array(ToolContribution).optional(),
+    converters: z11.array(ConverterContribution).optional(),
+    uriModules: z11.array(UriModuleContribution).optional(),
     // Host-composed artifact-backed schemes (see `ArtifactUriModuleContribution`): the plugin
     // declares scheme + editability; the daemon binds each to the kernel's artifact lifecycle
     // per session. Separate from `uriModules` (plugin-implemented backends) precisely because
     // the plugin registers NOTHING for these at activation.
-    artifactUriModules: z10.array(ArtifactUriModuleContribution).optional(),
-    cliBindings: z10.array(CliBindingContribution).optional(),
+    artifactUriModules: z11.array(ArtifactUriModuleContribution).optional(),
+    cliBindings: z11.array(CliBindingContribution).optional(),
     // Which git hosts this plugin's credential serves (see `GitHostContribution`): a
     // declaration, so a plugin for any git backend gets credentialed clones without
     // the daemon learning its name. Sibling of `cliBindings` because both answer the
     // same question — which of this plugin's auth services a host-side consumer
     // resolves — for two different transports.
-    gitHosts: z10.array(GitHostContribution).optional(),
-    resources: z10.array(ResourceContribution).optional(),
-    skills: z10.array(SkillContribution).optional(),
-    searchProviders: z10.array(SearchProviderContribution).optional(),
-    interactionDrivers: z10.array(InteractionDriverContribution).optional(),
-    entityResolvers: z10.array(EntityResolverContribution).optional(),
-    renderers: z10.array(AgentRenderContribution).optional(),
+    gitHosts: z11.array(GitHostContribution).optional(),
+    resources: z11.array(ResourceContribution).optional(),
+    skills: z11.array(SkillContribution).optional(),
+    searchProviders: z11.array(SearchProviderContribution).optional(),
+    interactionDrivers: z11.array(InteractionDriverContribution).optional(),
+    entityResolvers: z11.array(EntityResolverContribution).optional(),
+    renderers: z11.array(AgentRenderContribution).optional(),
     // Handler restricted to skill | tool by the manifest-level refinement below (see
     // `CommandContribution`'s doc for why the restriction is not expressed in the type, and
     // `CommandHandler`'s doc for why there is no promptTemplate variant to declare here).
-    commands: z10.array(CommandContribution).optional()
+    commands: z11.array(CommandContribution).optional()
   }).optional(),
   /**
    * The plugin's primer skill — the `localId` of one of its own declared
@@ -2968,55 +3003,55 @@ var KayAgentTargetManifest = z10.strictObject({
    * acquisition, not declared here, so there is nothing for the resolved contract to mint a
    * `globalId` for at parse time.
    */
-  skillSources: z10.array(PluginSkillSourceDeclaration).optional()
+  skillSources: z11.array(PluginSkillSourceDeclaration).optional()
 });
-var KayAppTargetManifest = z10.strictObject({
+var KayAppTargetManifest = z11.strictObject({
   // Optional, like `kay.ui`'s: a target may carry only declarative `contributes` (e.g. a plugin
   // that ships nothing but `mcpServers`) with no app-lifetime module for the host to load.
   entrypoint: TargetEntrypoint.optional(),
-  contributes: z10.strictObject({
+  contributes: z11.strictObject({
     // Session tools implemented by the app-lifetime activation (registered once, injected into
     // every session with a host-stamped session context) — the tool counterpart of `uriModules`
     // below. Same descriptor shape as kay.agent tools; `toolName` shares ONE flat session
     // namespace with them (enforced by the manifest-level refinement below).
-    tools: z10.array(ToolContribution).optional(),
-    endpoints: z10.array(EndpointContribution).optional(),
-    uriModules: z10.array(AppUriModuleContribution).optional(),
-    dataSources: z10.array(AppDataSourceContribution).optional(),
-    whiteboardTypes: z10.array(WhiteboardTypeContribution).optional(),
-    eventDefinitions: z10.array(PluginEventDefinitionContribution).optional(),
+    tools: z11.array(ToolContribution).optional(),
+    endpoints: z11.array(EndpointContribution).optional(),
+    uriModules: z11.array(AppUriModuleContribution).optional(),
+    dataSources: z11.array(AppDataSourceContribution).optional(),
+    whiteboardTypes: z11.array(WhiteboardTypeContribution).optional(),
+    eventDefinitions: z11.array(PluginEventDefinitionContribution).optional(),
     // Default notification rules over this plugin's own `eventDefinitions`; seeded by the host
     // (see `PluginNotificationRuleContribution`).
-    notificationRules: z10.array(PluginNotificationRuleContribution).optional(),
-    eventSubscriptions: z10.array(AppEventSubscription).optional(),
-    deviceDelegations: z10.array(DeviceDelegationContribution).optional(),
-    corpusConsumers: z10.array(CorpusContribution).optional(),
-    contextContributors: z10.array(ContextContributorContribution).optional(),
+    notificationRules: z11.array(PluginNotificationRuleContribution).optional(),
+    eventSubscriptions: z11.array(AppEventSubscription).optional(),
+    deviceDelegations: z11.array(DeviceDelegationContribution).optional(),
+    corpusConsumers: z11.array(CorpusContribution).optional(),
+    contextContributors: z11.array(ContextContributorContribution).optional(),
     // Vendored MCP servers this plugin ships (see `McpServerContributions`). Each is hosted only
     // for a plugin holding `mcp.host-server` for its name and URL; that is decided at
     // composition, not here (see ARCHITECTURE.md "Validation Law").
     mcpServers: McpServerContributions.optional(),
     // Handler restricted to endpoint-only by the manifest-level refinement below.
-    commands: z10.array(CommandContribution).optional()
+    commands: z11.array(CommandContribution).optional()
   }).optional()
 });
-var KayUiTargetManifest = z10.strictObject({
+var KayUiTargetManifest = z11.strictObject({
   entrypoint: TargetEntrypoint.optional(),
-  contributes: z10.strictObject({
-    commands: z10.array(UiCommandContribution).optional(),
-    slots: z10.array(UiSlotContribution).optional(),
-    settingsPanels: z10.array(SettingsPanelContribution).optional(),
-    resultRenderers: z10.array(ResultRendererContribution).optional(),
-    referencePresentations: z10.array(ReferencePresentationContribution).optional(),
-    views: z10.array(RichViewContribution).optional(),
-    apps: z10.array(UiAppContribution).optional(),
-    themes: z10.array(ThemeContribution).optional(),
-    eventSubscriptions: z10.array(UiEventSubscriptionContribution).optional(),
-    dataMaterializers: z10.array(AppDataMaterializerContribution).optional()
+  contributes: z11.strictObject({
+    commands: z11.array(UiCommandContribution).optional(),
+    slots: z11.array(UiSlotContribution).optional(),
+    settingsPanels: z11.array(SettingsPanelContribution).optional(),
+    resultRenderers: z11.array(ResultRendererContribution).optional(),
+    referencePresentations: z11.array(ReferencePresentationContribution).optional(),
+    views: z11.array(RichViewContribution).optional(),
+    apps: z11.array(UiAppContribution).optional(),
+    themes: z11.array(ThemeContribution).optional(),
+    eventSubscriptions: z11.array(UiEventSubscriptionContribution).optional(),
+    dataMaterializers: z11.array(AppDataMaterializerContribution).optional()
   }).optional()
 });
-var PluginConfigScope = z10.enum(["global", "project", "agent"]);
-var PluginConfigSectionManifest = z10.strictObject({
+var PluginConfigScope = z11.enum(["global", "project", "agent"]);
+var PluginConfigSectionManifest = z11.strictObject({
   section: NonEmptyString.optional(),
   schema: JsonSchema,
   /**
@@ -3034,25 +3069,25 @@ var PluginConfigSectionManifest = z10.strictObject({
    * is the baseline every section has; `agent` has no runtime mapping (the
    * agent/entity fold is downstream of the document protocol).
    */
-  scopes: z10.array(PluginConfigScope).optional()
+  scopes: z11.array(PluginConfigScope).optional()
 });
-var PluginConfigManifest = z10.array(PluginConfigSectionManifest).min(1);
+var PluginConfigManifest = z11.array(PluginConfigSectionManifest).min(1);
 function configSectionKeysForManifest(manifest) {
   return manifest.config?.map((config) => config.section ?? `plugins.${manifest.id}`) ?? [];
 }
-var PluginStorageManifest = z10.strictObject({
-  sqlite: z10.strictObject({
-    enabled: z10.boolean(),
-    ownerTarget: z10.literal("kay.app").optional(),
+var PluginStorageManifest = z11.strictObject({
+  sqlite: z11.strictObject({
+    enabled: z11.boolean(),
+    ownerTarget: z11.literal("kay.app").optional(),
     migrations: NonEmptyString.optional()
   }).optional(),
-  dataDir: z10.strictObject({
-    enabled: z10.boolean(),
-    ownerTarget: z10.literal("kay.app").optional()
+  dataDir: z11.strictObject({
+    enabled: z11.boolean(),
+    ownerTarget: z11.literal("kay.app").optional()
   }).optional()
 });
-var PluginOAuthClientSupplier = z10.enum(["kay", "user"]);
-var PluginProvisioningProbe = z10.strictObject({
+var PluginOAuthClientSupplier = z11.enum(["kay", "user"]);
+var PluginProvisioningProbe = z11.strictObject({
   /**
    * The API endpoint that answers the question. The host sends the service's OWN credential here,
    * so this must belong to the provider that minted it — enforced by the daemon against the
@@ -3060,13 +3095,13 @@ var PluginProvisioningProbe = z10.strictObject({
    */
   url: HttpsUrl,
   /** Absent ⇒ `GET`. */
-  method: z10.enum(["GET"]).optional(),
+  method: z11.enum(["GET"]).optional(),
   /**
    * The statuses that make the response a VERDICT at all. Anything else (a 401 from a stale
    * token, a 5xx, a rate limit) means the probe learned nothing and reports `unknown` — never
    * `unsatisfied`, which would tell a user to go fix setup that is fine.
    */
-  verdictStatuses: z10.array(SignedInStatusCode).min(1),
+  verdictStatuses: z11.array(SignedInStatusCode).min(1),
   /**
    * Dot-path to a JSON array in the response body that must be NON-EMPTY for the requirement to
    * count as satisfied (e.g. `installations`). Absent means a verdict status alone is enough.
@@ -3075,7 +3110,7 @@ var PluginProvisioningProbe = z10.strictObject({
    */
   nonEmptyArrayAt: NonEmptyString.optional()
 });
-var PluginProvisioningRequirement = z10.strictObject({
+var PluginProvisioningRequirement = z11.strictObject({
   /** Stable id, unique within the scheme. */
   id: LocalContributionId,
   /** Human-facing requirement name, e.g. "GitHub App installation". */
@@ -3092,7 +3127,7 @@ var PluginProvisioningRequirement = z10.strictObject({
   probe: PluginProvisioningProbe
 });
 var PluginProvisioningField = {
-  provisioning: z10.array(PluginProvisioningRequirement).optional()
+  provisioning: z11.array(PluginProvisioningRequirement).optional()
 };
 var PluginAuthSchemeDescriptionFields = {
   /** Human-facing flow name; the runtime scheme name is the fallback. */
@@ -3105,19 +3140,19 @@ var PluginAuthSchemeDescriptionFields = {
    */
   summary: NonEmptyString.optional()
 };
-var PluginAuthSchemeOAuthPkce = z10.strictObject({
+var PluginAuthSchemeOAuthPkce = z11.strictObject({
   ...PluginProvisioningField,
   ...PluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
-  kind: z10.literal("oauth2"),
-  exchange: z10.literal("pkce"),
+  kind: z11.literal("oauth2"),
+  exchange: z11.literal("pkce"),
   /**
    * Unordered SET of who may supply the client — non-empty, and every entry must be distinct
    * (fail-closed re-assertion of the kernel's construction-time dedupe: TS exhaustiveness never
    * runs on an untrusted manifest, so a hand-built `["kay","kay"]` must be refused here, not
    * silently normalized).
    */
-  clientSuppliers: z10.array(PluginOAuthClientSupplier).nonempty().superRefine((suppliers, ctx) => {
+  clientSuppliers: z11.array(PluginOAuthClientSupplier).nonempty().superRefine((suppliers, ctx) => {
     if (new Set(suppliers).size !== suppliers.length) {
       ctx.addIssue({
         code: "custom",
@@ -3125,53 +3160,53 @@ var PluginAuthSchemeOAuthPkce = z10.strictObject({
       });
     }
   }),
-  scopes: z10.array(NonEmptyString).optional()
+  scopes: z11.array(NonEmptyString).optional()
 });
-var PluginAuthSchemeOAuthConfidential = z10.strictObject({
+var PluginAuthSchemeOAuthConfidential = z11.strictObject({
   ...PluginProvisioningField,
   ...PluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
-  kind: z10.literal("oauth2"),
-  exchange: z10.literal("confidential"),
+  kind: z11.literal("oauth2"),
+  exchange: z11.literal("confidential"),
   /** Absent means `["kay"]` — a confidential exchange's secret may only ever be Bonsai's. */
-  clientSuppliers: z10.tuple([z10.literal("kay")]).optional(),
-  scopes: z10.array(NonEmptyString).optional()
+  clientSuppliers: z11.tuple([z11.literal("kay")]).optional(),
+  scopes: z11.array(NonEmptyString).optional()
 });
-var PluginAuthSchemeOAuth2 = z10.discriminatedUnion("exchange", [
+var PluginAuthSchemeOAuth2 = z11.discriminatedUnion("exchange", [
   PluginAuthSchemeOAuthPkce,
   PluginAuthSchemeOAuthConfidential
 ]);
-var PluginAuthSchemeApiKey = z10.strictObject({
+var PluginAuthSchemeApiKey = z11.strictObject({
   ...PluginProvisioningField,
   ...PluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
-  kind: z10.literal("api-key"),
-  scopes: z10.array(NonEmptyString).optional()
+  kind: z11.literal("api-key"),
+  scopes: z11.array(NonEmptyString).optional()
 });
-var PluginAuthSchemeDelegated = z10.strictObject({
+var PluginAuthSchemeDelegated = z11.strictObject({
   ...PluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
-  kind: z10.literal("delegated"),
-  scopes: z10.array(NonEmptyString).optional()
+  kind: z11.literal("delegated"),
+  scopes: z11.array(NonEmptyString).optional()
 });
-var ExternalCliArgument = z10.string().min(1).max(16384).refine((value) => ![...value].some(isUnsafeArgumentCharacter), {
+var ExternalCliArgument = z11.string().min(1).max(16384).refine((value) => ![...value].some(isUnsafeArgumentCharacter), {
   message: "an argument may hold tabs and line breaks, but no other control character, no invisible character and no bidirectional override"
 });
 function isUnsafeArgumentCharacter(character) {
   const code = character.codePointAt(0) ?? 0;
   return code <= 31 && code !== 9 && code !== 10 || code >= 127 && code <= 159 || code === 1564 || code >= 8203 && code <= 8207 || code === 8232 || code === 8233 || code >= 8234 && code <= 8238 || code >= 8288 && code <= 8297 || code === 65279;
 }
-var ExternalCliCommand = z10.string().max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/, {
+var ExternalCliCommand = z11.string().max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/, {
   message: "a command is an executable's basename (letters, digits, '.', '_', '+', '-'), never a path"
 });
 var ExternalCliHint = NonEmptyString.max(2048);
-var ExternalCliArguments = z10.array(ExternalCliArgument).max(64);
-var PluginExternalCliConnect = z10.strictObject({
+var ExternalCliArguments = z11.array(ExternalCliArgument).max(64);
+var PluginExternalCliConnect = z11.strictObject({
   /** A basename the host finds on `PATH` (`osascript`, `wrangler`), never a path. */
   binary: ExternalCliCommand,
-  probe: z10.strictObject({
+  probe: z11.strictObject({
     args: ExternalCliArguments.min(1),
-    timeoutMs: z10.number().int().min(1).max(12e4).optional(),
+    timeoutMs: z11.number().int().min(1).max(12e4).optional(),
     /**
      * The CLI's own signed-out marker: text a failed probe's output (stderr, else stdout) contains
      * when the CLI is signed out. A failure that carries it is a sign-in problem, and only such a
@@ -3181,18 +3216,18 @@ var PluginExternalCliConnect = z10.strictObject({
     signedOutMarker: ExternalCliArgument.refine((value) => value.trim() !== "", { message: "a signed-out marker needs text beyond whitespace" }).optional()
   }),
   /** The CLI's interactive sign-in. Absent: connect only probes and reports. */
-  login: z10.strictObject({
+  login: z11.strictObject({
     args: ExternalCliArguments.min(1),
-    timeoutMs: z10.number().int().min(1).max(6e5).optional()
+    timeoutMs: z11.number().int().min(1).max(6e5).optional()
   }).optional(),
   /**
    * The command that installs `binary`, as an argv. Bonsai never runs it: a surface shows it, joined
    * for display, or hands it to an agent session that runs it behind the ordinary bash approval.
    * Absent for a binary the OS ships (`osascript`).
    */
-  install: z10.strictObject({ command: ExternalCliCommand, args: ExternalCliArguments }).optional(),
+  install: z11.strictObject({ command: ExternalCliCommand, args: ExternalCliArguments }).optional(),
   /** Prose for a person: `install` when the binary is missing, `login` when the probe fails. */
-  hints: z10.strictObject({ install: ExternalCliHint, login: ExternalCliHint })
+  hints: z11.strictObject({ install: ExternalCliHint, login: ExternalCliHint })
 }).superRefine((cli, ctx) => {
   if (cli.login !== void 0 && cli.probe.signedOutMarker === void 0) {
     ctx.addIssue({
@@ -3202,42 +3237,42 @@ var PluginExternalCliConnect = z10.strictObject({
     });
   }
 });
-var PluginAuthSchemeExternalCli = z10.strictObject({
+var PluginAuthSchemeExternalCli = z11.strictObject({
   ...PluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
-  kind: z10.literal("external-cli"),
-  scopes: z10.array(NonEmptyString).optional(),
+  kind: z11.literal("external-cli"),
+  scopes: z11.array(NonEmptyString).optional(),
   cli: PluginExternalCliConnect.optional()
 });
-var PluginAuthScheme = z10.discriminatedUnion("kind", [
+var PluginAuthScheme = z11.discriminatedUnion("kind", [
   PluginAuthSchemeOAuth2,
   PluginAuthSchemeApiKey,
   PluginAuthSchemeDelegated,
   PluginAuthSchemeExternalCli
 ]);
-var PluginWebSessionProbe = z10.strictObject({
+var PluginWebSessionProbe = z11.strictObject({
   url: HttpsUrl,
   /** Absent ⇒ `GET`. `POST` sends an empty JSON object body. */
-  method: z10.enum(["GET", "POST"]).optional(),
-  signedInStatuses: z10.array(SignedInStatusCode).min(1)
+  method: z11.enum(["GET", "POST"]).optional(),
+  signedInStatuses: z11.array(SignedInStatusCode).min(1)
 });
-var PluginWebSessionDeclaration = z10.strictObject({
+var PluginWebSessionDeclaration = z11.strictObject({
   /** `required`: capabilities degrade without the site login; `recommended`: it only smooths UX. */
-  importance: z10.enum(["required", "recommended"]),
+  importance: z11.enum(["required", "recommended"]),
   loginUrl: HttpsUrl,
-  cookieDomains: z10.array(RegistrableDomain).min(1),
+  cookieDomains: z11.array(RegistrableDomain).min(1),
   probe: PluginWebSessionProbe,
-  oauthVenue: z10.enum(["embedded", "external"])
+  oauthVenue: z11.enum(["embedded", "external"])
 }).superRefine(refineWebSessionScopeConfined);
-var PluginAuthService = z10.strictObject({
+var PluginAuthService = z11.strictObject({
   localId: LocalContributionId,
   displayName: NonEmptyString,
-  schemes: z10.array(PluginAuthScheme).min(1),
-  purposes: z10.array(NonEmptyString).min(1),
+  schemes: z11.array(PluginAuthScheme).min(1),
+  purposes: z11.array(NonEmptyString).min(1),
   webSession: PluginWebSessionDeclaration.optional()
 });
-var PluginAuthManifest = z10.strictObject({
-  services: z10.array(PluginAuthService).optional()
+var PluginAuthManifest = z11.strictObject({
+  services: z11.array(PluginAuthService).optional()
 });
 var RETIRED_COMPATIBILITY_KEYS = ["policy"];
 function stripRetiredCompatibilityKeys(value) {
@@ -3249,8 +3284,8 @@ function stripRetiredCompatibilityKeys(value) {
     delete remaining[key];
   return remaining;
 }
-var PluginCompatibilityManifest = z10.preprocess(stripRetiredCompatibilityKeys, z10.strictObject({
-  supportedProtocols: z10.array(KayPluginProtocolVersion).optional(),
+var PluginCompatibilityManifest = z11.preprocess(stripRetiredCompatibilityKeys, z11.strictObject({
+  supportedProtocols: z11.array(KayPluginProtocolVersion).optional(),
   minKayVersion: NonEmptyString.optional(),
   sdk: NonEmptyString.optional()
 }));
@@ -3266,8 +3301,8 @@ function retiredCompatibilityKeysIn(rawManifest) {
 var KayVersionString = NonEmptyString.regex(SEMVER_PATTERN, {
   message: "version must be semver, for example 1.2.3"
 });
-var KayPluginManifestV1 = z10.strictObject({
-  protocol: z10.literal(KAY_PLUGIN_PROTOCOL_VERSION),
+var KayPluginManifestV1 = z11.strictObject({
+  protocol: z11.literal(KAY_PLUGIN_PROTOCOL_VERSION),
   id: PluginId,
   displayName: NonEmptyString,
   version: KayVersionString,
@@ -3297,8 +3332,8 @@ var KayPluginManifestV1 = z10.strictObject({
   icon: PackageAssetPath.optional(),
   iconDark: PackageAssetPath.optional(),
   namespace: PluginNamespace.optional(),
-  targets: z10.strictObject({
-    kay: z10.strictObject({
+  targets: z11.strictObject({
+    kay: z11.strictObject({
       agent: KayAgentTargetManifest.optional(),
       app: KayAppTargetManifest.optional(),
       ui: KayUiTargetManifest.optional()
@@ -3315,15 +3350,15 @@ var KayPluginManifestV1 = z10.strictObject({
    * schemes then report `ownedByBonsai`. Honoured only for a plugin that ships with Bonsai: the
    * host reads any other plugin's flag as false. Absent ⇒ false.
    */
-  ownedByBonsai: z10.boolean().optional(),
+  ownedByBonsai: z11.boolean().optional(),
   /**
    * Explicit plugin-level dependencies — other plugins this plugin requires to be present in the
    * composed roster. At composition time the runtime checks each id against the accepted
    * registration list and derives a provenance-complete dependency graph (together with implicit
    * auth-service edges from `consumesAuthServices`). Absent ⇒ no explicit dependencies.
    */
-  dependencies: z10.strictObject({
-    plugins: z10.array(PluginId).optional()
+  dependencies: z11.strictObject({
+    plugins: z11.array(PluginId).optional()
   }).optional()
 }).superRefine((manifest, ctx) => {
   const authServices = new Set(manifest.auth?.services?.map((service) => service.localId) ?? []);
@@ -4008,7 +4043,7 @@ function pushContributionIds(output, path, items) {
 }
 
 // packages/plugin-protocol/dist/plugin-directory-verdict.js
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // packages/plugin-protocol/dist/plugin-load-diagnostic.js
 var PLUGIN_DIAGNOSTIC_MESSAGE_CAP = 300;
@@ -4017,36 +4052,44 @@ function boundPluginDiagnosticMessage(message) {
 }
 
 // packages/plugin-protocol/dist/resolved-contract.js
-import { z as z11 } from "zod";
-var ResolvedPluginContributionId = z11.strictObject({
+import { z as z12 } from "zod";
+var ResolvedPluginContributionId = z12.strictObject({
   target: PluginTargetName,
   kind: PluginContributionKind,
-  localId: LocalContributionId,
+  localId: PluginEventLocalId,
   globalId: GlobalContributionId
+}).superRefine((value, ctx) => {
+  if (value.kind !== "eventDefinition" && !LocalContributionId.safeParse(value.localId).success) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["localId"],
+      message: "Only event definitions may use dotted local ids"
+    });
+  }
 });
-var ResolvedKayAgentTool = z11.strictObject({
+var ResolvedKayAgentTool = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
   toolName: PluginToolName
 });
 var ResolvedKayAppTool = ResolvedKayAgentTool;
-var ResolvedKayAppDataSource = z11.strictObject({
+var ResolvedKayAppDataSource = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  scope: z11.enum(["runtime", "account", "session"]),
-  snapshot: z11.strictObject({
-    version: z11.number().int().positive(),
-    schema: z11.record(z11.string(), z11.unknown())
+  scope: z12.enum(["runtime", "account", "session"]),
+  snapshot: z12.strictObject({
+    version: z12.number().int().positive(),
+    schema: z12.record(z12.string(), z12.unknown())
   }),
-  change: z11.strictObject({
-    version: z11.number().int().positive(),
-    schema: z11.record(z11.string(), z11.unknown()),
-    semantics: z11.discriminatedUnion("kind", [
-      z11.strictObject({ kind: z11.literal("incremental") }),
-      z11.strictObject({
-        kind: z11.literal("snapshot-replacement"),
-        maxEncodedBytes: z11.number().int().positive(),
-        rationale: z11.string().trim().min(1).max(1024)
+  change: z12.strictObject({
+    version: z12.number().int().positive(),
+    schema: z12.record(z12.string(), z12.unknown()),
+    semantics: z12.discriminatedUnion("kind", [
+      z12.strictObject({ kind: z12.literal("incremental") }),
+      z12.strictObject({
+        kind: z12.literal("snapshot-replacement"),
+        maxEncodedBytes: z12.number().int().positive(),
+        rationale: z12.string().trim().min(1).max(1024)
       })
     ]).optional()
   }),
@@ -4060,66 +4103,66 @@ var ResolvedKayAppDataSource = z11.strictObject({
     });
   }
 });
-var ResolvedKayAppWhiteboardType = z11.strictObject({
+var ResolvedKayAppWhiteboardType = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
   displayName: NonEmptyString,
-  schemaVersion: z11.number().int().positive(),
+  schemaVersion: z12.number().int().positive(),
   storage: WhiteboardTypeStorage,
   valueSchema: JsonSchema,
-  presentation: z11.strictObject({
+  presentation: z12.strictObject({
     app: GlobalContributionId
   }).optional()
 });
-var ResolvedKayAppMcpServer = z11.strictObject({
+var ResolvedKayAppMcpServer = z12.strictObject({
   name: LocalContributionId,
   pluginId: PluginId,
   url: McpServerUrl,
   auth: McpServerAuthMode,
   authServiceId: GlobalContributionId.optional()
 });
-var ResolvedKayAgentUriModule = z11.strictObject({
+var ResolvedKayAgentUriModule = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  schemes: z11.array(UriScheme).min(1),
+  schemes: z12.array(UriScheme).min(1),
   filesystemBacking: UriFilesystemBacking.optional(),
   /** Mirrors `UriModuleContribution.knownResources` (host-side recording opt-in). */
-  knownResources: z11.literal(true).optional()
+  knownResources: z12.literal(true).optional()
 });
-var ResolvedKayAgentArtifactUriModule = z11.strictObject({
+var ResolvedKayAgentArtifactUriModule = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
   scheme: UriScheme,
-  editable: z11.boolean(),
-  listable: z11.boolean(),
-  deletable: z11.boolean(),
-  appendable: z11.boolean(),
-  storageScope: z11.enum(["session", "family"])
+  editable: z12.boolean(),
+  listable: z12.boolean(),
+  deletable: z12.boolean(),
+  appendable: z12.boolean(),
+  storageScope: z12.enum(["session", "family"])
 });
-var ResolvedKayAgentEntityResolver = z11.strictObject({
+var ResolvedKayAgentEntityResolver = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
   displayName: NonEmptyString.optional(),
   uriModule: GlobalContributionId,
-  entityTypes: z11.array(NonEmptyString).min(1),
+  entityTypes: z12.array(NonEmptyString).min(1),
   uriHint: NonEmptyString
 });
-var ResolvedKayAgentGitHostClaim = z11.strictObject({
+var ResolvedKayAgentGitHostClaim = z12.strictObject({
   host: GitHostName,
   authServiceId: GlobalContributionId,
   /** Manifest-declared order; the clone ladder tries them in sequence. */
-  authSchemeIds: z11.array(GlobalContributionId).min(1),
+  authSchemeIds: z12.array(GlobalContributionId).min(1),
   /** Non-secret display copy for the claiming service, for clone failure text. */
-  authServiceDisplayName: z11.string(),
+  authServiceDisplayName: z12.string(),
   basicAuthUser: GitBasicAuthUser
 });
-var ResolvedKayAgentConverter = z11.strictObject({
+var ResolvedKayAgentConverter = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  mimeTypes: z11.array(MimeTypeString).min(1),
-  extensions: z11.array(FileExtensionToken).min(1).optional()
+  mimeTypes: z12.array(MimeTypeString).min(1),
+  extensions: z12.array(FileExtensionToken).min(1).optional()
 });
-var ResolvedReferencePresentation = z11.strictObject({
+var ResolvedReferencePresentation = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
   uriModule: GlobalContributionId,
@@ -4127,9 +4170,9 @@ var ResolvedReferencePresentation = z11.strictObject({
   open: ReferenceOpenBehavior,
   /** MIME-specific resource kinds; absent keys use the base presentation. */
   variants: ReferencePresentationVariants.optional(),
-  claims: z11.array(ReferencePresentationUrlClaim).optional()
+  claims: z12.array(ReferencePresentationUrlClaim).optional()
 });
-var ResolvedPluginProvisioningRequirement = z11.strictObject({
+var ResolvedPluginProvisioningRequirement = z12.strictObject({
   id: LocalContributionId,
   displayName: NonEmptyString,
   description: NonEmptyString,
@@ -4139,15 +4182,15 @@ var ResolvedPluginProvisioningRequirement = z11.strictObject({
    * URL degrades to "Reconnect" in the UI instead of a broken link.
    */
   remediationUrl: HttpsUrl.optional(),
-  probe: z11.strictObject({
+  probe: z12.strictObject({
     url: HttpsUrl,
-    method: z11.enum(["GET"]),
-    verdictStatuses: z11.array(SignedInStatusCode).min(1),
+    method: z12.enum(["GET"]),
+    verdictStatuses: z12.array(SignedInStatusCode).min(1),
     nonEmptyArrayAt: NonEmptyString.optional()
   })
 });
 var ResolvedProvisioningField = {
-  provisioning: z11.array(ResolvedPluginProvisioningRequirement).optional()
+  provisioning: z12.array(ResolvedPluginProvisioningRequirement).optional()
 };
 var ResolvedPluginAuthSchemeDescriptionFields = {
   displayName: NonEmptyString.optional(),
@@ -4159,98 +4202,99 @@ var ResolvedPluginAuthSchemeOAuthBase = {
   ...ResolvedPluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  kind: z11.literal("oauth2"),
-  scopes: z11.array(z11.string()).optional()
+  kind: z12.literal("oauth2"),
+  scopes: z12.array(z12.string()).optional()
 };
-var ResolvedPluginAuthSchemeOAuthPkce = z11.strictObject({
+var ResolvedPluginAuthSchemeOAuthPkce = z12.strictObject({
   ...ResolvedPluginAuthSchemeOAuthBase,
-  exchange: z11.literal("pkce"),
-  clientSuppliers: z11.array(PluginOAuthClientSupplier).nonempty()
+  exchange: z12.literal("pkce"),
+  clientSuppliers: z12.array(PluginOAuthClientSupplier).nonempty()
 });
-var ResolvedPluginAuthSchemeOAuthConfidential = z11.strictObject({
+var ResolvedPluginAuthSchemeOAuthConfidential = z12.strictObject({
   ...ResolvedPluginAuthSchemeOAuthBase,
-  exchange: z11.literal("confidential"),
-  clientSuppliers: z11.tuple([z11.literal("kay")])
+  exchange: z12.literal("confidential"),
+  clientSuppliers: z12.tuple([z12.literal("kay")])
 });
-var ResolvedPluginAuthSchemeOAuth2 = z11.discriminatedUnion("exchange", [
+var ResolvedPluginAuthSchemeOAuth2 = z12.discriminatedUnion("exchange", [
   ResolvedPluginAuthSchemeOAuthPkce,
   ResolvedPluginAuthSchemeOAuthConfidential
 ]);
-var ResolvedPluginAuthSchemeApiKey = z11.strictObject({
+var ResolvedPluginAuthSchemeApiKey = z12.strictObject({
   ...ResolvedProvisioningField,
   ...ResolvedPluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  kind: z11.literal("api-key"),
-  scopes: z11.array(z11.string()).optional()
+  kind: z12.literal("api-key"),
+  scopes: z12.array(z12.string()).optional()
 });
-var ResolvedPluginAuthSchemeDelegated = z11.strictObject({
+var ResolvedPluginAuthSchemeDelegated = z12.strictObject({
   ...ResolvedPluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  kind: z11.literal("delegated"),
-  scopes: z11.array(z11.string()).optional()
+  kind: z12.literal("delegated"),
+  scopes: z12.array(z12.string()).optional()
 });
-var ResolvedPluginAuthSchemeExternalCli = z11.strictObject({
+var ResolvedPluginAuthSchemeExternalCli = z12.strictObject({
   ...ResolvedPluginAuthSchemeDescriptionFields,
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  kind: z11.literal("external-cli"),
-  scopes: z11.array(z11.string()).optional(),
+  kind: z12.literal("external-cli"),
+  scopes: z12.array(z12.string()).optional(),
   /** The manifest's connect facts, verbatim. */
   cli: PluginExternalCliConnect.optional()
 });
-var ResolvedPluginAuthScheme = z11.discriminatedUnion("kind", [
+var ResolvedPluginAuthScheme = z12.discriminatedUnion("kind", [
   ResolvedPluginAuthSchemeOAuth2,
   ResolvedPluginAuthSchemeApiKey,
   ResolvedPluginAuthSchemeDelegated,
   ResolvedPluginAuthSchemeExternalCli
 ]);
-var ResolvedPluginWebSession = z11.strictObject({
-  importance: z11.enum(["required", "recommended"]),
+var ResolvedPluginWebSession = z12.strictObject({
+  importance: z12.enum(["required", "recommended"]),
   loginUrl: HttpsUrl,
-  cookieDomains: z11.array(RegistrableDomain).min(1),
-  probe: z11.strictObject({
+  cookieDomains: z12.array(RegistrableDomain).min(1),
+  probe: z12.strictObject({
     url: HttpsUrl,
-    method: z11.enum(["GET", "POST"]),
-    signedInStatuses: z11.array(SignedInStatusCode).min(1)
+    method: z12.enum(["GET", "POST"]),
+    signedInStatuses: z12.array(SignedInStatusCode).min(1)
   }),
-  oauthVenue: z11.enum(["embedded", "external"])
+  oauthVenue: z12.enum(["embedded", "external"])
 }).superRefine(refineWebSessionScopeConfined);
-var ResolvedPluginAuthService = z11.strictObject({
+var ResolvedPluginAuthService = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
-  displayName: z11.string(),
-  schemes: z11.array(ResolvedPluginAuthScheme).min(1),
-  purposes: z11.array(z11.string()).min(1),
+  displayName: z12.string(),
+  schemes: z12.array(ResolvedPluginAuthScheme).min(1),
+  purposes: z12.array(z12.string()).min(1),
   /** The service's browser half, when the manifest declares one. */
   webSession: ResolvedPluginWebSession.optional()
 });
-var ResolvedKayUiAppEndpointCapability = z11.strictObject({
+var ResolvedKayUiAppEndpointCapability = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId
 });
-var ResolvedKayUiApp = z11.strictObject({
+var ResolvedKayUiApp = z12.strictObject({
   localId: LocalContributionId,
   globalId: GlobalContributionId,
   displayName: NonEmptyString,
+  activityRail: UiAppActivityRail.optional(),
   description: NonEmptyString.optional(),
   icon: PackageAssetPath.optional(),
-  runtime: z11.literal("kay.react-app.v1"),
-  sdk: z11.strictObject({ range: NonEmptyString }),
+  runtime: z12.literal("kay.react-app.v1"),
+  sdk: z12.strictObject({ range: NonEmptyString }),
   entrypoint: TargetEntrypoint,
-  styles: z11.array(PackageAssetPath).optional(),
-  assets: z11.array(PackageAssetPath).optional(),
-  capabilities: z11.strictObject({
-    endpoints: z11.array(ResolvedKayUiAppEndpointCapability).optional(),
-    host: z11.array(KayUiAppHostCapability).optional()
+  styles: z12.array(PackageAssetPath).optional(),
+  assets: z12.array(PackageAssetPath).optional(),
+  capabilities: z12.strictObject({
+    endpoints: z12.array(ResolvedKayUiAppEndpointCapability).optional(),
+    host: z12.array(KayUiAppHostCapability).optional()
   }).optional()
 });
-var ResolvedPluginContractV1 = z11.strictObject({
-  protocol: z11.literal("kay.plugin.v1"),
+var ResolvedPluginContractV1 = z12.strictObject({
+  protocol: z12.literal("kay.plugin.v1"),
   pluginId: PluginId,
   namespace: PluginNamespace,
-  contributions: z11.array(ResolvedPluginContributionId),
+  contributions: z12.array(ResolvedPluginContributionId),
   // The deduplicated set of qualified (dotted) external auth-service ids this
   // plugin references, from agent uriModule `authService` refs, cliBinding
   // `authService` refs, and auth-grant `service` refs. Always present — a plugin
@@ -4258,30 +4302,30 @@ var ResolvedPluginContractV1 = z11.strictObject({
   // is a recorded dependency, not a resolution: there is no runtime plugin
   // loader in v1, so nothing here verifies the reference resolves within a
   // composed roster (a composition-time concern owned elsewhere).
-  consumesAuthServices: z11.array(GlobalContributionId),
+  consumesAuthServices: z12.array(GlobalContributionId),
   // The explicit plugin-level dependency ids declared in `dependencies.plugins` on the manifest,
   // deduped and validated at parse time. Always present; a plugin with no explicit dependencies
   // carries an empty array. Composition checks each id against the accepted roster and derives the
   // full dependency graph together with auth-inferred edges from `consumesAuthServices`.
-  explicitDependencies: z11.array(PluginId),
+  explicitDependencies: z12.array(PluginId),
   // The auth services this plugin OWNS, carrying the global ids its harness
   // target must register and the credential authority keys on. Always present;
   // a plugin that declares no `auth.services` carries an empty array. The dual
   // of `consumesAuthServices` (services it merely references).
-  authServices: z11.array(ResolvedPluginAuthService),
+  authServices: z12.array(ResolvedPluginAuthService),
   grants: ResolvedPluginGrants.optional(),
-  kayAgentUriModules: z11.array(ResolvedKayAgentUriModule).optional(),
-  kayAgentArtifactUriModules: z11.array(ResolvedKayAgentArtifactUriModule).optional(),
-  kayAgentEntityResolvers: z11.array(ResolvedKayAgentEntityResolver).optional(),
-  kayAgentGitHostClaims: z11.array(ResolvedKayAgentGitHostClaim).optional(),
-  kayAgentTools: z11.array(ResolvedKayAgentTool).optional(),
-  kayAppTools: z11.array(ResolvedKayAppTool).optional(),
-  kayAppDataSources: z11.array(ResolvedKayAppDataSource).optional(),
-  kayAppWhiteboardTypes: z11.array(ResolvedKayAppWhiteboardType).optional(),
-  kayAppMcpServers: z11.array(ResolvedKayAppMcpServer).optional(),
-  kayAgentConverters: z11.array(ResolvedKayAgentConverter).optional(),
-  referencePresentations: z11.array(ResolvedReferencePresentation).optional(),
-  kayUiApps: z11.array(ResolvedKayUiApp).optional()
+  kayAgentUriModules: z12.array(ResolvedKayAgentUriModule).optional(),
+  kayAgentArtifactUriModules: z12.array(ResolvedKayAgentArtifactUriModule).optional(),
+  kayAgentEntityResolvers: z12.array(ResolvedKayAgentEntityResolver).optional(),
+  kayAgentGitHostClaims: z12.array(ResolvedKayAgentGitHostClaim).optional(),
+  kayAgentTools: z12.array(ResolvedKayAgentTool).optional(),
+  kayAppTools: z12.array(ResolvedKayAppTool).optional(),
+  kayAppDataSources: z12.array(ResolvedKayAppDataSource).optional(),
+  kayAppWhiteboardTypes: z12.array(ResolvedKayAppWhiteboardType).optional(),
+  kayAppMcpServers: z12.array(ResolvedKayAppMcpServer).optional(),
+  kayAgentConverters: z12.array(ResolvedKayAgentConverter).optional(),
+  referencePresentations: z12.array(ResolvedReferencePresentation).optional(),
+  kayUiApps: z12.array(ResolvedKayUiApp).optional()
 });
 function narrowestAccountSelectors() {
   return [{ kind: "active" }];
@@ -4639,6 +4683,7 @@ function resolveKayPluginContractV1(manifest) {
   const kayUiApps = manifest.targets?.kay?.ui?.contributes?.apps?.map((app) => ({
     localId: app.localId,
     globalId: resolveGlobalContributionId(namespace, app.localId),
+    ...app.activityRail === void 0 ? {} : { activityRail: app.activityRail },
     displayName: app.displayName,
     ...app.description === void 0 ? {} : { description: app.description },
     ...app.icon === void 0 ? {} : { icon: app.icon },
@@ -4792,7 +4837,7 @@ async function judgeKayPluginDirectory(input) {
   if (!resolved.success) {
     return refuse("contract-resolve", "contract-unresolvable", `contract could not be resolved: ${resolved.error.message}`);
   }
-  const { contract, misnamedTools } = keepNamespaceDerivedTools(resolved.data);
+  const { contract, misnamedTools } = keepNamespaceDerivedTools(resolved.data, new Set(input.grandfatheredToolNames?.(manifest.id) ?? []));
   for (const tool of misnamedTools) {
     warnings.push({
       stage: "contract-resolve",
@@ -4833,23 +4878,23 @@ function kayPluginCompatibilityAdvisories(input) {
     message: boundPluginDiagnosticMessage(`${manifest.displayName} (${manifest.id}) ${advisory.message}`)
   }));
 }
-var ReadableCompatibility = z12.object({
-  supportedProtocols: z12.array(z12.string()).optional().catch(void 0),
+var ReadableCompatibility = z13.object({
+  supportedProtocols: z13.array(z13.string()).optional().catch(void 0),
   minKayVersion: NonEmptyString.optional().catch(void 0),
   sdk: NonEmptyString.optional().catch(void 0)
 });
-var ReadableManifestHead = z12.object({
-  id: z12.string().optional().catch(void 0),
-  displayName: z12.string().optional().catch(void 0),
+var ReadableManifestHead = z13.object({
+  id: z13.string().optional().catch(void 0),
+  displayName: z13.string().optional().catch(void 0),
   compatibility: ReadableCompatibility.optional().catch(void 0)
 });
-function keepNamespaceDerivedTools(contract) {
+function keepNamespaceDerivedTools(contract, grandfathered) {
   const misnamedTools = [];
   const droppedGlobalIds = /* @__PURE__ */ new Set();
   const keep = (tools) => {
     const kept = tools?.filter((tool) => {
       const expected = deriveDirectoryPluginToolName(contract.namespace, tool.localId);
-      if (tool.toolName === expected)
+      if (tool.toolName === expected || grandfathered.has(tool.toolName))
         return true;
       misnamedTools.push({
         localId: tool.localId,
@@ -4939,28 +4984,28 @@ function errorText(error) {
 }
 
 // packages/plugin-protocol/dist/session-health.js
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var SESSION_HEALTH_EXTENSION_ID = "kay.session-health";
 var SESSION_HEALTH_ENTRY_NAME = "session_health";
 var SESSION_HEALTH_CUSTOM_TYPE = `ext:${SESSION_HEALTH_EXTENSION_ID}:${SESSION_HEALTH_ENTRY_NAME}`;
 var SESSION_HEALTH_CLASSIFIER_IDS = ["jev"];
-var sessionHealthEntrySchema = z13.object({
-  v: z13.literal(1),
-  verdict: z13.enum(["well", "bad", "unknown"]),
+var sessionHealthEntrySchema = z14.object({
+  v: z14.literal(1),
+  verdict: z14.enum(["well", "bad", "unknown"]),
   /**
    * The model's calibrated confidence in `well`, 0..1, or null when the
    * classifier declined to produce one. Never exported raw: the telemetry
    * event carries only the decile bucket.
    */
-  p_well: z13.number().min(0).max(1).nullable(),
-  classifier: z13.enum(SESSION_HEALTH_CLASSIFIER_IDS),
-  classifier_version: z13.string().min(1).max(64),
-  judged_at: z13.number().int().nonnegative(),
-  user_entry_id: z13.string().min(1).max(256),
-  through_entry_id: z13.string().min(1).max(256),
-  usage: z13.strictObject({
-    input_tokens: z13.number().int().nonnegative(),
-    output_tokens: z13.number().int().nonnegative()
+  p_well: z14.number().min(0).max(1).nullable(),
+  classifier: z14.enum(SESSION_HEALTH_CLASSIFIER_IDS),
+  classifier_version: z14.string().min(1).max(64),
+  judged_at: z14.number().int().nonnegative(),
+  user_entry_id: z14.string().min(1).max(256),
+  through_entry_id: z14.string().min(1).max(256),
+  usage: z14.strictObject({
+    input_tokens: z14.number().int().nonnegative(),
+    output_tokens: z14.number().int().nonnegative()
   }).optional()
 });
 function sessionHealthPWellDecile(pWell) {
@@ -4970,23 +5015,23 @@ function sessionHealthPWellDecile(pWell) {
 }
 
 // packages/plugin-protocol/dist/resource-invocations.js
-import { z as z14 } from "zod";
-var CorpusResourceKind = z14.enum([
+import { z as z15 } from "zod";
+var CorpusResourceKind = z15.enum([
   "skill",
   "context-file",
   "prompt-command"
 ]);
-var CorpusResourceInvocationCursor = z14.strictObject({
-  at: z14.iso.datetime({ offset: true }),
-  eventId: z14.string().min(1)
+var CorpusResourceInvocationCursor = z15.strictObject({
+  at: z15.iso.datetime({ offset: true }),
+  eventId: z15.string().min(1)
 });
-var CorpusResourceInvocationQuery = z14.strictObject({
+var CorpusResourceInvocationQuery = z15.strictObject({
   kind: CorpusResourceKind,
-  since: z14.iso.datetime({ offset: true }),
-  until: z14.iso.datetime({ offset: true }),
+  since: z15.iso.datetime({ offset: true }),
+  until: z15.iso.datetime({ offset: true }),
   after: CorpusResourceInvocationCursor.optional(),
-  limit: z14.number().int().min(1).max(1e3).optional(),
-  rootCreatedByKind: z14.enum(AGENT_RUNTIME_SESSION_CREATOR_KINDS).optional()
+  limit: z15.number().int().min(1).max(1e3).optional(),
+  rootCreatedByKind: z15.enum(AGENT_RUNTIME_SESSION_CREATOR_KINDS).optional()
 }).refine((value) => Date.parse(value.since) < Date.parse(value.until), {
   message: "since must precede until"
 });
@@ -5166,14 +5211,14 @@ function skillSuggestionEvidenceItems(evidence, options = {}) {
 }
 
 // packages/plugin-protocol/dist/ui-app-package.js
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var KAY_UI_APP_PACKAGE_PROTOCOL = "kay.ui.app-package.v1";
 var KAY_UI_BUNDLE_INDEX_PROTOCOL = "kay.ui.bundle-index.v1";
-var KayUiBundleOutputPath = z15.string().trim().min(1).refine((value) => !value.startsWith("/") && !value.startsWith("./") && !value.includes("\\") && !value.split("/").includes(".."), { message: "bundle output path must stay relative to the bundle root" });
-var KayUiBundleIndexV1 = z15.strictObject({
-  protocol: z15.literal(KAY_UI_BUNDLE_INDEX_PROTOCOL),
+var KayUiBundleOutputPath = z16.string().trim().min(1).refine((value) => !value.startsWith("/") && !value.startsWith("./") && !value.includes("\\") && !value.split("/").includes(".."), { message: "bundle output path must stay relative to the bundle root" });
+var KayUiBundleIndexV1 = z16.strictObject({
+  protocol: z16.literal(KAY_UI_BUNDLE_INDEX_PROTOCOL),
   entryPath: KayUiBundleOutputPath,
-  files: z15.array(z15.strictObject({
+  files: z16.array(z16.strictObject({
     path: KayUiBundleOutputPath,
     mediaType: NonEmptyString
   })).min(1)
@@ -5200,19 +5245,19 @@ var KayUiBundleIndexV1 = z15.strictObject({
 function parseKayUiBundleIndexV1(input) {
   return KayUiBundleIndexV1.parse(input);
 }
-var KayUiAppPackageFile = z15.strictObject({
+var KayUiAppPackageFile = z16.strictObject({
   path: PackageAssetPath,
   mediaType: NonEmptyString,
-  bytes: z15.instanceof(Uint8Array).refine((bytes) => bytes.byteLength > 0, {
+  bytes: z16.instanceof(Uint8Array).refine((bytes) => bytes.byteLength > 0, {
     message: "app package file bytes must not be empty"
   })
 });
-var KayUiAppPackageV1 = z15.strictObject({
-  protocol: z15.literal(KAY_UI_APP_PACKAGE_PROTOCOL),
+var KayUiAppPackageV1 = z16.strictObject({
+  protocol: z16.literal(KAY_UI_APP_PACKAGE_PROTOCOL),
   appLocalId: LocalContributionId,
   entry: KayUiAppPackageFile,
-  styles: z15.array(KayUiAppPackageFile).optional(),
-  assets: z15.array(KayUiAppPackageFile).optional()
+  styles: z16.array(KayUiAppPackageFile).optional(),
+  assets: z16.array(KayUiAppPackageFile).optional()
 }).superRefine((appPackage, ctx) => {
   if (appPackage.entry.mediaType !== "application/javascript") {
     ctx.addIssue({
@@ -5249,16 +5294,16 @@ function parseKayUiAppPackageV1(input) {
 }
 
 // packages/plugin-protocol/dist/whiteboard.js
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var WhiteboardValue = JsonValue;
-var WhiteboardEntryEnvelope = z16.strictObject({
+var WhiteboardEntryEnvelope = z17.strictObject({
   id: NonEmptyString,
   typeId: GlobalContributionId,
-  schemaVersion: z16.number().int().positive(),
-  title: z16.string(),
+  schemaVersion: z17.number().int().positive(),
+  title: z17.string(),
   authorSessionId: NonEmptyString.nullable()
 });
-var WhiteboardEntrySummary = z16.strictObject({
+var WhiteboardEntrySummary = z17.strictObject({
   name: NonEmptyString,
   entry: WhiteboardEntryEnvelope,
   revision: NonEmptyString
@@ -5266,31 +5311,31 @@ var WhiteboardEntrySummary = z16.strictObject({
 var WhiteboardEntrySnapshot = WhiteboardEntrySummary.extend({
   value: WhiteboardValue
 });
-var WhiteboardDiagnostic = z16.strictObject({
+var WhiteboardDiagnostic = z17.strictObject({
   ruleId: NonEmptyString,
-  severity: z16.enum(["error", "warning"]),
+  severity: z17.enum(["error", "warning"]),
   message: NonEmptyString
 });
-var WhiteboardEntryInfo = z16.strictObject({
+var WhiteboardEntryInfo = z17.strictObject({
   name: NonEmptyString,
   revision: NonEmptyString,
   entry: WhiteboardEntryEnvelope.optional(),
-  state: z16.enum(["available", "unavailable", "unsupported-version", "invalid"]),
-  mutable: z16.boolean(),
-  diagnostics: z16.array(z16.string())
+  state: z17.enum(["available", "unavailable", "unsupported-version", "invalid"]),
+  mutable: z17.boolean(),
+  diagnostics: z17.array(z17.string())
 });
 var WhiteboardEntryInspection = WhiteboardEntryInfo.extend({
   value: WhiteboardValue.optional(),
-  text: z16.string(),
-  truncated: z16.boolean()
+  text: z17.string(),
+  truncated: z17.boolean()
 });
-var WhiteboardTypeInfo = z16.strictObject({
+var WhiteboardTypeInfo = z17.strictObject({
   typeId: GlobalContributionId,
   displayName: NonEmptyString,
-  schemaVersion: z16.number().int().positive(),
-  available: z16.boolean(),
+  schemaVersion: z17.number().int().positive(),
+  available: z17.boolean(),
   /** A plugin-owned readonly presentation; absent types use the host fallback. */
-  presentation: z16.strictObject({
+  presentation: z17.strictObject({
     app: GlobalContributionId
   }).optional()
 });
@@ -5383,6 +5428,7 @@ export {
   KnowledgeSearchGrantRequest,
   KnownResourcesGrantRequest,
   LocalContributionId,
+  MCP_SIGN_IN_SCHEME_KIND,
   McpServerAuthMode,
   McpServerContribution,
   McpServerContributions,
@@ -5391,6 +5437,7 @@ export {
   NonEmptyString,
   PLUGIN_CAPABILITY_SLUGS,
   PLUGIN_DIAGNOSTIC_MESSAGE_CAP,
+  PLUGIN_EVENT_ID_MAX_BYTES,
   PLUGIN_ICON_SHAPE_ATTRIBUTE,
   PLUGIN_NOTIFICATION_RULE_HOST_KEYS,
   PackageAssetPath,
@@ -5409,6 +5456,15 @@ export {
   PluginConfigSectionManifest,
   PluginContributionKind,
   PluginEventDefinitionContribution,
+  PluginEventEnvelope,
+  PluginEventId,
+  PluginEventLocalId,
+  PluginEventPublishInput,
+  PluginEventPublishSource,
+  PluginEventRelated,
+  PluginEventSource,
+  PluginEventTimestamp,
+  PluginEventUri,
   PluginExternalCliConnect,
   PluginId,
   PluginNamespace,
@@ -5488,6 +5544,7 @@ export {
   TargetPermissionWiring,
   ThemeContribution,
   ToolContribution,
+  UiAppActivityRail,
   UiAppCapabilities,
   UiAppContribution,
   UiCommandContribution,