@yaklabs-ai/plugin-protocol 0.8.4

package/dist/index.js

@@ -0,0 +1,4805 @@
+// packages/plugin-protocol/dist/app-data.js
+var KAY_APP_DATA_SNAPSHOT_MAX_BYTES = 16 * 1024 * 1024;
+var KAY_APP_DATA_CHANGE_MAX_BYTES = 256 * 1024;
+var KAY_APP_DATA_READ_REQUEST_MAX_BYTES = 64 * 1024;
+var KAY_APP_DATA_READ_RESULT_MAX_BYTES = 16 * 1024 * 1024;
+
+// packages/plugin-protocol/dist/transcript.js
+function branchEntryIds(entries) {
+  const last = entries[entries.length - 1];
+  if (last === void 0)
+    return EMPTY_BRANCH_IDS;
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const onBranch = /* @__PURE__ */ new Set();
+  let cursor = last.type === "leaf" ? last.targetId ?? null : last.id;
+  while (cursor !== null && !onBranch.has(cursor)) {
+    onBranch.add(cursor);
+    cursor = byId.get(cursor)?.parentId ?? null;
+  }
+  return onBranch;
+}
+var EMPTY_BRANCH_IDS = /* @__PURE__ */ new Set();
+
+// packages/plugin-protocol/dist/turn-packet.js
+var RUN_STARTED = "session_run_started";
+function textOf(entry) {
+  const content = entry.message?.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string" ? part.text : "").join("");
+}
+function originOf(entry) {
+  const m = entry.message;
+  if (m === void 0 || typeof m.clientIntentId !== "string")
+    return "unknown";
+  const details = m.details;
+  const deliveryId = typeof details === "object" && details !== null ? details.deliveryId : void 0;
+  return typeof deliveryId === "string" ? "human-verified" : "unknown";
+}
+function turnPacket(entries, settleEntryId, options = {}) {
+  const branch = branchEntryIds(entries);
+  const live = entries.filter((e) => branch.has(e.id));
+  const anchorIndex = live.findIndex((e) => e.id === settleEntryId);
+  const searchFrom = anchorIndex === -1 ? live.length - 1 : anchorIndex;
+  let runStart = -1;
+  for (let i = searchFrom; i >= 0; i -= 1) {
+    if (live[i]?.type === "custom" && live[i]?.customType === RUN_STARTED) {
+      runStart = i;
+      break;
+    }
+  }
+  let spanStart = runStart;
+  if (runStart === -1) {
+    spanStart = 0;
+    for (let i = searchFrom; i >= 0; i -= 1) {
+      if (live[i]?.type === "message" && live[i]?.message?.role === "user") {
+        spanStart = i;
+        break;
+      }
+    }
+  }
+  const span = live.slice(spanStart, searchFrom + 1);
+  const messages = span.filter((e) => e.type === "message" && e.message?.role !== void 0);
+  const people = messages.filter((e) => e.message?.role === "user");
+  const assistants = messages.filter((e) => e.message?.role === "assistant");
+  const opener = people[0];
+  if (opener === void 0)
+    return void 0;
+  const toPacket = (entry) => ({
+    entryId: entry.id,
+    timestamp: entry.timestamp,
+    text: textOf(entry),
+    origin: originOf(entry)
+  });
+  return {
+    personMessage: toPacket(opener),
+    personSteers: people.slice(1).map(toPacket),
+    assistantReplies: assistants.filter((e) => textOf(e).trim().length > 0).map(toPacket),
+    settleEntryId,
+    sessionTier: options.sessionTier ?? "unknown"
+  };
+}
+function precedingPersonMessages(entries, packet, count) {
+  if (count <= 0)
+    return [];
+  const branch = branchEntryIds(entries);
+  const live = entries.filter((e) => branch.has(e.id));
+  const openerIndex = live.findIndex((e) => e.id === packet.personMessage.entryId);
+  if (openerIndex === -1)
+    return [];
+  const found = [];
+  for (let i = openerIndex - 1; i >= 0 && found.length < count; i -= 1) {
+    const e = live[i];
+    if (e === void 0)
+      continue;
+    if (e.type !== "message" || e.message?.role !== "user")
+      continue;
+    if (originOf(e) !== "human-verified")
+      continue;
+    found.push({
+      entryId: e.id,
+      timestamp: e.timestamp,
+      text: textOf(e),
+      origin: "human-verified"
+    });
+  }
+  return found.reverse();
+}
+
+// packages/plugin-protocol/dist/app-data-read.js
+import { z as z2 } from "zod";
+
+// packages/plugin-protocol/dist/common.js
+import { z } from "zod";
+var KAY_PLUGIN_PROTOCOL_VERSION = "kay.plugin.v1";
+var KAY_PLUGIN_PROTOCOL_PACKAGE_NAME = "@kay/plugin-protocol";
+var KAY_PLUGIN_SDK_VERSION = "0.8.4";
+var KAY_PLUGIN_TARGET_NAMES = [
+  "kay.agent",
+  "kay.app",
+  "kay.ui"
+];
+var KayPluginProtocolVersion = z.literal(KAY_PLUGIN_PROTOCOL_VERSION);
+var PluginTargetName = z.enum(KAY_PLUGIN_TARGET_NAMES);
+var NonEmptyString = z.string().trim().min(1);
+var JsonValue = z.lazy(() => z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  z.array(JsonValue),
+  z.record(z.string(), JsonValue)
+]));
+var JsonObject = z.record(z.string(), JsonValue);
+var JsonSchema = z.record(z.string(), JsonValue);
+var PLUGIN_ID_PATTERN = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*$/;
+var LOCAL_CONTRIBUTION_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+var PLUGIN_TOOL_NAME_PATTERN = /^[a-z][a-z0-9_-]*$/;
+var PACKAGE_ASSET_PATH_PATTERN = /^\.\/(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+$/;
+var KAY_EVENT_PUBLISHER_ID = "kay";
+var PluginId = z.string().trim().regex(PLUGIN_ID_PATTERN).refine((id) => id !== KAY_EVENT_PUBLISHER_ID, {
+  message: `'${KAY_EVENT_PUBLISHER_ID}' is reserved for Bonsai's own event publisher`
+});
+var PluginNamespace = PluginId;
+var LocalContributionId = z.string().trim().regex(LOCAL_CONTRIBUTION_ID_PATTERN);
+var GlobalContributionId = z.string().trim().regex(PLUGIN_ID_PATTERN);
+var PluginToolName = z.string().trim().regex(PLUGIN_TOOL_NAME_PATTERN);
+var AuthServiceReference = GlobalContributionId;
+var AuthSchemeReference = GlobalContributionId;
+var AdapterSelectionKey = z.string().trim().regex(PLUGIN_ID_PATTERN);
+var AdapterPlacement = z.enum(["local-only", "anywhere"]);
+var UriScheme = z.string().trim().regex(/^[a-z][a-z0-9+.-]*$/);
+var MimeTypeString = z.string().trim().regex(/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/);
+var FileExtensionToken = z.string().trim().regex(/^[a-z0-9]+$/);
+var CliBinaryName = NonEmptyString.refine((value) => !value.includes("/"), {
+  message: "cli binding binary/alias must be a basename, not a path (no '/')"
+});
+var CliAuthEnvVarName = z.string().trim().regex(/^[A-Z][A-Z0-9_]*$/);
+var PackageAssetPath = z.string().trim().regex(PACKAGE_ASSET_PATH_PATTERN).refine((value) => !value.split("/").includes(".."), {
+  message: "package asset path must not contain a '..' path segment"
+});
+var PluginSourceClass = z.enum([
+  "bundled",
+  "org-shared",
+  "user-local",
+  "verified-marketplace",
+  "freeform"
+]);
+var ArtifactGenerationId = z.string().trim().min(1).brand();
+var HttpsUrl = z.url({ protocol: /^https$/ });
+var RegistrableDomain = z.string().trim().regex(/^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/);
+var HOST_LABEL_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var MAX_HOST_LENGTH = 253;
+var MAX_HOST_LABEL_LENGTH = 63;
+var GitHostName = RegistrableDomain.max(MAX_HOST_LENGTH).refine((host) => host.split(".").every((label) => label.length <= MAX_HOST_LABEL_LENGTH && HOST_LABEL_PATTERN.test(label)), {
+  message: "git host labels must be 1-63 characters and start and end with a letter or digit"
+});
+var GitBasicAuthUser = z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9._~-]+$/);
+var HttpStatusCode = z.number().int().min(100).max(599);
+var SignedInStatusCode = HttpStatusCode.refine((status) => !(status < 200 || status >= 300 && status < 400), {
+  message: "signedInStatuses cannot include 1xx or 3xx: the probe follows redirects and never observes them as a final status"
+});
+function hostWithinDomain(host, domain) {
+  return host === domain || host.endsWith(`.${domain}`);
+}
+function urlHostWithinDomain(url, domain) {
+  try {
+    return hostWithinDomain(new URL(url).hostname, domain);
+  } catch {
+    return false;
+  }
+}
+function refineWebSessionScopeConfined(webSession, ctx) {
+  const confined = (url) => webSession.cookieDomains.some((domain) => urlHostWithinDomain(url, domain));
+  if (!confined(webSession.loginUrl)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["loginUrl"],
+      message: "loginUrl host must fall within a declared cookie domain"
+    });
+  }
+  if (!confined(webSession.probe.url)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["probe", "url"],
+      message: "probe.url host must fall within a declared cookie domain"
+    });
+  }
+}
+var JsonPointer = z.string().trim().regex(/^(?:\/(?:[^/~]|~[01])*)*$/);
+var TargetEntrypoint = z.strictObject({
+  module: NonEmptyString,
+  export: NonEmptyString.optional()
+});
+
+// packages/plugin-protocol/dist/app-data-read.js
+var AppDataVersionedSchema = z2.strictObject({
+  version: z2.number().int().positive(),
+  schema: JsonSchema
+});
+var AppDataSourceRead = z2.strictObject({
+  request: AppDataVersionedSchema,
+  result: AppDataVersionedSchema
+});
+
+// packages/plugin-protocol/dist/artifact-provenance.js
+import { z as z4 } from "zod";
+
+// packages/plugin-protocol/dist/session-provenance.js
+import { z as z3 } from "zod";
+var NonEmptyString2 = z3.string().min(1);
+var SessionId = NonEmptyString2;
+var SessionRelationship = z3.discriminatedUnion("kind", [
+  /** Spawn lineage: this session is a subagent child of `sessionId`. */
+  z3.strictObject({ kind: z3.literal("child-of"), sessionId: SessionId }),
+  /**
+   * This session was forked from a point in `sessionId`'s transcript — `/fork`, and every
+   * hindsight followup. `atEntryId` pins the fork point when one was given.
+   */
+  z3.strictObject({
+    kind: z3.literal("forked-from"),
+    sessionId: SessionId,
+    atEntryId: NonEmptyString2.optional()
+  })
+]);
+var SdkSessionDoor = z3.enum([
+  "sessions.create",
+  "sessions.run",
+  "hindsight.runFollowup",
+  "agents.run"
+]);
+var SessionCreator = z3.discriminatedUnion("kind", [
+  /** A person, at the keyboard. `surface` names a scripted experience when one minted it. */
+  z3.strictObject({
+    kind: z3.literal("human"),
+    surface: NonEmptyString2.optional()
+  }),
+  /** Another session's agent, through a tool call. */
+  z3.strictObject({
+    kind: z3.literal("agent"),
+    sessionId: SessionId,
+    tool: NonEmptyString2,
+    /**
+     * The PARENT SESSION RUN that was driving when this session was minted
+     * (R2 provenance). Optional at parse so old rows stay readable; required
+     * of new agent producers. Absence on a new row is reported as a
+     * `legacy-run-id-missing` gap, never synthesized.
+     */
+    runId: NonEmptyString2.optional(),
+    /**
+     * Correlation only; never part of identity. A missing or reused
+     * `toolCallId` must not block the exact parent-run link and never
+     * participates in mutation-result identity.
+     */
+    toolCallId: NonEmptyString2.optional()
+  }),
+  /** A plugin, through one of its SDK doors. */
+  z3.strictObject({
+    kind: z3.literal("plugin"),
+    pluginId: NonEmptyString2,
+    door: SdkSessionDoor,
+    callerSessionId: SessionId.optional()
+  }),
+  /**
+   * An automation binding that fired.
+   *
+   * `triggerKind` names what the binding matched on, and `uri-change` is in the list because a
+   * durable watcher is a real condition kind (`@kay/automations`'s `AutomationMatch`) with no
+   * spelling among the other four: it watches the world OUTSIDE the session, so it is neither a
+   * schedule nor a session-fact occurrence. Added 2026-08-19, when the automation producers
+   * landed and a watcher's report session had nothing honest to stamp.
+   */
+  z3.strictObject({
+    kind: z3.literal("trigger"),
+    automationId: NonEmptyString2,
+    /**
+     * The AUTOMATION RUN that fired the binding (R2 provenance). Optional at
+     * parse so old rows stay readable; required of new automation producers.
+     * Absence on a new row is reported as a `legacy-run-id-missing` gap,
+     * never synthesized from the binding or a timestamp.
+     */
+    runId: NonEmptyString2.optional(),
+    bindingName: NonEmptyString2,
+    triggerKind: z3.enum(["cron", "time", "occurrence", "uri-change", "manual"])
+  }),
+  /** The daemon itself, for one of its own capabilities. */
+  z3.strictObject({ kind: z3.literal("daemon"), capability: NonEmptyString2 })
+]);
+var AGENT_RUNTIME_SESSION_CREATOR_KINDS = [
+  "human",
+  "agent",
+  "plugin",
+  "trigger",
+  "daemon"
+];
+var SessionDefiner = z3.discriminatedUnion("layer", [
+  z3.strictObject({
+    layer: z3.literal("plugin"),
+    pluginId: NonEmptyString2,
+    capability: NonEmptyString2,
+    /** See the type docblock: unpopulated by design until #5230's children land. */
+    version: NonEmptyString2.optional()
+  }),
+  z3.strictObject({ layer: z3.literal("host"), capability: NonEmptyString2 })
+]);
+var SessionIntent = z3.enum(["interactive", "headless"]);
+var SessionCausedByEventShape = z3.strictObject({
+  /** The plugin's own name for the subscribe handler that made this run, e.g. `"work-record"`. */
+  handler: NonEmptyString2,
+  /** Absent reads as `"session-event"` — see this type's own doc comment. */
+  kind: z3.enum(["session-event", "backfill"]).optional(),
+  /** Required when `kind` is `"session-event"` or absent; must be omitted when `kind` is `"backfill"`. */
+  event: z3.strictObject({
+    /** {@link KayAppSessionEventType} in `@kay/plugin-sdk`, mirrored: a closed, extensible union. */
+    type: z3.enum(["turn-settled", "phase-shift"]),
+    entryId: NonEmptyString2,
+    /** The source run captured at the event boundary; absence remains unresolved. */
+    runId: NonEmptyString2.optional()
+  }).optional(),
+  /**
+   * The plugin-supplied exact-match dedupe key, when it gave one. Absent when the handler chose
+   * not to dedupe this run (every call is admitted). Carried here (not just checked and
+   * discarded) so a later reader can explain WHY the host refused a same-keyed second run. A
+   * `"backfill"` cause always supplies one (`backfill:${sessionId}`) so a sweep can never
+   * double-run the same historical session, but that is a caller convention, not a schema rule.
+   */
+  dedupeKey: NonEmptyString2.optional()
+});
+var SessionCausedByEvent = SessionCausedByEventShape.refine((value) => (value.kind ?? "session-event") === "backfill" || value.event !== void 0, {
+  message: 'event is required unless kind is "backfill"',
+  path: ["event"]
+}).refine((value) => value.kind !== "backfill" || value.event === void 0, {
+  message: 'event must be omitted when kind is "backfill"',
+  path: ["event"]
+});
+var SessionProvenanceRecord = z3.strictObject({
+  relationships: z3.array(SessionRelationship),
+  createdBy: SessionCreator,
+  definedBy: SessionDefiner,
+  intent: SessionIntent,
+  /** See {@link SessionCausedByEvent}. Present only alongside `createdBy.door === "agents.run"`. */
+  causedByEvent: SessionCausedByEvent.optional()
+});
+
+// packages/plugin-protocol/dist/artifact-provenance.js
+var ARTIFACT_PROVENANCE_VERSION = "kay.artifact-provenance.v1";
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127)
+      return true;
+  }
+  return false;
+}
+function isProvenanceJson(input) {
+  const active = /* @__PURE__ */ new Set();
+  const stack = [{ value: input }];
+  while (stack.length > 0) {
+    const { value, leave } = stack.pop();
+    if (value === null || typeof value === "boolean")
+      continue;
+    if (typeof value === "string") {
+      if (hasControlCharacter(value))
+        return false;
+      continue;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value) || Object.is(value, -0))
+        return false;
+      continue;
+    }
+    if (typeof value !== "object")
+      return false;
+    if (leave) {
+      active.delete(value);
+      continue;
+    }
+    if (active.has(value))
+      return false;
+    const array = Array.isArray(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (!array && prototype !== Object.prototype && prototype !== null)
+      return false;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Reflect.ownKeys(descriptors).filter((key) => !array || key !== "length");
+    if (array && (keys.length !== value.length || keys.some((key, index) => key !== String(index))))
+      return false;
+    active.add(value);
+    stack.push({ value, leave: true });
+    for (const key of keys) {
+      if (typeof key !== "string" || hasControlCharacter(key))
+        return false;
+      const descriptor = descriptors[key];
+      if (!descriptor.enumerable || !("value" in descriptor))
+        return false;
+      stack.push({ value: descriptor.value });
+    }
+  }
+  return true;
+}
+var Text = z4.string().min(1).refine((value) => !hasControlCharacter(value), {
+  message: "Provenance text must not contain control characters"
+});
+var ArtifactProvenanceRevision = z4.strictObject({
+  storeId: Text,
+  artifactId: Text,
+  uri: Text.optional(),
+  /** The enclosing commit is resolved by the reader, avoiding a self-referential commit hash. */
+  revision: z4.union([
+    Text,
+    z4.strictObject({ kind: z4.literal("enclosing-commit") }),
+    z4.null()
+  ]),
+  operationId: Text.nullable(),
+  /** Optional when the store identifies revisions without content addressing (including tombstones). */
+  digest: z4.strictObject({ algorithm: Text, value: Text }).optional()
+});
+var ArtifactProvenanceActor = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("session"),
+    sessionId: Text,
+    runId: Text.nullable()
+  }),
+  z4.strictObject({
+    kind: z4.literal("human"),
+    userId: Text.optional(),
+    surface: Text
+  }),
+  z4.strictObject({
+    kind: z4.literal("plugin"),
+    pluginId: Text,
+    capability: Text
+  }),
+  z4.strictObject({ kind: z4.literal("host"), capability: Text }),
+  z4.strictObject({ kind: z4.literal("import"), source: Text }),
+  z4.strictObject({ kind: z4.literal("unknown") })
+]);
+var ArtifactProvenanceCause = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("session"),
+    sessionId: Text,
+    runId: Text.nullable()
+  }),
+  z4.strictObject({
+    kind: z4.literal("session-event"),
+    sessionId: Text,
+    cause: SessionCausedByEvent
+  }),
+  z4.strictObject({
+    kind: z4.literal("automation"),
+    automationId: Text,
+    runId: Text.nullable()
+  }),
+  z4.strictObject({ kind: z4.literal("operation"), operationId: Text })
+]);
+var ArtifactProvenanceOperation = z4.strictObject({
+  id: Text.nullable(),
+  at: z4.iso.datetime().nullable(),
+  name: Text,
+  actor: ArtifactProvenanceActor,
+  /** Null means no tool invocation; a known invocation with an unknown id records a gap. */
+  invocation: z4.strictObject({
+    tool: Text,
+    toolCallId: Text.nullable(),
+    origin: z4.enum(["model", "host"])
+  }).nullable(),
+  /** Known causes only; unavailable cause capture requires a gap, never a guessed creation cause. */
+  causes: z4.array(ArtifactProvenanceCause)
+});
+var ArtifactProvenanceReference = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("session"),
+    sessionId: Text,
+    runId: Text.optional()
+  }),
+  z4.strictObject({
+    kind: z4.literal("artifact"),
+    revision: ArtifactProvenanceRevision
+  }),
+  z4.strictObject({
+    kind: z4.literal("resource"),
+    uri: Text,
+    revision: Text.nullable()
+  })
+]);
+var ArtifactProvenanceGap = z4.strictObject({
+  code: z4.enum([
+    "unknown",
+    "capture-failed",
+    "legacy-derived",
+    "ambiguous-predecessor",
+    "unverified-index",
+    "missing-ancestor",
+    "cycle",
+    "truncated",
+    "metadata-write-failed",
+    "invalid-record"
+  ]),
+  /** JSON Pointer into this envelope; the empty pointer covers the whole capture. */
+  at: z4.string().regex(/^(?:\/(?:[^~/]|~[01])*)*$/).refine((value) => !hasControlCharacter(value)),
+  detail: Text.optional()
+}).refine((gap) => gap.at !== "" || gap.code === "capture-failed", {
+  message: "Only a whole-capture failure may cover the entire envelope"
+});
+var ArtifactProvenanceSession = z4.strictObject({
+  sessionId: Text,
+  basis: z4.enum(["recorded", "legacy-derived", "unverified-index", "missing"]),
+  record: SessionProvenanceRecord.nullable()
+});
+var ArtifactProvenanceSource = z4.strictObject({
+  relationship: z4.enum([
+    "revision-of",
+    "copied-from",
+    "harvested-from",
+    "restored-from",
+    "accepted-from",
+    "imported-from"
+  ]),
+  revision: ArtifactProvenanceRevision
+});
+var ArtifactProvenanceMutation = z4.strictObject({
+  kind: z4.enum([
+    "create",
+    "update",
+    "delete",
+    "copy",
+    "harvest",
+    "restore",
+    "accept",
+    "import"
+  ]),
+  target: ArtifactProvenanceRevision,
+  /** Retained from the source on copies/acceptance; operation.actor is the persistence actor. */
+  producer: ArtifactProvenanceOperation,
+  sources: z4.array(ArtifactProvenanceSource)
+});
+var Envelope = z4.strictObject({
+  version: z4.literal(ARTIFACT_PROVENANCE_VERSION),
+  operation: ArtifactProvenanceOperation,
+  artifacts: z4.array(ArtifactProvenanceMutation).min(1),
+  sessions: z4.array(ArtifactProvenanceSession),
+  subjects: z4.array(ArtifactProvenanceReference),
+  evidence: z4.array(ArtifactProvenanceReference),
+  gaps: z4.array(ArtifactProvenanceGap)
+});
+var UNKNOWN = [
+  "unknown",
+  "capture-failed",
+  "metadata-write-failed",
+  "invalid-record"
+];
+var MISSING = ["missing-ancestor", "truncated"];
+function checkOperation(operation, path, gap, session) {
+  if (operation.id === null)
+    gap(`${path}/id`, UNKNOWN);
+  if (operation.at === null)
+    gap(`${path}/at`, UNKNOWN);
+  if (operation.actor.kind === "unknown")
+    gap(`${path}/actor`, UNKNOWN);
+  if (operation.actor.kind === "session") {
+    session(operation.actor.sessionId, `${path}/actor/sessionId`);
+    if (operation.actor.runId === null)
+      gap(`${path}/actor/runId`, UNKNOWN);
+  }
+  if (operation.invocation?.toolCallId === null)
+    gap(`${path}/invocation/toolCallId`, UNKNOWN);
+  operation.causes.forEach((cause, index) => {
+    const causePath = `${path}/causes/${index}`;
+    if (cause.kind === "session" || cause.kind === "session-event")
+      session(cause.sessionId, `${causePath}/sessionId`);
+    if (cause.kind === "session-event" && (cause.cause.kind ?? "session-event") !== "backfill" && cause.cause.event?.runId === void 0) {
+      gap(`${causePath}/cause/event/runId`, UNKNOWN);
+    }
+    if ("runId" in cause && cause.runId === null)
+      gap(`${causePath}/runId`, UNKNOWN);
+  });
+}
+function checkRevision(revision, path, gap, issue, currentTarget = false) {
+  if (revision.revision === null)
+    gap(`${path}/revision`, UNKNOWN);
+  else if (typeof revision.revision === "object") {
+    if (!currentTarget)
+      issue(path.slice(1).split("/"), "Only the current target may refer to its enclosing commit");
+    if (revision.digest === void 0)
+      issue(path.slice(1).split("/"), "An enclosing-commit target must bind the exact content digest before commit");
+  }
+  if (revision.operationId === null)
+    gap(`${path}/operationId`, UNKNOWN);
+}
+function checkGraph(envelope, gap, issue) {
+  const nodes = new Map(envelope.sessions.map((node, index) => [node.sessionId, index]));
+  const edges = /* @__PURE__ */ new Map();
+  envelope.sessions.forEach((node, index) => {
+    const path = `/sessions/${index}`;
+    if (nodes.get(node.sessionId) !== index)
+      issue(["sessions", index, "sessionId"], "Session snapshots must be deduplicated by sessionId");
+    if (node.basis === "missing") {
+      if (node.record !== null)
+        issue(["sessions", index, "record"], "A missing snapshot cannot carry a creation record");
+      gap(path, MISSING);
+    } else if (node.record === null) {
+      issue(["sessions", index, "record"], "A non-missing snapshot requires its creation record");
+    }
+    if (node.basis === "legacy-derived")
+      gap(path, ["legacy-derived"]);
+    if (node.basis === "unverified-index")
+      gap(path, ["unverified-index"]);
+    const record = node.record;
+    if (record === null)
+      return;
+    const outgoing = record.relationships.map((relationship, edgeIndex) => ({
+      id: relationship.sessionId,
+      path: `${path}/record/relationships/${edgeIndex}/sessionId`
+    }));
+    const creator = record.createdBy;
+    if (creator.kind === "agent")
+      outgoing.push({
+        id: creator.sessionId,
+        path: `${path}/record/createdBy/sessionId`
+      });
+    if (creator.kind === "plugin" && creator.callerSessionId !== void 0)
+      outgoing.push({
+        id: creator.callerSessionId,
+        path: `${path}/record/createdBy/callerSessionId`
+      });
+    if ((creator.kind === "agent" || creator.kind === "trigger") && creator.runId === void 0 && node.basis === "recorded")
+      gap(`${path}/record/createdBy/runId`, UNKNOWN);
+    const eventCause = record.causedByEvent;
+    if (eventCause !== void 0 && (eventCause.kind ?? "session-event") !== "backfill" && eventCause.event?.runId === void 0 && node.basis === "recorded") {
+      gap(`${path}/record/causedByEvent/event/runId`, UNKNOWN);
+    }
+    edges.set(node.sessionId, outgoing);
+    outgoing.forEach((edge) => {
+      if (!nodes.has(edge.id))
+        gap(edge.path, MISSING);
+    });
+  });
+  const state = /* @__PURE__ */ new Map();
+  for (const node of envelope.sessions) {
+    if (state.has(node.sessionId))
+      continue;
+    const stack = [{ id: node.sessionId, next: 0 }];
+    state.set(node.sessionId, "active");
+    while (stack.length > 0) {
+      const current = stack[stack.length - 1];
+      const edge = edges.get(current.id)?.[current.next++];
+      if (edge === void 0) {
+        state.set(current.id, "done");
+        stack.pop();
+      } else if (state.get(edge.id) === "active") {
+        gap(edge.path, ["cycle"]);
+      } else if (nodes.has(edge.id) && !state.has(edge.id)) {
+        state.set(edge.id, "active");
+        stack.push({ id: edge.id, next: 0 });
+      }
+    }
+  }
+}
+function validateEnvelope(envelope, context) {
+  const issue = (path, message) => context.addIssue({ code: "custom", path, message });
+  const gap = (path, codes) => {
+    if (!envelope.gaps.some((entry) => entry.code === "capture-failed" && entry.at === "" || codes.includes(entry.code) && (path === entry.at || path.startsWith(`${entry.at}/`)))) {
+      issue(path.slice(1).split("/"), `Unresolved provenance requires an explicit ${codes.join(" or ")} gap`);
+    }
+  };
+  const nodes = new Set(envelope.sessions.map((node) => node.sessionId));
+  const session = (id, path) => {
+    if (!nodes.has(id))
+      gap(path, MISSING);
+  };
+  if (envelope.operation.id === null)
+    issue(["operation", "id"], "The current mutation requires a fresh operation identity");
+  checkOperation(envelope.operation, "/operation", gap, session);
+  const targets = /* @__PURE__ */ new Set();
+  envelope.artifacts.forEach((artifact, index) => {
+    const path = `/artifacts/${index}`;
+    const key = JSON.stringify([
+      artifact.target.storeId,
+      artifact.target.artifactId
+    ]);
+    if (targets.has(key))
+      issue(["artifacts", index, "target"], "One operation records each target artifact once");
+    targets.add(key);
+    if (artifact.target.operationId !== envelope.operation.id)
+      issue(["artifacts", index, "target", "operationId"], "The target must name the current persistence operation");
+    checkRevision(artifact.target, `${path}/target`, gap, issue, true);
+    checkOperation(artifact.producer, `${path}/producer`, gap, session);
+    artifact.sources.forEach((source, sourceIndex) => checkRevision(source.revision, `${path}/sources/${sourceIndex}/revision`, gap, issue));
+    const requiredSource = {
+      create: void 0,
+      update: "revision-of",
+      delete: "revision-of",
+      copy: "copied-from",
+      harvest: "harvested-from",
+      restore: "restored-from",
+      accept: "accepted-from",
+      import: "imported-from"
+    }[artifact.kind];
+    if (requiredSource !== void 0 && !artifact.sources.some((source) => source.relationship === requiredSource))
+      gap(`${path}/sources`, UNKNOWN);
+  });
+  for (const role of ["subjects", "evidence"]) {
+    envelope[role].forEach((reference, index) => {
+      const path = `/${role}/${index}`;
+      if (reference.kind === "session")
+        session(reference.sessionId, `${path}/sessionId`);
+      if (reference.kind === "artifact")
+        checkRevision(reference.revision, `${path}/revision`, gap, issue);
+      if (reference.kind === "resource" && reference.revision === null)
+        gap(`${path}/revision`, UNKNOWN);
+    });
+  }
+  checkGraph(envelope, gap, issue);
+}
+var ArtifactProvenanceEnvelopeV1 = z4.unknown().refine(isProvenanceJson, {
+  message: "Provenance must be plain, acyclic, lossless JSON without control characters"
+}).pipe(Envelope.superRefine(validateEnvelope));
+function parseArtifactProvenanceEnvelope(input) {
+  return ArtifactProvenanceEnvelopeV1.parse(input);
+}
+var ArtifactProvenanceCaptureContextSchema = z4.strictObject({
+  operation: ArtifactProvenanceOperation,
+  sessions: z4.array(ArtifactProvenanceSession),
+  subjects: z4.array(ArtifactProvenanceReference),
+  evidence: z4.array(ArtifactProvenanceReference),
+  gaps: z4.array(ArtifactProvenanceGap)
+});
+function parseArtifactProvenanceCaptureContext(input) {
+  return ArtifactProvenanceCaptureContextSchema.parse(input);
+}
+
+// packages/plugin-protocol/dist/artifact-provenance-capture.js
+var DEFAULT_CLOCK = {
+  now: () => (/* @__PURE__ */ new Date()).toISOString(),
+  mintId: () => globalThis.crypto.randomUUID()
+};
+function mintOperation(input, clock = DEFAULT_CLOCK) {
+  const gaps = [];
+  if (input.actor.kind === "unknown") {
+    gaps.push({ code: "unknown", at: "/operation/actor" });
+  }
+  if (input.actor.kind === "session" && input.actor.runId === null) {
+    gaps.push({ code: "unknown", at: "/operation/actor/runId" });
+  }
+  const invocation = input.invocation ?? null;
+  if (invocation !== null && invocation.toolCallId === null) {
+    gaps.push({ code: "unknown", at: "/operation/invocation/toolCallId" });
+  }
+  const causes = input.causes ?? [];
+  causes.forEach((cause, index) => {
+    if ("runId" in cause && cause.runId === null) {
+      gaps.push({ code: "unknown", at: `/operation/causes/${index}/runId` });
+    }
+    if (cause.kind === "session-event" && (cause.cause.kind ?? "session-event") !== "backfill" && cause.cause.event?.runId === void 0) {
+      gaps.push({
+        code: "unknown",
+        at: `/operation/causes/${index}/cause/event/runId`
+      });
+    }
+  });
+  return {
+    operation: {
+      id: input.id ?? clock.mintId(),
+      at: input.at ?? clock.now(),
+      name: input.name,
+      actor: input.actor,
+      invocation,
+      // Copied into a fresh mutable array: `ArtifactProvenanceOperation.causes` is a zod-inferred
+      // mutable array, and `causes` here is `readonly` only because it defaulted from an
+      // optional readonly input.
+      causes: [...causes]
+    },
+    gaps
+  };
+}
+function captureFailedContext(input, clock = DEFAULT_CLOCK) {
+  return {
+    operation: {
+      id: clock.mintId(),
+      at: clock.now(),
+      name: input.name,
+      actor: { kind: "unknown" },
+      invocation: null,
+      causes: []
+    },
+    sessions: [],
+    subjects: [],
+    evidence: [],
+    // The detail is an error message, and error text can carry C0/DEL control characters (a
+    // multi-line zod or V8 message). Escaped, never dropped: a control character would break the
+    // kernel's lossless-JSON check for the whole capture, turning a failed capture into a failed
+    // MUTATION — the one outcome this record exists to prevent.
+    gaps: [
+      {
+        code: "capture-failed",
+        at: "",
+        detail: scrubControlCharacters(input.detail)
+      }
+    ]
+  };
+}
+function scrubControlCharacters(value) {
+  let out = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    out += code <= 31 || code === 127 ? `\\u${code.toString(16).padStart(4, "0")}` : value[index];
+  }
+  return out;
+}
+var DEFAULT_MAX_NODES = 128;
+function edgesOf(record) {
+  const edges = record.relationships.map((r) => r.sessionId);
+  const creator = record.createdBy;
+  if (creator.kind === "agent")
+    edges.push(creator.sessionId);
+  if (creator.kind === "plugin" && creator.callerSessionId !== void 0) {
+    edges.push(creator.callerSessionId);
+  }
+  return edges;
+}
+async function resolveSessionAncestry(options) {
+  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+  const resolved = /* @__PURE__ */ new Map();
+  const order = [];
+  const queued = /* @__PURE__ */ new Set();
+  const queue = [];
+  const enqueue = (id) => {
+    if (queued.has(id) || resolved.has(id))
+      return;
+    queued.add(id);
+    queue.push(id);
+  };
+  for (const id of options.seedSessionIds)
+    enqueue(id);
+  let truncated = false;
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (order.length >= maxNodes) {
+      truncated = true;
+      continue;
+    }
+    const result = await options.lookup(id);
+    resolved.set(id, result);
+    order.push(id);
+    if (result.record !== null) {
+      for (const edge of edgesOf(result.record))
+        enqueue(edge);
+    }
+  }
+  truncated = truncated || queue.length > 0;
+  const indexOf = new Map(order.map((id, index) => [id, index]));
+  const sessions = order.map((id) => {
+    const result = resolved.get(id);
+    return { sessionId: id, basis: result.basis, record: result.record };
+  });
+  const gaps = [];
+  if (truncated) {
+    gaps.push({
+      code: "truncated",
+      at: "/sessions",
+      detail: `Ancestry walk stopped at ${maxNodes} sessions`
+    });
+  }
+  sessions.forEach((node, index) => {
+    const path = `/sessions/${index}`;
+    if (node.basis === "missing" && !truncated) {
+      gaps.push({ code: "missing-ancestor", at: path });
+    }
+    if (node.basis === "legacy-derived") {
+      gaps.push({ code: "legacy-derived", at: path });
+    }
+    if (node.basis === "unverified-index") {
+      gaps.push({ code: "unverified-index", at: path });
+    }
+    const record = node.record;
+    if (record === null)
+      return;
+    record.relationships.forEach((relationship, edgeIndex) => {
+      if (!indexOf.has(relationship.sessionId) && !truncated) {
+        gaps.push({
+          code: "missing-ancestor",
+          at: `${path}/record/relationships/${edgeIndex}/sessionId`
+        });
+      }
+    });
+    const creator = record.createdBy;
+    if (creator.kind === "agent" && !indexOf.has(creator.sessionId) && !truncated) {
+      gaps.push({
+        code: "missing-ancestor",
+        at: `${path}/record/createdBy/sessionId`
+      });
+    }
+    if (creator.kind === "plugin" && creator.callerSessionId !== void 0 && !indexOf.has(creator.callerSessionId) && !truncated) {
+      gaps.push({
+        code: "missing-ancestor",
+        at: `${path}/record/createdBy/callerSessionId`
+      });
+    }
+    if ((creator.kind === "agent" || creator.kind === "trigger") && creator.runId === void 0 && node.basis === "recorded") {
+      gaps.push({
+        code: "unknown",
+        at: `${path}/record/createdBy/runId`
+      });
+    }
+    const eventCause = record.causedByEvent;
+    if (eventCause !== void 0 && (eventCause.kind ?? "session-event") !== "backfill" && eventCause.event?.runId === void 0 && node.basis === "recorded") {
+      gaps.push({
+        code: "unknown",
+        at: `${path}/record/causedByEvent/event/runId`
+      });
+    }
+  });
+  const state = /* @__PURE__ */ new Map();
+  const edgesByIndex = sessions.map((node) => {
+    if (node.record === null)
+      return [];
+    const resolvedEdges = [];
+    edgesOf(node.record).forEach((id, slot) => {
+      const targetIndex = indexOf.get(id);
+      if (targetIndex !== void 0)
+        resolvedEdges.push({ targetIndex, slot });
+    });
+    return resolvedEdges;
+  });
+  for (let start = 0; start < sessions.length; start += 1) {
+    const startId = sessions[start].sessionId;
+    if (state.has(startId))
+      continue;
+    const stack = [
+      { index: start, next: 0 }
+    ];
+    state.set(startId, "active");
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const edges = edgesByIndex[frame.index];
+      if (frame.next >= edges.length) {
+        state.set(sessions[frame.index].sessionId, "done");
+        stack.pop();
+        continue;
+      }
+      const edge = edges[frame.next];
+      frame.next += 1;
+      const targetId = sessions[edge.targetIndex].sessionId;
+      const targetState = state.get(targetId);
+      if (targetState === "active") {
+        gaps.push({
+          code: "cycle",
+          at: edgeSlotPath(sessions[frame.index], frame.index, edge.slot)
+        });
+      } else if (targetState === void 0) {
+        state.set(targetId, "active");
+        stack.push({ index: edge.targetIndex, next: 0 });
+      }
+    }
+  }
+  return { sessions, gaps };
+}
+function edgeSlotPath(node, nodeIndex, slot) {
+  const path = `/sessions/${nodeIndex}`;
+  const record = node.record;
+  if (slot < record.relationships.length) {
+    return `${path}/record/relationships/${slot}/sessionId`;
+  }
+  const creator = record.createdBy;
+  return creator.kind === "agent" ? `${path}/record/createdBy/sessionId` : `${path}/record/createdBy/callerSessionId`;
+}
+async function captureArtifactProvenance(input, clock = DEFAULT_CLOCK) {
+  const { operation, gaps: operationGaps } = mintOperation(input.operation, clock);
+  const { sessions, gaps: ancestryGaps } = await resolveSessionAncestry({
+    seedSessionIds: [
+      .../* @__PURE__ */ new Set([
+        ...input.seedSessionIds,
+        ...operation.causes.flatMap((cause) => cause.kind === "session" || cause.kind === "session-event" ? [cause.sessionId] : []),
+        ...(input.subjects ?? []).flatMap((reference) => reference.kind === "session" ? [reference.sessionId] : []),
+        ...(input.evidence ?? []).flatMap((reference) => reference.kind === "session" ? [reference.sessionId] : [])
+      ])
+    ],
+    lookup: input.lookup,
+    ...input.maxNodes === void 0 ? {} : { maxNodes: input.maxNodes }
+  });
+  return {
+    operation,
+    sessions,
+    subjects: input.subjects ?? [],
+    evidence: input.evidence ?? [],
+    gaps: [...operationGaps, ...ancestryGaps]
+  };
+}
+function finalizeArtifactProvenanceEnvelope(capture, artifacts) {
+  const artifactGaps = [];
+  const blanket = capture.gaps.some((gap) => gap.code === "capture-failed" && gap.at === "");
+  if (!blanket) {
+    artifacts.forEach((artifact, index) => {
+      if (artifact.target.revision === null) {
+        artifactGaps.push({
+          code: "unknown",
+          at: `/artifacts/${index}/target/revision`
+        });
+      }
+      if (artifact.producer === capture.operation) {
+        for (const gap of capture.gaps) {
+          if (gap.at === "/operation" || gap.at.startsWith("/operation/")) {
+            artifactGaps.push({
+              ...gap,
+              at: `/artifacts/${index}/producer${gap.at.slice("/operation".length)}`
+            });
+          }
+        }
+      }
+    });
+  }
+  return parseArtifactProvenanceEnvelope({
+    version: ARTIFACT_PROVENANCE_VERSION,
+    operation: capture.operation,
+    artifacts,
+    sessions: capture.sessions,
+    subjects: capture.subjects,
+    evidence: capture.evidence,
+    gaps: [...capture.gaps, ...artifactGaps]
+  });
+}
+
+// packages/plugin-protocol/dist/authority.js
+import { z as z6 } from "zod";
+
+// packages/plugin-protocol/dist/permissions.js
+import { z as z5 } from "zod";
+var AuthGrantOperation = z5.enum([
+  "status",
+  "connect",
+  "disconnect",
+  "resolve"
+]);
+var AuthAccountSelector = z5.discriminatedUnion("kind", [
+  z5.strictObject({ kind: z5.literal("active") }),
+  z5.strictObject({ kind: z5.literal("account-id"), accountId: NonEmptyString }),
+  z5.strictObject({ kind: z5.literal("record-id"), recordId: NonEmptyString })
+]);
+var AuthScopeDefinition = z5.strictObject({
+  id: NonEmptyString,
+  label: NonEmptyString,
+  description: NonEmptyString,
+  documentationUrl: z5.url().optional()
+});
+var ScopeNeed = z5.strictObject({
+  scope: NonEmptyString,
+  reason: NonEmptyString.optional()
+});
+var ScopeAlternative = z5.strictObject({
+  allOf: z5.array(ScopeNeed).min(1)
+});
+var ScopeRequirement = z5.strictObject({
+  purpose: NonEmptyString,
+  alternatives: z5.array(ScopeAlternative).min(1)
+});
+var AuthGrantRequestBase = z5.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
+  // `consumesAuthServices` rather than resolved here.
+  service: AuthServiceReference,
+  // 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: z5.array(AuthSchemeReference).min(1).optional(),
+  operations: z5.array(AuthGrantOperation).min(1),
+  purposes: z5.array(NonEmptyString).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: z5.array(NonEmptyString).min(1).optional(),
+  // Legacy spelling for `allowedScopes`; new manifests should use the authority-shaped name.
+  requiredScopes: z5.array(NonEmptyString).min(1).optional(),
+  // Preferred proactive consent bundle; runtime resolution still uses `scopeRequirement`.
+  connectScopes: z5.array(NonEmptyString).min(1).optional(),
+  scopeRequirement: ScopeRequirement.optional(),
+  scopeDefinitions: z5.array(AuthScopeDefinition).min(1).optional(),
+  accountSelectors: z5.array(AuthAccountSelector).min(1).optional()
+});
+function validateAuthGrantRequest(grant, ctx) {
+  if (grant.allowedScopes !== void 0 && grant.requiredScopes !== void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["allowedScopes"],
+      message: "allowedScopes and legacy requiredScopes are mutually exclusive"
+    });
+  }
+  if (grant.requiredScopes !== void 0 && (grant.connectScopes !== void 0 || grant.scopeRequirement !== void 0 || grant.scopeDefinitions !== void 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["requiredScopes"],
+      message: "legacy requiredScopes cannot be combined with connectScopes, scopeRequirement, or scopeDefinitions"
+    });
+  }
+  const envelope = grant.allowedScopes ?? grant.requiredScopes;
+  if (grant.connectScopes !== void 0) {
+    if (grant.allowedScopes === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["connectScopes"],
+        message: "connectScopes requires an allowedScopes envelope"
+      });
+    } else {
+      const allowed = new Set(grant.allowedScopes);
+      for (const [scopeIndex, scope] of grant.connectScopes.entries()) {
+        if (!allowed.has(scope)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["connectScopes", scopeIndex],
+            message: `scope '${scope}' is outside allowedScopes`
+          });
+        }
+      }
+    }
+  }
+  if (grant.scopeRequirement !== void 0) {
+    if (envelope === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["scopeRequirement"],
+        message: "scopeRequirement requires an allowedScopes envelope"
+      });
+    } else {
+      const allowed = new Set(envelope);
+      for (const [alternativeIndex, alternative] of grant.scopeRequirement.alternatives.entries()) {
+        for (const [needIndex, need] of alternative.allOf.entries()) {
+          if (!allowed.has(need.scope)) {
+            ctx.addIssue({
+              code: "custom",
+              path: [
+                "scopeRequirement",
+                "alternatives",
+                alternativeIndex,
+                "allOf",
+                needIndex,
+                "scope"
+              ],
+              message: `scope '${need.scope}' is outside allowedScopes`
+            });
+          }
+        }
+      }
+    }
+  }
+  const seenDefinitions = /* @__PURE__ */ new Set();
+  for (const [index, definition] of (grant.scopeDefinitions ?? []).entries()) {
+    if (seenDefinitions.has(definition.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["scopeDefinitions", index, "id"],
+        message: `duplicate scope definition '${definition.id}'`
+      });
+    }
+    seenDefinitions.add(definition.id);
+  }
+}
+var AuthGrantRequest = AuthGrantRequestBase.superRefine(validateAuthGrantRequest);
+var StorageGrantRequest = z5.strictObject({
+  kind: z5.enum(["sqlite", "dataDir"]),
+  operations: z5.array(z5.enum(["open", "read", "write"])).min(1)
+});
+var EventGrantRequest = z5.strictObject({
+  event: NonEmptyString,
+  operations: z5.array(z5.enum(["subscribe", "publish"])).min(1)
+});
+var EndpointGrantRequest = z5.strictObject({
+  endpoint: LocalContributionId,
+  operations: z5.array(z5.enum(["register", "invoke"])).min(1)
+});
+var WebSessionOrigin = z5.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) {
+      ctx.addIssue({
+        code: "custom",
+        message: "must be a canonical HTTPS origin without credentials, path, query, or fragment"
+      });
+    }
+  } catch {
+    ctx.addIssue({ code: "custom", message: "must be a valid HTTPS origin" });
+  }
+});
+var WebSessionCsrfSourceUrl = z5.url({ protocol: /^https$/ }).superRefine((value, ctx) => {
+  const url = new URL(value);
+  if (url.username !== "" || url.password !== "" || url.hash !== "") {
+    ctx.addIssue({
+      code: "custom",
+      message: "must not contain credentials or a fragment"
+    });
+  }
+});
+var WebSessionPathPrefix = NonEmptyString.superRefine((value, ctx) => {
+  if (!value.startsWith("/") || value.includes("?") || value.includes("#")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "must be an absolute path prefix without a query or fragment"
+    });
+    return;
+  }
+  if (/%(?:25|2e|2f|5c)/iu.test(value)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "must not contain encoded percent, dot, or path-separator characters"
+    });
+    return;
+  }
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    ctx.addIssue({
+      code: "custom",
+      message: "contains invalid percent encoding"
+    });
+    return;
+  }
+  if (decoded.split("/").some((segment) => segment === "..")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "must not contain parent traversal"
+    });
+  }
+});
+function webSessionPathWithinPrefix(pathname, pathPrefix) {
+  if (pathPrefix.endsWith("/"))
+    return pathname.startsWith(pathPrefix);
+  return pathname === pathPrefix || pathname.startsWith(`${pathPrefix}/`);
+}
+var WEB_SESSION_CSRF_SELECTOR_PATTERN = /^(?=.)(?:[a-zA-Z][a-zA-Z0-9-]*)?(?:#[a-zA-Z_][\w-]*|\[[a-zA-Z_:][\w:.-]*(?:=(?:"[^"]*"|'[^']*'|[\w-]+))?\])*$/u;
+var WebSessionCsrfSelector = NonEmptyString.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)");
+var WebSessionGrantRequest = z5.strictObject({
+  origin: WebSessionOrigin,
+  pathPrefixes: z5.array(WebSessionPathPrefix).min(1),
+  csrf: z5.strictObject({
+    sourceUrl: WebSessionCsrfSourceUrl,
+    selector: WebSessionCsrfSelector,
+    attribute: NonEmptyString,
+    header: NonEmptyString,
+    /** Optional form field the host also injects for legacy download POSTs. */
+    bodyField: NonEmptyString.optional()
+  }).optional()
+});
+var KnowledgeSearchGrantRequest = z5.strictObject({
+  scope: z5.literal("own-schemes")
+});
+var KnownResourcesGrantRequest = z5.strictObject({
+  scope: z5.literal("own-modules")
+});
+var PluginAgentDefinitionPermissionRule = z5.strictObject({
+  effect: z5.enum(["allow", "deny", "ask"]),
+  /** Restrict to one tool name. */
+  tool: NonEmptyString.optional(),
+  /** Restrict to one classified capability key. */
+  ruleKey: NonEmptyString.optional(),
+  /** Restrict to one URI scheme / owning service id. */
+  scheme: NonEmptyString.optional(),
+  /** Restrict to matching resources (a path glob, or a URI-shaped policy address). */
+  resource: NonEmptyString.optional(),
+  /** Restrict the rule to one permission mode; omit to apply in all modes. */
+  mode: z5.enum(["default", "ask", "allow"]).optional()
+});
+var RETIRED_PERMISSION_ASK_KEYS = [
+  "network",
+  "process",
+  "filesystem",
+  "corpus",
+  "paths",
+  "workspace",
+  "sessions",
+  "automations",
+  "hindsight",
+  "agents",
+  "dynamicContext",
+  "appData",
+  "toolInterception",
+  "account",
+  "device",
+  "config",
+  "workflows",
+  "whiteboard"
+];
+var RETIRED_WEB_SESSION_ROW_KEYS = ["operations"];
+function stripRetiredPermissionAsks(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const remaining = { ...value };
+  for (const key of RETIRED_PERMISSION_ASK_KEYS)
+    delete remaining[key];
+  if (Array.isArray(remaining["webSession"])) {
+    remaining["webSession"] = remaining["webSession"].map((row) => {
+      if (typeof row !== "object" || row === null || Array.isArray(row)) {
+        return row;
+      }
+      const rest = { ...row };
+      for (const key of RETIRED_WEB_SESSION_ROW_KEYS)
+        delete rest[key];
+      return rest;
+    });
+  }
+  return remaining;
+}
+function retiredPermissionAsksIn(rawManifest) {
+  if (typeof rawManifest !== "object" || rawManifest === null)
+    return [];
+  const permissions = rawManifest["permissions"];
+  if (typeof permissions !== "object" || permissions === null)
+    return [];
+  const byTarget = permissions["byTarget"];
+  if (typeof byTarget !== "object" || byTarget === null)
+    return [];
+  const found = [];
+  for (const [target, set] of Object.entries(byTarget)) {
+    if (typeof set !== "object" || set === null || Array.isArray(set))
+      continue;
+    const record = set;
+    const keys = RETIRED_PERMISSION_ASK_KEYS.filter((key) => key in record);
+    const rows = record["webSession"];
+    const webSessionOperations = Array.isArray(rows) && rows.some((row) => typeof row === "object" && row !== null && RETIRED_WEB_SESSION_ROW_KEYS.some((key) => key in row));
+    if (keys.length === 0 && !webSessionOperations)
+      continue;
+    found.push({ target, keys, webSessionOperations });
+  }
+  return found;
+}
+var TargetPermissionWiring = z5.strictObject({
+  auth: z5.array(AuthGrantRequest).optional(),
+  storage: z5.array(StorageGrantRequest).optional(),
+  events: z5.array(EventGrantRequest).optional(),
+  endpoints: z5.array(EndpointGrantRequest).optional(),
+  webSession: z5.array(WebSessionGrantRequest).optional(),
+  knowledgeSearch: z5.array(KnowledgeSearchGrantRequest).optional(),
+  knownResources: z5.array(KnownResourcesGrantRequest).optional()
+}).superRefine((permissions, ctx) => {
+  const rows = permissions.webSession ?? [];
+  for (const [index, row] of rows.entries()) {
+    const sourceUrl = row.csrf?.sourceUrl;
+    if (sourceUrl === void 0)
+      continue;
+    const source = new URL(sourceUrl);
+    const covered = rows.some((candidate) => candidate.origin === source.origin && candidate.pathPrefixes.some((prefix) => webSessionPathWithinPrefix(source.pathname, prefix)));
+    if (!covered) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["webSession", index, "csrf", "sourceUrl"],
+        message: "must fall within a declared webSession row"
+      });
+    }
+  }
+});
+var TargetPermissionSet = z5.preprocess(stripRetiredPermissionAsks, TargetPermissionWiring);
+var PluginPermissionManifest = z5.strictObject({
+  byTarget: z5.strictObject({
+    "kay.agent": TargetPermissionSet.optional(),
+    "kay.app": TargetPermissionSet.optional(),
+    "kay.ui": TargetPermissionSet.optional()
+  })
+}).superRefine((manifest, ctx) => {
+  for (const grant of manifest.byTarget["kay.ui"]?.auth ?? []) {
+    if (grant.operations.includes("resolve")) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["byTarget", "kay.ui", "auth"],
+        message: "kay.ui targets cannot request raw auth material resolution"
+      });
+    }
+  }
+});
+var ResolvedAuthGrantRequest = AuthGrantRequestBase.extend({
+  service: GlobalContributionId,
+  schemes: z5.array(GlobalContributionId).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: z5.array(AuthAccountSelector).min(1)
+}).superRefine(validateAuthGrantRequest);
+var ResolvedEndpointGrantRequest = EndpointGrantRequest.extend({
+  endpoint: GlobalContributionId
+});
+var ResolvedTargetGrantSet = z5.strictObject({
+  auth: z5.array(ResolvedAuthGrantRequest).optional(),
+  storage: z5.array(StorageGrantRequest).optional(),
+  events: z5.array(EventGrantRequest).optional(),
+  endpoints: z5.array(ResolvedEndpointGrantRequest).optional(),
+  webSession: z5.array(WebSessionGrantRequest).optional(),
+  knowledgeSearch: z5.array(KnowledgeSearchGrantRequest).optional(),
+  knownResources: z5.array(KnownResourcesGrantRequest).optional()
+});
+var ResolvedPluginGrants = z5.strictObject({
+  byTarget: z5.strictObject({
+    "kay.agent": ResolvedTargetGrantSet.optional(),
+    "kay.app": ResolvedTargetGrantSet.optional(),
+    "kay.ui": ResolvedTargetGrantSet.optional()
+  })
+});
+
+// packages/plugin-protocol/dist/authority.js
+var WhiteboardCapabilityScope = z6.enum(["own-types", "all-types"]);
+var WhiteboardCapabilityOperation = z6.enum([
+  "discover",
+  "read",
+  "create",
+  "update",
+  "remove"
+]);
+var WhiteboardCapabilityClaimV1 = z6.strictObject({
+  target: z6.enum(["kay.agent", "kay.app"]),
+  slug: z6.enum([
+    "whiteboard.discover",
+    "whiteboard.read",
+    "whiteboard.create",
+    "whiteboard.update",
+    "whiteboard.remove"
+  ]),
+  envelope: z6.strictObject({ scope: WhiteboardCapabilityScope })
+}).superRefine((claim, ctx) => {
+  if (claim.target === "kay.app" && claim.slug !== "whiteboard.discover" && claim.slug !== "whiteboard.read") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["slug"],
+      message: "kay.app Whiteboard claims are read-only"
+    });
+  }
+});
+var PluginCapabilityClaimV1 = z6.discriminatedUnion("slug", [
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("sessions.run"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.agent"),
+    slug: z6.literal("network.connect"),
+    envelope: z6.strictObject({ connect: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.agent"),
+    slug: z6.literal("web-session.request"),
+    envelope: z6.strictObject({
+      origin: NonEmptyString,
+      pathPrefix: NonEmptyString
+    })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.agent"),
+    slug: z6.literal("web-session.download"),
+    envelope: z6.strictObject({
+      origin: NonEmptyString,
+      pathPrefix: NonEmptyString
+    })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.agent"),
+    slug: z6.literal("filesystem.read"),
+    envelope: z6.strictObject({ root: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.agent"),
+    slug: z6.literal("filesystem.write"),
+    envelope: z6.strictObject({ root: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.agent"),
+    slug: z6.literal("process.spawn"),
+    envelope: z6.strictObject({
+      command: NonEmptyString,
+      argvClass: NonEmptyString
+    })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("corpus.read"),
+    envelope: z6.strictObject({})
+  }),
+  z6.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: z6.literal("kay.app"),
+    slug: z6.literal("signals.read"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("workspace.command"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("sessions.create"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("sessions.update"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("models.complete"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    // Held to `kay.app`, the daemon-lifetime tier, even though the same wrapper 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
+    // more honest than a second, `kay.agent`-scoped sibling slug for the identical capability.
+    // `kay.agent`'s `api.withJev` authorizes against this SAME claim through the calling
+    // 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).
+    target: z6.literal("kay.app"),
+    slug: z6.literal("jev.use"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("automations.write"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("automations.run"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("workflows.define"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("session-events.subscribe"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("agents.run"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.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: z6.strictObject({ contributor: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("app-data.register"),
+    /** The declared `contributes.dataSources` localId. */
+    envelope: z6.strictObject({ source: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("account.assert"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("account.update"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.app"),
+    slug: z6.literal("agents.permissions"),
+    envelope: z6.strictObject({
+      /** The definition's local id — WHICH agent these rules are authored onto. */
+      agent: NonEmptyString,
+      /** `definition.permissions`, in declaration order (order is semantic; first match wins). */
+      rules: z6.array(PluginAgentDefinitionPermissionRule),
+      /** `definition.permissionsFallback`, in declaration order. */
+      fallback: z6.array(PluginAgentDefinitionPermissionRule)
+    })
+  }),
+  z6.strictObject({
+    target: z6.literal("kay.agent"),
+    slug: z6.literal("tool-interception.register"),
+    envelope: z6.strictObject({})
+  }),
+  z6.strictObject({
+    target: z6.literal("plugin"),
+    slug: z6.literal("config.declare-section"),
+    /** The settings-document section key, e.g. `models` or `plugins.com.acme.thing`. */
+    envelope: z6.strictObject({ section: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("plugin"),
+    slug: z6.literal("auth.own-service"),
+    /** The minted global service id this plugin would own, e.g. `google.account`. */
+    envelope: z6.strictObject({ service: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("plugin"),
+    slug: z6.literal("auth.shared-identity"),
+    /** The foreign global service id whose identity this plugin would resolve against. */
+    envelope: z6.strictObject({ service: NonEmptyString })
+  }),
+  z6.strictObject({
+    target: z6.literal("plugin"),
+    slug: z6.literal("cli.bind"),
+    /** The binary basename a resolved credential would be injected into. */
+    envelope: z6.strictObject({ binary: NonEmptyString })
+  }),
+  WhiteboardCapabilityClaimV1
+]);
+var PLUGIN_CAPABILITY_SLUGS = [
+  "sessions.run",
+  "network.connect",
+  "web-session.request",
+  "web-session.download",
+  "filesystem.read",
+  "filesystem.write",
+  "process.spawn",
+  "corpus.read",
+  "signals.read",
+  "workspace.command",
+  "sessions.create",
+  "sessions.update",
+  "models.complete",
+  "jev.use",
+  "automations.write",
+  "automations.run",
+  "workflows.define",
+  "session-events.subscribe",
+  "agents.run",
+  "dynamic-context.register",
+  "app-data.register",
+  "account.assert",
+  "account.update",
+  "agents.permissions",
+  "tool-interception.register",
+  "config.declare-section",
+  "auth.own-service",
+  "auth.shared-identity",
+  "cli.bind",
+  "whiteboard.discover",
+  "whiteboard.read",
+  "whiteboard.create",
+  "whiteboard.update",
+  "whiteboard.remove"
+];
+var PluginCapabilityRefusalLayer = z6.enum(["grant", "binding"]);
+var PluginCapabilityRefusalCode = z6.enum([
+  "not-granted",
+  "grant-read-failed",
+  "binding-missing",
+  "argv-outside-class"
+]);
+var PluginCapabilityRefusalV1 = z6.strictObject({
+  claim: PluginCapabilityClaimV1,
+  layer: PluginCapabilityRefusalLayer,
+  code: PluginCapabilityRefusalCode,
+  message: NonEmptyString,
+  artifactGenerationId: ArtifactGenerationId.optional()
+});
+var PluginCapabilityDecisionV1 = z6.discriminatedUnion("kind", [
+  z6.strictObject({
+    kind: z6.literal("allowed"),
+    claim: PluginCapabilityClaimV1,
+    artifactGenerationId: ArtifactGenerationId.optional()
+  }),
+  z6.strictObject({
+    kind: z6.literal("refused"),
+    refusal: PluginCapabilityRefusalV1
+  })
+]);
+function normalizeNetworkConnectHost(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0)
+    return void 0;
+  if (/[/\\?#@:[\]*%\s]/u.test(trimmed))
+    return void 0;
+  const withoutRootLabel = trimmed.endsWith(".") ? trimmed.slice(0, -1) : trimmed;
+  if (withoutRootLabel.length === 0)
+    return void 0;
+  let hostname;
+  try {
+    const url = new URL(`https://${withoutRootLabel}`);
+    if (url.port !== "" || url.username !== "" || url.password !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") {
+      return void 0;
+    }
+    hostname = url.hostname;
+  } catch {
+    return void 0;
+  }
+  if (hostname.length === 0 || hostname.split(".").some((label) => label.length === 0)) {
+    return void 0;
+  }
+  return hostname;
+}
+function canonicalAgentPermissionRules(rules) {
+  return JSON.stringify(rules.map((rule) => {
+    const canonical = {};
+    for (const field of AGENT_PERMISSION_RULE_FIELDS) {
+      const value = rule[field];
+      if (value !== void 0)
+        canonical[field] = value;
+    }
+    return canonical;
+  }));
+}
+var AGENT_PERMISSION_RULE_FIELDS = [
+  "effect",
+  "tool",
+  "ruleKey",
+  "scheme",
+  "resource",
+  "mode"
+];
+function sameClaim(a, b) {
+  if (a.slug !== b.slug || a.target !== b.target)
+    return false;
+  switch (a.slug) {
+    // Every empty-envelope claim: the slug IS the whole claim, and the slugs already matched.
+    case "sessions.run":
+    case "sessions.create":
+    case "sessions.update":
+    case "corpus.read":
+    case "signals.read":
+    case "workspace.command":
+    case "models.complete":
+    case "jev.use":
+    case "automations.write":
+    case "automations.run":
+    case "workflows.define":
+    case "session-events.subscribe":
+    case "agents.run":
+    case "account.assert":
+    case "account.update":
+    case "tool-interception.register":
+      return true;
+    case "network.connect":
+      return b.slug === "network.connect" && a.envelope.connect === b.envelope.connect;
+    case "web-session.request":
+    case "web-session.download":
+      return (b.slug === "web-session.request" || b.slug === "web-session.download") && a.envelope.origin === b.envelope.origin && a.envelope.pathPrefix === b.envelope.pathPrefix;
+    case "filesystem.read":
+    case "filesystem.write":
+      return (b.slug === "filesystem.read" || b.slug === "filesystem.write") && a.envelope.root === b.envelope.root;
+    case "process.spawn":
+      return b.slug === "process.spawn" && a.envelope.command === b.envelope.command && a.envelope.argvClass === b.envelope.argvClass;
+    case "dynamic-context.register":
+      return b.slug === "dynamic-context.register" && a.envelope.contributor === b.envelope.contributor;
+    case "app-data.register":
+      return b.slug === "app-data.register" && a.envelope.source === b.envelope.source;
+    case "agents.permissions":
+      return b.slug === "agents.permissions" && a.envelope.agent === b.envelope.agent && canonicalAgentPermissionRules(a.envelope.rules) === canonicalAgentPermissionRules(b.envelope.rules) && canonicalAgentPermissionRules(a.envelope.fallback) === canonicalAgentPermissionRules(b.envelope.fallback);
+    case "config.declare-section":
+      return b.slug === "config.declare-section" && a.envelope.section === b.envelope.section;
+    case "auth.own-service":
+    case "auth.shared-identity":
+      return (b.slug === "auth.own-service" || b.slug === "auth.shared-identity") && a.envelope.service === b.envelope.service;
+    case "cli.bind":
+      return b.slug === "cli.bind" && a.envelope.binary === b.envelope.binary;
+    case "whiteboard.discover":
+    case "whiteboard.read":
+    case "whiteboard.create":
+    case "whiteboard.update":
+    case "whiteboard.remove":
+      return b.slug === a.slug && "scope" in b.envelope && a.envelope.scope === b.envelope.scope;
+  }
+}
+function hasClaim(claims, claim) {
+  return claims.some((candidate) => sameClaim(candidate, claim));
+}
+function compareClaims(a, b) {
+  if (a.target !== b.target)
+    return a.target < b.target ? -1 : 1;
+  if (a.slug !== b.slug)
+    return a.slug < b.slug ? -1 : 1;
+  for (const [left, right] of envelopePairs(a, b)) {
+    if (left !== right)
+      return left < right ? -1 : 1;
+  }
+  return 0;
+}
+function envelopePairs(a, b) {
+  switch (a.slug) {
+    case "sessions.run":
+    case "sessions.create":
+    case "sessions.update":
+    case "corpus.read":
+    case "signals.read":
+    case "workspace.command":
+    case "models.complete":
+    case "jev.use":
+    case "automations.write":
+    case "automations.run":
+    case "workflows.define":
+    case "session-events.subscribe":
+    case "agents.run":
+    case "account.assert":
+    case "account.update":
+    case "tool-interception.register":
+      return [];
+    case "network.connect":
+      return b.slug === "network.connect" ? [[a.envelope.connect, b.envelope.connect]] : [];
+    case "web-session.request":
+    case "web-session.download":
+      return b.slug === "web-session.request" || b.slug === "web-session.download" ? [
+        [a.envelope.origin, b.envelope.origin],
+        [a.envelope.pathPrefix, b.envelope.pathPrefix]
+      ] : [];
+    case "filesystem.read":
+    case "filesystem.write":
+      return b.slug === "filesystem.read" || b.slug === "filesystem.write" ? [[a.envelope.root, b.envelope.root]] : [];
+    case "process.spawn":
+      return b.slug === "process.spawn" ? [
+        [a.envelope.command, b.envelope.command],
+        [a.envelope.argvClass, b.envelope.argvClass]
+      ] : [];
+    case "dynamic-context.register":
+      return b.slug === "dynamic-context.register" ? [[a.envelope.contributor, b.envelope.contributor]] : [];
+    case "app-data.register":
+      return b.slug === "app-data.register" ? [[a.envelope.source, b.envelope.source]] : [];
+    case "agents.permissions":
+      return b.slug === "agents.permissions" ? [
+        [a.envelope.agent, b.envelope.agent],
+        [
+          canonicalAgentPermissionRules(a.envelope.rules),
+          canonicalAgentPermissionRules(b.envelope.rules)
+        ],
+        [
+          canonicalAgentPermissionRules(a.envelope.fallback),
+          canonicalAgentPermissionRules(b.envelope.fallback)
+        ]
+      ] : [];
+    case "config.declare-section":
+      return b.slug === "config.declare-section" ? [[a.envelope.section, b.envelope.section]] : [];
+    case "auth.own-service":
+    case "auth.shared-identity":
+      return b.slug === "auth.own-service" || b.slug === "auth.shared-identity" ? [[a.envelope.service, b.envelope.service]] : [];
+    case "cli.bind":
+      return b.slug === "cli.bind" ? [[a.envelope.binary, b.envelope.binary]] : [];
+    case "whiteboard.discover":
+    case "whiteboard.read":
+    case "whiteboard.create":
+    case "whiteboard.update":
+    case "whiteboard.remove":
+      return b.slug === a.slug && "scope" in b.envelope ? [[a.envelope.scope, b.envelope.scope]] : [];
+  }
+}
+function whiteboardCapabilityClaim(operation, scope, target = "kay.agent") {
+  if (target === "kay.app" && operation !== "discover" && operation !== "read") {
+    throw new TypeError("kay.app Whiteboard claims are read-only");
+  }
+  return {
+    target,
+    slug: `whiteboard.${operation}`,
+    envelope: { scope }
+  };
+}
+function dedupeClaims(claims) {
+  const unique = [];
+  for (const claim of claims) {
+    if (!hasClaim(unique, claim))
+      unique.push(claim);
+  }
+  return unique;
+}
+
+// packages/plugin-protocol/dist/semver.js
+var SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+function parseSemver(value) {
+  const match = SEMVER_PATTERN.exec(value);
+  if (!match) {
+    return void 0;
+  }
+  const [, major, minor, patch, prerelease, build] = match;
+  return {
+    major: Number(major),
+    minor: Number(minor),
+    patch: Number(patch),
+    prerelease: prerelease === void 0 ? [] : prerelease.split(".").map((identifier) => /^\d+$/.test(identifier) ? Number(identifier) : identifier),
+    build
+  };
+}
+function compareSemver(a, b) {
+  const parsedA = parseSemver(a);
+  const parsedB = parseSemver(b);
+  if (!parsedA || !parsedB) {
+    return void 0;
+  }
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major - parsedB.major;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor - parsedB.minor;
+  }
+  if (parsedA.patch !== parsedB.patch) {
+    return parsedA.patch - parsedB.patch;
+  }
+  return comparePrerelease(parsedA.prerelease, parsedB.prerelease);
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 && b.length === 0) {
+    return 0;
+  }
+  if (a.length === 0) {
+    return 1;
+  }
+  if (b.length === 0) {
+    return -1;
+  }
+  const length = Math.max(a.length, b.length);
+  for (let i = 0; i < length; i++) {
+    if (i >= a.length) {
+      return -1;
+    }
+    if (i >= b.length) {
+      return 1;
+    }
+    const identifierA = a[i];
+    const identifierB = b[i];
+    const numericA = typeof identifierA === "number";
+    const numericB = typeof identifierB === "number";
+    if (numericA && numericB) {
+      if (identifierA !== identifierB) {
+        return identifierA - identifierB;
+      }
+      continue;
+    }
+    if (numericA !== numericB) {
+      return numericA ? -1 : 1;
+    }
+    const stringA = identifierA;
+    const stringB = identifierB;
+    if (stringA !== stringB) {
+      return stringA < stringB ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+// packages/plugin-protocol/dist/semver-range.js
+var COMPARATOR_HEAD = /^\s*(\^|~|>=|<=|>|<|=)?\s*([0-9A-Za-z.+-]+)\s*/;
+function parseComparators(alternative) {
+  const comparators = [];
+  let rest = alternative;
+  while (rest.trim().length > 0) {
+    const match = COMPARATOR_HEAD.exec(rest);
+    const rawVersion = match?.[2];
+    if (match === null || rawVersion === void 0)
+      return void 0;
+    const parsed = parseSemver(rawVersion);
+    if (parsed === void 0)
+      return void 0;
+    comparators.push({
+      operator: match[1] ?? "=",
+      version: rawVersion,
+      parsed
+    });
+    rest = rest.slice(match[0].length);
+  }
+  return comparators.length === 0 ? void 0 : comparators;
+}
+function rangeBounds(comparator) {
+  const { major, minor, patch } = comparator.parsed;
+  if (comparator.operator === "~") {
+    return {
+      lower: comparator.version,
+      upperExclusive: `${String(major)}.${String(minor + 1)}.0-0`
+    };
+  }
+  if (major !== 0) {
+    return {
+      lower: comparator.version,
+      upperExclusive: `${String(major + 1)}.0.0-0`
+    };
+  }
+  if (minor !== 0) {
+    return {
+      lower: comparator.version,
+      upperExclusive: `0.${String(minor + 1)}.0-0`
+    };
+  }
+  return {
+    lower: comparator.version,
+    upperExclusive: `0.0.${String(patch + 1)}-0`
+  };
+}
+function satisfiesComparator(version, comparator) {
+  const cmp = compareSemver(version, comparator.version);
+  if (cmp === void 0)
+    return false;
+  switch (comparator.operator) {
+    case "=":
+      return cmp === 0;
+    case ">":
+      return cmp > 0;
+    case ">=":
+      return cmp >= 0;
+    case "<":
+      return cmp < 0;
+    case "<=":
+      return cmp <= 0;
+    case "^":
+    case "~": {
+      const { lower, upperExclusive } = rangeBounds(comparator);
+      const atLeast = compareSemver(version, lower);
+      const below = compareSemver(version, upperExclusive);
+      return atLeast !== void 0 && below !== void 0 && atLeast >= 0 && below < 0;
+    }
+  }
+}
+function prereleaseAdmitted(parsedVersion, comparators) {
+  if (parsedVersion.prerelease.length === 0)
+    return true;
+  return comparators.some((comparator) => comparator.parsed.prerelease.length > 0 && comparator.parsed.major === parsedVersion.major && comparator.parsed.minor === parsedVersion.minor && comparator.parsed.patch === parsedVersion.patch);
+}
+function satisfiesSemverRange(version, range) {
+  const parsedVersion = parseSemver(version);
+  if (parsedVersion === void 0)
+    return void 0;
+  const alternatives = range.split("||").map((part) => part.trim());
+  if (alternatives.some((alternative) => alternative.length === 0)) {
+    return void 0;
+  }
+  let satisfied = false;
+  for (const alternative of alternatives) {
+    const comparators = parseComparators(alternative);
+    if (comparators === void 0)
+      return void 0;
+    if (prereleaseAdmitted(parsedVersion, comparators) && comparators.every((comparator) => satisfiesComparator(version, comparator))) {
+      satisfied = true;
+    }
+  }
+  return satisfied;
+}
+function isSupportedSemverRange(range) {
+  return satisfiesSemverRange("0.0.0", range) !== void 0;
+}
+
+// packages/plugin-protocol/dist/compatibility.js
+function isCompatible(report) {
+  return report.refusal === void 0;
+}
+function checkKayPluginHostCompatibility(compatibility, host) {
+  const advisories = [];
+  const declaredProtocols = compatibility?.supportedProtocols;
+  if (declaredProtocols !== void 0) {
+    if (!declaredProtocols.includes(host.protocolVersion)) {
+      const declared = declaredProtocols.length === 0 ? "no protocol versions" : declaredProtocols.join(", ");
+      return {
+        refusal: {
+          code: "unsupported-protocol",
+          message: `declares support for ${declared} but this Kay speaks ${host.protocolVersion}`
+        },
+        advisories
+      };
+    }
+  }
+  const minKayVersion = compatibility?.minKayVersion;
+  if (minKayVersion !== void 0) {
+    if (parseSemver(minKayVersion) === void 0) {
+      advisories.push({
+        code: "min-kay-version-unparseable",
+        message: `declares a minimum Kay version of "${minKayVersion}", which is not a version Kay can compare`
+      });
+    } else {
+      const order = compareSemver(host.appVersion, minKayVersion);
+      if (order === void 0) {
+        advisories.push({
+          code: "min-kay-version-unparseable",
+          message: `asks for Kay ${minKayVersion} or newer, which cannot be checked against this Kay's version "${host.appVersion}"`
+        });
+      } else if (order < 0) {
+        advisories.push({
+          code: "min-kay-version-unmet",
+          message: `asks for Kay ${minKayVersion} or newer; this is ${host.appVersion}`
+        });
+      }
+    }
+  }
+  const range = compatibility?.sdk;
+  if (range === void 0) {
+    if (host.bundled !== true) {
+      advisories.push({
+        code: "sdk-range-undeclared",
+        message: `declares no compatibility.sdk range; this Kay ships plugin SDK ${host.sdkVersion}`
+      });
+    }
+    return { refusal: void 0, advisories };
+  }
+  if (parseSemver(host.sdkVersion) === void 0) {
+    return {
+      refusal: {
+        code: "host-sdk-version-invalid",
+        message: `cannot be checked: this Kay reports plugin SDK "${host.sdkVersion}", which is not valid semver`
+      },
+      advisories
+    };
+  }
+  if (!isSupportedSemverRange(range)) {
+    return {
+      refusal: {
+        code: "sdk-range-unsupported",
+        message: `declares an SDK range of "${range}", which Kay cannot interpret (use a caret, tilde, or comparator range such as ^${host.sdkVersion})`
+      },
+      advisories
+    };
+  }
+  if (satisfiesSemverRange(host.sdkVersion, range) !== true) {
+    return {
+      refusal: {
+        code: "sdk-range-unsatisfied",
+        message: `needs plugin SDK ${range}, this Kay ships ${host.sdkVersion}`
+      },
+      advisories
+    };
+  }
+  return { refusal: void 0, advisories };
+}
+
+// packages/plugin-protocol/dist/contributions.js
+import { z as z7 } from "zod";
+var OptionalDisplayName = NonEmptyString.optional();
+var UriFilesystemBacking = z7.discriminatedUnion("root", [
+  z7.strictObject({ root: z7.literal("dataDir") }),
+  z7.strictObject({
+    root: z7.literal("filesystem"),
+    selector: NonEmptyString
+  })
+]);
+var ToolContribution = z7.strictObject({
+  localId: LocalContributionId,
+  toolName: PluginToolName,
+  displayName: OptionalDisplayName,
+  description: NonEmptyString.optional()
+});
+var ConverterContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  description: NonEmptyString.optional(),
+  /** MIME types this converter claims — contract data for introspection and
+   *  collision checks; runtime match behavior stays the converter's `matches()`. */
+  mimeTypes: z7.array(MimeTypeString).min(1),
+  /** Extension fallbacks (no dot) used when a probe has no usable MIME type. */
+  extensions: z7.array(FileExtensionToken).min(1).optional()
+});
+var UriMutationVerbs = z7.strictObject({
+  writable: z7.boolean().optional(),
+  editable: z7.boolean().optional(),
+  deletable: z7.boolean().optional()
+});
+var UriModuleContributionBase = z7.strictObject({
+  localId: LocalContributionId,
+  schemes: z7.array(UriScheme).min(1),
+  displayName: OptionalDisplayName,
+  // The plugin only requests a projection. The daemon binds the effective root
+  // and retains access control at finalization.
+  filesystemBacking: UriFilesystemBacking.optional(),
+  /** Host-native mutation verbs requested for an external filesystem projection. */
+  verbs: UriMutationVerbs.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
+  // `consumesAuthServices` on the resolved contract).
+  authService: AuthServiceReference.optional(),
+  // Opt this module's traffic into the daemon's known-resources ledger: the
+  // HOST records the canonical URIs (plus title/summary/mime facts) that flow
+  // through the module's successful read/list/search resolutions, filtered by
+  // the module's own `observes` predicate, and marks rows gone on a principled
+  // not-found. Recording is host behavior consented to here, not a capability
+  // handed to the plugin — reading the rows back is the separate
+  // `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: z7.literal(true).optional()
+});
+var UriModuleContribution = UriModuleContributionBase.superRefine((module, ctx) => {
+  if (module.verbs !== void 0 && module.filesystemBacking?.root !== "filesystem") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["verbs"],
+      message: "URI mutation verbs require external filesystem backing (root: 'filesystem')."
+    });
+  }
+});
+var AppUriModuleContribution = UriModuleContributionBase.omit({
+  authService: true,
+  filesystemBacking: true,
+  verbs: true,
+  knownResources: true
+});
+var AppDataSourceContribution = z7.strictObject({
+  localId: LocalContributionId,
+  scope: z7.enum(["runtime", "account", "session"]),
+  snapshot: z7.strictObject({
+    version: z7.number().int().positive(),
+    schema: JsonSchema
+  }),
+  change: z7.strictObject({
+    version: z7.number().int().positive(),
+    schema: JsonSchema,
+    /** Review-only claim; source schemas and behavioral tests enforce it because the daemon treats changes as opaque. */
+    semantics: z7.discriminatedUnion("kind", [
+      z7.strictObject({ kind: z7.literal("incremental") }),
+      z7.strictObject({
+        kind: z7.literal("snapshot-replacement"),
+        maxEncodedBytes: z7.number().int().positive(),
+        rationale: z7.string().trim().min(1).max(1024)
+      })
+    ]).optional()
+  }),
+  read: AppDataSourceRead.optional()
+}).superRefine((source, ctx) => {
+  if (source.read !== void 0 && source.scope !== "session") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["read"],
+      message: "App-data read operations require session scope."
+    });
+  }
+});
+var WhiteboardTypeStorage = z7.discriminatedUnion("kind", [
+  z7.strictObject({ kind: z7.literal("json") }),
+  z7.strictObject({ kind: z7.literal("payload") }),
+  z7.strictObject({
+    kind: z7.literal("markdown"),
+    bodyField: NonEmptyString
+  })
+]);
+var WhiteboardTypeContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: NonEmptyString,
+  schemaVersion: z7.number().int().positive(),
+  storage: WhiteboardTypeStorage,
+  valueSchema: JsonSchema,
+  presentation: z7.strictObject({
+    app: LocalContributionId
+  }).optional()
+});
+var AppDataMaterializerContribution = z7.strictObject({
+  source: LocalContributionId
+});
+var ArtifactUriModuleContribution = z7.strictObject({
+  localId: LocalContributionId,
+  /** The single `scheme://` this module owns; also the on-disk artifact kind. */
+  scheme: UriScheme,
+  /**
+   * Opt in to exact-text `edit` support (in addition to read/write). Default false — a
+   * write-only artifact scheme (agent replaces the whole document each time). Mirrors
+   * `CreateArtifactUriModuleOptions.editable`.
+   *
+   * No `displayName`: unlike a plugin-implemented `uriModule` (whose `activate()` code writes its
+   * own description/agentHint), an artifact-backed module ships no plugin code, and the host
+   * 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: z7.boolean().optional(),
+  /** Opt in to `list` over the kind's stored names. Default false. Mirrors
+   * `CreateArtifactUriModuleOptions.listable`. */
+  listable: z7.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: z7.boolean().optional(),
+  /**
+   * Opt in to the `{ content, mode: "append" }` write envelope, which extends
+   * stored text instead of replacing it (concurrent-appender-safe: the host
+   * serializes appends per file). Default false. Payloads without a `mode` key
+   * keep their verbatim round-trip. Mirrors
+   * `CreateArtifactUriModuleOptions.appendable`.
+   */
+  appendable: z7.boolean().optional(),
+  /**
+   * Which sessions share one storage namespace. Default `"session"` — the existing
+   * per-session behavior (each session gets its own kind directory; other sessions'
+   * entries are readable via the qualified `<scheme>://<sessionId>/<name>` form).
+   * `"family"` keys storage by the session FAMILY's root instead — the session and every
+   * subagent in its spawn tree mount one namespace — and makes addressing session-local
+   * (the qualified cross-session form is refused on every verb). The plugin only NAMES
+   * the scope; the host derives the family root from provenance it already holds, so
+   * family identity never crosses the SDK boundary.
+   */
+  storageScope: z7.enum(["session", "family"]).optional()
+});
+var CliBindingContribution = z7.strictObject({
+  localId: LocalContributionId,
+  binary: CliBinaryName,
+  aliases: z7.array(CliBinaryName).optional(),
+  /** Where the binary comes from. Omitted ⇒ `"vendored"` (decision 007). */
+  provider: z7.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
+  // `consumesAuthServices` on the resolved contract) — same discriminator as
+  // `UriModuleContribution.authService`.
+  authService: AuthServiceReference,
+  /**
+   * Env var the resolved credential is injected under. Required in practice for a
+   * `vendored` binding (a binding that injects nothing has no reason to name one);
+   * MUST be absent for a `path` binding, which can never receive a token.
+   */
+  authEnvVar: CliAuthEnvVarName.optional(),
+  readOnly: z7.array(NonEmptyString),
+  write: z7.array(NonEmptyString)
+});
+var GitHostContribution = z7.strictObject({
+  host: GitHostName,
+  authService: LocalContributionId,
+  basicAuthUser: GitBasicAuthUser
+});
+var ResourceContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  description: NonEmptyString.optional()
+});
+var SkillContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  /** Model-visible one-liner: when to reach for this skill. */
+  description: NonEmptyString,
+  /** The SKILL.md-style file inside the package carrying the full instructions. */
+  path: PackageAssetPath
+});
+var PluginSkillSourceDeclaration = z7.discriminatedUnion("channel", [
+  z7.strictObject({
+    channel: z7.literal("installer"),
+    localId: LocalContributionId,
+    displayName: OptionalDisplayName,
+    /** The package-runner executable, e.g. `npx` — checked against the daemon's allowlist. */
+    command: NonEmptyString,
+    /** Its argv, e.g. `["skills", "add", "clerk/skills"]`. */
+    args: z7.array(NonEmptyString)
+  }),
+  z7.strictObject({
+    channel: z7.literal("git-clone"),
+    localId: LocalContributionId,
+    displayName: OptionalDisplayName,
+    /** The repository locator — canonicalized and hygiene-checked by the daemon. */
+    locator: NonEmptyString,
+    /** Optional branch/tag to clone; omitted ⇒ the remote's default branch. */
+    ref: NonEmptyString.optional(),
+    /** Optional subdirectory within the repo to discover skills under. */
+    subdir: NonEmptyString.optional()
+  })
+]);
+var SearchProviderContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  schemes: z7.array(UriScheme).optional()
+});
+var EntityResolverContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  /** The `kay.agent` URI module (this manifest's own `contributes.uriModules[].localId`) whose
+   *  `search` verb answers `@` queries for `entityTypes`. */
+  uriModule: LocalContributionId,
+  /** `person` | `channel` | `repo` | `pull-request` | ... -- drives avatar-first vs glyph-first row
+   *  anatomy (N10-R2) and lets the renderer request a narrower `entityTypes` filter. */
+  entityTypes: z7.array(NonEmptyString).min(1),
+  /** The URI namespace/route `search()` is called against, e.g. `slack://directory` or
+   *  `github://search/repositories` -- the resolver's fixed search scope; the live user query is
+   *  the `search()` call's `query` param, never concatenated into this string. */
+  uriHint: NonEmptyString
+});
+var AgentRenderContribution = z7.strictObject({
+  localId: LocalContributionId,
+  resultKinds: z7.array(NonEmptyString).min(1)
+});
+var EndpointContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  requestSchema: JsonSchema.optional(),
+  responseSchema: JsonSchema.optional()
+});
+var MCP_SERVER_LOCAL_HTTP_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
+var McpServerUrl = z7.string().trim().min(1).refine((value) => {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol === "https:")
+    return true;
+  return parsed.protocol === "http:" && MCP_SERVER_LOCAL_HTTP_HOSTNAMES.has(parsed.hostname);
+}, {
+  message: "mcp server url must be https://, or http:// only for localhost/127.0.0.1 test servers"
+});
+var McpServerAuthMode = z7.enum(["oauth", "none"]);
+var McpServerContribution = z7.strictObject({
+  url: McpServerUrl,
+  auth: McpServerAuthMode.optional(),
+  authService: LocalContributionId.optional()
+}).superRefine((server, ctx) => {
+  if (server.auth !== "none" && server.authService === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["authService"],
+      message: "oauth mcp servers must name an authService"
+    });
+  }
+});
+var McpServerContributions = z7.record(LocalContributionId, McpServerContribution);
+var AppEventSubscription = z7.strictObject({
+  localId: LocalContributionId,
+  event: NonEmptyString
+});
+var ContextContributorContribution = z7.strictObject({
+  localId: LocalContributionId.max(64),
+  displayName: OptionalDisplayName,
+  description: NonEmptyString.optional()
+});
+var PluginEventDefinitionContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  description: NonEmptyString.optional(),
+  version: z7.number().int().positive().default(1),
+  payloadSchema: JsonSchema
+});
+var PluginNotificationRuleContribution = z7.strictObject({
+  localId: LocalContributionId,
+  /** The same-plugin `eventDefinitions` local id this rule matches. */
+  event: LocalContributionId,
+  where: z7.array(JsonObject).optional(),
+  rule: JsonObject
+});
+var PLUGIN_NOTIFICATION_RULE_HOST_KEYS = [
+  "id",
+  "match",
+  "sender"
+];
+var UiEventSubscriptionContribution = z7.strictObject({
+  localId: LocalContributionId,
+  event: NonEmptyString
+});
+var DeviceDelegationContribution = z7.strictObject({
+  localId: LocalContributionId,
+  device: z7.enum(["microphone"]),
+  delegateAs: z7.enum(["clip", "stream", "status"])
+});
+var CorpusContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  access: z7.enum(["read"]).default("read")
+});
+var UiCommandContribution = z7.strictObject({
+  localId: LocalContributionId,
+  title: NonEmptyString,
+  icon: NonEmptyString.optional(),
+  placement: NonEmptyString.optional()
+});
+var UiSlotContribution = z7.strictObject({
+  localId: LocalContributionId,
+  slot: NonEmptyString,
+  title: NonEmptyString.optional()
+});
+var SettingsPanelContribution = z7.strictObject({
+  localId: LocalContributionId,
+  title: NonEmptyString,
+  configSection: NonEmptyString.optional()
+});
+var ResultRendererContribution = z7.strictObject({
+  localId: LocalContributionId,
+  resultKinds: z7.array(NonEmptyString).min(1)
+});
+var ReferenceOpenBehavior = z7.discriminatedUnion("kind", [
+  z7.strictObject({ kind: z7.literal("working-document") }),
+  z7.strictObject({ kind: z7.literal("browser-pane") })
+]);
+var ReferencePresentationVariant = z7.strictObject({
+  resourceKind: NonEmptyString,
+  presentationPluginId: PluginId.optional()
+});
+var ReferencePresentationVariants = z7.record(MimeTypeString, ReferencePresentationVariant);
+var InlineSvg = z7.string().max(64 * 1024).refine((value) => /^\s*(?:<\?xml[^>]*>\s*)?(?:<!--[\s\S]*?-->\s*)*(?:<!DOCTYPE[^>]*>\s*)?<svg[\s>]/iu.test(value), { message: "brandIcon must be inline SVG markup." });
+var ReferencePresentationUrlClaim = z7.strictObject({
+  kind: z7.literal("urlPattern"),
+  pattern: z7.strictObject({
+    protocol: z7.enum(["http", "https"]),
+    hostname: NonEmptyString,
+    pathname: z7.string().optional(),
+    search: z7.string().optional()
+  }),
+  brandIcon: InlineSvg.optional()
+});
+var ReferencePresentationContribution = z7.strictObject({
+  localId: LocalContributionId,
+  uriModule: LocalContributionId,
+  resourceKind: NonEmptyString,
+  open: ReferenceOpenBehavior,
+  /** MIME-specific resource kinds; absent keys use the base presentation. */
+  variants: ReferencePresentationVariants.optional(),
+  /** Lexical public URL claims used only for host-rendered browser presentations. */
+  claims: z7.array(ReferencePresentationUrlClaim).optional()
+}).superRefine((value, ctx) => {
+  if (value.claims !== void 0 && value.claims.length > 0 && value.open.kind !== "browser-pane") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["claims"],
+      message: "URL claims require browser-pane opening."
+    });
+  }
+});
+var RichViewContribution = z7.strictObject({
+  localId: LocalContributionId,
+  title: NonEmptyString,
+  route: NonEmptyString.optional()
+});
+var KayUiAppHostCapability = z7.enum([
+  "navigation.open-session",
+  "cost.read",
+  // Server-rated organization billing, distinct from local/provider cost.
+  "billing.read",
+  // Context, Skills, and Memory analytics reads (full snapshots via the capability broker).
+  "context.read",
+  "skills.read",
+  "memory.read",
+  // The "session trees" lens: root-session USD/token roll-ups from the
+  // typed usage-query surface (telemetry-unification RFC Phase 3, PR 3
+  // contract `docs/telemetry-lane-pr3-contracts.md`, amendment A7). Follows
+  // the `cost.read`/`context.read`/`skills.read`/`memory.read` convention —
+  // names the data (`usage`), not the tab that happens to render it.
+  "usage.read",
+  // The self-improvement lens: reads the telemetry lane's self-improvement rollup
+  // (memory/skill/notebook activity). Follows the same "names the data" convention.
+  "self-improvement.read",
+  "automations.read",
+  "automations.run",
+  // Grants exactly `panes.place` (see `WORKSPACE_VERB_TIERS`/`KayWorkspaceCommand` in
+  // `@kay/agent-runtime-protocol`) through the `kay.ui` capability broker's `workspace.place`.
+  "workspace.place-pane",
+  // Grants presentation into the native header of the pane hosting this app instance.
+  "workspace.pane-header",
+  // Grants the non-destructive arrangement verbs: tabs.rename/select/move/reopen, panes.focus/maximize/
+  // restore/split, and both shell toggles — through the broker's `workspace.arrange`. Deliberately
+  // EXCLUDES the two `destructive`-tier verbs (`tabs.close`, `panes.close`); a `kay.ui` app can
+  // rearrange the workspace but never remove something the user would have to notice going missing.
+  "workspace.arrange"
+]);
+var UiAppCapabilities = z7.strictObject({
+  endpoints: z7.array(LocalContributionId).optional(),
+  host: z7.array(KayUiAppHostCapability).optional()
+}).superRefine((capabilities, ctx) => {
+  for (const field of ["endpoints", "host"]) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, value] of (capabilities[field] ?? []).entries()) {
+      if (seen.has(value)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [field, index],
+          message: `duplicate ui app ${field} capability ${value}`
+        });
+      }
+      seen.add(value);
+    }
+  }
+});
+var UiAppContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: NonEmptyString,
+  description: NonEmptyString.optional(),
+  icon: PackageAssetPath.optional(),
+  runtime: z7.literal("kay.react-app.v1"),
+  sdk: z7.strictObject({ range: NonEmptyString }),
+  entrypoint: TargetEntrypoint,
+  styles: z7.array(PackageAssetPath).optional(),
+  assets: z7.array(PackageAssetPath).optional(),
+  capabilities: UiAppCapabilities.optional()
+});
+var ThemeContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: NonEmptyString,
+  appearance: z7.enum(["light", "dark"]),
+  tokens: PackageAssetPath
+});
+var CommandHandler = z7.discriminatedUnion("kind", [
+  z7.strictObject({ kind: z7.literal("skill"), skill: LocalContributionId }),
+  z7.strictObject({
+    kind: z7.literal("tool"),
+    tool: PluginToolName,
+    /** Positional mapping from tokenized `argsText` onto the tool's own input fields — see this
+     *  union's doc for the exact tokenize/map/last-field-absorbs rule. */
+    argumentFields: z7.array(NonEmptyString)
+  }),
+  z7.strictObject({
+    kind: z7.literal("endpoint"),
+    endpoint: LocalContributionId
+  })
+]);
+var CommandContribution = z7.strictObject({
+  localId: LocalContributionId,
+  displayName: OptionalDisplayName,
+  description: NonEmptyString,
+  aliases: z7.array(LocalContributionId).optional(),
+  argumentHint: NonEmptyString.optional(),
+  handler: CommandHandler
+});
+var PluginContributionKind = z7.enum([
+  "tool",
+  "converter",
+  "uriModule",
+  "artifactUriModule",
+  "cliBinding",
+  "resource",
+  "skill",
+  "searchProvider",
+  "entityResolver",
+  "agentRenderer",
+  "endpoint",
+  "command",
+  "eventDefinition",
+  "eventSubscription",
+  "appDataSource",
+  "whiteboardType",
+  "contextContributor",
+  "transcriptionProvider",
+  "deviceDelegation",
+  "corpusConsumer",
+  "mcpServer",
+  "uiCommand",
+  "uiSlot",
+  "settingsPanel",
+  "resultRenderer",
+  "referencePresentation",
+  "view",
+  "app",
+  "theme",
+  "authService",
+  "storage",
+  "configSection"
+]);
+
+// packages/plugin-protocol/dist/ids.js
+function resolvePluginNamespace(pluginId, namespace) {
+  return namespace ?? pluginId;
+}
+function resolveGlobalContributionId(namespace, localId) {
+  return `${namespace}.${localId}`;
+}
+function resolvePluginEventType(namespace, localId) {
+  return resolveGlobalContributionId(namespace, localId);
+}
+function isQualifiedAuthServiceRef(ref) {
+  return ref.includes(".");
+}
+function isQualifiedAuthSchemeRef(ref) {
+  return ref.includes(".");
+}
+function resolveAdapterId(globalId, declaredAdapterId) {
+  return declaredAdapterId ?? globalId;
+}
+
+// packages/plugin-protocol/dist/manifest.js
+import { z as z8 } from "zod";
+
+// packages/plugin-protocol/dist/synthetic-contributions.js
+function resolveConfigSectionContributionLocalId(section) {
+  return `config-${toLocalContributionIdFragment(section)}`;
+}
+function resolveStorageContributionLocalId(kind) {
+  return kind === "sqlite" ? "storage-sqlite" : "storage-data-dir";
+}
+function toLocalContributionIdFragment(value) {
+  const fragment = value.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return /^[a-z]/.test(fragment) ? fragment : "section";
+}
+
+// packages/plugin-protocol/dist/manifest.js
+var KAY_UI_NATIVE_EVENT_SUBSCRIPTIONS = [
+  "native:renderer.session.projection.changed",
+  "native:renderer.contributions.changed"
+];
+var KAY_UI_NATIVE_EVENT_ALLOWLIST = new Set(KAY_UI_NATIVE_EVENT_SUBSCRIPTIONS);
+var KayAgentTargetManifest = z8.strictObject({
+  entrypoint: TargetEntrypoint,
+  contributes: z8.strictObject({
+    tools: z8.array(ToolContribution).optional(),
+    converters: z8.array(ConverterContribution).optional(),
+    uriModules: z8.array(UriModuleContribution).optional(),
+    // Host-composed artifact-backed schemes (see `ArtifactUriModuleContribution`): the plugin
+    // declares scheme + editability; the daemon binds each to the kernel's artifact lifecycle
+    // per session. Separate from `uriModules` (plugin-implemented backends) precisely because
+    // the plugin registers NOTHING for these at activation.
+    artifactUriModules: z8.array(ArtifactUriModuleContribution).optional(),
+    cliBindings: z8.array(CliBindingContribution).optional(),
+    // Which git hosts this plugin's credential serves (see `GitHostContribution`): a
+    // declaration, so a plugin for any git backend gets credentialed clones without
+    // the daemon learning its name. Sibling of `cliBindings` because both answer the
+    // same question — which of this plugin's auth services a host-side consumer
+    // resolves — for two different transports.
+    gitHosts: z8.array(GitHostContribution).optional(),
+    resources: z8.array(ResourceContribution).optional(),
+    skills: z8.array(SkillContribution).optional(),
+    searchProviders: z8.array(SearchProviderContribution).optional(),
+    entityResolvers: z8.array(EntityResolverContribution).optional(),
+    renderers: z8.array(AgentRenderContribution).optional(),
+    // Handler restricted to skill | tool by the manifest-level refinement below (see
+    // `CommandContribution`'s doc for why the restriction is not expressed in the type, and
+    // `CommandHandler`'s doc for why there is no promptTemplate variant to declare here).
+    commands: z8.array(CommandContribution).optional()
+  }).optional(),
+  /**
+   * The plugin's primer skill — the `localId` of one of its own declared
+   * `contributes.skills[]` entries, designating that skill as the plugin's agent-facing front
+   * door (the doc a session is told to read before first using the plugin). A pointer at an
+   * existing contribution, not a contribution kind of its own; the reference is validated by the
+   * manifest's superRefine. Plugins that declare no primer get a synthesized fallback at
+   * composition (host-side), so the field stays optional.
+   */
+  primer: LocalContributionId.optional(),
+  /**
+   * The plugin's prompt doc — a package-relative path (by convention `./prompt.md`) to
+   * a free-form Markdown section the host renders INTO the agent's system prompt, under
+   * `# Your workbench`, for every session the plugin is enabled in. Declaring it is the opt-in:
+   * most plugins should NOT be resident (their `<installed_plugins>` line plus primer is the
+   * default advertisement); a plugin that is part of how the agent works every turn (memory,
+   * scratchpad, variables) earns a section here. The body is prose the agent reads before any
+   * routing, so it should say what the capability is and when to reach for it, not how to
+   * operate it — that is the primer's job, and the host appends the primer route after the body.
+   *
+   * Policy the HOST applies (never trust this field alone): a body over 500 words is dropped,
+   * and a directory/repository-origin plugin's declaration is ignored — a third-party manifest
+   * does not buy prompt residency (mirrors the skill-exposure clamp).
+   */
+  prompt: PackageAssetPath.optional(),
+  /**
+   * External origins of skills this plugin claims as its own (see
+   * {@link PluginSkillSourceDeclaration}). Acquired by the daemon at boot and landed under the
+   * plugin's own skill-source slug, so a vendor's officially-published skills behave exactly
+   * like the ones the plugin ships in-tree.
+   *
+   * A sibling of `contributes`, not a member of it: these skills' names are discovered by
+   * acquisition, not declared here, so there is nothing for the resolved contract to mint a
+   * `globalId` for at parse time.
+   */
+  skillSources: z8.array(PluginSkillSourceDeclaration).optional()
+});
+var KayAppTargetManifest = z8.strictObject({
+  // Optional, like `kay.ui`'s: a target may carry only declarative `contributes` (e.g. a plugin
+  // that ships nothing but `mcpServers`) with no app-lifetime module for the host to load.
+  entrypoint: TargetEntrypoint.optional(),
+  contributes: z8.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: z8.array(ToolContribution).optional(),
+    endpoints: z8.array(EndpointContribution).optional(),
+    uriModules: z8.array(AppUriModuleContribution).optional(),
+    dataSources: z8.array(AppDataSourceContribution).optional(),
+    whiteboardTypes: z8.array(WhiteboardTypeContribution).optional(),
+    eventDefinitions: z8.array(PluginEventDefinitionContribution).optional(),
+    // Default notification rules over this plugin's own `eventDefinitions`; seeded by the host
+    // (see `PluginNotificationRuleContribution`).
+    notificationRules: z8.array(PluginNotificationRuleContribution).optional(),
+    eventSubscriptions: z8.array(AppEventSubscription).optional(),
+    deviceDelegations: z8.array(DeviceDelegationContribution).optional(),
+    corpusConsumers: z8.array(CorpusContribution).optional(),
+    contextContributors: z8.array(ContextContributorContribution).optional(),
+    // Vendored MCP servers this plugin ships (see `McpServerContributions`). Bundled-plugin-only
+    // in practice; this package cannot see plugin origin, so that ceiling is enforced at
+    // composition, not here (see ARCHITECTURE.md "Validation Law").
+    mcpServers: McpServerContributions.optional(),
+    // Handler restricted to endpoint-only by the manifest-level refinement below.
+    commands: z8.array(CommandContribution).optional()
+  }).optional()
+});
+var KayUiTargetManifest = z8.strictObject({
+  entrypoint: TargetEntrypoint.optional(),
+  contributes: z8.strictObject({
+    commands: z8.array(UiCommandContribution).optional(),
+    slots: z8.array(UiSlotContribution).optional(),
+    settingsPanels: z8.array(SettingsPanelContribution).optional(),
+    resultRenderers: z8.array(ResultRendererContribution).optional(),
+    referencePresentations: z8.array(ReferencePresentationContribution).optional(),
+    views: z8.array(RichViewContribution).optional(),
+    apps: z8.array(UiAppContribution).optional(),
+    themes: z8.array(ThemeContribution).optional(),
+    eventSubscriptions: z8.array(UiEventSubscriptionContribution).optional(),
+    dataMaterializers: z8.array(AppDataMaterializerContribution).optional()
+  }).optional()
+});
+var PluginConfigScope = z8.enum(["global", "project", "agent"]);
+var PluginConfigSectionManifest = z8.strictObject({
+  section: NonEmptyString.optional(),
+  schema: JsonSchema,
+  /**
+   * DECLARED-DEAD: validated and carried, but no runtime maps it — plugin
+   * config values come from the plugin's compiled defaults plus the settings
+   * document, never from this field. Mapping it into the fold is a future
+   * ruling (it would change folded output for declaring plugins).
+   */
+  defaults: JsonValue.optional(),
+  /**
+   * The scopes a section's values may come from. `project` is the only scope
+   * with live semantics: a manifest that declares scopes WITHOUT `"project"`
+   * gets `layering.projectOverlay: false` on its registered section
+   * (restrictive-only), so per-cwd project files cannot override it. `global`
+   * is the baseline every section has; `agent` has no runtime mapping (the
+   * agent/entity fold is downstream of the document protocol).
+   */
+  scopes: z8.array(PluginConfigScope).optional()
+});
+var PluginConfigManifest = z8.array(PluginConfigSectionManifest).min(1);
+function configSectionKeysForManifest(manifest) {
+  return manifest.config?.map((config) => config.section ?? `plugins.${manifest.id}`) ?? [];
+}
+var PluginStorageManifest = z8.strictObject({
+  sqlite: z8.strictObject({
+    enabled: z8.boolean(),
+    ownerTarget: z8.literal("kay.app").optional(),
+    migrations: NonEmptyString.optional()
+  }).optional(),
+  dataDir: z8.strictObject({
+    enabled: z8.boolean(),
+    ownerTarget: z8.literal("kay.app").optional()
+  }).optional()
+});
+var PluginOAuthClientSupplier = z8.enum(["kay", "user"]);
+var PluginProvisioningProbe = z8.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
+   * scheme's composed token endpoint, not trusted from this manifest.
+   */
+  url: HttpsUrl,
+  /** Absent ⇒ `GET`. */
+  method: z8.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: z8.array(SignedInStatusCode).min(1),
+  /**
+   * Dot-path to a JSON array in the response body that must be NON-EMPTY for the requirement to
+   * count as satisfied (e.g. `installations`). Absent means a verdict status alone is enough.
+   * An empty array is the shape "you are authenticated, and you have none of these" — exactly the
+   * GitHub App case where the token is valid and the app is installed nowhere.
+   */
+  nonEmptyArrayAt: NonEmptyString.optional()
+});
+var PluginProvisioningRequirement = z8.strictObject({
+  /** Stable id, unique within the scheme. */
+  id: LocalContributionId,
+  /** Human-facing requirement name, e.g. "GitHub App installation". */
+  displayName: NonEmptyString,
+  /** One sentence saying what is missing and why reconnecting will not fix it. */
+  description: NonEmptyString,
+  /**
+   * Where the user completes the setup. OPTIONAL: the URL can vary per environment, and a plugin
+   * cannot know it at manifest-declaration time — the broker supplies it at runtime. When neither
+   * a declared nor a resolved URL exists, the UI degrades to "Reconnect" instead of showing a
+   * broken link.
+   */
+  remediationUrl: HttpsUrl.optional(),
+  probe: PluginProvisioningProbe
+});
+var PluginProvisioningField = {
+  provisioning: z8.array(PluginProvisioningRequirement).optional()
+};
+var PluginAuthSchemeDescriptionFields = {
+  /** Human-facing flow name; the runtime scheme name is the fallback. */
+  displayName: NonEmptyString.optional(),
+  /** What this flow unlocks and when an agent should choose it. */
+  agentHint: NonEmptyString.optional(),
+  /**
+   * What this flow unlocks, for the person: one plain sentence with no identifiers or URIs, shown
+   * on the Plugins page beside the sign-in. The agent reads `agentHint`, not this.
+   */
+  summary: NonEmptyString.optional()
+};
+var PluginAuthSchemeOAuthPkce = z8.strictObject({
+  ...PluginProvisioningField,
+  ...PluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  kind: z8.literal("oauth2"),
+  exchange: z8.literal("pkce"),
+  /**
+   * Unordered SET of who may supply the client — non-empty, and every entry must be distinct
+   * (fail-closed re-assertion of the kernel's construction-time dedupe: TS exhaustiveness never
+   * runs on an untrusted manifest, so a hand-built `["kay","kay"]` must be refused here, not
+   * silently normalized).
+   */
+  clientSuppliers: z8.array(PluginOAuthClientSupplier).nonempty().superRefine((suppliers, ctx) => {
+    if (new Set(suppliers).size !== suppliers.length) {
+      ctx.addIssue({
+        code: "custom",
+        message: `clientSuppliers must not repeat a value (got ${JSON.stringify(suppliers)})`
+      });
+    }
+  }),
+  scopes: z8.array(NonEmptyString).optional()
+});
+var PluginAuthSchemeOAuthConfidential = z8.strictObject({
+  ...PluginProvisioningField,
+  ...PluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  kind: z8.literal("oauth2"),
+  exchange: z8.literal("confidential"),
+  /** Absent means `["kay"]` — a confidential exchange's secret may only ever be Kay's. */
+  clientSuppliers: z8.tuple([z8.literal("kay")]).optional(),
+  scopes: z8.array(NonEmptyString).optional()
+});
+var PluginAuthSchemeOAuth2 = z8.discriminatedUnion("exchange", [
+  PluginAuthSchemeOAuthPkce,
+  PluginAuthSchemeOAuthConfidential
+]);
+var PluginAuthSchemeApiKey = z8.strictObject({
+  ...PluginProvisioningField,
+  ...PluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  kind: z8.literal("api-key"),
+  scopes: z8.array(NonEmptyString).optional()
+});
+var PluginAuthSchemeDelegated = z8.strictObject({
+  ...PluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  kind: z8.literal("delegated"),
+  scopes: z8.array(NonEmptyString).optional()
+});
+var PluginAuthSchemeExternalCli = z8.strictObject({
+  ...PluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  kind: z8.literal("external-cli"),
+  scopes: z8.array(NonEmptyString).optional()
+});
+var PluginAuthScheme = z8.discriminatedUnion("kind", [
+  PluginAuthSchemeOAuth2,
+  PluginAuthSchemeApiKey,
+  PluginAuthSchemeDelegated,
+  PluginAuthSchemeExternalCli
+]);
+var PluginWebSessionProbe = z8.strictObject({
+  url: HttpsUrl,
+  /** Absent ⇒ `GET`. `POST` sends an empty JSON object body. */
+  method: z8.enum(["GET", "POST"]).optional(),
+  signedInStatuses: z8.array(SignedInStatusCode).min(1)
+});
+var PluginWebSessionDeclaration = z8.strictObject({
+  /** `required`: capabilities degrade without the site login; `recommended`: it only smooths UX. */
+  importance: z8.enum(["required", "recommended"]),
+  loginUrl: HttpsUrl,
+  cookieDomains: z8.array(RegistrableDomain).min(1),
+  probe: PluginWebSessionProbe,
+  oauthVenue: z8.enum(["embedded", "external"])
+}).superRefine(refineWebSessionScopeConfined);
+var PluginAuthService = z8.strictObject({
+  localId: LocalContributionId,
+  displayName: NonEmptyString,
+  schemes: z8.array(PluginAuthScheme).min(1),
+  purposes: z8.array(NonEmptyString).min(1),
+  webSession: PluginWebSessionDeclaration.optional()
+});
+var PluginAuthManifest = z8.strictObject({
+  services: z8.array(PluginAuthService).optional()
+});
+var RETIRED_COMPATIBILITY_KEYS = ["policy"];
+function stripRetiredCompatibilityKeys(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const remaining = { ...value };
+  for (const key of RETIRED_COMPATIBILITY_KEYS)
+    delete remaining[key];
+  return remaining;
+}
+var PluginCompatibilityManifest = z8.preprocess(stripRetiredCompatibilityKeys, z8.strictObject({
+  supportedProtocols: z8.array(KayPluginProtocolVersion).optional(),
+  minKayVersion: NonEmptyString.optional(),
+  sdk: NonEmptyString.optional()
+}));
+function retiredCompatibilityKeysIn(rawManifest) {
+  if (typeof rawManifest !== "object" || rawManifest === null)
+    return [];
+  const compatibility = rawManifest["compatibility"];
+  if (typeof compatibility !== "object" || compatibility === null)
+    return [];
+  const record = compatibility;
+  return RETIRED_COMPATIBILITY_KEYS.filter((key) => key in record);
+}
+var KayVersionString = NonEmptyString.regex(SEMVER_PATTERN, {
+  message: "version must be semver, for example 1.2.3"
+});
+var KayPluginManifestV1 = z8.strictObject({
+  protocol: z8.literal(KAY_PLUGIN_PROTOCOL_VERSION),
+  id: PluginId,
+  displayName: NonEmptyString,
+  version: KayVersionString,
+  publisher: NonEmptyString.optional(),
+  /**
+   * What this plugin lets an agent do, in one line. Required, and **model-visible**: it is
+   * the plugin's entry in the `plugin://` address space, and for most agents it is the first
+   * and only sentence they will read about this plugin. Write it for the agent deciding
+   * whether to reach for this plugin at all — not as marketing copy.
+   */
+  description: NonEmptyString,
+  // Display icons resolved relative to the package root and traversal-guarded
+  // by `PackageAssetPath`. `iconDark` is an optional dark-appearance variant;
+  // when absent the host falls back to `icon`. This is a *raster/asset* icon —
+  // distinct from the *symbolic* `UiCommandContribution.icon` (an icon-set
+  // name), see LEXICON `icon`.
+  icon: PackageAssetPath.optional(),
+  iconDark: PackageAssetPath.optional(),
+  namespace: PluginNamespace.optional(),
+  targets: z8.strictObject({
+    kay: z8.strictObject({
+      agent: KayAgentTargetManifest.optional(),
+      app: KayAppTargetManifest.optional(),
+      ui: KayUiTargetManifest.optional()
+    }).optional()
+  }).optional(),
+  config: PluginConfigManifest.optional(),
+  storage: PluginStorageManifest.optional(),
+  auth: PluginAuthManifest.optional(),
+  permissions: PluginPermissionManifest.optional(),
+  compatibility: PluginCompatibilityManifest.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: z8.strictObject({
+    plugins: z8.array(PluginId).optional()
+  }).optional()
+}).superRefine((manifest, ctx) => {
+  const authServices = new Set(manifest.auth?.services?.map((service) => service.localId) ?? []);
+  const authSchemeIdsByService = new Map((manifest.auth?.services ?? []).map((service) => [
+    service.localId,
+    new Set(service.schemes.flatMap((scheme) => [
+      scheme.localId,
+      `${manifest.namespace ?? manifest.id}.${scheme.localId}`
+    ]))
+  ]));
+  const endpointIds = new Set(manifest.targets?.kay?.app?.contributes?.endpoints?.map((endpoint) => endpoint.localId) ?? []);
+  const storageKinds = /* @__PURE__ */ new Set();
+  if (manifest.storage?.sqlite?.enabled)
+    storageKinds.add("sqlite");
+  if (manifest.storage?.dataDir?.enabled)
+    storageKinds.add("dataDir");
+  const configSections = /* @__PURE__ */ new Set();
+  for (const [index, section] of configSectionKeysForManifest(manifest).entries()) {
+    if (configSections.has(section)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["config", index, "section"],
+        message: `duplicate config section ${section}`
+      });
+    }
+    configSections.add(section);
+  }
+  const subscribedAppEvents = new Set(manifest.targets?.kay?.app?.contributes?.eventSubscriptions?.map((subscription) => subscription.event) ?? []);
+  const definedPluginEvents = new Set(manifest.targets?.kay?.app?.contributes?.eventDefinitions?.map((definition) => definition.localId) ?? []);
+  for (const [index, rule] of (manifest.targets?.kay?.app?.contributes?.notificationRules ?? []).entries()) {
+    const path = [
+      "targets",
+      "kay",
+      "app",
+      "contributes",
+      "notificationRules",
+      index
+    ];
+    if (!definedPluginEvents.has(rule.event)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "event"],
+        message: `notification rule ${rule.localId} references unknown plugin event ${rule.event}`
+      });
+    }
+    for (const key of PLUGIN_NOTIFICATION_RULE_HOST_KEYS) {
+      if (Object.hasOwn(rule.rule, key)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [...path, "rule", key],
+          message: `notification rule ${rule.localId} sets '${key}', which the host stamps for a plugin's default rule`
+        });
+      }
+    }
+  }
+  reportDuplicateLocalIds(ctx, ["targets", "kay", "app", "contributes", "notificationRules"], manifest.targets?.kay?.app?.contributes?.notificationRules, "notification rule");
+  const declaredAppDataSources = new Set(manifest.targets?.kay?.app?.contributes?.dataSources?.map((source) => source.localId) ?? []);
+  const materializedAppDataSources = /* @__PURE__ */ new Set();
+  for (const [index, materializer] of (manifest.targets?.kay?.ui?.contributes?.dataMaterializers ?? []).entries()) {
+    if (!declaredAppDataSources.has(materializer.source)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "targets",
+          "kay",
+          "ui",
+          "contributes",
+          "dataMaterializers",
+          index,
+          "source"
+        ],
+        message: `app-data materializer references unknown app source ${materializer.source}`
+      });
+    }
+    if (materializedAppDataSources.has(materializer.source)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "targets",
+          "kay",
+          "ui",
+          "contributes",
+          "dataMaterializers",
+          index,
+          "source"
+        ],
+        message: `app-data source ${materializer.source} has more than one materializer`
+      });
+    }
+    materializedAppDataSources.add(materializer.source);
+  }
+  for (const source of declaredAppDataSources) {
+    if (materializedAppDataSources.has(source))
+      continue;
+    ctx.addIssue({
+      code: "custom",
+      path: ["targets", "kay", "app", "contributes", "dataSources"],
+      message: `app-data source ${source} has no same-plugin UI materializer`
+    });
+  }
+  reportDuplicateLocalIds(ctx, ["targets", "kay", "app", "contributes", "whiteboardTypes"], manifest.targets?.kay?.app?.contributes?.whiteboardTypes, "Whiteboard type");
+  const uiAppIds = new Set(manifest.targets?.kay?.ui?.contributes?.apps?.map((app) => app.localId) ?? []);
+  for (const [index, type] of (manifest.targets?.kay?.app?.contributes?.whiteboardTypes ?? []).entries()) {
+    if (type.presentation !== void 0 && !uiAppIds.has(type.presentation.app)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "targets",
+          "kay",
+          "app",
+          "contributes",
+          "whiteboardTypes",
+          index,
+          "presentation",
+          "app"
+        ],
+        message: `Whiteboard type ${type.localId} references unknown ui app ${type.presentation.app}`
+      });
+    }
+  }
+  const subscribedUiEvents = new Set(manifest.targets?.kay?.ui?.contributes?.eventSubscriptions?.map((subscription) => subscription.event) ?? []);
+  const invokedUiEndpoints = new Set(manifest.permissions?.byTarget["kay.ui"]?.endpoints?.filter((grant) => grant.operations.includes("invoke")).map((grant) => grant.endpoint) ?? []);
+  const uriModuleIds = new Set(manifest.targets?.kay?.agent?.contributes?.uriModules?.map((module) => module.localId) ?? []);
+  const presentationByUriModule = /* @__PURE__ */ new Map();
+  for (const [index, presentation] of (manifest.targets?.kay?.ui?.contributes?.referencePresentations ?? []).entries()) {
+    const path = [
+      "targets",
+      "kay",
+      "ui",
+      "contributes",
+      "referencePresentations",
+      index
+    ];
+    if (!uriModuleIds.has(presentation.uriModule)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "uriModule"],
+        message: `reference presentation ${presentation.localId} references unknown uri module ${presentation.uriModule}`
+      });
+    }
+    const existing = presentationByUriModule.get(presentation.uriModule);
+    if (existing !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "uriModule"],
+        message: `uri module ${presentation.uriModule} is presented by both ${existing} and ${presentation.localId}`
+      });
+    } else {
+      presentationByUriModule.set(presentation.uriModule, presentation.localId);
+    }
+  }
+  reportDuplicateLocalIds(ctx, ["targets", "kay", "ui", "contributes", "referencePresentations"], manifest.targets?.kay?.ui?.contributes?.referencePresentations, "reference presentation");
+  reportDuplicateLocalIds(ctx, ["targets", "kay", "app", "contributes", "eventDefinitions"], manifest.targets?.kay?.app?.contributes?.eventDefinitions, "plugin event definition");
+  reportDuplicateLocalIds(ctx, ["targets", "kay", "app", "contributes", "contextContributors"], manifest.targets?.kay?.app?.contributes?.contextContributors, "context contributor");
+  const syntheticContributionIds = collectSyntheticContributionIds(manifest);
+  for (const contribution of collectDeclaredContributionIds(manifest)) {
+    if (syntheticContributionIds.has(contribution.localId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: contribution.path,
+        message: `contribution local id ${contribution.localId} is reserved by a manifest-level declaration`
+      });
+    }
+  }
+  const toolNames = /* @__PURE__ */ new Map();
+  for (const target of ["agent", "app"]) {
+    const contributes = target === "agent" ? manifest.targets?.kay?.agent?.contributes : manifest.targets?.kay?.app?.contributes;
+    for (const tool of contributes?.tools ?? []) {
+      const existing = toolNames.get(tool.toolName);
+      if (existing !== void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["targets", "kay", target, "contributes", "tools"],
+          message: `toolName ${tool.toolName} is declared by both ${existing} and ${tool.localId}`
+        });
+      }
+      toolNames.set(tool.toolName, tool.localId);
+    }
+  }
+  const converterMimeTypes = /* @__PURE__ */ new Map();
+  for (const converter of manifest.targets?.kay?.agent?.contributes?.converters ?? []) {
+    for (const mimeType of converter.mimeTypes) {
+      const existing = converterMimeTypes.get(mimeType);
+      if (existing !== void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["targets", "kay", "agent", "contributes", "converters"],
+          message: `mime type ${mimeType} is declared by both ${existing} and ${converter.localId}`
+        });
+      }
+      converterMimeTypes.set(mimeType, converter.localId);
+    }
+  }
+  const agentPrimer = manifest.targets?.kay?.agent?.primer;
+  if (agentPrimer !== void 0) {
+    const declaredSkillIds = new Set((manifest.targets?.kay?.agent?.contributes?.skills ?? []).map((skill) => skill.localId));
+    if (!declaredSkillIds.has(agentPrimer)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targets", "kay", "agent", "primer"],
+        message: `primer '${agentPrimer}' does not name a declared kay.agent skill contribution`
+      });
+    }
+  }
+  for (const skill of manifest.targets?.kay?.agent?.contributes?.skills ?? []) {
+    if (skill.localId === "primer" && agentPrimer !== "primer") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targets", "kay", "agent", "contributes", "skills"],
+        message: `skill localId 'primer' is reserved for the plugin's designated primer, so set targets.kay.agent.primer to 'primer' or rename the skill`
+      });
+    }
+  }
+  for (const module of manifest.targets?.kay?.agent?.contributes?.uriModules ?? []) {
+    if (module.authService && !isQualifiedAuthServiceRef(module.authService) && !authServices.has(module.authService)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targets", "kay", "agent", "contributes", "uriModules"],
+        message: `uri module ${module.localId} references unknown auth service ${module.authService}`
+      });
+    }
+  }
+  for (const [index, resolver] of (manifest.targets?.kay?.agent?.contributes?.entityResolvers ?? []).entries()) {
+    if (!uriModuleIds.has(resolver.uriModule)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "targets",
+          "kay",
+          "agent",
+          "contributes",
+          "entityResolvers",
+          index,
+          "uriModule"
+        ],
+        message: `entity resolver ${resolver.localId} references unknown uri module ${resolver.uriModule}`
+      });
+    }
+  }
+  reportDuplicateLocalIds(ctx, ["targets", "kay", "agent", "contributes", "entityResolvers"], manifest.targets?.kay?.agent?.contributes?.entityResolvers, "entity resolver");
+  reportDuplicateLocalIds(ctx, ["targets", "kay", "agent", "contributes", "artifactUriModules"], manifest.targets?.kay?.agent?.contributes?.artifactUriModules, "artifact uri module");
+  const artifactSchemeOwners = /* @__PURE__ */ new Map();
+  const uriModuleSchemeOwners = /* @__PURE__ */ new Map();
+  for (const module of manifest.targets?.kay?.agent?.contributes?.uriModules ?? []) {
+    for (const scheme of module.schemes)
+      uriModuleSchemeOwners.set(scheme, module.localId);
+  }
+  for (const module of manifest.targets?.kay?.app?.contributes?.uriModules ?? []) {
+    for (const scheme of module.schemes)
+      uriModuleSchemeOwners.set(scheme, module.localId);
+  }
+  for (const module of manifest.targets?.kay?.agent?.contributes?.artifactUriModules ?? []) {
+    const uriOwner = uriModuleSchemeOwners.get(module.scheme);
+    if (uriOwner !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "targets",
+          "kay",
+          "agent",
+          "contributes",
+          "artifactUriModules"
+        ],
+        message: `artifact uri module ${module.localId} claims scheme ${module.scheme} already declared by uri module ${uriOwner}`
+      });
+    }
+    const artifactOwner = artifactSchemeOwners.get(module.scheme);
+    if (artifactOwner !== void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "targets",
+          "kay",
+          "agent",
+          "contributes",
+          "artifactUriModules"
+        ],
+        message: `artifact uri module scheme ${module.scheme} is declared by both ${artifactOwner} and ${module.localId}`
+      });
+    }
+    artifactSchemeOwners.set(module.scheme, module.localId);
+  }
+  const cliBindingNames = /* @__PURE__ */ new Map();
+  for (const binding of manifest.targets?.kay?.agent?.contributes?.cliBindings ?? []) {
+    if (!isQualifiedAuthServiceRef(binding.authService) && !authServices.has(binding.authService)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targets", "kay", "agent", "contributes", "cliBindings"],
+        message: `cli binding ${binding.localId} references unknown auth service ${binding.authService}`
+      });
+    }
+    for (const name of [binding.binary, ...binding.aliases ?? []]) {
+      const owner = cliBindingNames.get(name);
+      if (owner !== void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["targets", "kay", "agent", "contributes", "cliBindings"],
+          message: `cli binding binary/alias ${name} is declared by both ${owner} and ${binding.localId}`
+        });
+        continue;
+      }
+      cliBindingNames.set(name, binding.localId);
+    }
+  }
+  const gitHostClaimants = /* @__PURE__ */ new Set();
+  for (const claim of manifest.targets?.kay?.agent?.contributes?.gitHosts ?? []) {
+    if (!authServices.has(claim.authService)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targets", "kay", "agent", "contributes", "gitHosts"],
+        message: `git host ${claim.host} references unknown auth service ${claim.authService}`
+      });
+    }
+    if (gitHostClaimants.has(claim.host)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targets", "kay", "agent", "contributes", "gitHosts"],
+        message: `git host ${claim.host} is claimed twice by this manifest`
+      });
+    }
+    gitHostClaimants.add(claim.host);
+  }
+  for (const [name, server] of Object.entries(manifest.targets?.kay?.app?.contributes?.mcpServers ?? {})) {
+    if (server.authService !== void 0 && !isQualifiedAuthServiceRef(server.authService) && !authServices.has(server.authService)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [
+          "targets",
+          "kay",
+          "app",
+          "contributes",
+          "mcpServers",
+          name,
+          "authService"
+        ],
+        message: `mcp server ${name} references unknown auth service ${server.authService}`
+      });
+    }
+  }
+  const skillLocalIds = new Set(manifest.targets?.kay?.agent?.contributes?.skills?.map((skill) => skill.localId) ?? []);
+  const commandNames = /* @__PURE__ */ new Map();
+  const validateCommandName = (path, command) => {
+    for (const name of [command.localId, ...command.aliases ?? []]) {
+      const owner = commandNames.get(name);
+      if (owner !== void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: [...path, "localId"],
+          message: `command name ${name} is declared by both ${owner} and ${command.localId}`
+        });
+        continue;
+      }
+      commandNames.set(name, command.localId);
+    }
+  };
+  for (const [index, command] of (manifest.targets?.kay?.agent?.contributes?.commands ?? []).entries()) {
+    const path = [
+      "targets",
+      "kay",
+      "agent",
+      "contributes",
+      "commands",
+      index
+    ];
+    validateCommandName(path, command);
+    if (command.handler.kind === "endpoint") {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "handler", "kind"],
+        message: `command ${command.localId} declares an endpoint handler on kay.agent; endpoint handlers are kay.app-only`
+      });
+    } else if (command.handler.kind === "skill" && !skillLocalIds.has(command.handler.skill)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "handler", "skill"],
+        message: `command ${command.localId} references unknown skill ${command.handler.skill}`
+      });
+    } else if (command.handler.kind === "tool" && !toolNames.has(command.handler.tool)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "handler", "tool"],
+        message: `command ${command.localId} references unknown tool ${command.handler.tool}`
+      });
+    }
+  }
+  for (const [index, command] of (manifest.targets?.kay?.app?.contributes?.commands ?? []).entries()) {
+    const path = ["targets", "kay", "app", "contributes", "commands", index];
+    validateCommandName(path, command);
+    if (command.handler.kind !== "endpoint") {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "handler", "kind"],
+        message: `command ${command.localId} declares a ${command.handler.kind} handler on kay.app; kay.app commands must use an endpoint handler`
+      });
+    } else if (!endpointIds.has(command.handler.endpoint)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path, "handler", "endpoint"],
+        message: `command ${command.localId} references unknown endpoint ${command.handler.endpoint}`
+      });
+    }
+  }
+  for (const [appIndex, app] of (manifest.targets?.kay?.ui?.contributes?.apps ?? []).entries()) {
+    for (const [endpointIndex, endpoint] of (app.capabilities?.endpoints ?? []).entries()) {
+      const path = [
+        "targets",
+        "kay",
+        "ui",
+        "contributes",
+        "apps",
+        appIndex,
+        "capabilities",
+        "endpoints",
+        endpointIndex
+      ];
+      if (!endpointIds.has(endpoint)) {
+        ctx.addIssue({
+          code: "custom",
+          path,
+          message: `ui app ${app.localId} references unknown endpoint ${endpoint}`
+        });
+      } else if (!invokedUiEndpoints.has(endpoint)) {
+        ctx.addIssue({
+          code: "custom",
+          path,
+          message: `ui app ${app.localId} endpoint ${endpoint} requires a kay.ui invoke grant`
+        });
+      }
+    }
+  }
+  for (const [index, subscription] of (manifest.targets?.kay?.ui?.contributes?.eventSubscriptions ?? []).entries()) {
+    const path = [
+      "targets",
+      "kay",
+      "ui",
+      "contributes",
+      "eventSubscriptions",
+      index,
+      "event"
+    ];
+    const validation = validateKayUiEventSubscription(subscription.event, definedPluginEvents);
+    if (validation.valid)
+      continue;
+    ctx.addIssue({
+      code: "custom",
+      path,
+      message: validation.message
+    });
+  }
+  for (const target of KAY_PLUGIN_TARGET_NAMES) {
+    const targetPermissions = manifest.permissions?.byTarget[target];
+    for (const grant of targetPermissions?.auth ?? []) {
+      if (!isQualifiedAuthServiceRef(grant.service) && !authServices.has(grant.service)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["permissions", "byTarget", target, "auth"],
+          message: `permission references unknown auth service ${grant.service}`
+        });
+      }
+      if (!isQualifiedAuthServiceRef(grant.service)) {
+        const declaredSchemes = authSchemeIdsByService.get(grant.service);
+        for (const scheme of grant.schemes ?? []) {
+          if (declaredSchemes !== void 0 && !declaredSchemes.has(scheme)) {
+            ctx.addIssue({
+              code: "custom",
+              path: ["permissions", "byTarget", target, "auth"],
+              message: `permission references unknown auth scheme ${scheme} for service ${grant.service}`
+            });
+          }
+        }
+      }
+    }
+    for (const grant of targetPermissions?.endpoints ?? []) {
+      if (!endpointIds.has(grant.endpoint)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["permissions", "byTarget", target, "endpoints"],
+          message: `permission references unknown endpoint contribution ${grant.endpoint}`
+        });
+      }
+    }
+    for (const grant of targetPermissions?.storage ?? []) {
+      if (!storageKinds.has(grant.kind)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["permissions", "byTarget", target, "storage"],
+          message: `permission references undeclared storage kind ${grant.kind}`
+        });
+      }
+    }
+    for (const grant of targetPermissions?.events ?? []) {
+      if (target === "kay.agent") {
+        ctx.addIssue({
+          code: "custom",
+          path: ["permissions", "byTarget", target, "events"],
+          message: `kay.agent targets cannot declare events grants: no runtime event capability backs them (grant references ${grant.event})`
+        });
+        continue;
+      }
+      if (grant.operations.includes("subscribe") && target === "kay.app" && !subscribedAppEvents.has(grant.event)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["permissions", "byTarget", target, "events"],
+          message: `event subscribe permission references undeclared app event subscription ${grant.event}`
+        });
+      }
+      if (grant.operations.includes("subscribe") && target === "kay.ui" && !subscribedUiEvents.has(grant.event)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["permissions", "byTarget", target, "events"],
+          message: `event subscribe permission references undeclared ui event subscription ${grant.event}`
+        });
+      }
+      if (grant.operations.includes("publish") && target === "kay.app") {
+        const localId = grant.event.startsWith("self:") ? grant.event.slice("self:".length) : grant.event;
+        if (!definedPluginEvents.has(localId)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["permissions", "byTarget", target, "events"],
+            message: `event publish permission references undeclared plugin event ${grant.event}`
+          });
+        }
+      }
+    }
+  }
+  const declaredDeps = manifest.dependencies?.plugins;
+  if (declaredDeps !== void 0 && declaredDeps.length > 0) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, depId] of declaredDeps.entries()) {
+      if (depId === manifest.id) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["dependencies", "plugins", index],
+          message: `plugin '${manifest.id}' cannot declare itself as a dependency`
+        });
+        continue;
+      }
+      if (seen.has(depId)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["dependencies", "plugins", index],
+          message: `duplicate dependency plugin id '${depId}'`
+        });
+      } else {
+        seen.add(depId);
+      }
+    }
+  }
+});
+function parseKayPluginManifestV1(value) {
+  return KayPluginManifestV1.parse(value);
+}
+function kayUiEventSubscriptionsFromManifest(manifest) {
+  return manifest.targets?.kay?.ui?.contributes?.eventSubscriptions ?? [];
+}
+function validateKayUiEventSubscription(event, definedPluginEvents) {
+  if (event.startsWith("self:")) {
+    const localId = event.slice("self:".length);
+    if (!definedPluginEvents.has(localId)) {
+      return {
+        valid: false,
+        message: `ui event subscription references unknown plugin event ${event}`
+      };
+    }
+    return { valid: true };
+  }
+  if (event.startsWith("native:")) {
+    if (!KAY_UI_NATIVE_EVENT_ALLOWLIST.has(event)) {
+      return {
+        valid: false,
+        message: `ui event subscription references unsupported native event ${event}`
+      };
+    }
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    message: "ui event subscriptions must reference self:<event-local-id> or an allowlisted native:<event>"
+  };
+}
+function reportDuplicateLocalIds(ctx, path, contributions, label) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, contribution] of (contributions ?? []).entries()) {
+    if (!seen.has(contribution.localId)) {
+      seen.add(contribution.localId);
+      continue;
+    }
+    ctx.addIssue({
+      code: "custom",
+      path: [...path, index, "localId"],
+      message: `duplicate ${label} local id ${contribution.localId}`
+    });
+  }
+}
+function collectKayAppContributionIds(manifest) {
+  const contributes = manifest.targets?.kay?.app?.contributes;
+  const output = [];
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "tools"], contributes?.tools);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "endpoints"], contributes?.endpoints);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "uriModules"], contributes?.uriModules);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "dataSources"], contributes?.dataSources);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "whiteboardTypes"], contributes?.whiteboardTypes);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "eventDefinitions"], contributes?.eventDefinitions);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "eventSubscriptions"], contributes?.eventSubscriptions);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "deviceDelegations"], contributes?.deviceDelegations);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "corpusConsumers"], contributes?.corpusConsumers);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "contextContributors"], contributes?.contextContributors);
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "mcpServers"], contributes?.mcpServers && Object.keys(contributes.mcpServers).map((localId) => ({ localId })));
+  pushContributionIds(output, ["targets", "kay", "app", "contributes", "commands"], contributes?.commands);
+  return output;
+}
+function collectDeclaredContributionIds(manifest) {
+  const output = [];
+  const agent = manifest.targets?.kay?.agent?.contributes;
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "tools"], agent?.tools);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "converters"], agent?.converters);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "uriModules"], agent?.uriModules);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "artifactUriModules"], agent?.artifactUriModules);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "cliBindings"], agent?.cliBindings);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "resources"], agent?.resources);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "skills"], agent?.skills);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "searchProviders"], agent?.searchProviders);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "entityResolvers"], agent?.entityResolvers);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "renderers"], agent?.renderers);
+  pushContributionIds(output, ["targets", "kay", "agent", "contributes", "commands"], agent?.commands);
+  output.push(...collectKayAppContributionIds(manifest));
+  const ui = manifest.targets?.kay?.ui?.contributes;
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "commands"], ui?.commands);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "slots"], ui?.slots);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "settingsPanels"], ui?.settingsPanels);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "resultRenderers"], ui?.resultRenderers);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "referencePresentations"], ui?.referencePresentations);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "views"], ui?.views);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "apps"], ui?.apps);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "themes"], ui?.themes);
+  pushContributionIds(output, ["targets", "kay", "ui", "contributes", "eventSubscriptions"], ui?.eventSubscriptions);
+  pushContributionIds(output, ["auth", "services"], manifest.auth?.services);
+  return output;
+}
+function collectSyntheticContributionIds(manifest) {
+  const output = /* @__PURE__ */ new Set();
+  if (manifest.storage?.sqlite?.enabled) {
+    output.add(resolveStorageContributionLocalId("sqlite"));
+  }
+  if (manifest.storage?.dataDir?.enabled) {
+    output.add(resolveStorageContributionLocalId("dataDir"));
+  }
+  for (const section of configSectionKeysForManifest(manifest)) {
+    output.add(resolveConfigSectionContributionLocalId(section));
+  }
+  return output;
+}
+function pushContributionIds(output, path, items) {
+  for (const [index, item] of (items ?? []).entries()) {
+    output.push({ localId: item.localId, path: [...path, index, "localId"] });
+  }
+}
+
+// packages/plugin-protocol/dist/resolved-contract.js
+import { z as z9 } from "zod";
+var ResolvedPluginContributionId = z9.strictObject({
+  target: PluginTargetName,
+  kind: PluginContributionKind,
+  localId: LocalContributionId,
+  globalId: GlobalContributionId
+});
+var ResolvedKayAgentTool = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  toolName: PluginToolName
+});
+var ResolvedKayAppTool = ResolvedKayAgentTool;
+var ResolvedKayAppDataSource = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  scope: z9.enum(["runtime", "account", "session"]),
+  snapshot: z9.strictObject({
+    version: z9.number().int().positive(),
+    schema: z9.record(z9.string(), z9.unknown())
+  }),
+  change: z9.strictObject({
+    version: z9.number().int().positive(),
+    schema: z9.record(z9.string(), z9.unknown()),
+    semantics: z9.discriminatedUnion("kind", [
+      z9.strictObject({ kind: z9.literal("incremental") }),
+      z9.strictObject({
+        kind: z9.literal("snapshot-replacement"),
+        maxEncodedBytes: z9.number().int().positive(),
+        rationale: z9.string().trim().min(1).max(1024)
+      })
+    ]).optional()
+  }),
+  read: AppDataSourceRead.optional()
+}).superRefine((source, ctx) => {
+  if (source.read !== void 0 && source.scope !== "session") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["read"],
+      message: "Resolved app-data read operations require session scope."
+    });
+  }
+});
+var ResolvedKayAppWhiteboardType = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  displayName: NonEmptyString,
+  schemaVersion: z9.number().int().positive(),
+  storage: WhiteboardTypeStorage,
+  valueSchema: JsonSchema,
+  presentation: z9.strictObject({
+    app: GlobalContributionId
+  }).optional()
+});
+var ResolvedKayAppMcpServer = z9.strictObject({
+  name: LocalContributionId,
+  pluginId: PluginId,
+  url: McpServerUrl,
+  auth: McpServerAuthMode,
+  authServiceId: GlobalContributionId.optional()
+});
+var ResolvedKayAgentUriModule = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  schemes: z9.array(UriScheme).min(1),
+  filesystemBacking: UriFilesystemBacking.optional(),
+  verbs: z9.strictObject({
+    writable: z9.boolean().optional(),
+    editable: z9.boolean().optional(),
+    deletable: z9.boolean().optional()
+  }).optional(),
+  /** Mirrors `UriModuleContribution.knownResources` (host-side recording opt-in). */
+  knownResources: z9.literal(true).optional()
+}).superRefine((module, ctx) => {
+  if (module.verbs !== void 0 && module.filesystemBacking?.root !== "filesystem") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["verbs"],
+      message: "Resolved URI mutation verbs require external filesystem backing (root: 'filesystem')."
+    });
+  }
+});
+var ResolvedKayAgentArtifactUriModule = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  scheme: UriScheme,
+  editable: z9.boolean(),
+  listable: z9.boolean(),
+  deletable: z9.boolean(),
+  appendable: z9.boolean(),
+  storageScope: z9.enum(["session", "family"])
+});
+var ResolvedKayAgentEntityResolver = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  displayName: NonEmptyString.optional(),
+  uriModule: GlobalContributionId,
+  entityTypes: z9.array(NonEmptyString).min(1),
+  uriHint: NonEmptyString
+});
+var ResolvedKayAgentGitHostClaim = z9.strictObject({
+  host: GitHostName,
+  authServiceId: GlobalContributionId,
+  /** Manifest-declared order; the clone ladder tries them in sequence. */
+  authSchemeIds: z9.array(GlobalContributionId).min(1),
+  /** Non-secret display copy for the claiming service, for clone failure text. */
+  authServiceDisplayName: z9.string(),
+  basicAuthUser: GitBasicAuthUser
+});
+var ResolvedKayAgentConverter = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  mimeTypes: z9.array(MimeTypeString).min(1),
+  extensions: z9.array(FileExtensionToken).min(1).optional()
+});
+var ResolvedReferencePresentation = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  uriModule: GlobalContributionId,
+  resourceKind: NonEmptyString,
+  open: ReferenceOpenBehavior,
+  /** MIME-specific resource kinds; absent keys use the base presentation. */
+  variants: ReferencePresentationVariants.optional(),
+  claims: z9.array(ReferencePresentationUrlClaim).optional()
+});
+var ResolvedPluginProvisioningRequirement = z9.strictObject({
+  id: LocalContributionId,
+  displayName: NonEmptyString,
+  description: NonEmptyString,
+  /**
+   * Where the user completes the setup. Optional mirror of the manifest field: a per-environment
+   * URL the broker supplies at runtime, so a requirement with neither a declared nor a resolved
+   * URL degrades to "Reconnect" in the UI instead of a broken link.
+   */
+  remediationUrl: HttpsUrl.optional(),
+  probe: z9.strictObject({
+    url: HttpsUrl,
+    method: z9.enum(["GET"]),
+    verdictStatuses: z9.array(SignedInStatusCode).min(1),
+    nonEmptyArrayAt: NonEmptyString.optional()
+  })
+});
+var ResolvedProvisioningField = {
+  provisioning: z9.array(ResolvedPluginProvisioningRequirement).optional()
+};
+var ResolvedPluginAuthSchemeDescriptionFields = {
+  displayName: NonEmptyString.optional(),
+  agentHint: NonEmptyString.optional(),
+  summary: NonEmptyString.optional()
+};
+var ResolvedPluginAuthSchemeOAuthBase = {
+  ...ResolvedProvisioningField,
+  ...ResolvedPluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  kind: z9.literal("oauth2"),
+  scopes: z9.array(z9.string()).optional()
+};
+var ResolvedPluginAuthSchemeOAuthPkce = z9.strictObject({
+  ...ResolvedPluginAuthSchemeOAuthBase,
+  exchange: z9.literal("pkce"),
+  clientSuppliers: z9.array(PluginOAuthClientSupplier).nonempty()
+});
+var ResolvedPluginAuthSchemeOAuthConfidential = z9.strictObject({
+  ...ResolvedPluginAuthSchemeOAuthBase,
+  exchange: z9.literal("confidential"),
+  clientSuppliers: z9.tuple([z9.literal("kay")])
+});
+var ResolvedPluginAuthSchemeOAuth2 = z9.discriminatedUnion("exchange", [
+  ResolvedPluginAuthSchemeOAuthPkce,
+  ResolvedPluginAuthSchemeOAuthConfidential
+]);
+var ResolvedPluginAuthSchemeApiKey = z9.strictObject({
+  ...ResolvedProvisioningField,
+  ...ResolvedPluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  kind: z9.literal("api-key"),
+  scopes: z9.array(z9.string()).optional()
+});
+var ResolvedPluginAuthSchemeDelegated = z9.strictObject({
+  ...ResolvedPluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  kind: z9.literal("delegated"),
+  scopes: z9.array(z9.string()).optional()
+});
+var ResolvedPluginAuthSchemeExternalCli = z9.strictObject({
+  ...ResolvedPluginAuthSchemeDescriptionFields,
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  kind: z9.literal("external-cli"),
+  scopes: z9.array(z9.string()).optional()
+});
+var ResolvedPluginAuthScheme = z9.discriminatedUnion("kind", [
+  ResolvedPluginAuthSchemeOAuth2,
+  ResolvedPluginAuthSchemeApiKey,
+  ResolvedPluginAuthSchemeDelegated,
+  ResolvedPluginAuthSchemeExternalCli
+]);
+var ResolvedPluginWebSession = z9.strictObject({
+  importance: z9.enum(["required", "recommended"]),
+  loginUrl: HttpsUrl,
+  cookieDomains: z9.array(RegistrableDomain).min(1),
+  probe: z9.strictObject({
+    url: HttpsUrl,
+    method: z9.enum(["GET", "POST"]),
+    signedInStatuses: z9.array(SignedInStatusCode).min(1)
+  }),
+  oauthVenue: z9.enum(["embedded", "external"])
+}).superRefine(refineWebSessionScopeConfined);
+var ResolvedPluginAuthService = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  displayName: z9.string(),
+  schemes: z9.array(ResolvedPluginAuthScheme).min(1),
+  purposes: z9.array(z9.string()).min(1),
+  /** The service's browser half, when the manifest declares one. */
+  webSession: ResolvedPluginWebSession.optional()
+});
+var ResolvedKayUiAppEndpointCapability = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId
+});
+var ResolvedKayUiApp = z9.strictObject({
+  localId: LocalContributionId,
+  globalId: GlobalContributionId,
+  displayName: NonEmptyString,
+  description: NonEmptyString.optional(),
+  icon: PackageAssetPath.optional(),
+  runtime: z9.literal("kay.react-app.v1"),
+  sdk: z9.strictObject({ range: NonEmptyString }),
+  entrypoint: TargetEntrypoint,
+  styles: z9.array(PackageAssetPath).optional(),
+  assets: z9.array(PackageAssetPath).optional(),
+  capabilities: z9.strictObject({
+    endpoints: z9.array(ResolvedKayUiAppEndpointCapability).optional(),
+    host: z9.array(KayUiAppHostCapability).optional()
+  }).optional()
+});
+var ResolvedPluginContractV1 = z9.strictObject({
+  protocol: z9.literal("kay.plugin.v1"),
+  pluginId: PluginId,
+  namespace: PluginNamespace,
+  contributions: z9.array(ResolvedPluginContributionId),
+  // The deduplicated set of qualified (dotted) external auth-service ids this
+  // plugin references, from agent uriModule `authService` refs, cliBinding
+  // `authService` refs, and auth-grant `service` refs. Always present — a plugin
+  // that only references its own local services carries an empty array. This
+  // 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: z9.array(GlobalContributionId),
+  // The explicit plugin-level dependency ids declared in `dependencies.plugins` on the manifest,
+  // deduped and validated at parse time. Always present; a plugin with no explicit dependencies
+  // carries an empty array. Composition checks each id against the accepted roster and derives the
+  // full dependency graph together with auth-inferred edges from `consumesAuthServices`.
+  explicitDependencies: z9.array(PluginId),
+  // The auth services this plugin OWNS, carrying the global ids its harness
+  // target must register and the credential authority keys on. Always present;
+  // a plugin that declares no `auth.services` carries an empty array. The dual
+  // of `consumesAuthServices` (services it merely references).
+  authServices: z9.array(ResolvedPluginAuthService),
+  grants: ResolvedPluginGrants.optional(),
+  kayAgentUriModules: z9.array(ResolvedKayAgentUriModule).optional(),
+  kayAgentArtifactUriModules: z9.array(ResolvedKayAgentArtifactUriModule).optional(),
+  kayAgentEntityResolvers: z9.array(ResolvedKayAgentEntityResolver).optional(),
+  kayAgentGitHostClaims: z9.array(ResolvedKayAgentGitHostClaim).optional(),
+  kayAgentTools: z9.array(ResolvedKayAgentTool).optional(),
+  kayAppTools: z9.array(ResolvedKayAppTool).optional(),
+  kayAppDataSources: z9.array(ResolvedKayAppDataSource).optional(),
+  kayAppWhiteboardTypes: z9.array(ResolvedKayAppWhiteboardType).optional(),
+  kayAppMcpServers: z9.array(ResolvedKayAppMcpServer).optional(),
+  kayAgentConverters: z9.array(ResolvedKayAgentConverter).optional(),
+  referencePresentations: z9.array(ResolvedReferencePresentation).optional(),
+  kayUiApps: z9.array(ResolvedKayUiApp).optional()
+});
+function narrowestAccountSelectors() {
+  return [{ kind: "active" }];
+}
+var KayPluginContractResolutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KayPluginContractResolutionError";
+  }
+};
+function parseResolvedPluginContractV1(value) {
+  return ResolvedPluginContractV1.parse(value);
+}
+function pushAll(output, target, kind, items) {
+  for (const item of items ?? [])
+    output.push({ target, kind, localId: item.localId });
+}
+function collectContributionSources(manifest) {
+  const output = [];
+  const agent = manifest.targets?.kay?.agent?.contributes;
+  pushAll(output, "kay.agent", "tool", agent?.tools);
+  pushAll(output, "kay.agent", "converter", agent?.converters);
+  pushAll(output, "kay.agent", "uriModule", agent?.uriModules);
+  pushAll(output, "kay.agent", "artifactUriModule", agent?.artifactUriModules);
+  pushAll(output, "kay.agent", "cliBinding", agent?.cliBindings);
+  pushAll(output, "kay.agent", "resource", agent?.resources);
+  pushAll(output, "kay.agent", "skill", agent?.skills);
+  pushAll(output, "kay.agent", "searchProvider", agent?.searchProviders);
+  pushAll(output, "kay.agent", "entityResolver", agent?.entityResolvers);
+  pushAll(output, "kay.agent", "agentRenderer", agent?.renderers);
+  pushAll(output, "kay.agent", "command", agent?.commands);
+  const app = manifest.targets?.kay?.app?.contributes;
+  pushAll(output, "kay.app", "tool", app?.tools);
+  pushAll(output, "kay.app", "endpoint", app?.endpoints);
+  pushAll(output, "kay.app", "uriModule", app?.uriModules);
+  pushAll(output, "kay.app", "appDataSource", app?.dataSources);
+  pushAll(output, "kay.app", "whiteboardType", app?.whiteboardTypes);
+  pushAll(output, "kay.app", "command", app?.commands);
+  pushAll(output, "kay.app", "eventDefinition", app?.eventDefinitions);
+  pushAll(output, "kay.app", "eventSubscription", app?.eventSubscriptions);
+  pushAll(output, "kay.app", "deviceDelegation", app?.deviceDelegations);
+  pushAll(output, "kay.app", "corpusConsumer", app?.corpusConsumers);
+  pushAll(output, "kay.app", "contextContributor", app?.contextContributors);
+  pushAll(output, "kay.app", "mcpServer", app?.mcpServers && Object.keys(app.mcpServers).map((name) => ({ localId: name })));
+  const ui = manifest.targets?.kay?.ui?.contributes;
+  pushAll(output, "kay.ui", "uiCommand", ui?.commands);
+  pushAll(output, "kay.ui", "uiSlot", ui?.slots);
+  pushAll(output, "kay.ui", "settingsPanel", ui?.settingsPanels);
+  pushAll(output, "kay.ui", "resultRenderer", ui?.resultRenderers);
+  pushAll(output, "kay.ui", "referencePresentation", ui?.referencePresentations);
+  pushAll(output, "kay.ui", "view", ui?.views);
+  pushAll(output, "kay.ui", "app", ui?.apps);
+  pushAll(output, "kay.ui", "theme", ui?.themes);
+  pushAll(output, "kay.ui", "eventSubscription", ui?.eventSubscriptions);
+  pushAll(output, "kay.app", "authService", manifest.auth?.services);
+  if (manifest.storage?.sqlite?.enabled) {
+    output.push({
+      target: "kay.app",
+      kind: "storage",
+      localId: resolveStorageContributionLocalId("sqlite")
+    });
+  }
+  if (manifest.storage?.dataDir?.enabled) {
+    output.push({
+      target: "kay.app",
+      kind: "storage",
+      localId: resolveStorageContributionLocalId("dataDir")
+    });
+  }
+  for (const section of configSectionKeysForManifest(manifest)) {
+    output.push({
+      target: "kay.app",
+      kind: "configSection",
+      localId: resolveConfigSectionContributionLocalId(section)
+    });
+  }
+  return output;
+}
+function resolveGrantSet(namespace, targetGrants) {
+  const result = {};
+  if (targetGrants?.auth) {
+    result.auth = targetGrants.auth.map((grant) => {
+      const serviceOwnerNamespace = isQualifiedAuthServiceRef(grant.service) ? PluginNamespace.parse(grant.service.slice(0, grant.service.lastIndexOf("."))) : namespace;
+      return {
+        ...grant,
+        // A qualified ref already names another plugin's global id and is kept
+        // as-is; only a local ref is minted under this plugin's own namespace.
+        service: isQualifiedAuthServiceRef(grant.service) ? grant.service : resolveGlobalContributionId(namespace, grant.service),
+        ...grant.schemes === void 0 ? {} : {
+          schemes: grant.schemes.map((scheme) => isQualifiedAuthSchemeRef(scheme) ? scheme : resolveGlobalContributionId(serviceOwnerNamespace, scheme))
+        },
+        accountSelectors: grant.accountSelectors ?? narrowestAccountSelectors()
+      };
+    });
+  }
+  if (targetGrants?.storage) {
+    result.storage = targetGrants.storage;
+  }
+  if (targetGrants?.events) {
+    result.events = targetGrants.events;
+  }
+  if (targetGrants?.endpoints) {
+    result.endpoints = targetGrants.endpoints.map((grant) => ({
+      ...grant,
+      endpoint: resolveGlobalContributionId(namespace, grant.endpoint)
+    }));
+  }
+  if (targetGrants?.webSession) {
+    result.webSession = targetGrants.webSession;
+  }
+  if (targetGrants?.knowledgeSearch) {
+    result.knowledgeSearch = targetGrants.knowledgeSearch;
+  }
+  if (targetGrants?.knownResources) {
+    result.knownResources = targetGrants.knownResources;
+  }
+  return result;
+}
+function hasAnyGrant(set) {
+  return Object.values(set).some((value) => Array.isArray(value) && value.length > 0);
+}
+function collectConsumedAuthServiceIds(manifest) {
+  const output = /* @__PURE__ */ new Set();
+  const add = (ref) => {
+    if (ref && isQualifiedAuthServiceRef(ref))
+      output.add(ref);
+  };
+  for (const module of manifest.targets?.kay?.agent?.contributes?.uriModules ?? []) {
+    add(module.authService);
+  }
+  for (const binding of manifest.targets?.kay?.agent?.contributes?.cliBindings ?? []) {
+    add(binding.authService);
+  }
+  for (const target of KAY_PLUGIN_TARGET_NAMES) {
+    for (const grant of manifest.permissions?.byTarget[target]?.auth ?? []) {
+      add(grant.service);
+    }
+  }
+  return Array.from(output);
+}
+function resolveAuthServices(namespace, manifest) {
+  const seenSchemeIds = /* @__PURE__ */ new Map();
+  return (manifest.auth?.services ?? []).map((service) => ({
+    localId: service.localId,
+    globalId: resolveGlobalContributionId(namespace, service.localId),
+    displayName: service.displayName,
+    purposes: [...service.purposes],
+    ...service.webSession === void 0 ? {} : {
+      webSession: {
+        importance: service.webSession.importance,
+        loginUrl: service.webSession.loginUrl,
+        cookieDomains: [...service.webSession.cookieDomains],
+        probe: {
+          url: service.webSession.probe.url,
+          // Absent means GET; resolved carries the applied default so no
+          // downstream consumer re-defaults it.
+          method: service.webSession.probe.method ?? "GET",
+          signedInStatuses: [...service.webSession.probe.signedInStatuses]
+        },
+        oauthVenue: service.webSession.oauthVenue
+      }
+    },
+    schemes: service.schemes.map((scheme) => {
+      const globalId = resolveGlobalContributionId(namespace, scheme.localId);
+      const owner = seenSchemeIds.get(globalId);
+      if (owner !== void 0) {
+        throw new KayPluginContractResolutionError(owner === service.localId ? `duplicate resolved auth scheme id ${globalId} declared twice by service ${service.localId}` : `duplicate resolved auth scheme id ${globalId} from services ${owner} and ${service.localId}`);
+      }
+      seenSchemeIds.set(globalId, service.localId);
+      const scopesField = scheme.scopes ? { scopes: [...scheme.scopes] } : {};
+      const descriptionFields = {
+        ...scheme.displayName === void 0 ? {} : { displayName: scheme.displayName },
+        ...scheme.agentHint === void 0 ? {} : { agentHint: scheme.agentHint },
+        ...scheme.summary === void 0 ? {} : { summary: scheme.summary }
+      };
+      const provisioningField = "provisioning" in scheme && scheme.provisioning !== void 0 ? {
+        provisioning: scheme.provisioning.map((requirement) => ({
+          id: requirement.id,
+          displayName: requirement.displayName,
+          description: requirement.description,
+          ...requirement.remediationUrl === void 0 ? {} : { remediationUrl: requirement.remediationUrl },
+          probe: {
+            url: requirement.probe.url,
+            method: requirement.probe.method ?? "GET",
+            verdictStatuses: [...requirement.probe.verdictStatuses],
+            ...requirement.probe.nonEmptyArrayAt === void 0 ? {} : { nonEmptyArrayAt: requirement.probe.nonEmptyArrayAt }
+          }
+        }))
+      } : {};
+      if (scheme.kind === "oauth2") {
+        return scheme.exchange === "pkce" ? {
+          localId: scheme.localId,
+          globalId,
+          kind: "oauth2",
+          exchange: "pkce",
+          clientSuppliers: scheme.clientSuppliers,
+          ...scopesField,
+          ...descriptionFields,
+          ...provisioningField
+        } : {
+          localId: scheme.localId,
+          globalId,
+          kind: "oauth2",
+          exchange: "confidential",
+          clientSuppliers: scheme.clientSuppliers ?? ["kay"],
+          ...scopesField,
+          ...descriptionFields,
+          ...provisioningField
+        };
+      }
+      return {
+        localId: scheme.localId,
+        globalId,
+        kind: scheme.kind,
+        ...scopesField,
+        ...descriptionFields,
+        ...provisioningField
+      };
+    })
+  }));
+}
+function resolveGitHostClaims(manifest, authServices) {
+  const byLocalId = new Map(authServices.map((service) => [service.localId, service]));
+  return (manifest.targets?.kay?.agent?.contributes?.gitHosts ?? []).map((claim) => {
+    const service = byLocalId.get(claim.authService);
+    if (service === void 0) {
+      throw new KayPluginContractResolutionError(`git host ${claim.host} references auth service ${claim.authService}, which this manifest does not declare`);
+    }
+    return {
+      host: claim.host,
+      authServiceId: service.globalId,
+      authSchemeIds: service.schemes.map((scheme) => scheme.globalId),
+      authServiceDisplayName: service.displayName,
+      basicAuthUser: claim.basicAuthUser
+    };
+  });
+}
+function resolveKayPluginContractV1(manifest) {
+  const namespace = resolvePluginNamespace(manifest.id, manifest.namespace);
+  const seenGlobalIds = /* @__PURE__ */ new Map();
+  const contributions = collectContributionSources(manifest).map((source) => {
+    const globalId = resolveGlobalContributionId(namespace, source.localId);
+    const existing = seenGlobalIds.get(globalId);
+    if (existing) {
+      throw new KayPluginContractResolutionError(`duplicate resolved contribution id ${globalId} from ${existing.kind} and ${source.kind}`);
+    }
+    seenGlobalIds.set(globalId, source);
+    return {
+      target: source.target,
+      kind: source.kind,
+      localId: source.localId,
+      globalId
+    };
+  });
+  const byTarget = manifest.permissions?.byTarget;
+  const grantByTarget = {
+    "kay.agent": byTarget?.["kay.agent"] ? resolveGrantSet(namespace, byTarget["kay.agent"]) : void 0,
+    "kay.app": byTarget?.["kay.app"] ? resolveGrantSet(namespace, byTarget["kay.app"]) : void 0,
+    "kay.ui": byTarget?.["kay.ui"] ? resolveGrantSet(namespace, byTarget["kay.ui"]) : void 0
+  };
+  const grants = {
+    byTarget: Object.fromEntries(Object.entries(grantByTarget).filter(([, set]) => set && hasAnyGrant(set)))
+  };
+  const kayAgentTools = manifest.targets?.kay?.agent?.contributes?.tools?.map((tool) => ({
+    localId: tool.localId,
+    globalId: resolveGlobalContributionId(namespace, tool.localId),
+    toolName: tool.toolName
+  }));
+  const kayAppTools = manifest.targets?.kay?.app?.contributes?.tools?.map((tool) => ({
+    localId: tool.localId,
+    globalId: resolveGlobalContributionId(namespace, tool.localId),
+    toolName: tool.toolName
+  }));
+  const kayAppDataSources = manifest.targets?.kay?.app?.contributes?.dataSources?.map((source) => ({
+    localId: source.localId,
+    globalId: resolveGlobalContributionId(namespace, source.localId),
+    scope: source.scope,
+    snapshot: source.snapshot,
+    change: source.change,
+    ...source.read === void 0 ? {} : { read: source.read }
+  }));
+  const kayAppWhiteboardTypes = manifest.targets?.kay?.app?.contributes?.whiteboardTypes?.map((type) => ({
+    localId: type.localId,
+    globalId: resolveGlobalContributionId(namespace, type.localId),
+    displayName: type.displayName,
+    schemaVersion: type.schemaVersion,
+    storage: type.storage,
+    valueSchema: type.valueSchema,
+    ...type.presentation === void 0 ? {} : {
+      presentation: {
+        app: resolveGlobalContributionId(namespace, type.presentation.app)
+      }
+    }
+  }));
+  const kayAppMcpServers = Object.entries(manifest.targets?.kay?.app?.contributes?.mcpServers ?? {}).map(([name, server]) => ({
+    name,
+    pluginId: manifest.id,
+    url: server.url,
+    auth: server.auth ?? "oauth",
+    ...server.authService === void 0 ? {} : {
+      authServiceId: resolveGlobalContributionId(namespace, server.authService)
+    }
+  }));
+  const kayAgentUriModules = manifest.targets?.kay?.agent?.contributes?.uriModules?.map((module) => ({
+    localId: module.localId,
+    globalId: resolveGlobalContributionId(namespace, module.localId),
+    schemes: [...module.schemes],
+    ...module.filesystemBacking === void 0 ? {} : { filesystemBacking: module.filesystemBacking },
+    ...module.verbs === void 0 ? {} : { verbs: module.verbs },
+    ...module.knownResources === void 0 ? {} : { knownResources: module.knownResources }
+  }));
+  const kayAgentArtifactUriModules = manifest.targets?.kay?.agent?.contributes?.artifactUriModules?.map((module) => ({
+    localId: module.localId,
+    globalId: resolveGlobalContributionId(namespace, module.localId),
+    scheme: module.scheme,
+    editable: module.editable ?? false,
+    listable: module.listable ?? false,
+    deletable: module.deletable ?? false,
+    appendable: module.appendable ?? false,
+    storageScope: module.storageScope ?? "session"
+  }));
+  const authServices = resolveAuthServices(namespace, manifest);
+  const kayAgentGitHostClaims = resolveGitHostClaims(manifest, authServices);
+  const kayAgentEntityResolvers = manifest.targets?.kay?.agent?.contributes?.entityResolvers?.map((resolver) => ({
+    localId: resolver.localId,
+    globalId: resolveGlobalContributionId(namespace, resolver.localId),
+    ...resolver.displayName === void 0 ? {} : { displayName: resolver.displayName },
+    uriModule: resolveGlobalContributionId(namespace, resolver.uriModule),
+    entityTypes: [...resolver.entityTypes],
+    uriHint: resolver.uriHint
+  }));
+  const kayAgentConverters = manifest.targets?.kay?.agent?.contributes?.converters?.map((converter) => ({
+    localId: converter.localId,
+    globalId: resolveGlobalContributionId(namespace, converter.localId),
+    mimeTypes: [...converter.mimeTypes],
+    ...converter.extensions ? { extensions: [...converter.extensions] } : {}
+  }));
+  const referencePresentations = manifest.targets?.kay?.ui?.contributes?.referencePresentations?.map((presentation) => ({
+    localId: presentation.localId,
+    globalId: resolveGlobalContributionId(namespace, presentation.localId),
+    uriModule: resolveGlobalContributionId(namespace, presentation.uriModule),
+    resourceKind: presentation.resourceKind,
+    open: presentation.open,
+    ...presentation.variants ? {
+      variants: Object.fromEntries(Object.entries(presentation.variants).map(([mimeType, variant]) => [mimeType, { ...variant }]))
+    } : {},
+    ...presentation.claims === void 0 ? {} : {
+      claims: presentation.claims.map((claim) => ({
+        ...claim,
+        pattern: { ...claim.pattern }
+      }))
+    }
+  }));
+  const kayUiApps = manifest.targets?.kay?.ui?.contributes?.apps?.map((app) => ({
+    localId: app.localId,
+    globalId: resolveGlobalContributionId(namespace, app.localId),
+    displayName: app.displayName,
+    ...app.description === void 0 ? {} : { description: app.description },
+    ...app.icon === void 0 ? {} : { icon: app.icon },
+    runtime: app.runtime,
+    sdk: app.sdk,
+    entrypoint: app.entrypoint,
+    ...app.styles === void 0 ? {} : { styles: [...app.styles] },
+    ...app.assets === void 0 ? {} : { assets: [...app.assets] },
+    ...app.capabilities === void 0 ? {} : {
+      capabilities: {
+        ...app.capabilities.endpoints === void 0 ? {} : {
+          endpoints: app.capabilities.endpoints.map((endpoint) => ({
+            localId: endpoint,
+            globalId: resolveGlobalContributionId(namespace, endpoint)
+          }))
+        },
+        ...app.capabilities.host === void 0 ? {} : { host: [...app.capabilities.host] }
+      }
+    }
+  }));
+  return {
+    protocol: "kay.plugin.v1",
+    pluginId: manifest.id,
+    namespace,
+    contributions,
+    consumesAuthServices: collectConsumedAuthServiceIds(manifest),
+    // Dedup preserving first-occurrence order; manifest superRefine already
+    // rejected self-references and duplicates, so this mirrors the validated array.
+    explicitDependencies: [
+      ...manifest.dependencies?.plugins ?? []
+    ],
+    authServices,
+    ...grants && Object.keys(grants.byTarget).length > 0 ? { grants } : {},
+    ...kayAgentUriModules && kayAgentUriModules.length > 0 ? { kayAgentUriModules } : {},
+    ...kayAgentArtifactUriModules && kayAgentArtifactUriModules.length > 0 ? { kayAgentArtifactUriModules } : {},
+    ...kayAgentEntityResolvers && kayAgentEntityResolvers.length > 0 ? { kayAgentEntityResolvers } : {},
+    ...kayAgentGitHostClaims.length > 0 ? { kayAgentGitHostClaims } : {},
+    ...kayAgentTools && kayAgentTools.length > 0 ? { kayAgentTools } : {},
+    ...kayAppTools && kayAppTools.length > 0 ? { kayAppTools } : {},
+    ...kayAppDataSources && kayAppDataSources.length > 0 ? { kayAppDataSources } : {},
+    ...kayAppWhiteboardTypes && kayAppWhiteboardTypes.length > 0 ? { kayAppWhiteboardTypes } : {},
+    ...kayAppMcpServers.length > 0 ? { kayAppMcpServers } : {},
+    ...kayAgentConverters && kayAgentConverters.length > 0 ? { kayAgentConverters } : {},
+    ...referencePresentations && referencePresentations.length > 0 ? { referencePresentations } : {},
+    ...kayUiApps && kayUiApps.length > 0 ? { kayUiApps } : {}
+  };
+}
+function safeResolveKayPluginContractV1(manifest) {
+  try {
+    return {
+      success: true,
+      data: resolveKayPluginContractV1(manifest)
+    };
+  } catch (error) {
+    if (error instanceof KayPluginContractResolutionError) {
+      return { success: false, error };
+    }
+    throw error;
+  }
+}
+
+// packages/plugin-protocol/dist/session-health.js
+import { z as z10 } 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 = z10.object({
+  v: z10.literal(1),
+  verdict: z10.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: z10.number().min(0).max(1).nullable(),
+  classifier: z10.enum(SESSION_HEALTH_CLASSIFIER_IDS),
+  classifier_version: z10.string().min(1).max(64),
+  judged_at: z10.number().int().nonnegative(),
+  user_entry_id: z10.string().min(1).max(256),
+  through_entry_id: z10.string().min(1).max(256),
+  usage: z10.strictObject({
+    input_tokens: z10.number().int().nonnegative(),
+    output_tokens: z10.number().int().nonnegative()
+  }).optional()
+});
+function sessionHealthPWellDecile(pWell) {
+  if (pWell === null)
+    return null;
+  return Math.min(9, Math.floor(pWell * 10));
+}
+
+// packages/plugin-protocol/dist/ui-app-package.js
+import { z as z11 } 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 = z11.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 = z11.strictObject({
+  protocol: z11.literal(KAY_UI_BUNDLE_INDEX_PROTOCOL),
+  entryPath: KayUiBundleOutputPath,
+  files: z11.array(z11.strictObject({
+    path: KayUiBundleOutputPath,
+    mediaType: NonEmptyString
+  })).min(1)
+}).superRefine((index, ctx) => {
+  const paths = /* @__PURE__ */ new Set();
+  for (const [fileIndex, file] of index.files.entries()) {
+    if (paths.has(file.path)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["files", fileIndex, "path"],
+        message: `duplicate bundle output path ${file.path}`
+      });
+    }
+    paths.add(file.path);
+  }
+  if (!paths.has(index.entryPath)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["entryPath"],
+      message: "bundle index entryPath must name an indexed file"
+    });
+  }
+});
+function parseKayUiBundleIndexV1(input) {
+  return KayUiBundleIndexV1.parse(input);
+}
+var KayUiAppPackageFile = z11.strictObject({
+  path: PackageAssetPath,
+  mediaType: NonEmptyString,
+  bytes: z11.instanceof(Uint8Array).refine((bytes) => bytes.byteLength > 0, {
+    message: "app package file bytes must not be empty"
+  })
+});
+var KayUiAppPackageV1 = z11.strictObject({
+  protocol: z11.literal(KAY_UI_APP_PACKAGE_PROTOCOL),
+  appLocalId: LocalContributionId,
+  entry: KayUiAppPackageFile,
+  styles: z11.array(KayUiAppPackageFile).optional(),
+  assets: z11.array(KayUiAppPackageFile).optional()
+}).superRefine((appPackage, ctx) => {
+  if (appPackage.entry.mediaType !== "application/javascript") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["entry", "mediaType"],
+      message: "app package entry media type must be application/javascript"
+    });
+  }
+  const seenPaths = /* @__PURE__ */ new Set();
+  const files = [
+    { file: appPackage.entry, path: ["entry", "path"] },
+    ...(appPackage.styles ?? []).map((file, index) => ({
+      file,
+      path: ["styles", index, "path"]
+    })),
+    ...(appPackage.assets ?? []).map((file, index) => ({
+      file,
+      path: ["assets", index, "path"]
+    }))
+  ];
+  for (const { file, path } of files) {
+    if (seenPaths.has(file.path)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [...path],
+        message: `duplicate app package file path ${file.path}`
+      });
+    }
+    seenPaths.add(file.path);
+  }
+});
+function parseKayUiAppPackageV1(input) {
+  return KayUiAppPackageV1.parse(input);
+}
+
+// packages/plugin-protocol/dist/whiteboard.js
+import { z as z12 } from "zod";
+var WhiteboardValue = JsonValue;
+var WhiteboardEntryEnvelope = z12.strictObject({
+  id: NonEmptyString,
+  typeId: GlobalContributionId,
+  schemaVersion: z12.number().int().positive(),
+  title: z12.string(),
+  authorSessionId: NonEmptyString.nullable()
+});
+var WhiteboardEntrySummary = z12.strictObject({
+  name: NonEmptyString,
+  entry: WhiteboardEntryEnvelope,
+  revision: NonEmptyString
+});
+var WhiteboardEntrySnapshot = WhiteboardEntrySummary.extend({
+  value: WhiteboardValue
+});
+var WhiteboardDiagnostic = z12.strictObject({
+  ruleId: NonEmptyString,
+  severity: z12.enum(["error", "warning"]),
+  message: NonEmptyString
+});
+var WhiteboardEntryInfo = z12.strictObject({
+  name: NonEmptyString,
+  revision: NonEmptyString,
+  entry: WhiteboardEntryEnvelope.optional(),
+  state: z12.enum(["available", "unavailable", "unsupported-version", "invalid"]),
+  mutable: z12.boolean(),
+  diagnostics: z12.array(z12.string())
+});
+var WhiteboardEntryInspection = WhiteboardEntryInfo.extend({
+  value: WhiteboardValue.optional(),
+  text: z12.string(),
+  truncated: z12.boolean()
+});
+var WhiteboardTypeInfo = z12.strictObject({
+  typeId: GlobalContributionId,
+  displayName: NonEmptyString,
+  schemaVersion: z12.number().int().positive(),
+  available: z12.boolean(),
+  /** A plugin-owned readonly presentation; absent types use the host fallback. */
+  presentation: z12.strictObject({
+    app: GlobalContributionId
+  }).optional()
+});
+export {
+  AGENT_RUNTIME_SESSION_CREATOR_KINDS,
+  ARTIFACT_PROVENANCE_VERSION,
+  AdapterPlacement,
+  AdapterSelectionKey,
+  AgentRenderContribution,
+  AppDataMaterializerContribution,
+  AppDataSourceContribution,
+  AppDataSourceRead,
+  AppEventSubscription,
+  AppUriModuleContribution,
+  ArtifactGenerationId,
+  ArtifactProvenanceActor,
+  ArtifactProvenanceCaptureContextSchema,
+  ArtifactProvenanceCause,
+  ArtifactProvenanceEnvelopeV1,
+  ArtifactProvenanceGap,
+  ArtifactProvenanceMutation,
+  ArtifactProvenanceOperation,
+  ArtifactProvenanceReference,
+  ArtifactProvenanceRevision,
+  ArtifactProvenanceSession,
+  ArtifactProvenanceSource,
+  ArtifactUriModuleContribution,
+  AuthAccountSelector,
+  AuthGrantOperation,
+  AuthGrantRequest,
+  AuthSchemeReference,
+  AuthScopeDefinition,
+  AuthServiceReference,
+  CliAuthEnvVarName,
+  CliBinaryName,
+  CliBindingContribution,
+  CommandContribution,
+  CommandHandler,
+  ContextContributorContribution,
+  ConverterContribution,
+  CorpusContribution,
+  DeviceDelegationContribution,
+  EndpointContribution,
+  EndpointGrantRequest,
+  EntityResolverContribution,
+  EventGrantRequest,
+  FileExtensionToken,
+  GitBasicAuthUser,
+  GitHostContribution,
+  GitHostName,
+  GlobalContributionId,
+  HttpStatusCode,
+  HttpsUrl,
+  JsonObject,
+  JsonPointer,
+  JsonSchema,
+  JsonValue,
+  KAY_APP_DATA_CHANGE_MAX_BYTES,
+  KAY_APP_DATA_READ_REQUEST_MAX_BYTES,
+  KAY_APP_DATA_READ_RESULT_MAX_BYTES,
+  KAY_APP_DATA_SNAPSHOT_MAX_BYTES,
+  KAY_EVENT_PUBLISHER_ID,
+  KAY_PLUGIN_PROTOCOL_PACKAGE_NAME,
+  KAY_PLUGIN_PROTOCOL_VERSION,
+  KAY_PLUGIN_SDK_VERSION,
+  KAY_PLUGIN_TARGET_NAMES,
+  KAY_UI_APP_PACKAGE_PROTOCOL,
+  KAY_UI_BUNDLE_INDEX_PROTOCOL,
+  KAY_UI_NATIVE_EVENT_SUBSCRIPTIONS,
+  KayAgentTargetManifest,
+  KayAppTargetManifest,
+  KayPluginContractResolutionError,
+  KayPluginManifestV1,
+  KayPluginProtocolVersion,
+  KayUiAppHostCapability,
+  KayUiAppPackageFile,
+  KayUiAppPackageV1,
+  KayUiBundleIndexV1,
+  KayUiTargetManifest,
+  KayVersionString,
+  KnowledgeSearchGrantRequest,
+  KnownResourcesGrantRequest,
+  LocalContributionId,
+  McpServerAuthMode,
+  McpServerContribution,
+  McpServerContributions,
+  McpServerUrl,
+  MimeTypeString,
+  NonEmptyString,
+  PLUGIN_CAPABILITY_SLUGS,
+  PLUGIN_NOTIFICATION_RULE_HOST_KEYS,
+  PackageAssetPath,
+  PluginAgentDefinitionPermissionRule,
+  PluginAuthManifest,
+  PluginAuthScheme,
+  PluginAuthService,
+  PluginCapabilityClaimV1,
+  PluginCapabilityDecisionV1,
+  PluginCapabilityRefusalCode,
+  PluginCapabilityRefusalLayer,
+  PluginCapabilityRefusalV1,
+  PluginCompatibilityManifest,
+  PluginConfigManifest,
+  PluginConfigScope,
+  PluginConfigSectionManifest,
+  PluginContributionKind,
+  PluginEventDefinitionContribution,
+  PluginId,
+  PluginNamespace,
+  PluginNotificationRuleContribution,
+  PluginOAuthClientSupplier,
+  PluginPermissionManifest,
+  PluginProvisioningProbe,
+  PluginProvisioningRequirement,
+  PluginSkillSourceDeclaration,
+  PluginSourceClass,
+  PluginStorageManifest,
+  PluginTargetName,
+  PluginToolName,
+  PluginWebSessionDeclaration,
+  PluginWebSessionProbe,
+  RETIRED_COMPATIBILITY_KEYS,
+  RETIRED_PERMISSION_ASK_KEYS,
+  RETIRED_WEB_SESSION_ROW_KEYS,
+  ReferenceOpenBehavior,
+  ReferencePresentationContribution,
+  ReferencePresentationUrlClaim,
+  ReferencePresentationVariant,
+  ReferencePresentationVariants,
+  RegistrableDomain,
+  ResolvedAuthGrantRequest,
+  ResolvedEndpointGrantRequest,
+  ResolvedKayAgentArtifactUriModule,
+  ResolvedKayAgentConverter,
+  ResolvedKayAgentEntityResolver,
+  ResolvedKayAgentGitHostClaim,
+  ResolvedKayAgentTool,
+  ResolvedKayAgentUriModule,
+  ResolvedKayAppDataSource,
+  ResolvedKayAppMcpServer,
+  ResolvedKayAppTool,
+  ResolvedKayAppWhiteboardType,
+  ResolvedKayUiApp,
+  ResolvedKayUiAppEndpointCapability,
+  ResolvedPluginAuthScheme,
+  ResolvedPluginAuthService,
+  ResolvedPluginContractV1,
+  ResolvedPluginContributionId,
+  ResolvedPluginGrants,
+  ResolvedPluginProvisioningRequirement,
+  ResolvedPluginWebSession,
+  ResolvedReferencePresentation,
+  ResolvedTargetGrantSet,
+  ResourceContribution,
+  ResultRendererContribution,
+  RichViewContribution,
+  SEMVER_PATTERN,
+  SESSION_HEALTH_CLASSIFIER_IDS,
+  SESSION_HEALTH_CUSTOM_TYPE,
+  SESSION_HEALTH_ENTRY_NAME,
+  SESSION_HEALTH_EXTENSION_ID,
+  ScopeAlternative,
+  ScopeNeed,
+  ScopeRequirement,
+  SdkSessionDoor,
+  SearchProviderContribution,
+  SessionCausedByEvent,
+  SessionCreator,
+  SessionDefiner,
+  SessionIntent,
+  SessionProvenanceRecord,
+  SessionRelationship,
+  SettingsPanelContribution,
+  SignedInStatusCode,
+  SkillContribution,
+  StorageGrantRequest,
+  TargetEntrypoint,
+  TargetPermissionSet,
+  TargetPermissionWiring,
+  ThemeContribution,
+  ToolContribution,
+  UiAppCapabilities,
+  UiAppContribution,
+  UiCommandContribution,
+  UiEventSubscriptionContribution,
+  UiSlotContribution,
+  UriFilesystemBacking,
+  UriModuleContribution,
+  UriScheme,
+  WEB_SESSION_CSRF_SELECTOR_PATTERN,
+  WebSessionCsrfSelector,
+  WebSessionGrantRequest,
+  WhiteboardCapabilityClaimV1,
+  WhiteboardCapabilityOperation,
+  WhiteboardCapabilityScope,
+  WhiteboardDiagnostic,
+  WhiteboardEntryEnvelope,
+  WhiteboardEntryInfo,
+  WhiteboardEntryInspection,
+  WhiteboardEntrySnapshot,
+  WhiteboardEntrySummary,
+  WhiteboardTypeContribution,
+  WhiteboardTypeInfo,
+  WhiteboardTypeStorage,
+  WhiteboardValue,
+  captureArtifactProvenance,
+  captureFailedContext,
+  checkKayPluginHostCompatibility,
+  compareClaims,
+  compareSemver,
+  configSectionKeysForManifest,
+  dedupeClaims,
+  finalizeArtifactProvenanceEnvelope,
+  hasClaim,
+  hostWithinDomain,
+  isCompatible,
+  isQualifiedAuthSchemeRef,
+  isQualifiedAuthServiceRef,
+  isSupportedSemverRange,
+  kayUiEventSubscriptionsFromManifest,
+  mintOperation,
+  normalizeNetworkConnectHost,
+  parseArtifactProvenanceCaptureContext,
+  parseArtifactProvenanceEnvelope,
+  parseKayPluginManifestV1,
+  parseKayUiAppPackageV1,
+  parseKayUiBundleIndexV1,
+  parseResolvedPluginContractV1,
+  parseSemver,
+  precedingPersonMessages,
+  refineWebSessionScopeConfined,
+  resolveAdapterId,
+  resolveGlobalContributionId,
+  resolveKayPluginContractV1,
+  resolvePluginEventType,
+  resolvePluginNamespace,
+  resolveSessionAncestry,
+  retiredCompatibilityKeysIn,
+  retiredPermissionAsksIn,
+  safeResolveKayPluginContractV1,
+  sameClaim,
+  satisfiesSemverRange,
+  sessionHealthEntrySchema,
+  sessionHealthPWellDecile,
+  turnPacket,
+  urlHostWithinDomain,
+  validateKayUiEventSubscription,
+  webSessionPathWithinPrefix,
+  whiteboardCapabilityClaim
+};