@yaklabs-ai/plugin-protocol 0.51.0 → 0.52.0

package/dist/index.js

@@ -266,8 +266,9 @@ var JsonSchema = z4.record(z4.string(), JsonValue);
 var KAY_PLUGIN_MANIFEST_SIZE_CAP_BYTES = 1024 * 1024;
 var KAY_PLUGIN_PROTOCOL_VERSION = "kay.plugin.v1";
 var KAY_PLUGIN_PROTOCOL_PACKAGE_NAME = "@bonsai/plugin-protocol";
-var KAY_PLUGIN_SDK_VERSION = "0.51.0";
+var KAY_PLUGIN_SDK_VERSION = "0.52.0";
 var KAY_PLUGIN_COMPATIBLE_SDK_VERSIONS = [
+  "0.51.0",
   "0.50.0",
   "0.49.0"
 ];
@@ -1233,7 +1234,7 @@ function finalizeArtifactProvenanceEnvelope(capture, artifacts) {
 }
 
 // packages/plugin-protocol/dist/authority.js
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // packages/plugin-protocol/dist/permissions.js
 var permissions_exports = {};
@@ -1268,7 +1269,7 @@ __export(permissions_exports, {
   retiredPermissionAsksIn: () => retiredPermissionAsksIn,
   webSessionPathWithinPrefix: () => webSessionPathWithinPrefix
 });
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // packages/plugin-protocol/dist/ids.js
 function resolvePluginNamespace(pluginId, namespace) {
@@ -1296,6 +1297,50 @@ function resolveAdapterId(globalId, declaredAdapterId) {
   return declaredAdapterId ?? globalId;
 }
 
+// packages/plugin-protocol/dist/sign-in-facts.js
+import { z as z9 } from "zod";
+var Label = z9.string().min(1).max(120).refine((value) => value.trim().length > 0);
+var SetupText = z9.string().min(1).max(2048).refine((value) => value.trim().length > 0);
+var ClientFieldValidation = z9.discriminatedUnion("kind", [
+  z9.strictObject({ kind: z9.literal("uuid") }),
+  z9.strictObject({
+    kind: z9.literal("suffix"),
+    value: z9.string().min(1).max(120)
+  })
+]);
+var PluginByoocProfile = z9.strictObject({
+  displayName: Label,
+  fields: z9.array(z9.strictObject({
+    id: z9.string().regex(/^[A-Za-z][A-Za-z0-9]{0,63}$/),
+    label: Label,
+    optional: z9.boolean().optional(),
+    validation: ClientFieldValidation.optional(),
+    failureMessage: SetupText.optional()
+  })).min(1).max(8).refine((fields) => fields[0]?.id === "clientId", {
+    message: "the first BYOOC field must be clientId"
+  }).refine((fields) => new Set(fields.map((field) => field.id)).size === fields.length, {
+    message: "BYOOC field ids must be unique"
+  }),
+  setup: z9.strictObject({
+    steps: z9.array(SetupText).min(1).max(20),
+    notes: z9.array(SetupText).max(20),
+    url: z9.url().startsWith("https://")
+  }),
+  endpointTemplates: z9.strictObject({
+    authorizationUrl: z9.string().min(1).max(512),
+    tokenUrl: z9.string().min(1).max(512)
+  }).optional()
+});
+var PluginPickerRound = z9.strictObject({
+  scopes: z9.array(z9.string().min(1).max(512)).min(1).max(16),
+  extraAuthorizeParams: z9.record(z9.string().min(1), z9.string()),
+  redirectParam: z9.string().min(1).max(120),
+  requiresGrantedScope: z9.string().min(1).max(512),
+  supersededByScopes: z9.array(z9.string().min(1).max(512)).max(16),
+  purpose: Label,
+  displayNoun: Label
+});
+
 // packages/plugin-protocol/dist/permissions.js
 var WEB_SESSION_CSRF_SELECTOR_PATTERN = /^(?=.)(?:[a-zA-Z][a-zA-Z0-9-]*)?(?:#[a-zA-Z_][\w-]*|\[[a-zA-Z_:][\w:.-]*(?:=(?:"[^"]*"|'[^']*'|[\w-]+))?\])*$/u;
 var RETIRED_PERMISSION_ASK_KEYS = [
@@ -1321,39 +1366,39 @@ var RETIRED_PERMISSION_ASK_KEYS = [
 var RETIRED_WEB_SESSION_ROW_KEYS = ["operations"];
 function createPermissionsSchemas(canonical) {
   const { AuthSchemeReference: AuthSchemeReference2, AuthServiceReference: AuthServiceReference2, GlobalContributionId: GlobalContributionId2, LocalContributionId: LocalContributionId2, NonEmptyString: NonEmptyString3 } = canonical ? canonicalCommonSchemas : common_exports;
-  const AuthGrantOperation2 = z9.enum([
+  const AuthGrantOperation2 = z10.enum([
     "status",
     "list",
     "connect",
     "disconnect",
     "resolve"
   ]);
-  const AuthAccountSelector2 = z9.discriminatedUnion("kind", [
-    z9.strictObject({ kind: z9.literal("active") }),
-    z9.strictObject({
-      kind: z9.literal("account-id"),
+  const AuthAccountSelector2 = z10.discriminatedUnion("kind", [
+    z10.strictObject({ kind: z10.literal("active") }),
+    z10.strictObject({
+      kind: z10.literal("account-id"),
       accountId: NonEmptyString3
     }),
-    z9.strictObject({ kind: z9.literal("record-id"), recordId: NonEmptyString3 })
+    z10.strictObject({ kind: z10.literal("record-id"), recordId: NonEmptyString3 })
   ]);
-  const AuthScopeDefinition2 = z9.strictObject({
+  const AuthScopeDefinition2 = z10.strictObject({
     id: NonEmptyString3,
     label: NonEmptyString3,
     description: NonEmptyString3,
-    documentationUrl: z9.url().optional()
+    documentationUrl: z10.url().optional()
   });
-  const ScopeNeed2 = z9.strictObject({
+  const ScopeNeed2 = z10.strictObject({
     scope: NonEmptyString3,
     reason: NonEmptyString3.exactOptional()
   });
-  const ScopeAlternative2 = z9.strictObject({
-    allOf: z9.array(ScopeNeed2).min(1)
+  const ScopeAlternative2 = z10.strictObject({
+    allOf: z10.array(ScopeNeed2).min(1)
   });
-  const ScopeRequirement2 = z9.strictObject({
+  const ScopeRequirement2 = z10.strictObject({
     purpose: NonEmptyString3,
-    alternatives: z9.array(ScopeAlternative2).min(1)
+    alternatives: z10.array(ScopeAlternative2).min(1)
   });
-  const AuthGrantFrontDoor2 = z9.strictObject({
+  const AuthGrantFrontDoor2 = z10.strictObject({
     /**
      * The door id: the id `service_connect` takes (`gmail`). Never a registered auth service's id, and
      * not the grant's `service`, which names the shared sign-in the door expands.
@@ -1365,15 +1410,20 @@ function createPermissionsSchemas(canonical) {
      * first connect chains into a pick. `selection`: the scope already reaches every file of the
      * type, and the pick only records which ones the person meant.
      */
-    resourcePicker: z9.strictObject({
-      effect: z9.enum(["selection", "resource-grant"]),
+    resourcePicker: z10.strictObject({
+      effect: z10.enum(["selection", "resource-grant"]),
       /** The file types the picker offers. */
-      mimeTypes: z9.array(NonEmptyString3.max(255)).min(1).max(32).optional(),
+      mimeTypes: z10.array(NonEmptyString3.max(255)).min(1).max(32).optional(),
       /** What the agent is told about the picked set once the pick lands. */
-      successNote: NonEmptyString3.max(2048).optional()
+      successNote: NonEmptyString3.max(2048).optional(),
+      round: PluginPickerRound.optional(),
+      completion: z10.strictObject({
+        pluginId: z10.string().min(1),
+        moduleId: z10.string().min(1)
+      }).optional()
     }).optional()
   });
-  const AuthGrantRequestBase = z9.strictObject({
+  const AuthGrantRequestBase = z10.strictObject({
     // A local (undotted) service must be declared in this same manifest; a
     // qualified (dotted) service names another plugin's global id and is an
     // external service dependency, recorded on the resolved contract's
@@ -1382,22 +1432,22 @@ function createPermissionsSchemas(canonical) {
     // Optional for backward compatibility with grants whose service has a
     // single unambiguous scheme. Local ids resolve under the service owner's
     // namespace; qualified ids are preserved.
-    schemes: z9.array(AuthSchemeReference2).min(1).optional(),
-    operations: z9.array(AuthGrantOperation2).min(1),
-    purposes: z9.array(NonEmptyString3).optional(),
+    schemes: z10.array(AuthSchemeReference2).min(1).optional(),
+    operations: z10.array(AuthGrantOperation2).min(1),
+    purposes: z10.array(NonEmptyString3).optional(),
     // Bridged by the runtime into an enforceable `CredentialGrant`:
     // `allowedScopes` is the caller's scope ENVELOPE and
     // `accountSelectors` map through. Absent `accountSelectors` resolves to the
     // narrowest bound (see `ResolvedAuthGrantRequest`); absent scope envelope
     // leaves the bridged grant scope-agnostic.
-    allowedScopes: z9.array(NonEmptyString3).min(1).optional(),
+    allowedScopes: z10.array(NonEmptyString3).min(1).optional(),
     // Legacy spelling for `allowedScopes`; new manifests should use the authority-shaped name.
-    requiredScopes: z9.array(NonEmptyString3).min(1).optional(),
+    requiredScopes: z10.array(NonEmptyString3).min(1).optional(),
     // Preferred proactive consent bundle; runtime resolution still uses `scopeRequirement`.
-    connectScopes: z9.array(NonEmptyString3).min(1).optional(),
+    connectScopes: z10.array(NonEmptyString3).min(1).optional(),
     scopeRequirement: ScopeRequirement2.optional(),
-    scopeDefinitions: z9.array(AuthScopeDefinition2).min(1).optional(),
-    accountSelectors: z9.array(AuthAccountSelector2).min(1).optional(),
+    scopeDefinitions: z10.array(AuthScopeDefinition2).min(1).optional(),
+    accountSelectors: z10.array(AuthAccountSelector2).min(1).optional(),
     frontDoor: AuthGrantFrontDoor2.optional()
   });
   function validateAuthGrantRequest(grant, ctx) {
@@ -1485,19 +1535,19 @@ function createPermissionsSchemas(canonical) {
     }
   }
   const AuthGrantRequest2 = AuthGrantRequestBase.superRefine(validateAuthGrantRequest);
-  const StorageGrantRequest2 = z9.strictObject({
-    kind: z9.enum(["sqlite", "dataDir"]),
-    operations: z9.array(z9.enum(["open", "read", "write"])).min(1)
+  const StorageGrantRequest2 = z10.strictObject({
+    kind: z10.enum(["sqlite", "dataDir"]),
+    operations: z10.array(z10.enum(["open", "read", "write"])).min(1)
   });
-  const EventGrantRequest2 = z9.strictObject({
+  const EventGrantRequest2 = z10.strictObject({
     event: NonEmptyString3,
-    operations: z9.array(z9.enum(["subscribe", "publish"])).min(1)
+    operations: z10.array(z10.enum(["subscribe", "publish"])).min(1)
   });
-  const EndpointGrantRequest2 = z9.strictObject({
+  const EndpointGrantRequest2 = z10.strictObject({
     endpoint: LocalContributionId2,
-    operations: z9.array(z9.enum(["register", "invoke"])).min(1)
+    operations: z10.array(z10.enum(["register", "invoke"])).min(1)
   });
-  const WebSessionOrigin = z9.string().superRefine((value, ctx) => {
+  const WebSessionOrigin = z10.string().superRefine((value, ctx) => {
     try {
       const url = new URL(value);
       if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "" || url.origin !== value) {
@@ -1510,7 +1560,7 @@ function createPermissionsSchemas(canonical) {
       ctx.addIssue({ code: "custom", message: "must be a valid HTTPS origin" });
     }
   });
-  const WebSessionCsrfSourceUrl = z9.url({ protocol: /^https$/ }).superRefine((value, ctx) => {
+  const WebSessionCsrfSourceUrl = z10.url({ protocol: /^https$/ }).superRefine((value, ctx) => {
     const url = new URL(value);
     if (url.username !== "" || url.password !== "" || url.hash !== "") {
       ctx.addIssue({
@@ -1552,10 +1602,10 @@ function createPermissionsSchemas(canonical) {
     }
   });
   const WebSessionCsrfSelector2 = NonEmptyString3.regex(WEB_SESSION_CSRF_SELECTOR_PATTERN, "must be a compound simple selector: optional tag, then #id or [attr=value] predicates on that one element (no combinators, classes, or pseudo-classes)");
-  const WebSessionGrantRequest2 = z9.strictObject({
+  const WebSessionGrantRequest2 = z10.strictObject({
     origin: WebSessionOrigin,
-    pathPrefixes: z9.array(WebSessionPathPrefix).min(1),
-    csrf: z9.strictObject({
+    pathPrefixes: z10.array(WebSessionPathPrefix).min(1),
+    csrf: z10.strictObject({
       sourceUrl: WebSessionCsrfSourceUrl,
       selector: WebSessionCsrfSelector2,
       attribute: NonEmptyString3,
@@ -1564,14 +1614,14 @@ function createPermissionsSchemas(canonical) {
       bodyField: NonEmptyString3.optional()
     }).optional()
   });
-  const KnowledgeSearchGrantRequest2 = z9.strictObject({
-    scope: z9.literal("own-schemes")
+  const KnowledgeSearchGrantRequest2 = z10.strictObject({
+    scope: z10.literal("own-schemes")
   });
-  const KnownResourcesGrantRequest2 = z9.strictObject({
-    scope: z9.literal("own-modules")
+  const KnownResourcesGrantRequest2 = z10.strictObject({
+    scope: z10.literal("own-modules")
   });
-  const PluginAgentDefinitionPermissionRule2 = z9.strictObject({
-    effect: z9.enum(["allow", "deny", "ask"]),
+  const PluginAgentDefinitionPermissionRule2 = z10.strictObject({
+    effect: z10.enum(["allow", "deny", "ask"]),
     /** Restrict to one tool name. */
     tool: NonEmptyString3.optional(),
     /** Restrict to one classified capability key. */
@@ -1581,7 +1631,7 @@ function createPermissionsSchemas(canonical) {
     /** Restrict to matching resources (a path glob, or a URI-shaped policy address). */
     resource: NonEmptyString3.optional(),
     /** Restrict the rule to one permission mode; omit to apply in all modes. */
-    mode: z9.enum(["default", "ask", "allow", "auto"]).optional()
+    mode: z10.enum(["default", "ask", "allow", "auto"]).optional()
   });
   function stripRetiredPermissionAsks(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -1603,14 +1653,14 @@ function createPermissionsSchemas(canonical) {
     }
     return remaining;
   }
-  const TargetPermissionWiring2 = z9.strictObject({
-    auth: z9.array(AuthGrantRequest2).optional(),
-    storage: z9.array(StorageGrantRequest2).optional(),
-    events: z9.array(EventGrantRequest2).optional(),
-    endpoints: z9.array(EndpointGrantRequest2).optional(),
-    webSession: z9.array(WebSessionGrantRequest2).optional(),
-    knowledgeSearch: z9.array(KnowledgeSearchGrantRequest2).optional(),
-    knownResources: z9.array(KnownResourcesGrantRequest2).optional()
+  const TargetPermissionWiring2 = z10.strictObject({
+    auth: z10.array(AuthGrantRequest2).optional(),
+    storage: z10.array(StorageGrantRequest2).optional(),
+    events: z10.array(EventGrantRequest2).optional(),
+    endpoints: z10.array(EndpointGrantRequest2).optional(),
+    webSession: z10.array(WebSessionGrantRequest2).optional(),
+    knowledgeSearch: z10.array(KnowledgeSearchGrantRequest2).optional(),
+    knownResources: z10.array(KnownResourcesGrantRequest2).optional()
   }).superRefine((permissions, ctx) => {
     const rows = permissions.webSession ?? [];
     for (const [index, row] of rows.entries()) {
@@ -1628,9 +1678,9 @@ function createPermissionsSchemas(canonical) {
       }
     }
   });
-  const TargetPermissionSet2 = canonical ? TargetPermissionWiring2 : z9.preprocess(stripRetiredPermissionAsks, TargetPermissionWiring2);
-  const PluginPermissionManifest2 = z9.strictObject({
-    byTarget: z9.strictObject({
+  const TargetPermissionSet2 = canonical ? TargetPermissionWiring2 : z10.preprocess(stripRetiredPermissionAsks, TargetPermissionWiring2);
+  const PluginPermissionManifest2 = z10.strictObject({
+    byTarget: z10.strictObject({
       "kay.agent": TargetPermissionSet2.optional(),
       "kay.app": TargetPermissionSet2.optional(),
       "kay.ui": TargetPermissionSet2.optional()
@@ -1648,26 +1698,26 @@ function createPermissionsSchemas(canonical) {
   });
   const ResolvedAuthGrantRequest2 = AuthGrantRequestBase.extend({
     service: GlobalContributionId2,
-    schemes: z9.array(GlobalContributionId2).min(1).optional(),
+    schemes: z10.array(GlobalContributionId2).min(1).optional(),
     // Resolution fills an absent binding with the narrowest bound, so a resolved
     // grant ALWAYS carries an explicit, non-broadening account selector - the
     // runtime never has to invent a default and fail open.
-    accountSelectors: z9.array(AuthAccountSelector2).min(1)
+    accountSelectors: z10.array(AuthAccountSelector2).min(1)
   }).superRefine(validateAuthGrantRequest);
   const ResolvedEndpointGrantRequest2 = EndpointGrantRequest2.extend({
     endpoint: GlobalContributionId2
   });
-  const ResolvedTargetGrantSet2 = z9.strictObject({
-    auth: z9.array(ResolvedAuthGrantRequest2).optional(),
-    storage: z9.array(StorageGrantRequest2).optional(),
-    events: z9.array(EventGrantRequest2).optional(),
-    endpoints: z9.array(ResolvedEndpointGrantRequest2).optional(),
-    webSession: z9.array(WebSessionGrantRequest2).optional(),
-    knowledgeSearch: z9.array(KnowledgeSearchGrantRequest2).optional(),
-    knownResources: z9.array(KnownResourcesGrantRequest2).optional()
-  });
-  const ResolvedPluginGrants2 = z9.strictObject({
-    byTarget: z9.strictObject({
+  const ResolvedTargetGrantSet2 = z10.strictObject({
+    auth: z10.array(ResolvedAuthGrantRequest2).optional(),
+    storage: z10.array(StorageGrantRequest2).optional(),
+    events: z10.array(EventGrantRequest2).optional(),
+    endpoints: z10.array(ResolvedEndpointGrantRequest2).optional(),
+    webSession: z10.array(WebSessionGrantRequest2).optional(),
+    knowledgeSearch: z10.array(KnowledgeSearchGrantRequest2).optional(),
+    knownResources: z10.array(KnownResourcesGrantRequest2).optional()
+  });
+  const ResolvedPluginGrants2 = z10.strictObject({
+    byTarget: z10.strictObject({
       "kay.agent": ResolvedTargetGrantSet2.optional(),
       "kay.app": ResolvedTargetGrantSet2.optional(),
       "kay.ui": ResolvedTargetGrantSet2.optional()
@@ -1818,24 +1868,24 @@ var AGENT_PERMISSION_RULE_FIELDS = [
 function createAuthoritySchemas(canonical) {
   const { ArtifactGenerationId: ArtifactGenerationId2, NonEmptyString: NonEmptyString3, UriScheme: UriScheme2, PluginId: PluginId2, LocalContributionId: LocalContributionId2 } = canonical ? canonicalCommonSchemas : common_exports;
   const { PluginAgentDefinitionPermissionRule: PluginAgentDefinitionPermissionRule2 } = canonical ? canonicalPermissionSchemas : permissions_exports;
-  const WhiteboardCapabilityScope2 = z10.enum(["own-types", "all-types"]);
-  const WhiteboardCapabilityOperation2 = z10.enum([
+  const WhiteboardCapabilityScope2 = z11.enum(["own-types", "all-types"]);
+  const WhiteboardCapabilityOperation2 = z11.enum([
     "discover",
     "read",
     "create",
     "update",
     "remove"
   ]);
-  const WhiteboardCapabilityClaimV12 = z10.strictObject({
-    target: z10.enum(["kay.agent", "kay.app"]),
-    slug: z10.enum([
+  const WhiteboardCapabilityClaimV12 = z11.strictObject({
+    target: z11.enum(["kay.agent", "kay.app"]),
+    slug: z11.enum([
       "whiteboard.discover",
       "whiteboard.read",
       "whiteboard.create",
       "whiteboard.update",
       "whiteboard.remove"
     ]),
-    envelope: z10.strictObject({ scope: WhiteboardCapabilityScope2 })
+    envelope: z11.strictObject({ scope: WhiteboardCapabilityScope2 })
   }).superRefine((claim, ctx) => {
     if (claim.target === "kay.app" && claim.slug !== "whiteboard.discover" && claim.slug !== "whiteboard.read") {
       ctx.addIssue({
@@ -1845,167 +1895,167 @@ function createAuthoritySchemas(canonical) {
       });
     }
   });
-  const DeclaredSkillSourceEnvelope2 = z10.discriminatedUnion("channel", [
-    z10.strictObject({
-      channel: z10.literal("git-clone"),
+  const DeclaredSkillSourceEnvelope2 = z11.discriminatedUnion("channel", [
+    z11.strictObject({
+      channel: z11.literal("git-clone"),
       locator: NonEmptyString3,
       ref: NonEmptyString3.optional(),
       subdir: NonEmptyString3.optional()
     }),
-    z10.strictObject({
-      channel: z10.literal("installer"),
+    z11.strictObject({
+      channel: z11.literal("installer"),
       command: NonEmptyString3,
-      args: z10.array(NonEmptyString3)
+      args: z11.array(NonEmptyString3)
     })
   ]);
-  const PluginCapabilityClaimV12 = z10.discriminatedUnion("slug", [
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("sessions.run"),
-      envelope: z10.strictObject({})
+  const PluginCapabilityClaimV12 = z11.discriminatedUnion("slug", [
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("sessions.run"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("network.connect"),
-      envelope: z10.strictObject({ connect: NonEmptyString3 })
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("network.connect"),
+      envelope: z11.strictObject({ connect: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("web-session.request"),
-      envelope: z10.strictObject({
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("web-session.request"),
+      envelope: z11.strictObject({
         origin: NonEmptyString3,
         pathPrefix: NonEmptyString3
       })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("web-session.download"),
-      envelope: z10.strictObject({
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("web-session.download"),
+      envelope: z11.strictObject({
         origin: NonEmptyString3,
         pathPrefix: NonEmptyString3
       })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("process.spawn"),
-      envelope: z10.strictObject({
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("process.spawn"),
+      envelope: z11.strictObject({
         command: NonEmptyString3,
         argvClass: NonEmptyString3
       })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("sessions.read"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("sessions.read"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Every plugin's recorded Jev signals, not only the caller's own: an empty envelope because
       // the grant itself is the visibility decision. Both first consumers (a session timeline, and
       // an agent loop turning signals into skills) read rows another plugin recorded.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("signals.read"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("signals.read"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.enum(["kay.agent", "kay.app"]),
-      slug: z10.literal("uri.call"),
-      envelope: z10.strictObject({
+    z11.strictObject({
+      target: z11.enum(["kay.agent", "kay.app"]),
+      slug: z11.literal("uri.call"),
+      envelope: z11.strictObject({
         scheme: UriScheme2,
-        verb: z10.enum(["read", "list", "search", "write", "edit", "delete"])
+        verb: z11.enum(["read", "list", "search", "write", "edit", "delete"])
       })
     }),
-    z10.strictObject({
-      target: z10.enum(["kay.agent", "kay.app"]),
-      slug: z10.literal("endpoints.invoke"),
-      envelope: z10.strictObject({
+    z11.strictObject({
+      target: z11.enum(["kay.agent", "kay.app"]),
+      slug: z11.literal("endpoints.invoke"),
+      envelope: z11.strictObject({
         pluginId: PluginId2,
         endpointId: LocalContributionId2
       })
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Read every managed skill and its history: identity, versions, revisions, changes against
       // the source, past versions, suggestions. Never a write. An empty envelope because the
       // grant itself is the visibility decision, as with `signals.read`.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("skills.read"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("skills.read"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Change, install and delete the user's skills. Every write follows the same rules an
       // agent's `skill://` write does, and each revision records the plugin that made it.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("skills.write"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("skills.write"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Publish a share plan `skills.prepareShare` built: push the user's skill, with their git
       // credentials, into a marketplace repository other people's installs read. Private
       // (PRIVATE_PLUGIN_CAPABILITY_SLUGS): the host has no consent prompt for an SDK call that
       // sends data off the machine.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("skills.share"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("skills.share"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Turn an installed plugin on or off, which starts or stops its code under its own grants.
       // Private (PRIVATE_PLUGIN_CAPABILITY_SLUGS): a plugin holding it could turn back on what the
       // user turned off.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("plugins.set-enabled"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("plugins.set-enabled"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Write a steward entry (recap, next steps, title, work headlines) into the session whose
       // event the calling handler is answering. Bound to that session: a call for any other is
       // refused. The daemon keeps its own bounds on every field.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("sessions.annotate"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("sessions.annotate"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Compact the session whose event the calling handler is answering. Its own claim because
       // compaction rewrites the live context and spends a model call; the daemon keeps the user's
       // consent switch and the context floor in front of it.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("sessions.compact"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("sessions.compact"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Read and rewrite the soul file every new conversation is told. Private
       // (PRIVATE_PLUGIN_CAPABILITY_SLUGS): only a plugin the release carries may hold it.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("soul.write"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("soul.write"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // The text an agent sees for a tool or an address in a live session, where each comes from,
       // and whether it is one of Bonsai's own. Read-only and never a call. An empty envelope because
       // the grant itself is the visibility decision, as with `skills.read`.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("tools.describe"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("tools.describe"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("workspace.command"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("workspace.command"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("sessions.create"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("sessions.create"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("sessions.update"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("sessions.update"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("models.complete"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("models.complete"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Held to `kay.app`, the daemon-lifetime tier, even though the same System One client is exposed on
       // BOTH the `kay.app` and `kay.agent` plugin SDKs (and to host composition directly): a slug
       // pins exactly one target (see this file's module doc), so one shared claim is simpler and
@@ -2014,195 +2064,195 @@ function createAuthoritySchemas(canonical) {
       // plugin's own pinned authority, which already spans both targets for every other capability
       // (`network.connect`/`tool-interception.register` are decided by the identical per-plugin
       // handle `kay.app`-target claims use). `app.systemOne` authorizes against it the same way.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("systemOne.use"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("systemOne.use"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("automations.write"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("automations.write"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("automations.run"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("automations.run"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("workflows.define"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("workflows.define"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Start a declared workflow on every plugin's signal events (`signals: true`), which carry
       // other plugins' data. Private (PRIVATE_PLUGIN_CAPABILITY_SLUGS): only a plugin the release
       // carries may hold it, so a third-party plugin cannot read every source's signals.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("workflows.signals"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("workflows.signals"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("session-events.subscribe"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("session-events.subscribe"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("agents.run"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("agents.run"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("dynamic-context.register"),
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("dynamic-context.register"),
       // The declared `contributes.contextContributors` localId, which doubles as the contributor's
       // section tag at the model boundary - so the row a human consents to names the section.
-      envelope: z10.strictObject({ contributor: NonEmptyString3 })
+      envelope: z11.strictObject({ contributor: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("app-data.register"),
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("app-data.register"),
       /** The declared `contributes.dataSources` localId. */
-      envelope: z10.strictObject({ source: NonEmptyString3 })
+      envelope: z11.strictObject({ source: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("session-artifacts.read"),
-      envelope: z10.strictObject({ kind: z10.enum(["upload", "output"]) })
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("session-artifacts.read"),
+      envelope: z11.strictObject({ kind: z11.enum(["upload", "output"]) })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("session-artifacts.create"),
-      envelope: z10.strictObject({ kind: z10.literal("output") })
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("session-artifacts.create"),
+      envelope: z11.strictObject({ kind: z11.literal("output") })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("artifacts.read"),
-      envelope: z10.strictObject({ kind: z10.literal("output") })
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("artifacts.read"),
+      envelope: z11.strictObject({ kind: z11.literal("output") })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("knowledge-source.register"),
-      envelope: z10.strictObject({ source: NonEmptyString3 })
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("knowledge-source.register"),
+      envelope: z11.strictObject({ source: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("account.assert"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("account.assert"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("account.update"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("account.update"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.app"),
-      slug: z10.literal("agents.permissions"),
-      envelope: z10.strictObject({
+    z11.strictObject({
+      target: z11.literal("kay.app"),
+      slug: z11.literal("agents.permissions"),
+      envelope: z11.strictObject({
         /** The definition's local id - WHICH agent these rules are authored onto. */
         agent: NonEmptyString3,
         /** `definition.permissions`, in declaration order (order is semantic; first match wins). */
-        rules: z10.array(PluginAgentDefinitionPermissionRule2),
+        rules: z11.array(PluginAgentDefinitionPermissionRule2),
         /** `definition.permissionsFallback`, in declaration order. */
-        fallback: z10.array(PluginAgentDefinitionPermissionRule2)
+        fallback: z11.array(PluginAgentDefinitionPermissionRule2)
       })
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("tool-interception.register"),
-      envelope: z10.strictObject({})
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("tool-interception.register"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("kay.agent"),
-      slug: z10.literal("interaction.surface"),
+    z11.strictObject({
+      target: z11.literal("kay.agent"),
+      slug: z11.literal("interaction.surface"),
       /** The one Bonsai-shipped interaction surface this plugin may drive; one claim per surface. */
-      envelope: z10.strictObject({
-        surface: z10.enum(["browser-pane", "desktop"])
+      envelope: z11.strictObject({
+        surface: z11.enum(["browser-pane", "desktop"])
       })
     }),
-    z10.strictObject({
-      target: z10.literal("plugin"),
-      slug: z10.literal("config.declare-section"),
+    z11.strictObject({
+      target: z11.literal("plugin"),
+      slug: z11.literal("config.declare-section"),
       /** The settings-document section key, e.g. `models` or `plugins.com.acme.thing`. */
-      envelope: z10.strictObject({ section: NonEmptyString3 })
+      envelope: z11.strictObject({ section: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("plugin"),
-      slug: z10.literal("auth.own-service"),
+    z11.strictObject({
+      target: z11.literal("plugin"),
+      slug: z11.literal("auth.own-service"),
       /** The minted global service id this plugin would own, e.g. `google.account`. */
-      envelope: z10.strictObject({ service: NonEmptyString3 })
+      envelope: z11.strictObject({ service: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("plugin"),
-      slug: z10.literal("auth.shared-identity"),
+    z11.strictObject({
+      target: z11.literal("plugin"),
+      slug: z11.literal("auth.shared-identity"),
       /** The foreign global service id whose identity this plugin would resolve against. */
-      envelope: z10.strictObject({ service: NonEmptyString3 })
+      envelope: z11.strictObject({ service: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("plugin"),
-      slug: z10.literal("cli.bind"),
+    z11.strictObject({
+      target: z11.literal("plugin"),
+      slug: z11.literal("cli.bind"),
       /** The binary basename a resolved credential would be injected into. */
-      envelope: z10.strictObject({ binary: NonEmptyString3 })
+      envelope: z11.strictObject({ binary: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("plugin"),
-      slug: z10.literal("mcp.host-server"),
+    z11.strictObject({
+      target: z11.literal("plugin"),
+      slug: z11.literal("mcp.host-server"),
       // The daemon dials this endpoint, holds its sign-in, and serves it as `mcp://<name>`, so the
       // endpoint becomes daemon execution authority. It also lets the plugin's own code call any of
       // the server's tools, writes included, through `api.vendoredMcp`, which the per-tool
       // `mcp:<server>::<tool>` permission rows do not gate. One claim per exact name and URL.
-      envelope: z10.strictObject({ name: NonEmptyString3, url: NonEmptyString3 })
+      envelope: z11.strictObject({ name: NonEmptyString3, url: NonEmptyString3 })
     }),
-    z10.strictObject({
-      target: z10.literal("plugin"),
-      slug: z10.literal("prompt.resident"),
+    z11.strictObject({
+      target: z11.literal("plugin"),
+      slug: z11.literal("prompt.resident"),
       // A section of the plugin's own text in every session's system prompt. An empty envelope
       // because the grant itself is the decision; the host caps the section's length.
-      envelope: z10.strictObject({})
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Private API: registering the policy the daemon consults to pick a chat's model as it goes
       // (`app.modelSelection.registerPolicy`). Only a plugin the release carries holds it.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("model-selection.register"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("model-selection.register"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
+    z11.strictObject({
       // Private API: adding text to every chat's system prompt (`app.systemPrompt.register`).
       // Only a plugin the release carries holds it, so the text has no length cap yet.
-      target: z10.literal("kay.app"),
-      slug: z10.literal("system-prompt.register"),
-      envelope: z10.strictObject({})
+      target: z11.literal("kay.app"),
+      slug: z11.literal("system-prompt.register"),
+      envelope: z11.strictObject({})
     }),
-    z10.strictObject({
-      target: z10.literal("plugin"),
-      slug: z10.literal("skills.declared-source"),
+    z11.strictObject({
+      target: z11.literal("plugin"),
+      slug: z11.literal("skills.declared-source"),
       envelope: DeclaredSkillSourceEnvelope2
     }),
     WhiteboardCapabilityClaimV12
   ]);
-  const PluginCapabilityRefusalLayer2 = z10.enum(["grant", "binding", "release"]);
-  const PluginCapabilityRefusalCode2 = z10.enum([
+  const PluginCapabilityRefusalLayer2 = z11.enum(["grant", "binding", "release"]);
+  const PluginCapabilityRefusalCode2 = z11.enum([
     "not-granted",
     "grant-read-failed",
     "binding-missing",
     "argv-outside-class",
     "builtin-only"
   ]);
-  const PluginCapabilityRefusalV12 = z10.strictObject({
+  const PluginCapabilityRefusalV12 = z11.strictObject({
     claim: PluginCapabilityClaimV12,
     layer: PluginCapabilityRefusalLayer2,
     code: PluginCapabilityRefusalCode2,
     message: NonEmptyString3,
     artifactGenerationId: ArtifactGenerationId2.optional()
   });
-  const PluginCapabilityDecisionV12 = z10.discriminatedUnion("kind", [
-    z10.strictObject({
-      kind: z10.literal("allowed"),
+  const PluginCapabilityDecisionV12 = z11.discriminatedUnion("kind", [
+    z11.strictObject({
+      kind: z11.literal("allowed"),
       claim: PluginCapabilityClaimV12,
       artifactGenerationId: ArtifactGenerationId2.optional()
     }),
-    z10.strictObject({
-      kind: z10.literal("refused"),
+    z11.strictObject({
+      kind: z11.literal("refused"),
       refusal: PluginCapabilityRefusalV12
     })
   ]);
@@ -2220,7 +2270,7 @@ function createAuthoritySchemas(canonical) {
 }
 var { WhiteboardCapabilityScope, WhiteboardCapabilityOperation, WhiteboardCapabilityClaimV1, DeclaredSkillSourceEnvelope, PluginCapabilityClaimV1, PluginCapabilityRefusalLayer, PluginCapabilityRefusalCode, PluginCapabilityRefusalV1, PluginCapabilityDecisionV1 } = createAuthoritySchemas(false);
 var canonicalAuthoritySchemas = createAuthoritySchemas(true);
-var PluginCapabilityClaimInputV1 = z10.custom((value) => PluginCapabilityClaimV1.safeParse(value).success, "Invalid capability claim");
+var PluginCapabilityClaimInputV1 = z11.custom((value) => PluginCapabilityClaimV1.safeParse(value).success, "Invalid capability claim");
 function normalizeNetworkConnectHost(value) {
   const trimmed = value.trim();
   if (trimmed.length === 0)
@@ -2830,7 +2880,7 @@ __export(contributions_exports, {
   isUiAppSourceModule: () => isUiAppSourceModule,
   uiAppSourceStylePath: () => uiAppSourceStylePath
 });
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // packages/plugin-protocol/dist/plugin-events.js
 var plugin_events_exports = {};
@@ -2857,7 +2907,7 @@ __export(plugin_events_exports, {
   canonicalPluginEventSchemas: () => canonicalPluginEventSchemas,
   pluginSignalPayloadJsonSchema: () => pluginSignalPayloadJsonSchema
 });
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // packages/plugin-protocol/dist/plugin-signal-limits.js
 var PLUGIN_EVENT_REFUSED_ERROR_NAME = "PluginEventRefusedError";
@@ -2883,8 +2933,8 @@ var PLUGIN_SIGNAL_RELATED_KEYS = [
 var PLUGIN_EVENT_ID_MAX_BYTES = 1024;
 function createPluginEventsSchemas(canonical) {
   const { GlobalContributionId: GlobalContributionId2, NonEmptyString: NonEmptyString3 } = canonical ? canonicalCommonSchemas : common_exports;
-  const PluginEventLocalId2 = z11.string().regex(/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/);
-  const PluginEventUri2 = z11.string().refine((value) => {
+  const PluginEventLocalId2 = z12.string().regex(/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/);
+  const PluginEventUri2 = z12.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 {
@@ -2893,24 +2943,24 @@ function createPluginEventsSchemas(canonical) {
       return false;
     }
   }, { message: "Expected an absolute resource URI" });
-  const PluginEventTimestamp2 = z11.iso.datetime().refine((value) => !/\.\d{10}/.test(value), {
+  const PluginEventTimestamp2 = z12.iso.datetime().refine((value) => !/\.\d{10}/.test(value), {
     message: "Expected an ISO instant with at most nanosecond precision"
   });
-  const PluginEventRelated2 = z11.record(NonEmptyString3, z11.union([PluginEventUri2, z11.array(PluginEventUri2)]));
-  const PluginEventPublishSource2 = z11.strictObject({
+  const PluginEventRelated2 = z12.record(NonEmptyString3, z12.union([PluginEventUri2, z12.array(PluginEventUri2)]));
+  const PluginEventPublishSource2 = z12.strictObject({
     poller: NonEmptyString3.optional(),
     runId: NonEmptyString3.optional()
   });
-  const PluginEventSource2 = z11.strictObject({
-    layer: z11.literal("runtime"),
+  const PluginEventSource2 = z12.strictObject({
+    layer: z12.literal("runtime"),
     pluginId: NonEmptyString3,
     sessionId: NonEmptyString3.optional(),
     ...PluginEventPublishSource2.shape
   });
-  const PluginEventId2 = z11.string().min(1).refine((value) => value === value.trim() && !/\p{Cc}/u.test(value) && new TextEncoder().encode(value).length <= PLUGIN_EVENT_ID_MAX_BYTES, {
+  const PluginEventId2 = z12.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"
   });
-  const PluginEventPublishInput2 = z11.strictObject({
+  const PluginEventPublishInput2 = z12.strictObject({
     uri: PluginEventUri2,
     related: PluginEventRelated2.optional(),
     key: PluginEventId2.optional(),
@@ -2918,11 +2968,11 @@ function createPluginEventsSchemas(canonical) {
     source: PluginEventPublishSource2.optional(),
     payload: JsonValue.optional()
   });
-  const PluginEventEnvelope2 = z11.strictObject({
+  const PluginEventEnvelope2 = z12.strictObject({
     id: PluginEventId2,
     localId: PluginEventLocalId2,
     type: GlobalContributionId2,
-    version: z11.number().int().positive(),
+    version: z12.number().int().positive(),
     uri: PluginEventUri2,
     related: PluginEventRelated2.optional(),
     key: PluginEventPublishInput2.shape.key,
@@ -2931,30 +2981,30 @@ function createPluginEventsSchemas(canonical) {
     source: PluginEventSource2,
     payload: JsonValue.optional()
   });
-  const PluginSignal2 = z11.strictObject({
-    kind: z11.enum(PLUGIN_SIGNAL_KINDS),
-    direction: z11.enum(["in", "out"]).optional(),
-    title: z11.string().max(PLUGIN_SIGNAL_TITLE_MAX).optional(),
-    snippet: z11.string().max(PLUGIN_SIGNAL_SNIPPET_MAX).optional(),
-    actor: z11.strictObject({
-      name: z11.string().max(PLUGIN_SIGNAL_TITLE_MAX).optional(),
+  const PluginSignal2 = z12.strictObject({
+    kind: z12.enum(PLUGIN_SIGNAL_KINDS),
+    direction: z12.enum(["in", "out"]).optional(),
+    title: z12.string().max(PLUGIN_SIGNAL_TITLE_MAX).optional(),
+    snippet: z12.string().max(PLUGIN_SIGNAL_SNIPPET_MAX).optional(),
+    actor: z12.strictObject({
+      name: z12.string().max(PLUGIN_SIGNAL_TITLE_MAX).optional(),
       uri: PluginEventUri2
     }).optional(),
-    addressed: z11.enum(["direct", "cc", "mention", "group", "none"]).optional(),
-    labels: z11.array(z11.string().min(1).max(PLUGIN_SIGNAL_LABEL_MAX)).max(PLUGIN_SIGNAL_LABELS_MAX).optional(),
+    addressed: z12.enum(["direct", "cc", "mention", "group", "none"]).optional(),
+    labels: z12.array(z12.string().min(1).max(PLUGIN_SIGNAL_LABEL_MAX)).max(PLUGIN_SIGNAL_LABELS_MAX).optional(),
     dueAt: PluginEventTimestamp2.optional(),
-    state: z11.enum(["open", "resolved"]).optional()
+    state: z12.enum(["open", "resolved"]).optional()
   }).refine((signal) => signal.state === void 0 || signal.kind === "status", {
     message: "state is only for a status signal",
     path: ["state"]
   });
-  const PluginSignalRelatedValue = z11.union([
+  const PluginSignalRelatedValue = z12.union([
     PluginEventUri2,
-    z11.array(PluginEventUri2)
+    z12.array(PluginEventUri2)
   ]);
-  const PluginSignalPublish2 = z11.object({
+  const PluginSignalPublish2 = z12.object({
     payload: PluginSignal2,
-    related: z11.strictObject({
+    related: z12.strictObject({
       thread: PluginEventUri2,
       from: PluginSignalRelatedValue.optional(),
       to: PluginSignalRelatedValue.optional(),
@@ -2978,7 +3028,7 @@ function createPluginEventsSchemas(canonical) {
 var { PluginSignal, PluginSignalPublish, PluginEventLocalId, PluginEventUri, PluginEventTimestamp, PluginEventRelated, PluginEventPublishSource, PluginEventSource, PluginEventId, PluginEventPublishInput, PluginEventEnvelope } = createPluginEventsSchemas(false);
 var canonicalPluginEventSchemas = createPluginEventsSchemas(true);
 function pluginSignalPayloadJsonSchema() {
-  return z11.toJSONSchema(PluginSignal, {
+  return z12.toJSONSchema(PluginSignal, {
     io: "input",
     unrepresentable: "any"
   });
@@ -3333,22 +3383,22 @@ function createContributionsSchemas(canonical) {
   const { AuthSchemeReference: AuthSchemeReference2, AuthServiceReference: AuthServiceReference2, CliAuthEnvVarName: CliAuthEnvVarName2, CliBinaryName: CliBinaryName2, FileExtensionToken: FileExtensionToken2, GitBasicAuthUser: GitBasicAuthUser2, GitHostName: GitHostName2, LocalContributionId: LocalContributionId2, MimeTypeString: MimeTypeString2, NonEmptyString: NonEmptyString3, PackageAssetPath: PackageAssetPath2, PluginId: PluginId2, PluginToolName: PluginToolName2, TargetEntrypoint: TargetEntrypoint2, UriScheme: UriScheme2 } = canonical ? canonicalCommonSchemas : common_exports;
   const { ScopeRequirement: ScopeRequirement2 } = canonical ? canonicalPermissionSchemas : permissions_exports;
   const OptionalDisplayName = NonEmptyString3.optional();
-  const ApprovalCardValueName = z12.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/u, "must be a plain field name");
-  const ApprovalCardForm2 = z12.strictObject({
+  const ApprovalCardValueName = z13.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/u, "must be a plain field name");
+  const ApprovalCardForm2 = z13.strictObject({
     /** Where the write goes: a fixed address, or the card value that names one. */
-    uri: z12.union([
-      z12.strictObject({ fixed: NonEmptyString3 }),
-      z12.strictObject({ value: ApprovalCardValueName })
+    uri: z13.union([
+      z13.strictObject({ fixed: NonEmptyString3 }),
+      z13.strictObject({ value: ApprovalCardValueName })
     ]),
     /** The delivery request fields this kind of card accepts, beyond provider and account. */
-    requestFields: z12.array(ApprovalCardValueName).optional(),
+    requestFields: z13.array(ApprovalCardValueName).optional(),
     /** Payload field to the card value it is filled from. An absent value or empty list is left out. */
-    payload: z12.record(ApprovalCardValueName, ApprovalCardValueName),
+    payload: z13.record(ApprovalCardValueName, ApprovalCardValueName),
     /** Payload fields with a constant value. */
-    fixed: z12.record(ApprovalCardValueName, z12.union([z12.string(), z12.boolean()])).optional()
+    fixed: z13.record(ApprovalCardValueName, z13.union([z13.string(), z13.boolean()])).optional()
   });
   const ApprovalCardStoredForm2 = ApprovalCardForm2.extend({
-    read: z12.strictObject({
+    read: z13.strictObject({
       revision: ApprovalCardValueName,
       body: ApprovalCardValueName,
       subject: ApprovalCardValueName.optional(),
@@ -3359,13 +3409,13 @@ function createContributionsSchemas(canonical) {
       attachments: ApprovalCardValueName.optional()
     })
   });
-  const ApprovalCardField = z12.strictObject({
+  const ApprovalCardField = z13.strictObject({
     key: ApprovalCardValueName,
-    max: z12.number().int().positive()
+    max: z13.number().int().positive()
   });
-  const ApprovalTypeContribution2 = z12.strictObject({
+  const ApprovalTypeContribution2 = z13.strictObject({
     localId: LocalContributionId2,
-    kind: z12.literal("message"),
+    kind: z13.literal("message"),
     /** The URI scheme of `uriModule` that cards of this type write to. */
     provider: UriScheme2,
     /** The local id of this plugin's URI module that handles the write. */
@@ -3373,82 +3423,82 @@ function createContributionsSchemas(canonical) {
     /** Shown when a send's outcome cannot be confirmed: where the person checks. */
     unknownMessage: NonEmptyString3,
     /** The payload fields holding the text a person may edit. A `subject` makes this a mail type. */
-    fields: z12.strictObject({
+    fields: z13.strictObject({
       body: ApprovalCardField,
       subject: ApprovalCardField.optional()
     }),
-    presentation: z12.strictObject({
-      showAccount: z12.boolean(),
-      recipient: z12.enum(["person", "target"])
+    presentation: z13.strictObject({
+      showAccount: z13.boolean(),
+      recipient: z13.enum(["person", "target"])
     }),
     /** One form per kind of card this provider supports. A kind left out is never bound. */
-    forms: z12.strictObject({
+    forms: z13.strictObject({
       inline: ApprovalCardForm2.optional(),
       saved: ApprovalCardForm2.optional(),
       stored: ApprovalCardStoredForm2.optional()
     }),
     /** What the card shows beyond its text, read from the delivery request. */
-    display: z12.strictObject({
+    display: z13.strictObject({
       /** How the renderer reads the body. Absent is Markdown, or plain for a stored draft. */
-      bodyFormat: z12.literal("mrkdwn").optional(),
+      bodyFormat: z13.literal("mrkdwn").optional(),
       /** The request field naming what this card replies to. */
       replyField: ApprovalCardValueName.optional(),
       /** Shown instead of the reply's id when that id means nothing to a person. */
       replyLabel: NonEmptyString3.optional(),
       /** Further request fields shown as labelled lines. */
-      facts: z12.array(z12.strictObject({
+      facts: z13.array(z13.strictObject({
         label: NonEmptyString3,
         field: ApprovalCardValueName
       })).optional()
     }).optional()
   });
-  const ToolIdentity = z12.strictObject({
+  const ToolIdentity = z13.strictObject({
     localId: LocalContributionId2,
     toolName: PluginToolName2,
     displayName: OptionalDisplayName,
     description: NonEmptyString3.optional()
   });
-  const ToolPermission2 = z12.strictObject({
-    kind: z12.enum(["read", "mutate", "destructive", "execute"]),
+  const ToolPermission2 = z13.strictObject({
+    kind: z13.enum(["read", "mutate", "destructive", "execute"]),
     ruleKey: NonEmptyString3.optional(),
     scheme: NonEmptyString3.optional(),
-    resourcePrefix: z12.string().max(256).optional(),
+    resourcePrefix: z13.string().max(256).optional(),
     // Arguments whose string values name the resources a call touches.
-    resourceArgs: z12.array(NonEmptyString3).min(1).optional(),
-    resourceTrim: z12.literal(true).optional(),
-    defaultPermission: z12.enum(["allow", "ask", "never"]).optional(),
+    resourceArgs: z13.array(NonEmptyString3).min(1).optional(),
+    resourceTrim: z13.literal(true).optional(),
+    defaultPermission: z13.enum(["allow", "ask", "never"]).optional(),
     /** First matching rule wins; every condition in its when list must hold. */
-    classificationRules: z12.array(z12.strictObject({
-      when: z12.array(z12.union([
-        z12.strictObject({
+    classificationRules: z13.array(z13.strictObject({
+      when: z13.array(z13.union([
+        z13.strictObject({
           arg: NonEmptyString3,
-          equals: z12.union([
-            z12.string(),
-            z12.number(),
-            z12.boolean(),
-            z12.null()
+          equals: z13.union([
+            z13.string(),
+            z13.number(),
+            z13.boolean(),
+            z13.null()
           ])
         }),
-        z12.strictObject({ arg: NonEmptyString3, present: z12.boolean() })
+        z13.strictObject({ arg: NonEmptyString3, present: z13.boolean() })
       ])).min(1).max(32),
-      kind: z12.enum(["read", "mutate", "destructive", "execute"]),
+      kind: z13.enum(["read", "mutate", "destructive", "execute"]),
       ruleKey: NonEmptyString3.optional()
     })).min(1).max(64).optional()
   });
-  const ToolContribution2 = z12.strictObject({
+  const ToolContribution2 = z13.strictObject({
     ...ToolIdentity.shape,
     parameters: JsonSchema.optional(),
-    executionMode: z12.enum(["sequential", "parallel"]).optional(),
+    executionMode: z13.enum(["sequential", "parallel"]).optional(),
     promptSnippet: NonEmptyString3.optional(),
-    promptGuidelines: z12.array(NonEmptyString3).optional(),
+    promptGuidelines: z13.array(NonEmptyString3).optional(),
     permission: ToolPermission2.optional()
   });
-  const AgentToolContribution2 = z12.strictObject({
+  const AgentToolContribution2 = z13.strictObject({
     ...ToolContribution2.shape,
     parameters: JsonSchema.optional(),
-    executionMode: z12.enum(["sequential", "parallel"]).optional(),
+    executionMode: z13.enum(["sequential", "parallel"]).optional(),
     promptSnippet: NonEmptyString3.optional(),
-    promptGuidelines: z12.array(NonEmptyString3).optional(),
+    promptGuidelines: z13.array(NonEmptyString3).optional(),
     // A local ref names an auth service declared in this manifest; a dotted ref names another
     // plugin's service, as `UriModuleContribution.authService` does.
     authService: AuthServiceReference2.optional(),
@@ -3456,17 +3506,17 @@ function createContributionsSchemas(canonical) {
     authScheme: LocalContributionId2.optional(),
     permission: ToolPermission2.optional()
   });
-  const ConverterContribution2 = z12.strictObject({
+  const ConverterContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
     description: NonEmptyString3.optional(),
     /** MIME types this converter claims - contract data for introspection and
      *  collision checks; runtime match behavior stays the converter's `matches()`. */
-    mimeTypes: z12.array(MimeTypeString2).min(1),
+    mimeTypes: z13.array(MimeTypeString2).min(1),
     /** Extension fallbacks (no dot) used when a probe has no usable MIME type. */
-    extensions: z12.array(FileExtensionToken2).min(1).optional()
+    extensions: z13.array(FileExtensionToken2).min(1).optional()
   });
-  const UriOperationName = z12.enum([
+  const UriOperationName = z13.enum([
     "help",
     "read",
     "write",
@@ -3475,8 +3525,8 @@ function createContributionsSchemas(canonical) {
     "search",
     "delete"
   ]);
-  const UriPermissionDefault = z12.enum(["allow", "ask", "never"]);
-  const UriVerbSentences = z12.strictObject({
+  const UriPermissionDefault = z13.enum(["allow", "ask", "never"]);
+  const UriVerbSentences = z13.strictObject({
     read: NonEmptyString3.exactOptional(),
     list: NonEmptyString3.exactOptional(),
     search: NonEmptyString3.exactOptional(),
@@ -3484,81 +3534,83 @@ function createContributionsSchemas(canonical) {
     edit: NonEmptyString3.exactOptional(),
     delete: NonEmptyString3.exactOptional()
   });
-  const UriPatternInit = z12.strictObject({
+  const UriPatternInit = z13.strictObject({
     protocol: NonEmptyString3.exactOptional(),
     hostname: NonEmptyString3.exactOptional(),
     pathname: NonEmptyString3.exactOptional(),
-    search: z12.string().exactOptional()
+    search: z13.string().exactOptional()
   });
-  const UriClaimContribution = z12.discriminatedUnion("kind", [
-    z12.strictObject({ kind: z12.literal("scheme"), scheme: UriScheme2 }),
-    z12.strictObject({
-      kind: z12.literal("uriPattern"),
+  const UriClaimContribution = z13.discriminatedUnion("kind", [
+    z13.strictObject({ kind: z13.literal("scheme"), scheme: UriScheme2 }),
+    z13.strictObject({
+      kind: z13.literal("uriPattern"),
       pattern: UriPatternInit,
       normalizeTo: NonEmptyString3.exactOptional(),
       route: LocalContributionId2.exactOptional(),
       sourceUrl: NonEmptyString3.exactOptional(),
       title: NonEmptyString3.exactOptional(),
-      examples: z12.array(NonEmptyString3).exactOptional()
+      examples: z13.array(NonEmptyString3).exactOptional()
     }),
-    z12.strictObject({
-      kind: z12.literal("urlPattern"),
+    z13.strictObject({
+      kind: z13.literal("urlPattern"),
       pattern: UriPatternInit,
       normalizeTo: NonEmptyString3.exactOptional(),
       route: LocalContributionId2.exactOptional(),
-      examples: z12.array(NonEmptyString3).exactOptional()
+      examples: z13.array(NonEmptyString3).exactOptional()
     })
   ]);
-  const UriTemplateContribution = z12.strictObject({
+  const UriTemplateContribution = z13.strictObject({
     uri: NonEmptyString3,
     description: NonEmptyString3,
-    operations: z12.array(UriOperationName).exactOptional(),
-    operationDocs: z12.partialRecord(UriOperationName, NonEmptyString3).exactOptional(),
-    operationDefaults: z12.partialRecord(UriOperationName, UriPermissionDefault).exactOptional()
+    operations: z13.array(UriOperationName).exactOptional(),
+    operationDocs: z13.partialRecord(UriOperationName, NonEmptyString3).exactOptional(),
+    operationDefaults: z13.partialRecord(UriOperationName, UriPermissionDefault).exactOptional()
   });
   const UriAuthActionRuleConditions = {
-    operations: z12.array(UriOperationName).min(1).exactOptional(),
-    routes: z12.array(LocalContributionId2).min(1).exactOptional(),
-    query: z12.record(NonEmptyString3, z12.string()).exactOptional()
+    operations: z13.array(UriOperationName).min(1).exactOptional(),
+    routes: z13.array(LocalContributionId2).min(1).exactOptional(),
+    query: z13.record(NonEmptyString3, z13.string()).exactOptional()
   };
-  const UriAuthActionRule = z12.union([
-    z12.strictObject({ ...UriAuthActionRuleConditions, action: NonEmptyString3 }),
-    z12.strictObject({ ...UriAuthActionRuleConditions, public: z12.literal(true) })
+  const UriAuthActionRule = z13.union([
+    z13.strictObject({ ...UriAuthActionRuleConditions, action: NonEmptyString3 }),
+    z13.strictObject({ ...UriAuthActionRuleConditions, public: z13.literal(true) })
   ]);
-  const UriAgentHintContribution = z12.strictObject({
+  const UriAgentHintContribution = z13.strictObject({
     summary: NonEmptyString3,
-    commonFlows: z12.array(z12.strictObject({
+    commonFlows: z13.array(z13.strictObject({
       label: NonEmptyString3,
       when: NonEmptyString3.exactOptional(),
       example: NonEmptyString3
     })).exactOptional(),
     helpUri: NonEmptyString3.exactOptional(),
-    triggers: z12.strictObject({
-      keywords: z12.array(NonEmptyString3).exactOptional(),
-      patterns: z12.array(NonEmptyString3).exactOptional()
+    triggers: z13.strictObject({
+      keywords: z13.array(NonEmptyString3).exactOptional(),
+      patterns: z13.array(NonEmptyString3).exactOptional()
     }).exactOptional(),
-    skills: z12.array(NonEmptyString3).exactOptional()
+    skills: z13.array(NonEmptyString3).exactOptional()
   });
-  const ScreenActionOption = z12.discriminatedUnion("kind", [
-    z12.strictObject({
-      kind: z12.literal("exact"),
+  const ScreenActionOption = z13.discriminatedUnion("kind", [
+    z13.strictObject({
+      kind: z13.literal("exact"),
       description: NonEmptyString3,
-      verb: z12.enum(["read", "write", "edit", "delete"]),
+      verb: z13.enum(["read", "write", "edit", "delete"]),
       uri: NonEmptyString3
     }),
-    z12.strictObject({
-      kind: z12.literal("catch-all"),
+    z13.strictObject({
+      kind: z13.literal("catch-all"),
       description: NonEmptyString3,
-      verb: z12.enum(["read", "write", "edit", "delete"])
+      verb: z13.enum(["read", "write", "edit", "delete"])
     })
   ]);
   const UriModuleFactsShape = {
-    screenActions: z12.strictObject({
+    revisionBacked: z13.literal(true).optional(),
+    mailCalibrationSource: z13.literal(true).optional(),
+    screenActions: z13.strictObject({
       scheme: UriScheme2,
-      hosts: z12.array(NonEmptyString3),
-      paths: z12.array(NonEmptyString3).min(1).optional(),
-      apps: z12.array(NonEmptyString3),
-      options: z12.record(NonEmptyString3, ScreenActionOption)
+      hosts: z13.array(NonEmptyString3),
+      paths: z13.array(NonEmptyString3).min(1).optional(),
+      apps: z13.array(NonEmptyString3),
+      options: z13.record(NonEmptyString3, ScreenActionOption)
     }).superRefine((catalog, ctx) => {
       if (catalog.hosts.length === 0 && catalog.apps.length === 0) {
         ctx.addIssue({
@@ -3583,29 +3635,29 @@ function createContributionsSchemas(canonical) {
       }
     }).exactOptional(),
     /** Addresses the module answers, in match order; see `@herd/uri`'s `UriClaim`. */
-    claims: z12.array(UriClaimContribution).min(1).exactOptional(),
+    claims: z13.array(UriClaimContribution).min(1).exactOptional(),
     /** The module's routes, as its scheme-root `help` lists them. */
-    templates: z12.array(UriTemplateContribution).exactOptional(),
-    verbs: z12.strictObject({
-      readable: z12.boolean(),
-      writable: z12.boolean(),
-      editable: z12.boolean(),
-      deletable: z12.boolean().exactOptional(),
-      listable: z12.boolean(),
+    templates: z13.array(UriTemplateContribution).exactOptional(),
+    verbs: z13.strictObject({
+      readable: z13.boolean(),
+      writable: z13.boolean(),
+      editable: z13.boolean(),
+      deletable: z13.boolean().exactOptional(),
+      listable: z13.boolean(),
       /** The module answers `search`. */
-      searchable: z12.boolean().exactOptional()
+      searchable: z13.boolean().exactOptional()
     }).exactOptional(),
     verbDocs: UriVerbSentences.exactOptional(),
-    permissionDefaults: z12.strictObject({
+    permissionDefaults: z13.strictObject({
       read: UriPermissionDefault.exactOptional(),
       write: UriPermissionDefault.exactOptional(),
       edit: UriPermissionDefault.exactOptional(),
       delete: UriPermissionDefault.exactOptional()
     }).exactOptional(),
     /** Which sign-in action each call needs: the action table and the rules that pick one. */
-    authActions: z12.strictObject({
-      actions: z12.record(NonEmptyString3, ScopeRequirement2),
-      rules: z12.array(UriAuthActionRule).min(1)
+    authActions: z13.strictObject({
+      actions: z13.record(NonEmptyString3, ScopeRequirement2),
+      rules: z13.array(UriAuthActionRule).min(1)
     }).superRefine((policy, ctx) => {
       policy.rules.forEach((rule, index) => {
         if ("action" in rule && !(rule.action in policy.actions)) {
@@ -3617,18 +3669,18 @@ function createContributionsSchemas(canonical) {
         }
       });
     }).exactOptional(),
-    requiresConnection: z12.literal(true).exactOptional(),
-    acceptsSourceCopy: z12.literal(false).exactOptional(),
-    acceptsWriteSources: z12.literal(true).exactOptional(),
-    acceptsBytes: z12.literal(true).exactOptional(),
-    ownsLineSelectors: z12.literal(true).exactOptional(),
+    requiresConnection: z13.literal(true).exactOptional(),
+    acceptsSourceCopy: z13.literal(false).exactOptional(),
+    acceptsWriteSources: z13.literal(true).exactOptional(),
+    acceptsBytes: z13.literal(true).exactOptional(),
+    ownsLineSelectors: z13.literal(true).exactOptional(),
     description: NonEmptyString3.exactOptional(),
     agentHint: UriAgentHintContribution.exactOptional()
   };
-  const UriModuleFacts2 = z12.strictObject(UriModuleFactsShape);
-  const UriModuleContribution2 = z12.strictObject({
+  const UriModuleFacts2 = z13.strictObject(UriModuleFactsShape);
+  const UriModuleContribution2 = z13.strictObject({
     localId: LocalContributionId2,
-    schemes: z12.array(UriScheme2).min(1),
+    schemes: z13.array(UriScheme2).min(1),
     displayName: OptionalDisplayName,
     ...UriModuleFactsShape,
     // A local ref (no dot) must name an auth service declared in this same
@@ -3651,15 +3703,15 @@ function createContributionsSchemas(canonical) {
     // `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: z12.literal(true).optional(),
+    knownResources: z13.literal(true).optional(),
     // The module's code defines `describeOperation`, the approval card's facts for a call. The
     // daemon reads it here because it may hold only the manifest (a plugin that runs in the
     // plugin host), and the host refuses a module whose code disagrees.
-    describesOperations: z12.literal(true).optional(),
+    describesOperations: z13.literal(true).optional(),
     // The module's code defines `lookupWebLink`, which finds a resource's page when someone opens
     // it. The daemon reads it here for the same reason, and the host refuses a module whose code
     // disagrees.
-    looksUpWebLinks: z12.literal(true).optional()
+    looksUpWebLinks: z13.literal(true).optional()
   });
   const AppUriModuleContribution2 = UriModuleContribution2.omit({
     authActions: true,
@@ -3669,30 +3721,30 @@ function createContributionsSchemas(canonical) {
     describesOperations: true,
     looksUpWebLinks: true
   });
-  const AppDataSourceStore = z12.discriminatedUnion("shape", [
-    z12.strictObject({
-      shape: z12.literal("rows"),
+  const AppDataSourceStore = z13.discriminatedUnion("shape", [
+    z13.strictObject({
+      shape: z13.literal("rows"),
       rowsField: NonEmptyString3,
-      key: z12.array(NonEmptyString3).min(1)
+      key: z13.array(NonEmptyString3).min(1)
     }),
-    z12.strictObject({ shape: z12.literal("value") })
+    z13.strictObject({ shape: z13.literal("value") })
   ]);
-  const AppDataSourceContribution2 = z12.strictObject({
+  const AppDataSourceContribution2 = z13.strictObject({
     localId: LocalContributionId2,
-    scope: z12.enum(["runtime", "account", "session"]),
-    snapshot: z12.strictObject({
-      version: z12.number().int().positive(),
+    scope: z13.enum(["runtime", "account", "session"]),
+    snapshot: z13.strictObject({
+      version: z13.number().int().positive(),
       schema: JsonSchema
     }),
-    change: z12.strictObject({
-      version: z12.number().int().positive(),
+    change: z13.strictObject({
+      version: z13.number().int().positive(),
       schema: JsonSchema,
       /** Review-only claim; source schemas and behavioral tests enforce it because the daemon treats changes as opaque. */
-      semantics: z12.discriminatedUnion("kind", [
-        z12.strictObject({ kind: z12.literal("incremental") }),
-        z12.strictObject({
-          kind: z12.literal("snapshot-replacement"),
-          maxEncodedBytes: z12.number().int().positive(),
+      semantics: z13.discriminatedUnion("kind", [
+        z13.strictObject({ kind: z13.literal("incremental") }),
+        z13.strictObject({
+          kind: z13.literal("snapshot-replacement"),
+          maxEncodedBytes: z13.number().int().positive(),
           rationale: pluginString(canonical).min(1).max(1024)
         })
       ]).optional()
@@ -3718,25 +3770,25 @@ function createContributionsSchemas(canonical) {
       });
     }
   });
-  const WhiteboardTypeStorage2 = z12.discriminatedUnion("kind", [
-    z12.strictObject({ kind: z12.literal("json") }),
-    z12.strictObject({ kind: z12.literal("payload") }),
-    z12.strictObject({
-      kind: z12.literal("markdown"),
+  const WhiteboardTypeStorage2 = z13.discriminatedUnion("kind", [
+    z13.strictObject({ kind: z13.literal("json") }),
+    z13.strictObject({ kind: z13.literal("payload") }),
+    z13.strictObject({
+      kind: z13.literal("markdown"),
       bodyField: NonEmptyString3
     })
   ]);
-  const WhiteboardTypeContribution2 = z12.strictObject({
+  const WhiteboardTypeContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: NonEmptyString3,
-    schemaVersion: z12.number().int().positive(),
+    schemaVersion: z13.number().int().positive(),
     storage: WhiteboardTypeStorage2,
     valueSchema: JsonSchema
   });
-  const AppDataMaterializerContribution2 = z12.strictObject({
+  const AppDataMaterializerContribution2 = z13.strictObject({
     source: LocalContributionId2
   });
-  const ArtifactUriModuleContribution2 = z12.strictObject({
+  const ArtifactUriModuleContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     /** The single `scheme://` this module owns; also the on-disk artifact kind. */
     scheme: UriScheme2,
@@ -3750,17 +3802,17 @@ function createContributionsSchemas(canonical) {
      * 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: z12.boolean().optional(),
+    editable: z13.boolean().optional(),
     /** Opt in to `list` over the kind's stored names. Default false. Mirrors
      * `CreateArtifactUriModuleOptions.listable`. */
-    listable: z12.boolean().optional(),
+    listable: z13.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: z12.boolean().optional(),
+    deletable: z13.boolean().optional(),
     /**
      * Opt in to the `{ content, mode: "append" }` write envelope, which extends
      * stored text instead of replacing it (concurrent-appender-safe: the host
@@ -3768,7 +3820,7 @@ function createContributionsSchemas(canonical) {
      * keep their verbatim round-trip. Mirrors
      * `CreateArtifactUriModuleOptions.appendable`.
      */
-    appendable: z12.boolean().optional(),
+    appendable: z13.boolean().optional(),
     /**
      * Which sessions share one storage namespace. Default `"session"` - the existing
      * per-session behavior (each session gets its own kind directory; other sessions'
@@ -3779,14 +3831,14 @@ function createContributionsSchemas(canonical) {
      * the scope; the host derives the family root from provenance it already holds, so
      * family identity never crosses the SDK boundary.
      */
-    storageScope: z12.enum(["session", "family"]).optional()
+    storageScope: z13.enum(["session", "family"]).optional()
   });
-  const CliBindingContribution2 = z12.strictObject({
+  const CliBindingContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     binary: CliBinaryName2,
-    aliases: z12.array(CliBinaryName2).optional(),
+    aliases: z13.array(CliBinaryName2).optional(),
     /** Where the binary comes from. Omitted => `"vendored"` (decision 007). */
-    provider: z12.enum(["vendored", "path"]).optional(),
+    provider: z13.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
@@ -3799,20 +3851,20 @@ function createContributionsSchemas(canonical) {
      * MUST be absent for a `path` binding, which can never receive a token.
      */
     authEnvVar: CliAuthEnvVarName2.optional(),
-    readOnly: z12.array(NonEmptyString3),
-    write: z12.array(NonEmptyString3)
+    readOnly: z13.array(NonEmptyString3),
+    write: z13.array(NonEmptyString3)
   });
-  const GitHostContribution2 = z12.strictObject({
+  const GitHostContribution2 = z13.strictObject({
     host: GitHostName2,
     authService: LocalContributionId2,
     basicAuthUser: GitBasicAuthUser2
   });
-  const ResourceContribution2 = z12.strictObject({
+  const ResourceContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
     description: NonEmptyString3.optional()
   });
-  const SkillContribution2 = z12.strictObject({
+  const SkillContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
     /** Model-visible one-liner: when to reach for this skill. */
@@ -3820,18 +3872,18 @@ function createContributionsSchemas(canonical) {
     /** The SKILL.md-style file inside the package carrying the full instructions. */
     path: PackageAssetPath2
   });
-  const PluginSkillSourceDeclaration2 = z12.discriminatedUnion("channel", [
-    z12.strictObject({
-      channel: z12.literal("installer"),
+  const PluginSkillSourceDeclaration2 = z13.discriminatedUnion("channel", [
+    z13.strictObject({
+      channel: z13.literal("installer"),
       localId: LocalContributionId2,
       displayName: OptionalDisplayName,
       /** The package-runner executable, e.g. `npx` - checked against the daemon's allowlist. */
       command: NonEmptyString3,
       /** Its argv, e.g. `["skills", "add", "clerk/skills"]`. */
-      args: z12.array(NonEmptyString3)
+      args: z13.array(NonEmptyString3)
     }),
-    z12.strictObject({
-      channel: z12.literal("git-clone"),
+    z13.strictObject({
+      channel: z13.literal("git-clone"),
       localId: LocalContributionId2,
       displayName: OptionalDisplayName,
       /** The repository locator - canonicalized and hygiene-checked by the daemon. */
@@ -3842,17 +3894,17 @@ function createContributionsSchemas(canonical) {
       subdir: NonEmptyString3.optional()
     })
   ]);
-  const SearchProviderContribution2 = z12.strictObject({
+  const SearchProviderContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
-    schemes: z12.array(UriScheme2).optional()
+    schemes: z13.array(UriScheme2).optional()
   });
-  const InteractionDriverContribution2 = z12.strictObject({
+  const InteractionDriverContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
-    kind: z12.enum(["browser", "computer-use"])
+    kind: z13.enum(["browser", "computer-use"])
   });
-  const EntityResolverContribution2 = z12.strictObject({
+  const EntityResolverContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
     /** The `kay.agent` URI module (this manifest's own `contributes.uriModules[].localId`) whose
@@ -3860,17 +3912,17 @@ function createContributionsSchemas(canonical) {
     uriModule: LocalContributionId2,
     /** `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: z12.array(NonEmptyString3).min(1),
+    entityTypes: z13.array(NonEmptyString3).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: NonEmptyString3
   });
-  const AgentRenderContribution2 = z12.strictObject({
+  const AgentRenderContribution2 = z13.strictObject({
     localId: LocalContributionId2,
-    resultKinds: z12.array(NonEmptyString3).min(1)
+    resultKinds: z13.array(NonEmptyString3).min(1)
   });
-  const PluginCardContribution2 = z12.strictObject({
+  const PluginCardContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     description: NonEmptyString3,
     inputs: JsonSchema,
@@ -3878,26 +3930,26 @@ function createContributionsSchemas(canonical) {
     submitEndpoint: LocalContributionId2,
     authService: AuthServiceReference2.optional()
   });
-  const EndpointContribution2 = z12.strictObject({
+  const EndpointContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
     requestSchema: JsonSchema.optional(),
     responseSchema: JsonSchema.optional(),
-    auth: z12.strictObject({
+    auth: z13.strictObject({
       service: AuthServiceReference2,
-      schemes: z12.array(AuthSchemeReference2).min(1),
+      schemes: z13.array(AuthSchemeReference2).min(1),
       purpose: NonEmptyString3
     }).optional(),
-    timeoutMs: z12.number().int().positive().optional()
+    timeoutMs: z13.number().int().positive().optional()
   });
-  const WorkflowContribution2 = z12.strictObject({
+  const WorkflowContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     name: NonEmptyString3,
     /** Plain-text purpose, at most 280 characters. */
     description: NonEmptyString3,
     /** How often it runs. The automations engine enforces its scheduling floor. */
-    everyMs: z12.number().int().positive(),
-    auth: z12.strictObject({
+    everyMs: z13.number().int().positive(),
+    auth: z13.strictObject({
       /** A local ref names a service in this manifest; a dotted ref names another plugin's. */
       service: AuthServiceReference2,
       scheme: AuthSchemeReference2,
@@ -3905,7 +3957,7 @@ function createContributionsSchemas(canonical) {
        * Scopes each account's token must hold. Omitted, the host asks for the first scope of the
        * `background-job` grant's `allowedScopes` that the account holds.
        */
-      scopes: z12.array(NonEmptyString3).min(1).optional()
+      scopes: z13.array(NonEmptyString3).min(1).optional()
     }).optional()
   });
   const McpServerUrl2 = pluginString(canonical).min(1).refine((value) => {
@@ -3921,8 +3973,8 @@ function createContributionsSchemas(canonical) {
   }, {
     message: "mcp server url must be https://, or http:// only for localhost/127.0.0.1 test servers"
   });
-  const McpServerAuthMode2 = z12.enum(["oauth", "api-key", "none"]);
-  const McpServerContribution2 = z12.strictObject({
+  const McpServerAuthMode2 = z13.enum(["oauth", "api-key", "none"]);
+  const McpServerContribution2 = z13.strictObject({
     url: McpServerUrl2,
     auth: McpServerAuthMode2.optional(),
     authService: LocalContributionId2.optional()
@@ -3935,24 +3987,24 @@ function createContributionsSchemas(canonical) {
       });
     }
   });
-  const McpServerContributions2 = z12.record(LocalContributionId2, McpServerContribution2);
-  const AppEventSubscription2 = z12.strictObject({
+  const McpServerContributions2 = z13.record(LocalContributionId2, McpServerContribution2);
+  const AppEventSubscription2 = z13.strictObject({
     localId: LocalContributionId2,
     event: NonEmptyString3
   });
-  const ContextContributorContribution2 = z12.strictObject({
+  const ContextContributorContribution2 = z13.strictObject({
     localId: LocalContributionId2.max(64),
     displayName: OptionalDisplayName,
     description: NonEmptyString3.optional()
   });
-  const EventDefinitionVersion = z12.number().int().positive();
-  const PluginEventDefinitionContribution2 = z12.strictObject({
+  const EventDefinitionVersion = z13.number().int().positive();
+  const PluginEventDefinitionContribution2 = z13.strictObject({
     localId: PluginEventLocalId2,
     displayName: OptionalDisplayName,
     description: NonEmptyString3.optional(),
     version: canonical ? EventDefinitionVersion : EventDefinitionVersion.default(1),
     uriScheme: UriScheme2,
-    relatedKeys: z12.array(NonEmptyString3).readonly().optional(),
+    relatedKeys: z13.array(NonEmptyString3).readonly().optional(),
     payloadSchema: JsonSchema.optional(),
     /**
      * This event is a signal: its payload is the shared `PluginSignal` v1 and every publish
@@ -3961,7 +4013,7 @@ function createContributionsSchemas(canonical) {
      * and `relatedKeys` holds `thread` plus any of `from`, `to`, `cc`. Turning it on changes
      * the payload, so bump `version` with it.
      */
-    signal: z12.boolean().optional()
+    signal: z13.boolean().optional()
   }).superRefine((definition, context) => {
     if (definition.signal !== true)
       return;
@@ -3982,42 +4034,42 @@ function createContributionsSchemas(canonical) {
       });
     }
   });
-  const PluginNotificationRuleContribution2 = z12.strictObject({
+  const PluginNotificationRuleContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     /** The same-plugin `eventDefinitions` local id this rule matches. */
     event: PluginEventLocalId2,
-    where: z12.string({ error: (issue) => whereNotAStringMessage(issue.input) }).optional(),
+    where: z13.string({ error: (issue) => whereNotAStringMessage(issue.input) }).optional(),
     rule: JsonObject
   });
-  const PluginProductEventContribution2 = z12.union([
-    z12.strictObject({
+  const PluginProductEventContribution2 = z13.union([
+    z13.strictObject({
       name: NonEmptyString3,
       description: NonEmptyString3.optional(),
-      fields: z12.record(z12.string(), JsonObject).optional()
+      fields: z13.record(z13.string(), JsonObject).optional()
     }),
-    z12.strictObject({ catalogEvent: NonEmptyString3 })
+    z13.strictObject({ catalogEvent: NonEmptyString3 })
   ]);
-  const UiEventSubscriptionContribution2 = z12.strictObject({
+  const UiEventSubscriptionContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     event: NonEmptyString3
   });
-  const DeviceDelegationContribution2 = z12.strictObject({
+  const DeviceDelegationContribution2 = z13.strictObject({
     localId: LocalContributionId2,
-    device: z12.enum(["microphone"]),
-    delegateAs: z12.enum(["clip", "stream", "status"])
+    device: z13.enum(["microphone"]),
+    delegateAs: z13.enum(["clip", "stream", "status"])
   });
-  const CorpusAccess = z12.enum(["read"]);
-  const SessionReaderContribution2 = z12.strictObject({
+  const CorpusAccess = z13.enum(["read"]);
+  const SessionReaderContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
     access: canonical ? CorpusAccess : CorpusAccess.default("read")
   });
-  const UiCommandContribution2 = z12.strictObject({
+  const UiCommandContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     title: NonEmptyString3,
     icon: PackageAssetPath2.optional(),
-    button: z12.enum(["tabStrip"]).optional(),
-    menu: z12.enum(["help"]).optional(),
+    button: z13.enum(["tabStrip"]).optional(),
+    menu: z13.enum(["help"]).optional(),
     where: NonEmptyString3.optional()
   }).superRefine((command, ctx) => {
     if (command.where === void 0)
@@ -4038,7 +4090,7 @@ function createContributionsSchemas(canonical) {
       });
     }
   });
-  const UiSlotContribution2 = z12.strictObject({
+  const UiSlotContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     slot: NonEmptyString3,
     title: NonEmptyString3.optional()
@@ -4052,84 +4104,84 @@ function createContributionsSchemas(canonical) {
     "blob",
     "about"
   ]);
-  const ReferenceOpenBehavior2 = z12.discriminatedUnion("kind", [
-    z12.strictObject({ kind: z12.literal("working-document") }),
-    z12.strictObject({ kind: z12.literal("browser-pane") }),
+  const ReferenceOpenBehavior2 = z13.discriminatedUnion("kind", [
+    z13.strictObject({ kind: z13.literal("working-document") }),
+    z13.strictObject({ kind: z13.literal("browser-pane") }),
     /**
      * Open one of the pages this manifest declares in `pages`. The window answers this from the
      * manifest, and the page gets the whole address as its `objectId` unless `addresses` says
      * otherwise. Needs no web address, so a plugin-only resource (`user-todo://items/3`) can pill.
      */
-    z12.strictObject({ kind: z12.literal("page"), pageId: NonEmptyString3 }),
+    z13.strictObject({ kind: z13.literal("page"), pageId: NonEmptyString3 }),
     /**
      * Hand the address's link to an app on this machine. The module's claims fill the link as its
      * `sourceUrl`, and `schemes` names every scheme those links may use: main opens a link only when
      * a loaded plugin declares its scheme here. A plugin the person installed can't declare this.
      */
-    z12.strictObject({
-      kind: z12.literal("local-app"),
-      schemes: z12.array(UriScheme2.refine((scheme) => !NOT_LOCAL_APP_SCHEMES.has(scheme), "Names the web, a file or script, not an app on this machine")).min(1)
+    z13.strictObject({
+      kind: z13.literal("local-app"),
+      schemes: z13.array(UriScheme2.refine((scheme) => !NOT_LOCAL_APP_SCHEMES.has(scheme), "Names the web, a file or script, not an app on this machine")).min(1)
     })
   ]);
-  const ReferencePresentationVariant2 = z12.strictObject({
+  const ReferencePresentationVariant2 = z13.strictObject({
     resourceKind: NonEmptyString3,
     presentationPluginId: PluginId2.optional()
   });
-  const ReferencePresentationVariants2 = z12.record(MimeTypeString2, ReferencePresentationVariant2);
-  const ReferencePresentationUriPattern2 = z12.strictObject({
+  const ReferencePresentationVariants2 = z13.record(MimeTypeString2, ReferencePresentationVariant2);
+  const ReferencePresentationUriPattern2 = z13.strictObject({
     protocol: NonEmptyString3,
     hostname: NonEmptyString3,
-    pathname: z12.string().optional(),
-    search: z12.string().optional()
+    pathname: z13.string().optional(),
+    search: z13.string().optional()
   });
-  const ReferencePresentationUrlClaim2 = z12.strictObject({
-    kind: z12.literal("urlPattern"),
+  const ReferencePresentationUrlClaim2 = z13.strictObject({
+    kind: z13.literal("urlPattern"),
     pattern: ReferencePresentationUriPattern2.extend({
-      protocol: z12.enum(["http", "https"])
+      protocol: z13.enum(["http", "https"])
     }),
     /** The claim's mark: an SVG file in the plugin, drawn in its own colours. */
     brandIcon: PackageAssetPath2.optional()
   });
-  const ReferencePresentationTooltip2 = z12.strictObject({
+  const ReferencePresentationTooltip2 = z13.strictObject({
     /** Same-plugin kay.ui app mounted with read-only reference URI context. */
     app: LocalContributionId2,
     pattern: ReferencePresentationUriPattern2
   });
-  const ReferencePresentationAddress2 = z12.strictObject({
+  const ReferencePresentationAddress2 = z13.strictObject({
     pattern: ReferencePresentationUriPattern2,
     objectId: NonEmptyString3.optional(),
-    open: z12.strictObject({ kind: z12.literal("none") }).optional()
+    open: z13.strictObject({ kind: z13.literal("none") }).optional()
   });
-  const ReferencePresentationAccountLinkPage = z12.strictObject({
+  const ReferencePresentationAccountLinkPage = z13.strictObject({
     /** A literal host name. */
-    hostname: z12.string().regex(/^[a-z0-9.-]+$/, "An account link's hostname is a literal lower-case host name."),
-    pathname: z12.string().optional(),
+    hostname: z13.string().regex(/^[a-z0-9.-]+$/, "An account link's hostname is a literal lower-case host name."),
+    pathname: z13.string().optional(),
     /** A page matching one of these already names its account, so it stays as it is. */
-    unlessPathname: z12.array(z12.string()).min(1).optional(),
+    unlessPathname: z13.array(z13.string()).min(1).optional(),
     /** The path the page opens at, in place of its own. */
-    setPathname: z12.string().startsWith("/").optional(),
+    setPathname: z13.string().startsWith("/").optional(),
     /** Query values to add. A page that already has one of these names stays as it is. */
-    addQuery: z12.record(NonEmptyString3, NonEmptyString3)
+    addQuery: z13.record(NonEmptyString3, NonEmptyString3)
   });
-  const ReferencePresentationAccountLinkAddress = z12.strictObject({
+  const ReferencePresentationAccountLinkAddress = z13.strictObject({
     pattern: ReferencePresentationUriPattern2,
-    url: z12.string().regex(/^https?:\/\//, "An account link's url is a web page.")
+    url: z13.string().regex(/^https?:\/\//, "An account link's url is a web page.")
   });
-  const ReferencePresentationAccountLinks2 = z12.strictObject({
-    label: z12.enum(["email", "name"]).optional(),
-    pages: z12.array(ReferencePresentationAccountLinkPage).min(1).optional(),
-    addresses: z12.array(ReferencePresentationAccountLinkAddress).min(1).optional()
+  const ReferencePresentationAccountLinks2 = z13.strictObject({
+    label: z13.enum(["email", "name"]).optional(),
+    pages: z13.array(ReferencePresentationAccountLinkPage).min(1).optional(),
+    addresses: z13.array(ReferencePresentationAccountLinkAddress).min(1).optional()
   });
-  const ReferencePresentationWords2 = z12.strictObject({
+  const ReferencePresentationWords2 = z13.strictObject({
     /** The row's mark, for a source with no icon of its own. Left out: the plugin's main icon. */
-    glyph: z12.enum(TOOL_GLYPHS).optional(),
+    glyph: z13.enum(TOOL_GLYPHS).optional(),
     /** The thing an address names ("channel" in "Read Slack channel"). Left out: the row reads the scheme's own name. */
     kind: NonEmptyString3.optional(),
     /**
      * A more specific kind by the address's shape. The first row that matches decides, and an
      * address no row matches reads `kind`.
      */
-    kinds: z12.array(z12.strictObject({
+    kinds: z13.array(z13.strictObject({
       pattern: ReferencePresentationUriPattern2,
       kind: NonEmptyString3
     })).min(1).optional(),
@@ -4138,7 +4190,7 @@ function createContributionsSchemas(canonical) {
     /** What the live phrase names ("Slack" in "Reading Slack"). Left out: the bare verb ("Reading"). */
     target: NonEmptyString3.optional(),
     /** `kind` already says which source this is: "Edited plan", not "Edited Plan plan". */
-    kindNamesSource: z12.literal(true).optional()
+    kindNamesSource: z13.literal(true).optional()
   }).superRefine((value, ctx) => {
     if (value.kind === void 0 && (value.glyph !== void 0 || value.kindNamesSource !== void 0 || value.kinds !== void 0)) {
       ctx.addIssue({
@@ -4148,7 +4200,7 @@ function createContributionsSchemas(canonical) {
       });
     }
   });
-  const ReferencePresentationContribution2 = z12.strictObject({
+  const ReferencePresentationContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     /** This manifest's URI module. Leave it out only for an address another layer serves. */
     uriModule: LocalContributionId2.optional(),
@@ -4159,7 +4211,7 @@ function createContributionsSchemas(canonical) {
      */
     scheme: UriScheme2.optional(),
     /** Which of the addresses open the page, and on what. Read by the window. */
-    addresses: z12.array(ReferencePresentationAddress2).min(1).optional(),
+    addresses: z13.array(ReferencePresentationAddress2).min(1).optional(),
     /** Comes with `open`. A presentation with neither only words its module's addresses. */
     resourceKind: NonEmptyString3.optional(),
     /** How the address opens. Left out, it stays plain text. */
@@ -4167,7 +4219,7 @@ function createContributionsSchemas(canonical) {
     /** MIME-specific resource kinds; absent keys use the base presentation. */
     variants: ReferencePresentationVariants2.optional(),
     /** Lexical public URL claims used only for host-rendered browser presentations. */
-    claims: z12.array(ReferencePresentationUrlClaim2).optional(),
+    claims: z13.array(ReferencePresentationUrlClaim2).optional(),
     /** Informational app presentation matched against the canonical resource URI. */
     tooltip: ReferencePresentationTooltip2.optional(),
     /** What the transcript calls this module's addresses. Needs a `uriModule`. */
@@ -4250,7 +4302,7 @@ function createContributionsSchemas(canonical) {
       });
     }
   });
-  const KayUiAppHostCapability2 = z12.enum([
+  const KayUiAppHostCapability2 = z13.enum([
     "navigation.open-session",
     // Lets `navigation.openChat` create a blank chat (no message, no model
     // turn) when no session id is given. It never sends anything.
@@ -4274,6 +4326,16 @@ function createContributionsSchemas(canonical) {
     // artifacts the account may manage the access rule with a count of listed addresses, never the addresses.
     // It reads no artifact bytes.
     "shared-artifacts.read",
+    // Lists the person's projects with their pinned-to-Home state and build state, pins or unpins
+    // one to Home, renames a project or changes its description, and draws the host's project
+    // controls in the app's pane (mark, working folder and repository, sessions, build status, the
+    // new-project flow). Through `BonsaiProjectSessions` and `sessionsView` it exposes each
+    // project's session titles, states and activity times. The page app holding it is the window's
+    // project view and receives every request to show a project (`onOpenRequest`). It cannot
+    // remove or refile a project or a file. Only a plugin that ships with Bonsai keeps it: desktop
+    // main drops it from any other plugin's apps when it accepts them
+    // (`BUNDLED_ONLY_UI_APP_HOST_CAPABILITIES`).
+    "projects.manage",
     // Grants exactly `panes.place` (see `WORKSPACE_VERB_TIERS`/`KayWorkspaceCommand` in
     // `@bonsai/agent-runtime-protocol`) through the `kay.ui` capability broker's `workspace.place`,
     // and `workspace.openBeside`: one artifact in the shell's reference side pane beside the app's own
@@ -4287,12 +4349,12 @@ function createContributionsSchemas(canonical) {
     // rearrange the workspace but never remove something the user would have to notice going missing.
     "workspace.arrange"
   ]);
-  const UiAppCapabilities2 = z12.strictObject({
-    endpoints: z12.array(LocalContributionId2).optional(),
-    host: z12.array(KayUiAppHostCapability2).optional(),
+  const UiAppCapabilities2 = z13.strictObject({
+    endpoints: z13.array(LocalContributionId2).optional(),
+    host: z13.array(KayUiAppHostCapability2).optional(),
     // The feeds this app's pages read with `useBonsaiFeed`. A name means this plugin's own
     // `kay.app` data source if it declares one, otherwise the feed the daemon publishes.
-    feeds: z12.array(LocalContributionId2).optional()
+    feeds: z13.array(LocalContributionId2).optional()
   }).superRefine((capabilities, ctx) => {
     for (const field of ["endpoints", "host", "feeds"]) {
       const seen = /* @__PURE__ */ new Set();
@@ -4308,10 +4370,10 @@ function createContributionsSchemas(canonical) {
       }
     }
   });
-  const UiRailBadge = z12.strictObject({
+  const UiRailBadge = z13.strictObject({
     source: LocalContributionId2,
     where: NonEmptyString3.optional(),
-    label: z12.strictObject({
+    label: z13.strictObject({
       one: NonEmptyString3.optional(),
       other: NonEmptyString3
     })
@@ -4327,48 +4389,48 @@ function createContributionsSchemas(canonical) {
       });
     }
   });
-  const UiRailEntryContribution2 = z12.strictObject({
+  const UiRailEntryContribution2 = z13.strictObject({
     id: LocalContributionId2,
     title: NonEmptyString3,
     icon: PackageAssetPath2.optional(),
     page: NonEmptyString3,
     homeLocation: NonEmptyString3.optional(),
     shortcut: NonEmptyString3.optional(),
-    order: z12.number().finite().optional(),
-    section: z12.enum(["primary", "plugins"]).optional(),
+    order: z13.number().finite().optional(),
+    section: z13.enum(["primary", "plugins"]).optional(),
     badge: UiRailBadge.optional(),
-    panel: z12.strictObject({ body: LocalContributionId2 }).optional(),
-    featureFlagVariant: z12.strictObject({
+    panel: z13.strictObject({ body: LocalContributionId2 }).optional(),
+    featureFlagVariant: z13.strictObject({
       flag: NonEmptyString3,
       title: NonEmptyString3.optional(),
       icon: PackageAssetPath2.optional(),
-      panel: z12.literal(false).optional()
+      panel: z13.literal(false).optional()
     }).optional()
   });
-  const UiToastPreviewContribution2 = z12.strictObject({
+  const UiToastPreviewContribution2 = z13.strictObject({
     rule: LocalContributionId2,
     body: LocalContributionId2,
     address: NonEmptyString3
   });
-  const UiPageContribution2 = z12.strictObject({
+  const UiPageContribution2 = z13.strictObject({
     id: NonEmptyString3,
     title: NonEmptyString3.optional(),
     icon: PackageAssetPath2.optional(),
-    companion: z12.boolean().optional(),
+    companion: z13.boolean().optional(),
     openedEvent: NonEmptyString3.optional()
   });
-  const UiAppFields = z12.strictObject({
+  const UiAppFields = z13.strictObject({
     localId: LocalContributionId2,
     displayName: NonEmptyString3,
     description: NonEmptyString3.optional(),
     icon: PackageAssetPath2.optional(),
-    runtime: z12.literal("kay.react-app.v1"),
+    runtime: z13.literal("kay.react-app.v1"),
     /** Mounted only by a host-supplied context; never a standalone navigation destination. */
-    contextOnly: z12.literal(true).optional(),
-    sdk: z12.strictObject({ range: NonEmptyString3 }),
+    contextOnly: z13.literal(true).optional(),
+    sdk: z13.strictObject({ range: NonEmptyString3 }),
     entrypoint: TargetEntrypoint2,
-    styles: z12.array(PackageAssetPath2).optional(),
-    assets: z12.array(PackageAssetPath2).optional(),
+    styles: z13.array(PackageAssetPath2).optional(),
+    assets: z13.array(PackageAssetPath2).optional(),
     capabilities: UiAppCapabilities2.optional()
   });
   function stripRetiredUiAppFields(value) {
@@ -4379,36 +4441,36 @@ function createContributionsSchemas(canonical) {
     delete remaining["activityRail"];
     return remaining;
   }
-  const UiAppContribution2 = canonical ? UiAppFields : z12.preprocess(stripRetiredUiAppFields, UiAppFields);
-  const ThemeContribution2 = z12.strictObject({
+  const UiAppContribution2 = canonical ? UiAppFields : z13.preprocess(stripRetiredUiAppFields, UiAppFields);
+  const ThemeContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: NonEmptyString3,
-    appearance: z12.enum(["light", "dark"]),
+    appearance: z13.enum(["light", "dark"]),
     tokens: PackageAssetPath2
   });
-  const CommandHandler2 = z12.discriminatedUnion("kind", [
-    z12.strictObject({ kind: z12.literal("skill"), skill: LocalContributionId2 }),
-    z12.strictObject({
-      kind: z12.literal("tool"),
+  const CommandHandler2 = z13.discriminatedUnion("kind", [
+    z13.strictObject({ kind: z13.literal("skill"), skill: LocalContributionId2 }),
+    z13.strictObject({
+      kind: z13.literal("tool"),
       tool: PluginToolName2,
       /** 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: z12.array(NonEmptyString3)
+      argumentFields: z13.array(NonEmptyString3)
     }),
-    z12.strictObject({
-      kind: z12.literal("endpoint"),
+    z13.strictObject({
+      kind: z13.literal("endpoint"),
       endpoint: LocalContributionId2
     })
   ]);
-  const CommandContribution2 = z12.strictObject({
+  const CommandContribution2 = z13.strictObject({
     localId: LocalContributionId2,
     displayName: OptionalDisplayName,
     description: NonEmptyString3,
-    aliases: z12.array(LocalContributionId2).optional(),
+    aliases: z13.array(LocalContributionId2).optional(),
     argumentHint: NonEmptyString3.optional(),
     handler: CommandHandler2
   });
-  const PluginContributionKind2 = z12.enum([
+  const PluginContributionKind2 = z13.enum([
     "tool",
     "converter",
     "uriModule",
@@ -4566,7 +4628,56 @@ __export(manifest_exports, {
   retiredCompatibilityKeysIn: () => retiredCompatibilityKeysIn,
   validateKayUiEventSubscription: () => validateKayUiEventSubscription
 });
-import { z as z13 } from "zod";
+
+// packages/plugin-protocol/dist/shell-commands.js
+import { z as z14 } from "zod";
+var PluginShellCommand = z14.strictObject({
+  name: z14.string().regex(/^[a-z][a-z0-9-]*$/),
+  aliases: z14.array(z14.string().regex(/^[a-z][a-z0-9-]*$/)).optional(),
+  endpoint: z14.string().min(1),
+  usage: z14.string().min(1)
+});
+var ShellCommandOutcome = z14.strictObject({
+  exitCode: z14.number().int(),
+  envelope: JsonValue,
+  result: JsonValue.optional()
+});
+var ShellCommandRequest = z14.strictObject({
+  argv: z14.array(z14.string()),
+  cwd: z14.string(),
+  outcomes: z14.array(ShellCommandOutcome).max(3)
+});
+var ShellCommandStep = z14.discriminatedUnion("kind", [
+  z14.strictObject({
+    kind: z14.literal("invoke"),
+    toolName: z14.enum([
+      "read",
+      "list",
+      "search",
+      "write",
+      "edit",
+      "delete",
+      "help"
+    ]),
+    input: z14.record(z14.string(), JsonValue),
+    flags: z14.record(z14.string(), z14.string())
+  }),
+  z14.strictObject({
+    kind: z14.literal("finish"),
+    exitCode: z14.number().int(),
+    stdout: z14.string()
+  })
+]);
+
+// packages/plugin-protocol/dist/manifest.js
+import { z as z16 } from "zod";
+
+// packages/plugin-protocol/dist/workload-purposes.js
+import { z as z15 } from "zod";
+var PluginWorkloadPurpose = z15.strictObject({
+  purpose: z15.string().regex(/^[a-z][a-z0-9-]*$/),
+  workloadClass: z15.enum(["dreaming", "hindsight"])
+});
 
 // packages/plugin-protocol/dist/synthetic-contributions.js
 function resolveConfigSectionContributionLocalId(section) {
@@ -4591,34 +4702,34 @@ function createManifestSchemas(canonical) {
   const { AgentRenderContribution: AgentRenderContribution2, ApprovalTypeContribution: ApprovalTypeContribution2, WorkflowContribution: WorkflowContribution2, PluginCardContribution: PluginCardContribution2, AppDataMaterializerContribution: AppDataMaterializerContribution2, AppDataSourceContribution: AppDataSourceContribution2, AppUriModuleContribution: AppUriModuleContribution2, AppEventSubscription: AppEventSubscription2, ArtifactUriModuleContribution: ArtifactUriModuleContribution2, CliBindingContribution: CliBindingContribution2, CommandContribution: CommandContribution2, ContextContributorContribution: ContextContributorContribution2, ConverterContribution: ConverterContribution2, SessionReaderContribution: SessionReaderContribution2, DeviceDelegationContribution: DeviceDelegationContribution2, EndpointContribution: EndpointContribution2, EntityResolverContribution: EntityResolverContribution2, GitHostContribution: GitHostContribution2, McpServerContributions: McpServerContributions2, PluginEventDefinitionContribution: PluginEventDefinitionContribution2, PluginNotificationRuleContribution: PluginNotificationRuleContribution2, PluginProductEventContribution: PluginProductEventContribution2, ResourceContribution: ResourceContribution2, ReferencePresentationContribution: ReferencePresentationContribution2, PluginSkillSourceDeclaration: PluginSkillSourceDeclaration2, InteractionDriverContribution: InteractionDriverContribution2, SearchProviderContribution: SearchProviderContribution2, SkillContribution: SkillContribution2, ThemeContribution: ThemeContribution2, AgentToolContribution: AgentToolContribution2, ToolContribution: ToolContribution2, UiCommandContribution: UiCommandContribution2, UiAppContribution: UiAppContribution2, UiRailEntryContribution: UiRailEntryContribution2, UiToastPreviewContribution: UiToastPreviewContribution2, UiPageContribution: UiPageContribution2, UiEventSubscriptionContribution: UiEventSubscriptionContribution2, UiSlotContribution: UiSlotContribution2, UriModuleContribution: UriModuleContribution2, WhiteboardTypeContribution: WhiteboardTypeContribution2 } = canonical ? canonicalContributionSchemas : contributions_exports;
   const { HttpsUrl: HttpsUrl2, LocalContributionId: LocalContributionId2, NonEmptyString: NonEmptyString3, PackageAssetPath: PackageAssetPath2, PluginId: PluginId2, PluginNamespace: PluginNamespace2, RegistrableDomain: RegistrableDomain2, SignedInStatusCode: SignedInStatusCode2, TargetEntrypoint: TargetEntrypoint2 } = canonical ? canonicalCommonSchemas : common_exports;
   const { PluginPermissionManifest: PluginPermissionManifest2 } = canonical ? canonicalPermissionSchemas : permissions_exports;
-  const KayAgentTargetManifest2 = z13.strictObject({
+  const KayAgentTargetManifest2 = z16.strictObject({
     entrypoint: TargetEntrypoint2,
-    contributes: z13.strictObject({
-      tools: z13.array(AgentToolContribution2).optional(),
-      converters: z13.array(ConverterContribution2).optional(),
-      uriModules: z13.array(UriModuleContribution2).optional(),
+    contributes: z16.strictObject({
+      tools: z16.array(AgentToolContribution2).optional(),
+      converters: z16.array(ConverterContribution2).optional(),
+      uriModules: z16.array(UriModuleContribution2).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: z13.array(ArtifactUriModuleContribution2).optional(),
-      cliBindings: z13.array(CliBindingContribution2).optional(),
+      artifactUriModules: z16.array(ArtifactUriModuleContribution2).optional(),
+      cliBindings: z16.array(CliBindingContribution2).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: z13.array(GitHostContribution2).optional(),
-      resources: z13.array(ResourceContribution2).optional(),
-      skills: z13.array(SkillContribution2).optional(),
-      searchProviders: z13.array(SearchProviderContribution2).optional(),
-      interactionDrivers: z13.array(InteractionDriverContribution2).optional(),
-      entityResolvers: z13.array(EntityResolverContribution2).optional(),
-      renderers: z13.array(AgentRenderContribution2).optional(),
+      gitHosts: z16.array(GitHostContribution2).optional(),
+      resources: z16.array(ResourceContribution2).optional(),
+      skills: z16.array(SkillContribution2).optional(),
+      searchProviders: z16.array(SearchProviderContribution2).optional(),
+      interactionDrivers: z16.array(InteractionDriverContribution2).optional(),
+      entityResolvers: z16.array(EntityResolverContribution2).optional(),
+      renderers: z16.array(AgentRenderContribution2).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: z13.array(CommandContribution2).optional()
+      commands: z16.array(CommandContribution2).optional()
     }).optional(),
     /**
      * The plugin's primer skill - the `localId` of one of its own declared
@@ -4664,61 +4775,61 @@ function createManifestSchemas(canonical) {
      * acquisition, not declared here, so there is nothing for the resolved contract to mint a
      * `globalId` for at parse time.
      */
-    skillSources: z13.array(PluginSkillSourceDeclaration2).optional()
+    skillSources: z16.array(PluginSkillSourceDeclaration2).optional()
   });
-  const KayAppTargetManifest2 = z13.strictObject({
+  const KayAppTargetManifest2 = z16.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: TargetEntrypoint2.optional(),
-    contributes: z13.strictObject({
+    contributes: z16.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: z13.array(ToolContribution2).optional(),
-      endpoints: z13.array(EndpointContribution2).optional(),
-      cards: z13.array(PluginCardContribution2).optional(),
-      uriModules: z13.array(AppUriModuleContribution2).optional(),
-      dataSources: z13.array(AppDataSourceContribution2).optional(),
-      whiteboardTypes: z13.array(WhiteboardTypeContribution2).optional(),
-      approvalTypes: z13.array(ApprovalTypeContribution2).optional(),
-      workflows: z13.array(WorkflowContribution2).optional(),
-      eventDefinitions: z13.array(PluginEventDefinitionContribution2).optional(),
+      tools: z16.array(ToolContribution2).optional(),
+      endpoints: z16.array(EndpointContribution2).optional(),
+      cards: z16.array(PluginCardContribution2).optional(),
+      uriModules: z16.array(AppUriModuleContribution2).optional(),
+      dataSources: z16.array(AppDataSourceContribution2).optional(),
+      whiteboardTypes: z16.array(WhiteboardTypeContribution2).optional(),
+      approvalTypes: z16.array(ApprovalTypeContribution2).optional(),
+      workflows: z16.array(WorkflowContribution2).optional(),
+      eventDefinitions: z16.array(PluginEventDefinitionContribution2).optional(),
       // Default notification rules over this plugin's own `eventDefinitions`; seeded by the host
       // (see `PluginNotificationRuleContribution`).
-      notificationRules: z13.array(PluginNotificationRuleContribution2).optional(),
-      productEvents: z13.array(PluginProductEventContribution2).optional(),
-      eventSubscriptions: z13.array(AppEventSubscription2).optional(),
-      deviceDelegations: z13.array(DeviceDelegationContribution2).optional(),
-      sessionReaders: z13.array(SessionReaderContribution2).optional(),
-      contextContributors: z13.array(ContextContributorContribution2).optional(),
+      notificationRules: z16.array(PluginNotificationRuleContribution2).optional(),
+      productEvents: z16.array(PluginProductEventContribution2).optional(),
+      eventSubscriptions: z16.array(AppEventSubscription2).optional(),
+      deviceDelegations: z16.array(DeviceDelegationContribution2).optional(),
+      sessionReaders: z16.array(SessionReaderContribution2).optional(),
+      contextContributors: z16.array(ContextContributorContribution2).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: McpServerContributions2.optional(),
       // Handler restricted to endpoint-only by the manifest-level refinement below.
-      commands: z13.array(CommandContribution2).optional()
+      commands: z16.array(CommandContribution2).optional()
     }).optional()
   });
-  const KayUiTargetManifest2 = z13.strictObject({
+  const KayUiTargetManifest2 = z16.strictObject({
     entrypoint: TargetEntrypoint2.extend({
-      format: z13.literal("compiled-bundle").optional()
+      format: z16.literal("compiled-bundle").optional()
     }).optional(),
-    contributes: z13.strictObject({
-      commands: z13.array(UiCommandContribution2).optional(),
-      slots: z13.array(UiSlotContribution2).optional(),
-      referencePresentations: z13.array(ReferencePresentationContribution2).optional(),
-      apps: z13.array(UiAppContribution2).optional(),
-      railEntries: z13.array(UiRailEntryContribution2).optional(),
-      toastPreviews: z13.array(UiToastPreviewContribution2).optional(),
-      pages: z13.array(UiPageContribution2).optional(),
-      themes: z13.array(ThemeContribution2).optional(),
-      eventSubscriptions: z13.array(UiEventSubscriptionContribution2).optional(),
-      dataMaterializers: z13.array(AppDataMaterializerContribution2).optional()
+    contributes: z16.strictObject({
+      commands: z16.array(UiCommandContribution2).optional(),
+      slots: z16.array(UiSlotContribution2).optional(),
+      referencePresentations: z16.array(ReferencePresentationContribution2).optional(),
+      apps: z16.array(UiAppContribution2).optional(),
+      railEntries: z16.array(UiRailEntryContribution2).optional(),
+      toastPreviews: z16.array(UiToastPreviewContribution2).optional(),
+      pages: z16.array(UiPageContribution2).optional(),
+      themes: z16.array(ThemeContribution2).optional(),
+      eventSubscriptions: z16.array(UiEventSubscriptionContribution2).optional(),
+      dataMaterializers: z16.array(AppDataMaterializerContribution2).optional()
     }).optional()
   });
-  const PluginConfigScope2 = z13.enum(["global", "project", "agent"]);
-  const PluginConfigSectionManifest2 = z13.strictObject({
+  const PluginConfigScope2 = z16.enum(["global", "project", "agent"]);
+  const PluginConfigSectionManifest2 = z16.strictObject({
     section: NonEmptyString3.optional(),
     schema: JsonSchema,
     /**
@@ -4736,22 +4847,23 @@ function createManifestSchemas(canonical) {
      * is the baseline every section has; `agent` has no runtime mapping (the
      * agent/entity fold is downstream of the document protocol).
      */
-    scopes: z13.array(PluginConfigScope2).optional()
+    scopes: z16.array(PluginConfigScope2).optional()
   });
-  const PluginConfigManifest2 = z13.array(PluginConfigSectionManifest2).min(1);
-  const PluginStorageManifest2 = z13.strictObject({
-    sqlite: z13.strictObject({
-      enabled: z13.boolean(),
-      ownerTarget: z13.literal("kay.app").optional(),
+  const PluginConfigManifest2 = z16.array(PluginConfigSectionManifest2).min(1);
+  const PluginStorageManifest2 = z16.strictObject({
+    sqlite: z16.strictObject({
+      enabled: z16.boolean(),
+      ownerTarget: z16.literal("kay.app").optional(),
       migrations: NonEmptyString3.optional()
     }).optional(),
-    dataDir: z13.strictObject({
-      enabled: z13.boolean(),
-      ownerTarget: z13.literal("kay.app").optional()
+    dataDir: z16.strictObject({
+      enabled: z16.boolean(),
+      ownerTarget: z16.literal("kay.app").optional(),
+      sharedWith: PluginId2.optional()
     }).optional()
   });
-  const PluginOAuthClientSupplier2 = z13.enum(["kay", "user"]);
-  const PluginProvisioningProbe2 = z13.strictObject({
+  const PluginOAuthClientSupplier2 = z16.enum(["kay", "user"]);
+  const PluginProvisioningProbe2 = z16.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
@@ -4759,13 +4871,13 @@ function createManifestSchemas(canonical) {
      */
     url: HttpsUrl2,
     /** Absent => `GET`. */
-    method: z13.enum(["GET"]).optional(),
+    method: z16.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: z13.array(SignedInStatusCode2).min(1),
+    verdictStatuses: z16.array(SignedInStatusCode2).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.
@@ -4774,7 +4886,7 @@ function createManifestSchemas(canonical) {
      */
     nonEmptyArrayAt: NonEmptyString3.optional()
   });
-  const PluginProvisioningRequirement2 = z13.strictObject({
+  const PluginProvisioningRequirement2 = z16.strictObject({
     /** Stable id, unique within the scheme. */
     id: LocalContributionId2,
     /** Human-facing requirement name, e.g. "GitHub App installation". */
@@ -4791,7 +4903,7 @@ function createManifestSchemas(canonical) {
     probe: PluginProvisioningProbe2
   });
   const PluginProvisioningField = {
-    provisioning: z13.array(PluginProvisioningRequirement2).optional()
+    provisioning: z16.array(PluginProvisioningRequirement2).optional()
   };
   const PluginAuthSchemeDescriptionFields = {
     /** Human-facing flow name; absent, the service's name stands in. */
@@ -4808,16 +4920,17 @@ function createManifestSchemas(canonical) {
     authorizationUrl: HttpsUrl2,
     tokenUrl: HttpsUrl2,
     /** Provider-specific query parameters added to the authorize URL. */
-    extraAuthorizeParams: z13.record(NonEmptyString3, z13.string()).optional()
+    extraAuthorizeParams: z16.record(NonEmptyString3, z16.string()).optional()
   };
-  const PluginAuthSchemeAccountLookup = z13.literal("lookup");
-  const PluginAuthSchemeOAuthPkce = z13.strictObject({
+  const PluginAuthSchemeAccountLookup = z16.literal("lookup");
+  const PluginAuthSchemeOAuthPkce = z16.strictObject({
     ...PluginProvisioningField,
     ...PluginAuthSchemeDescriptionFields,
     ...PluginAuthSchemeOAuthEndpointFields,
     localId: LocalContributionId2,
-    kind: z13.literal("oauth2"),
-    exchange: z13.literal("pkce"),
+    kind: z16.literal("oauth2"),
+    exchange: z16.literal("pkce"),
+    byoocProfile: PluginByoocProfile.optional(),
     /**
      * A public client id the plugin ships for its own sign-in. Only an installed plugin's is used:
      * Bonsai's own plugins sign in with clients the host holds.
@@ -4840,7 +4953,7 @@ function createManifestSchemas(canonical) {
      * runs on an untrusted manifest, so a hand-built `["kay","kay"]` must be refused here, not
      * silently normalized).
      */
-    clientSuppliers: z13.array(PluginOAuthClientSupplier2).nonempty().superRefine((suppliers, ctx) => {
+    clientSuppliers: z16.array(PluginOAuthClientSupplier2).nonempty().superRefine((suppliers, ctx) => {
       if (new Set(suppliers).size !== suppliers.length) {
         ctx.addIssue({
           code: "custom",
@@ -4848,7 +4961,10 @@ function createManifestSchemas(canonical) {
         });
       }
     }),
-    scopes: z13.array(NonEmptyString3).optional()
+    scopes: z16.array(NonEmptyString3).optional()
+  }).refine((scheme) => scheme.byoocProfile === void 0 || scheme.clientSuppliers.includes("user"), {
+    message: "An own-client profile requires the user client supplier.",
+    path: ["byoocProfile"]
   }).refine((scheme) => scheme.clientSecret === void 0 || scheme.clientId !== void 0, {
     message: "clientSecret needs the clientId it belongs to",
     path: ["clientSecret"]
@@ -4856,33 +4972,33 @@ function createManifestSchemas(canonical) {
     message: "a scheme with its own clientId names where its account comes from (`account`)",
     path: ["account"]
   });
-  const PluginAuthSchemeOAuthConfidential = z13.strictObject({
+  const PluginAuthSchemeOAuthConfidential = z16.strictObject({
     ...PluginProvisioningField,
     ...PluginAuthSchemeDescriptionFields,
     ...PluginAuthSchemeOAuthEndpointFields,
     localId: LocalContributionId2,
-    kind: z13.literal("oauth2"),
-    exchange: z13.literal("confidential"),
+    kind: z16.literal("oauth2"),
+    exchange: z16.literal("confidential"),
     /** Absent means `["kay"]` - a confidential exchange's secret may only ever be Bonsai's. */
-    clientSuppliers: z13.tuple([z13.literal("kay")]).optional(),
-    scopes: z13.array(NonEmptyString3).optional(),
+    clientSuppliers: z16.tuple([z16.literal("kay")]).optional(),
+    scopes: z16.array(NonEmptyString3).optional(),
     /** Where the account comes from (see {@link PluginAuthSchemeAccountLookup}). */
-    account: z13.union([PluginAuthSchemeAccountLookup, z13.literal("sign-in")])
+    account: z16.union([PluginAuthSchemeAccountLookup, z16.literal("sign-in")])
   });
-  const PluginAuthSchemeOAuth2 = z13.discriminatedUnion("exchange", [
+  const PluginAuthSchemeOAuth2 = z16.discriminatedUnion("exchange", [
     PluginAuthSchemeOAuthPkce,
     PluginAuthSchemeOAuthConfidential
   ]);
-  const PluginAuthSchemeApiKey = z13.strictObject({
+  const PluginAuthSchemeApiKey = z16.strictObject({
     ...PluginProvisioningField,
     ...PluginAuthSchemeDescriptionFields,
     localId: LocalContributionId2,
-    kind: z13.literal("api-key"),
-    scopes: z13.array(NonEmptyString3).optional(),
+    kind: z16.literal("api-key"),
+    scopes: z16.array(NonEmptyString3).optional(),
     /** The connect prompt's label for the key. Absent: "<service name> API key". */
     inputLabel: NonEmptyString3.optional(),
     /** Two or more labeled inputs for a secret that comes in parts; absent asks for one key. */
-    fields: z13.array(z13.strictObject({ id: LocalContributionId2, label: NonEmptyString3 })).min(2).superRefine((fields, ctx) => {
+    fields: z16.array(z16.strictObject({ id: LocalContributionId2, label: NonEmptyString3 })).min(2).superRefine((fields, ctx) => {
       if (new Set(fields.map((field) => field.id)).size !== fields.length) {
         ctx.addIssue({
           code: "custom",
@@ -4891,7 +5007,7 @@ function createManifestSchemas(canonical) {
       }
     }).optional(),
     /** Where and how the person creates the key outside Bonsai. */
-    setup: z13.strictObject({ instructions: NonEmptyString3, url: HttpsUrl2 }).optional(),
+    setup: z16.strictObject({ instructions: NonEmptyString3, url: HttpsUrl2 }).optional(),
     /**
      * `"lookup"`: the plugin checks a key before it is saved and names its account, with the function
      * it registers (`api.auth.registerAccountLookup`). Absent: the key is saved unchecked, under the
@@ -4899,27 +5015,27 @@ function createManifestSchemas(canonical) {
      */
     account: PluginAuthSchemeAccountLookup.optional()
   });
-  const PluginAuthSchemeDelegated = z13.strictObject({
+  const PluginAuthSchemeDelegated = z16.strictObject({
     ...PluginAuthSchemeDescriptionFields,
     localId: LocalContributionId2,
-    kind: z13.literal("delegated"),
-    scopes: z13.array(NonEmptyString3).optional()
+    kind: z16.literal("delegated"),
+    scopes: z16.array(NonEmptyString3).optional()
   });
-  const ExternalCliArgument = z13.string().min(1).max(16384).refine((value) => ![...value].some(isUnsafeArgumentCharacter), {
+  const ExternalCliArgument = z16.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"
   });
-  const ExternalCliCommand = z13.string().max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._+-]*$/, {
+  const ExternalCliCommand = z16.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"
   });
   const ExternalCliHint = NonEmptyString3.max(2048);
-  const ExternalCliArguments = z13.array(ExternalCliArgument).max(64);
+  const ExternalCliArguments = z16.array(ExternalCliArgument).max(64);
   const SignedOutMarker = ExternalCliArgument.refine((value) => value.trim() !== "", { message: "a signed-out marker needs text beyond whitespace" });
-  const PluginExternalCliConnect2 = z13.strictObject({
+  const PluginExternalCliConnect2 = z16.strictObject({
     /** A basename the host finds on `PATH` (`osascript`, `wrangler`), never a path. */
     binary: ExternalCliCommand,
-    probe: z13.strictObject({
+    probe: z16.strictObject({
       args: ExternalCliArguments.min(1),
-      timeoutMs: z13.number().int().min(1).max(12e4).optional(),
+      timeoutMs: z16.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
@@ -4927,13 +5043,13 @@ function createManifestSchemas(canonical) {
        * unavailable. Required when `login` is declared, so a timeout never starts a sign-in. A list
        * is for a CLI with several signed-out messages; any one of them counts.
        */
-      signedOutMarker: z13.union([SignedOutMarker, z13.array(SignedOutMarker).min(1)]).optional()
+      signedOutMarker: z16.union([SignedOutMarker, z16.array(SignedOutMarker).min(1)]).optional()
     }),
     /** The CLI's interactive sign-in. Absent: connect only probes and reports. */
-    login: z13.strictObject({
+    login: z16.strictObject({
       args: ExternalCliArguments.min(1),
-      timeoutMs: z13.number().int().min(1).max(6e5).optional(),
-      pasteCode: z13.strictObject({
+      timeoutMs: z16.number().int().min(1).max(6e5).optional(),
+      pasteCode: z16.strictObject({
         /** The redeeming argv; the host appends the code as its last argument. */
         args: ExternalCliArguments.min(1),
         /** What the prompt says, for a person. */
@@ -4945,12 +5061,12 @@ function createManifestSchemas(canonical) {
      * 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: z13.strictObject({
+    install: z16.strictObject({
       command: ExternalCliCommand,
       args: ExternalCliArguments
     }).optional(),
     /** Prose for a person: `install` when the binary is missing, `login` when the probe fails. */
-    hints: z13.strictObject({
+    hints: z16.strictObject({
       install: ExternalCliHint,
       login: ExternalCliHint
     })
@@ -4963,50 +5079,50 @@ function createManifestSchemas(canonical) {
       });
     }
   });
-  const PluginAuthSchemeExternalCli = z13.strictObject({
+  const PluginAuthSchemeExternalCli = z16.strictObject({
     ...PluginAuthSchemeDescriptionFields,
     localId: LocalContributionId2,
-    kind: z13.literal("external-cli"),
-    scopes: z13.array(NonEmptyString3).optional(),
+    kind: z16.literal("external-cli"),
+    scopes: z16.array(NonEmptyString3).optional(),
     cli: PluginExternalCliConnect2.optional()
   });
-  const PluginAuthScheme2 = z13.discriminatedUnion("kind", [
+  const PluginAuthScheme2 = z16.discriminatedUnion("kind", [
     PluginAuthSchemeOAuth2,
     PluginAuthSchemeApiKey,
     PluginAuthSchemeDelegated,
     PluginAuthSchemeExternalCli
   ]);
-  const PluginWebSessionProbe2 = z13.strictObject({
+  const PluginWebSessionProbe2 = z16.strictObject({
     url: HttpsUrl2,
     /** Absent => `GET`. `POST` sends an empty JSON object body. */
-    method: z13.enum(["GET", "POST"]).optional(),
-    signedInStatuses: z13.array(SignedInStatusCode2).min(1)
+    method: z16.enum(["GET", "POST"]).optional(),
+    signedInStatuses: z16.array(SignedInStatusCode2).min(1)
   });
-  const PluginWebSessionDeclaration2 = z13.strictObject({
+  const PluginWebSessionDeclaration2 = z16.strictObject({
     /** `required`: capabilities degrade without the site login; `recommended`: it only smooths UX. */
-    importance: z13.enum(["required", "recommended"]),
+    importance: z16.enum(["required", "recommended"]),
     loginUrl: HttpsUrl2,
-    cookieDomains: z13.array(RegistrableDomain2).min(1),
+    cookieDomains: z16.array(RegistrableDomain2).min(1),
     probe: PluginWebSessionProbe2,
-    oauthVenue: z13.enum(["embedded", "external"]),
+    oauthVenue: z16.enum(["embedded", "external"]),
     /**
      * Where a page goes first when it opens in one of Bonsai's browser panes and this site login
      * is missing: a sign-in page that continues to the page. A template with `:email` and `:url`
      * (see `UriClaimTemplate`), on a host within `cookieDomains`.
      */
-    signInFirst: z13.string().optional()
+    signInFirst: z16.string().optional()
   }).superRefine(refineWebSessionScopeConfined);
-  const PluginAuthService2 = z13.strictObject({
+  const PluginAuthService2 = z16.strictObject({
     localId: LocalContributionId2,
     displayName: NonEmptyString3,
     /** One plain sentence on what connecting this service gives Bonsai. */
     summary: NonEmptyString3.optional(),
-    schemes: z13.array(PluginAuthScheme2).min(1),
-    purposes: z13.array(NonEmptyString3).min(1),
+    schemes: z16.array(PluginAuthScheme2).min(1),
+    purposes: z16.array(NonEmptyString3).min(1),
     webSession: PluginWebSessionDeclaration2.optional()
   });
-  const PluginAuthManifest2 = z13.strictObject({
-    services: z13.array(PluginAuthService2).optional()
+  const PluginAuthManifest2 = z16.strictObject({
+    services: z16.array(PluginAuthService2).optional()
   });
   function stripRetiredCompatibilityKeys(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -5017,17 +5133,17 @@ function createManifestSchemas(canonical) {
       delete remaining[key];
     return remaining;
   }
-  const PluginCompatibilityFields = z13.strictObject({
-    supportedProtocols: z13.array(KayPluginProtocolVersion).optional(),
+  const PluginCompatibilityFields = z16.strictObject({
+    supportedProtocols: z16.array(KayPluginProtocolVersion).optional(),
     minKayVersion: NonEmptyString3.optional(),
     sdk: NonEmptyString3.optional()
   });
-  const PluginCompatibilityManifest2 = canonical ? PluginCompatibilityFields : z13.preprocess(stripRetiredCompatibilityKeys, PluginCompatibilityFields);
+  const PluginCompatibilityManifest2 = canonical ? PluginCompatibilityFields : z16.preprocess(stripRetiredCompatibilityKeys, PluginCompatibilityFields);
   const KayVersionString2 = NonEmptyString3.regex(SEMVER_PATTERN, {
     message: "version must be semver, for example 1.2.3"
   });
-  const KayPluginManifestV12 = z13.strictObject({
-    protocol: z13.literal(KAY_PLUGIN_PROTOCOL_VERSION),
+  const KayPluginManifestV12 = z16.strictObject({
+    protocol: z16.literal(KAY_PLUGIN_PROTOCOL_VERSION),
     id: PluginId2,
     displayName: NonEmptyString3,
     version: KayVersionString2,
@@ -5055,8 +5171,8 @@ function createManifestSchemas(canonical) {
     icon: PackageAssetPath2.optional(),
     iconDark: PackageAssetPath2.optional(),
     namespace: PluginNamespace2.optional(),
-    targets: z13.strictObject({
-      kay: z13.strictObject({
+    targets: z16.strictObject({
+      kay: z16.strictObject({
         agent: KayAgentTargetManifest2.optional(),
         app: KayAppTargetManifest2.optional(),
         ui: KayUiTargetManifest2.optional()
@@ -5064,6 +5180,8 @@ function createManifestSchemas(canonical) {
     }).optional(),
     config: PluginConfigManifest2.optional(),
     storage: PluginStorageManifest2.optional(),
+    workloadPurposes: z16.array(PluginWorkloadPurpose).optional(),
+    shellCommands: z16.array(PluginShellCommand).optional(),
     auth: PluginAuthManifest2.optional(),
     permissions: PluginPermissionManifest2.optional(),
     compatibility: PluginCompatibilityManifest2.optional(),
@@ -5073,17 +5191,36 @@ function createManifestSchemas(canonical) {
      * 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: z13.boolean().optional(),
+    ownedByBonsai: z16.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: z13.strictObject({
-      plugins: z13.array(PluginId2).optional()
+    dependencies: z16.strictObject({
+      plugins: z16.array(PluginId2).optional()
     }).optional()
   }).superRefine((manifest, ctx) => {
+    const sharedWith = manifest.storage?.dataDir?.sharedWith;
+    if (sharedWith !== void 0 && (!manifest.storage?.dataDir?.enabled || sharedWith === manifest.id || !manifest.dependencies?.plugins?.includes(sharedWith))) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["storage", "dataDir", "sharedWith"],
+        message: "A shared data directory must name another declared plugin dependency."
+      });
+    }
+    const workloadPurposes = /* @__PURE__ */ new Set();
+    for (const [index, workload] of (manifest.workloadPurposes ?? []).entries()) {
+      if (workloadPurposes.has(workload.purpose)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["workloadPurposes", index, "purpose"],
+          message: "A workload purpose must be unique within its plugin."
+        });
+      }
+      workloadPurposes.add(workload.purpose);
+    }
     const authServices = new Set(manifest.auth?.services?.map((service) => service.localId) ?? []);
     const authSchemeIdsByService = new Map((manifest.auth?.services ?? []).map((service) => [
       service.localId,
@@ -5093,6 +5230,33 @@ function createManifestSchemas(canonical) {
       ]))
     ]));
     const endpointIds = new Set(manifest.targets?.kay?.app?.contributes?.endpoints?.map((endpoint) => endpoint.localId) ?? []);
+    const shellNames = /* @__PURE__ */ new Set([
+      "help",
+      "version",
+      "info",
+      "open",
+      "launch",
+      "session"
+    ]);
+    for (const [index, command] of (manifest.shellCommands ?? []).entries()) {
+      if (!endpointIds.has(command.endpoint)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["shellCommands", index, "endpoint"],
+          message: "A shell command must name an endpoint declared by this plugin's app target."
+        });
+      }
+      for (const name of [command.name, ...command.aliases ?? []]) {
+        if (shellNames.has(name)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["shellCommands", index],
+            message: `Shell command name '${name}' is reserved or already declared.`
+          });
+        }
+        shellNames.add(name);
+      }
+    }
     const storageKinds = /* @__PURE__ */ new Set();
     if (manifest.storage?.sqlite?.enabled)
       storageKinds.add("sqlite");
@@ -6143,7 +6307,7 @@ function pushContributionIds(output, path, items) {
 }
 
 // packages/plugin-protocol/dist/plugin-directory-verdict.js
-import { z as z15 } from "zod";
+import { z as z18 } from "zod";
 
 // packages/plugin-protocol/dist/plugin-load-diagnostic.js
 var PLUGIN_DIAGNOSTIC_MESSAGE_CAP = 300;
@@ -6152,14 +6316,14 @@ function boundPluginDiagnosticMessage(message) {
 }
 
 // packages/plugin-protocol/dist/resolved-contract.js
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 function createResolvedContractSchemas(canonical) {
   const { PluginEventLocalId: PluginEventLocalId2 } = canonical ? canonicalPluginEventSchemas : plugin_events_exports;
   const { ApprovalTypeContribution: ApprovalTypeContribution2, KayUiAppHostCapability: KayUiAppHostCapability2, McpServerAuthMode: McpServerAuthMode2, McpServerUrl: McpServerUrl2, PluginContributionKind: PluginContributionKindSchema, ReferenceOpenBehavior: ReferenceOpenBehavior2, ReferencePresentationUriPattern: ReferencePresentationUriPattern2, ReferencePresentationAccountLinks: ReferencePresentationAccountLinks2, ReferencePresentationAddress: ReferencePresentationAddress2, ReferencePresentationUrlClaim: ReferencePresentationUrlClaim2, ReferencePresentationVariants: ReferencePresentationVariants2, ReferencePresentationWords: ReferencePresentationWords2, UriModuleFacts: UriModuleFacts2, WhiteboardTypeStorage: WhiteboardTypeStorage2 } = canonical ? canonicalContributionSchemas : contributions_exports;
   const { FileExtensionToken: FileExtensionToken2, GitBasicAuthUser: GitBasicAuthUser2, GitHostName: GitHostName2, GlobalContributionId: GlobalContributionId2, HttpsUrl: HttpsUrl2, LocalContributionId: LocalContributionId2, MimeTypeString: MimeTypeString2, NonEmptyString: NonEmptyString3, PackageAssetPath: PackageAssetPath2, PluginId: PluginId2, PluginNamespace: PluginNamespace2, PluginToolName: PluginToolName2, RegistrableDomain: RegistrableDomain2, SignedInStatusCode: SignedInStatusCode2, TargetEntrypoint: TargetEntrypoint2, UriScheme: UriScheme2 } = canonical ? canonicalCommonSchemas : common_exports;
   const { PluginExternalCliConnect: PluginExternalCliConnect2, PluginOAuthClientSupplier: PluginOAuthClientSupplier2 } = canonical ? canonicalManifestSchemas : manifest_exports;
   const { ResolvedPluginGrants: ResolvedPluginGrants2 } = canonical ? canonicalPermissionSchemas : permissions_exports;
-  const ResolvedPluginContributionId2 = z14.strictObject({
+  const ResolvedPluginContributionId2 = z17.strictObject({
     target: PluginTargetName,
     kind: PluginContributionKindSchema,
     localId: PluginEventLocalId2,
@@ -6173,54 +6337,54 @@ function createResolvedContractSchemas(canonical) {
       });
     }
   });
-  const ResolvedKayToolId = z14.strictObject({
+  const ResolvedKayToolId = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     toolName: PluginToolName2
   });
-  const ResolvedKayAgentTool2 = z14.strictObject({
+  const ResolvedKayAgentTool2 = z17.strictObject({
     ...ResolvedKayToolId.shape,
     displayName: NonEmptyString3.optional(),
     description: NonEmptyString3.optional(),
     parameters: JsonSchema.optional(),
-    executionMode: z14.enum(["sequential", "parallel"]).optional(),
+    executionMode: z17.enum(["sequential", "parallel"]).optional(),
     promptSnippet: NonEmptyString3.optional(),
-    promptGuidelines: z14.array(NonEmptyString3).optional(),
-    requiresAuth: z14.strictObject({
+    promptGuidelines: z17.array(NonEmptyString3).optional(),
+    requiresAuth: z17.strictObject({
       serviceId: GlobalContributionId2,
       schemeId: GlobalContributionId2.optional()
     }).optional(),
     permission: canonical ? canonicalContributionSchemas.ToolPermission.optional() : ToolPermission.optional()
   });
   const ResolvedKayAppTool2 = ResolvedKayAgentTool2.omit({ requiresAuth: true });
-  const ResolvedKayAppDataSource2 = z14.strictObject({
+  const ResolvedKayAppDataSource2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
-    scope: z14.enum(["runtime", "account", "session"]),
-    snapshot: z14.strictObject({
-      version: z14.number().int().positive(),
-      schema: z14.record(z14.string(), z14.unknown())
+    scope: z17.enum(["runtime", "account", "session"]),
+    snapshot: z17.strictObject({
+      version: z17.number().int().positive(),
+      schema: z17.record(z17.string(), z17.unknown())
     }),
-    change: z14.strictObject({
-      version: z14.number().int().positive(),
-      schema: z14.record(z14.string(), z14.unknown()),
-      semantics: z14.discriminatedUnion("kind", [
-        z14.strictObject({ kind: z14.literal("incremental") }),
-        z14.strictObject({
-          kind: z14.literal("snapshot-replacement"),
-          maxEncodedBytes: z14.number().int().positive(),
+    change: z17.strictObject({
+      version: z17.number().int().positive(),
+      schema: z17.record(z17.string(), z17.unknown()),
+      semantics: z17.discriminatedUnion("kind", [
+        z17.strictObject({ kind: z17.literal("incremental") }),
+        z17.strictObject({
+          kind: z17.literal("snapshot-replacement"),
+          maxEncodedBytes: z17.number().int().positive(),
           rationale: pluginString(canonical).min(1).max(1024)
         })
       ]).optional()
     }),
     read: AppDataSourceRead.optional(),
-    store: z14.discriminatedUnion("shape", [
-      z14.strictObject({
-        shape: z14.literal("rows"),
-        rowsField: z14.string().min(1),
-        key: z14.array(z14.string().min(1)).min(1)
+    store: z17.discriminatedUnion("shape", [
+      z17.strictObject({
+        shape: z17.literal("rows"),
+        rowsField: z17.string().min(1),
+        key: z17.array(z17.string().min(1)).min(1)
       }),
-      z14.strictObject({ shape: z14.literal("value") })
+      z17.strictObject({ shape: z17.literal("value") })
     ]).optional()
   }).superRefine((source, ctx) => {
     if (source.read !== void 0 && source.scope !== "session") {
@@ -6240,127 +6404,127 @@ function createResolvedContractSchemas(canonical) {
     /** The auth service that module signs in through, whose accounts a card may send from. */
     authService: GlobalContributionId2.optional()
   });
-  const ResolvedPluginCard2 = z14.strictObject({
+  const ResolvedPluginCard2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     pluginId: PluginId2,
     description: NonEmptyString3,
     inputs: JsonSchema,
-    readEndpoint: z14.strictObject({
+    readEndpoint: z17.strictObject({
       localId: LocalContributionId2,
       globalId: GlobalContributionId2
     }),
-    submitEndpoint: z14.strictObject({
+    submitEndpoint: z17.strictObject({
       localId: LocalContributionId2,
       globalId: GlobalContributionId2
     }),
     authService: GlobalContributionId2.optional()
   });
-  const ResolvedKayAppWorkflow2 = z14.strictObject({
+  const ResolvedKayAppWorkflow2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     name: NonEmptyString3,
     description: NonEmptyString3,
-    everyMs: z14.number().int().positive(),
-    auth: z14.strictObject({
+    everyMs: z17.number().int().positive(),
+    auth: z17.strictObject({
       serviceId: GlobalContributionId2,
       schemeId: GlobalContributionId2,
-      scopes: z14.array(NonEmptyString3).min(1).optional()
+      scopes: z17.array(NonEmptyString3).min(1).optional()
     }).optional()
   });
-  const ResolvedKayAppWhiteboardType2 = z14.strictObject({
+  const ResolvedKayAppWhiteboardType2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     displayName: NonEmptyString3,
-    schemaVersion: z14.number().int().positive(),
+    schemaVersion: z17.number().int().positive(),
     storage: WhiteboardTypeStorage2,
     valueSchema: JsonSchema
   });
-  const ResolvedKayAppMcpServer2 = z14.strictObject({
+  const ResolvedKayAppMcpServer2 = z17.strictObject({
     name: LocalContributionId2,
     pluginId: PluginId2,
     url: McpServerUrl2,
     auth: McpServerAuthMode2,
     authServiceId: GlobalContributionId2.optional()
   });
-  const ResolvedKayAgentUriModule2 = z14.strictObject({
+  const ResolvedKayAgentUriModule2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
-    schemes: z14.array(UriScheme2).min(1),
+    schemes: z17.array(UriScheme2).min(1),
     displayName: NonEmptyString3.optional(),
     authServiceId: GlobalContributionId2.optional(),
     /** Mirrors `UriModuleContribution.authScheme`; a local ref takes the plugin's namespace. */
     authSchemeId: GlobalContributionId2.optional(),
     /** Mirrors `UriModuleContribution.knownResources` (host-side recording opt-in). */
-    knownResources: z14.literal(true).optional(),
+    knownResources: z17.literal(true).optional(),
     /** Mirrors `UriModuleContribution.describesOperations`. */
-    describesOperations: z14.literal(true).optional(),
+    describesOperations: z17.literal(true).optional(),
     /** Mirrors `UriModuleContribution.looksUpWebLinks`. */
-    looksUpWebLinks: z14.literal(true).optional(),
+    looksUpWebLinks: z17.literal(true).optional(),
     ...UriModuleFacts2.shape
   });
-  const ResolvedKayAgentArtifactUriModule2 = z14.strictObject({
+  const ResolvedKayAgentArtifactUriModule2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     scheme: UriScheme2,
-    editable: z14.boolean(),
-    listable: z14.boolean(),
-    deletable: z14.boolean(),
-    appendable: z14.boolean(),
-    storageScope: z14.enum(["session", "family"])
+    editable: z17.boolean(),
+    listable: z17.boolean(),
+    deletable: z17.boolean(),
+    appendable: z17.boolean(),
+    storageScope: z17.enum(["session", "family"])
   });
-  const ResolvedKayAgentEntityResolver2 = z14.strictObject({
+  const ResolvedKayAgentEntityResolver2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     displayName: NonEmptyString3.optional(),
     uriModule: GlobalContributionId2,
-    entityTypes: z14.array(NonEmptyString3).min(1),
+    entityTypes: z17.array(NonEmptyString3).min(1),
     uriHint: NonEmptyString3
   });
-  const ResolvedKayAgentGitHostClaim2 = z14.strictObject({
+  const ResolvedKayAgentGitHostClaim2 = z17.strictObject({
     host: GitHostName2,
     authServiceId: GlobalContributionId2,
     /** Manifest-declared order; the clone ladder tries them in sequence. */
-    authSchemeIds: z14.array(GlobalContributionId2).min(1),
+    authSchemeIds: z17.array(GlobalContributionId2).min(1),
     /** Non-secret display copy for the claiming service, for clone failure text. */
-    authServiceDisplayName: z14.string(),
+    authServiceDisplayName: z17.string(),
     basicAuthUser: GitBasicAuthUser2
   });
-  const ResolvedKayAgentConverter2 = z14.strictObject({
+  const ResolvedKayAgentConverter2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     description: NonEmptyString3.optional(),
-    mimeTypes: z14.array(MimeTypeString2).min(1),
-    extensions: z14.array(FileExtensionToken2).min(1).optional()
+    mimeTypes: z17.array(MimeTypeString2).min(1),
+    extensions: z17.array(FileExtensionToken2).min(1).optional()
   });
   const ResolvedReferencePresentationUrlClaim = ReferencePresentationUrlClaim2.extend({
-    brandIcon: z14.string().max(64 * 1024).optional()
+    brandIcon: z17.string().max(64 * 1024).optional()
   });
-  const ResolvedReferencePresentation2 = z14.strictObject({
+  const ResolvedReferencePresentation2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     uriModule: GlobalContributionId2.optional(),
     /** The schemes this presentation is about: its `scheme`, or its module's. */
-    schemes: z14.array(UriScheme2).min(1).optional(),
+    schemes: z17.array(UriScheme2).min(1).optional(),
     /** The module's `displayName`: the source's name in a row. */
     displayName: NonEmptyString3.optional(),
     /** The module's auth service, qualified: whose accounts `accountLinks` reads. */
     authService: GlobalContributionId2.optional(),
     accountLinks: ReferencePresentationAccountLinks2.optional(),
-    addresses: z14.array(ReferencePresentationAddress2).min(1).optional(),
+    addresses: z17.array(ReferencePresentationAddress2).min(1).optional(),
     /** Comes with `open`. A presentation with neither only words its module's addresses. */
     resourceKind: NonEmptyString3.optional(),
     open: ReferenceOpenBehavior2.optional(),
     /** MIME-specific resource kinds; absent keys use the base presentation. */
     variants: ReferencePresentationVariants2.optional(),
-    claims: z14.array(ResolvedReferencePresentationUrlClaim).optional(),
-    tooltip: z14.strictObject({
+    claims: z17.array(ResolvedReferencePresentationUrlClaim).optional(),
+    tooltip: z17.strictObject({
       app: GlobalContributionId2,
       pattern: ReferencePresentationUriPattern2
     }).optional(),
     words: ReferencePresentationWords2.optional()
   });
-  const ResolvedPluginProvisioningRequirement2 = z14.strictObject({
+  const ResolvedPluginProvisioningRequirement2 = z17.strictObject({
     id: LocalContributionId2,
     displayName: NonEmptyString3,
     description: NonEmptyString3,
@@ -6370,15 +6534,15 @@ function createResolvedContractSchemas(canonical) {
      * URL degrades to "Reconnect" in the UI instead of a broken link.
      */
     remediationUrl: HttpsUrl2.optional(),
-    probe: z14.strictObject({
+    probe: z17.strictObject({
       url: HttpsUrl2,
-      method: z14.enum(["GET"]),
-      verdictStatuses: z14.array(SignedInStatusCode2).min(1),
+      method: z17.enum(["GET"]),
+      verdictStatuses: z17.array(SignedInStatusCode2).min(1),
       nonEmptyArrayAt: NonEmptyString3.optional()
     })
   });
   const ResolvedProvisioningField = {
-    provisioning: z14.array(ResolvedPluginProvisioningRequirement2).optional()
+    provisioning: z17.array(ResolvedPluginProvisioningRequirement2).optional()
   };
   const ResolvedPluginAuthSchemeDescriptionFields = {
     displayName: NonEmptyString3.optional(),
@@ -6390,114 +6554,115 @@ function createResolvedContractSchemas(canonical) {
     ...ResolvedPluginAuthSchemeDescriptionFields,
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
-    kind: z14.literal("oauth2"),
-    scopes: z14.array(z14.string()).optional(),
+    kind: z17.literal("oauth2"),
+    scopes: z17.array(z17.string()).optional(),
     authorizationUrl: HttpsUrl2,
     tokenUrl: HttpsUrl2,
-    extraAuthorizeParams: z14.record(z14.string(), z14.string()).optional()
+    extraAuthorizeParams: z17.record(z17.string(), z17.string()).optional()
   };
-  const ResolvedPluginAuthSchemeOAuthPkce = z14.strictObject({
+  const ResolvedPluginAuthSchemeOAuthPkce = z17.strictObject({
     ...ResolvedPluginAuthSchemeOAuthBase,
-    exchange: z14.literal("pkce"),
-    clientSuppliers: z14.array(PluginOAuthClientSupplier2).nonempty(),
+    exchange: z17.literal("pkce"),
+    byoocProfile: PluginByoocProfile.optional(),
+    clientSuppliers: z17.array(PluginOAuthClientSupplier2).nonempty(),
     clientId: NonEmptyString3.optional(),
     clientSecret: NonEmptyString3.optional(),
-    account: z14.literal("lookup").optional()
+    account: z17.literal("lookup").optional()
   });
-  const ResolvedPluginAuthSchemeOAuthConfidential = z14.strictObject({
+  const ResolvedPluginAuthSchemeOAuthConfidential = z17.strictObject({
     ...ResolvedPluginAuthSchemeOAuthBase,
-    exchange: z14.literal("confidential"),
-    clientSuppliers: z14.tuple([z14.literal("kay")]),
-    account: z14.enum(["lookup", "sign-in"])
+    exchange: z17.literal("confidential"),
+    clientSuppliers: z17.tuple([z17.literal("kay")]),
+    account: z17.enum(["lookup", "sign-in"])
   });
-  const ResolvedPluginAuthSchemeOAuth2 = z14.discriminatedUnion("exchange", [
+  const ResolvedPluginAuthSchemeOAuth2 = z17.discriminatedUnion("exchange", [
     ResolvedPluginAuthSchemeOAuthPkce,
     ResolvedPluginAuthSchemeOAuthConfidential
   ]);
-  const ResolvedPluginAuthSchemeApiKey = z14.strictObject({
+  const ResolvedPluginAuthSchemeApiKey = z17.strictObject({
     ...ResolvedProvisioningField,
     ...ResolvedPluginAuthSchemeDescriptionFields,
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
-    kind: z14.literal("api-key"),
-    scopes: z14.array(z14.string()).optional(),
+    kind: z17.literal("api-key"),
+    scopes: z17.array(z17.string()).optional(),
     /** Resolution applies the manifest's default, "<service name> API key". */
     inputLabel: NonEmptyString3,
-    fields: z14.array(z14.strictObject({ id: z14.string(), label: z14.string() })).optional(),
-    setup: z14.strictObject({ instructions: z14.string(), url: HttpsUrl2 }).optional(),
-    account: z14.literal("lookup").optional()
+    fields: z17.array(z17.strictObject({ id: z17.string(), label: z17.string() })).optional(),
+    setup: z17.strictObject({ instructions: z17.string(), url: HttpsUrl2 }).optional(),
+    account: z17.literal("lookup").optional()
   });
-  const ResolvedPluginAuthSchemeDelegated = z14.strictObject({
+  const ResolvedPluginAuthSchemeDelegated = z17.strictObject({
     ...ResolvedPluginAuthSchemeDescriptionFields,
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
-    kind: z14.literal("delegated"),
-    scopes: z14.array(z14.string()).optional()
+    kind: z17.literal("delegated"),
+    scopes: z17.array(z17.string()).optional()
   });
-  const ResolvedPluginAuthSchemeExternalCli = z14.strictObject({
+  const ResolvedPluginAuthSchemeExternalCli = z17.strictObject({
     ...ResolvedPluginAuthSchemeDescriptionFields,
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
-    kind: z14.literal("external-cli"),
-    scopes: z14.array(z14.string()).optional(),
+    kind: z17.literal("external-cli"),
+    scopes: z17.array(z17.string()).optional(),
     /** The manifest's connect facts, verbatim. */
     cli: PluginExternalCliConnect2.optional()
   });
-  const ResolvedPluginAuthScheme2 = z14.discriminatedUnion("kind", [
+  const ResolvedPluginAuthScheme2 = z17.discriminatedUnion("kind", [
     ResolvedPluginAuthSchemeOAuth2,
     ResolvedPluginAuthSchemeApiKey,
     ResolvedPluginAuthSchemeDelegated,
     ResolvedPluginAuthSchemeExternalCli
   ]);
-  const ResolvedPluginWebSession2 = z14.strictObject({
-    importance: z14.enum(["required", "recommended"]),
+  const ResolvedPluginWebSession2 = z17.strictObject({
+    importance: z17.enum(["required", "recommended"]),
     loginUrl: HttpsUrl2,
-    cookieDomains: z14.array(RegistrableDomain2).min(1),
-    probe: z14.strictObject({
+    cookieDomains: z17.array(RegistrableDomain2).min(1),
+    probe: z17.strictObject({
       url: HttpsUrl2,
-      method: z14.enum(["GET", "POST"]),
-      signedInStatuses: z14.array(SignedInStatusCode2).min(1)
+      method: z17.enum(["GET", "POST"]),
+      signedInStatuses: z17.array(SignedInStatusCode2).min(1)
     }),
-    oauthVenue: z14.enum(["embedded", "external"]),
-    signInFirst: z14.string().optional()
+    oauthVenue: z17.enum(["embedded", "external"]),
+    signInFirst: z17.string().optional()
   }).superRefine(refineWebSessionScopeConfined);
-  const ResolvedPluginAuthService2 = z14.strictObject({
+  const ResolvedPluginAuthService2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
-    displayName: z14.string(),
-    summary: z14.string().optional(),
-    schemes: z14.array(ResolvedPluginAuthScheme2).min(1),
-    purposes: z14.array(z14.string()).min(1),
+    displayName: z17.string(),
+    summary: z17.string().optional(),
+    schemes: z17.array(ResolvedPluginAuthScheme2).min(1),
+    purposes: z17.array(z17.string()).min(1),
     /** The service's browser half, when the manifest declares one. */
     webSession: ResolvedPluginWebSession2.optional()
   });
-  const ResolvedKayUiAppEndpointCapability2 = z14.strictObject({
+  const ResolvedKayUiAppEndpointCapability2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2
   });
-  const ResolvedKayUiApp2 = z14.strictObject({
+  const ResolvedKayUiApp2 = z17.strictObject({
     localId: LocalContributionId2,
     globalId: GlobalContributionId2,
     displayName: NonEmptyString3,
-    contextOnly: z14.literal(true).optional(),
+    contextOnly: z17.literal(true).optional(),
     description: NonEmptyString3.optional(),
     icon: PackageAssetPath2.optional(),
-    runtime: z14.literal("kay.react-app.v1"),
-    sdk: z14.strictObject({ range: NonEmptyString3 }),
+    runtime: z17.literal("kay.react-app.v1"),
+    sdk: z17.strictObject({ range: NonEmptyString3 }),
     entrypoint: TargetEntrypoint2,
-    styles: z14.array(PackageAssetPath2).optional(),
-    assets: z14.array(PackageAssetPath2).optional(),
-    capabilities: z14.strictObject({
-      endpoints: z14.array(ResolvedKayUiAppEndpointCapability2).optional(),
-      host: z14.array(KayUiAppHostCapability2).optional(),
-      feeds: z14.array(LocalContributionId2).optional()
+    styles: z17.array(PackageAssetPath2).optional(),
+    assets: z17.array(PackageAssetPath2).optional(),
+    capabilities: z17.strictObject({
+      endpoints: z17.array(ResolvedKayUiAppEndpointCapability2).optional(),
+      host: z17.array(KayUiAppHostCapability2).optional(),
+      feeds: z17.array(LocalContributionId2).optional()
     }).optional()
   });
-  const ResolvedPluginContractV12 = z14.strictObject({
-    protocol: z14.literal("kay.plugin.v1"),
+  const ResolvedPluginContractV12 = z17.strictObject({
+    protocol: z17.literal("kay.plugin.v1"),
     pluginId: PluginId2,
     namespace: PluginNamespace2,
-    contributions: z14.array(ResolvedPluginContributionId2),
+    contributions: z17.array(ResolvedPluginContributionId2),
     // The deduplicated set of qualified (dotted) external auth-service ids this
     // plugin references, from agent uriModule, tool and cliBinding
     // `authService` refs, card sign-in refs, and auth-grant `service` refs. Always present - a plugin
@@ -6505,33 +6670,38 @@ function createResolvedContractSchemas(canonical) {
     // 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: z14.array(GlobalContributionId2),
+    consumesAuthServices: z17.array(GlobalContributionId2),
     // 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: z14.array(PluginId2),
+    explicitDependencies: z17.array(PluginId2),
+    dataDirSharedWith: PluginId2.optional(),
+    workloadPurposes: z17.array(PluginWorkloadPurpose).optional(),
+    shellCommands: z17.array(PluginShellCommand.omit({ endpoint: true }).extend({
+      endpointId: GlobalContributionId2
+    })).optional(),
     // 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: z14.array(ResolvedPluginAuthService2),
+    authServices: z17.array(ResolvedPluginAuthService2),
     grants: ResolvedPluginGrants2.optional(),
-    kayAgentUriModules: z14.array(ResolvedKayAgentUriModule2).optional(),
-    kayAgentArtifactUriModules: z14.array(ResolvedKayAgentArtifactUriModule2).optional(),
-    kayAgentEntityResolvers: z14.array(ResolvedKayAgentEntityResolver2).optional(),
-    kayAgentGitHostClaims: z14.array(ResolvedKayAgentGitHostClaim2).optional(),
-    kayAgentTools: z14.array(ResolvedKayAgentTool2).optional(),
-    kayAppTools: z14.array(ResolvedKayAppTool2).optional(),
-    kayAppApprovalTypes: z14.array(ResolvedKayAppApprovalType2).optional(),
-    kayAppWorkflows: z14.array(ResolvedKayAppWorkflow2).optional(),
-    kayAppCards: z14.array(ResolvedPluginCard2).optional(),
-    kayAppDataSources: z14.array(ResolvedKayAppDataSource2).optional(),
-    kayAppWhiteboardTypes: z14.array(ResolvedKayAppWhiteboardType2).optional(),
-    kayAppMcpServers: z14.array(ResolvedKayAppMcpServer2).optional(),
-    kayAgentConverters: z14.array(ResolvedKayAgentConverter2).optional(),
-    referencePresentations: z14.array(ResolvedReferencePresentation2).optional(),
-    kayUiApps: z14.array(ResolvedKayUiApp2).optional()
+    kayAgentUriModules: z17.array(ResolvedKayAgentUriModule2).optional(),
+    kayAgentArtifactUriModules: z17.array(ResolvedKayAgentArtifactUriModule2).optional(),
+    kayAgentEntityResolvers: z17.array(ResolvedKayAgentEntityResolver2).optional(),
+    kayAgentGitHostClaims: z17.array(ResolvedKayAgentGitHostClaim2).optional(),
+    kayAgentTools: z17.array(ResolvedKayAgentTool2).optional(),
+    kayAppTools: z17.array(ResolvedKayAppTool2).optional(),
+    kayAppApprovalTypes: z17.array(ResolvedKayAppApprovalType2).optional(),
+    kayAppWorkflows: z17.array(ResolvedKayAppWorkflow2).optional(),
+    kayAppCards: z17.array(ResolvedPluginCard2).optional(),
+    kayAppDataSources: z17.array(ResolvedKayAppDataSource2).optional(),
+    kayAppWhiteboardTypes: z17.array(ResolvedKayAppWhiteboardType2).optional(),
+    kayAppMcpServers: z17.array(ResolvedKayAppMcpServer2).optional(),
+    kayAgentConverters: z17.array(ResolvedKayAgentConverter2).optional(),
+    referencePresentations: z17.array(ResolvedReferencePresentation2).optional(),
+    kayUiApps: z17.array(ResolvedKayUiApp2).optional()
   });
   return {
     ResolvedPluginContributionId: ResolvedPluginContributionId2,
@@ -6769,6 +6939,7 @@ function resolveAuthServices(namespace, manifest) {
           kind: "oauth2",
           exchange: "pkce",
           clientSuppliers: scheme.clientSuppliers,
+          ...scheme.byoocProfile === void 0 ? {} : { byoocProfile: scheme.byoocProfile },
           ...scheme.clientId === void 0 ? {} : { clientId: scheme.clientId },
           ...scheme.clientSecret === void 0 ? {} : { clientSecret: scheme.clientSecret },
           ...scheme.account === void 0 ? {} : { account: scheme.account },
@@ -7059,6 +7230,14 @@ function resolveKayPluginContractV1(manifest) {
       ...manifest.dependencies?.plugins ?? []
     ],
     authServices,
+    ...manifest.storage?.dataDir?.sharedWith === void 0 ? {} : { dataDirSharedWith: manifest.storage.dataDir.sharedWith },
+    ...manifest.workloadPurposes === void 0 ? {} : { workloadPurposes: manifest.workloadPurposes },
+    ...manifest.shellCommands === void 0 ? {} : {
+      shellCommands: manifest.shellCommands.map(({ endpoint, ...command }) => ({
+        ...command,
+        endpointId: resolveGlobalContributionId(namespace, endpoint)
+      }))
+    },
     ...grants && Object.keys(grants.byTarget).length > 0 ? { grants } : {},
     ...kayAgentUriModules && kayAgentUriModules.length > 0 ? { kayAgentUriModules } : {},
     ...kayAgentArtifactUriModules && kayAgentArtifactUriModules.length > 0 ? { kayAgentArtifactUriModules } : {},
@@ -7242,14 +7421,14 @@ function kayPluginCompatibilityAdvisories(input) {
     message: boundPluginDiagnosticMessage(`${manifest.displayName} (${manifest.id}) ${advisory.message}`)
   }));
 }
-var ReadableCompatibility = z15.object({
-  supportedProtocols: z15.array(z15.string()).optional().catch(void 0),
+var ReadableCompatibility = z18.object({
+  supportedProtocols: z18.array(z18.string()).optional().catch(void 0),
   minKayVersion: NonEmptyString.optional().catch(void 0),
   sdk: NonEmptyString.optional().catch(void 0)
 });
-var ReadableManifestHead = z15.object({
-  id: z15.string().optional().catch(void 0),
-  displayName: z15.string().optional().catch(void 0),
+var ReadableManifestHead = z18.object({
+  id: z18.string().optional().catch(void 0),
+  displayName: z18.string().optional().catch(void 0),
   compatibility: ReadableCompatibility.optional().catch(void 0)
 });
 function keepNamespaceDerivedTools(contract, grandfathered) {
@@ -7353,28 +7532,28 @@ function errorText(error) {
 }
 
 // packages/plugin-protocol/dist/session-health.js
-import { z as z16 } from "zod";
+import { z as z19 } 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 = z16.object({
-  v: z16.literal(1),
-  verdict: z16.enum(["well", "bad", "unknown"]),
+var sessionHealthEntrySchema = z19.object({
+  v: z19.literal(1),
+  verdict: z19.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: z16.number().min(0).max(1).nullable(),
-  classifier: z16.enum(SESSION_HEALTH_CLASSIFIER_IDS),
-  classifier_version: z16.string().min(1).max(64),
-  judged_at: z16.number().int().nonnegative(),
-  user_entry_id: z16.string().min(1).max(256),
-  through_entry_id: z16.string().min(1).max(256),
-  usage: z16.strictObject({
-    input_tokens: z16.number().int().nonnegative(),
-    output_tokens: z16.number().int().nonnegative()
+  p_well: z19.number().min(0).max(1).nullable(),
+  classifier: z19.enum(SESSION_HEALTH_CLASSIFIER_IDS),
+  classifier_version: z19.string().min(1).max(64),
+  judged_at: z19.number().int().nonnegative(),
+  user_entry_id: z19.string().min(1).max(256),
+  through_entry_id: z19.string().min(1).max(256),
+  usage: z19.strictObject({
+    input_tokens: z19.number().int().nonnegative(),
+    output_tokens: z19.number().int().nonnegative()
   }).optional()
 });
 function sessionHealthPWellDecile(pWell) {
@@ -7384,23 +7563,23 @@ function sessionHealthPWellDecile(pWell) {
 }
 
 // packages/plugin-protocol/dist/resource-invocations.js
-import { z as z17 } from "zod";
-var CorpusResourceKind = z17.enum([
+import { z as z20 } from "zod";
+var CorpusResourceKind = z20.enum([
   "skill",
   "context-file",
   "prompt-command"
 ]);
-var CorpusResourceInvocationCursor = z17.strictObject({
-  at: z17.iso.datetime({ offset: true }),
-  eventId: z17.string().min(1)
+var CorpusResourceInvocationCursor = z20.strictObject({
+  at: z20.iso.datetime({ offset: true }),
+  eventId: z20.string().min(1)
 });
-var CorpusResourceInvocationQuery = z17.strictObject({
+var CorpusResourceInvocationQuery = z20.strictObject({
   kind: CorpusResourceKind,
-  since: z17.iso.datetime({ offset: true }),
-  until: z17.iso.datetime({ offset: true }),
+  since: z20.iso.datetime({ offset: true }),
+  until: z20.iso.datetime({ offset: true }),
   after: CorpusResourceInvocationCursor.optional(),
-  limit: z17.number().int().min(1).max(1e3).optional(),
-  rootCreatedByKind: z17.enum(AGENT_RUNTIME_SESSION_CREATOR_KINDS).optional()
+  limit: z20.number().int().min(1).max(1e3).optional(),
+  rootCreatedByKind: z20.enum(AGENT_RUNTIME_SESSION_CREATOR_KINDS).optional()
 }).refine((value) => Date.parse(value.since) < Date.parse(value.until), {
   message: "since must precede until"
 });
@@ -7580,14 +7759,14 @@ function skillSuggestionEvidenceItems(evidence, options = {}) {
 }
 
 // packages/plugin-protocol/dist/ui-app-package.js
-import { z as z18 } from "zod";
+import { z as z21 } 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 = z18.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 = z18.strictObject({
-  protocol: z18.literal(KAY_UI_BUNDLE_INDEX_PROTOCOL),
+var KayUiBundleOutputPath = z21.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 = z21.strictObject({
+  protocol: z21.literal(KAY_UI_BUNDLE_INDEX_PROTOCOL),
   entryPath: KayUiBundleOutputPath,
-  files: z18.array(z18.strictObject({
+  files: z21.array(z21.strictObject({
     path: KayUiBundleOutputPath,
     mediaType: NonEmptyString
   })).min(1)
@@ -7614,19 +7793,19 @@ var KayUiBundleIndexV1 = z18.strictObject({
 function parseKayUiBundleIndexV1(input) {
   return KayUiBundleIndexV1.parse(input);
 }
-var KayUiAppPackageFile = z18.strictObject({
+var KayUiAppPackageFile = z21.strictObject({
   path: PackageAssetPath,
   mediaType: NonEmptyString,
-  bytes: z18.instanceof(Uint8Array).refine((bytes) => bytes.byteLength > 0, {
+  bytes: z21.instanceof(Uint8Array).refine((bytes) => bytes.byteLength > 0, {
     message: "app package file bytes must not be empty"
   })
 });
-var KayUiAppPackageV1 = z18.strictObject({
-  protocol: z18.literal(KAY_UI_APP_PACKAGE_PROTOCOL),
+var KayUiAppPackageV1 = z21.strictObject({
+  protocol: z21.literal(KAY_UI_APP_PACKAGE_PROTOCOL),
   appLocalId: LocalContributionId,
   entry: KayUiAppPackageFile,
-  styles: z18.array(KayUiAppPackageFile).optional(),
-  assets: z18.array(KayUiAppPackageFile).optional()
+  styles: z21.array(KayUiAppPackageFile).optional(),
+  assets: z21.array(KayUiAppPackageFile).optional()
 }).superRefine((appPackage, ctx) => {
   if (appPackage.entry.mediaType !== "application/javascript") {
     ctx.addIssue({
@@ -7663,16 +7842,16 @@ function parseKayUiAppPackageV1(input) {
 }
 
 // packages/plugin-protocol/dist/whiteboard.js
-import { z as z19 } from "zod";
+import { z as z22 } from "zod";
 var WhiteboardValue = JsonValue;
-var WhiteboardEntryEnvelope = z19.strictObject({
+var WhiteboardEntryEnvelope = z22.strictObject({
   id: NonEmptyString,
   typeId: GlobalContributionId,
-  schemaVersion: z19.number().int().positive(),
-  title: z19.string(),
+  schemaVersion: z22.number().int().positive(),
+  title: z22.string(),
   authorSessionId: NonEmptyString.nullable()
 });
-var WhiteboardEntrySummary = z19.strictObject({
+var WhiteboardEntrySummary = z22.strictObject({
   name: NonEmptyString,
   entry: WhiteboardEntryEnvelope,
   revision: NonEmptyString
@@ -7680,54 +7859,54 @@ var WhiteboardEntrySummary = z19.strictObject({
 var WhiteboardEntrySnapshot = WhiteboardEntrySummary.extend({
   value: WhiteboardValue
 });
-var WhiteboardDiagnostic = z19.strictObject({
+var WhiteboardDiagnostic = z22.strictObject({
   ruleId: NonEmptyString,
-  severity: z19.enum(["error", "warning"]),
+  severity: z22.enum(["error", "warning"]),
   message: NonEmptyString
 });
-var WhiteboardEntryInfo = z19.strictObject({
+var WhiteboardEntryInfo = z22.strictObject({
   name: NonEmptyString,
   revision: NonEmptyString,
   entry: WhiteboardEntryEnvelope.optional(),
-  state: z19.enum(["available", "unavailable", "unsupported-version", "invalid"]),
-  mutable: z19.boolean(),
-  diagnostics: z19.array(z19.string())
+  state: z22.enum(["available", "unavailable", "unsupported-version", "invalid"]),
+  mutable: z22.boolean(),
+  diagnostics: z22.array(z22.string())
 });
 var WhiteboardEntryInspection = WhiteboardEntryInfo.extend({
   value: WhiteboardValue.optional(),
-  text: z19.string(),
-  truncated: z19.boolean()
+  text: z22.string(),
+  truncated: z22.boolean()
 });
-var WhiteboardTypeInfo = z19.strictObject({
+var WhiteboardTypeInfo = z22.strictObject({
   typeId: GlobalContributionId,
   displayName: NonEmptyString,
-  schemaVersion: z19.number().int().positive(),
-  available: z19.boolean()
+  schemaVersion: z22.number().int().positive(),
+  available: z22.boolean()
 });
 
 // packages/plugin-protocol/dist/product-events.js
-import { z as z20 } from "zod";
+import { z as z23 } from "zod";
 var exportable = {
-  class: z20.literal("exportable"),
-  optional: z20.boolean().optional()
+  class: z23.literal("exportable"),
+  optional: z23.boolean().optional()
 };
-var PluginProductEventField = z20.union([
-  z20.strictObject({ class: z20.literal("local") }),
-  z20.strictObject({
+var PluginProductEventField = z23.union([
+  z23.strictObject({ class: z23.literal("local") }),
+  z23.strictObject({
     ...exportable,
-    type: z20.literal("enum"),
-    values: z20.array(z20.string())
+    type: z23.literal("enum"),
+    values: z23.array(z23.string())
   }),
-  z20.strictObject({
+  z23.strictObject({
     ...exportable,
-    type: z20.literal("number"),
-    min: z20.number(),
-    max: z20.number(),
-    integer: z20.boolean().optional()
+    type: z23.literal("number"),
+    min: z23.number(),
+    max: z23.number(),
+    integer: z23.boolean().optional()
   }),
-  z20.strictObject({
+  z23.strictObject({
     ...exportable,
-    type: z20.enum([
+    type: z23.enum([
       "boolean",
       "id",
       "identifier",
@@ -7743,9 +7922,9 @@ function isPluginProductEventName(name) {
 }
 
 // packages/plugin-protocol/dist/artifact-outputs.js
-import { z as z21 } from "zod";
+import { z as z24 } from "zod";
 var ARTIFACT_OUTPUT_PAGE_MAX = 200;
-var Segment = z21.string().min(1).max(1024).refine((value) => !/[^A-Za-z0-9._-]/.test(value)).refine((value) => value !== "." && value !== "..");
+var Segment = z24.string().min(1).max(1024).refine((value) => !/[^A-Za-z0-9._-]/.test(value)).refine((value) => value !== "." && value !== "..");
 function parseArtifactOutputUri(uri) {
   const match = /^output:\/\/([^/]+)\/([^/]+)$/.exec(uri);
   if (match === null || !Segment.safeParse(match[1]).success || !Segment.safeParse(match[2]).success)
@@ -7755,12 +7934,12 @@ function parseArtifactOutputUri(uri) {
 function isCanonicalArtifactOutputUri(uri) {
   return parseArtifactOutputUri(uri) !== void 0;
 }
-var ArtifactOutputUri = z21.string().refine(isCanonicalArtifactOutputUri, "Expected a canonical output://session/name URI");
-var ArtifactOutputChange = z21.union([
-  z21.strictObject({
-    uris: z21.array(ArtifactOutputUri).min(1).max(ARTIFACT_OUTPUT_PAGE_MAX)
+var ArtifactOutputUri = z24.string().refine(isCanonicalArtifactOutputUri, "Expected a canonical output://session/name URI");
+var ArtifactOutputChange = z24.union([
+  z24.strictObject({
+    uris: z24.array(ArtifactOutputUri).min(1).max(ARTIFACT_OUTPUT_PAGE_MAX)
   }),
-  z21.strictObject({ sessionId: Segment })
+  z24.strictObject({ sessionId: Segment })
 ]);
 
 // packages/plugin-protocol/dist/credential-text.js
@@ -7803,25 +7982,25 @@ function isCredentialShapedText(value) {
 }
 
 // packages/plugin-protocol/dist/ui-module-bundle.js
-import { z as z22 } from "zod";
+import { z as z25 } from "zod";
 var KAY_UI_MODULE_BUNDLE_PROTOCOL = "kay.ui.module-bundle.v1";
 var KAY_UI_MODULE_FILE_MAX_BYTES = 8 * 1024 * 1024;
 var KAY_UI_MODULE_BUNDLE_MAX_BYTES = 32 * 1024 * 1024;
 var KAY_UI_MODULE_BUNDLE_MAX_FILES = 256;
-var OutputPath = z22.string().min(1).max(1024).refine((value) => {
+var OutputPath = z25.string().min(1).max(1024).refine((value) => {
   const parsed = KayUiBundleIndexV1.shape.entryPath.safeParse(value);
   return parsed.success && parsed.data === value && value.split("/").every((part) => part !== "" && part !== ".") && // oxlint-disable-next-line eslint/no-control-regex -- Untrusted artifact paths must reject literal control characters.
   !/[\u0000-\u001f?#:%]/.test(value);
 }, { message: "bundle path must contain only unambiguous relative segments" });
-var Sha256 = z22.string().regex(/^[a-f0-9]{64}$/);
-var KayUiModuleBundleIndexV1 = z22.strictObject({
-  protocol: z22.literal(KAY_UI_MODULE_BUNDLE_PROTOCOL),
+var Sha256 = z25.string().regex(/^[a-f0-9]{64}$/);
+var KayUiModuleBundleIndexV1 = z25.strictObject({
+  protocol: z25.literal(KAY_UI_MODULE_BUNDLE_PROTOCOL),
   entryPath: OutputPath,
-  stylePaths: z22.array(OutputPath).max(KAY_UI_MODULE_BUNDLE_MAX_FILES),
-  files: z22.array(z22.strictObject({
+  stylePaths: z25.array(OutputPath).max(KAY_UI_MODULE_BUNDLE_MAX_FILES),
+  files: z25.array(z25.strictObject({
     path: OutputPath,
-    mediaType: z22.string().min(1).max(128).regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/),
-    byteLength: z22.number().int().min(1).max(KAY_UI_MODULE_FILE_MAX_BYTES),
+    mediaType: z25.string().min(1).max(128).regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/),
+    byteLength: z25.number().int().min(1).max(KAY_UI_MODULE_FILE_MAX_BYTES),
     sha256: Sha256
   })).min(1).max(KAY_UI_MODULE_BUNDLE_MAX_FILES)
 }).superRefine((index, ctx) => {
@@ -7851,9 +8030,9 @@ var KayUiModuleBundleIndexV1 = z22.strictObject({
       message: "bundle exceeds byte cap"
     });
 });
-var KayUiModuleBundleReference = z22.strictObject({
+var KayUiModuleBundleReference = z25.strictObject({
   generationId: Sha256,
-  revision: z22.string().min(1).max(4096).refine((value) => value.trim() === value),
+  revision: z25.string().min(1).max(4096).refine((value) => value.trim() === value),
   index: KayUiModuleBundleIndexV1
 });
 export {
@@ -7988,6 +8167,7 @@ export {
   PluginAuthManifest,
   PluginAuthScheme,
   PluginAuthService,
+  PluginByoocProfile,
   PluginCapabilityClaimInputV1,
   PluginCapabilityClaimV1,
   PluginCapabilityDecisionV1,
@@ -8016,10 +8196,12 @@ export {
   PluginNotificationRuleContribution,
   PluginOAuthClientSupplier,
   PluginPermissionManifest,
+  PluginPickerRound,
   PluginProductEventContribution,
   PluginProductEventField,
   PluginProvisioningProbe,
   PluginProvisioningRequirement,
+  PluginShellCommand,
   PluginSignal,
   PluginSignalPublish,
   PluginSkillSourceDeclaration,
@@ -8029,6 +8211,7 @@ export {
   PluginToolName,
   PluginWebSessionDeclaration,
   PluginWebSessionProbe,
+  PluginWorkloadPurpose,
   RENAMED_PLUGIN_CAPABILITY_SLUGS,
   RESERVED_DIRECTORY_PLUGIN_ID_PREFIXES,
   RETIRED_COMPATIBILITY_KEYS,
@@ -8091,6 +8274,9 @@ export {
   SessionProvenanceRecord,
   SessionReaderContribution,
   SessionRelationship,
+  ShellCommandOutcome,
+  ShellCommandRequest,
+  ShellCommandStep,
   SignedInStatusCode,
   SkillContribution,
   StorageGrantRequest,