@rizom/site-rizom-ai 0.2.0-alpha.258 → 0.2.0-alpha.260

package/dist/index.d.ts

@@ -1,22 +1,25 @@
-import { JSX, ReactNode } from "react";
-import { z } from "zod/v4";
+import { JSX, ReactElement, ReactNode } from "react";
+import { ZodRawShape, ZodType, z, z as z$1 } from "zod/v4";
+import { LibSQLDatabase } from "drizzle-orm/libsql";
+import { SQLiteColumn, SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
+import { McpServer, ToolAnnotations } from "@modelcontextprotocol/server";
 //#region ../../packages/site/src/index.d.ts
 /** Permission levels for editable site content templates. */
-type UserPermissionLevel = "admin" | "trusted" | "public";
-type JsonPrimitive = null | boolean | number | string;
-type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+type UserPermissionLevel$1 = "admin" | "trusted" | "public";
+type JsonPrimitive$1 = null | boolean | number | string;
+type JsonValue$1 = JsonPrimitive$1 | JsonValue$1[] | JsonObject$1;
 /** A JSON document with an object at its root. */
-interface JsonObject {
-  [key: string]: JsonValue;
+interface JsonObject$1 {
+  [key: string]: JsonValue$1;
 }
 /** Runtime script declaration attached to a content section/template. */
-interface RuntimeScript {
+interface RuntimeScript$1 {
   src: string;
   defer?: boolean;
   module?: boolean;
 }
 /** Bivariant component type for author-supplied layout components. */
-type ComponentType<P = unknown> = {
+type ComponentType$1<P = unknown> = {
   bivarianceHack(props: P): JSX.Element;
 }["bivarianceHack"];
 /** Navigation slot types exposed to authored routes and generated entity routes. */
@@ -89,11 +92,11 @@ type SiteContentFieldDefinition = SiteContentStringFieldDefinition | SiteContent
 interface SiteContentSectionDefinition {
   description: string;
   title: string;
-  layout: ComponentType<unknown>;
+  layout: ComponentType$1<unknown>;
   fields: Record<string, SiteContentFieldDefinition>;
-  requiredPermission?: UserPermissionLevel;
+  requiredPermission?: UserPermissionLevel$1;
   fullscreen?: boolean;
-  runtimeScripts?: RuntimeScript[];
+  runtimeScripts?: RuntimeScript$1[];
 }
 interface SiteContentDefinition {
   namespace: string;
@@ -103,16 +106,16 @@ interface SiteContentDefinition {
 interface SectionMeta {
   title: string;
   description: string;
-  requiredPermission?: UserPermissionLevel | undefined;
+  requiredPermission?: UserPermissionLevel$1 | undefined;
   fullscreen?: boolean | undefined;
 }
 /**
  * A schema-first content section. Its component props are inferred from the
  * same schema used by runtime validation, markdown formatting, and editing.
  */
-interface SiteSectionDefinition<S extends z.ZodType = z.ZodType<JsonObject>> extends SectionMeta {
+interface SiteSectionDefinition<S extends z$1.ZodType = z$1.ZodType<JsonObject$1>> extends SectionMeta {
   schema: S;
-  component: ComponentType<z.output<S>>;
+  component: ComponentType$1<z$1.output<S>>;
 }
 interface SiteSectionGroup {
   namespace: string;
@@ -165,12 +168,12 @@ interface SiteLayoutProps {
 }
 /** Initial section content keyed by section-group namespace and section id. */
 interface SiteContent {
-  [namespace: string]: Record<string, JsonObject>;
+  [namespace: string]: Record<string, JsonObject$1>;
 }
 /** Declarative site-package shape authored by public site packages. */
 interface SiteDefinition {
   /** Layout components keyed by name — a `default` layout is required. */
-  layouts: Record<string, ComponentType<SiteLayoutProps>>;
+  layouts: Record<string, ComponentType$1<SiteLayoutProps>>;
   /** Hand-written route definitions (home, about, etc.). */
   routes: RouteDefinitionInput[];
   /** Optional initial content validated by the corresponding section schema. */
@@ -187,28 +190,28 @@ interface SiteDefinition {
   staticAssets?: Record<string, string> | undefined;
 }
 type SiteDefinitionOverrides = { [K in keyof SiteDefinition]?: SiteDefinition[K] | undefined; };
-type Strict<Shape extends z.ZodRawShape> = z.ZodObject<Shape, z.core.$strict>;
+type Strict$2<Shape extends z$1.ZodRawShape> = z$1.ZodObject<Shape, z$1.core.$strict>;
 /**
  * Display and behavior metadata for an entity type, as a site declares it.
  * The one definition: the site-builder takes it as it is.
  */
-declare const entityDisplaySchema: Strict<{
-  label: z.ZodString;
-  pluralName: z.ZodOptional<z.ZodString>;
-  layout: z.ZodOptional<z.ZodString>;
-  paginate: z.ZodOptional<z.ZodBoolean>;
-  pageSize: z.ZodOptional<z.ZodNumber>;
-  citable: z.ZodOptional<z.ZodBoolean>;
-  navigation: z.ZodOptional<Strict<{
-    show: z.ZodOptional<z.ZodBoolean>;
-    slot: z.ZodOptional<z.ZodEnum<{
+declare const entityDisplaySchema: Strict$2<{
+  label: z$1.ZodString;
+  pluralName: z$1.ZodOptional<z$1.ZodString>;
+  layout: z$1.ZodOptional<z$1.ZodString>;
+  paginate: z$1.ZodOptional<z$1.ZodBoolean>;
+  pageSize: z$1.ZodOptional<z$1.ZodNumber>;
+  citable: z$1.ZodOptional<z$1.ZodBoolean>;
+  navigation: z$1.ZodOptional<Strict$2<{
+    show: z$1.ZodOptional<z$1.ZodBoolean>;
+    slot: z$1.ZodOptional<z$1.ZodEnum<{
       primary: "primary";
       secondary: "secondary";
     }>>;
-    priority: z.ZodOptional<z.ZodNumber>;
+    priority: z$1.ZodOptional<z$1.ZodNumber>;
   }>>;
 }>;
-type EntityDisplayEntry = z.output<typeof entityDisplaySchema>;
+type EntityDisplayEntry = z$1.output<typeof entityDisplaySchema>;
 //#endregion
 //#region src/rizom/contracts.d.ts
 interface RizomLink {
@@ -245,14 +248,14 @@ interface RizomMessageBus {
 interface RizomLogger {
   info(message: string): void;
 }
-interface DataSourceRegistry {
+interface DataSourceRegistry$1 {
   register(dataSource: unknown): void;
 }
 interface RizomSiteShell {
   getMessageBus(): RizomMessageBus;
   getLogger(): RizomLogger;
   registerTemplates(templates: Record<string, unknown>, namespace?: string): void;
-  getDataSourceRegistry(): DataSourceRegistry;
+  getDataSourceRegistry(): DataSourceRegistry$1;
 }
 interface SiteCompositionPlugin {
   readonly id: string;
@@ -349,108 +352,4345 @@ interface DividerProps {
 }
 declare const Divider: ({ className }: DividerProps) => JSX.Element;
 //#endregion
-//#region ../../shared/ui-library/src/highlighted-text.d.ts
+//#region ../../shell/entity-service/src/entity-type-classification.d.ts
+/** Plugin-owned semantic classification, independent of access and projection policy. */
+declare const entityTypeClassificationSchema: z.ZodDefault<z.ZodEnum<{
+  content: "content";
+  system: "system";
+}>>;
+type EntityTypeClassification = z.output<typeof entityTypeClassificationSchema>;
+//#endregion
+//#region ../../shell/entity-service/src/visibility.d.ts
+declare const canonicalContentVisibilitySchema: z.ZodEnum<{
+  public: "public";
+  shared: "shared";
+  restricted: "restricted";
+}>;
+type ContentVisibility = z.infer<typeof canonicalContentVisibilitySchema>;
+type RawContentVisibility = ContentVisibility | "private";
+//#endregion
+//#region ../../shell/entity-service/src/entity-grouping.d.ts
+declare const entityGroupingSchema: z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  field: z.ZodString;
+  types: z.ZodArray<z.ZodString>;
+}>;
+type EntityGrouping = z.infer<typeof entityGroupingSchema>;
+/** One ordering vocabulary, shared by the queries, the routes and the UI. */
+declare const groupingSortSchema: z.ZodEnum<{
+  "updated-desc": "updated-desc";
+  "updated-asc": "updated-asc";
+  "created-desc": "created-desc";
+  "created-asc": "created-asc";
+}>;
+declare const queryGroupingCatalogSchema: z.ZodObject<{
+  grouping: z.ZodString;
+  entityTypes: z.ZodArray<z.ZodString>;
+  visibilityScope: z.ZodOptional<typeof canonicalContentVisibilitySchema>;
+  limit: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+}>;
+declare const queryGroupingMembersSchema: z.ZodObject<{
+  grouping: z.ZodString;
+  entityTypes: z.ZodArray<z.ZodString>;
+  visibilityScope: z.ZodOptional<typeof canonicalContentVisibilitySchema>;
+  limit: z.ZodDefault<z.ZodNumber>;
+  offset: z.ZodDefault<z.ZodNumber>;
+  signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+  value: z.ZodString;
+  q: z.ZodOptional<z.ZodString>;
+  sort: z.ZodDefault<typeof groupingSortSchema>;
+}>;
+/** Usage is a distinct entry total plus counts for a bounded set of exact values. */
+declare const queryGroupingUsageSchema: z.ZodObject<{
+  grouping: z.ZodString;
+  entityTypes: z.ZodArray<z.ZodString>;
+  visibilityScope: z.ZodOptional<typeof canonicalContentVisibilitySchema>;
+  signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+  values: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}>;
+type QueryGroupingUsageRequest = z.input<typeof queryGroupingUsageSchema>;
+interface EntityGroupingUsage {
+  /** Entries with at least one text membership, including values outside a list. */
+  entries: number;
+  /** Request order and literals preserved; unused values have a zero count. */
+  values: Array<{
+    value: string;
+    count: number;
+  }>;
+}
+type QueryGroupingCatalogRequest = z.input<typeof queryGroupingCatalogSchema>;
+type QueryGroupingMembersRequest = z.input<typeof queryGroupingMembersSchema>;
+interface EntityGroupingCatalog {
+  values: Array<{
+    value: string;
+    count: number;
+  }>;
+  total: number;
+}
+//#endregion
+//#region ../../shell/entity-service/src/grouping-projection-state.d.ts
+interface GroupingProjectionTarget {
+  entityType: string;
+  field: string;
+  generation: number;
+}
+//#endregion
+//#region ../../shared/assets/src/index.d.ts
+type AssetRef = `asset://sha256/${string}`;
+interface AssetStat {
+  ref: AssetRef;
+  sizeBytes: number;
+}
+interface AssetVerification extends AssetStat {
+  expectedDigest: string;
+  actualDigest: string;
+  valid: boolean;
+}
 /**
- * Render a content string with two lightweight markup conventions:
+ * Validated, bounded bytes ready to join an entity mutation. Preparation does
+ * not write durable state; only the entity transaction may commit the bytes.
+ */
+interface PreparedAsset extends AssetRecord {
+  bytes: Uint8Array;
+}
+/** Read-only durable asset surface. There is deliberately no independent put. */
+interface AssetReader {
+  read(ref: AssetRef): Promise<Uint8Array>;
+  stat(ref: AssetRef): Promise<AssetStat | null>;
+  verify(ref: AssetRef): Promise<AssetVerification>;
+}
+declare const assetRefSchema: z.ZodCustom<AssetRef, AssetRef>;
+declare const assetRecordSchema: z.ZodObject<{
+  ref: typeof assetRefSchema;
+  digest: z.ZodString;
+  sizeBytes: z.ZodNumber;
+}>;
+type AssetRecord = z.output<typeof assetRecordSchema>;
+//#endregion
+//#region ../../shell/entity-service/src/entity-id-path.d.ts
+type EntityIdPath = [string, ...string[]];
+type EntityIdPathInput = readonly [string, ...string[]];
+//#endregion
+//#region ../../shared/contracts/src/guest-execution.d.ts
+type Strict$1<Shape extends z.ZodRawShape> = z.ZodObject<Shape, z.core.$strict>;
+/** Server-owned limits, not a browser's requested model settings. */
+declare const guestExecutionLimitsSchema: Strict$1<{
+  messageCharacters: z.ZodNumber;
+  requestTimeoutSeconds: z.ZodNumber;
+}>;
+declare const guestExecutionPolicySchema: Strict$1<{
+  limits: typeof guestExecutionLimitsSchema;
+  maxCostMicroUsd: z.ZodNumber;
+}>;
+type GuestExecutionPolicy = z.output<typeof guestExecutionPolicySchema>;
+/** What the provider reported for a guest turn, summed across its calls. */
+declare const guestTurnUsageSchema: Strict$1<{
+  modelCalls: z.ZodNumber;
+  inputTokens: z.ZodNumber;
+  cachedInputTokens: z.ZodNumber;
+  outputTokens: z.ZodNumber;
+  reasoningTokens: z.ZodNumber;
+  embeddingTokens: z.ZodNumber;
+}>;
+/**
+ * A turn's cost from provider usage at a pinned pricing revision. Computed
+ * locally, not reconciled billing; a quote is never a known cost. Missing
+ * usage or pricing the revision does not cover stays unknown.
+ */
+declare const guestTurnCostSchema: z.ZodDiscriminatedUnion<[Strict$1<{
+  state: z.ZodLiteral<"known">;
+  microUsd: z.ZodNumber;
+  pricing: z.ZodString;
+}>, Strict$1<{
+  state: z.ZodLiteral<"unknown">;
+  reason: z.ZodEnum<{
+    "missing-usage": "missing-usage";
+    "unsupported-pricing": "unsupported-pricing";
+  }>;
+}>], "state">;
+declare const guestTurnSettlementSchema: Strict$1<{
+  usage: typeof guestTurnUsageSchema;
+  cost: typeof guestTurnCostSchema;
+}>;
+/**
+ * What a guest turn screens a visitor's question against, passed in by the
+ * box's host beside its execution limits: the site's public topics as its
+ * scope, and the refusal a screened-out visitor reads, in the site's words.
+ */
+declare const guestScreeningSchema: Strict$1<{
+  topics: z.ZodArray<z.ZodString>;
+  refusal: z.ZodOptional<z.ZodString>;
+}>;
+type GuestScreening = z.output<typeof guestScreeningSchema>;
+/** The categories that refuse a question. */
+declare const guestRefusalCategorySchema: z.ZodEnum<{
+  "off-topic": "off-topic";
+  abusive: "abusive";
+  injection: "injection";
+  harmful: "harmful";
+}>;
+/**
+ * What screening did with a guest turn: answered after an in-scope judgment,
+ * refused with the category it was judged, or answered unscreened because
+ * the judgment failed.
+ */
+declare const guestScreeningOutcomeSchema: z.ZodDiscriminatedUnion<[Strict$1<{
+  outcome: z.ZodLiteral<"answered">;
+}>, Strict$1<{
+  outcome: z.ZodLiteral<"refused">;
+  category: typeof guestRefusalCategorySchema;
+}>, Strict$1<{
+  outcome: z.ZodLiteral<"unscreened">;
+}>], "outcome">;
+//#endregion
+//#region ../../shared/contracts/src/agent-response.d.ts
+type PendingConfirmationSchema = z.ZodObject<{
+  id: z.ZodString;
+  toolCallId: z.ZodOptional<z.ZodString>;
+  toolName: z.ZodString;
+  summary: z.ZodString;
+  completionSummary: z.ZodOptional<z.ZodString>;
+  preview: z.ZodOptional<z.ZodString>;
+  args: z.ZodUnknown;
+}>;
+declare const PendingConfirmationSchema: PendingConfirmationSchema;
+type ToolApprovalCardStateSchema = z.ZodEnum<{
+  "approval-requested": "approval-requested";
+  "approval-responded": "approval-responded";
+  "output-available": "output-available";
+  "output-denied": "output-denied";
+  "output-error": "output-error";
+}>;
+declare const ToolApprovalCardStateSchema: ToolApprovalCardStateSchema;
+type ToolApprovalCardSchema = z.ZodObject<{
+  kind: z.ZodLiteral<"tool-approval">;
+  id: z.ZodString;
+  toolCallId: z.ZodOptional<z.ZodString>;
+  toolName: z.ZodString;
+  input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  summary: z.ZodString;
+  completionSummary: z.ZodOptional<z.ZodString>;
+  preview: z.ZodOptional<z.ZodString>;
+  state: ToolApprovalCardStateSchema;
+  output: z.ZodOptional<z.ZodUnknown>;
+  error: z.ZodOptional<z.ZodString>;
+}>;
+declare const ToolApprovalCardSchema: ToolApprovalCardSchema;
+type AttachmentCardSourceSchema = z.ZodObject<{
+  entityType: z.ZodOptional<z.ZodString>;
+  entityId: z.ZodOptional<z.ZodString>;
+  attachmentType: z.ZodOptional<z.ZodString>;
+}>;
+declare const AttachmentCardSourceSchema: AttachmentCardSourceSchema;
+type AttachmentCardDataSchema = z.ZodObject<{
+  mediaType: z.ZodString;
+  url: z.ZodString;
+  downloadUrl: z.ZodOptional<z.ZodString>;
+  previewUrl: z.ZodOptional<z.ZodString>;
+  filename: z.ZodOptional<z.ZodString>;
+  sizeBytes: z.ZodOptional<z.ZodNumber>;
+  source: z.ZodOptional<AttachmentCardSourceSchema>;
+}>;
+declare const AttachmentCardDataSchema: AttachmentCardDataSchema;
+type AttachmentCardSchema = z.ZodObject<{
+  kind: z.ZodLiteral<"attachment">;
+  id: z.ZodString;
+  jobId: z.ZodOptional<z.ZodString>;
+  title: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  attachment: AttachmentCardDataSchema;
+}>;
+declare const AttachmentCardSchema: AttachmentCardSchema;
+type SourceCitationSchema = z.ZodObject<{
+  id: z.ZodString;
+  title: z.ZodOptional<z.ZodString>;
+  source: z.ZodString;
+  url: z.ZodOptional<z.ZodString>;
+  entityType: z.ZodOptional<z.ZodString>;
+  entityId: z.ZodOptional<z.ZodString>;
+  excerpt: z.ZodOptional<z.ZodString>;
+  provenance: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+declare const SourceCitationSchema: SourceCitationSchema;
+type SourcesCardSchema = z.ZodObject<{
+  kind: z.ZodLiteral<"sources">;
+  id: z.ZodString;
+  title: z.ZodOptional<z.ZodString>;
+  sources: z.ZodArray<SourceCitationSchema>;
+}>;
+declare const SourcesCardSchema: SourcesCardSchema;
+type PromptChatActionSchema = z.ZodObject<{
+  type: z.ZodLiteral<"prompt">;
+  id: z.ZodString;
+  label: z.ZodString;
+  prompt: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}>;
+declare const PromptChatActionSchema: PromptChatActionSchema;
+type EventChatActionSchema = z.ZodObject<{
+  type: z.ZodLiteral<"event">;
+  id: z.ZodString;
+  label: z.ZodString;
+  event: z.ZodString;
+  fromState: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+}>;
+declare const EventChatActionSchema: EventChatActionSchema;
+type ChatActionSchema = z.ZodDiscriminatedUnion<[PromptChatActionSchema, EventChatActionSchema]>;
+declare const ChatActionSchema: ChatActionSchema;
+type ActionsCardSchema = z.ZodObject<{
+  kind: z.ZodLiteral<"actions">;
+  id: z.ZodString;
+  title: z.ZodOptional<z.ZodString>;
+  defaultOpen: z.ZodOptional<z.ZodBoolean>;
+  actions: z.ZodArray<ChatActionSchema>;
+}>;
+declare const ActionsCardSchema: ActionsCardSchema;
+type StructuredChatCardSchema = z.ZodDiscriminatedUnion<[ToolApprovalCardSchema, AttachmentCardSchema, SourcesCardSchema, ActionsCardSchema]>;
+declare const StructuredChatCardSchema: StructuredChatCardSchema;
+type ToolResultErrorDataSchema = z.ZodObject<{
+  message: z.ZodString;
+  code: z.ZodOptional<z.ZodString>;
+}>;
+type ToolResultDataSchema = z.ZodObject<{
+  toolName: z.ZodString;
+  args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  jobId: z.ZodOptional<z.ZodString>;
+  data: z.ZodOptional<z.ZodUnknown>;
+  error: z.ZodOptional<ToolResultErrorDataSchema>;
+}>;
+declare const ToolResultDataSchema: ToolResultDataSchema;
+type AgentResponseUsageSchema = z.ZodObject<{
+  promptTokens: z.ZodNumber;
+  completionTokens: z.ZodNumber;
+  totalTokens: z.ZodNumber;
+}>;
+type AgentResponseSchema = z.ZodObject<{
+  text: z.ZodString;
+  error: z.ZodOptional<z.ZodString>;
+  toolResults: z.ZodOptional<z.ZodArray<ToolResultDataSchema>>;
+  cards: z.ZodOptional<z.ZodArray<StructuredChatCardSchema>>;
+  pendingConfirmations: z.ZodOptional<z.ZodArray<PendingConfirmationSchema>>;
+  usage: AgentResponseUsageSchema;
+  guestSettlement: z.ZodOptional<typeof guestTurnSettlementSchema>;
+  guestScreening: z.ZodOptional<typeof guestScreeningOutcomeSchema>;
+}>;
+declare const AgentResponseSchema: AgentResponseSchema;
+type AgentResponse = z.output<typeof AgentResponseSchema>;
+//#endregion
+//#region ../../shared/contracts/src/actor-ref.d.ts
+type ActorRefSchema = z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"user">;
+  userId: z.ZodString;
+  canonicalId: z.ZodOptional<z.ZodString>;
+}>, z.ZodObject<{
+  kind: z.ZodLiteral<"external">;
+  externalActorId: z.ZodString;
+}>, z.ZodObject<{
+  kind: z.ZodLiteral<"agent">;
+  agentId: z.ZodString;
+}>, z.ZodObject<{
+  kind: z.ZodLiteral<"service">;
+  serviceId: z.ZodString;
+}>]>;
+declare const actorRefSchema: ActorRefSchema;
+type ActorRef = z.output<typeof actorRefSchema>;
+//#endregion
+//#region ../../shared/contracts/src/interface-principal.d.ts
+interface InterfacePrincipalGrantState {
+  interfaceType: string;
+  principalKeyHash: string;
+  permissionLevel: "admin" | "trusted";
+}
+interface InterfaceAnchorBindingState {
+  interfaceType: string;
+  principalKeyHash: string;
+}
+interface RuntimeInterfacePrincipalState {
+  grants: InterfacePrincipalGrantState[];
+  anchors: InterfaceAnchorBindingState[];
+}
+//#endregion
+//#region ../../shared/contracts/src/json.d.ts
+type JsonPrimitive = null | boolean | number | string;
+type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+/** A JSON document with an object at its root. */
+interface JsonObject {
+  [key: string]: JsonValue;
+}
+//#endregion
+//#region ../../shared/contracts/src/message-role.d.ts
+type MessageRoleSchema = z.ZodEnum<{
+  user: "user";
+  assistant: "assistant";
+}>;
+declare const messageRoleSchema: MessageRoleSchema;
+/** Canonical role of a stored conversation message. */
+type MessageRole = z.output<typeof messageRoleSchema>;
+//#endregion
+//#region ../../shared/contracts/src/operation-provenance.d.ts
+type ProvenanceEntityReferenceSchema = z.ZodObject<{
+  entityType: z.ZodString;
+  entityId: z.ZodString;
+  contentHash: z.ZodOptional<z.ZodString>;
+}>;
+declare const ProvenanceEntityReferenceSchema: ProvenanceEntityReferenceSchema;
+type ProvenanceEntityReference = z.output<typeof ProvenanceEntityReferenceSchema>;
+type OperationProvenanceSchema = z.ZodObject<{
+  rootJobId: z.ZodString;
+  causationId: z.ZodString;
+  projectionId: z.ZodOptional<z.ZodString>;
+  projectionLineage: z.ZodArray<z.ZodString>;
+  sourceEntity: z.ZodOptional<ProvenanceEntityReferenceSchema>;
+  derivationDepth: z.ZodNumber;
+}>;
+declare const OperationProvenanceSchema: OperationProvenanceSchema;
+//#endregion
+//#region ../../shared/contracts/src/publish-types.d.ts
+type PublishMediaData = {
+  type: "document";
+  data: Buffer;
+  mimeType: "application/pdf";
+  filename: string;
+} | {
+  type: "image";
+  data: Buffer;
+  mimeType: "image/png";
+  filename: string;
+};
+//#endregion
+//#region ../../shared/contracts/src/response-types.d.ts
+/**
+ * Query response schemas used throughout the system
+ */
+type DefaultQuerySourceSchema = z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodString;
+  excerpt: z.ZodOptional<z.ZodString>;
+  relevance: z.ZodOptional<z.ZodNumber>;
+}>;
+type DefaultQueryResponseSchema = z.ZodObject<{
+  message: z.ZodString;
+  summary: z.ZodOptional<z.ZodString>;
+  topics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  sources: z.ZodOptional<z.ZodArray<DefaultQuerySourceSchema>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+declare const defaultQueryResponseSchema: DefaultQueryResponseSchema;
+type DefaultQueryResponse = z.output<typeof defaultQueryResponseSchema>;
+//#endregion
+//#region ../../shared/db/src/sqlite.d.ts
+type SqliteDatabase = LibSQLDatabase<Record<string, unknown>>;
+//#endregion
+//#region ../../shared/utils/src/logger.d.ts
+/**
+ * What a logger provides to callers.
  *
- * - `\n` in the string produces a `<br />` (for multi-line headlines)
- * - Any `*...*` run is wrapped in a `<span>` carrying `highlightClass`
+ * Consumers depend on this rather than on `ConsoleLogger`. The class carries
+ * private fields and a private constructor, so nothing else can be assignable
+ * to it — which is why every test double had to be asserted into place, a cast
+ * that also erased the check on the members the double did define.
+ */
+interface Logger {
+  silly(message: string, ...args: unknown[]): void;
+  verbose(message: string, ...args: unknown[]): void;
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  child(context: string): Logger;
+  setUseStderr(useStderr: boolean): void;
+}
+//#endregion
+//#region ../../shared/db/src/sqlite-columns.d.ts
+/**
+ * Drizzle column annotation aliases for exported SQLite tables.
  *
- * Authors write the phrase as one natural string in markdown content;
- * the renderer does the structural split. Highlight styling is passed
- * per-brand (rizom.ai uses accent+midline, professional uses italic+accent)
- * so each consumer owns its own emphasis treatment while the parsing/
- * structure is shared.
+ * `isolatedDeclarations` requires exported table constants to carry explicit
+ * types, and drizzle's inferred column types are internal `SQLiteColumn`
+ * config objects. Before this module, every DB-owning package hand-wrote the
+ * same sixteen-key config literal per column kind; these aliases are that
+ * literal written once, with every axis the schemas actually vary on exposed
+ * as a parameter.
+ *
+ * Schema files keep short local aliases binding their table name (and any
+ * fixed axes) so the table declarations below them stay readable.
  */
-declare function renderHighlightedText(text: string, highlightClass: string): JSX.Element;
+type SqliteTextColumn<TTableName extends string, TName extends string, TNotNull extends boolean, THasDefault extends boolean = false, TPrimaryKey extends boolean = false, THasRuntimeDefault extends boolean = false, TData = string, TEnumValues extends [string, ...string[]] = [string, ...string[]]> = SQLiteColumn<{
+  name: TName;
+  tableName: TTableName;
+  dataType: "string";
+  columnType: "SQLiteText";
+  data: TData;
+  driverParam: string;
+  notNull: TNotNull;
+  hasDefault: THasDefault;
+  isPrimaryKey: TPrimaryKey;
+  isAutoincrement: false;
+  hasRuntimeDefault: THasRuntimeDefault;
+  enumValues: TEnumValues;
+  baseColumn: never;
+  identity: undefined;
+  generated: undefined;
+}, Record<string, never>, {
+  length: number | undefined;
+}>;
+type SqliteIntegerColumn<TTableName extends string, TName extends string, TNotNull extends boolean, THasDefault extends boolean = false, THasRuntimeDefault extends boolean = false, TPrimaryKey extends boolean = false, TAutoincrement extends boolean = false, TData = number> = SQLiteColumn<{
+  name: TName;
+  tableName: TTableName;
+  dataType: "number";
+  columnType: "SQLiteInteger";
+  data: TData;
+  driverParam: number;
+  notNull: TNotNull;
+  hasDefault: THasDefault;
+  isPrimaryKey: TPrimaryKey;
+  isAutoincrement: TAutoincrement;
+  hasRuntimeDefault: THasRuntimeDefault;
+  enumValues: undefined;
+  baseColumn: never;
+  identity: undefined;
+  generated: undefined;
+}, Record<string, never>, Record<string, never>>;
+type SqliteJsonColumn<TTableName extends string, TName extends string, TData, TNotNull extends boolean, TExtraConfig extends object = Record<string, never>, THasDefault extends boolean = false> = SQLiteColumn<{
+  name: TName;
+  tableName: TTableName;
+  dataType: "json";
+  columnType: "SQLiteTextJson";
+  data: TData;
+  driverParam: string;
+  notNull: TNotNull;
+  hasDefault: THasDefault;
+  isPrimaryKey: false;
+  isAutoincrement: false;
+  hasRuntimeDefault: false;
+  enumValues: undefined;
+  baseColumn: never;
+  identity: undefined;
+  generated: undefined;
+}, Record<string, never>, TExtraConfig>;
 //#endregion
-//#region src/rizom/ui/site-info-links.d.ts
-declare function socialLinksToRizomLinks(siteInfo: Pick<SiteLayoutInfo, "socialLinks">, allowedPlatforms?: string[]): RizomLink[];
+//#region ../../shell/entity-service/src/db/index.d.ts
+type EntityDB = SqliteDatabase;
 //#endregion
-//#region src/rizom/ui/Wordmark.d.ts
-interface WordmarkProps {
-  /** Brand name before the dot. Defaults to `"rizom"`. */
-  name?: string;
-  /** Suffix after the dot. Any string (e.g. `"ai"`, `"io"`, `"foundation"`). */
-  brandSuffix: RizomBrandSuffix | string;
-  className?: string;
-  dotClassName?: string;
-  suffixClassName?: string;
+//#region ../../shell/entity-service/src/mutation-admission.d.ts
+interface EntityMutationAdmissionTarget {
+  operation: "create" | "update" | "delete";
+  entityType: string;
+  entityId: string;
+}
+interface EntityMutationAdmission {
+  assertMutationAdmission(target: EntityMutationAdmissionTarget): Promise<void>;
 }
-declare const Wordmark: ({ name, brandSuffix, className, dotClassName, suffixClassName }: WordmarkProps) => JSX.Element;
 //#endregion
-//#region src/rizom/ui/Ecosystem.d.ts
-interface EcosystemCard {
-  suffix: RizomBrandSuffix;
-  title: string;
-  body: string;
-  linkLabel: string;
-  linkHref: string;
+//#region ../../shell/entity-service/src/projection-batch-contracts.d.ts
+interface BulkMutationInput {
+  source: string;
+  operationId: string;
 }
-interface EcosystemContent {
-  eyebrow: string;
-  headline: string;
-  cards: EcosystemCard[];
+interface DurableBulkMutationRootInput extends BulkMutationInput {
+  rootJobId: string;
+  expectedChildren: number;
+}
+interface DurableBulkMutationChildInput extends DurableBulkMutationRootInput {
+  childKey: string;
+  jobId: string;
+}
+interface SettleDurableBulkMutationChildInput {
+  operationId: string;
+  childKey: string;
+  jobId: string;
+  outcome: "completed" | "failed";
+}
+interface ProjectionBatchOwnedJob {
+  jobId: string;
+  childKey: string;
+  status: "pending" | "processing" | "completed" | "failed";
+  terminalAt: number | null;
+}
+type ProjectionBatchRootReader = (rootJobId: string, operationId: string) => Promise<readonly ProjectionBatchOwnedJob[]>;
+interface ProjectionBatchRecoveryResult {
+  fencedCallbacks: number;
+  releasedDurableRoots: number;
 }
-declare const Ecosystem: ({ eyebrow, headline, cards }: EcosystemContent) => JSX.Element;
 //#endregion
-//#region src/rizom/runtime/default-layout.d.ts
-declare const DefaultRizomLayout: ({ sections }: RizomLayoutProps) => JSX.Element;
+//#region ../../shell/entity-service/src/projection-transaction-runner.d.ts
+type EntityTransaction = Parameters<Parameters<EntityDB["transaction"]>[0]>[0];
 //#endregion
-//#region src/rizom/runtime/base-site.d.ts
-declare const rizomBaseSite: SiteDefinition;
+//#region ../../shell/entity-service/src/projection-batch-coordinator.d.ts
+interface ProjectionBatchDiagnostics {
+  preparing: number;
+  open: number;
+  abandoned: number;
+  expiredCallbackLeases: number;
+  oldestActiveAgeMs: number | null;
+  oldestProgressAgeMs: number | null;
+}
 //#endregion
-//#region src/rizom/create-site.d.ts
-interface RizomRuntimeHooks {
-  contentNamespace: string;
-  templates?: Record<string, unknown>;
-  dataSources?: unknown[];
+//#region ../../shell/entity-service/src/projection-contracts.d.ts
+type ProjectionJsonObject = JsonObject;
+interface ProjectionEntityWrite<TMetadata extends ProjectionJsonObject = ProjectionJsonObject> {
+  id: string;
+  entityType: string;
+  content: string;
+  metadata: TMetadata;
+  visibility: ContentVisibility;
 }
-interface CreateRizomSiteOptions {
-  packageName: string;
-  layout: unknown;
-  routes: RouteDefinitionInput[];
-  content?: SiteContent;
+type ProjectionWriteIntent<TMetadata extends ProjectionJsonObject = ProjectionJsonObject> = {
+  operation: "upsert";
+  entity: ProjectionEntityWrite<TMetadata>;
+} | {
+  operation: "delete";
+  entityType: string;
+  id: string;
+};
+//#endregion
+//#region ../../shell/entity-service/src/schema/projection-state.d.ts
+type ProjectionTextColumn<TTable extends string, TName extends string, TNotNull extends boolean, THasDefault extends boolean = false, TPrimaryKey extends boolean = false, TData = string, TEnumValues extends [string, ...string[]] = [string, ...string[]]> = SqliteTextColumn<TTable, TName, TNotNull, THasDefault, TPrimaryKey, false, TData, TEnumValues>;
+type ProjectionIntegerColumn<TTable extends string, TName extends string, TNotNull extends boolean, THasDefault extends boolean = false, TPrimaryKey extends boolean = false, TAutoincrement extends boolean = false> = SqliteIntegerColumn<TTable, TName, TNotNull, THasDefault, false, TPrimaryKey, TAutoincrement>;
+type ProjectionJsonColumn<TTable extends string, TName extends string, TData, THasDefault extends boolean = false> = SqliteJsonColumn<TTable, TName, TData, true, {
+  $type: TData;
+}, THasDefault>;
+type ProjectionDirtyInputsTable = SQLiteTableWithColumns<{
+  name: "projection_dirty_inputs";
+  schema: undefined;
+  columns: {
+    generation: ProjectionIntegerColumn<"projection_dirty_inputs", "generation", true, true, true>;
+    sourceType: ProjectionTextColumn<"projection_dirty_inputs", "source_type", true>;
+    sourceId: ProjectionTextColumn<"projection_dirty_inputs", "source_id", true>;
+    revision: ProjectionTextColumn<"projection_dirty_inputs", "revision", true>;
+    operation: ProjectionTextColumn<"projection_dirty_inputs", "operation", true, false, false, "upsert" | "delete", ["upsert", "delete"]>;
+    markedAt: ProjectionIntegerColumn<"projection_dirty_inputs", "marked_at", true>;
+  };
+  dialect: "sqlite";
+}>;
+type ProjectionWavesTable = SQLiteTableWithColumns<{
+  name: "projection_waves";
+  schema: undefined;
+  columns: {
+    id: ProjectionTextColumn<"projection_waves", "id", true, false, true>;
+    cutoffGeneration: ProjectionIntegerColumn<"projection_waves", "cutoff_generation", true>;
+    graphFingerprint: ProjectionTextColumn<"projection_waves", "graph_fingerprint", true>;
+    admissionEpoch: ProjectionIntegerColumn<"projection_waves", "admission_epoch", true, true>;
+    status: ProjectionTextColumn<"projection_waves", "status", true, false, false, "running" | "completed" | "failed" | "superseded", ["running", "completed", "failed", "superseded"]>;
+    startedAt: ProjectionIntegerColumn<"projection_waves", "started_at", true>;
+    completedAt: ProjectionIntegerColumn<"projection_waves", "completed_at", false>;
+  };
+  dialect: "sqlite";
+}>;
+type ProjectionIncidentsTable = SQLiteTableWithColumns<{
+  name: "projection_incidents";
+  schema: undefined;
+  columns: {
+    waveId: ProjectionTextColumn<"projection_incidents", "wave_id", true, false, true>;
+    ruleId: ProjectionTextColumn<"projection_incidents", "rule_id", true>;
+    jobId: ProjectionTextColumn<"projection_incidents", "job_id", false>;
+    failureReason: ProjectionTextColumn<"projection_incidents", "failure_reason", true>;
+    recoveryGeneration: ProjectionIntegerColumn<"projection_incidents", "recovery_generation", true>;
+    createdAt: ProjectionIntegerColumn<"projection_incidents", "created_at", true>;
+    resolvedAt: ProjectionIntegerColumn<"projection_incidents", "resolved_at", false>;
+  };
+  dialect: "sqlite";
+}>;
+type ProjectionWaveInputsTable = SQLiteTableWithColumns<{
+  name: "projection_wave_inputs";
+  schema: undefined;
+  columns: {
+    waveId: ProjectionTextColumn<"projection_wave_inputs", "wave_id", true>;
+    sourceType: ProjectionTextColumn<"projection_wave_inputs", "source_type", true>;
+    sourceId: ProjectionTextColumn<"projection_wave_inputs", "source_id", true>;
+    revision: ProjectionTextColumn<"projection_wave_inputs", "revision", true>;
+    operation: ProjectionTextColumn<"projection_wave_inputs", "operation", true, false, false, "upsert" | "delete", ["upsert", "delete"]>;
+    generation: ProjectionIntegerColumn<"projection_wave_inputs", "generation", true>;
+  };
+  dialect: "sqlite";
+}>;
+interface ProjectionChangedTarget {
+  entityType: string;
+  entityId: string;
+  operation: "upsert" | "delete";
+  contentHash?: string | undefined;
+}
+type ProjectionWaveRulesTable = SQLiteTableWithColumns<{
+  name: "projection_wave_rules";
+  schema: undefined;
+  columns: {
+    waveId: ProjectionTextColumn<"projection_wave_rules", "wave_id", true>;
+    ruleId: ProjectionTextColumn<"projection_wave_rules", "rule_id", true>;
+    targetType: ProjectionTextColumn<"projection_wave_rules", "target_type", true>;
+    level: ProjectionIntegerColumn<"projection_wave_rules", "level", true>;
+    jobId: ProjectionTextColumn<"projection_wave_rules", "job_id", false>;
+    status: ProjectionTextColumn<"projection_wave_rules", "status", true, false, false, "pending" | "queued" | "completed" | "failed", ["pending", "queued", "completed", "failed"]>;
+    inputFingerprint: ProjectionTextColumn<"projection_wave_rules", "input_fingerprint", false>;
+    changedTargets: ProjectionJsonColumn<"projection_wave_rules", "changed_targets", ProjectionChangedTarget[], true>;
+  };
+  dialect: "sqlite";
+}>;
+type ProjectionRuleMemosTable = SQLiteTableWithColumns<{
+  name: "projection_rule_memos";
+  schema: undefined;
+  columns: {
+    ruleId: ProjectionTextColumn<"projection_rule_memos", "rule_id", true>;
+    ruleVersion: ProjectionTextColumn<"projection_rule_memos", "rule_version", true>;
+    inputFingerprint: ProjectionTextColumn<"projection_rule_memos", "input_fingerprint", true>;
+    writeIntents: ProjectionJsonColumn<"projection_rule_memos", "write_intents", ProjectionWriteIntent[]>;
+    createdAt: ProjectionIntegerColumn<"projection_rule_memos", "created_at", true>;
+  };
+  dialect: "sqlite";
+}>;
+declare const projectionDirtyInputs: ProjectionDirtyInputsTable;
+declare const projectionWaves: ProjectionWavesTable;
+declare const projectionIncidents: ProjectionIncidentsTable;
+declare const projectionWaveInputs: ProjectionWaveInputsTable;
+declare const projectionWaveRules: ProjectionWaveRulesTable;
+declare const projectionRuleMemos: ProjectionRuleMemosTable;
+type ProjectionDirtyInput = typeof projectionDirtyInputs.$inferSelect;
+type ProjectionIncident = typeof projectionIncidents.$inferSelect;
+type ProjectionWave = typeof projectionWaves.$inferSelect;
+type ProjectionWaveInput = typeof projectionWaveInputs.$inferSelect;
+type ProjectionWaveRule = typeof projectionWaveRules.$inferSelect;
+type ProjectionRuleMemo = typeof projectionRuleMemos.$inferSelect;
+//#endregion
+//#region ../../shell/entity-service/src/projection-rule-contracts.d.ts
+interface GetProjectionRuleMemoInput {
+  ruleId: string;
+  ruleVersion: string;
+  inputFingerprint: string;
+}
+interface ProjectionWaveRuleInput {
+  ruleId: string;
+  targetType: string;
+  level: number;
+}
+interface ApplyProjectionRuleResultInput {
+  waveId: string;
+  ruleId: string;
+  ruleVersion: string;
+  inputFingerprint: string;
+  writeIntents: readonly ProjectionWriteIntent[];
+  completedAt: number;
+}
+interface ProjectionRuleMemoValue extends Omit<ProjectionRuleMemo, "writeIntents"> {
+  writeIntents: ProjectionWriteIntent[];
+}
+//#endregion
+//#region ../../shell/entity-service/src/projection-wave-contracts.d.ts
+interface ProjectionIncidentDiagnostics {
+  total: number;
+  incidents: ProjectionIncident[];
+}
+interface ClaimProjectionWaveInput {
+  waveId: string;
+  graphFingerprint: string;
+  startedAt: number;
+}
+interface ProjectionIncidentInput {
+  waveId: string;
+  ruleId: string;
+  jobId: string | null;
+  failureReason: string;
+  failedAt: number;
+}
+//#endregion
+//#region ../../shell/entity-service/src/entity-export-types.d.ts
+interface EntityExportIntent {
+  entityType: string;
+  entityId: string;
+  operation: "upsert" | "delete";
+  revision: string;
+  markedAt: number;
+}
+interface EntityExportAcknowledgement {
+  entityType: string;
+  entityId: string;
+  revision: string;
+}
+interface AcknowledgeEntityExportsRequest {
+  intents: readonly EntityExportAcknowledgement[];
+}
+//#endregion
+//#region ../../shell/entity-service/src/sqlite-asset-repository.d.ts
+type AssetTransaction = Parameters<Parameters<EntityDB["transaction"]>[0]>[0];
+/** Validated and copied before a transaction acquires SQLite's write lock. */
+interface StagedAsset extends AssetRecord {
+  bytes: Buffer;
+}
+/**
+ * SQLite implementation owned by the entity database. Durable insertion is
+ * intentionally package-private and requires the entity transaction type.
+ */
+declare class SqliteAssetRepository implements AssetReader {
+  private readonly db;
+  private readonly maxBytes;
+  private readonly now;
+  constructor(db: EntityDB, options?: {
+    maxBytes?: number;
+    now?: () => number;
+  });
+  /** Validate and copy bytes before entering an entity transaction. */
+  stage(prepared: PreparedAsset): StagedAsset;
   /**
-   * Schema-first section groups (authored via `@rizom/site`'
-   * `defineSection`/`sectionGroup`). Registered as content templates at brain
-   * boot exactly like `content`, so the Studio + directory-sync + resolver treat
-   * them identically — but the section shape is derived from one zod schema.
+   * Bind asset-backed entity content to bytes in the same transaction. Legacy
+   * inline content is left alone for the temporary image migration window.
    */
-  sections?: SiteSectionGroup | SiteSectionGroup[];
-  themeOverride?: string;
+  bindEntityContent(transaction: AssetTransaction, content: string, staged?: StagedAsset): Promise<void>;
+  read(ref: AssetRef): Promise<Uint8Array>;
+  stat(ref: AssetRef): Promise<AssetStat | null>;
+  verify(ref: AssetRef): Promise<AssetVerification>;
+  private insertOrVerify;
+  private assertExists;
+  private assertSize;
+}
+//#endregion
+//#region ../../shell/entity-service/src/projection-write-intent-applier.d.ts
+/** Stored row plus timestamps, including schema-normalized owner metadata. */
+interface ProjectionPersistEntity extends Omit<ProjectionEntityWrite, "metadata"> {
+  metadata: Record<string, unknown>;
+  contentHash: string;
+  created: string;
+  updated: string;
+}
+interface ProjectionEntityStoragePolicy {
+  assetRepository: SqliteAssetRepository;
+  isAssetBacked(entityType: string): boolean;
+  isFullTextSearchable(entityType: string): boolean;
+  /** Normalize source fields and check read-only persistence constraints
+   * inside the admitted transaction, before any upsert effects. */
+  prepareEntity?(entity: ProjectionPersistEntity, operation: "create" | "update"): Promise<ProjectionPersistEntity>;
+}
+//#endregion
+//#region ../../shell/entity-service/src/projection-store.d.ts
+interface MarkProjectionDirtyInput {
+  sourceType: string;
+  sourceId: string;
+  revision: string;
+  operation: "upsert" | "delete";
+  markedAt: number;
+}
+interface ProjectionOwnedEntityInput {
+  entityType: string;
+  id: string;
+}
+/** Entity-database persistence boundary for scheduler coordination state. */
+declare class ProjectionStore {
+  private readonly db;
+  private readonly writeIntentApplier;
+  private readonly transactions;
+  private readonly batches;
+  private readonly waves;
+  private readonly rules;
+  constructor(db: EntityDB, mutationAdmission?: EntityMutationAdmission, now?: () => number, storagePolicy?: ProjectionEntityStoragePolicy);
+  runBulkMutation<TResult>(input: BulkMutationInput, mutation: () => Promise<TResult>): Promise<TResult>;
   /**
-   * Presentation config for entity-backed list/detail routes (labels, plural
-   * names, navigation). Merged onto the base site's empty map. Sites that
-   * surface plugin lists — e.g. `post`→"Essay", `deck`→"Talk" — set it here.
+   * Force the batch coordinator's ambient scope to empty for the duration of
+   * `fn`. A caller that defines a fresh unit of work (the job queue, once per
+   * job) must wrap that unit in this so it never inherits another unit's
+   * batch identity — see ProjectionBatchCoordinator.runFreshBatchScope.
    */
-  entityDisplay?: Record<string, EntityDisplayEntry>;
-  /** Advanced runtime hooks for in-repo sites that need custom template/data-source wiring. */
-  runtime?: RizomRuntimeHooks;
+  runFreshBatchScope<T>(fn: () => T): T;
+  prepareDurableBulkMutation(input: DurableBulkMutationRootInput): Promise<void>;
+  finalizeDurableBulkMutationEnqueue(operationId: string): Promise<void>;
+  failDurableBulkMutationEnqueue(operationId: string): Promise<void>;
+  runDurableBulkMutationChild<TResult>(input: DurableBulkMutationChildInput, mutation: () => Promise<TResult>): Promise<TResult>;
+  settleDurableBulkMutationChild(input: SettleDurableBulkMutationChildInput): Promise<boolean>;
+  recoverProjectionBatches(readRoot: ProjectionBatchRootReader): Promise<ProjectionBatchRecoveryResult>;
+  cleanupProjectionBatches(retentionMs?: number, maximumRecords?: number): Promise<number>;
+  getProjectionBatchDiagnostics(): Promise<ProjectionBatchDiagnostics>;
+  isProjectionOwnedEntity(input: ProjectionOwnedEntityInput): Promise<boolean>;
+  releaseProjectionOwnership(input: ProjectionOwnedEntityInput): Promise<void>;
+  transferEntityAuthority<TResult>(input: ProjectionOwnedEntityInput, mutation: (transaction: EntityTransaction) => Promise<TResult>): Promise<TResult>;
+  markDirty(input: MarkProjectionDirtyInput): Promise<number>;
+  withDirtyInput<TResult>(input: MarkProjectionDirtyInput, mutation: (transaction: EntityTransaction) => Promise<TResult>): Promise<TResult>;
+  listPendingInputs(): Promise<ProjectionDirtyInput[]>;
+  hasActiveProjectionBatch(): Promise<boolean>;
+  claimPendingWave(input: ClaimProjectionWaveInput): Promise<ProjectionWave | null>;
+  listWaveInputs(waveId: string): Promise<ProjectionWaveInput[]>;
+  getWave(waveId: string): Promise<ProjectionWave | null>;
+  getActiveWave(): Promise<ProjectionWave | null>;
+  completeWave(waveId: string, completedAt: number): Promise<ProjectionWave>;
+  supersedeWaveIfStale(waveId: string, supersededAt: number): Promise<boolean>;
+  failWave(waveId: string, failedAt: number): Promise<ProjectionWave>;
+  failWaveWithIncident(input: ProjectionIncidentInput): Promise<ProjectionWave>;
+  getUnresolvedProjectionIncidentDiagnostics(limit?: number): Promise<ProjectionIncidentDiagnostics>;
+  putWaveRules(waveId: string, rules: readonly ProjectionWaveRuleInput[]): Promise<void>;
+  listWaveRules(waveId: string): Promise<ProjectionWaveRule[]>;
+  queueWaveRule(waveId: string, ruleId: string, jobId: string): Promise<ProjectionWaveRule>;
+  getWaveRule(waveId: string, ruleId: string): Promise<ProjectionWaveRule | null>;
+  applyRuleResult(input: ApplyProjectionRuleResultInput): Promise<ProjectionWaveRule | null>;
+  getRuleMemo(input: GetProjectionRuleMemoInput): Promise<ProjectionRuleMemoValue | null>;
 }
-declare function createRizomSite(options: CreateRizomSiteOptions): SitePackage;
 //#endregion
-//#region src/site.d.ts
-declare const rizomAiSite: SitePackage;
+//#region ../../shell/entity-service/src/entity-write-contracts.d.ts
+/** null means create only if absent; a token means replace that incarnation. */
+interface EntityWriteCondition {
+  expectedRevision: string | null;
+}
 //#endregion
-//#region src/routes.d.ts
+//#region ../../shell/entity-service/src/types.d.ts
 /**
- * The consolidated Rizom site routes. The home page composes the living-memory
- * content namespace; the layout owns navigation (the
- * two-tier faces strip), so routes stay out of the entity nav.
+ * Options for entity mutation operations (create, update, upsert)
  */
-declare const aiRoutes: RouteDefinitionInput[];
-//#endregion
-//#region src/home.d.ts
+interface EntityMutationEventContext {
+  conversationId?: string;
+  channelId?: string;
+  runId?: string;
+  toolCallId?: string;
+  actor?: ActorRef;
+  interfaceType?: string;
+}
+interface EntityWriteSnapshot {
+  entity: BaseEntity;
+  revision: string;
+}
+type EntityPersistenceOrigin = "ordinary" | "directory-sync";
+interface EntityJobOptions {
+  priority?: number;
+  maxRetries?: number;
+  eventContext?: EntityMutationEventContext;
+  /**
+   * Identifies authoritative file imports/deletes so they clear, rather than
+   * create, an outbound directory-export intent.
+   */
+  persistenceOrigin?: EntityPersistenceOrigin;
+}
+/**
+ * Options for entity creation (extends EntityJobOptions with deduplication)
+ */
+interface CreateEntityOptions extends EntityJobOptions {
+  /** Cancel before the atomic write boundary, not after a mutation commits. */
+  signal?: AbortSignal;
+  /** Runtime-only guard over the final persisted fields, immediately before writing. */
+  beforeWrite?: (entity: Readonly<BaseEntity>) => Promise<void>;
+  deduplicateId?: boolean;
+  /** Atomic create-if-absent. Cannot deduplicate. */
+  conditionalWrite?: EntityWriteCondition;
+}
+/** Options for updating an existing entity. */
+interface UpdateEntityOptions extends EntityJobOptions {
+  /** Cancel before the atomic write boundary, not after a mutation commits. */
+  signal?: AbortSignal;
+  /** Runtime-only guard over the final persisted fields, immediately before writing. */
+  beforeWrite?: (entity: Readonly<BaseEntity>) => Promise<void>;
+  /** Apply only while the stored entity still has this content hash. */
+  expectedContentHash?: string | undefined;
+  /** Atomic full-revision replace. */
+  conditionalWrite?: EntityWriteCondition;
+}
+/**
+ * Result of an entity mutation that triggers an embedding job.
+ * When skipped is true, no DB write, event, or embedding job was produced.
+ */
+interface EntityMutationResult {
+  entityId: string;
+  jobId: string;
+  skipped: boolean;
+  skipReason?: "content-conflict" | undefined;
+}
+/**
+ * Input for adapter-validated direct creation from finalized markdown.
+ */
+interface CreateEntityFromMarkdownInput {
+  entityType: string;
+  id: string;
+  markdown: string;
+  /** Explicit core visibility. When omitted, markdown frontmatter or the public default applies. */
+  visibility?: ContentVisibility;
+}
+/**
+ * Data for storing an embedding for an entity
+ */
+interface StoreEmbeddingData {
+  entityId: string;
+  entityType: string;
+  embedding: Float32Array;
+  contentHash: string;
+}
+type EntitySchema<T> = z.ZodType<T, unknown>;
+type UnknownEntitySchema = EntitySchema<unknown>;
+type FrontmatterSchema = z.ZodObject<z.ZodRawShape>;
+/**
+ * Base entity type - generic to support typed metadata
+ * TMetadata defaults to Record<string, unknown> for backward compatibility
+ */
+interface BaseEntity<TMetadata = Record<string, unknown>> {
+  id: string;
+  entityType: string;
+  content: string;
+  created: string;
+  updated: string;
+  visibility: ContentVisibility;
+  metadata: TMetadata;
+  /** SHA256 hash of content for change detection */
+  contentHash: string;
+}
+/**
+ * Entity input type for creation - allows partial entities with optional system fields
+ * contentHash is excluded because it's computed automatically by the entity service
+ */
+type EntityInput<T extends BaseEntity> = Omit<T, "id" | "created" | "updated" | "contentHash" | "visibility"> & {
+  id?: string;
+  created?: string;
+  updated?: string;
+  visibility?: RawContentVisibility;
+};
+/**
+ * Search result type
+ */
+interface SearchResult<T extends BaseEntity = BaseEntity> {
+  entity: T;
+  score: number;
+  excerpt: string;
+}
+/**
+ * Normalized system_create input shape used by plugin create interceptors.
+ */
+interface CreateCoverImageInput {
+  generate?: boolean | undefined;
+  prompt?: string | undefined;
+}
+interface CreateFromAttachmentInput {
+  kind: "entity-attachment";
+  sourceEntityType: string;
+  sourceEntityId: string;
+  attachmentType: string;
+}
+interface CreateFromUploadInput {
+  kind: "upload";
+  id: string;
+}
+interface CreateFromConversationMessageInput {
+  kind: "conversation-message";
+  messageId?: string | undefined;
+}
+type CreateFromInput = CreateFromAttachmentInput | CreateFromUploadInput | CreateFromConversationMessageInput;
+type CreateTransform = "extract-markdown" | "preserve";
+interface CreateInput {
+  entityType: string;
+  prompt?: string;
+  title?: string;
+  visibility?: ContentVisibility;
+  content?: string;
+  url?: string;
+  from?: CreateFromInput;
+  transform?: CreateTransform;
+  replace?: boolean;
+  sourceEntityType?: string;
+  sourceEntityId?: string;
+  sourceEntityIds?: string[];
+  targetEntityType?: string;
+  targetEntityId?: string;
+  coverImage?: boolean | CreateCoverImageInput;
+}
+/**
+ * Minimal caller context forwarded to plugin create interceptors.
+ */
+interface CreateExecutionContext {
+  interfaceType: string;
+  actor: ActorRef;
+  channelId?: string;
+  channelName?: string;
+}
+/**
+ * Result returned to system_create when a plugin fully handles creation.
+ */
+declare const createResultAttachmentSchema: z.ZodObject<{
+  mediaType: z.ZodString;
+  url: z.ZodString;
+  downloadUrl: z.ZodOptional<z.ZodString>;
+  previewUrl: z.ZodOptional<z.ZodString>;
+  filename: z.ZodOptional<z.ZodString>;
+  sizeBytes: z.ZodOptional<z.ZodNumber>;
+  source: z.ZodOptional<z.ZodObject<{
+    entityType: z.ZodOptional<z.ZodString>;
+    entityId: z.ZodOptional<z.ZodString>;
+    attachmentType: z.ZodOptional<z.ZodString>;
+  }>>;
+}>;
+type CreateResultAttachment = z.infer<typeof createResultAttachmentSchema>;
+type CreateResult = {
+  success: true;
+  data: {
+    entityId?: string;
+    jobId?: string;
+    status: string;
+    attachment?: CreateResultAttachment;
+  };
+} | {
+  success: false;
+  error: string;
+};
 /**
- * The umbrella home page's authored sections. The namespace ("home") matches
- * the route id, so each stores as site-content/home/<section>.md and resolves
- * as "home:<section>". Two sections live elsewhere: the hero is the live
- * agent proximity map (agent-discovery:proximity-map) and the proof/ask is
- * the knowledge map (topics:knowledge-map) — both authored via overlay
- * markdown merged over their live datasource payloads.
+ * Plugin create interceptors can either fully handle creation,
+ * or continue with a rewritten normalized input.
  */
-declare const homeSections: SiteSectionGroup;
+type CreateInterceptionResult = {
+  kind: "handled";
+  result: CreateResult;
+} | {
+  kind: "continue";
+  input: CreateInput;
+};
+type CreateInterceptor = (input: CreateInput, executionContext: CreateExecutionContext) => Promise<CreateInterceptionResult>;
+interface UploadSaveInput {
+  upload: CreateFromUploadInput;
+  title?: string;
+  visibility?: ContentVisibility;
+}
+type UploadSaveHandler = (input: UploadSaveInput, executionContext: CreateExecutionContext) => Promise<CreateResult>;
+interface UploadSaveHandlerRegistration {
+  entityType: string;
+  mediaTypes: string[];
+  handler: UploadSaveHandler;
+}
+/**
+ * Called before an entity is persisted (on create or update). Throws to reject
+ * the write with an operator-facing error. Use this for cross-entity invariants
+ * the per-entity Zod schema cannot express. Includes projection upserts, which
+ * validate inside their transaction. Read-only lookups are allowed; mutations
+ * and external effects are not.
+ */
+type PersistValidator<T extends BaseEntity = BaseEntity> = (entity: T, context: {
+  operation: "create" | "update";
+}) => Promise<void>;
+/**
+ * Interface for entity adapter - handles conversion between entities and markdown
+ * following the hybrid storage model
+ *
+ * @template TEntity - The full entity type
+ * @template TMetadata - The metadata type (defaults to Record<string, unknown>)
+ */
+interface EntityAdapter<TEntity extends BaseEntity<TMetadata>, TMetadata = Record<string, unknown>> {
+  entityType: string;
+  /**
+   * One declarative sentence describing what this entity type is. This is the
+   * data the model reads to select `entityType`, replacing hardcoded example
+   * phrasings in system instructions. Required: every type must define itself.
+   */
+  purpose: string;
+  schema: EntitySchema<TEntity>;
+  toMarkdown(entity: TEntity): string;
+  fromMarkdown(markdown: string): Partial<TEntity>;
+  extractMetadata(entity: TEntity): TMetadata;
+  parseFrontMatter<TFrontmatter>(markdown: string, schema: {
+    parse(data: unknown): TFrontmatter;
+  }): TFrontmatter;
+  generateFrontMatter(entity: TEntity): string;
+  /** Optional: Zod schema for frontmatter fields. Used by Studio config generation. */
+  frontmatterSchema?: z.ZodObject<z.ZodRawShape>;
+  /** Optional: Declares this entity type is a singleton (one file, e.g., identity/identity.md). Used by Studio to generate files collection. */
+  isSingleton?: boolean;
+  /** Optional: Whether this entity has a free-form markdown body below frontmatter. Defaults to true. When false, Studio omits the body widget. */
+  hasBody?: boolean;
+  /** Returns a markdown body template with section headings for this entity type. Empty string for free-form entities. */
+  getBodyTemplate(): string;
+  /** Optional: Declares that this entity type supports cover images via coverImageId in frontmatter */
+  supportsCoverImage?: boolean;
+  /**
+   * Optional: the `metadata.status` values that count as published for
+   * `publishedOnly` queries (production site builds). Declaring this makes the
+   * list exact — entities without a status are NOT published. When absent, the
+   * default lifecycle semantics apply: status `published`, `active`, or no
+   * status at all.
+   */
+  publishedStatuses?: string[];
+  /** Optional: Extract coverImageId from entity content/frontmatter */
+  getCoverImageId?(entity: TEntity): string | undefined;
+  /**
+   * Optional: build the markdown content and metadata for a queued-generation stub.
+   * When undefined, this entity type does not support prompt-based queued creation
+   * via system_create; the tool will reject the call rather than silently degrade.
+   * The returned metadata must satisfy this entity's metadata schema (with
+   * status set to "generating"); central code only stamps id/timestamps/visibility.
+   */
+  buildStub?(input: {
+    id: string;
+    title: string;
+  }): {
+    content: string;
+    metadata: TMetadata;
+  };
+}
+/**
+ * Sort field specification for multi-field sorting
+ */
+interface SortField {
+  /** Field to sort by - "created", "updated", or a metadata field name */
+  field: string;
+  /** Sort direction */
+  direction: "asc" | "desc";
+  /** Sort NULL values before non-NULL values (default: false / SQLite default) */
+  nullsFirst?: boolean;
+}
+/**
+ * List entities options
+ * Generic over metadata type for type-safe filtering
+ */
+interface EntityReadOptions {
+  /** Cooperative boundary checks, not proof of remote SQL cancellation. */
+  signal?: AbortSignal;
+}
+interface ListOptions<TMetadata = Record<string, unknown>> extends EntityReadOptions {
+  limit?: number;
+  offset?: number;
+  /** Multi-field sorting - supports system fields (created, updated) and metadata fields */
+  sortFields?: SortField[];
+  filter?: {
+    metadata?: Partial<TMetadata>;
+    /** Literal substring search through serialized content, including frontmatter. */
+    contentContains?: string | undefined;
+    /** Exact visibility, intersected with visibilityScope rather than widening it. */
+    visibility?: ContentVisibility | undefined;
+    visibilityScope?: ContentVisibility | undefined;
+  };
+  /** Filter to only entities with metadata.status = "published" */
+  publishedOnly?: boolean;
+}
+/**
+ * Search options
+ */
+interface SearchOptions extends EntityReadOptions {
+  limit?: number;
+  offset?: number;
+  types?: string[];
+  excludeTypes?: string[];
+  sortBy?: "relevance" | "created" | "updated";
+  sortDirection?: "asc" | "desc";
+  /** Score multipliers per entity type - applied after initial search */
+  weight?: Record<string, number>;
+  visibilityScope?: ContentVisibility | undefined;
+  /** Include queued/failed generation stubs in search results (default: false) */
+  includeUngenerated?: boolean;
+  /** Only entities their type counts as published, as for published-only listings (default: false) */
+  publishedOnly?: boolean;
+  /** Minimum relevance score to return. Omit for no score cutoff. */
+  minScore?: number;
+}
+type ProjectionSourceRole = "canonical" | "primary" | "secondary" | "supporting" | "ambient" | "excluded";
+/**
+ * Configuration for entity type registration
+ */
+interface EntityTypeConfig {
+  /** Plugin-owned semantic role, defaulting to content. System types cannot contribute to groupings. */
+  classification?: EntityTypeClassification;
+  /** Score multiplier for search results (default: 1.0) */
+  weight?: number;
+  /** Whether to generate embeddings for this entity type (default: true).
+   *  Set to false for entity types with non-textual content (e.g., images). */
+  embeddable?: boolean;
+  /** Whether to index serialized content in full-text search (default: true).
+   *  Set to false for binary entity types. Mutations remove stale FTS rows. */
+  fullTextSearchable?: boolean;
+  /** Binary storage policy. Absence means text content. */
+  binaryStorage?: "data-url" | "asset";
+  /** Default system_list order, applied by the entity service before pagination. */
+  defaultSort?: SortField[];
+  /** Accepts upload text extraction through system_create extract-markdown. */
+  markdownImport?: boolean;
+  /**
+   * The type's own minimum action policy, from whoever registers it. It
+   * tightens wildcard defaults without relaxing stricter rules, including
+   * `never`, so an admin-only type stays protected without its bundle's rule.
+   * An explicit per-type instance entry still overrides, action by action.
+   */
+  actionPolicy?: Partial<Record<"create" | "update" | "delete" | "extract" | "publish", "never" | "admin" | "trusted" | "public">>;
+  /** Whether this entity type may be used as source material for derived projections (default: true).
+   *  Set to false for projection outputs that would create feedback loops. */
+  projectionSource?: boolean;
+  /** Default source authority role for derived projections. Entity types own
+   *  their durable/source character; consumers may map roles to local policy. */
+  projectionSourceRole?: ProjectionSourceRole;
+  /** Publish semantics for status-bearing entity types. Statuses listed here
+   *  represent publication commitment/execution states and require the
+   *  `publish` entity action when entered or modified. */
+  publish?: {
+    publishStatuses: string[];
+  };
+}
+/**
+ * Core entity service interface for read-only operations
+ * Used by core plugins that need entity access but shouldn't modify entities
+ */
+interface GetEntityRequest extends EntityReadOptions {
+  entityType: string;
+  id: string;
+  /**
+   * Optional visibility scope. Undefined fails closed to "public" — callers
+   * with elevated access must opt up explicitly.
+   */
+  visibilityScope?: ContentVisibility | undefined;
+  /** Only an entity its type counts as published, as for published-only listings. */
+  publishedOnly?: boolean | undefined;
+}
+type GetEntityRawRequest = GetEntityRequest;
+interface ProjectionOwnedEntityRequest {
+  entityType: string;
+  id: string;
+}
+interface ListEntitiesRequest {
+  entityType: string;
+  options?: ListOptions | undefined;
+}
+interface QueryEntityHierarchyRequest {
+  entityType: string;
+  /** Null/omitted means the collection root; segments identify stored identity. */
+  prefix?: EntityIdPathInput | null | undefined;
+  /** Search matching entries throughout the prefix; no folder rows in this mode. */
+  includeDescendants?: boolean | undefined;
+  /** Omitted fails closed to public, including folder names and counts. */
+  visibilityScope?: ContentVisibility | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+  sortFields?: SortField[] | undefined;
+  filter?: {
+    metadata?: Record<string, unknown> | undefined;
+    contentContains?: string | undefined;
+    visibility?: ContentVisibility | undefined;
+  } | undefined;
+  signal?: AbortSignal | undefined;
+}
+interface EntityHierarchyPage {
+  prefix: EntityIdPath | null;
+  folders: Array<{
+    path: EntityIdPath;
+    name: string;
+    descendantCount: number;
+  }>;
+  /** Only direct children, with derived paths kept outside durable entity data. */
+  entities: Array<{
+    entity: BaseEntity;
+    path: EntityIdPath;
+  }>;
+  offset: number;
+  totalEntities: number;
+}
+interface CountEntitiesRequest {
+  entityType: string;
+  options?: Pick<ListOptions, "publishedOnly" | "filter"> | undefined;
+}
+interface CreateEntityRequest<T extends BaseEntity> {
+  entity: EntityInput<T>;
+  /** Prepared bytes committed in the same transaction as their entity reference. */
+  preparedAsset?: PreparedAsset | undefined;
+  options?: CreateEntityOptions | undefined;
+}
+interface CreateEntityFromMarkdownRequest {
+  input: CreateEntityFromMarkdownInput;
+  options?: CreateEntityOptions | undefined;
+}
+interface UpdateEntityRequest<T extends BaseEntity> {
+  entity: T;
+  /** Prepared bytes committed in the same transaction as their entity reference. */
+  preparedAsset?: PreparedAsset | undefined;
+  options?: UpdateEntityOptions | undefined;
+}
+interface DeleteEntityRequest {
+  entityType: string;
+  id: string;
+  options?: Pick<EntityJobOptions, "eventContext" | "persistenceOrigin"> | undefined;
+}
+interface UpsertEntityRequest<T extends BaseEntity> {
+  entity: T;
+  /** Prepared bytes committed in the same transaction as their entity reference. */
+  preparedAsset?: PreparedAsset | undefined;
+  /** Conditional upserts never fall through from a raced create to update. */
+  options?: (EntityJobOptions & {
+    conditionalWrite?: EntityWriteCondition;
+  }) | undefined;
+}
+interface EntitySearchRequest {
+  query: string;
+  options?: SearchOptions | undefined;
+}
+interface SearchWithDistancesRequest {
+  query: string;
+}
+interface SemanticEntityReference {
+  entityId: string;
+  entityType: string;
+}
+interface ProjectSemanticSpaceRequest {
+  /** Entity types to include as projected points. Empty or omitted includes all types. */
+  types?: string[];
+  /** Optional entity used as the semantic origin. Missing origins fall back to the point centroid. */
+  origin?: SemanticEntityReference;
+  /** Include pairwise neighbors at or below this cosine distance. */
+  maxNeighborDistance?: number;
+  /** Undefined fails closed to public-only visibility. */
+  visibilityScope?: ContentVisibility | undefined;
+}
+interface SemanticSpacePoint extends SemanticEntityReference {
+  /** Coordinates on the first two principal components of the semantic space. */
+  coordinates: [number, number];
+  /** Cosine distance from the requested origin or the fallback centroid. */
+  distanceToOrigin: number;
+}
+interface SemanticSpaceNeighbor {
+  source: SemanticEntityReference;
+  target: SemanticEntityReference;
+  distance: number;
+}
+type SemanticSpaceOrigin = ({
+  kind: "entity";
+} & SemanticEntityReference) | {
+  kind: "centroid";
+};
+interface SemanticSpaceDistanceRange {
+  min: number;
+  max: number;
+}
+interface SemanticSpaceProjection {
+  origin: SemanticSpaceOrigin;
+  points: SemanticSpacePoint[];
+  neighbors: SemanticSpaceNeighbor[];
+  /** Observed origin-distance extent for projection-independent scaling. */
+  distanceRange: SemanticSpaceDistanceRange;
+}
+/**
+ * Context passed to all DataSource operations
+ * Contains internal state that should not be mixed with user query parameters
+ */
+interface BaseDataSourceContext {
+  /**
+   * Whether to filter to only published/complete content
+   * Set by site-builder: true for production, false for preview
+   */
+  publishedOnly?: boolean;
+  /**
+   * Scoped entity service that auto-applies publishedOnly filter
+   * Datasources should use this instead of their injected entityService
+   * to ensure consistent filtering behavior across environments
+   */
+  entityService: EntityServiceClient;
+}
+/**
+ * DataSource Interface
+ *
+ * Provides data for templates through fetch, generate, or transform operations.
+ * DataSources are registered in the DataSourceRegistry and referenced by templates
+ * via their dataSourceId property.
+ */
+/** Runtime-only, read-only access for caller-bound generation. */
+interface DataSourceGenerationContext {
+  readonly visibilityScope: ContentVisibility;
+  readonly signal?: AbortSignal;
+  getEntity(entityType: string, id: string): Promise<BaseEntity | null>;
+  search(query: string, options?: Pick<SearchOptions, "limit" | "weight">): Promise<SearchResult[]>;
+}
+interface DataSource {
+  /**
+   * Unique identifier for this data source
+   */
+  id: string;
+  /**
+   * Human-readable name for this data source
+   */
+  name: string;
+  /**
+   * Optional description of what this data source provides
+   */
+  description?: string;
+  /**
+   * Optional: Fetch existing data
+   * Used by data sources that aggregate or retrieve data (e.g., dashboard stats, API data)
+   * DataSources validate output using the provided schema
+   * @param query - Query parameters for fetching data
+   * @param outputSchema - Schema for validating output data
+   * @param context - Context with environment
+   */
+  fetch?: <T>(query: unknown, outputSchema: z.ZodSchema<T>, context: BaseDataSourceContext) => Promise<T>;
+  /**
+   * Optional: Generate new content
+   * Used by data sources that create content (e.g., AI-generated content, reports)
+   */
+  generate?: <T>(request: unknown, schema: z.ZodSchema<T>, signal?: AbortSignal) => Promise<T>;
+  /**
+   * Opt-in scoped generation. All content reads must use this runtime context,
+   * not ambient entity services/caches. Never fall back to generate().
+   */
+  generateScoped?: <T>(request: unknown, schema: z.ZodSchema<T>, context: DataSourceGenerationContext) => Promise<T>;
+  /**
+   * Optional: Transform content between formats
+   * Used by data sources that convert content (e.g., markdown to HTML, data formatting)
+   */
+  transform?: <T>(content: unknown, format: string, schema: z.ZodSchema<T>) => Promise<T>;
+}
+/**
+ * DataSource capabilities for discovery and validation
+ */
+interface DataSourceCapabilities {
+  canFetch: boolean;
+  canGenerate: boolean;
+  canTransform: boolean;
+}
+interface ICoreEntityService {
+  getEntity(request: GetEntityRequest): Promise<BaseEntity | null>;
+  getEntity<T extends BaseEntity>(request: GetEntityRequest, schema: EntitySchema<T>): Promise<T | null>;
+  /**
+   * Get entity without content resolution (raw)
+   * Used internally to avoid recursion when resolving image references
+   */
+  getEntityRaw(request: GetEntityRawRequest): Promise<BaseEntity | null>;
+  getEntityRaw<T extends BaseEntity>(request: GetEntityRawRequest, schema: EntitySchema<T>): Promise<T | null>;
+  listEntities(request: ListEntitiesRequest): Promise<BaseEntity[]>;
+  listEntities<T extends BaseEntity>(request: ListEntitiesRequest, schema: EntitySchema<T>): Promise<T[]>;
+  /** Immediate folders and paginated direct children; no filesystem interpretation. */
+  queryEntityHierarchy(request: QueryEntityHierarchyRequest): Promise<EntityHierarchyPage>;
+  queryGroupingCatalog(request: QueryGroupingCatalogRequest): Promise<EntityGroupingCatalog>;
+  queryGroupingMembers(request: QueryGroupingMembersRequest): Promise<EntityGroupingMembers>;
+  queryGroupingUsage(request: QueryGroupingUsageRequest): Promise<EntityGroupingUsage>;
+  search(request: EntitySearchRequest): Promise<SearchResult<BaseEntity>[]>;
+  search<T extends BaseEntity>(request: EntitySearchRequest, schema: EntitySchema<T>): Promise<SearchResult<T>[]>;
+  /** Return embedded entities with raw cosine distance to a query. */
+  searchWithDistances(request: SearchWithDistancesRequest): Promise<Array<{
+    entityId: string;
+    entityType: string;
+    distance: number;
+  }>>;
+  /** Project visible entities into a provider-independent semantic space. */
+  projectSemanticSpace(request: ProjectSemanticSpaceRequest): Promise<SemanticSpaceProjection>;
+  getEntityTypes(): string[];
+  hasEntityType(type: string): boolean;
+  countEntities(request: CountEntitiesRequest): Promise<number>;
+  /**
+   * Group counts by entity type. Fails closed: undefined visibilityScope
+   * filters to public-only counts so aggregate insights cannot reveal
+   * non-public entity existence.
+   */
+  getEntityCounts(visibilityScope?: ContentVisibility): Promise<Array<{
+    entityType: string;
+    count: number;
+  }>>;
+  /** Get configuration for a specific entity type */
+  getEntityTypeConfig(type: string): EntityTypeConfig;
+  /** Get weight map for all registered entity types with non-default weights */
+  getWeightMap(): Record<string, number>;
+}
+/** One visibility-scoped, mixed-type member page. */
+interface EntityGroupingMembers {
+  entities: BaseEntity[];
+  total: number;
+}
+/** A single document owner refreshes in-memory grouping contracts before use. */
+interface EntityGroupingSource {
+  readonly entityType: string;
+  /** Read-only with respect to persistence: never mutate entities or reproject. */
+  ensureCurrent(options?: {
+    afterWrite?: boolean;
+  }): Promise<void>;
+}
+interface EmbeddingBackfillResult {
+  queued: number;
+  skipped: number;
+}
+interface EmbeddingIndexStats {
+  missingEmbeddings: number;
+  staleEmbeddings: number;
+  failedEmbeddings: number;
+  /** Entities whose type generates embeddings (non-embeddable types excluded). */
+  embeddableEntities: number;
+  /** Embeddable entities whose embedding is present and current. */
+  embeddedEntities: number;
+}
+interface IndexReadinessOptions {
+  /** Stop polling after this duration. Omit for an owning runtime monitor. */
+  timeoutMs?: number;
+  intervalMs?: number;
+  /** Cancels readiness polling when the owning runtime shuts down. */
+  signal?: AbortSignal;
+}
+interface IndexReadinessStatus extends EmbeddingIndexStats {
+  ready: boolean;
+  degraded: boolean;
+  activeEmbeddingJobs: number;
+}
+/**
+ * The entity-service surface ordinary plugins receive. A real interface
+ * rather than Omit<EntityService, ...>: mapped types collapse overloaded
+ * methods (like the schema-taking reads) down to one signature.
+ */
+interface EntityServiceClient extends ICoreEntityService {
+  /** Visibility-scoped read and revision for atomic conditional writes. */
+  getEntityWriteSnapshot(request: GetEntityRequest): Promise<EntityWriteSnapshot | null>;
+  /** Local admission state; grouping endpoints must not serve partial bootstrap results. */
+  areGroupingsReady(): boolean;
+  /** Refresh definitions and start missing scans outside write transactions. */
+  ensureGroupingsReady(): Promise<boolean>;
+  /** Internal source-authority check used by persistence integrations. */
+  isProjectionOwnedEntity(request: ProjectionOwnedEntityRequest): Promise<boolean>;
+  listPendingEntityExports(): Promise<EntityExportIntent[]>;
+  hasPendingEntityExports(): Promise<boolean>;
+  acknowledgeEntityExports(request: AcknowledgeEntityExportsRequest): Promise<number>;
+  runBulkMutation<TResult>(input: BulkMutationInput, mutation: () => Promise<TResult>): Promise<TResult>;
+  createEntity<T extends BaseEntity>(request: CreateEntityRequest<T>): Promise<EntityMutationResult>;
+  createEntityFromMarkdown(request: CreateEntityFromMarkdownRequest): Promise<EntityMutationResult>;
+  updateEntity<T extends BaseEntity>(request: UpdateEntityRequest<T>): Promise<EntityMutationResult>;
+  deleteEntity(request: DeleteEntityRequest): Promise<boolean>;
+  upsertEntity<T extends BaseEntity>(request: UpsertEntityRequest<T>): Promise<EntityMutationResult & {
+    created: boolean;
+  }>;
+  storeEmbedding(data: StoreEmbeddingData): Promise<void>;
+  reconcileProjectionTargets(targets: readonly ProjectionChangedTarget[]): Promise<void>;
+  backfillMissingEmbeddings(): Promise<EmbeddingBackfillResult>;
+  isIndexReady(): boolean;
+  awaitIndexReady(options: IndexReadinessOptions): Promise<IndexReadinessStatus>;
+  serializeEntity(entity: BaseEntity): string;
+  deserializeEntity(markdown: string, entityType: string): Partial<BaseEntity>;
+  countEmbeddings(): Promise<number>;
+  initialize(): Promise<void>;
+  getAsyncJobStatus(jobId: string): Promise<{
+    status: "pending" | "processing" | "completed" | "failed";
+    error?: string;
+  } | null>;
+}
+interface EntityService extends EntityServiceClient {
+  /** Normal web/combined boot only, after initial sync; not an ordinary mutation. */
+  reprojectRegisteredGroupings(): Promise<void>;
+  getProjectionStore(): ProjectionStore;
+  setProjectionWakeup(wakeup: () => Promise<void>): () => void;
+  prepareDurableBulkMutation(input: DurableBulkMutationRootInput): Promise<void>;
+  finalizeDurableBulkMutationEnqueue(operationId: string): Promise<void>;
+  failDurableBulkMutationEnqueue(operationId: string): Promise<void>;
+  runDurableBulkMutationChild<TResult>(input: DurableBulkMutationChildInput, mutation: () => Promise<TResult>): Promise<TResult>;
+  settleDurableBulkMutationChild(input: SettleDurableBulkMutationChildInput): Promise<boolean>;
+  recoverProjectionBatches(readRoot: ProjectionBatchRootReader): Promise<ProjectionBatchRecoveryResult>;
+}
+/**
+ * Entity Registry interface for managing entity types and their schemas/adapters
+ */
+interface EntityRegistry {
+  registerEntityType<TEntity extends BaseEntity<TMetadata>, TMetadata extends Record<string, unknown> = Record<string, unknown>>(type: string, schema: UnknownEntitySchema, adapter: EntityAdapter<TEntity, TMetadata>, config?: EntityTypeConfig): void;
+  /** Remove an entity type after failed plugin registration or shell teardown. */
+  unregisterEntityType(type: string): void;
+  getSchema(type: string): UnknownEntitySchema;
+  getAdapter(type: string): EntityAdapter<BaseEntity>;
+  hasEntityType(type: string): boolean;
+  validateEntity(type: string, entity: unknown): BaseEntity;
+  getAllEntityTypes(): string[];
+  /** Get configuration for a specific entity type */
+  getEntityTypeConfig(type: string): EntityTypeConfig;
+  /** Get weight map for all registered entity types with non-default weights */
+  getWeightMap(): Record<string, number>;
+  registerCreateInterceptor(type: string, interceptor: CreateInterceptor): void;
+  getCreateInterceptor(type: string): CreateInterceptor | undefined;
+  registerUploadSaveHandler(registration: UploadSaveHandlerRegistration): void;
+  getUploadSaveHandler(mediaType: string): UploadSaveHandlerRegistration | undefined;
+  registerPersistValidator(type: string, validator: PersistValidator): void;
+  getPersistValidator(type: string): PersistValidator | undefined;
+  /**
+   * Extend an adapter's frontmatterSchema with additional fields.
+   * Used by plugins to add domain-specific fields (e.g., professional-site adds tagline to profile).
+   * Extensions are merged into the effective schema returned by getEffectiveFrontmatterSchema().
+   */
+  extendFrontmatterSchema(type: string, extension: z.ZodObject<z.ZodRawShape>): void;
+  registerGroupingSource(source: EntityGroupingSource): void;
+  /** Capture preparation state; invoke the guard inside the write transaction. */
+  captureGroupingWriteGuard(entityType: string): () => Promise<void>;
+  getGroupingSourceType(): string | undefined;
+  getPendingGroupingProjections(): GroupingProjectionTarget[];
+  completeGroupingProjections(targets: readonly GroupingProjectionTarget[]): void;
+  /** The source's own entity reads skip refresh to avoid recursion. */
+  ensureGroupingsCurrent(entityType?: string, options?: {
+    afterWrite?: boolean;
+  }): Promise<void>;
+  /** Preflight a complete replacement set without modifying active schemas. */
+  validateGroupings(groupings: readonly EntityGrouping[]): void;
+  /** Atomically replace declarations; observers may recheck retained fields. */
+  replaceGroupings(groupings: readonly EntityGrouping[], options?: {
+    reprojectExisting?: boolean;
+  }): void;
+  registerGrouping(grouping: EntityGrouping): void;
+  getGrouping(key: string): EntityGrouping;
+  getGroupings(): EntityGrouping[];
+  projectMetadata(type: string, content: string, metadata: Record<string, unknown>): Record<string, unknown>;
+  /** Bootstrap projection: an invalid stored value is omitted, never fatal. */
+  projectStoredMetadata(type: string, content: string, metadata: Record<string, unknown>): Record<string, unknown>;
+  groupingFields(type: string): string[];
+  isGroupingContributor(type: string): boolean;
+  /** Registered extension contracts, including their refinements. */
+  getFrontmatterExtensions(type: string): readonly FrontmatterSchema[];
+  /**
+   * Get the effective frontmatter schema for an entity type,
+   * with all registered extensions merged in.
+   * Returns undefined if the adapter has no frontmatterSchema.
+   */
+  getEffectiveFrontmatterSchema(type: string): z.ZodObject<z.ZodRawShape> | undefined;
+}
+/**
+ * The read-only projection of the entity service.
+ *
+ * What a plugin is handed when it has no business writing: insight handlers
+ * compute over entities and return a summary. A projection of
+ * `ICoreEntityService` rather than a hand-written parallel interface, so a
+ * method that changes shape fails to compile here instead of drifting.
+ *
+ * `@brains/plugins` restates this as `IEntityService` on its published
+ * authoring surface; `public-surface-soundness.test.ts` holds the two
+ * together.
+ */
+type ReadOnlyEntityService = Pick<ICoreEntityService, "getEntity" | "listEntities" | "search" | "searchWithDistances" | "getEntityTypes" | "hasEntityType" | "countEntities" | "getEntityCounts" | "getEntityTypeConfig">;
+//#endregion
+//#region ../../shell/job-queue/src/schema/types.d.ts
+/**
+ * Operation type enum for structured progress tracking and aggregation
+ * Using generic categories to accommodate various plugin operations
+ */
+declare const OperationTypeEnum: z.ZodEnum<{
+  file_operations: "file_operations";
+  content_operations: "content_operations";
+  data_processing: "data_processing";
+  batch_processing: "batch_processing";
+}>;
+type JobContextInputSchema = z.ZodObject<{
+  pluginId: z.ZodOptional<z.ZodString>;
+  progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+  operationType: typeof OperationTypeEnum;
+  operationTarget: z.ZodOptional<z.ZodString>;
+  interfaceType: z.ZodOptional<z.ZodString>;
+  conversationId: z.ZodOptional<z.ZodString>;
+  channelId: z.ZodOptional<z.ZodString>;
+  requestedByActor: z.ZodOptional<typeof actorRefSchema>;
+  requestedByUserId: z.ZodOptional<z.ZodString>;
+  requestedByInterface: z.ZodOptional<z.ZodString>;
+  silent: z.ZodOptional<z.ZodBoolean>;
+  provenance: z.ZodOptional<typeof OperationProvenanceSchema>;
+}, z.core.$loose>;
+/**
+ * Job context input schema - what callers provide when creating jobs
+ * Note: rootJobId is not included here - it's managed internally by the job queue service
+ * and defaults to the job's own ID for standalone jobs, or the batch ID for batch children.
+ *
+ * Callers attach further keys of their own; the object is loose so parsing
+ * keeps them and the type admits them.
+ */
+declare const JobContextInputSchema: JobContextInputSchema;
+type JobContextInput = z.output<typeof JobContextInputSchema>;
+/**
+ * Full job context schema - includes rootJobId for stored/transmitted metadata
+ * This is what gets stored in the database and sent in progress events.
+ */
+declare const JobContextSchema: z.ZodObject<JobContextInputSchema["shape"] & {
+  rootJobId: z.ZodString;
+}, z.core.$loose>;
+/**
+ * Deduplication strategy for job queue
+ */
+declare const DeduplicationStrategyEnum: z.ZodEnum<{
+  none: "none";
+  skip: "skip";
+  replace: "replace";
+  coalesce: "coalesce";
+}>;
+type DeduplicationStrategy = z.output<typeof DeduplicationStrategyEnum>;
+/**
+ * Job options for job creation
+ */
+interface ProjectionJobContext {
+  id: string;
+  sourceEntity?: ProvenanceEntityReference | undefined;
+}
+interface JobOptions {
+  priority?: number;
+  maxRetries?: number;
+  delayMs?: number;
+  source: string;
+  metadata: JobContextInput;
+  deduplication?: DeduplicationStrategy;
+  deduplicationKey?: string;
+  /** Projection identity used to advance inherited causal provenance. */
+  projection?: ProjectionJobContext;
+  /**
+   * Override rootJobId for batch child jobs
+   * External callers should not use this - it's set automatically by the job queue service
+   * Batch jobs use this to link child jobs to the parent batch
+   */
+  rootJobId?: string;
+}
+//#endregion
+//#region ../../shared/utils/src/progress.d.ts
+/**
+ * Progress notification for long-running operations
+ */
+interface ProgressNotification {
+  progress: number;
+  total?: number;
+  message?: string;
+  rate?: number;
+  eta?: number;
+}
+/**
+ * Progress callback type
+ */
+type ProgressCallback = (notification: ProgressNotification) => Promise<void>;
+/**
+ * A simple utility class for managing progress reporting in nested operations
+ *
+ * @example
+ * ```typescript
+ * // Create from a callback
+ * const progress = ProgressReporter.from(sendProgress);
+ *
+ * // Report progress
+ * await progress?.report({
+ *   message: "Building project",
+ *   progress: 10,
+ *   total: 100
+ * });
+ *
+ * // Create sub-progress with scaled range
+ * const subProgress = progress?.createSub({ scale: { start: 10, end: 90 } });
+ *
+ * // Use with APIs that expect a callback
+ * await someApi(subProgress?.toCallback());
+ * ```
+ */
+/**
+ * What a progress reporter provides to callers.
+ *
+ * Consumers depend on this rather than on `CallbackProgressReporter`. The class
+ * carries a private callback and a private constructor, so nothing else can be
+ * assignable to it — which is why every test double had to be asserted into
+ * place, a cast that also erased the check on the members it did define.
+ */
+interface ProgressReporter {
+  createSub(options?: {
+    scale?: {
+      start: number;
+      end: number;
+    };
+  }): ProgressReporter;
+  report(notification: ProgressNotification): Promise<void>;
+  startHeartbeat(message: string, intervalMs?: number): void;
+  stopHeartbeat(): void;
+  toCallback(): ProgressCallback;
+}
+//#endregion
+//#region ../../shell/job-queue/src/batch-schemas.d.ts
+type BatchOperationSchema = z.ZodObject<{
+  type: z.ZodString;
+  data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+/**
+ * Schema for batch operation data
+ */
+declare const BatchOperationSchema: BatchOperationSchema;
+type BatchOperation = z.output<typeof BatchOperationSchema>;
+type BatchJobStatusSchema = z.ZodObject<{
+  batchId: z.ZodString;
+  totalOperations: z.ZodNumber;
+  completedOperations: z.ZodNumber;
+  failedOperations: z.ZodNumber;
+  currentOperation: z.ZodOptional<z.ZodString>;
+  errors: z.ZodArray<z.ZodString>;
+  status: z.ZodEnum<{
+    pending: "pending";
+    processing: "processing";
+    completed: "completed";
+    failed: "failed";
+  }>;
+  metadata: z.ZodOptional<typeof JobContextSchema>;
+}>;
+/**
+ * Schema for batch job status response
+ */
+declare const BatchJobStatusSchema: BatchJobStatusSchema;
+type BatchJobStatus = z.output<typeof BatchJobStatusSchema>;
+type BatchSchema = z.ZodObject<{
+  batchId: z.ZodString;
+  status: BatchJobStatusSchema;
+  metadata: z.ZodObject<{
+    operations: z.ZodArray<BatchOperationSchema>;
+    source: z.ZodString;
+    startedAt: z.ZodString;
+    metadata: typeof JobContextSchema;
+  }>;
+}>;
+/**
+ * Schema for batch result with full metadata
+ */
+declare const BatchSchema: BatchSchema;
+type Batch = z.output<typeof BatchSchema>;
+//#endregion
+//#region ../../shell/job-queue/src/types.d.ts
+/**
+ * Request for enqueueing a job in the core job queue service.
+ */
+interface JobQueueEnqueueRequest {
+  /** Job type to enqueue */
+  type: string;
+  /** Job payload passed to the registered handler */
+  data: unknown;
+  /** Optional queue behavior, routing metadata, and retry settings */
+  options?: JobOptions;
+}
+/** Ownership attached atomically when a worker dequeues a job. */
+interface JobClaimOptions {
+  workerSlotId: string;
+  workerSessionId: string;
+  leaseDurationMs: number;
+}
+type JobInfoSchema = z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodString;
+  data: z.ZodString;
+  status: z.ZodEnum<{
+    pending: "pending";
+    processing: "processing";
+    completed: "completed";
+    failed: "failed";
+  }>;
+  source: z.ZodNullable<z.ZodString>;
+  priority: z.ZodNumber;
+  retryCount: z.ZodNumber;
+  maxRetries: z.ZodNumber;
+  lastError: z.ZodNullable<z.ZodString>;
+  createdAt: z.ZodNumber;
+  scheduledFor: z.ZodNumber;
+  startedAt: z.ZodNullable<z.ZodNumber>;
+  completedAt: z.ZodNullable<z.ZodNumber>;
+  attemptId: z.ZodNullable<z.ZodString>;
+  workerSlotId: z.ZodNullable<z.ZodString>;
+  workerSessionId: z.ZodNullable<z.ZodString>;
+  leaseExpiresAt: z.ZodNullable<z.ZodNumber>;
+  attemptHeartbeatAt: z.ZodNullable<z.ZodNumber>;
+  runtimeUpdatedAt: z.ZodNullable<z.ZodNumber>;
+  metadata: typeof JobContextSchema;
+  progress: z.ZodNullable<z.ZodCustom<ProgressNotification, ProgressNotification>>;
+  result: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+}>;
+/**
+ * Simplified job info schema for external packages
+ * Avoids exposing the complex Drizzle-inferred JobQueue type
+ */
+declare const JobInfoSchema: JobInfoSchema;
+type JobInfo = z.output<typeof JobInfoSchema>;
+interface JobValidator<TInput = unknown> {
+  /** Validate and parse job data before durable enqueue. */
+  validateAndParse(data: unknown): TInput | null;
+}
+/** Immutable declaration derived from a registered durable handler. */
+interface JobExecutionRegistration {
+  readonly type: string;
+  readonly pluginId: string | undefined;
+}
+/**
+ * Job handler interface for processing specific job types
+ *
+ * @template TJobType - The job type string (can be any string for plugin extensibility)
+ * @template TInput - The input data type for the job
+ * @template TOutput - The output data type for the job
+ */
+interface JobHandler<_TJobType extends string = string, TInput = unknown, TOutput = unknown> extends JobValidator<TInput> {
+  /** Per-type execution deadline; falls back to the worker default. */
+  readonly executionTimeoutMs?: number | undefined;
+  /**
+   * Process a job of this type
+   * @param data - The job input data
+   * @param jobId - Unique identifier for this job
+   * @param progressReporter - Progress reporter for granular updates
+   */
+  process(data: TInput, jobId: string, progressReporter: ProgressReporter, signal: AbortSignal): Promise<TOutput>;
+  /**
+   * Handle job failure (optional)
+   */
+  /** Runs after successful terminal state is durably persisted. */
+  onTerminalSuccess?(data: TInput, jobId: string, progressReporter: ProgressReporter, signal: AbortSignal): Promise<void>;
+  onError?(error: Error, data: TInput, jobId: string, progressReporter: ProgressReporter, signal: AbortSignal): Promise<void>;
+  /** Runs once after the queue exhausts retries and persists terminal failure. */
+  onTerminalError?(error: Error, data: TInput, jobId: string, progressReporter: ProgressReporter, signal: AbortSignal): Promise<void>;
+}
+interface JobQueueStats {
+  pending: number;
+  processing: number;
+  failed: number;
+  completed: number;
+  total: number;
+}
+interface JobRuntimeUpdateCursor {
+  readonly updatedAt: number;
+  readonly jobId: string;
+}
+interface JobRuntimeUpdate {
+  readonly job: JobInfo;
+  readonly cursor: JobRuntimeUpdateCursor;
+}
+interface JobWorkerSessionDiagnostics {
+  total: number;
+  active: number;
+  stale: number;
+  latestHeartbeatAgeMs: number | null;
+}
+interface JobQueueDiagnostics {
+  totals: Omit<JobQueueStats, "total">;
+  byType: Array<{
+    type: string;
+    status: JobInfo["status"];
+    count: number;
+  }>;
+  oldestPendingAgeMs: number | null;
+  duePending: number;
+  oldestDuePendingAgeMs: number | null;
+  latestClaimAgeMs: number | null;
+  oldestProcessingAgeMs: number | null;
+  staleLeaseCount: number;
+  workerSessions: JobWorkerSessionDiagnostics;
+}
+interface JobQueueIdleOptions {
+  /** How long the queue must stay empty before it counts as settled. */
+  quietMs?: number;
+  /** Give up after this long and report what is still outstanding. */
+  timeoutMs?: number;
+  pollIntervalMs?: number;
+  signal?: AbortSignal;
+}
+/**
+ * Job queue service interface
+ */
+interface IJobQueueService {
+  /** Settle database readiness work before runtime services start. */
+  initialize?(): Promise<void>;
+  /**
+   * Register a job handler for a specific type
+   */
+  registerHandler(type: string, handler: JobHandler, pluginId?: string): void;
+  /**
+   * Unregister a job handler for a specific type
+   */
+  unregisterHandler(type: string): void;
+  /**
+   * Unregister all handlers for a specific plugin
+   */
+  unregisterPluginHandlers(pluginId: string): void;
+  /**
+   * Get a handler for a specific job type
+   */
+  getHandler(type: string): JobHandler | undefined;
+  /**
+   * Get the validator for a declared job type. Present in every registration
+   * mode, including validation-only processes that hold no executable handler.
+   */
+  getValidator(type: string): JobValidator | undefined;
+  /** Freeze handler declarations before runtime services can admit work. */
+  finalizeHandlerRegistrations(): readonly JobExecutionRegistration[];
+  /** Read the immutable handler declarations derived during boot. */
+  getExecutionRegistrations(): readonly JobExecutionRegistration[];
+  /**
+   * Enqueue a job for processing
+   */
+  enqueue(request: JobQueueEnqueueRequest): Promise<string>;
+  /** Dequeue and attach explicit attempt ownership. */
+  dequeue(claim?: JobClaimOptions): Promise<JobInfo | null>;
+  /** Register or supersede the live session for a stable worker slot. */
+  startWorkerSession(workerSlotId: string, workerSessionId: string, workerSessionTimeoutMs?: number): Promise<void>;
+  /** Persist worker liveness only while the session still owns its slot. */
+  heartbeatWorkerSession(workerSlotId: string, workerSessionId: string, workerSessionTimeoutMs?: number): Promise<boolean>;
+  /** Remove a normally stopped worker session. */
+  endWorkerSession(workerSlotId: string, workerSessionId: string): Promise<boolean>;
+  /** Renew a processing attempt's fenced lease. */
+  renewAttemptLease(jobId: string, attemptId: string, leaseDurationMs: number): Promise<boolean>;
+  /** Fence and persist a progress snapshot without extending the lease. */
+  recordAttemptProgress(jobId: string, attemptId: string, progress: ProgressNotification): Promise<boolean>;
+  /** Mark job as completed, fenced when an attempt token is supplied. */
+  complete(jobId: string, result: unknown, attemptId?: string): Promise<boolean>;
+  /** Mark job as failed, fenced when an attempt token is supplied. */
+  fail(jobId: string, error: Error, attemptId?: string): Promise<boolean>;
+  /** Update job data, fenced when an attempt token is supplied. */
+  update(jobId: string, data: unknown, attemptId?: string): Promise<boolean>;
+  /**
+   * Get job status by job ID
+   */
+  getStatus(jobId: string): Promise<JobInfo | null>;
+  /** Read all durable jobs belonging to one root operation. */
+  getJobsByRootJobId(rootJobId: string): Promise<JobInfo[]>;
+  /**
+   * Get job status by entity ID (for embedding jobs)
+   */
+  getStatusByEntityId(entityId: string): Promise<JobInfo | null>;
+  /**
+   * Get queue statistics
+   */
+  getStats(): Promise<JobQueueStats>;
+  /** Get bounded operational diagnostics without loading queue rows. */
+  getDiagnostics(now?: number): Promise<JobQueueDiagnostics>;
+  /** Settle once nothing is in flight and nothing new has arrived. */
+  waitForIdle(options?: JobQueueIdleOptions): Promise<void>;
+  /** Read durable processing and terminal updates for web-owned publication. */
+  getRuntimeUpdates(cursor: JobRuntimeUpdateCursor, limit?: number): Promise<JobRuntimeUpdate[]>;
+  /**
+   * Clean up old completed jobs
+   */
+  cleanup(olderThanMs: number): Promise<number>;
+  /**
+   * Get active jobs (pending or processing)
+   */
+  getActiveJobs(types?: string[]): Promise<JobInfo[]>;
+  /**
+   * Get recent jobs of any status, newest first
+   */
+  getRecentJobs(types?: string[], limit?: number): Promise<JobInfo[]>;
+  /**
+   * Get failed jobs
+   */
+  getFailedJobs(types?: string[]): Promise<JobInfo[]>;
+  /**
+   * Get registered job types
+   */
+  getRegisteredTypes(): string[];
+  /**
+   * Close the underlying database connection.
+   */
+  close(): void;
+}
+/**
+ * Unified jobs namespace interface
+ * Combines job queue and batch operations for shell/context usage
+ */
+interface IJobsNamespace {
+  /** Get active jobs, optionally filtered by type */
+  getActiveJobs(types?: string[]): Promise<JobInfo[]>;
+  /** Get recent jobs of any status, newest first, optionally filtered by type */
+  getRecentJobs(types?: string[], limit?: number): Promise<JobInfo[]>;
+  /** Get status of a specific job */
+  getStatus(jobId: string): Promise<JobInfo | null>;
+  /** Enqueue multiple operations as a batch */
+  enqueueBatch(operations: BatchOperation[], options: JobOptions, batchId: string, pluginId: string): Promise<string>;
+  /** Get all active batches */
+  getActiveBatches(): Promise<Batch[]>;
+  /** Get status of a specific batch */
+  getBatchStatus(batchId: string): Promise<BatchJobStatus | null>;
+}
+//#endregion
+//#region ../../shared/content-formatters/src/types.d.ts
+/**
+ * Interface for content formatters (human-editable content formatting)
+ *
+ * ContentFormatters handle bidirectional transformation between structured data
+ * and human-editable markdown templates. Unlike SchemaFormatters which are for
+ * one-way API response formatting, ContentFormatters support parsing edited
+ * content back into structured data.
+ */
+interface ContentFormatter<T = unknown> {
+  /**
+   * Format structured data into human-editable markdown
+   * @param data - The structured data to format
+   * @returns Human-editable markdown representation
+   */
+  format(data: T): string;
+  /**
+   * Parse human-editable markdown back into structured data
+   * @param content - The markdown content to parse
+   * @returns Structured data parsed from the markdown
+   * @throws Error if the content cannot be parsed
+   */
+  parse(content: string): T;
+}
+//#endregion
+//#region ../../shell/templates/src/types.d.ts
+/**
+ * Component type for layouts - using React
+ * Returns a React element
+ */
+type ComponentType<P = unknown> = {
+  bivarianceHack(props: P): ReactElement;
+}["bivarianceHack"];
+type TemplateDataSchema<T> = ZodType<T, unknown>;
+/**
+ * A runtime script that a template depends on. Site-builder collects
+ * these per route across all templates rendered on the page, dedupes
+ * by `src`, and injects them as <script> tags.
+ *
+ * Use this for non-hydration runtime scripts (background canvases,
+ * scroll observers, decorative animations) that should ONLY load on
+ * pages where the template actually renders — unlike the plugin-level
+ * head-script registration which fires on every page.
+ */
+interface RuntimeScript {
+  src: string;
+  defer?: boolean;
+  module?: boolean;
+}
+/**
+ * Unified template interface that bundles content generation and view rendering
+ * This is the single source of truth for what constitutes a template
+ */
+interface TemplateBase extends Omit<TemplateInput, "schema" | "layout" | "formatter"> {
+  formatter?: ContentFormatter<unknown>;
+  /**
+   * Opt-in content overlay. When set alongside a `dataSourceId`, the section's
+   * saved content is parsed with this formatter and merged over the datasource
+   * output (authored fields win), rather than the two being mutually exclusive.
+   * Lets a live datasource-backed section carry content-authored fields — e.g.
+   * a map whose data is live but whose hero copy is editable. Absent → the
+   * classic datasource-or-saved precedence is unchanged.
+   */
+  overlayFormatter?: ContentFormatter<unknown>;
+  /**
+   * Whether to retrieve relevant entities from the knowledge base
+   * and inject them as context before AI generation. Default: false.
+   */
+  useKnowledgeContext?: boolean;
+  /**
+   * Runtime script dependencies. Loaded only on routes where this
+   * template actually renders — site-builder collects from all
+   * templates on a route, dedupes by src, and injects into <head>.
+   */
+  runtimeScripts?: RuntimeScript[];
+  /**
+   * Static files this template needs served alongside the site — typically
+   * the file behind a runtimeScripts src. Keyed by output-relative path;
+   * site-builder writes each entry into the build output for routes that
+   * actually render this template.
+   */
+  staticAssets?: Record<string, string>;
+}
+/** A renderer template must parse to a JSON document before it can be snapshotted. */
+interface LayoutTemplate extends TemplateBase {
+  schema: TemplateDataSchema<JsonObject>;
+  layout: {
+    component?: ComponentType<unknown>;
+    fullscreen?: boolean;
+  };
+}
+/** Generation-only templates never enter the serializable site-build snapshot. */
+interface NonLayoutTemplate extends TemplateBase {
+  schema: TemplateDataSchema<unknown>;
+  layout?: undefined;
+}
+type Template = LayoutTemplate | NonLayoutTemplate;
+/**
+ * Template schema for validation
+ */
+declare const TemplateSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  schema: z.ZodUnknown;
+  basePrompt: z.ZodOptional<z.ZodString>;
+  useKnowledgeContext: z.ZodOptional<z.ZodBoolean>;
+  requiredPermission: z.ZodEnum<{
+    admin: "admin";
+    trusted: "trusted";
+    public: "public";
+  }>;
+  formatter: z.ZodOptional<z.ZodUnknown>;
+  overlayFormatter: z.ZodOptional<z.ZodUnknown>;
+  layout: z.ZodOptional<z.ZodObject<{
+    component: z.ZodOptional<z.ZodUnknown>;
+    fullscreen: z.ZodOptional<z.ZodBoolean>;
+  }>>;
+  dataSourceId: z.ZodOptional<z.ZodString>;
+}>;
+type TemplateInput = z.output<typeof TemplateSchema>;
+//#endregion
+//#region ../../shell/templates/src/permission-service.d.ts
+/**
+ * User permission level schema
+ */
+declare const UserPermissionLevelSchema: z.ZodEnum<{
+  admin: "admin";
+  trusted: "trusted";
+  public: "public";
+}>;
+type UserPermissionLevel = z.output<typeof UserPermissionLevelSchema>;
+declare const EntityActionSchema: z.ZodEnum<{
+  create: "create";
+  update: "update";
+  delete: "delete";
+  extract: "extract";
+  publish: "publish";
+}>;
+type EntityAction = z.output<typeof EntityActionSchema>;
+/**
+ * Required level for an entity action.
+ *
+ * `never` forbids the action through system tools regardless of caller level.
+ */
+declare const EntityActionRequiredLevelSchema: z.ZodEnum<{
+  never: "never";
+  admin: "admin";
+  trusted: "trusted";
+  public: "public";
+}>;
+type EntityActionRequiredLevel = z.output<typeof EntityActionRequiredLevelSchema>;
+declare const entityActionPolicyRuleSchema: z.ZodObject<{
+  create: z.ZodOptional<typeof EntityActionRequiredLevelSchema>;
+  update: z.ZodOptional<typeof EntityActionRequiredLevelSchema>;
+  delete: z.ZodOptional<typeof EntityActionRequiredLevelSchema>;
+  extract: z.ZodOptional<typeof EntityActionRequiredLevelSchema>;
+  publish: z.ZodOptional<typeof EntityActionRequiredLevelSchema>;
+}, z.core.$strict>;
+type EntityActionPolicyRule = z.output<typeof entityActionPolicyRuleSchema>;
+declare const entityActionPolicyConfigSchema: z.ZodRecord<z.ZodString, typeof entityActionPolicyRuleSchema>;
+type EntityActionPolicyConfigInput = z.input<typeof entityActionPolicyConfigSchema>;
+/**
+ * Generic interface for items with visibility
+ */
+interface WithVisibility {
+  visibility?: UserPermissionLevel;
+}
+/**
+ * Permission rule for pattern-based permission matching
+ */
+interface PermissionRule {
+  pattern: string;
+  level: UserPermissionLevel;
+}
+type PermissionRuleInput = PermissionRule;
+/**
+ * Configuration for the permission system
+ */
+interface ConfiguredPrincipalSeeds {
+  admins: string[];
+  anchors: string[];
+  trusted: string[];
+}
+interface PermissionConfig {
+  /** Callers with administrative permission. */
+  admins?: string[];
+  /** Caller identities that represent the brain's person anchor in chat. */
+  anchors?: string[];
+  trusted?: string[];
+  rules?: PermissionRuleInput[];
+  entityActions?: EntityActionPolicyConfigInput;
+}
+/**
+ * Additional context interfaces can provide for shared-space permission checks.
+ *
+ * Each interface normalizes its location concept (Discord channel/thread,
+ * Slack channel, Matrix room, ...) into the single canonical `channelId`
+ * before calling the resolver.
+ */
+interface PermissionLookupContext {
+  channelId?: string;
+  isBot?: boolean;
+  isGuest?: boolean;
+}
+interface PermissionServiceOptions {
+  /** Shared conversation space selectors, e.g. discord:123 or discord:project-* */
+  spaces?: string[];
+  /**
+   * A type's own minimum, from whoever registered it. It tightens wildcard
+   * defaults without relaxing stricter rules, including `never`, so a brain
+   * assembled without the canonical bundle cannot leave an admin-only type
+   * open. An explicit entry for the type still wins, action by action.
+   */
+  entityActionFloor?: (entityType: string) => EntityActionPolicyRule | undefined;
+}
+/**
+ * Centralized permission service for determining user permission levels
+ * Handles both explicit user lists and pattern-based rules
+ * Replaces the previous permission handler.
+ */
+declare class PermissionService {
+  private admins;
+  private anchors;
+  private trusted;
+  private readonly configuredPrincipalSeeds;
+  private rules;
+  private spaces;
+  private entityActions?;
+  private readonly entityActionFloor?;
+  constructor(config: PermissionConfig, options?: PermissionServiceOptions);
+  /**
+   * Determine the permission level for a user in a specific interface.
+   *
+   * Resolution order (load-bearing — locks user-facing trust semantics):
+   *   1. Explicit admin/trusted lists win — they encode operator intent.
+   *   2. Pattern rules granting admin/trusted win — same intent, broader.
+   *   3. Configured shared-space membership grants `trusted` — only raises
+   *      otherwise-public callers; never elevates to `admin`.
+   *   4. Public-fallback pattern rules apply.
+   *   5. Default `public`.
+   */
+  determineUserLevel(interfaceType: string, userId: string, context?: PermissionLookupContext): UserPermissionLevel;
+  /** Whether the caller is this professional brain's Anchor identity. */
+  isAnchor(interfaceType: string, userId: string): boolean;
+  getConfiguredPrincipalSeeds(): ConfiguredPrincipalSeeds;
+  replaceRuntimePrincipalState(state: RuntimeInterfacePrincipalState): void;
+  /**
+   * Return the merged entity action policy for an entity type.
+   * Entity-specific entries override the "*" default one action at a time.
+   */
+  getResolvedEntityActionPolicy(entityType: string): EntityActionPolicyRule | undefined;
+  getEntityActionRequiredLevel(entityType: string, action: EntityAction): EntityActionRequiredLevel | undefined;
+  getRequiredEntityActionLevel(entityType: string, action: EntityAction): EntityActionRequiredLevel | undefined;
+  canPerformEntityAction(userLevel: UserPermissionLevel | undefined, entityType: string, action: EntityAction): boolean;
+  assertEntityActionAllowed(entityType: string, action: EntityAction, userLevel: UserPermissionLevel | undefined): void;
+  /**
+   * Check if a user has a specific permission level or higher
+   * @param userLevel The user's actual permission level
+   * @param requiredLevel The required permission level
+   * @returns True if the user meets the permission requirement
+   */
+  hasPermission(userLevel: UserPermissionLevel, requiredLevel: UserPermissionLevel): boolean;
+  /**
+   * Filter items based on user permission level
+   * Works for tools, commands, or any item with a visibility property
+   * @param items Array of items with visibility levels
+   * @param userLevel The user's permission level
+   * @returns Filtered array of items the user can access
+   */
+  filterByPermission<T extends WithVisibility>(items: T[], userLevel: UserPermissionLevel): T[];
+  /**
+   * Static method to check if a permission level meets the required level
+   * Used by Shell for interface-based permission checking (commands, templates, etc.)
+   * Maintains compatibility with existing Shell.generateContent() usage
+   */
+  static hasPermission(grantedLevel: UserPermissionLevel, requiredLevel: UserPermissionLevel): boolean;
+  private getPatternLevel;
+  private matchesConfiguredSpace;
+}
+//#endregion
+//#region ../../shell/templates/src/render-types.d.ts
+/**
+ * Renderer output formats supported by view templates.
+ */
+declare const OutputFormatSchema: z.ZodEnum<{
+  web: "web";
+  image: "image";
+  pdf: "pdf";
+}>;
+type OutputFormat = z.output<typeof OutputFormatSchema>;
+/**
+ * Renderer types for different output formats
+ */
+type WebRenderer<T = unknown> = ComponentType<T> | string;
+type ImageRenderer<T = unknown> = ComponentType<T> | string;
+type PdfRenderer<T = unknown> = ComponentType<T> | string;
+type MediaRenderer<T = unknown> = ImageRenderer<T> | PdfRenderer<T>;
+type Renderer<T = unknown> = WebRenderer<T> | MediaRenderer<T>;
+/**
+ * View template with support for multiple output formats
+ */
+interface ViewTemplate<T extends JsonObject = JsonObject> {
+  name: string;
+  schema: TemplateDataSchema<T>;
+  description?: string;
+  pluginId: string;
+  renderers: {
+    web?: WebRenderer<T>;
+    image?: ImageRenderer<T>;
+    pdf?: PdfRenderer<T>;
+  };
+  fullscreen?: boolean;
+  providerId?: string;
+  formatter?: ContentFormatter<T>;
+  /** Runtime script dependencies (see Template.runtimeScripts). */
+  runtimeScripts?: RuntimeScript[];
+  /** Static files behind runtimeScripts srcs (see Template.staticAssets). */
+  staticAssets?: Record<string, string>;
+}
+/**
+ * View template registry interface
+ */
+/**
+ * The render service as consumers use it.
+ *
+ * `hasRenderer` and `listFormats` were missing here even though callers use
+ * both: consumers took the `RenderService` class instead, which meant a test
+ * double had to be asserted into a type with private state.
+ */
+interface ViewTemplateRegistry {
+  get(name: string): ViewTemplate | undefined;
+  list(): ViewTemplate[];
+  validate(templateName: string, content: unknown): boolean;
+  findViewTemplate(filter: {
+    name?: string;
+    pluginId?: string;
+    namePattern?: string;
+  }): ViewTemplate | undefined;
+  getRenderer(templateName: string, format: OutputFormat): Renderer | undefined;
+  hasRenderer(templateName: string, format: OutputFormat): boolean;
+  listFormats(templateName: string): OutputFormat[];
+}
+//#endregion
+//#region ../../shell/messaging-service/src/message-validator.d.ts
+type MessageValidationResult<T> = {
+  valid: true;
+  data: T;
+} | {
+  valid: false;
+  error: string;
+};
+type MessageValidationSchema<T> = ZodType<T, unknown>;
+//#endregion
+//#region ../../shell/messaging-service/src/base-types.d.ts
+/**
+ * Simple response schema for message handlers
+ */
+declare const messageResponseSchema: z.ZodObject<{
+  success: z.ZodBoolean;
+  data: z.ZodOptional<z.ZodUnknown>;
+  error: z.ZodOptional<z.ZodString>;
+}>;
+/** A handler's reply: the parsed response with its data narrowed to T, or a no-op. */
+type MessageResponse<T = unknown> = (Omit<z.output<typeof messageResponseSchema>, "data"> & {
+  data?: T | undefined;
+}) | {
+  noop: true;
+};
+type BaseMessageSchema = z.ZodObject<{
+  id: z.ZodString;
+  timestamp: z.ZodString;
+  type: z.ZodString;
+  source: z.ZodString;
+  target: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+/**
+ * Base message schema - all messages must have these fields
+ */
+declare const baseMessageSchema: BaseMessageSchema;
+type BaseMessage = z.output<typeof baseMessageSchema>;
+type MessageWithPayload<T = unknown> = BaseMessage & {
+  payload: T;
+};
+/**
+ * Message handler type
+ */
+type MessageHandler<T = unknown, R = unknown> = (message: MessageWithPayload<T>) => Promise<MessageResponse<R>> | MessageResponse<R>;
+/**
+ * Options for sending messages
+ */
+interface MessageSendOptions {
+  /** Optional target for filtered delivery */
+  target?: string;
+  /** Optional metadata for filtered delivery */
+  metadata?: Record<string, unknown>;
+  /** If true, all matching handlers are called regardless of responses */
+  broadcast?: boolean;
+}
+interface MessageSendRequest<T = unknown> extends MessageSendOptions {
+  type: string;
+  payload: T;
+}
+interface MessageBusSendRequest<T = unknown> extends MessageSendRequest<T> {
+  sender: string;
+}
+//#endregion
+//#region ../../shell/messaging-service/src/types.d.ts
+/**
+ * Subscription filter for targeted message delivery
+ */
+interface SubscriptionFilter {
+  source?: string | RegExp;
+  target?: string | RegExp;
+  metadata?: Record<string, unknown>;
+  predicate?: (message: MessageWithPayload) => boolean;
+}
+/**
+ * Message bus interface
+ */
+interface IMessageBus {
+  send<T = unknown, R = unknown>(request: MessageBusSendRequest<T>): Promise<MessageResponse<R>>;
+  subscribe<T = unknown, R = unknown>(type: string, handler: MessageHandler<T, R>, filter?: SubscriptionFilter): () => void;
+  /** Collect one response from every matching handler, in registration order. */
+  collect<T = unknown, R = unknown>(request: MessageBusSendRequest<T>): Promise<MessageResponse<R>[]>;
+  validateMessage<T>(message: unknown, schema: MessageValidationSchema<T>): MessageValidationResult<T>;
+  unsubscribe<T = unknown, R = unknown>(type: string, handler: MessageHandler<T, R>): void;
+  hasHandlers?(type: string): boolean;
+  getHandlerCount(messageType: string): number;
+  getTargetedHandlerCount(messageType: string, target: string): number;
+  clearHandlers(messageType: string): void;
+  clearAllHandlers(): void;
+}
+//#endregion
+//#region ../../shell/mcp-service/src/types.d.ts
+/**
+ * Tool visibility levels for permission control
+ * Uses the same levels as UserPermissionLevel for consistency
+ */
+type ToolVisibility = UserPermissionLevel;
+/**
+ * Tool execution context
+ * Provides progress reporting and routing metadata
+ */
+interface ToolContext {
+  progressToken?: string | number;
+  sendProgress?: (notification: ProgressNotification) => Promise<void>;
+  /** Cancellation for the active request; handlers may opt in. */
+  signal?: AbortSignal;
+  interfaceType: string;
+  actor: ActorRef;
+  displayName?: string;
+  conversationId?: string;
+  channelId?: string;
+  channelName?: string;
+  runId?: string;
+  toolCallId?: string;
+  /** Caller's permission level. Tools that read/write entities use this to derive
+   *  the content-visibility scope they are allowed to see. */
+  userPermissionLevel?: UserPermissionLevel;
+  /** Whether the authenticated caller is the brain's configured Anchor. */
+  isAnchor?: boolean;
+}
+/**
+ * Success response schema
+ */
+declare const toolSuccessSchema: z.ZodObject<{
+  success: z.ZodLiteral<true>;
+  data: z.ZodOptional<z.ZodUnknown>;
+  message: z.ZodOptional<z.ZodString>;
+  cached: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+/**
+ * Error response schema
+ */
+declare const toolErrorSchema: z.ZodObject<{
+  success: z.ZodLiteral<false>;
+  error: z.ZodString;
+  code: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Confirmation response schema
+ * Tools return this when an operation needs user approval.
+ * The agent service detects this shape and enters the confirmation flow.
+ */
+declare const toolConfirmationSchema: z.ZodObject<{
+  needsConfirmation: z.ZodLiteral<true>;
+  toolName: z.ZodString;
+  summary: z.ZodString;
+  completionSummary: z.ZodOptional<z.ZodString>;
+  preview: z.ZodOptional<z.ZodString>;
+  args: z.ZodUnknown;
+}, z.core.$strict>;
+/**
+ * Standardized tool response schema
+ * All tools return one of: success, error, or confirmation request.
+ */
+declare const toolResponseSchema: z.ZodUnion<readonly [typeof toolSuccessSchema, typeof toolErrorSchema, typeof toolConfirmationSchema]>;
+type ToolResponse = z.output<typeof toolResponseSchema>;
+type ToolSideEffects = "none" | "writes" | "external";
+type DirectMcpExposure = "none" | "basic" | "debug";
+type ToolInputSchema = ZodRawShape;
+type ToolOutputSchema = z.ZodType;
+type MCPProtocolMode = "basic" | "debug";
+/**
+ * Tool definition
+ * @template TOutput - The output type, defaults to ToolResponse for backward compatibility
+ */
+interface Tool<TOutput = ToolResponse> {
+  name: string;
+  description: string;
+  inputSchema: ToolInputSchema;
+  outputSchema?: ToolOutputSchema;
+  handler: (input: unknown, context: ToolContext) => Promise<TOutput>;
+  visibility?: ToolVisibility;
+  /** Declares whether this tool is safe to repeat/cache within one model turn. Undefined defaults to not cacheable. */
+  sideEffects?: ToolSideEffects;
+  /** Whether the LLM agent may receive this tool in its callable tool set. Defaults to true. */
+  agentTool?: boolean;
+  /** Direct external MCP protocol exposure. Defaults to debug; basic exposure requires an explicit opt-in. */
+  directMcpExposure?: DirectMcpExposure;
+  /** MCP protocol annotations advertised to external clients. Derived from sideEffects when omitted. */
+  annotations?: ToolAnnotations;
+  /** Optional CLI metadata — makes this tool invocable as a brain CLI command */
+  cli?: {
+    /** CLI command name (e.g. "list", "sync", "build") */
+    name: string;
+  };
+}
+/**
+ * Resource definition
+ */
+interface Resource {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+  handler: () => Promise<{
+    contents: Array<{
+      text: string;
+      uri: string;
+      mimeType?: string;
+    }>;
+  }>;
+}
+/**
+ * Variables extracted from a URI template.
+ * Generic parameter ensures handlers receive typed vars, not loose index signatures.
+ */
+type ResourceVars<K extends string = string> = { [P in K]: string; };
+/**
+ * A parameterized resource with URI template (e.g. "entity://{type}/{id}")
+ */
+interface ResourceTemplate<K extends string = string> {
+  name: string;
+  uriTemplate: string;
+  description?: string;
+  mimeType?: string;
+  /** List all concrete resources matching this template (for resources/list) */
+  list?: () => Promise<Array<{
+    uri: string;
+    name: string;
+  }>>;
+  /** Autocomplete values for template variables (populates client selectors) */
+  complete?: Record<K, (value: string, context?: {
+    arguments?: Partial<ResourceVars<K>>;
+  }) => string[] | Promise<string[]>>;
+  /** Read a single resource by resolved template variables */
+  handler: (vars: ResourceVars<K>) => Promise<{
+    contents: Array<{
+      text: string;
+      uri: string;
+      mimeType?: string;
+    }>;
+  }>;
+}
+/**
+ * An MCP prompt — parameterized message template for client prompt pickers
+ */
+interface Prompt {
+  name: string;
+  description?: string;
+  args: Record<string, {
+    description: string;
+    required?: boolean;
+  }>;
+  handler: (args: Record<string, string>) => Promise<{
+    messages: Array<{
+      role: "user" | "assistant";
+      content: {
+        type: "text";
+        text: string;
+      };
+    }>;
+  }>;
+  /** Default: "admin" — prompt bodies can reference restricted workflows,
+   *  so they ship as admin-only unless explicitly marked. */
+  visibility?: ToolVisibility;
+}
+/**
+ * Minimal interface exposed to transport layers
+ * Only provides what's needed to connect transports to the MCP server
+ */
+interface IMCPTransport {
+  /**
+   * Get the underlying MCP server for transport layers to connect to
+   * Transport layers should import McpServer from @modelcontextprotocol/server directly
+   */
+  getMcpServer(): McpServer;
+  /**
+   * Create a fresh MCP server instance with all registered tools/resources.
+   * Stateless HTTP invokes this for every authenticated request.
+   */
+  createMcpServer(permissionLevel?: UserPermissionLevel): McpServer;
+  /**
+   * Set the permission level for this transport
+   */
+  setPermissionLevel(level: UserPermissionLevel): void;
+  /** Set whether the transport's configured caller is the brain Anchor. */
+  setAnchorStatus?(isAnchor: boolean): void;
+  /** Select which registered tools are exposed on the external MCP protocol server. */
+  setProtocolMode(mode: MCPProtocolMode): void;
+}
+/**
+ * Tool registration info
+ */
+interface ToolInfo {
+  name: string;
+  description: string;
+  pluginId: string;
+}
+//#endregion
+//#region ../../shell/entity-service/src/datasource-registry.d.ts
+/**
+ * The data source registry as consumers use it.
+ *
+ * They depend on this rather than on `InMemoryDataSourceRegistry`: the class
+ * has private state and a private constructor, so nothing else can be
+ * assignable to it — which is why every test double had to be asserted in.
+ */
+interface DataSourceRegistry {
+  register(dataSource: DataSource): void;
+  unregister(id: string): void;
+  get(id: string): DataSource | undefined;
+  has(id: string): boolean;
+  list(): DataSource[];
+  getIds(): string[];
+  getByCapability(capability: keyof DataSourceCapabilities): DataSource[];
+  find(predicate: (dataSource: DataSource) => boolean): DataSource[];
+  clear(): void;
+}
+//#endregion
+//#region ../../shell/plugins/src/manager/daemon-types.d.ts
+/**
+ * Daemon health status schema
+ */
+declare const DaemonHealthSchema: z.ZodObject<{
+  status: z.ZodEnum<{
+    healthy: "healthy";
+    warning: "warning";
+    error: "error";
+    unknown: "unknown";
+  }>;
+  message: z.ZodOptional<z.ZodString>;
+  lastCheck: z.ZodOptional<z.ZodDate>;
+  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+type DaemonHealth = z.output<typeof DaemonHealthSchema>;
+/**
+ * Daemon status info schema for validation
+ */
+declare const DaemonStatusInfoSchema: z.ZodObject<{
+  name: z.ZodString;
+  pluginId: z.ZodString;
+  status: z.ZodString;
+  health: z.ZodOptional<typeof DaemonHealthSchema>;
+}>;
+/**
+ * Daemon interface for long-running interface processes
+ */
+interface Daemon {
+  /**
+   * Start the daemon - called when plugin is initialized
+   */
+  start: () => Promise<void>;
+  /**
+   * Stop the daemon - called when plugin is unloaded/shutdown
+   */
+  stop: () => Promise<void>;
+  /**
+   * Optional health check - called periodically to monitor daemon health
+   */
+  healthCheck?: () => Promise<DaemonHealth>;
+}
+//#endregion
+//#region ../../shell/content-service/src/generation-context.d.ts
+/** Context shared by immediate and durable template-based generation. */
+declare const generationContextSchema: z.ZodObject<{
+  prompt: z.ZodOptional<z.ZodString>;
+  conversationHistory: z.ZodOptional<z.ZodString>;
+  data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  representedIdentity: z.ZodOptional<z.ZodEnum<{
+    brain: "brain";
+    anchor: "anchor";
+    none: "none";
+  }>>;
+  styleGuide: z.ZodOptional<z.ZodObject<{
+    voice: z.ZodOptional<z.ZodString>;
+    visual: z.ZodOptional<z.ZodString>;
+  }>>;
+}>;
+type GenerationContext = z.output<typeof generationContextSchema>;
+//#endregion
+//#region ../../shell/content-service/src/generation-authorization.d.ts
+/** Supplied by a trusted runtime binding, never by a tool's input schema. */
+interface GenerationCaller {
+  actor: ActorRef;
+  permissionLevel: UserPermissionLevel;
+}
+/** Durable delegation: account binding and an admission-time permission ceiling. */
+interface GenerationAuthority {
+  actor: ActorRef;
+  permissionCeiling: UserPermissionLevel;
+  principalId?: string | undefined;
+}
+interface GenerationAccess {
+  permissionLevel: UserPermissionLevel;
+  visibilityScope: ContentVisibility;
+}
+//#endregion
+//#region ../../shell/content-service/src/generation-contracts.d.ts
+interface DurableGenerationContext extends Omit<GenerationContext, "data"> {
+  data?: JsonObject | undefined;
+}
+interface ContentGenerationDestination {
+  entityType: string;
+  idPath: EntityIdPath;
+  metadata: JsonObject;
+  visibility?: ContentVisibility | undefined;
+}
+interface ContentGenerationDestinationInput {
+  entityType: string;
+  idPath: EntityIdPathInput;
+  metadata: JsonObject;
+  visibility?: ContentVisibility | undefined;
+}
+interface ContentGenerationTarget {
+  templateName: string;
+  context: DurableGenerationContext;
+  destination: ContentGenerationDestination;
+}
+interface ContentGenerationTargetInput {
+  templateName: string;
+  context?: DurableGenerationContext;
+  destination: ContentGenerationDestinationInput;
+}
+interface ContentGenerationOptions {
+  dryRun?: boolean;
+  force?: boolean;
+}
+interface ContentGenerationRequestInput {
+  caller: GenerationCaller;
+  targets: ContentGenerationTargetInput[];
+  options?: ContentGenerationOptions;
+  /** Template names are local to this plugin and scoped by the runtime. */
+  pluginId?: string;
+}
+interface PersistedContentGenerationDestination {
+  entityType: string;
+  entityId: string;
+  metadata: JsonObject;
+  visibility: ContentVisibility;
+}
+interface ContentGenerationJobData {
+  authority: GenerationAuthority;
+  templateName: string;
+  context: DurableGenerationContext;
+  destination: PersistedContentGenerationDestination;
+  expectedRevision: string | null;
+}
+declare const contentGenerationSkipReasons: readonly ["content-exists", "template-not-found", "template-cannot-generate"];
+type ContentGenerationSkipReason = (typeof contentGenerationSkipReasons)[number];
+/** `index` is the target's position in the request, so results keep its order. */
+interface PlannedContentGeneration {
+  readonly index: number;
+  readonly target: ContentGenerationTarget;
+  readonly entityId: string;
+  readonly jobData: ContentGenerationJobData;
+}
+interface SkippedContentGeneration {
+  readonly index: number;
+  readonly target: ContentGenerationTarget;
+  readonly entityId: string;
+  readonly reason: ContentGenerationSkipReason;
+}
+interface ContentGenerationPlan {
+  readonly planned: readonly PlannedContentGeneration[];
+  readonly skipped: readonly SkippedContentGeneration[];
+  readonly totalTargets: number;
+}
+interface ContentGenerationItemBase {
+  readonly destination: {
+    readonly entityType: string;
+    readonly idPath: EntityIdPath;
+    readonly entityId: string;
+  };
+  readonly templateName: string;
+}
+/** One admission decision per requested target, in request order. */
+type ContentGenerationItemResult = (ContentGenerationItemBase & {
+  readonly status: "planned";
+}) | (ContentGenerationItemBase & {
+  readonly status: "queued";
+  readonly jobId: string;
+}) | (ContentGenerationItemBase & {
+  readonly status: "skipped";
+  readonly reason: ContentGenerationSkipReason;
+});
+interface ContentGenerationBatchResult {
+  readonly items: readonly ContentGenerationItemResult[];
+  readonly totalTargets: number;
+  readonly plannedTargets: number;
+  readonly queuedTargets: number;
+  readonly skippedTargets: number;
+  readonly batchId?: string;
+}
+//#endregion
+//#region ../../shell/content-service/src/generation-submission.d.ts
+/**
+ * Runtime wiring, never author-supplied tool input. The plugin layer owns job
+ * options and attribution; content-service only decides what to enqueue.
+ */
+interface GenerationQueueBinding {
+  /** Existing root job ID to share; a fresh one is allocated otherwise. */
+  batchId?: string | undefined;
+  enqueue(jobData: ContentGenerationJobData, batchId: string): Promise<string>;
+}
+//#endregion
+//#region ../../shell/content-service/src/types.d.ts
+type ContentTemplateDataSchema<T> = ZodType<T, unknown>;
+/**
+ * Zod schema for ContentTemplate validation (used in plugin configurations)
+ */
+declare const ContentTemplateSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  schema: z.ZodUnknown;
+  basePrompt: z.ZodOptional<z.ZodString>;
+  requiredPermission: z.ZodEnum<{
+    admin: "admin";
+    trusted: "trusted";
+    public: "public";
+  }>;
+  formatter: z.ZodOptional<z.ZodUnknown>;
+  dataSourceId: z.ZodOptional<z.ZodString>;
+  layout: z.ZodOptional<z.ZodObject<{
+    component: z.ZodUnknown;
+    description: z.ZodOptional<z.ZodString>;
+    packageName: z.ZodOptional<z.ZodString>;
+  }>>;
+}>;
+type ContentTemplateInput = z.output<typeof ContentTemplateSchema>;
+/**
+ * ContentTemplate for reusable generation patterns and view rendering
+ */
+interface ContentTemplate<T = unknown> extends Omit<ContentTemplateInput, "schema" | "formatter"> {
+  schema: ContentTemplateDataSchema<T>;
+  formatter?: ContentFormatter<T>;
+  dataSourceId?: string;
+}
+/**
+ * Options for content resolution with multiple strategies
+ */
+interface ResolutionOptions {
+  /** Look up previously saved content from entity storage */
+  savedContent?: {
+    entityType: string;
+    entityId: string;
+  };
+  /** Parameters for DataSource fetch operation */
+  dataParams?: unknown;
+  /** Format for DataSource transform operation (e.g., "list" or "detail") */
+  transformFormat?: string;
+  /** Static fallback content */
+  fallback?: unknown;
+  /**
+   * Whether to filter to only published/complete content
+   * Set by site-builder: true for production, false for preview
+   */
+  publishedOnly?: boolean;
+  /**
+   * Visibility scope to enforce on entity lookups within this resolution.
+   * Set by site-builder: "public" for production, anchor scope for preview.
+   * Undefined fails closed at the entity-service chokepoint to "public".
+   */
+  visibilityScope?: ContentVisibility;
+}
+/**
+ * Public interface for ContentService
+ * Used by plugins and for testing
+ */
+/** Runtime-only generation settings; never author input. */
+interface GenerateContentOptions {
+  pluginId?: string | undefined;
+  signal?: AbortSignal | undefined;
+  /** Fixes every read to the authorized output visibility (durable jobs). */
+  visibilityScope?: ContentVisibility | undefined;
+}
+interface ContentService {
+  /**
+   * Authorize a durable generation job: the full policy when it starts, and
+   * current authority over the final fields when `persisted` is supplied.
+   */
+  authorizeGenerationWrite(data: ContentGenerationJobData, persisted?: Readonly<BaseEntity>): Promise<GenerationAccess>;
+  submitGeneration(request: ContentGenerationRequestInput, binding: GenerationQueueBinding, signal?: AbortSignal): Promise<ContentGenerationBatchResult>;
+  /** Plan validated, template-backed generation without enqueueing work. */
+  planGeneration(request: ContentGenerationRequestInput, signal?: AbortSignal): Promise<ContentGenerationPlan>;
+  /**
+   * Get a registered template
+   */
+  getTemplate(name: string): ContentTemplate<unknown> | null;
+  /**
+   * List all available templates
+   */
+  listTemplates(): ContentTemplate<unknown>[];
+  /**
+   * Resolve content for a template using multiple resolution strategies
+   * Priority order: DataSource fetch -> saved content -> fallback
+   *
+   * Returns `unknown`: the value is validated against the *template's* schema,
+   * which a caller-chosen type parameter has no relationship to. Callers that
+   * need a specific type should parse it.
+   */
+  resolveContent(templateName: string, options?: ResolutionOptions, pluginId?: string): Promise<unknown>;
+  /**
+   * Generate content using a template with entity-aware context.
+   *
+   * Returns unknown: generation validates against the template's schema, and
+   * callers parse the shape they need.
+   */
+  generateContent(templateName: string, context?: GenerationContext, options?: GenerateContentOptions): Promise<unknown>;
+  /**
+   * Format content using a template's formatter
+   */
+  formatContent<T = unknown>(templateName: string, data: T, options?: {
+    truncate?: number;
+    pluginId?: string;
+  }): string;
+  /**
+   * Parse existing content using a template's formatter. Returns unknown:
+   * the formatter parses to the template's own shape.
+   */
+  parseContent(templateName: string, content: string, pluginId?: string): unknown;
+}
+//#endregion
+//#region ../../shell/ai-service/src/types.d.ts
+type AIGenerationSchema<T> = ZodType<T>;
+/**
+ * Aspect ratio for image generation
+ */
+type AspectRatio = "1:1" | "16:9" | "9:16" | "4:3" | "3:4";
+/**
+ * Options for image generation
+ */
+interface ImageGenerationOptions {
+  /** Aspect ratio for the generated image (default: "16:9") */
+  aspectRatio?: AspectRatio;
+  /** Cancel the underlying provider request. */
+  signal?: AbortSignal;
+}
+/**
+ * Result of image generation
+ */
+interface ImageGenerationResult {
+  /** Raw base64-encoded image data */
+  base64: string;
+  /** Data URL format: data:image/png;base64,... */
+  dataUrl: string;
+}
+//#endregion
+//#region ../../shared/contracts/src/chat.d.ts
+type Strict<Shape extends z.ZodRawShape> = z.ZodObject<Shape, z.core.$strict>;
+/** Pinned when a guest conversation is created; reads cannot renew retention. */
+declare const guestRetentionSchema: Strict<{
+  idleSeconds: z.ZodNumber;
+  maxAgeSeconds: z.ZodNumber;
+}>;
+declare const guestConversationOwnershipSchema: Strict<{
+  visitorId: z.ZodString;
+  retention: typeof guestRetentionSchema;
+}>;
+type GuestConversationOwnership = z.output<typeof guestConversationOwnershipSchema>;
+//#endregion
+//#region ../../shell/conversation-service/src/schema.d.ts
+type ConversationTextColumn<TTable extends string, TName extends string, TNotNull extends boolean, TPrimaryKey extends boolean = false> = SqliteTextColumn<TTable, TName, TNotNull, false, TPrimaryKey, false, TNotNull extends true ? string : string | null>;
+type ConversationsTable = SQLiteTableWithColumns<{
+  name: "conversations";
+  schema: undefined;
+  columns: {
+    id: ConversationTextColumn<"conversations", "id", true, true>;
+    sessionId: ConversationTextColumn<"conversations", "session_id", true>;
+    interfaceType: ConversationTextColumn<"conversations", "interface_type", true>;
+    channelId: ConversationTextColumn<"conversations", "channel_id", true>;
+    personId: ConversationTextColumn<"conversations", "person_id", false>;
+    started: ConversationTextColumn<"conversations", "started", true>;
+    lastActive: ConversationTextColumn<"conversations", "last_active", true>;
+    metadata: ConversationTextColumn<"conversations", "metadata", false>;
+    created: ConversationTextColumn<"conversations", "created", true>;
+    updated: ConversationTextColumn<"conversations", "updated", true>;
+  };
+  dialect: "sqlite";
+}>;
+type MessagesTable = SQLiteTableWithColumns<{
+  name: "messages";
+  schema: undefined;
+  columns: {
+    id: ConversationTextColumn<"messages", "id", true, true>;
+    conversationId: ConversationTextColumn<"messages", "conversation_id", true>;
+    role: ConversationTextColumn<"messages", "role", true>;
+    content: ConversationTextColumn<"messages", "content", true>;
+    timestamp: ConversationTextColumn<"messages", "timestamp", true>;
+    metadata: ConversationTextColumn<"messages", "metadata", false>;
+  };
+  dialect: "sqlite";
+}>;
+/**
+ * Conversations table - tracks conversation sessions
+ */
+declare const conversations: ConversationsTable;
+/**
+ * Messages table - stores individual messages in conversations
+ */
+declare const messages: MessagesTable;
+type Conversation = typeof conversations.$inferSelect;
+type Message = typeof messages.$inferSelect;
+//#endregion
+//#region ../../shell/conversation-service/src/types.d.ts
+/**
+ * Metadata for a conversation
+ */
+interface ConversationMetadata {
+  guest?: GuestConversationOwnership;
+  channelName: string;
+  interfaceType: string;
+  channelId: string;
+}
+/**
+ * Service interface for conversation storage
+ */
+/**
+ * Options for retrieving messages
+ */
+interface GetMessagesOptions {
+  limit?: number;
+  range?: {
+    start: number;
+    end: number;
+  };
+}
+interface StartConversationRequest {
+  sessionId: string;
+  interfaceType: string;
+  channelId: string;
+  personId?: string;
+  metadata: ConversationMetadata;
+}
+declare const conversationMessageActorSchema: z.ZodObject<{
+  identity: typeof actorRefSchema;
+  interfaceType: z.ZodString;
+  role: typeof messageRoleSchema;
+  displayName: z.ZodOptional<z.ZodString>;
+  username: z.ZodOptional<z.ZodString>;
+  isBot: z.ZodOptional<z.ZodBoolean>;
+}>;
+type ConversationMessageActor = z.output<typeof conversationMessageActorSchema>;
+declare const conversationMessageSourceSchema: z.ZodObject<{
+  messageId: z.ZodOptional<z.ZodString>;
+  channelId: z.ZodOptional<z.ZodString>;
+  channelName: z.ZodOptional<z.ZodString>;
+  threadId: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+type ConversationMessageSource = z.output<typeof conversationMessageSourceSchema>;
+interface AddConversationMessageRequest {
+  conversationId: string;
+  role: MessageRole;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+interface UpdateConversationMetadataRequest {
+  conversationId: string;
+  metadata: Record<string, unknown>;
+}
+interface ListConversationsOptions {
+  limit?: number;
+  offset?: number;
+  /** Match title or message text literally, case-insensitively. */
+  query?: string;
+  /** Omit to include both active and archived conversations. */
+  archived?: boolean;
+  updatedAfter?: string;
+  interfaceType?: string;
+  sessionId?: string;
+  channelId?: string;
+  personId?: string;
+}
+interface IConversationService {
+  /** Settle non-fatal database readiness work (connection pragmas). */
+  initialize?(): Promise<void>;
+  startConversation(request: StartConversationRequest): Promise<string>;
+  addMessage(request: AddConversationMessageRequest): Promise<void>;
+  getMessages(conversationId: string, options?: GetMessagesOptions): Promise<Message[]>;
+  countMessages(conversationId: string): Promise<number>;
+  getConversation(conversationId: string): Promise<Conversation | null>;
+  listConversations(options?: ListConversationsOptions): Promise<Conversation[]>;
+  updateConversationMetadata(request: UpdateConversationMetadataRequest): Promise<boolean>;
+  deleteConversation(conversationId: string): Promise<boolean>;
+  /** Trusted host maintenance; never an anonymous conversation action. */
+  deleteExpiredGuestConversations(limit?: number): Promise<number>;
+  searchConversations(query: string, sessionId?: string): Promise<Conversation[]>;
+  close(): void;
+}
+//#endregion
+//#region ../../shell/identity-service/src/brain-character-schema.d.ts
+interface BrainCharacter {
+  name: string;
+  role: string;
+  purpose: string;
+  values: string[];
+}
+//#endregion
+//#region ../../shell/identity-service/src/anchor-profile-schema.d.ts
+interface AnchorProfileSocialLink {
+  platform: "github" | "instagram" | "linkedin" | "email" | "website";
+  url: string;
+  label?: string | undefined;
+}
+interface AnchorProfile {
+  name: string;
+  organization?: string | undefined;
+  description?: string | undefined;
+  avatar?: string | undefined;
+  website?: string | undefined;
+  email?: string | undefined;
+  socialLinks?: AnchorProfileSocialLink[] | undefined;
+}
+//#endregion
+//#region ../../shell/identity-service/src/profile-kind-registry.d.ts
+declare const profileCategorySchema: z.ZodEnum<{
+  person: "person";
+  team: "team";
+  organization: "organization";
+}>;
+type ProfileCategory = z.infer<typeof profileCategorySchema>;
+interface ProfileKindLabels {
+  singular: string;
+  plural: string;
+}
+interface ProfileKindDefinition {
+  kind: string;
+  category: ProfileCategory;
+  fields: FrontmatterSchema;
+  labels: ProfileKindLabels;
+}
+interface ResolvedProfileKind {
+  kind: string;
+  category: ProfileCategory;
+  labels: ProfileKindLabels;
+}
+type ResolvedProfileSelection = ResolvedProfileKind | null;
+interface IProfileKindRegistry {
+  register(pluginId: string, definition: ProfileKindDefinition): void;
+  unregisterPlugin(pluginId: string): void;
+  finalize(): ResolvedProfileSelection;
+  getResolved(): ResolvedProfileSelection;
+  getSelectedDefinition(): ProfileKindDefinition | undefined;
+  isFinalized(): boolean;
+}
+//#endregion
+//#region ../../shell/ai-service/src/agent-types.d.ts
+/**
+ * Context for a chat message
+ * Contains per-message information like user permission level
+ */
+interface ChatAttachmentSource {
+  kind: string;
+  id: string;
+}
+interface TextChatAttachment {
+  kind: "text";
+  filename: string;
+  mediaType: string;
+  content: string;
+  sizeBytes?: number | undefined;
+  source?: ChatAttachmentSource | undefined;
+}
+interface FileChatAttachment {
+  kind: "file";
+  filename: string;
+  mediaType: string;
+  data: Uint8Array;
+  sizeBytes?: number | undefined;
+  source?: ChatAttachmentSource | undefined;
+}
+type ChatAttachment = TextChatAttachment | FileChatAttachment;
+interface ChatContext {
+  /** Server-owned limits bound to the already-reserved guest execution. */
+  guestExecution?: GuestExecutionPolicy;
+  /** The site's scope and refusal copy a guest question is screened against. */
+  guestScreening?: GuestScreening;
+  userPermissionLevel?: UserPermissionLevel;
+  /** Whether the authenticated caller is the brain's configured Anchor. */
+  isAnchor?: boolean;
+  interfaceType?: string;
+  channelId?: string;
+  channelName?: string;
+  actor?: ConversationMessageActor;
+  source?: ConversationMessageSource;
+  attachments?: ChatAttachment[] | undefined;
+}
+/**
+ * Agent service interface
+ */
+interface IAgentService {
+  /** Guest turns can run: the search index they read is ready. */
+  readonly guestReady?: boolean;
+  /**
+   * Send a message to the agent and get a response
+   * @param message - The user's message
+   * @param conversationId - ID of the conversation for history tracking
+   * @param context - Optional context including user permission level
+   */
+  chat(message: string, conversationId: string, context?: ChatContext, signal?: AbortSignal): Promise<AgentResponse>;
+  /**
+   * Confirm a pending approval-gated action
+   * @param conversationId - ID of the conversation
+   * @param confirmed - Whether the user confirmed the operation
+   * @param approvalId - Explicit approval/action id to resolve
+   */
+  confirmPendingAction(conversationId: string, confirmed: boolean, approvalId: string, context: ChatContext, signal?: AbortSignal): Promise<AgentResponse>;
+  /** Stop active turns and release conversation actors. */
+  shutdown?(): Promise<void>;
+  /**
+   * Invalidate the cached agent so the next conversation rebuilds
+   * with fresh identity, profile, and instructions.
+   */
+  invalidateAgent(): void;
+}
+//#endregion
+//#region ../../shell/plugins/src/channel-registry.d.ts
+interface ChannelSubjectPattern {
+  source: string;
+  flags?: string | undefined;
+}
+interface ChannelDescriptor {
+  type: string;
+  displayName: string;
+  subjectLabel: string;
+  subjectPattern?: ChannelSubjectPattern | undefined;
+  manualDelivery?: boolean | undefined;
+}
+type ChannelDeliverySensitivity = "normal" | "secret";
+interface ChannelDeliveryThreading {
+  inReplyTo: string;
+  references: string[];
+}
+interface ChannelDeliveryInput {
+  recipient: string;
+  subject: string;
+  text: string;
+  idempotencyKey: string;
+  /** Optional rich body for transports that render it. */
+  html?: string | undefined;
+  /**
+   * "secret" keeps recipient and subject out of provider logs. Providers that
+   * cannot honour it should treat every delivery as secret.
+   */
+  sensitivity?: ChannelDeliverySensitivity | undefined;
+  /** Optional transport threading metadata. Unsupported channels may ignore it. */
+  threading?: ChannelDeliveryThreading | undefined;
+}
+type ChannelDeliveryResult = {
+  status: "sent";
+  providerDeliveryId?: string | undefined;
+} | {
+  status: "failed";
+  failureCode: string;
+};
+interface ChannelDeliveryProvider {
+  channelType: string;
+  isAvailable(): Promise<boolean>;
+  send(input: ChannelDeliveryInput): Promise<ChannelDeliveryResult>;
+}
+interface IChannelRegistry {
+  registerDescriptor(pluginId: string, descriptor: ChannelDescriptor): void;
+  registerDeliveryProvider(pluginId: string, provider: ChannelDeliveryProvider): void;
+  unregisterPlugin(pluginId: string): void;
+  finalize(): void;
+  listDescriptors(): ChannelDescriptor[];
+  getDescriptor(channelType: string): ChannelDescriptor | undefined;
+  getDeliveryProvider(channelType: string): ChannelDeliveryProvider | undefined;
+  isFinalized(): boolean;
+}
+//#endregion
+//#region ../../shell/plugins/src/inbox-registry.d.ts
+declare const inboxUrgencySchema: z.ZodEnum<{
+  high: "high";
+  normal: "normal";
+}>;
+type InboxFacetOptionSchema = z.ZodObject<{
+  value: z.ZodString;
+  label: z.ZodString;
+}, z.core.$strict>;
+type InboxFacetDefinitionSchema = z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  values: z.ZodArray<InboxFacetOptionSchema>;
+}, z.core.$strict>;
+declare const inboxFacetDefinitionsSchema: z.ZodArray<InboxFacetDefinitionSchema>;
+declare const inboxFacetsSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+type InboxFollowUpDeclarationSchema = z.ZodObject<{
+  kind: z.ZodString;
+  context: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;
+declare const inboxFollowUpDeclarationsSchema: z.ZodArray<InboxFollowUpDeclarationSchema>;
+type InboxActionSchema = z.ZodObject<{
+  id: z.ZodString;
+  label: z.ZodString;
+  confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type InboxEntityRefSchema = z.ZodObject<{
+  entityType: z.ZodString;
+  entityId: z.ZodString;
+}, z.core.$strict>;
+type InboxContactSchema = z.ZodObject<{
+  label: z.ZodString;
+  personId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type InboxItemSchema = z.ZodObject<{
+  id: z.ZodString;
+  title: z.ZodString;
+  summary: z.ZodOptional<z.ZodString>;
+  contact: z.ZodOptional<InboxContactSchema>;
+  threadOrdinal: z.ZodOptional<z.ZodNumber>;
+  receivedAt: z.ZodISODateTime;
+  urgency: typeof inboxUrgencySchema;
+  entityRef: z.ZodOptional<InboxEntityRefSchema>;
+  facets: z.ZodOptional<typeof inboxFacetsSchema>;
+  followUps: z.ZodOptional<typeof inboxFollowUpDeclarationsSchema>;
+  actions: z.ZodArray<InboxActionSchema>;
+}, z.core.$strict>;
+declare const inboxItemSchema: InboxItemSchema;
+type InboxActorSchema = z.ZodObject<{
+  permissionLevel: z.ZodEnum<{
+    admin: "admin";
+    trusted: "trusted";
+    public: "public";
+  }>;
+}, z.core.$strict>;
+declare const inboxActorSchema: InboxActorSchema;
+type InboxItemDetailSchema = z.ZodObject<{
+  kind: z.ZodLiteral<"plain">;
+  text: z.ZodString;
+  truncated: z.ZodBoolean;
+}, z.core.$strict>;
+declare const inboxItemDetailSchema: InboxItemDetailSchema;
+type InboxSourceDescriptorSchema = z.ZodObject<{
+  sourceId: z.ZodString;
+  displayName: z.ZodString;
+  facets: z.ZodOptional<typeof inboxFacetDefinitionsSchema>;
+}, z.core.$strict>;
+declare const inboxSourceDescriptorSchema: InboxSourceDescriptorSchema;
+type InboxItem = z.output<typeof inboxItemSchema>;
+type InboxActor = z.output<typeof inboxActorSchema>;
+type InboxItemDetail = z.output<typeof inboxItemDetailSchema>;
+type InboxSourceDescriptor = z.output<typeof inboxSourceDescriptorSchema>;
+interface InboxSource extends InboxSourceDescriptor {
+  list(): Promise<InboxItem[]>;
+  resolveDetail?(itemId: string, actor: InboxActor, signal: AbortSignal): Promise<InboxItemDetail>;
+  act(itemId: string, actionId: string, actor: InboxActor): Promise<void>;
+}
+interface IInboxRegistry {
+  registerSource(pluginId: string, source: InboxSource): void;
+  unregisterPlugin(pluginId: string): void;
+  finalize(): void;
+  listSources(): InboxSource[];
+  getSource(sourceId: string): InboxSource | undefined;
+  isFinalized(): boolean;
+}
+//#endregion
+//#region ../../shell/plugins/src/inbox-follow-up-registry.d.ts
+type InboxFollowUpMode = "universal" | "declared";
+type InboxFollowUpContext = Readonly<Record<string, string>>;
+interface InboxFollowUpResolutionInput {
+  sourceId: string;
+  item: InboxItem;
+  actor: InboxActor;
+  context?: InboxFollowUpContext | undefined;
+}
+interface InboxFollowUpTargetInput {
+  href: string;
+  state?: unknown;
+}
+interface InboxFollowUpKindRegistration {
+  kind: string;
+  label: string;
+  priority: number;
+  mode: InboxFollowUpMode;
+  permissionLevel: UserPermissionLevel;
+  contextSchema?: z.ZodType<InboxFollowUpContext, unknown> | undefined;
+  applies(input: InboxFollowUpResolutionInput): boolean | Promise<boolean>;
+  resolve(input: InboxFollowUpResolutionInput): InboxFollowUpTargetInput | undefined | Promise<InboxFollowUpTargetInput | undefined>;
+}
+type RegisteredInboxFollowUpKind = Readonly<InboxFollowUpKindRegistration>;
+interface IInboxFollowUpRegistry {
+  registerKind(pluginId: string, registration: InboxFollowUpKindRegistration): void;
+  unregisterPlugin(pluginId: string): void;
+  finalize(): void;
+  listKinds(): RegisteredInboxFollowUpKind[];
+  getKind(kind: string): RegisteredInboxFollowUpKind | undefined;
+  resolve(input: Omit<InboxFollowUpResolutionInput, "context">): Promise<ResolvedInboxFollowUp[]>;
+  resolveUniversal(input: Omit<InboxFollowUpResolutionInput, "context">): Promise<ResolvedInboxFollowUp[]>;
+  isFinalized(): boolean;
+}
+declare const inboxFollowUpStateSchema: z.ZodRecord<z.ZodString, ReturnType<typeof z.json>>;
+type ResolvedInboxFollowUpSchema = z.ZodObject<{
+  kind: z.ZodString;
+  label: z.ZodString;
+  href: z.ZodString;
+  state: z.ZodOptional<typeof inboxFollowUpStateSchema>;
+}, z.core.$strict>;
+declare const resolvedInboxFollowUpSchema: ResolvedInboxFollowUpSchema;
+type ResolvedInboxFollowUp = z.output<typeof resolvedInboxFollowUpSchema>;
+//#endregion
+//#region ../../shell/plugins/src/contracts/runtime-health.d.ts
+type RuntimeHealthCheckSchema = z.ZodObject<{
+  name: z.ZodString;
+  status: z.ZodEnum<{
+    healthy: "healthy";
+    degraded: "degraded";
+    unhealthy: "unhealthy";
+  }>;
+  message: z.ZodOptional<z.ZodString>;
+  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}>;
+declare const RuntimeHealthCheckSchema: RuntimeHealthCheckSchema;
+type RuntimeHealthCheck = z.output<typeof RuntimeHealthCheckSchema>;
+type RuntimeWorkerSignalsSchema = z.ZodObject<{
+  total: z.ZodNumber;
+  active: z.ZodNumber;
+  stale: z.ZodNumber;
+  latestHeartbeatAgeMs: z.ZodNullable<z.ZodNumber>;
+}>;
+type RuntimeQueueSignalsSchema = z.ZodObject<{
+  totals: z.ZodObject<{
+    pending: z.ZodNumber;
+    processing: z.ZodNumber;
+    completed: z.ZodNumber;
+    failed: z.ZodNumber;
+  }>;
+  byType: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    status: z.ZodEnum<{
+      pending: "pending";
+      processing: "processing";
+      completed: "completed";
+      failed: "failed";
+    }>;
+    count: z.ZodNumber;
+  }>>;
+  oldestPendingAgeMs: z.ZodNullable<z.ZodNumber>;
+  duePending: z.ZodNumber;
+  oldestDuePendingAgeMs: z.ZodNullable<z.ZodNumber>;
+  latestClaimAgeMs: z.ZodNullable<z.ZodNumber>;
+  oldestProcessingAgeMs: z.ZodNullable<z.ZodNumber>;
+  staleLeaseCount: z.ZodNumber;
+  workerSessions: RuntimeWorkerSignalsSchema;
+}>;
+declare const RuntimeQueueSignalsSchema: RuntimeQueueSignalsSchema;
+type RuntimeResourceSignalsSchema = z.ZodObject<{
+  memory: z.ZodObject<{
+    rssBytes: z.ZodNumber;
+    heapUsedBytes: z.ZodNumber;
+    heapTotalBytes: z.ZodNumber;
+  }>;
+  fileDescriptors: z.ZodNullable<z.ZodNumber>;
+  processes: z.ZodObject<{
+    total: z.ZodNullable<z.ZodNumber>;
+    zombies: z.ZodNullable<z.ZodNumber>;
+  }>;
+  queue: z.ZodNullable<RuntimeQueueSignalsSchema>;
+  projection: z.ZodObject<{
+    initialized: z.ZodBoolean;
+    trackedRoots: z.ZodNumber;
+    openCircuits: z.ZodArray<z.ZodObject<{
+      projectionId: z.ZodString;
+      reason: z.ZodString;
+      openedAt: z.ZodNumber;
+      expiresAt: z.ZodNumber;
+    }>>;
+  }>;
+  worker: RuntimeWorkerSignalsSchema;
+}>;
+declare const RuntimeResourceSignalsSchema: RuntimeResourceSignalsSchema;
+type RuntimeReadinessSchema = z.ZodObject<{
+  status: z.ZodEnum<{
+    ready: "ready";
+    not_ready: "not_ready";
+  }>;
+  operationalStatus: z.ZodEnum<{
+    operational: "operational";
+    degraded: "degraded";
+  }>;
+  checkedAt: z.ZodISODateTime;
+  checks: z.ZodArray<RuntimeHealthCheckSchema>;
+  resources: RuntimeResourceSignalsSchema;
+}>;
+declare const RuntimeReadinessSchema: RuntimeReadinessSchema;
+type RuntimeReadiness = z.output<typeof RuntimeReadinessSchema>;
+//#endregion
+//#region ../../shell/plugins/src/operational-health-registry.d.ts
+type OperationalHealthProvider = () => Promise<Omit<RuntimeHealthCheck, "name">> | Omit<RuntimeHealthCheck, "name">;
+interface IOperationalHealthRegistry {
+  register(pluginId: string, name: string, provider: OperationalHealthProvider): () => void;
+  unregisterPlugin(pluginId: string): void;
+  getChecks(): Promise<RuntimeHealthCheck[]>;
+}
+//#endregion
+//#region ../../shell/plugins/src/operator/operator-field-contract.d.ts
+/** Host-rendered scalar controls shared by Account and Studio action forms. */
+declare const operatorFieldControlSchema: z.ZodEnum<{
+  text: "text";
+  url: "url";
+  number: "number";
+  checkbox: "checkbox";
+  select: "select";
+}>;
+type OperatorFieldControl = z.output<typeof operatorFieldControlSchema>;
+declare const accountSettingsControlSchema: z.ZodEnum<{
+  text: "text";
+  url: "url";
+  number: "number";
+  checkbox: "checkbox";
+}>;
+type AccountSettingsControl = z.output<typeof accountSettingsControlSchema>;
+interface OperatorFieldDefinitionBase<TControl extends OperatorFieldControl = OperatorFieldControl> {
+  readonly label: string;
+  readonly control: TControl;
+  readonly secret?: boolean | undefined;
+}
+//#endregion
+//#region ../../shell/plugins/src/operator/account-settings-definition-contract.d.ts
+type AccountSettingsSchema = z.ZodObject<z.ZodRawShape>;
+interface AccountSettingsFieldDefinition extends Omit<OperatorFieldDefinitionBase<AccountSettingsControl>, "control"> {
+  readonly control?: AccountSettingsControl | undefined;
+}
+/**
+ * Every schema field must be declared. Totality is what makes `secret` a
+ * decision rather than an omission: a missing entry would otherwise render a
+ * credential as an ordinary echoing text input.
+ */
+type AccountSettingsFieldMap<TSchema extends AccountSettingsSchema> = { readonly [K in Extract<keyof z.input<TSchema>, string>]: AccountSettingsFieldDefinition; };
+interface AccountSettingsDefinition<TSchema extends AccountSettingsSchema = AccountSettingsSchema, TFields extends AccountSettingsFieldMap<TSchema> = AccountSettingsFieldMap<TSchema>> {
+  readonly kind: "rizom-account-settings";
+  readonly title: string;
+  readonly description?: string | undefined;
+  readonly schema: TSchema;
+  readonly fields: TFields;
+}
+type AnyAccountSettingsDefinition = AccountSettingsDefinition<AccountSettingsSchema, AccountSettingsFieldMap<AccountSettingsSchema>>;
+type AccountSettingsValue<TDefinition extends AnyAccountSettingsDefinition> = z.output<TDefinition["schema"]>;
+//#endregion
+//#region ../../shell/plugins/src/operator/account-settings-registry.d.ts
+type AccountSettingsScalar = z.output<typeof accountSettingsScalarSchema>;
+type AccountSettingsStoredValues = Readonly<Record<string, AccountSettingsScalar>>;
+interface AccountSettingsStorageIdentity {
+  readonly packageName: string;
+  readonly definitionId: string;
+  readonly actorId: string;
+}
+interface StoredAccountSettings {
+  readonly values: AccountSettingsStoredValues;
+  readonly revision: number;
+}
+interface AccountSettingsBackend {
+  read(identity: AccountSettingsStorageIdentity): Promise<StoredAccountSettings | null>;
+  list(input: {
+    readonly packageName: string;
+    readonly definitionId: string;
+  }): Promise<readonly {
+    readonly actorId: string;
+    readonly values: AccountSettingsStoredValues;
+    readonly revision: number;
+  }[]>;
+  write(identity: AccountSettingsStorageIdentity, values: AccountSettingsStoredValues): Promise<StoredAccountSettings>;
+  delete(identity: AccountSettingsStorageIdentity): Promise<boolean>;
+  deleteActor(actorId: string): Promise<number>;
+}
+interface AccountSettingsRegistration<TDefinition extends AnyAccountSettingsDefinition = AnyAccountSettingsDefinition> {
+  readonly id: string;
+  readonly ownerPluginId: string;
+  readonly packageName: string;
+  readonly definitionId: string;
+  readonly definition: TDefinition;
+}
+interface AccountSettingsFormField {
+  readonly name: string;
+  readonly label: string;
+  readonly control: "text" | "url" | "number" | "checkbox";
+  readonly secret: boolean;
+  readonly required: boolean;
+  readonly value?: AccountSettingsScalar | undefined;
+  readonly set?: boolean | undefined;
+}
+interface AccountSettingsForm {
+  readonly id: string;
+  readonly title: string;
+  readonly description?: string | undefined;
+  readonly configured: boolean;
+  /** Opaque change token for host form reset; never contains stored values. */
+  readonly revision: number | null;
+  readonly fields: readonly AccountSettingsFormField[];
+}
+interface ConfiguredAccountSettings<TDefinition extends AnyAccountSettingsDefinition = AnyAccountSettingsDefinition> {
+  readonly id: string;
+  readonly settings: AccountSettingsValue<TDefinition>;
+  readonly revision: number;
+}
+interface RegisterAccountSettingsInput<TDefinition extends AnyAccountSettingsDefinition = AnyAccountSettingsDefinition> {
+  readonly ownerPluginId: string;
+  readonly packageName: string;
+  readonly definitionId: string;
+  readonly definition: TDefinition;
+}
+type AccountSettingsChangeListener = () => void;
+declare const accountSettingsScalarSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+/** App-scoped definition catalog and guarded access to the auth-owned backend. */
+declare class AccountSettingsRegistry {
+  private readonly registrations;
+  private readonly listeners;
+  private readonly mutationTails;
+  private backend;
+  register<TDefinition extends AnyAccountSettingsDefinition>(input: RegisterAccountSettingsInput<TDefinition>): AccountSettingsRegistration<TDefinition>;
+  unregister(registration: AccountSettingsRegistration): void;
+  bindBackend(backend: AccountSettingsBackend): () => void;
+  hasRegistrations(): boolean;
+  hasBackend(): boolean;
+  listRegistrations(): readonly AccountSettingsRegistration[];
+  listForms(actorId: string): Promise<readonly AccountSettingsForm[]>;
+  save(registrationIdValue: string, actorId: string, input: Readonly<Record<string, unknown>>): Promise<AccountSettingsForm>;
+  delete(registrationIdValue: string, actorId: string): Promise<boolean>;
+  deleteActor(actorId: string): Promise<number>;
+  /** Notify account-bound supervisors after auth-owned cascade deletion. */
+  accountDeleted(actorId: string): void;
+  private refreshActor;
+  getForActor<TDefinition extends AnyAccountSettingsDefinition>(registration: AccountSettingsRegistration<TDefinition>, actorId: string): Promise<AccountSettingsValue<TDefinition> | null>;
+  listConfigured<TDefinition extends AnyAccountSettingsDefinition>(registration: AccountSettingsRegistration<TDefinition>): Promise<readonly ConfiguredAccountSettings<TDefinition>[]>;
+  subscribe(registration: AccountSettingsRegistration, listener: AccountSettingsChangeListener): () => void;
+  private formFor;
+  private requireRegistration;
+  private requireAttached;
+  private requireBackend;
+  private notify;
+  private serializeMutation;
+}
+//#endregion
+//#region ../../shell/plugins/src/service/attachment-registry.d.ts
+interface AttachmentResolveRequest {
+  sourceEntityType: string;
+  sourceEntityId: string;
+  attachmentType: string;
+}
+interface AttachmentProviderMetadata {
+  outputEntityType: "image" | "document";
+  targetField?: "coverImageId" | "ogImageId";
+}
+interface AttachmentProvider {
+  metadata?: AttachmentProviderMetadata;
+  resolve(request: AttachmentResolveRequest): Promise<PublishMediaData | undefined> | PublishMediaData | undefined;
+}
+/**
+ * Attachment namespace — source-derived publish artifacts.
+ * Source plugins register providers; publishers resolve by semantic attachment type.
+ */
+interface IAttachmentsNamespace {
+  /** Register an attachment provider for a source entity type and semantic attachment type. */
+  register: (sourceEntityType: string, attachmentType: string, provider: AttachmentProvider) => () => void;
+  /** Resolve a source-derived attachment if a provider is available. */
+  resolve: (request: AttachmentResolveRequest) => Promise<PublishMediaData | undefined>;
+  /** Check whether a provider exists for the requested source/attachment type. */
+  hasProvider: (sourceEntityType: string, attachmentType: string) => boolean;
+  /** Get registered provider capability metadata, if declared. */
+  getProviderMetadata: (sourceEntityType: string, attachmentType: string) => AttachmentProviderMetadata | undefined;
+}
+//#endregion
+//#region ../../shell/runtime-state/src/types.d.ts
+type RuntimeStateValueSchema<T> = ZodType<T, unknown>;
+interface RuntimeStateScopeOptions<T> {
+  /** Stable consumer namespace, e.g. "chat.discord.subscriptions". */
+  namespace: string;
+  /** Schema used to validate values crossing the persistence boundary. */
+  schema: RuntimeStateValueSchema<T>;
+}
+interface RuntimeStateRecordValue<T> {
+  key: string;
+  value: T;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface RuntimeStateListOptions {
+  keyPrefix?: string | undefined;
+  /** Exclusive key cursor, ordered using SQLite's binary key order. */
+  afterKey?: string | undefined;
+  /** Optional bounded page size (1–1000); applied before value parsing. */
+  limit?: number | undefined;
+}
+interface IRuntimeStateStore<T> {
+  get(key: string): Promise<T | null>;
+  has(key: string): Promise<boolean>;
+  set(key: string, value: T): Promise<void>;
+  setIfNotExists(key: string, value: T): Promise<boolean>;
+  /** Atomically replace an existing value only if its schema-serialized value matches.
+   * Use a revision field when the consumer must distinguish an ABA change.
+   * Independent processes must use the same backing database to coordinate.
+   */
+  compareAndSet(key: string, expected: T, value: T): Promise<boolean>;
+  delete(key: string): Promise<boolean>;
+  list(options?: RuntimeStateListOptions): Promise<RuntimeStateRecordValue<T>[]>;
+  clear(options?: {
+    keyPrefix?: string | undefined;
+  }): Promise<number>;
+}
+interface IRuntimeStateNamespace {
+  scoped<T>(options: RuntimeStateScopeOptions<T>): IRuntimeStateStore<T>;
+}
+//#endregion
+//#region ../../shell/recurring-checks/src/types.d.ts
+type RecurringCheckCadence = "daily" | "weekly";
+/** Alert payloads are operational state and must not contain secrets. */
+declare const recurringAlertSchema: z.ZodObject<{
+  dedupeKey: z.ZodString;
+  title: z.ZodString;
+  body: z.ZodString;
+  html: z.ZodOptional<z.ZodString>;
+  sensitivity: z.ZodOptional<z.ZodEnum<{
+    normal: "normal";
+    secret: "secret";
+  }>>;
+  includeInInbox: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const recurringCheckResultSchema: z.ZodObject<{
+  alerts: z.ZodOptional<z.ZodArray<typeof recurringAlertSchema>>;
+}, z.core.$strict>;
+type RecurringCheckResult = z.output<typeof recurringCheckResultSchema>;
+interface RecurringCheckRunContext {
+  /** Aborted when the caller cancels or the recurring-check daemon stops. */
+  signal: AbortSignal;
+}
+interface RecurringCheckDefinition {
+  id: string;
+  cadence: RecurringCheckCadence;
+  /** Deliver returned alerts and retry pending alerts. False suppresses notification delivery. Defaults to true. */
+  deliverAlerts?: boolean | undefined;
+  /** Project returned alerts into the shared Inbox. Defaults to true. */
+  includeInInbox?: boolean | undefined;
+  run(context: RecurringCheckRunContext): Promise<RecurringCheckResult>;
+}
+interface IRecurringChecksNamespace {
+  /** Register a plugin-owned recurring check. Returns an unregister callback. */
+  register(check: RecurringCheckDefinition): () => void;
+}
+//#endregion
+//#region ../../shell/plugins/src/service/upload-registry.d.ts
+interface RuntimeUploadRef {
+  kind: string;
+  id: string;
+}
+interface RuntimeUploadRecord {
+  id: string;
+  ref: RuntimeUploadRef;
+  filename: string;
+  mediaType: string;
+  sizeBytes: number;
+  createdAt: string;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface RuntimeUploadResponseBody extends RuntimeUploadRecord {
+  url: string;
+  downloadUrl: string;
+}
+interface RuntimeUploadScopeOptions {
+  /** Filesystem namespace below the runtime data directory, e.g. "upload". */
+  namespace: string;
+  /** Ref discriminator exposed to clients, e.g. "upload". */
+  refKind: string;
+  /** HTTP route used to resolve stored uploads, e.g. "/api/chat/uploads". */
+  routePath: string;
+  retentionMs?: number | undefined;
+  maxCount?: number | undefined;
+  createId?: (() => string) | undefined;
+  now?: (() => Date) | undefined;
+}
+interface SaveRuntimeUploadInput {
+  filename: string;
+  mediaType: string;
+  content: Buffer;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface ResolvedRuntimeUpload {
+  record: RuntimeUploadRecord;
+  content: Buffer;
+}
+/**
+ * The store surface consumers get, rather than the class that implements it.
+ *
+ * Declaring the class here made every consumer depend on its private fields
+ * too, so nothing could stand in for a scoped store without asserting it was
+ * one. The class satisfies this by construction.
+ */
+type ScopedRuntimeUploadStore = Pick<RuntimeUploadStore, "save" | "read" | "readRecord" | "toResponseBody" | "prune" | "getUploadDir" | "remove">;
+interface IRuntimeUploadsNamespace {
+  /** Create a scoped runtime upload store for an interface/plugin namespace. */
+  scoped(options: RuntimeUploadScopeOptions): ScopedRuntimeUploadStore;
+}
+interface RuntimeUploadStoreOptions extends RuntimeUploadScopeOptions {
+  dataDir: string;
+  logger?: Logger | undefined;
+}
+declare class RuntimeUploadStore {
+  private readonly options;
+  private readonly retentionMs;
+  private readonly maxCount;
+  private readonly createUploadId;
+  private readonly getNow;
+  private readonly logger;
+  constructor(options: RuntimeUploadStoreOptions);
+  save(input: SaveRuntimeUploadInput): Promise<RuntimeUploadRecord>;
+  remove(uploadId: string): Promise<void>;
+  read(uploadId: string): Promise<ResolvedRuntimeUpload>;
+  readRecord(uploadId: string): Promise<RuntimeUploadRecord>;
+  toResponseBody(record: RuntimeUploadRecord): RuntimeUploadResponseBody;
+  /**
+   * Drop uploads past the retention window or the count cap.
+   *
+   * Returns quietly only when the uploads directory does not exist yet — it is
+   * created on first save. Every other failure raises: an unreadable directory
+   * or a deletion that did not happen means uploads accumulate unbounded, and
+   * a silent catch here made that indistinguishable from a successful prune.
+   */
+  prune(): Promise<void>;
+  getUploadDir(uploadId: string): string;
+  private getUploadsRoot;
+  private getUploadUrl;
+  private assertValidUploadId;
+}
+//#endregion
+//#region ../../shell/plugins/src/contracts/runtime-app-info.d.ts
+declare const userPermissionLevelSchema: z.ZodEnum<{
+  admin: "admin";
+  trusted: "trusted";
+  public: "public";
+}>;
+declare const endpointInfoSchema: z.ZodObject<{
+  label: z.ZodString;
+  url: z.ZodString;
+  pluginId: z.ZodString;
+  priority: z.ZodDefault<z.ZodNumber>;
+  visibility: z.ZodDefault<typeof userPermissionLevelSchema>;
+  requiresActiveSession: z.ZodOptional<z.ZodBoolean>;
+}>;
+type EndpointInfo = z.output<typeof endpointInfoSchema>;
+type EndpointInfoInput = z.input<typeof endpointInfoSchema>;
+declare const interactionKindSchema: z.ZodEnum<{
+  human: "human";
+  agent: "agent";
+  admin: "admin";
+  protocol: "protocol";
+}>;
+declare const interactionStatusSchema: z.ZodEnum<{
+  available: "available";
+  "coming-soon": "coming-soon";
+  disabled: "disabled";
+}>;
+declare const interactionInfoSchema: z.ZodObject<{
+  id: z.ZodString;
+  label: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  href: z.ZodString;
+  kind: typeof interactionKindSchema;
+  pluginId: z.ZodString;
+  priority: z.ZodDefault<z.ZodNumber>;
+  visibility: z.ZodDefault<typeof userPermissionLevelSchema>;
+  requiresActiveSession: z.ZodOptional<z.ZodBoolean>;
+  status: z.ZodDefault<typeof interactionStatusSchema>;
+}>;
+type InteractionInfo = z.output<typeof interactionInfoSchema>;
+type InteractionInfoInput = z.input<typeof interactionInfoSchema>;
+declare const entityCountSchema: z.ZodObject<{
+  entityType: z.ZodString;
+  count: z.ZodNumber;
+}>;
+declare const backgroundWorkInfoSchema: z.ZodObject<{
+  status: z.ZodEnum<{
+    operational: "operational";
+    degraded: "degraded";
+  }>;
+  reasons: z.ZodArray<z.ZodString>;
+  worker: z.ZodObject<{
+    state: z.ZodEnum<{
+      active: "active";
+      missing: "missing";
+      stale: "stale";
+    }>;
+    activeSessions: z.ZodNumber;
+    staleSessions: z.ZodNumber;
+    latestHeartbeatAgeMs: z.ZodNullable<z.ZodNumber>;
+  }>;
+  queue: z.ZodObject<{
+    duePending: z.ZodNumber;
+    processing: z.ZodNumber;
+    oldestDuePendingAgeMs: z.ZodNullable<z.ZodNumber>;
+    latestClaimAgeMs: z.ZodNullable<z.ZodNumber>;
+    stalled: z.ZodBoolean;
+  }>;
+}>;
+declare const appInfoSchema: z.ZodObject<{
+  model: z.ZodString;
+  version: z.ZodString;
+  uptime: z.ZodNumber;
+  entities: z.ZodNumber;
+  entityCounts: z.ZodArray<typeof entityCountSchema>;
+  embeddings: z.ZodNumber;
+  backgroundWork: typeof backgroundWorkInfoSchema;
+  ai: z.ZodObject<{
+    model: z.ZodString;
+    embeddingModel: z.ZodString;
+  }>;
+  daemons: z.ZodArray<typeof DaemonStatusInfoSchema>;
+  endpoints: z.ZodArray<typeof endpointInfoSchema>;
+  interactions: z.ZodArray<typeof interactionInfoSchema>;
+}>;
+type RuntimeAppInfo = z.output<typeof appInfoSchema>;
+//#endregion
+//#region ../../shell/plugins/src/contracts/generation.d.ts
+interface GenerationStyleGuide {
+  voice?: string;
+  visual?: string;
+}
+interface ContentGenerationConfig {
+  prompt: string;
+  templateName: string;
+  conversationHistory?: string;
+  data?: Record<string, unknown>;
+  representedIdentity?: "brain" | "anchor" | "none";
+  styleGuide?: GenerationStyleGuide;
+  interfacePermissionGrant?: UserPermissionLevel;
+}
+//#endregion
+//#region ../../shell/plugins/src/types/api-routes.d.ts
+declare const apiRouteDefinitionSchema: z.ZodObject<{
+  path: z.ZodString;
+  method: z.ZodDefault<z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    DELETE: "DELETE";
+  }>>;
+  tool: z.ZodString;
+  public: z.ZodDefault<z.ZodBoolean>;
+  successRedirect: z.ZodOptional<z.ZodString>;
+  errorRedirect: z.ZodOptional<z.ZodString>;
+}>;
+type ApiRouteDefinition = z.output<typeof apiRouteDefinitionSchema>;
+/**
+ * A registered API route with full path and plugin context
+ * Returned by Shell.getPluginApiRoutes()
+ */
+interface RegisteredApiRoute {
+  /** The plugin that registered this route */
+  pluginId: string;
+  /** Full path including /api/{pluginId} prefix */
+  fullPath: string;
+  /** The original route definition */
+  definition: ApiRouteDefinition;
+}
+//#endregion
+//#region ../../shell/plugins/src/types/web-routes.d.ts
+declare const WebRouteMethods: readonly ["GET", "POST", "PUT", "DELETE", "OPTIONS"];
+type WebRouteMethod = (typeof WebRouteMethods)[number];
+/** Host-supplied socket metadata. Never derive this from HTTP/forwarding headers. */
+interface WebRouteTransportContext {
+  readonly remoteAddress?: string;
+}
+type WebRouteHandler = (request: Request, transport?: WebRouteTransportContext) => Response | Promise<Response>;
+type WebRouteMatch = "exact" | "prefix";
+interface WebRouteDefinition {
+  /** Absolute mounted path (e.g. "/studio" or "/studio-config") */
+  path: string;
+  /** Match only `path` (default) or descendants on a segment boundary. */
+  match?: WebRouteMatch;
+  /** HTTP method */
+  method?: WebRouteMethod;
+  /** Allow unauthenticated access */
+  public?: boolean;
+  /** Also serve on the preview host. Reachability only; admission checks still apply. */
+  preview?: boolean;
+  /** Request handler */
+  handler: WebRouteHandler;
+}
+interface RegisteredWebRoute {
+  /** The plugin that registered this route */
+  pluginId: string;
+  /** The mounted path */
+  fullPath: string;
+  /** The original route definition */
+  definition: WebRouteDefinition;
+}
+//#endregion
+//#region ../../shell/plugins/src/contracts/handlers.d.ts
+type EvalHandler<TInput = unknown, TOutput = unknown> = (input: TInput) => Promise<TOutput>;
+/**
+ * Computes a domain summary over entities.
+ *
+ * Takes the read-only projection, not the full service: an insight reports on
+ * what exists and must not write. `@brains/plugins` publishes this signature
+ * to plugin authors, so widening it here would promise them less than they
+ * are given.
+ */
+type InsightHandler = (entityService: ReadOnlyEntityService, visibilityScope: ContentVisibility) => Promise<Record<string, unknown>>;
+//#endregion
+//#region ../../shell/plugins/src/interfaces.d.ts
+/**
+ * Query context for shell queries
+ */
+interface QueryContext {
+  userId?: string;
+  conversationHistory?: string;
+  messageId?: string;
+  threadId?: string;
+  timestamp?: string;
+  [key: string]: unknown;
+}
+/**
+ * Bounded model-as-judge request exposed to plugins.
+ * Kept structural here so public plugin declarations do not import ai-service internals.
+ */
+interface JudgeInput<T> {
+  instruction: string;
+  material: string;
+  schema: AIGenerationSchema<T>;
+}
+/**
+ * Shell interface that plugins use to access core services
+ * This avoids circular dependencies between core and plugin-context
+ */
+/**
+ * Registry for insight types.
+ * Core registers generic insights; plugins register domain-specific ones.
+ */
+interface IInsightsRegistry {
+  register(type: string, handler: InsightHandler): void;
+  unregister(type: string): void;
+  getTypes(): string[];
+  get(type: string, entityService: ReadOnlyEntityService, visibilityScope: ContentVisibility): Promise<Record<string, unknown>>;
+}
+interface IShell {
+  getMessageBus(): IMessageBus;
+  getContentService(): ContentService;
+  getLogger(): Logger;
+  getEntityService(): EntityService;
+  getEntityRegistry(): EntityRegistry;
+  getJobQueueService(): IJobQueueService;
+  getRenderService(): ViewTemplateRegistry;
+  getConversationService(): IConversationService;
+  getMCPService(): IMCPTransport;
+  listToolsForPermissionLevel(level: UserPermissionLevel): ToolInfo[];
+  getPermissionService(): PermissionService;
+  getDataSourceRegistry(): DataSourceRegistry;
+  getAgentService(): IAgentService;
+  getAttachmentRegistry(): IAttachmentsNamespace;
+  getRuntimeUploadRegistry(): IRuntimeUploadsNamespace;
+  getRuntimeState(): IRuntimeStateNamespace;
+  getRecurringChecks(pluginId: string): IRecurringChecksNamespace;
+  getIdentity(): BrainCharacter;
+  getProfile(): AnchorProfile;
+  getProfileKindRegistry(): IProfileKindRegistry;
+  getChannelRegistry(): IChannelRegistry;
+  getInboxRegistry(): IInboxRegistry;
+  getInboxFollowUpRegistry(): IInboxFollowUpRegistry;
+  getOperationalHealthRegistry(): IOperationalHealthRegistry;
+  getAccountSettingsRegistry(): AccountSettingsRegistry;
+  getDomain(): string | undefined;
+  getLocalSiteUrl(): string | undefined;
+  shouldPreferLocalUrls(): boolean;
+  getThemeCSS(): string;
+  getSpaces(): string[];
+  getDataDir(): string;
+  getGitBrokerSocket(): string | undefined;
+  getGitBrokerCheckout(): string | undefined;
+  getAppInfo(): Promise<RuntimeAppInfo>;
+  getRuntimeReadiness(): Promise<RuntimeReadiness>;
+  generateContent(config: ContentGenerationConfig): Promise<unknown>;
+  generateObject<T>(prompt: string, schema: AIGenerationSchema<T>, signal?: AbortSignal): Promise<{
+    object: T;
+  }>;
+  judge<T>(input: JudgeInput<T>): Promise<{
+    verdict: T;
+    usage: {
+      promptTokens: number;
+      completionTokens: number;
+      totalTokens: number;
+    };
+  }>;
+  query(prompt: string, context?: QueryContext): Promise<DefaultQueryResponse>;
+  generateImage(prompt: string, options?: ImageGenerationOptions): Promise<ImageGenerationResult>;
+  canGenerateImages(): boolean;
+  registerTemplates(templates: Record<string, Template>, pluginId?: string): void;
+  getTemplate(name: string): Template | undefined;
+  registerTools(pluginId: string, tools: Tool[]): void;
+  registerResources(pluginId: string, resources: Resource[]): void;
+  registerResourceTemplate<K extends string = string>(pluginId: string, template: ResourceTemplate<K>): void;
+  registerPrompt(pluginId: string, prompt: Prompt): void;
+  registerInstructions(pluginId: string, instructions: string): void;
+  getPluginPackageName(pluginId: string): string | undefined;
+  hasPlugin(id: string): boolean;
+  readonly jobs: IJobsNamespace;
+  registerDaemon(name: string, daemon: Daemon, pluginId: string): void;
+  registerEndpoint(endpoint: EndpointInfoInput): void;
+  listEndpoints(): EndpointInfo[];
+  registerInteraction(interaction: InteractionInfoInput): void;
+  listInteractions(): InteractionInfo[];
+  registerEvalHandler(pluginId: string, handlerId: string, handler: EvalHandler): void;
+  getInsightsRegistry(): IInsightsRegistry;
+  getPluginApiRoutes(): RegisteredApiRoute[];
+  getPluginWebRoutes(): RegisteredWebRoute[];
+}
+//#endregion
+//#region ../../shared/ui-library/src/highlighted-text.d.ts
+/**
+ * Render a content string with two lightweight markup conventions:
+ *
+ * - `\n` in the string produces a `<br />` (for multi-line headlines)
+ * - Any `*...*` run is wrapped in a `<span>` carrying `highlightClass`
+ *
+ * Authors write the phrase as one natural string in markdown content;
+ * the renderer does the structural split. Highlight styling is passed
+ * per-brand (rizom.ai uses accent+midline, professional uses italic+accent)
+ * so each consumer owns its own emphasis treatment while the parsing/
+ * structure is shared.
+ */
+declare function renderHighlightedText(text: string, highlightClass: string): JSX.Element;
+//#endregion
+//#region src/rizom/ui/site-info-links.d.ts
+declare function socialLinksToRizomLinks(siteInfo: Pick<SiteLayoutInfo, "socialLinks">, allowedPlatforms?: string[]): RizomLink[];
+//#endregion
+//#region src/rizom/ui/Wordmark.d.ts
+interface WordmarkProps {
+  /** Brand name before the dot. Defaults to `"rizom"`. */
+  name?: string;
+  /** Suffix after the dot. Any string (e.g. `"ai"`, `"io"`, `"foundation"`). */
+  brandSuffix: RizomBrandSuffix | string;
+  className?: string;
+  dotClassName?: string;
+  suffixClassName?: string;
+}
+declare const Wordmark: ({ name, brandSuffix, className, dotClassName, suffixClassName }: WordmarkProps) => JSX.Element;
+//#endregion
+//#region src/rizom/ui/Ecosystem.d.ts
+interface EcosystemCard {
+  suffix: RizomBrandSuffix;
+  title: string;
+  body: string;
+  linkLabel: string;
+  linkHref: string;
+}
+interface EcosystemContent {
+  eyebrow: string;
+  headline: string;
+  cards: EcosystemCard[];
+}
+declare const Ecosystem: ({ eyebrow, headline, cards }: EcosystemContent) => JSX.Element;
+//#endregion
+//#region src/rizom/runtime/default-layout.d.ts
+declare const DefaultRizomLayout: ({ sections }: RizomLayoutProps) => JSX.Element;
+//#endregion
+//#region src/rizom/runtime/base-site.d.ts
+declare const rizomBaseSite: SiteDefinition;
+//#endregion
+//#region src/rizom/create-site.d.ts
+interface RizomRuntimeHooks {
+  contentNamespace: string;
+  templates?: Record<string, unknown>;
+  dataSources?: unknown[];
+  /** Datasources that need the plugin's runtime, built when it registers. */
+  dataSourceFactories?: Array<(shell: IShell) => unknown>;
+}
+interface CreateRizomSiteOptions {
+  packageName: string;
+  layout: unknown;
+  routes: RouteDefinitionInput[];
+  content?: SiteContent;
+  /**
+   * Schema-first section groups (authored via `@rizom/site`'
+   * `defineSection`/`sectionGroup`). Registered as content templates at brain
+   * boot exactly like `content`, so the Studio + directory-sync + resolver treat
+   * them identically — but the section shape is derived from one zod schema.
+   */
+  sections?: SiteSectionGroup | SiteSectionGroup[];
+  themeOverride?: string;
+  /**
+   * Presentation config for entity-backed list/detail routes (labels, plural
+   * names, navigation). Merged onto the base site's empty map. Sites that
+   * surface plugin lists — e.g. `post`→"Essay", `deck`→"Talk" — set it here.
+   */
+  entityDisplay?: Record<string, EntityDisplayEntry>;
+  /** Advanced runtime hooks for in-repo sites that need custom template/data-source wiring. */
+  runtime?: RizomRuntimeHooks;
+}
+declare function createRizomSite(options: CreateRizomSiteOptions): SitePackage;
+//#endregion
+//#region src/site.d.ts
+declare const rizomAiSite: SitePackage;
+//#endregion
+//#region src/routes.d.ts
+/**
+ * The consolidated Rizom site routes. The home page composes the living-memory
+ * content namespace; the layout owns navigation (the one bar), so routes stay out of the entity nav.
+ */
+declare const aiRoutes: RouteDefinitionInput[];
 //#endregion
 //#region src/living-memory.d.ts
 declare const livingMemorySections: SiteSectionGroup;
@@ -461,4 +4701,4 @@ declare const workSections: SiteSectionGroup;
 //#region src/foundation.d.ts
 declare const foundationSections: SiteSectionGroup;
 //#endregion
-export { Badge, type BadgeProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, type CreateRizomSiteOptions, DefaultRizomLayout, Divider, type DividerProps, Ecosystem, type EcosystemCard, type EcosystemContent, type EntityDisplayEntry, Footer, GUTTER, Header, type RizomBrandSuffix, type RizomFooterTagline, RizomFrame, type RizomFrameProps, type RizomLayoutProps, type RizomLink, type RizomSideNavItem, type RouteDefinitionInput, Section, type SectionDefinitionInput, type SectionProps, SideNav, type SiteContentArrayFieldDefinition, type SiteContentDefinition, type SiteContentEnumFieldDefinition, type SiteContentFieldDefinition, type SiteContentNumberFieldDefinition, type SiteContentObjectFieldDefinition, type SiteContentSectionDefinition, type SiteContentStringFieldDefinition, type SiteDefinition, type SiteDefinitionOverrides, type SiteLayoutInfo, type SitePackage, Wordmark, type WordmarkProps, aiRoutes, createRizomSite, rizomAiSite as default, rizomAiSite, foundationSections, homeSections, livingMemorySections, renderHighlightedText, rizomBaseSite, socialLinksToRizomLinks, workSections };
+export { Badge, type BadgeProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, type CreateRizomSiteOptions, DefaultRizomLayout, Divider, type DividerProps, Ecosystem, type EcosystemCard, type EcosystemContent, type EntityDisplayEntry, Footer, GUTTER, Header, type RizomBrandSuffix, type RizomFooterTagline, RizomFrame, type RizomFrameProps, type RizomLayoutProps, type RizomLink, type RizomSideNavItem, type RouteDefinitionInput, Section, type SectionDefinitionInput, type SectionProps, SideNav, type SiteContentArrayFieldDefinition, type SiteContentDefinition, type SiteContentEnumFieldDefinition, type SiteContentFieldDefinition, type SiteContentNumberFieldDefinition, type SiteContentObjectFieldDefinition, type SiteContentSectionDefinition, type SiteContentStringFieldDefinition, type SiteDefinition, type SiteDefinitionOverrides, type SiteLayoutInfo, type SitePackage, Wordmark, type WordmarkProps, aiRoutes, createRizomSite, rizomAiSite as default, rizomAiSite, foundationSections, livingMemorySections, renderHighlightedText, rizomBaseSite, socialLinksToRizomLinks, workSections };