@opengeni/contracts 0.40.0 → 0.50.0

package/src/index.ts

@@ -1,15 +1,28 @@
 import { z } from "zod";
+import { ScopedKnowledgeScope } from "./scoped-knowledge";
 import {
   boundSessionEventPayload,
   measureSessionEventJson,
   sessionEventJsonBytes,
   type SessionEventBoundarySurface,
 } from "./event-preview";
+import { MemorySlackPublicationDistribution } from "./memory-slack-delivery";
 import { WorkspaceInstructionPolicyRoleKeyInput } from "./workspace-instruction-policies";
 import { ClientResumableVoiceInputConfig } from "./transcription-recordings";
+import { MediaGenerationResult } from "./video-generation";
 
 export * from "./slack-bot-scopes";
+export * from "./slack-task-policy";
+export * from "./atlassian";
 export * from "./connector-destinations";
+export * from "./memory-slack-delivery";
+export * from "./image-generation";
+export * from "./video-generation";
+export * from "./editable-artifacts";
+export * from "./editable-artifact-committed-transaction";
+export * from "./editable-artifact-serialized-commit";
+export * from "./tool-catalog";
+export * from "./interaction";
 
 export {
   CreateWorkspaceArtifactRequest,
@@ -71,6 +84,8 @@ export {
   COMPUTER_SCREENSHOT_MAX_PIXELS,
   COMPUTER_SCREENSHOT_RETENTION_MS,
   COMPUTER_SCREENSHOT_WORKSPACE_QUOTA_BYTES,
+  GENERATED_IMAGE_MAX_BYTES,
+  GENERATED_VIDEO_MAX_BYTES,
   RETAINED_OUTPUT_DEFAULT_PAGE_BYTES,
   RETAINED_OUTPUT_MAX_PAGE_BYTES,
   RETAINED_OUTPUT_RECEIPT_MAX_BYTES,
@@ -81,6 +96,8 @@ export {
   RetainedOutputKind,
   RetainedOutputUnavailableReason,
   retainedArtifactReferenceFromFile,
+  retainedGeneratedImageReferenceFromFile,
+  retainedGeneratedVideoReferenceFromFile,
   retainedScreenshotReferenceFromFile,
   retainedOutputUnavailable,
   resolveRetainedOutputRange,
@@ -88,6 +105,8 @@ export {
   type RetainedArtifactFileInput,
   type RetainedArtifactMetadata,
   type RetainedArtifactReference,
+  type RetainedGeneratedImageArtifactInput,
+  type RetainedGeneratedVideoArtifactInput,
   type RetainedScreenshotArtifactInput,
   type RetainedArtifactUnavailable,
   type RetainedOutputAvailableEvidence,
@@ -101,6 +120,7 @@ export {
   WORKSPACE_ARCHIVE_DESCRIPTOR_VERSION,
   backendForNativeSnapshotProvider,
   decodeNativeSnapshotRef,
+  encodeNativeSnapshotRef,
   parseWorkspaceArchiveDescriptor,
   type NativeSnapshotDescriptor,
   type NativeSnapshotProvider,
@@ -147,6 +167,54 @@ export const SandboxBackend = z.enum([
 ]);
 export type SandboxBackend = z.infer<typeof SandboxBackend>;
 
+// OpenGeni-owned identity carried beside the provider's opaque SDK envelope.
+// Provider serializers intentionally use different keys (`sandboxId`,
+// `devboxId`, `sandboxName`, ...); durable lease logic must not need to learn a
+// new provider's private state shape. Existing envelopes remain readable via
+// the legacy keys below, while every newly-serialized envelope carries this
+// stable field.
+export const OPENGENI_SANDBOX_PROVIDER_INSTANCE_ID_FIELD = "opengeniProviderInstanceId" as const;
+export const SANDBOX_PROVIDER_INSTANCE_ID_FIELDS_BY_BACKEND = {
+  docker: ["containerId"],
+  modal: ["sandboxId"],
+  local: ["workspaceRootPath"],
+  none: [],
+  daytona: ["sandboxId"],
+  runloop: ["devboxId"],
+  e2b: ["sandboxId"],
+  // A Blaxel name is reusable after deletion. The SDK persists a canonical
+  // metadata identity (name + creation timestamp + workspace) specifically to
+  // distinguish a later sandbox created under the same name.
+  blaxel: ["sandboxIdentity"],
+  cloudflare: ["sandboxId"],
+  vercel: ["sandboxId"],
+  selfhosted: ["agentId"],
+} as const satisfies Record<SandboxBackend, readonly string[]>;
+export const LEGACY_SANDBOX_PROVIDER_INSTANCE_ID_FIELDS = [
+  "sandboxId",
+  "devboxId",
+  "sandboxName",
+  "sandboxIdentity",
+  "containerId",
+  "workspaceRootPath",
+  "agentId",
+] as const;
+
+/**
+ * Durable proof that a provider may replace an execution wrapper without
+ * replacing the workspace OpenGeni owns. This is intentionally narrower than
+ * generic provider resume: only a provider adapter that can prove the same
+ * continuity key may consume it, and only a cold->warming owner or teardown
+ * claimant may authorize that replacement.
+ */
+export type SandboxProviderContinuityRecovery = {
+  version: 1;
+  backend: SandboxBackend;
+  kind: "docker_workspace";
+  sourceInstanceId: string;
+  continuityKey: string;
+};
+
 // OS axis. Only "linux" is reachable in v1; macos/windows are seam placeholders.
 export const SandboxOs = z.enum(["linux", "macos", "windows"]);
 export type SandboxOs = z.infer<typeof SandboxOs>;
@@ -178,7 +246,7 @@ export type CapabilityDescriptor = {
     FileSystem: { available: boolean; readOnly: boolean };
     Terminal: {
       available: boolean;
-      transport: "sse-events" | "pty-ws" | null;
+      transport: "sse-events" | "pty-ws" | "relay-pty" | null;
       pty: boolean;
     };
     Git: { available: boolean };
@@ -217,6 +285,7 @@ export const DESKTOP_STREAM_PORT = 6080;
 // ttyd's default; the box bakes ttyd and launches it on this port. The pty-ws
 // Terminal cell's `url` is the tunnel address resolved against this port.
 export const TERMINAL_STREAM_PORT = 7681;
+export const BROWSER_CONTROL_PORT = 7682;
 
 // The provider capability matrix (sandbox contract PART D + module 03-providers). One row per
 // backend (10 rows). v1 reachable cells are all Linux; macos/windows are seam
@@ -499,7 +568,7 @@ export const CAPABILITY_DESCRIPTORS: Record<SandboxBackend, CapabilityDescriptor
     os: { supported: ["linux", "macos", "windows"], default: "linux" },
     capabilities: {
       FileSystem: { available: true, readOnly: false },
-      Terminal: { available: true, transport: "pty-ws", pty: true }, // real PTY over the relay
+      Terminal: { available: true, transport: "relay-pty", pty: true }, // real PTY over the relay
       Git: { available: true },
       DesktopStream: { available: true, transport: "vnc-ws" }, // proclaimed; consent-gated at enroll
       Recording: { available: true }, // boot invariant: == DesktopStream.available
@@ -557,6 +626,7 @@ export const ErrorEnvelope = z.object({
     code: ErrorCode,
     message: z.string(),
     retryable: z.boolean(),
+    outcomeUnknown: z.boolean().optional(),
     requestId: z.string().optional(),
     details: z.record(z.string(), z.unknown()).optional(),
   }),
@@ -664,7 +734,7 @@ export const Permission = z.enum([
   // Programmatic sandbox -> tool access through the first-party MCP gate. This is
   // intentionally narrow and is never part of first-party MCP defaults; callers
   // must receive it through an explicit delegated `ogd_` mint carrying sessionId.
-  "toolspace:call",
+  "codemode:call",
   "goals:manage",
   // Bring-your-own-compute (M5). enrollments:read lists a workspace's machines;
   // enrollments:manage approves a device-flow enrollment (the LOUD whole-machine
@@ -697,6 +767,7 @@ export type Permission = z.infer<typeof Permission>;
  */
 export const DEFAULT_FIRST_PARTY_MCP_PERMISSIONS = [
   "workspace:read",
+  "files:upload",
   "files:read",
   "documents:search",
   "scheduled_tasks:manage",
@@ -729,6 +800,7 @@ export const FIRST_PARTY_MCP_TOOL_NAMES = [
   "set_session_title",
   "goal_set",
   "goal_update",
+  "goal_progress",
   "goal_complete",
   "goal_pause",
   "memory_search",
@@ -736,6 +808,9 @@ export const FIRST_PARTY_MCP_TOOL_NAMES = [
   "memory_correct",
   "preference_registry_summary",
   "preference_registry_get",
+  "task_notes_list",
+  "task_note_save",
+  "task_note_archive",
   "sandboxes_list",
   "sandbox_attach",
   "sandbox_swap",
@@ -756,11 +831,31 @@ export const FIRST_PARTY_MCP_TOOL_NAMES = [
   "session_resume",
   "session_steer",
   "set_other_session_title",
+  "interaction_discover",
+  "browser_open",
+  "browser_tabs",
+  "browser_observe",
+  "browser_act",
+  "browser_clipboard",
+  "browser_debug",
+  "browser_auth",
+  "interaction_request_human",
+  "browser_identity",
+  "browser_publish",
+  "browser_lifecycle",
+  "computer_open",
+  "computer_targets",
+  "computer_observe",
+  "computer_clipboard",
+  "computer_act",
+  "computer_lifecycle",
   "variable_set_list",
   "environment_list",
   "variable_set_get_variable",
   "variable_set_set_variable",
   "environment_set_variable",
+  "capability_catalog_search",
+  "capability_authorization_request",
   "github_connect_link",
   "github_repositories_list",
   "social_connections_list",
@@ -771,6 +866,18 @@ export const FIRST_PARTY_MCP_TOOL_NAMES = [
   "social_thread_fetch",
   "social_posts_sync",
   "social_post_reply",
+  "x_accounts_list",
+  "x_search_live",
+  "x_mentions_live",
+  "x_thread_fetch",
+  "x_posts_sync",
+  "x_post_reply",
+  "reddit_accounts_list",
+  "reddit_search_live",
+  "reddit_mentions_live",
+  "reddit_thread_fetch",
+  "reddit_posts_sync",
+  "reddit_post_reply",
   "scheduled_tasks_list",
   "scheduled_tasks_get",
   "scheduled_tasks_create",
@@ -789,22 +896,114 @@ export const FIRST_PARTY_MCP_TOOL_NAMES = [
   "slack_bot_file_content",
   "slack_bot_post_message",
   "slack_bot_delete_message",
+  "fiken_companies_list",
+  "fiken_contacts_list",
+  "fiken_contact_create",
+  "fiken_products_list",
+  "fiken_invoices_list",
+  "fiken_invoice_get",
+  "fiken_invoice_draft_create",
+  "fiken_bank_accounts_list",
+  "fiken_purchases_list",
+  "fiken_sales_list",
+  "atlassian_sources_list",
+  "atlassian_search",
+  "atlassian_get",
   "artifacts_list",
   "artifacts_get_source",
   "artifacts_create",
   "artifacts_publish",
   "artifacts_rollback",
+  "editable_artifact_list",
+  "editable_artifact_create",
+  "editable_artifact_import",
+  "editable_artifact_get",
+  "editable_artifact_inspect",
+  "editable_artifact_apply",
+  "editable_artifact_export",
+  "editable_artifact_export_status",
 ] as const;
 export const FirstPartyMcpToolName = z.enum(FIRST_PARTY_MCP_TOOL_NAMES);
 export type FirstPartyMcpToolName = z.infer<typeof FirstPartyMcpToolName>;
 
+/**
+ * First-party interaction tools executed inside the frozen attempt rather than
+ * registered on the remote `opengeni` MCP server. They still belong to the
+ * same user-selectable first-party catalog and use the same attempt executor.
+ */
+export const FIRST_PARTY_IN_PROCESS_TOOL_NAMES = [
+  "interaction_discover",
+  "browser_open",
+  "browser_tabs",
+  "browser_observe",
+  "browser_act",
+  "browser_clipboard",
+  "browser_debug",
+  "browser_auth",
+  "interaction_request_human",
+  "browser_identity",
+  "browser_publish",
+  "browser_lifecycle",
+  "computer_open",
+  "computer_targets",
+  "computer_observe",
+  "computer_clipboard",
+  "computer_act",
+  "computer_lifecycle",
+] as const satisfies readonly FirstPartyMcpToolName[];
+
+const FIRST_PARTY_IN_PROCESS_TOOL_NAME_SET = new Set<FirstPartyMcpToolName>(
+  FIRST_PARTY_IN_PROCESS_TOOL_NAMES,
+);
+
+/**
+ * Names accepted for stored-selection compatibility but intentionally omitted
+ * from the remote first-party `opengeni` MCP server.
+ *
+ * `slack_bot_post_message` cannot accept a model/caller-supplied UUID as a
+ * trustworthy logical-delivery identity. Server-owned Slack delivery paths
+ * call the internal client directly with their own durable operation IDs.
+ */
+const FIRST_PARTY_COMPATIBILITY_ONLY_TOOL_NAMES = [
+  "slack_bot_post_message",
+] as const satisfies readonly FirstPartyMcpToolName[];
+
+const FIRST_PARTY_COMPATIBILITY_ONLY_TOOL_NAME_SET = new Set<FirstPartyMcpToolName>(
+  FIRST_PARTY_COMPATIBILITY_ONLY_TOOL_NAMES,
+);
+
+/** Exact catalog registered by the remote first-party `opengeni` MCP server. */
+export const FIRST_PARTY_REMOTE_MCP_TOOL_NAMES = FIRST_PARTY_MCP_TOOL_NAMES.filter(
+  (name) =>
+    !FIRST_PARTY_IN_PROCESS_TOOL_NAME_SET.has(name) &&
+    !FIRST_PARTY_COMPATIBILITY_ONLY_TOOL_NAME_SET.has(name),
+) satisfies readonly FirstPartyMcpToolName[];
+
+/** Authored CodeMode paths for the canonical collaborative artifact surface. */
+export const EDITABLE_ARTIFACT_MCP_CODEMODE_PATHS = {
+  editable_artifact_list: ["artifacts", "list"],
+  editable_artifact_create: ["artifacts", "create"],
+  editable_artifact_import: ["artifacts", "import"],
+  editable_artifact_get: ["artifacts", "get"],
+  editable_artifact_inspect: ["artifacts", "inspect"],
+  editable_artifact_apply: ["artifacts", "apply"],
+  editable_artifact_export: ["artifacts", "export"],
+  editable_artifact_export_status: ["artifacts", "exportStatus"],
+} as const satisfies Partial<Record<FirstPartyMcpToolName, readonly [string, string]>>;
+
 /**
  * Connector-wide tools are explicit-only. Ordinary session omission selects
  * the non-connector catalog, while an explicit session policy may still select
  * any catalogued connector tool and remains independently permission-gated.
  */
 export const DEFAULT_FIRST_PARTY_MCP_TOOLS = FIRST_PARTY_MCP_TOOL_NAMES.filter(
-  (name) => !name.startsWith("social_") && !name.startsWith("slack_bot_"),
+  (name) =>
+    !name.startsWith("social_") &&
+    !name.startsWith("x_") &&
+    !name.startsWith("reddit_") &&
+    !name.startsWith("slack_bot_") &&
+    !name.startsWith("fiken_") &&
+    !name.startsWith("atlassian_"),
 ) satisfies readonly FirstPartyMcpToolName[];
 
 export function prefixedMcpToolName(registryId: string, toolName: string): string {
@@ -826,6 +1025,255 @@ export type UsageLimitsMode = z.infer<typeof UsageLimitsMode>;
 export const AccountRole = z.enum(["owner", "admin", "member"]);
 export type AccountRole = z.infer<typeof AccountRole>;
 
+/**
+ * Settled tenancy vocabulary for resources that may outlive or be used from
+ * more than one workspace. This names authority only; parsing one of these
+ * contracts never authorizes access by itself.
+ */
+export const ResourceAuthorityScope = z.enum(["organization", "workspace", "user"]);
+export type ResourceAuthorityScope = z.infer<typeof ResourceAuthorityScope>;
+
+export const ResourceAuthorityListScope = z.enum([
+  "effective",
+  "organization",
+  "workspace",
+  "user",
+]);
+export type ResourceAuthorityListScope = z.infer<typeof ResourceAuthorityListScope>;
+
+export const OrganizationMembershipStatus = z.enum([
+  "provisioning",
+  "active",
+  "suspended",
+  "revoked",
+]);
+export type OrganizationMembershipStatus = z.infer<typeof OrganizationMembershipStatus>;
+
+export const PersonalResourceRetentionMode = z.enum(["retain", "delete_after"]);
+export type PersonalResourceRetentionMode = z.infer<typeof PersonalResourceRetentionMode>;
+
+export const SessionTenancyVisibility = z.enum(["user_private", "workspace_shared"]);
+export type SessionTenancyVisibility = z.infer<typeof SessionTenancyVisibility>;
+
+/** Public/session API vocabulary. Persistence keeps the explicit tenancy names. */
+export const SessionVisibility = z.enum(["private", "workspace"]);
+export type SessionVisibility = z.infer<typeof SessionVisibility>;
+
+export function sessionVisibilityToPublic(value: SessionTenancyVisibility): SessionVisibility {
+  return value === "user_private" ? "private" : "workspace";
+}
+
+export function sessionVisibilityFromPublic(value: SessionVisibility): SessionTenancyVisibility {
+  return value === "private" ? "user_private" : "workspace_shared";
+}
+
+export const UserResourceGrantMode = z.enum(["once", "session", "always"]);
+export type UserResourceGrantMode = z.infer<typeof UserResourceGrantMode>;
+
+/** Canonical non-wildcard action named by a personal-resource grant. */
+export const UserResourceGrantAction = z
+  .string()
+  .min(1)
+  .max(64)
+  .regex(/^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$/u);
+export type UserResourceGrantAction = z.infer<typeof UserResourceGrantAction>;
+
+export const UserResourceGrantStatus = z.enum(["active", "consumed", "revoked", "expired"]);
+export type UserResourceGrantStatus = z.infer<typeof UserResourceGrantStatus>;
+
+function refineUserResourceGrantFence(
+  value: {
+    mode: UserResourceGrantMode;
+    sessionId: string | null;
+    authorityEpoch: number | null;
+  },
+  context: z.RefinementCtx,
+): void {
+  const sessionBoundMode = value.mode === "once" || value.mode === "session";
+  const hasSession = value.sessionId !== null;
+  const hasAuthorityEpoch = value.authorityEpoch !== null;
+
+  if (sessionBoundMode && !hasSession) {
+    context.addIssue({
+      code: "custom",
+      path: ["sessionId"],
+      message: "once and session grants require an exact sessionId",
+    });
+  }
+  if (sessionBoundMode && !hasAuthorityEpoch) {
+    context.addIssue({
+      code: "custom",
+      path: ["authorityEpoch"],
+      message: "once and session grants require an authorityEpoch fence",
+    });
+  }
+  if (!sessionBoundMode && (hasSession || hasAuthorityEpoch)) {
+    context.addIssue({
+      code: "custom",
+      path: ["mode"],
+      message: "always grants must not carry a session or authority-epoch fence",
+    });
+  }
+  if (hasSession !== hasAuthorityEpoch) {
+    context.addIssue({
+      code: "custom",
+      path: ["authorityEpoch"],
+      message: "sessionId and authorityEpoch must be present or absent together",
+    });
+  }
+}
+
+/** Self-only organization membership projection; no subject identifier leaks. */
+export const OrganizationMembershipProjection = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  status: OrganizationMembershipStatus,
+  personalWorkspaceId: z.string().uuid().nullable(),
+  personalRetentionUntil: z.string().datetime({ offset: true }).nullable(),
+});
+export type OrganizationMembershipProjection = z.infer<typeof OrganizationMembershipProjection>;
+
+/**
+ * Exact active-membership facts returned by managed-human login provisioning.
+ * Retention is intentionally absent because the narrow provisioning capability
+ * neither reads nor mutates offboarding policy.
+ */
+export const ManagedOrganizationMembershipProjection = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  status: z.literal("active"),
+  personalWorkspaceId: z.string().uuid(),
+});
+export type ManagedOrganizationMembershipProjection = z.infer<
+  typeof ManagedOrganizationMembershipProjection
+>;
+
+export const ListManagedOrganizationMembershipsResponse = z.object({
+  memberships: z.array(ManagedOrganizationMembershipProjection),
+});
+export type ListManagedOrganizationMembershipsResponse = z.infer<
+  typeof ListManagedOrganizationMembershipsResponse
+>;
+
+/**
+ * Opaque user-resource authority projection. Ownership is represented by the
+ * server-issued authority id, never a raw subject or membership id.
+ */
+export const UserResourceAuthorityProjection = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  scope: z.literal("user"),
+  resourceKind: z.string().min(1).max(64),
+  originWorkspaceId: z.string().uuid().nullable(),
+  generation: z.number().int().positive(),
+  status: z.enum(["active", "retained", "revoked"]),
+});
+export type UserResourceAuthorityProjection = z.infer<typeof UserResourceAuthorityProjection>;
+
+/**
+ * Opaque grant projection. A grant is still inert until a server-side access
+ * boundary proves the organization, owner, workspace, session context, and
+ * current authority epoch.
+ */
+export const UserResourceGrantProjection = z
+  .object({
+    id: z.string().uuid(),
+    authorityId: z.string().uuid(),
+    organizationId: z.string().uuid(),
+    workspaceId: z.string().uuid(),
+    sessionId: z.string().uuid().nullable(),
+    action: UserResourceGrantAction,
+    mode: UserResourceGrantMode,
+    context: SessionTenancyVisibility,
+    authorityEpoch: z.number().int().positive().nullable(),
+    generation: z.number().int().positive(),
+    status: UserResourceGrantStatus,
+    expiresAt: z.string().datetime({ offset: true }).nullable(),
+  })
+  .superRefine(refineUserResourceGrantFence);
+export type UserResourceGrantProjection = z.infer<typeof UserResourceGrantProjection>;
+
+/**
+ * Extensible immutable delegation payload for accepted work. It contains only
+ * opaque authority/grant identity and execution fences, never owner identity
+ * or credential material.
+ */
+export const UserResourceDelegation = z
+  .object({
+    authorityId: z.string().uuid(),
+    grantId: z.string().uuid(),
+    organizationId: z.string().uuid(),
+    workspaceId: z.string().uuid(),
+    sessionId: z.string().uuid().nullable(),
+    action: UserResourceGrantAction,
+    mode: UserResourceGrantMode,
+    context: SessionTenancyVisibility,
+    authorityEpoch: z.number().int().positive().nullable(),
+    authorityGeneration: z.number().int().positive(),
+    grantGeneration: z.number().int().positive(),
+    resourceVersionId: z.string().uuid().nullable().optional(),
+  })
+  .superRefine(refineUserResourceGrantFence);
+export type UserResourceDelegation = z.infer<typeof UserResourceDelegation>;
+
+/**
+ * Compatibility envelope for future resource selectors. Omitted scope and
+ * authority parse to workspace-only behavior; user authority is impossible
+ * without one complete opaque delegation.
+ */
+export const ResourceAuthorityEnvelope = z
+  .object({
+    scope: ResourceAuthorityScope.default("workspace"),
+    userDelegation: UserResourceDelegation.optional(),
+  })
+  .superRefine((value, context) => {
+    if (value.scope === "user" && value.userDelegation === undefined) {
+      context.addIssue({
+        code: "custom",
+        path: ["userDelegation"],
+        message: "user scope requires an explicit immutable delegation",
+      });
+    }
+    if (value.scope !== "user" && value.userDelegation !== undefined) {
+      context.addIssue({
+        code: "custom",
+        path: ["userDelegation"],
+        message: "only user scope may carry a user delegation",
+      });
+    }
+  });
+export type ResourceAuthorityEnvelope = z.infer<typeof ResourceAuthorityEnvelope>;
+
+/** Secret-safe generic session tenancy metadata for an authorized viewer. */
+export const SessionTenancyProjection = z.object({
+  visibility: SessionTenancyVisibility,
+  authorityEpoch: z.number().int().positive(),
+  ownedByCurrentUser: z.boolean(),
+  fork: z
+    .object({
+      sourceVisibility: SessionTenancyVisibility,
+      sourceAuthorityEpoch: z.number().int().positive(),
+      forkedAt: z.string().datetime({ offset: true }),
+    })
+    .nullable(),
+});
+export type SessionTenancyProjection = z.infer<typeof SessionTenancyProjection>;
+
+/** Secret-safe public projection used by activated session APIs. */
+export const SessionTenancyPublicProjection = z.object({
+  visibility: SessionVisibility,
+  authorityEpoch: z.number().int().positive(),
+  ownedByCurrentUser: z.boolean(),
+  fork: z
+    .object({
+      sourceVisibility: SessionVisibility,
+      sourceAuthorityEpoch: z.number().int().positive(),
+      forkedAt: z.string().datetime({ offset: true }),
+    })
+    .nullable(),
+});
+export type SessionTenancyPublicProjection = z.infer<typeof SessionTenancyPublicProjection>;
+
 export const ManagedAccount = z.object({
   id: z.string().uuid(),
   name: z.string(),
@@ -1220,12 +1668,7 @@ export * from "./transcription-recordings";
 export const CodexCompactionMode = z.enum(["remote_v2", "portable"]);
 export type CodexCompactionMode = z.infer<typeof CodexCompactionMode>;
 
-export const SlackReactionEmojiName = z
-  .string()
-  .trim()
-  .min(1)
-  .max(64)
-  .regex(/^[a-z0-9_+-]+$/, "use the exact Slack emoji name without surrounding colons");
+export const SlackReactionEmojiName = z.literal("genie");
 export type SlackReactionEmojiName = z.infer<typeof SlackReactionEmojiName>;
 
 export const WorkspaceSlackReactionChannelPolicy = z.discriminatedUnion("mode", [
@@ -1271,12 +1714,17 @@ export const DEFAULT_WORKSPACE_SLACK_REACTION_SUMMON_SETTINGS = {
   channelPolicy: { mode: "bot_member" },
 } as const satisfies WorkspaceSlackReactionSummonSettings;
 
+export const WorkspaceMemoryPromptMode = z.enum(["legacy_standing", "retrieval_only"]);
+export type WorkspaceMemoryPromptMode = z.infer<typeof WorkspaceMemoryPromptMode>;
+
 // Validates the KNOWN keys of workspaces.settings; passthrough keeps unknown
-// (future) keys rather than stripping them. memoryEnabled defaults off;
+// (future) keys rather than stripping them. memoryEnabled defaults off and the
+// reversible Memory V1 containment rollout defaults to legacy standing context;
 // voiceInput defaults to enabled when the deployment has a provider.
 export const WorkspaceSettingsSchema = z
   .object({
     memoryEnabled: z.boolean().optional(),
+    memoryPromptMode: WorkspaceMemoryPromptMode.optional(),
     /** Preferred workspace voice-input toggle. */
     voiceInput: WorkspaceVoiceInputSettings.optional(),
     /**
@@ -1306,6 +1754,12 @@ export function resolveWorkspaceMemoryEnabled(settings: unknown): boolean {
   return parsed.success ? parsed.data.memoryEnabled === true : false;
 }
 
+/** Reversible Memory V1 prompt rollout. Absent preserves legacy composition. */
+export function resolveWorkspaceMemoryPromptMode(settings: unknown): WorkspaceMemoryPromptMode {
+  const parsed = WorkspaceSettingsSchema.safeParse(settings ?? {});
+  return parsed.success ? (parsed.data.memoryPromptMode ?? "legacy_standing") : "legacy_standing";
+}
+
 /** Default Codex compaction mode for new Codex sessions (remote_v2 when unset). */
 export function resolveWorkspaceCodexCompactionDefault(settings: unknown): CodexCompactionMode {
   const parsed = WorkspaceSettingsSchema.safeParse(settings ?? {});
@@ -1376,6 +1830,7 @@ export function workspaceSlackReactionChannelAllowed(
 export const UpdateWorkspaceSettingsRequest = z
   .object({
     memoryEnabled: z.boolean().optional(),
+    memoryPromptMode: WorkspaceMemoryPromptMode.optional(),
     voiceInput: WorkspaceVoiceInputSettings.optional(),
     /** @deprecated Prefer `voiceInput`. Kept for one compatibility release. */
     transcription: WorkspaceTranscriptionPolicy.optional(),
@@ -1443,6 +1898,8 @@ const reservedServiceTurnInitiatorContextKeys = new Set([
   "backfill",
   "label",
   "provenanceError",
+  "opengeniSiteAuthConnectionId",
+  "opengeniSiteAuthMaintenanceOperationId",
   "via",
   "viaTruncated",
 ]);
@@ -1544,6 +2001,11 @@ export const DelegatedAccessTokenPayload = z
     // Model-visible first-party tool selection for a worker-bound session.
     // This is visibility only; permissions remain the authorization boundary.
     firstPartyMcpTools: z.array(FirstPartyMcpToolName).optional(),
+    // Trusted root-relative depth facts frozen when the worker prepares this
+    // attempt. They shape only the model-visible tool catalog; the database
+    // remains authoritative for admission and concurrent policy changes.
+    nestedAgentDepth: NestedAgentDepthValue.optional(),
+    effectiveMaxNestedAgentDepth: NestedAgentDepthValue.optional(),
     // The turn making the call (the caller's identity), HMAC-signed by the worker
     // at turn setup. Lets a tool classify WHO is calling from the token itself,
     // instead of racily re-reading the session's live active_turn_id — e.g. the
@@ -1564,6 +2026,23 @@ export const DelegatedAccessTokenPayload = z
       payload.executionGeneration,
     ];
     const exactAttemptClaimCount = exactAttemptClaims.filter((value) => value !== undefined).length;
+    const depthClaimCount = [payload.nestedAgentDepth, payload.effectiveMaxNestedAgentDepth].filter(
+      (value) => value !== undefined,
+    ).length;
+    if (depthClaimCount !== 0 && depthClaimCount !== 2) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["nestedAgentDepth"],
+        message: "nested-agent depth claims must be supplied together",
+      });
+    }
+    if (depthClaimCount > 0 && payload.principalKind !== "agent_attempt") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["principalKind"],
+        message: "nested-agent depth claims require an agent_attempt principal",
+      });
+    }
     if (
       payload.principalKind === "human_session" &&
       (exactAttemptClaimCount !== 0 || payload.serviceInitiator !== undefined)
@@ -2086,6 +2565,61 @@ export const UpdateWorkspaceMemberRequest = z.object({
 });
 export type UpdateWorkspaceMemberRequest = z.infer<typeof UpdateWorkspaceMemberRequest>;
 
+export const SlackUserLinkAccessRequestStatus = z.enum([
+  "prepared",
+  "pending",
+  "completed",
+  "denied",
+  "cancelled",
+  "expired",
+]);
+export type SlackUserLinkAccessRequestStatus = z.infer<typeof SlackUserLinkAccessRequestStatus>;
+
+/**
+ * Durable, token-free projection of one signed Slack identity-link intent.
+ * The original bearer and its digest are deliberately absent from every
+ * public response.
+ */
+export const SlackUserLinkAccessRequest = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  workspaceDisplayName: z.string().min(1).max(256).nullable(),
+  subjectLabel: z.string().min(1).max(512).nullable(),
+  status: SlackUserLinkAccessRequestStatus,
+  version: z.number().int().positive(),
+  expiresAt: z.string().datetime({ offset: true }),
+  requestedAt: z.string().datetime({ offset: true }).nullable(),
+  decidedAt: z.string().datetime({ offset: true }).nullable(),
+  completedAt: z.string().datetime({ offset: true }).nullable(),
+  createdAt: z.string().datetime({ offset: true }),
+  updatedAt: z.string().datetime({ offset: true }),
+});
+export type SlackUserLinkAccessRequest = z.infer<typeof SlackUserLinkAccessRequest>;
+
+export const PrepareSlackUserLinkAccessRequest = z.object({
+  linkToken: z.string().min(1).max(2_048),
+});
+export type PrepareSlackUserLinkAccessRequest = z.infer<typeof PrepareSlackUserLinkAccessRequest>;
+
+export const SlackUserLinkAccessMutationRequest = z.object({
+  expectedVersion: z.number().int().positive(),
+  idempotencyKey: z.string().trim().min(1).max(200),
+});
+export type SlackUserLinkAccessMutationRequest = z.infer<typeof SlackUserLinkAccessMutationRequest>;
+
+export const ApproveSlackUserLinkAccessRequest = SlackUserLinkAccessMutationRequest.extend({
+  role: z.string().trim().min(1).max(128).optional(),
+  permissions: z.array(Permission).min(1),
+});
+export type ApproveSlackUserLinkAccessRequest = z.infer<typeof ApproveSlackUserLinkAccessRequest>;
+
+export const ListSlackUserLinkAccessRequestsResponse = z.object({
+  requests: z.array(SlackUserLinkAccessRequest),
+});
+export type ListSlackUserLinkAccessRequestsResponse = z.infer<
+  typeof ListSlackUserLinkAccessRequestsResponse
+>;
+
 export const UsageEventType = z.enum([
   "agent_run.created",
   "agent_run.completed",
@@ -2095,6 +2629,10 @@ export const UsageEventType = z.enum([
   "file.deleted",
   "document.indexed",
   "scheduled_task.fired",
+  "knowledge_source_sync.fired",
+  "knowledge_source_sync.completed",
+  "knowledge_source_sync.items",
+  "knowledge_source_sync.bytes",
   "api_key.request",
   // --- sandbox warm-time metering (P2.1) ---
   // Wall-clock seconds a box was warm — the billable warm-time meter. Accrued on
@@ -2133,6 +2671,9 @@ export type InsightsRange = z.infer<typeof InsightsRange>;
 export const InsightsBillingPath = z.enum(["opengeni_credits", "external"]);
 export type InsightsBillingPath = z.infer<typeof InsightsBillingPath>;
 
+export const InsightsPricingSource = z.enum(["configured_list_price", "gateway_reported"]);
+export type InsightsPricingSource = z.infer<typeof InsightsPricingSource>;
+
 export const InsightsModelUsageRow = z.object({
   id: z.string().min(1),
   model: z.string().min(1),
@@ -2142,20 +2683,37 @@ export const InsightsModelUsageRow = z.object({
   inputTokens: z.number().nonnegative(),
   outputTokens: z.number().nonnegative(),
   cachedTokens: z.number().nonnegative(),
+  cacheInputTokens: z.number().nonnegative(),
   cacheWriteTokens: z.number().nonnegative(),
   reasoningTokens: z.number().nonnegative(),
+  totalTokens: z.number().nonnegative(),
+  tokenKnownCalls: z.number().int().nonnegative(),
+  cacheKnownCalls: z.number().int().nonnegative(),
   /** Priced OpenGeni credit $ for this model×provider (from model_call_facts). */
   creditUsd: z.number().nonnegative(),
+  /** Hypothetical provider-rate USD; never an OpenGeni charge. */
+  estimatedProviderUsd: z.number().nonnegative(),
+  estimatedProviderCostKnownCalls: z.number().int().nonnegative(),
 });
 export type InsightsModelUsageRow = z.infer<typeof InsightsModelUsageRow>;
 
 export const InsightsSeriesPoint = z.object({
   label: z.string().min(1),
-  /** Day-bucketed sum of usage_events.model.cost (workspace-wide) or filtered facts when provider/model set. */
+  /** UTC hour/day-bucketed sum of usage_events.model.cost (workspace-wide) or filtered facts when provider/model set. */
   modelCostUsd: z.number().nonnegative(),
+  /** UTC hour/day-bucketed hypothetical provider-rate USD for calls with captured pricing. */
+  estimatedProviderUsd: z.number().nonnegative(),
+  estimatedProviderCostKnownCalls: z.number().int().nonnegative(),
   warmSeconds: z.number().nonnegative(),
   inputTokens: z.number().nonnegative(),
+  outputTokens: z.number().nonnegative(),
   cachedTokens: z.number().nonnegative(),
+  cacheInputTokens: z.number().nonnegative(),
+  cacheWriteTokens: z.number().nonnegative(),
+  reasoningTokens: z.number().nonnegative(),
+  totalTokens: z.number().nonnegative(),
+  tokenKnownCalls: z.number().int().nonnegative(),
+  cacheKnownCalls: z.number().int().nonnegative(),
   cacheHitPct: z.number().int().min(0).max(100),
   calls: z.number().int().nonnegative(),
 });
@@ -2178,9 +2736,12 @@ export const InsightsSpendDriver = z.object({
   groupBy: z.enum(["root_session", "schedule"]),
   label: z.string().min(1),
   creditUsd: z.number().nonnegative(),
+  estimatedProviderUsd: z.number().nonnegative(),
+  estimatedProviderCostKnownCalls: z.number().int().nonnegative(),
   tokens: z.number().nonnegative(),
   cacheHitPct: z.number().int().min(0).max(100),
   pctOfCreditUsd: z.number().int().min(0).max(100),
+  pctOfTokens: z.number().int().min(0).max(100),
   deltaUsdVsPrior: z.number(),
 });
 export type InsightsSpendDriver = z.infer<typeof InsightsSpendDriver>;
@@ -2227,18 +2788,48 @@ export const InsightsScheduleRow = z.object({
   fires: z.number().int().nonnegative(),
   /** Null when no facts carry scheduled_task_id for this window. */
   creditUsd: z.number().nonnegative().nullable(),
+  estimatedProviderUsd: z.number().nonnegative().nullable(),
+  estimatedProviderCostKnownCalls: z.number().int().nonnegative().nullable(),
   tokens: z.number().nonnegative().nullable(),
   cacheHitPct: z.number().int().min(0).max(100).nullable(),
   billing: InsightsBillingPath.nullable(),
 });
 export type InsightsScheduleRow = z.infer<typeof InsightsScheduleRow>;
 
+export const InsightsModelCallRow = z.object({
+  id: z.string().uuid(),
+  occurredAt: z.string().datetime(),
+  recordedAt: z.string().datetime(),
+  sessionId: z.string().uuid(),
+  sessionTitle: z.string(),
+  turnId: z.string().uuid(),
+  provider: z.string().min(1),
+  providerApi: z.string().min(1),
+  model: z.string().min(1),
+  billing: InsightsBillingPath,
+  inputTokens: z.number().nonnegative().nullable(),
+  outputTokens: z.number().nonnegative().nullable(),
+  cachedTokens: z.number().nonnegative().nullable(),
+  cacheWriteTokens: z.number().nonnegative().nullable(),
+  reasoningTokens: z.number().nonnegative().nullable(),
+  totalTokens: z.number().nonnegative().nullable(),
+  /** OpenGeni credit price for this call. External calls are always zero. */
+  creditUsd: z.number().nonnegative(),
+  /** Hypothetical provider-rate USD; null when historical pricing is unavailable. */
+  estimatedProviderUsd: z.number().nonnegative().nullable(),
+  pricingSource: InsightsPricingSource.nullable(),
+});
+export type InsightsModelCallRow = z.infer<typeof InsightsModelCallRow>;
+
 export const WorkspaceInsightsSnapshot = z.object({
   range: InsightsRange,
   rangeLabel: z.string().min(1),
   priorLabel: z.string().min(1),
   seriesLabel: z.string().min(1),
   cacheSeriesLabel: z.string().min(1),
+  windowStart: z.string().datetime(),
+  windowEnd: z.string().datetime(),
+  generatedAt: z.string().datetime(),
   /** All ranges/series are UTC. */
   timezone: z.literal("UTC"),
   models: z.array(InsightsModelUsageRow),
@@ -2248,6 +2839,7 @@ export const WorkspaceInsightsSnapshot = z.object({
   depth: z.array(InsightsDepthBucket),
   drivers: z.array(InsightsSpendDriver),
   schedules: z.array(InsightsScheduleRow),
+  recentCalls: z.array(InsightsModelCallRow),
   warmSeconds: z.number().nonnegative(),
   priorWarmSeconds: z.number().nonnegative(),
   warmGroups: z.array(InsightsWarmGroupRow),
@@ -2261,7 +2853,14 @@ export const WorkspaceInsightsSnapshot = z.object({
   /** Model-filterable credit $ from facts (equals workspace when unfiltered, ignoring late-reject drift). */
   creditUsd: z.number().nonnegative(),
   priorCreditUsd: z.number().nonnegative(),
+  /** Hypothetical provider-rate USD for calls whose historical price was captured. */
+  estimatedProviderUsd: z.number().nonnegative(),
+  priorEstimatedProviderUsd: z.number().nonnegative(),
+  estimatedProviderCostKnownCalls: z.number().int().nonnegative(),
+  priorEstimatedProviderCostKnownCalls: z.number().int().nonnegative(),
+  modelCalls: z.number().int().nonnegative(),
   priorInputTokens: z.number().nonnegative(),
+  priorTotalTokens: z.number().nonnegative(),
   priorCacheHitPct: z.number().int().min(0).max(100),
   priorCalls: z.number().int().nonnegative(),
   /** Lifetime workspace topology (not scoped to the selected Insights range). */
@@ -2408,7 +3007,7 @@ export type GitCredentialRepositoryRef = z.infer<typeof GitCredentialRepositoryR
 //     `loadVariableSetForRun` (today decrypted with
 //     `environmentsEncryptionKeyBytes(settings)`).
 //   - MCP credentials: request-time transport headers for connection-backed
-//     servers, shared by normal model tools and Toolspace/Code Mode.
+//     servers, shared by normal model tools and Codemode/Code Mode.
 //
 // In embedded/separate topologies the HOST owns these external connections
 // (its GitHub App, its secret vault + encryption key). When a host binds this
@@ -2691,7 +3290,7 @@ export const McpPersonalConnectionDelegation = z
     ownerSubjectId: z.string().min(1).max(512),
     providerDomain: z.string().min(1).max(2048),
     kind: z.enum(["oauth2", "api_key", "app_install", "delegated"]).optional(),
-    connectionType: z.enum(["mcp", "social"]).optional(),
+    connectionType: z.enum(["mcp", "social", "atlassian"]).optional(),
   })
   .strict();
 export type McpPersonalConnectionDelegation = z.infer<typeof McpPersonalConnectionDelegation>;
@@ -2727,7 +3326,7 @@ export type McpPersonalConnectionSummary = z.infer<typeof McpPersonalConnectionS
 export type McpCredentialsRequest = {
   accountId: string;
   workspaceId: string;
-  /** Immediate session whose model or Toolspace call needs the credential. */
+  /** Immediate session whose model or Codemode call needs the credential. */
   sessionId: string;
   /** Workspace-scoped lineage root for host authorization and binding lookup. */
   rootSessionId: string;
@@ -2740,9 +3339,16 @@ export type McpCredentialsRequest = {
   initiatorContext: TurnInitiatorContext;
   /** Immediate technical caller, retained only as non-authoritative audit context. */
   callerSubjectId?: string;
-  surface: "model" | "toolspace";
+  surface: "model" | "codemode";
   /** Canonical MCP destination that will receive the resolved headers. */
   destinationUrl: string;
+  /**
+   * Credential transport requested by the caller. Omitted means the existing
+   * header-only MCP transport. The additive `http_api` target allows embedding
+   * hosts to return query/cookie API-key placements for local API integrations
+   * without making those placements eligible for a remote MCP request.
+   */
+  credentialTarget?: "mcp" | "http_api";
   serverId: string;
   toolName?: string;
   connectionRef: McpServerConnectionRef;
@@ -2755,6 +3361,13 @@ export type McpCredentialAuthNeededReason =
   | "unsupported_auth"
   | "resource_scope_unavailable";
 
+export type ConnectionCredentialPlacement = {
+  carrier: "header" | "query" | "cookie";
+  name: string;
+  value: string;
+  prefix?: string;
+};
+
 export type McpCredentialResolution =
   | {
       status: "ok";
@@ -2763,6 +3376,12 @@ export type McpCredentialResolution =
       workspaceId: string;
       sessionId: string;
       headers: Record<string, string>;
+      /**
+       * Optional normalized HTTP credential placements. When present, header
+       * placements must exactly match `headers`. Query/cookie placements are
+       * accepted only for a request whose credentialTarget is `http_api`.
+       */
+      placements?: ConnectionCredentialPlacement[];
       connectionId: string;
       providerDomain: string;
       provider?: string;
@@ -2803,7 +3422,7 @@ export type ConnectionCredentialsPort = {
    * Resolve rotating MCP transport credentials at request time. Embedded hosts
    * use this to keep their provider connection as the sole credential source;
    * OpenGeni never requires a duplicate connection record. The same resolver is
-   * used by model-visible MCP tools and the additive Toolspace/Code Mode proxy.
+   * used by model-visible MCP tools and the exact-attempt Codemode projection.
    */
   mcpCredentials?(input: McpCredentialsRequest): Promise<McpCredentialResolution>;
 };
@@ -3098,6 +3717,12 @@ export type FileResourceRef = z.infer<typeof FileResourceRef>;
  * reconstruct the same typed attachment input after a model switch or retry.
  */
 export const MODEL_ATTACHMENT_REFS_FIELD = "opengeni_attachment_refs" as const;
+/**
+ * Structured timeline annotations retained beside the deterministic user-text
+ * projection in canonical history. Provider adapters remove this OpenGeni
+ * extension field; the numbered projection in `content` remains model-visible.
+ */
+export const MODEL_TIMELINE_ANNOTATIONS_FIELD = "opengeni_timeline_annotations" as const;
 
 export const ResourceRef = z.discriminatedUnion("kind", [RepositoryResourceRef, FileResourceRef]);
 export type ResourceRef = z.infer<typeof ResourceRef>;
@@ -3408,6 +4033,56 @@ export const DocumentSearchResponse = z.object({
 });
 export type DocumentSearchResponse = z.infer<typeof DocumentSearchResponse>;
 
+export const IndexedDocumentSource = z.object({
+  kind: KnowledgeSourceKind,
+  uri: z.string().nullable(),
+  externalId: z.string().nullable(),
+  title: z.string().nullable(),
+  author: z.string().nullable(),
+  createdAt: z.string().nullable(),
+  updatedAt: z.string().nullable(),
+  version: z.string().nullable(),
+});
+export type IndexedDocumentSource = z.infer<typeof IndexedDocumentSource>;
+
+export const IndexedDocumentProvenance = z.object({
+  ingestionWorkspaceId: z.string().uuid(),
+  baseId: z.string().uuid(),
+  fileId: z.string().uuid(),
+  authorityKind: DocumentAuthorityKind,
+  authorityWorkspaceId: z.string().uuid().nullable(),
+  authoritySubjectId: z.string().nullable(),
+  createdBy: z.string().nullable(),
+  createdAt: z.string(),
+});
+export type IndexedDocumentProvenance = z.infer<typeof IndexedDocumentProvenance>;
+
+export const IndexedDocumentSummary = z.object({
+  id: z.string().uuid(),
+  title: z.string(),
+  parser: z.string(),
+  chunkCount: z.number().int().nonnegative(),
+  indexedAt: z.string(),
+  summary: z.string().nullable(),
+  topics: z.array(z.string()),
+  source: IndexedDocumentSource,
+  provenance: IndexedDocumentProvenance,
+});
+export type IndexedDocumentSummary = z.infer<typeof IndexedDocumentSummary>;
+
+export const ListIndexedDocumentsRequest = z.object({
+  checkpoint: z.string().min(1).max(1_024).optional(),
+  limit: z.number().int().positive().max(100).default(50),
+});
+export type ListIndexedDocumentsRequest = z.infer<typeof ListIndexedDocumentsRequest>;
+
+export const ListIndexedDocumentsResponse = z.object({
+  documents: z.array(IndexedDocumentSummary),
+  nextCheckpoint: z.string().min(1).max(1_024),
+  hasMore: z.boolean(),
+});
+export type ListIndexedDocumentsResponse = z.infer<typeof ListIndexedDocumentsResponse>;
+
 export const CreateDocumentBaseRequest = z.object({
   name: z.string().min(1),
   description: z.string().optional(),
@@ -3547,6 +4222,7 @@ export const CreateKnowledgeMemoryRequest = z.object({
   createdBySessionId: z.string().uuid().optional(),
   pinned: z.boolean().optional(),
   replacesId: z.string().min(1).optional(),
+  slackPublication: MemorySlackPublicationDistribution.optional(),
 });
 export type CreateKnowledgeMemoryRequest = z.infer<typeof CreateKnowledgeMemoryRequest>;
 
@@ -3945,6 +4621,86 @@ export type SessionGoalStatus = z.infer<typeof SessionGoalStatus>;
 export const SessionGoalCreatedBy = z.enum(["api", "agent", "scheduled_task"]);
 export type SessionGoalCreatedBy = z.infer<typeof SessionGoalCreatedBy>;
 
+export const SessionGoalMutationPolicy = z.enum([
+  "review_changes",
+  "preserve_intent",
+  "autonomous_adaptation",
+]);
+export type SessionGoalMutationPolicy = z.infer<typeof SessionGoalMutationPolicy>;
+
+export const SessionGoalChangeKind = z.enum(["refinement", "adaptation", "replacement"]);
+export type SessionGoalChangeKind = z.infer<typeof SessionGoalChangeKind>;
+
+export const SESSION_GOAL_TEXT_MAX_BYTES = 8 * 1024;
+export const SESSION_GOAL_SUCCESS_CRITERIA_MAX_BYTES = 8 * 1024;
+export const SESSION_GOAL_RATIONALE_MAX_BYTES = 2 * 1024;
+export const SESSION_GOAL_PROGRESS_MAX_BYTES = 4 * 1024;
+
+export function sessionGoalUtf8Bytes(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function boundedSessionGoalString(maxBytes: number, field: string) {
+  return z
+    .string()
+    .min(1)
+    .refine((value) => sessionGoalUtf8Bytes(value) <= maxBytes, {
+      message: `${field} exceeds ${maxBytes} UTF-8 bytes`,
+    });
+}
+
+const SessionGoalTextWrite = boundedSessionGoalString(SESSION_GOAL_TEXT_MAX_BYTES, "goal text");
+const SessionGoalSuccessCriteriaWrite = boundedSessionGoalString(
+  SESSION_GOAL_SUCCESS_CRITERIA_MAX_BYTES,
+  "goal success criteria",
+);
+const SessionGoalRationaleWrite = boundedSessionGoalString(
+  SESSION_GOAL_RATIONALE_MAX_BYTES,
+  "goal rationale",
+);
+
+export const SessionGoalSnapshot = z.discriminatedUnion("state", [
+  z.object({ state: z.literal("none"), capturedAt: z.string() }),
+  z.object({
+    state: z.enum(["active", "paused", "completed"]),
+    goalId: z.string().uuid(),
+    objectiveRevision: z.number().int().positive(),
+    text: SessionGoalTextWrite,
+    successCriteria: SessionGoalSuccessCriteriaWrite.nullable(),
+    mutationPolicy: SessionGoalMutationPolicy,
+    capturedAt: z.string(),
+  }),
+]);
+export type SessionGoalSnapshot = z.infer<typeof SessionGoalSnapshot>;
+
+export const SessionGoalRevision = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  sessionId: z.string().uuid(),
+  goalId: z.string().uuid(),
+  disposition: z.enum(["applied", "proposed", "rejected"]),
+  changeKind: SessionGoalChangeKind,
+  baseObjectiveRevision: z.number().int().nonnegative(),
+  resultObjectiveRevision: z.number().int().positive().nullable(),
+  text: z.string().min(1),
+  successCriteria: z.string().nullable(),
+  mutationPolicy: SessionGoalMutationPolicy,
+  rationale: z.string().min(1),
+  actor: z.enum(["agent", "api", "scheduled_task"]),
+  actorTurnId: z.string().uuid().nullable(),
+  actorAttemptId: z.string().uuid().nullable(),
+  proposalId: z.string().uuid().nullable(),
+  createdAt: z.string(),
+});
+export type SessionGoalRevision = z.infer<typeof SessionGoalRevision>;
+
+export const ApplySessionGoalRevisionRequest = z.object({
+  expectedObjectiveRevision: z.number().int().positive(),
+  rationale: SessionGoalRationaleWrite.optional(),
+});
+export type ApplySessionGoalRevisionRequest = z.infer<typeof ApplySessionGoalRevisionRequest>;
+
 export const SessionGoalPausedReason = z.enum([
   "agent",
   "user_pause",
@@ -4003,6 +4759,8 @@ export const SessionGoal = z.object({
   pausedReason: z.string().nullable(),
   createdBy: SessionGoalCreatedBy,
   version: z.number().int().positive(),
+  objectiveRevision: z.number().int().positive(),
+  mutationPolicy: SessionGoalMutationPolicy,
   autoContinuations: z.number().int().nonnegative(),
   noProgressStreak: z.number().int().nonnegative(),
   maxAutoContinuations: z.number().int().positive().nullable(),
@@ -4016,16 +4774,26 @@ export const SessionGoal = z.object({
 export type SessionGoal = z.infer<typeof SessionGoal>;
 
 export const GoalSpec = z.object({
-  text: z.string().min(1),
-  successCriteria: z.string().min(1).optional(),
+  text: SessionGoalTextWrite,
+  successCriteria: SessionGoalSuccessCriteriaWrite.optional(),
   maxAutoContinuations: z.number().int().positive().optional(),
+  mutationPolicy: SessionGoalMutationPolicy.optional(),
 });
 export type GoalSpec = z.infer<typeof GoalSpec>;
 
-export const UpdateSessionGoalRequest = z.object({
-  status: z.enum(["paused", "active"]),
-  rationale: z.string().min(1).optional(),
-});
+export const UpdateSessionGoalRequest = z.union([
+  z.object({
+    status: z.enum(["paused", "active"]),
+    rationale: SessionGoalRationaleWrite.optional(),
+  }),
+  z.object({
+    text: SessionGoalTextWrite,
+    successCriteria: SessionGoalSuccessCriteriaWrite.nullable().optional(),
+    mutationPolicy: SessionGoalMutationPolicy.optional(),
+    rationale: SessionGoalRationaleWrite,
+    expectedObjectiveRevision: z.number().int().positive(),
+  }),
+]);
 export type UpdateSessionGoalRequest = z.infer<typeof UpdateSessionGoalRequest>;
 
 export const UpdateSessionRequest = z.object({
@@ -4161,7 +4929,7 @@ export const SessionAuthorizationSurface = z.enum([
   "core",
   "stream",
   "first_party_mcp",
-  "toolspace",
+  "codemode",
 ]);
 export type SessionAuthorizationSurface = z.infer<typeof SessionAuthorizationSurface>;
 
@@ -4354,6 +5122,7 @@ export type SyncSessionRealtimeLedgerResponse = z.infer<typeof SyncSessionRealti
 
 export const SessionRealtimeModel = z.enum([
   "gpt-live-1-boulder-alpha",
+  "supergrok/grok-voice-think-fast-2.0",
   "opengeni-gateway/openai/gpt-realtime-2.1",
   "opengeni-gateway/openai/gpt-realtime-mini",
   "opengeni-gateway/xai/grok-voice-think-fast-2.0",
@@ -4366,7 +5135,7 @@ export type SessionRealtimeModel = z.infer<typeof SessionRealtimeModel>;
 export const WorkspaceRealtimeModelCatalogItem = z.object({
   id: SessionRealtimeModel,
   label: z.string().min(1),
-  provider: z.enum(["OpenGeni", "Connected Codex", "Your Gateway"]),
+  provider: z.enum(["OpenGeni", "Connected Codex", "Connected SuperGrok", "Your Gateway"]),
   description: z.string().min(1),
   available: z.boolean(),
   unavailableReason: z.string().nullable(),
@@ -4450,7 +5219,7 @@ export const SessionAuthorizationOperation = z.enum([
   "session.viewer.control",
   "session.first_party_mcp.call",
   "session.secret.read",
-  "session.toolspace.call",
+  "session.codemode.call",
   "session.pin.write",
   "session.codex_account.write",
   "session.realtime.start",
@@ -4460,11 +5229,14 @@ export const SessionAuthorizationOperation = z.enum([
   "session.human_input.read",
   "session.human_input.write",
   "session.title.write",
+  "session.channel.write",
   "session.mcp.approval_policy.write",
   "session.tool_policy.write",
   "session.goal.read",
   "session.goal.write",
   "session.child.create",
+  "session.visibility.write",
+  "session.fork.create",
 ]);
 export type SessionAuthorizationOperation = z.infer<typeof SessionAuthorizationOperation>;
 
@@ -4486,6 +5258,8 @@ export const SessionAuthorizationActor = z.discriminatedUnion("kind", [
     /** Frozen authority that admitted the calling turn. */
     initiator: TurnInitiator,
     initiatorContext: TurnInitiatorContext,
+    /** Durable causal human for delegated/service work; null for pure service work. */
+    initiatingHumanSubjectId: z.string().min(1).max(1024).nullable(),
   }),
 ]);
 export type SessionAuthorizationActor = z.infer<typeof SessionAuthorizationActor>;
@@ -4564,44 +5338,276 @@ export type SessionAuthorizationPort = {
   ): Promise<SessionAuthorizationListScope>;
 };
 
-export const SessionTurn = z.object({
-  id: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  sessionId: z.string().uuid(),
-  triggerEventId: z.string().uuid(),
-  temporalWorkflowId: z.string(),
-  status: SessionTurnStatus,
-  source: SessionTurnSource,
-  position: z.number().int(),
-  prompt: z.string().min(1),
-  resources: z.array(ResourceRef),
-  tools: z.array(ToolRef),
-  // Omitted/default discovery and explicit `tools: []` are distinct. False
-  // inherits the durable session policy; true replaces it for this turn after
-  // admission proves the selection is a subset.
-  toolsProvided: z.boolean().optional(),
-  model: z.string().min(1),
-  reasoningEffort: ReasoningEffort,
-  latencyMode: LatencyMode.default("standard"),
-  sandboxBackend: SandboxBackend,
-  // Per-turn OS override. NULL = inherit the session's sandboxOs.
-  sandboxOs: SandboxOs.nullable(),
-  metadata: z.record(z.string(), z.unknown()),
-  version: z.number().int().positive(),
-  executionGeneration: z.number().int().nonnegative(),
-  activeAttemptId: z.string().uuid().nullable(),
-  lineage: z.record(z.string(), z.unknown()),
-  initiator: TurnInitiator,
-  initiatorContext: TurnInitiatorContext,
-  /** Secret-safe projection of the exact personal authority frozen on this turn. */
-  personalConnections: z.array(McpPersonalConnectionSummary).default([]),
-  cancelledBy: z.string().nullable(),
-  cancelReason: z.string().nullable(),
-  startedAt: z.string().nullable(),
-  finishedAt: z.string().nullable(),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-});
+export const TIMELINE_ANNOTATION_MAX_COUNT = 12;
+export const TIMELINE_ANNOTATION_QUOTE_MAX_BYTES = 16 * 1024;
+export const TIMELINE_ANNOTATION_NOTE_MAX_BYTES = 2 * 1024;
+export const TIMELINE_ANNOTATION_CONTEXT_MAX_BYTES = 512;
+export const TIMELINE_ANNOTATION_LABEL_MAX_BYTES = 256;
+export const TIMELINE_ANNOTATIONS_MAX_BYTES = 64 * 1024;
+
+export const TimelineAnnotationSourceKind = z.enum([
+  "user_message",
+  "assistant_message",
+  "tool_output",
+]);
+export type TimelineAnnotationSourceKind = z.infer<typeof TimelineAnnotationSourceKind>;
+
+export const TimelineAnnotationSourceEventType = z.enum([
+  "user.message",
+  "agent.message.completed",
+  "agent.toolCall.output",
+]);
+export type TimelineAnnotationSourceEventType = z.infer<typeof TimelineAnnotationSourceEventType>;
+
+function timelineAnnotationUtf8Bytes(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function timelineAnnotationBoundedText(maxBytes: number, label: string) {
+  return z.string().superRefine((value, ctx) => {
+    if (timelineAnnotationUtf8Bytes(value) > maxBytes) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `${label} must be at most ${maxBytes} UTF-8 bytes`,
+      });
+    }
+  });
+}
+
+export const TimelineAnnotationSource = z
+  .object({
+    kind: TimelineAnnotationSourceKind,
+    eventId: z.string().uuid(),
+    eventType: TimelineAnnotationSourceEventType,
+    sequence: z.number().int().positive(),
+    turnId: z.string().uuid().nullable(),
+    startOffset: z.number().int().nonnegative(),
+    endOffset: z.number().int().nonnegative(),
+    contextBefore: timelineAnnotationBoundedText(
+      TIMELINE_ANNOTATION_CONTEXT_MAX_BYTES,
+      "annotation source contextBefore",
+    ),
+    contextAfter: timelineAnnotationBoundedText(
+      TIMELINE_ANNOTATION_CONTEXT_MAX_BYTES,
+      "annotation source contextAfter",
+    ),
+    label: timelineAnnotationBoundedText(
+      TIMELINE_ANNOTATION_LABEL_MAX_BYTES,
+      "annotation source label",
+    ).optional(),
+  })
+  .strict()
+  .superRefine((source, ctx) => {
+    if (source.endOffset < source.startOffset) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["endOffset"],
+        message: "annotation source endOffset must not precede startOffset",
+      });
+    }
+    const expectedKind =
+      source.eventType === "user.message"
+        ? "user_message"
+        : source.eventType === "agent.message.completed"
+          ? "assistant_message"
+          : "tool_output";
+    if (source.kind !== expectedKind) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["kind"],
+        message: "annotation source kind does not match eventType",
+      });
+    }
+  });
+export type TimelineAnnotationSource = z.infer<typeof TimelineAnnotationSource>;
+
+export const DraftTimelineAnnotation = z
+  .object({
+    id: z.string().uuid(),
+    source: TimelineAnnotationSource,
+    quote: timelineAnnotationBoundedText(TIMELINE_ANNOTATION_QUOTE_MAX_BYTES, "annotation quote"),
+    note: timelineAnnotationBoundedText(TIMELINE_ANNOTATION_NOTE_MAX_BYTES, "annotation note"),
+  })
+  .strict()
+  .superRefine((annotation, ctx) => {
+    if (!annotation.quote.trim()) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["quote"],
+        message: "annotation quote must contain non-whitespace text",
+      });
+    }
+  });
+export type DraftTimelineAnnotation = z.infer<typeof DraftTimelineAnnotation>;
+
+export const SubmittedTimelineAnnotation = DraftTimelineAnnotation.superRefine(
+  (annotation, ctx) => {
+    if (!annotation.note.trim()) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["note"],
+        message: "annotation note must contain non-whitespace text",
+      });
+    }
+  },
+);
+export type SubmittedTimelineAnnotation = z.infer<typeof SubmittedTimelineAnnotation>;
+
+export const TimelineAnnotation = z
+  .object({
+    id: z.string().uuid(),
+    source: TimelineAnnotationSource,
+    quote: timelineAnnotationBoundedText(TIMELINE_ANNOTATION_QUOTE_MAX_BYTES, "annotation quote"),
+    note: timelineAnnotationBoundedText(
+      TIMELINE_ANNOTATION_NOTE_MAX_BYTES,
+      "annotation note",
+    ).refine((value) => value.trim().length > 0, {
+      message: "annotation note must contain non-whitespace text",
+    }),
+    ordinal: z.number().int().positive(),
+  })
+  .strict();
+export type TimelineAnnotation = z.infer<typeof TimelineAnnotation>;
+
+function timelineAnnotationArray<T extends z.ZodTypeAny>(item: T) {
+  return z
+    .array(item)
+    .max(TIMELINE_ANNOTATION_MAX_COUNT)
+    .superRefine((annotations, ctx) => {
+      const ids = new Set<string>();
+      for (let index = 0; index < annotations.length; index += 1) {
+        const id = (annotations[index] as { id?: unknown }).id;
+        if (typeof id === "string" && ids.has(id)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [index, "id"],
+            message: "annotation ids must be unique",
+          });
+        }
+        if (typeof id === "string") ids.add(id);
+      }
+      if (
+        timelineAnnotationUtf8Bytes(JSON.stringify(annotations)) > TIMELINE_ANNOTATIONS_MAX_BYTES
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `annotations must be at most ${TIMELINE_ANNOTATIONS_MAX_BYTES} UTF-8 bytes`,
+        });
+      }
+    });
+}
+
+export const DraftTimelineAnnotations = timelineAnnotationArray(DraftTimelineAnnotation);
+export type DraftTimelineAnnotations = z.infer<typeof DraftTimelineAnnotations>;
+
+export const SubmittedTimelineAnnotations = timelineAnnotationArray(SubmittedTimelineAnnotation);
+export type SubmittedTimelineAnnotations = z.infer<typeof SubmittedTimelineAnnotations>;
+
+export const TimelineAnnotations = timelineAnnotationArray(TimelineAnnotation).superRefine(
+  (annotations, ctx) => {
+    for (let index = 0; index < annotations.length; index += 1) {
+      if (annotations[index]!.ordinal !== index + 1) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [index, "ordinal"],
+          message: "annotation ordinals must be contiguous and match array order",
+        });
+      }
+    }
+  },
+);
+export type TimelineAnnotations = z.infer<typeof TimelineAnnotations>;
+
+export function numberTimelineAnnotations(
+  annotations: readonly SubmittedTimelineAnnotation[],
+): TimelineAnnotation[] {
+  return annotations.map((annotation, index) => ({
+    ...annotation,
+    source: { ...annotation.source },
+    ordinal: index + 1,
+  }));
+}
+
+export function renderTimelineAnnotationsForModel(
+  text: string,
+  annotations: readonly TimelineAnnotation[],
+): string {
+  if (annotations.length === 0) return text;
+  const sections = annotations.flatMap((annotation) => [
+    `Annotation ${annotation.ordinal}`,
+    `Source: ${JSON.stringify({
+      kind: annotation.source.kind,
+      eventId: annotation.source.eventId,
+      eventType: annotation.source.eventType,
+      sequence: annotation.source.sequence,
+      turnId: annotation.source.turnId,
+      startOffset: annotation.source.startOffset,
+      endOffset: annotation.source.endOffset,
+      contextBefore: annotation.source.contextBefore,
+      contextAfter: annotation.source.contextAfter,
+      ...(annotation.source.label ? { label: annotation.source.label } : {}),
+    })}`,
+    `Exact quote: ${JSON.stringify(annotation.quote)}`,
+    `User note: ${JSON.stringify(annotation.note)}`,
+  ]);
+  return [
+    ...(text.length > 0 ? [text, ""] : []),
+    "[OpenGeni timeline annotations]",
+    ...sections.flatMap((line, index) =>
+      index > 0 && line.startsWith("Annotation ") ? ["", line] : [line],
+    ),
+  ].join("\n");
+}
+
+export const SessionTurn = z
+  .object({
+    id: z.string().uuid(),
+    workspaceId: z.string().uuid(),
+    sessionId: z.string().uuid(),
+    triggerEventId: z.string().uuid(),
+    temporalWorkflowId: z.string(),
+    status: SessionTurnStatus,
+    source: SessionTurnSource,
+    position: z.number().int(),
+    prompt: z.string(),
+    annotations: TimelineAnnotations.default([]),
+    resources: z.array(ResourceRef),
+    tools: z.array(ToolRef),
+    // Omitted/default discovery and explicit `tools: []` are distinct. False
+    // inherits the durable session policy; true replaces it for this turn after
+    // admission proves the selection is a subset.
+    toolsProvided: z.boolean().optional(),
+    model: z.string().min(1),
+    reasoningEffort: ReasoningEffort,
+    latencyMode: LatencyMode.default("standard"),
+    sandboxBackend: SandboxBackend,
+    // Per-turn OS override. NULL = inherit the session's sandboxOs.
+    sandboxOs: SandboxOs.nullable(),
+    metadata: z.record(z.string(), z.unknown()),
+    version: z.number().int().positive(),
+    executionGeneration: z.number().int().nonnegative(),
+    activeAttemptId: z.string().uuid().nullable(),
+    lineage: z.record(z.string(), z.unknown()),
+    initiator: TurnInitiator,
+    initiatorContext: TurnInitiatorContext,
+    /** Secret-safe projection of the exact personal authority frozen on this turn. */
+    personalConnections: z.array(McpPersonalConnectionSummary).default([]),
+    cancelledBy: z.string().nullable(),
+    cancelReason: z.string().nullable(),
+    startedAt: z.string().nullable(),
+    finishedAt: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+  })
+  .superRefine((turn, ctx) => {
+    if (turn.prompt.length === 0 && turn.annotations.length === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["prompt"],
+        message: "turn prompt or annotations are required",
+      });
+    }
+  });
 export type SessionTurn = z.infer<typeof SessionTurn>;
 
 export const EffectiveControlBlocker = z.object({
@@ -4670,6 +5676,7 @@ export type SessionCommandReceipt = z.infer<typeof SessionCommandReceipt>;
 export const ComposerDraft = z.object({
   revision: z.number().int().nonnegative(),
   text: z.string(),
+  annotations: DraftTimelineAnnotations.default([]),
   resources: z.array(ResourceRef),
   model: z.string().min(1),
   reasoningEffort: ReasoningEffort,
@@ -4711,6 +5718,7 @@ export type DeleteSessionQueueItemRequest = z.infer<typeof DeleteSessionQueueIte
 
 export const SaveComposerDraftRequest = ComposerDraft.pick({
   text: true,
+  annotations: true,
   resources: true,
   model: true,
   reasoningEffort: true,
@@ -4984,6 +5992,7 @@ export const SessionSystemUpdateKind = z.enum([
   "agent_message",
   "agent_steer_instruction",
   "child_terminal_result",
+  "media_generation_result",
 ]);
 export type SessionSystemUpdateKind = z.infer<typeof SessionSystemUpdateKind>;
 
@@ -5028,6 +6037,7 @@ export const SessionSystemUpdatePayload = z.discriminatedUnion("type", [
       status: z.enum(["idle", "failed", "cancelled"]),
     })
     .passthrough(),
+  MediaGenerationResult,
 ]);
 export type SessionSystemUpdatePayload = z.infer<typeof SessionSystemUpdatePayload>;
 
@@ -5259,6 +6269,126 @@ export const RigCheck = z.object({
 });
 export type RigCheck = z.infer<typeof RigCheck>;
 
+export const RigProviderImageBuildStatus = z.enum(["building", "ready", "failed", "unsupported"]);
+export type RigProviderImageBuildStatus = z.infer<typeof RigProviderImageBuildStatus>;
+
+export const RigProviderImage = z
+  .object({
+    backend: SandboxBackend,
+    provider: z.string().min(1).max(64),
+    status: RigProviderImageBuildStatus,
+    // Exact immutable rig-definition/setup identity used to reject stale image
+    // reuse when a version or its effective base image changes.
+    contentHash: z.string().regex(/^sha256:[0-9a-f]{64}$/u),
+    setupHash: z.string().regex(/^sha256:[0-9a-f]{64}$/u),
+    sourceImage: z.string().max(2048).nullable(),
+    buildRequestId: z.string().uuid(),
+    imageId: z.string().min(1).max(512).nullable(),
+    imageDigest: z.string().min(1).max(512).nullable(),
+    artifactId: z.string().uuid().nullable(),
+    providerBindingKeyHash: z
+      .string()
+      .regex(/^sha256:[0-9a-f]{64}$/u)
+      .nullable(),
+    // Added after provider-image v1 shipped. Absence is retained for rolling
+    // compatibility but means runtime must use logical-image + setup fallback
+    // until an explicit verification cold-boots this exact image.
+    coldBootValidation: z
+      .object({
+        version: z.literal(1),
+        checkedAt: z.string().datetime(),
+      })
+      .optional(),
+    provenance: z.object({
+      kind: z.literal("rig_verification"),
+      targetKind: z.enum(["change", "version"]),
+      targetId: z.string().uuid(),
+    }),
+    startedAt: z.string().datetime(),
+    finishedAt: z.string().datetime().nullable(),
+    error: z
+      .object({
+        code: z.string().min(1).max(120),
+        message: z.string().min(1).max(2000),
+        retryable: z.boolean(),
+      })
+      .nullable(),
+  })
+  .superRefine((value, ctx) => {
+    if (value.status === "ready" && !value.imageId && !value.imageDigest) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["imageId"],
+        message: "ready provider images require an immutable image id or digest",
+      });
+    }
+    if (
+      value.status === "ready" &&
+      value.backend === "modal" &&
+      (value.artifactId === null || value.providerBindingKeyHash === null)
+    ) {
+      ctx.addIssue({
+        code: "custom",
+        path: [value.artifactId === null ? "artifactId" : "providerBindingKeyHash"],
+        message: "ready Modal provider images require durable artifact ownership and binding",
+      });
+    }
+    if (value.status !== "ready" && value.artifactId !== null) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["artifactId"],
+        message: "only ready provider images may retain a durable artifact",
+      });
+    }
+    if (value.status === "building") {
+      if (value.finishedAt !== null) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["finishedAt"],
+          message: "building provider images cannot be finished",
+        });
+      }
+      if (value.error !== null) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["error"],
+          message: "building provider images cannot have a terminal error",
+        });
+      }
+    } else if (value.finishedAt === null) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["finishedAt"],
+        message: "terminal provider images require a finish timestamp",
+      });
+    }
+    if ((value.status === "failed" || value.status === "unsupported") && value.error === null) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["error"],
+        message: `${value.status} provider images require failure truth`,
+      });
+    }
+    if (value.status === "ready" && value.error !== null) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["error"],
+        message: "ready provider images cannot retain an error",
+      });
+    }
+    if (value.status !== "ready" && value.coldBootValidation !== undefined) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["coldBootValidation"],
+        message: "only ready provider images may retain cold-boot validation",
+      });
+    }
+  });
+export type RigProviderImage = z.infer<typeof RigProviderImage>;
+
+export const RigProviderImages = z.partialRecord(SandboxBackend, RigProviderImage);
+export type RigProviderImages = z.infer<typeof RigProviderImages>;
+
 export const RigVersion = z.object({
   id: z.string().uuid(),
   rigId: z.string().uuid(),
@@ -5269,6 +6399,9 @@ export const RigVersion = z.object({
   credentialHooks: z.array(z.string()),
   defaultVariableSetIds: z.array(z.string().uuid()),
   changelog: z.string().nullable(),
+  // Operational build metadata is version-bound but not part of the immutable
+  // rig definition. Each backend records its own truthful build state.
+  providerImages: RigProviderImages.default({}),
   // Attribution: 'user:<subject>' | 'session:<id>' | 'system'.
   createdBy: z.string().nullable(),
   active: z.boolean(),
@@ -5361,6 +6494,40 @@ export const UpdateRigRequest = z.object({
 });
 export type UpdateRigRequest = z.infer<typeof UpdateRigRequest>;
 
+// Workspace-shared channels organize root sessions ("workstreams") by work
+// type in the rail. Pure organizational metadata: filing a session into a
+// channel never affects execution, authority, memory, or history.
+export const Channel = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().nullable(),
+  createdBy: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+export type Channel = z.infer<typeof Channel>;
+
+export const CreateChannelRequest = z.object({
+  name: z.string().trim().min(1).max(80),
+  description: z.string().max(2000).optional(),
+});
+export type CreateChannelRequest = z.infer<typeof CreateChannelRequest>;
+
+export const UpdateChannelRequest = z.object({
+  name: z.string().trim().min(1).max(80).optional(),
+  description: z.string().max(2000).nullable().optional(),
+});
+export type UpdateChannelRequest = z.infer<typeof UpdateChannelRequest>;
+
+// Re-files one session (rail organization only). null moves it back to the
+// unfiled inbox.
+export const UpdateSessionChannelRequest = z.object({
+  channelId: z.string().uuid().nullable(),
+});
+export type UpdateSessionChannelRequest = z.infer<typeof UpdateSessionChannelRequest>;
+
 // setup_append: the exact command that already worked (+ an optional note).
 export const RigSetupAppendPayload = z.object({
   command: z.string().min(1).max(8192),
@@ -5389,26 +6556,112 @@ export const ProposeRigChangeRequest = z.discriminatedUnion("kind", [
 ]);
 export type ProposeRigChangeRequest = z.infer<typeof ProposeRigChangeRequest>;
 
-export const ScheduledTaskStatus = z.enum(["active", "paused"]);
+export const ScheduledTaskStatus = /* @__PURE__ */ z.enum(["active", "paused"]);
 export type ScheduledTaskStatus = z.infer<typeof ScheduledTaskStatus>;
 
-export const ScheduledTaskRunStatus = z.enum(["queued", "dispatched", "failed"]);
+export const ScheduledTaskRunStatus = /* @__PURE__ */ z.enum([
+  "queued",
+  "dispatched",
+  "succeeded",
+  "skipped",
+  "failed",
+]);
 export type ScheduledTaskRunStatus = z.infer<typeof ScheduledTaskRunStatus>;
 
-export const ScheduledTaskRunMode = z.enum([
+export const ScheduledTaskRunMode = /* @__PURE__ */ z.enum([
   "new_session_per_run",
   "reusable_session",
   "existing_session",
 ]);
 export type ScheduledTaskRunMode = z.infer<typeof ScheduledTaskRunMode>;
 
-export const ScheduledTaskOverlapPolicy = z.enum(["allow_concurrent", "skip", "buffer_one"]);
+export const ScheduledTaskOverlapPolicy = /* @__PURE__ */ z.enum([
+  "allow_concurrent",
+  "skip",
+  "buffer_one",
+]);
 export type ScheduledTaskOverlapPolicy = z.infer<typeof ScheduledTaskOverlapPolicy>;
 
-export const ScheduledTaskTriggerType = z.enum(["scheduled", "manual"]);
+export const ScheduledTaskTriggerType = /* @__PURE__ */ z.enum([
+  "scheduled",
+  "manual",
+  "initial",
+  "provider_event",
+  "retry",
+  "repair",
+]);
 export type ScheduledTaskTriggerType = z.infer<typeof ScheduledTaskTriggerType>;
 
-export const ScheduledTaskScheduleSpec = z.discriminatedUnion("type", [
+export const ScheduledTaskActionKind = /* @__PURE__ */ z.enum([
+  "agent_turn",
+  "knowledge_source_sync",
+]);
+export type ScheduledTaskActionKind = z.infer<typeof ScheduledTaskActionKind>;
+
+const KnowledgeSourceSyncPositiveInteger = z.number().int().positive();
+const KnowledgeSourceSyncNonnegativeInteger = z.number().int().nonnegative();
+const KnowledgeSourceSyncZeroInteger = KnowledgeSourceSyncNonnegativeInteger.default(0);
+const KnowledgeSourceSyncUuid = z.string().uuid();
+const KnowledgeSourceSyncSubject = z.string().min(1).max(1024);
+const KnowledgeSourceSyncEnabled = z.boolean().default(true);
+const KnowledgeSourceSyncDisabled = z.boolean().default(false);
+
+export const KnowledgeSourceSyncLimits = /* @__PURE__ */ z.object({
+  maxItems: KnowledgeSourceSyncPositiveInteger.max(10_000).default(500),
+  maxBytes: KnowledgeSourceSyncPositiveInteger.max(5_000_000_000).default(500_000_000),
+  maxFileBytes: KnowledgeSourceSyncPositiveInteger.max(5_000_000_000).default(100_000_000),
+  maxProviderRequests: KnowledgeSourceSyncPositiveInteger.max(10_000).default(1_000),
+  maxElapsedSeconds: KnowledgeSourceSyncPositiveInteger.max(3_600).default(300),
+  maxConcurrency: KnowledgeSourceSyncPositiveInteger.max(32).default(4),
+  maxFailureDetails: KnowledgeSourceSyncPositiveInteger.max(100).default(25),
+});
+export type KnowledgeSourceSyncLimits = z.infer<typeof KnowledgeSourceSyncLimits>;
+
+export const KnowledgeSourceSyncConnectionAuthority = /* @__PURE__ */ z.object({
+  connectionId: KnowledgeSourceSyncUuid,
+  connectionVersion: KnowledgeSourceSyncPositiveInteger,
+  providerDomain: z.string().min(1).max(2048),
+  kind: z.enum(["oauth2", "api_key", "app_install", "delegated"]),
+  ownerSubjectId: KnowledgeSourceSyncSubject,
+});
+export type KnowledgeSourceSyncConnectionAuthority = z.infer<
+  typeof KnowledgeSourceSyncConnectionAuthority
+>;
+
+export const KnowledgeSourceSyncAction = /* @__PURE__ */ z
+  .object({
+    kind: z.literal("knowledge_source_sync"),
+    sourceId: KnowledgeSourceSyncUuid,
+    sourceGeneration: KnowledgeSourceSyncNonnegativeInteger,
+    sourceLifecycleGeneration: KnowledgeSourceSyncPositiveInteger,
+    sourceConfigGeneration: KnowledgeSourceSyncPositiveInteger,
+    controlWorkspaceId: KnowledgeSourceSyncUuid,
+    providerCoordinationKey: z.string().trim().min(1).max(1024),
+    connection: KnowledgeSourceSyncConnectionAuthority,
+    destination: ScopedKnowledgeScope,
+    initiatingSubjectId: KnowledgeSourceSyncSubject,
+    allDescendants: KnowledgeSourceSyncEnabled,
+    limits: KnowledgeSourceSyncLimits.prefault({}),
+  })
+  .strict();
+export type KnowledgeSourceSyncAction = z.infer<typeof KnowledgeSourceSyncAction>;
+
+export const KnowledgeSourceSyncScheduleControl = /* @__PURE__ */ z
+  .object({
+    sourceEnabled: KnowledgeSourceSyncEnabled,
+    connectionPaused: KnowledgeSourceSyncDisabled,
+  })
+  .strict();
+export type KnowledgeSourceSyncScheduleControl = z.infer<typeof KnowledgeSourceSyncScheduleControl>;
+
+export const ScheduledTaskAction = /* @__PURE__ */ z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("agent_turn") }).strict(),
+  KnowledgeSourceSyncAction,
+]);
+export type ScheduledTaskAction = z.infer<typeof ScheduledTaskAction>;
+
+export const ScheduledTaskScheduleSpec = /* @__PURE__ */ z.discriminatedUnion("type", [
+  z.object({ type: z.literal("manual") }).strict(),
   z.object({
     type: z.literal("once"),
     runAt: z.string().datetime({ offset: true }),
@@ -5433,7 +6686,7 @@ export const ScheduledTaskScheduleSpec = z.discriminatedUnion("type", [
 ]);
 export type ScheduledTaskScheduleSpec = z.infer<typeof ScheduledTaskScheduleSpec>;
 
-export const ScheduledTaskAgentConfig = z.object({
+export const ScheduledTaskAgentConfig = /* @__PURE__ */ z.object({
   prompt: z.string().min(1),
   resources: z.array(ResourceRef).default([]),
   tools: z.array(ToolRef).default([]),
@@ -5452,7 +6705,7 @@ export const ScheduledTaskAgentConfig = z.object({
 });
 export type ScheduledTaskAgentConfig = z.infer<typeof ScheduledTaskAgentConfig>;
 
-export const ScheduledTask = z.object({
+export const ScheduledTask = /* @__PURE__ */ z.object({
   id: z.string().uuid(),
   accountId: z.string().uuid(),
   workspaceId: z.string().uuid(),
@@ -5462,6 +6715,7 @@ export const ScheduledTask = z.object({
   temporalScheduleId: z.string(),
   runMode: ScheduledTaskRunMode,
   overlapPolicy: ScheduledTaskOverlapPolicy,
+  action: ScheduledTaskAction.default({ kind: "agent_turn" }),
   agentConfig: ScheduledTaskAgentConfig,
   createdBy: TurnInitiator.default({
     kind: "service",
@@ -5484,7 +6738,52 @@ export const ScheduledTask = z.object({
 });
 export type ScheduledTask = z.infer<typeof ScheduledTask>;
 
-export const ScheduledTaskRun = z.object({
+export const KnowledgeSourceSyncFailure = /* @__PURE__ */ z.object({
+  externalObjectId: KnowledgeSourceSyncSubject,
+  code: z.enum([
+    "authority_changed",
+    "connection_reconnect_required",
+    "provider_unavailable",
+    "provider_rejected",
+    "provider_payload_invalid",
+    "content_unsupported",
+    "content_too_large",
+    "resource_limit",
+    "item_processing_failed",
+    "indexing_failed",
+    "internal_failure",
+  ]),
+  retryable: z.boolean(),
+  message: z.string().min(1).max(1000),
+});
+export type KnowledgeSourceSyncFailure = z.infer<typeof KnowledgeSourceSyncFailure>;
+
+export const KnowledgeSourceSyncRunSummary = /* @__PURE__ */ z.object({
+  phase: z
+    .enum(["queued", "inventory", "transfer", "index", "checkpoint", "completed", "failed"])
+    .default("queued"),
+  scanned: KnowledgeSourceSyncZeroInteger,
+  imported: KnowledgeSourceSyncZeroInteger,
+  unchanged: KnowledgeSourceSyncZeroInteger,
+  skipped: KnowledgeSourceSyncZeroInteger,
+  failed: KnowledgeSourceSyncZeroInteger,
+  bytes: KnowledgeSourceSyncZeroInteger,
+  providerRequests: KnowledgeSourceSyncZeroInteger,
+  elapsedMs: KnowledgeSourceSyncZeroInteger,
+  indexed: KnowledgeSourceSyncZeroInteger,
+  aclPending: KnowledgeSourceSyncZeroInteger,
+  retryable: KnowledgeSourceSyncDisabled,
+  limitReached: z
+    .enum(["items", "bytes", "file_bytes", "provider_requests", "elapsed_time"])
+    .nullable()
+    .default(null),
+  checkpointed: KnowledgeSourceSyncDisabled,
+  reconnectRequired: KnowledgeSourceSyncDisabled,
+  failures: z.array(KnowledgeSourceSyncFailure).max(100).default([]),
+});
+export type KnowledgeSourceSyncRunSummary = z.infer<typeof KnowledgeSourceSyncRunSummary>;
+
+export const ScheduledTaskRun = /* @__PURE__ */ z.object({
   id: z.string().uuid(),
   accountId: z.string().uuid(),
   workspaceId: z.string().uuid(),
@@ -5495,15 +6794,23 @@ export const ScheduledTaskRun = z.object({
   firedAt: z.string(),
   sessionId: z.string().uuid().nullable(),
   triggerEventId: z.string().uuid().nullable(),
+  actionKind: ScheduledTaskActionKind.default("agent_turn"),
+  knowledgeSyncRunId: KnowledgeSourceSyncUuid.nullable().default(null),
+  knowledgeSummary: KnowledgeSourceSyncRunSummary.nullable().default(null),
+  completedAt: z.string().nullable().default(null),
   error: z.string().nullable(),
   createdAt: z.string(),
   updatedAt: z.string(),
 });
 export type ScheduledTaskRun = z.infer<typeof ScheduledTaskRun>;
 
-export const CreateScheduledTaskRequest = withVariableSetIdAlias({
+const CreateAgentScheduledTaskRequest = /* @__PURE__ */ withVariableSetIdAlias({
   name: z.string().min(1),
   schedule: ScheduledTaskScheduleSpec,
+  action: z
+    .object({ kind: z.literal("agent_turn") })
+    .strict()
+    .default({ kind: "agent_turn" }),
   runMode: ScheduledTaskRunMode.default("new_session_per_run"),
   overlapPolicy: ScheduledTaskOverlapPolicy.default("allow_concurrent"),
   targetSessionId: z.string().uuid().nullable().optional(),
@@ -5537,48 +6844,80 @@ export const CreateScheduledTaskRequest = withVariableSetIdAlias({
     });
   }
 });
+
+const CreateKnowledgeSourceSyncScheduledTaskRequest = /* @__PURE__ */ z
+  .object({
+    name: z.string().min(1),
+    schedule: ScheduledTaskScheduleSpec,
+    action: KnowledgeSourceSyncAction,
+    overlapPolicy: z.enum(["skip", "buffer_one"]).default("buffer_one"),
+    status: ScheduledTaskStatus.default("active"),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+  })
+  .strict()
+  .transform((value) => ({
+    ...value,
+    runMode: "new_session_per_run" as const,
+    targetSessionId: null,
+    agentConfig: {
+      prompt: "Knowledge source synchronization",
+      resources: [],
+      tools: [],
+      metadata: {},
+    },
+    variableSetId: null,
+    environmentId: null,
+    rigId: null,
+  }));
+
+export const CreateScheduledTaskRequest = /* @__PURE__ */ z.union([
+  CreateKnowledgeSourceSyncScheduledTaskRequest,
+  CreateAgentScheduledTaskRequest,
+]);
 export type CreateScheduledTaskRequest = z.infer<typeof CreateScheduledTaskRequest>;
 
-export const UpdateScheduledTaskRequest = withVariableSetIdAlias({
-  name: z.string().min(1).optional(),
-  schedule: ScheduledTaskScheduleSpec.optional(),
-  runMode: ScheduledTaskRunMode.optional(),
-  overlapPolicy: ScheduledTaskOverlapPolicy.optional(),
-  targetSessionId: z.string().uuid().nullable().optional(),
-  agentConfig: ScheduledTaskAgentConfig.optional(),
-  status: ScheduledTaskStatus.optional(),
-  variableSetId: z.string().uuid().nullable().optional(),
-  environmentId: z.string().uuid().nullable().optional(),
-  // The rig each run binds to (M3); null clears it. Its active version is
-  // resolved per fire, so an update takes effect on the next dispatch.
-  rigId: z.string().uuid().nullable().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-}).superRefine((value, context) => {
-  if (value.targetSessionId && value.runMode && value.runMode !== "existing_session") {
-    context.addIssue({
-      code: "custom",
-      path: ["targetSessionId"],
-      message: "targetSessionId requires runMode=existing_session",
-    });
-  }
-  if (value.runMode === "existing_session" && value.targetSessionId === null) {
-    context.addIssue({
-      code: "custom",
-      path: ["targetSessionId"],
-      message: "targetSessionId cannot be null when runMode=existing_session",
-    });
-  }
-  if (
-    value.agentConfig?.goal &&
-    (value.runMode === "existing_session" || Boolean(value.targetSessionId))
-  ) {
-    context.addIssue({
-      code: "custom",
-      path: ["agentConfig", "goal"],
-      message: "agentConfig.goal cannot be used with an existing-session target",
-    });
-  }
-});
+export const UpdateScheduledTaskRequest =
+  /* @__PURE__ */ withVariableSetIdAlias({
+    name: z.string().min(1).optional(),
+    schedule: ScheduledTaskScheduleSpec.optional(),
+    runMode: ScheduledTaskRunMode.optional(),
+    overlapPolicy: ScheduledTaskOverlapPolicy.optional(),
+    action: ScheduledTaskAction.optional(),
+    targetSessionId: z.string().uuid().nullable().optional(),
+    agentConfig: ScheduledTaskAgentConfig.optional(),
+    status: ScheduledTaskStatus.optional(),
+    variableSetId: z.string().uuid().nullable().optional(),
+    environmentId: z.string().uuid().nullable().optional(),
+    // The rig each run binds to (M3); null clears it. Its active version is
+    // resolved per fire, so an update takes effect on the next dispatch.
+    rigId: z.string().uuid().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  }).superRefine((value, context) => {
+    if (value.targetSessionId && value.runMode && value.runMode !== "existing_session") {
+      context.addIssue({
+        code: "custom",
+        path: ["targetSessionId"],
+        message: "targetSessionId requires runMode=existing_session",
+      });
+    }
+    if (value.runMode === "existing_session" && value.targetSessionId === null) {
+      context.addIssue({
+        code: "custom",
+        path: ["targetSessionId"],
+        message: "targetSessionId cannot be null when runMode=existing_session",
+      });
+    }
+    if (
+      value.agentConfig?.goal &&
+      (value.runMode === "existing_session" || Boolean(value.targetSessionId))
+    ) {
+      context.addIssue({
+        code: "custom",
+        path: ["agentConfig", "goal"],
+        message: "agentConfig.goal cannot be used with an existing-session target",
+      });
+    }
+  });
 export type UpdateScheduledTaskRequest = z.infer<typeof UpdateScheduledTaskRequest>;
 
 /**
@@ -5729,11 +7068,86 @@ function isSafePackSkillRelativePath(path: string): boolean {
     .every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
 }
 
-const CapabilityPackVariableSet = z.object({
-  description: z.string().min(1),
-  requiredVariables: z.array(VariableSetVariableName).default([]),
-  required: z.boolean().default(false),
-});
+const CapabilityPackVariableSet = z
+  .object({
+    description: z.string().min(1).max(2048),
+    requiredVariables: z.array(VariableSetVariableName).max(256).default([]),
+    required: z.boolean().default(false),
+  })
+  .strict();
+
+const CapabilityPackComponentKey = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/);
+
+const CapabilityPackInstanceKey = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/);
+
+/**
+ * Immutable requirements adopted by a Pack installation. The manifest names
+ * portable identities; installation resolves them to exact workspace-local
+ * component rows and records Pack ownership in the shared component ledger.
+ */
+export const CapabilityPackComponentReference = z.discriminatedUnion("kind", [
+  z
+    .object({
+      key: CapabilityPackComponentKey,
+      kind: z.literal("plugin"),
+      pluginKey: z.string().min(1).max(200),
+      version: z.string().min(1).max(128),
+      manifestDigest: z.string().regex(/^[0-9a-f]{64}$/),
+      required: z.boolean().default(true),
+    })
+    .strict(),
+  z
+    .object({
+      key: CapabilityPackComponentKey,
+      kind: z.literal("skill"),
+      capabilityId: z.string().min(1).max(512),
+      contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+      required: z.boolean().default(true),
+    })
+    .strict(),
+  z
+    .object({
+      key: CapabilityPackComponentKey,
+      kind: z.literal("integration"),
+      capabilityId: z.string().min(1).max(512),
+      instanceKey: CapabilityPackInstanceKey,
+      revisionId: z.string().min(1).max(512),
+      contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+      required: z.boolean().default(true),
+    })
+    .strict(),
+  z
+    .object({
+      key: CapabilityPackComponentKey,
+      kind: z.literal("facet"),
+      capabilityId: z.string().min(1).max(512),
+      instanceKey: CapabilityPackInstanceKey,
+      facetKey: z.string().min(1).max(200),
+      bindingKey: CapabilityPackInstanceKey,
+      configDigest: z.string().regex(/^[0-9a-f]{64}$/),
+      required: z.boolean().default(true),
+    })
+    .strict(),
+]);
+export type CapabilityPackComponentReference = z.infer<typeof CapabilityPackComponentReference>;
+
+export const CapabilityPackRigRequirement = z
+  .object({
+    description: z.string().min(1).max(2048).optional(),
+    required: z.boolean().default(true),
+    rigId: z.string().uuid().optional(),
+    requireVerified: z.boolean().default(false),
+  })
+  .strict();
+export type CapabilityPackRigRequirement = z.infer<typeof CapabilityPackRigRequirement>;
 
 export const CapabilityPack = z.preprocess(
   (input) => {
@@ -5763,15 +7177,19 @@ export const CapabilityPack = z.preprocess(
   },
   z
     .object({
-      id: z.string().min(1),
-      name: z.string().min(1),
-      description: z.string().min(1),
-      role: z.string().min(1),
-      category: z.string().min(1),
-      version: z.string().min(1),
-      // Container image ref (digest-pinned recommended) the pack's sessions run
-      // in. At most one enabled pack per workspace may declare one; with none,
-      // sessions use the deployment-wide image settings.
+      id: z
+        .string()
+        .min(1)
+        .max(100)
+        .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/),
+      name: z.string().min(1).max(200),
+      description: z.string().min(1).max(4096),
+      role: z.string().min(1).max(128),
+      category: z.string().min(1).max(128),
+      version: z.string().min(1).max(128),
+      // Legacy manifest compatibility. V2 installation resolves this image to
+      // an explicit Rig requirement; the Pack no longer changes workspace
+      // runtime settings directly.
       sandboxImage: z.string().trim().min(1).max(512).optional(),
       // Optional provider-native immutable identities for the exact logical
       // sandboxImage above. These avoid re-importing a private registry image on
@@ -5791,7 +7209,8 @@ export const CapabilityPack = z.preprocess(
         })
         .strict()
         .optional(),
-      // Skills delivered into the sandbox skill index when the pack is enabled.
+      // Legacy inline Skills are migrated into immutable Skill components by
+      // the V2 Pack installer. They are not loaded directly by V2 runtime.
       skills: z
         .array(CapabilityPackSkill)
         .max(32)
@@ -5810,6 +7229,8 @@ export const CapabilityPack = z.preprocess(
           });
         })
         .default([]),
+      components: z.array(CapabilityPackComponentReference).max(128).default([]),
+      rig: CapabilityPackRigRequirement.optional(),
       tools: z.array(ToolRef).default([]),
       connectors: z.array(CapabilityPackConnector).default([]),
       knowledge: z.array(CapabilityPackKnowledge).default([]),
@@ -5818,6 +7239,28 @@ export const CapabilityPack = z.preprocess(
       metadata: z.record(z.string(), z.unknown()).default({}),
     })
     .superRefine((pack, ctx) => {
+      const componentKeys = new Set<string>();
+      pack.components.forEach((component, index) => {
+        if (componentKeys.has(component.key)) {
+          ctx.addIssue({
+            code: "custom",
+            message: `duplicate Pack component key: ${component.key}`,
+            path: ["components", index, "key"],
+          });
+        }
+        componentKeys.add(component.key);
+      });
+      pack.skills.forEach((skill, index) => {
+        const key = `inline-skill/${skill.name.toLowerCase()}`;
+        if (componentKeys.has(key)) {
+          ctx.addIssue({
+            code: "custom",
+            message: `Pack component key conflicts with inline Skill ${skill.name}: ${key}`,
+            path: ["skills", index, "name"],
+          });
+        }
+        componentKeys.add(key);
+      });
       if (!pack.sandboxProviderImages?.modal) {
         return;
       }
@@ -5855,7 +7298,12 @@ export const WorkspaceRegisteredPack = z.object({
 });
 export type WorkspaceRegisteredPack = z.infer<typeof WorkspaceRegisteredPack>;
 
-export const PackInstallationStatus = z.enum(["active", "disabled"]);
+export const PackInstallationStatus = z.enum([
+  "installing",
+  "active",
+  "needs_attention",
+  "disabled",
+]);
 export type PackInstallationStatus = z.infer<typeof PackInstallationStatus>;
 
 export const PackInstallation = z.object({
@@ -5864,6 +7312,14 @@ export const PackInstallation = z.object({
   workspaceId: z.string().uuid(),
   packId: z.string().min(1),
   status: PackInstallationStatus,
+  version: z.number().int().positive(),
+  manifestSnapshot: CapabilityPack.nullable(),
+  manifestDigest: z
+    .string()
+    .regex(/^[0-9a-f]{64}$/)
+    .nullable(),
+  selectedRigId: z.string().uuid().nullable(),
+  installedBySubjectId: z.string().min(1).max(1024).nullable(),
   metadata: z.record(z.string(), z.unknown()),
   enabledAt: z.string(),
   updatedAt: z.string(),
@@ -5877,6 +7333,116 @@ export const EnablePackRequest = withVariableSetIdAlias({
 });
 export type EnablePackRequest = z.infer<typeof EnablePackRequest>;
 
+export const PackComponentResolutionStatus = z.enum(["ready", "missing", "mismatch"]);
+export type PackComponentResolutionStatus = z.infer<typeof PackComponentResolutionStatus>;
+
+export const PackComponentResolution = z
+  .object({
+    key: CapabilityPackComponentKey,
+    kind: z.enum(["plugin", "skill", "integration", "facet", "inline_skill"]),
+    capabilityId: z.string().min(1).max(512),
+    required: z.boolean(),
+    status: PackComponentResolutionStatus,
+    expectedDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    actualDigest: z
+      .string()
+      .regex(/^[0-9a-f]{64}$/)
+      .nullable(),
+    resolvedId: z.string().min(1).max(512).nullable(),
+    label: z.string().min(1).max(200),
+  })
+  .strict();
+export type PackComponentResolution = z.infer<typeof PackComponentResolution>;
+
+export const PackRigResolution = z
+  .object({
+    required: z.boolean(),
+    status: z.enum(["not_required", "ready", "missing", "mismatch", "unverified"]),
+    requestedRigId: z.string().uuid().nullable(),
+    rigId: z.string().uuid().nullable(),
+    rigVersionId: z.string().uuid().nullable(),
+    name: z.string().min(1).max(200).nullable(),
+    image: z.string().min(1).max(512).nullable(),
+  })
+  .strict();
+export type PackRigResolution = z.infer<typeof PackRigResolution>;
+
+export const PreviewPackInstallationRequest = z
+  .object({
+    rigId: z.string().uuid().optional(),
+    variableSetId: z.string().uuid().optional(),
+  })
+  .strict();
+export type PreviewPackInstallationRequest = z.infer<typeof PreviewPackInstallationRequest>;
+
+export const PackInstallationPreview = z
+  .object({
+    packId: z.string().min(1),
+    packVersion: z.string().min(1),
+    manifestDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    installationVersion: z.number().int().positive().nullable(),
+    action: z.enum(["install", "update", "repair"]),
+    ready: z.boolean(),
+    blockers: z.array(z.string().min(1).max(500)).max(256),
+    components: z.array(PackComponentResolution).max(160),
+    rig: PackRigResolution,
+    variableSetId: z.string().uuid().nullable(),
+    legacyInlineSkillCount: z.number().int().nonnegative().max(32),
+    legacySandboxImage: z.string().min(1).max(512).nullable(),
+  })
+  .strict();
+export type PackInstallationPreview = z.infer<typeof PackInstallationPreview>;
+
+export const InstallPackRequest = z
+  .object({
+    expectedManifestDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    expectedInstallationVersion: z.number().int().positive().optional(),
+    rigId: z.string().uuid().optional(),
+    variableSetId: z.string().uuid().optional(),
+    idempotencyKey: z.string().uuid(),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+  })
+  .strict();
+export type InstallPackRequest = z.infer<typeof InstallPackRequest>;
+
+export const PackUninstallPreview = z
+  .object({
+    packId: z.string().min(1),
+    installed: z.boolean(),
+    installationVersion: z.number().int().positive().nullable(),
+    components: z
+      .array(
+        z
+          .object({
+            key: CapabilityPackComponentKey,
+            kind: z.enum(["plugin", "skill", "integration", "facet", "inline_skill"]),
+            capabilityId: z.string().min(1).max(512),
+            retainedByOtherOwners: z.boolean(),
+          })
+          .strict(),
+      )
+      .max(160),
+  })
+  .strict();
+export type PackUninstallPreview = z.infer<typeof PackUninstallPreview>;
+
+export const UninstallPackRequest = z
+  .object({
+    expectedInstallationVersion: z.number().int().positive(),
+    idempotencyKey: z.string().uuid(),
+  })
+  .strict();
+export type UninstallPackRequest = z.infer<typeof UninstallPackRequest>;
+
+export const UninstallPackResult = z
+  .object({
+    packId: z.string().min(1),
+    status: z.enum(["not_installed", "uninstalled"]),
+    retainedComponents: z.array(z.string().min(1).max(512)).max(160),
+  })
+  .strict();
+export type UninstallPackResult = z.infer<typeof UninstallPackResult>;
+
 export const SocialProvider = z.enum([
   "x",
   "reddit",
@@ -5995,6 +7561,48 @@ export const OpenGeniSlackBotConnectionMetadata = z
   .passthrough();
 export type OpenGeniSlackBotConnectionMetadata = z.infer<typeof OpenGeniSlackBotConnectionMetadata>;
 
+export const FIKEN_PROVIDER_DOMAIN = "fiken.no" as const;
+export const FIKEN_CREDENTIAL_ROLE = "fiken_api_token" as const;
+export const FIKEN_CREDENTIAL_LABEL = "Fiken API token" as const;
+
+export const FikenCompanySummary = z.object({
+  slug: z.string().min(1).max(128),
+  name: z.string().min(1).max(256),
+  organizationNumber: z.string().max(64).nullable(),
+});
+export type FikenCompanySummary = z.infer<typeof FikenCompanySummary>;
+
+export const FikenConnectionMetadata = z
+  .object({
+    credentialRole: z.literal(FIKEN_CREDENTIAL_ROLE),
+    credentialLabel: z.literal(FIKEN_CREDENTIAL_LABEL),
+    companies: z.array(FikenCompanySummary).max(100),
+    defaultCompanySlug: z.string().min(1).max(128).nullable(),
+    verifiedAt: z.string().datetime({ offset: true }),
+  })
+  .passthrough();
+export type FikenConnectionMetadata = z.infer<typeof FikenConnectionMetadata>;
+
+export const FikenInstallRequest = z.object({
+  apiToken: z.string().min(16).max(512),
+  defaultCompanySlug: z.string().min(1).max(128).optional(),
+  /** Existing Fiken connection to rewrite in place (reconnect). */
+  connectionId: z.string().uuid().optional(),
+});
+export type FikenInstallRequest = z.infer<typeof FikenInstallRequest>;
+
+export const FikenOAuthStartRequest = z.object({
+  /** Existing Fiken connection to re-authorize in place (reconnect). */
+  connectionId: z.string().uuid().optional(),
+});
+export type FikenOAuthStartRequest = z.infer<typeof FikenOAuthStartRequest>;
+
+export const FikenOAuthStartResponse = z.object({
+  authorizationUrl: z.string().url(),
+  expiresAt: z.string().datetime({ offset: true }),
+});
+export type FikenOAuthStartResponse = z.infer<typeof FikenOAuthStartResponse>;
+
 export const ConnectionMetadata = z.object({
   id: z.string().uuid(),
   accountId: z.string().uuid(),
@@ -6110,6 +7718,38 @@ export const OpenGeniSlackBotInstallStart = z.object({
 });
 export type OpenGeniSlackBotInstallStart = z.infer<typeof OpenGeniSlackBotInstallStart>;
 
+export const SlackInstallationBindingState = z.enum(["active", "quarantined"]);
+export type SlackInstallationBindingState = z.infer<typeof SlackInstallationBindingState>;
+
+export const SlackInstallationBinding = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  accountName: z.string().min(1),
+  workspaceId: z.string().uuid(),
+  workspaceName: z.string().min(1),
+  connectionId: z.string().uuid(),
+  connectionStatus: ConnectionStatus,
+  connectionVersion: z.number().int().positive(),
+  slackTeamId: z.string().min(1).max(64),
+  slackTeamName: z.string().min(1).max(256),
+  botId: z.string().min(1).max(64),
+  botUserId: z.string().min(1).max(64),
+  botDisplayName: z.literal("OpenGeni"),
+  state: SlackInstallationBindingState,
+  quarantineReason: z.string().min(1).nullable(),
+  version: z.number().int().positive(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+export type SlackInstallationBinding = z.infer<typeof SlackInstallationBinding>;
+
+export const ListSlackInstallationBindingsResponse = z.object({
+  bindings: z.array(SlackInstallationBinding),
+});
+export type ListSlackInstallationBindingsResponse = z.infer<
+  typeof ListSlackInstallationBindingsResponse
+>;
+
 export const UpdateConnectionRequest = z.object({
   providerDomain: z.string().min(1).optional(),
   subjectId: z.string().min(1).nullable().optional(),
@@ -6201,176 +7841,977 @@ export const CapabilitySource = z.enum([
 ]);
 export type CapabilitySource = z.infer<typeof CapabilitySource>;
 
-export const CapabilityInstallationStatus = z.enum(["active", "disabled"]);
-export type CapabilityInstallationStatus = z.infer<typeof CapabilityInstallationStatus>;
+export const CapabilityInstallationStatus = z.enum(["active", "disabled"]);
+export type CapabilityInstallationStatus = z.infer<typeof CapabilityInstallationStatus>;
+
+export const CapabilityCatalogAuthKind = z.enum(["oauth2", "api_key", "none", "unknown"]);
+export type CapabilityCatalogAuthKind = z.infer<typeof CapabilityCatalogAuthKind>;
+
+export const CapabilityCatalogTier = z.enum(["verified", "community"]);
+export type CapabilityCatalogTier = z.infer<typeof CapabilityCatalogTier>;
+
+/**
+ * User-facing lifecycle truth for the Capabilities control center. This is a
+ * read-model projection only: each action is still executed by the owning
+ * Plugin, Integration, Connection, Skill, or Pack domain.
+ */
+export const CapabilityLifecycleStatus = z.enum([
+  "available",
+  "installed",
+  "connected",
+  "ready",
+  "needs_attention",
+  "unavailable",
+  "managed",
+]);
+export type CapabilityLifecycleStatus = z.infer<typeof CapabilityLifecycleStatus>;
+
+export const CapabilityReadiness = z.enum(["ready", "setup_required", "attention", "unavailable"]);
+export type CapabilityReadiness = z.infer<typeof CapabilityReadiness>;
+
+export const CapabilityAction = z.enum([
+  "install",
+  "connect",
+  "configure",
+  "update",
+  "repair",
+  "disconnect",
+  "uninstall",
+  "inspect",
+]);
+export type CapabilityAction = z.infer<typeof CapabilityAction>;
+
+export const CapabilityLifecycle = z.object({
+  status: CapabilityLifecycleStatus,
+  readiness: CapabilityReadiness,
+  detail: z.string().nullable().default(null),
+  managedBy: z.enum(["deployment", "platform", "workspace"]).nullable().default(null),
+});
+export type CapabilityLifecycle = z.infer<typeof CapabilityLifecycle>;
+
+export const CapabilityRuntime = z.object({
+  available: z.boolean().default(false),
+  mcpServerId: z.string().min(1).optional(),
+  transport: z.string().min(1).optional(),
+  notes: z.string().nullable().default(null),
+  // Registry exposure provenance is server-derived and contains no endpoint or
+  // credential material.
+  catalogTrust: z
+    .object({
+      state: z.enum(["trusted", "legacy_active", "unverified"]),
+      reason: z.enum([
+        "trusted_source",
+        "verified_probe",
+        "active_installation_compatibility",
+        "missing_verification",
+      ]),
+    })
+    .optional(),
+});
+export type CapabilityRuntime = z.infer<typeof CapabilityRuntime>;
+
+export const CapabilityCatalogItem = z.object({
+  id: z.string().min(1),
+  accountId: z.string().uuid().optional(),
+  workspaceId: z.string().uuid().optional(),
+  kind: CapabilityKind,
+  source: CapabilitySource,
+  name: z.string().min(1),
+  description: z.string().nullable().default(null),
+  category: z.string().min(1).default("custom"),
+  tags: z.array(z.string().min(1)).default([]),
+  homepageUrl: z.string().url().nullable().default(null),
+  endpointUrl: z.string().url().nullable().default(null),
+  installUrl: z.string().url().nullable().default(null),
+  authModel: z.string().min(1).nullable().default(null),
+  providerDomain: z.string().min(1).nullable().default(null),
+  surfaceType: z.string().min(1).nullable().default(null),
+  transport: z.string().min(1).nullable().default(null),
+  mcpUrl: z.string().url().nullable().default(null),
+  authKind: CapabilityCatalogAuthKind.nullable().default(null),
+  credentialFacts: z.array(z.record(z.string(), z.unknown())).default([]),
+  tier: CapabilityCatalogTier.nullable().default(null),
+  provenance: z.string().min(1).nullable().default(null),
+  logoAssetPath: z.string().min(1).nullable().default(null),
+  importBatchId: z.string().uuid().nullable().default(null),
+  stale: z.boolean().default(false),
+  staleAt: z.string().nullable().default(null),
+  tools: z.array(ToolRef).default([]),
+  runtime: CapabilityRuntime.default({ available: false, notes: null }),
+  lifecycle: CapabilityLifecycle.default({
+    status: "available",
+    readiness: "setup_required",
+    detail: null,
+    managedBy: null,
+  }),
+  actions: z.array(CapabilityAction).default([]),
+  /**
+   * @deprecated Compatibility projection for existing clients. New surfaces
+   * must use lifecycle and actions rather than treating every type as an
+   * enable/disable toggle.
+   */
+  enabled: z.boolean().default(false),
+  /** @deprecated Compatibility explanation paired with enabled. */
+  enabledReason: z.string().nullable().default(null),
+  // The non-secret connection binding stored with an enabled installation.
+  // Workspace refs retain an exact row id. Subject refs deliberately omit it:
+  // each caller resolves their own visible row by provider/kind at runtime.
+  connectionRef: z
+    .object({
+      connectionId: z.string().min(1).optional(),
+      providerDomain: z.string().min(1),
+      kind: z.string().min(1),
+      subjectScope: z.enum(["workspace", "subject"]).optional(),
+    })
+    .nullable()
+    .default(null),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+export type CapabilityCatalogItem = z.infer<typeof CapabilityCatalogItem>;
+
+/**
+ * Shared trust gate for catalog visibility and runtime selection. Registry rows
+ * remain durable for provenance and audit, but only a reviewed real-MCP probe
+ * with known authentication is exposable. API-key rows additionally need a
+ * machine-actionable header contract; prose credential instructions are not a
+ * runtime contract and must fail closed.
+ */
+export function capabilityCatalogItemIsTrustedForExposure(
+  item: Pick<CapabilityCatalogItem, "source" | "stale" | "authKind" | "metadata">,
+): boolean {
+  if (item.stale) return false;
+  if (item.source !== "registry") return true;
+  const probe = item.metadata.mcpProbe;
+  if (!probe || typeof probe !== "object" || Array.isArray(probe)) return false;
+  if ((probe as Record<string, unknown>).status !== "real") return false;
+  if (item.authKind === null || item.authKind === "unknown") return false;
+  if (item.authKind !== "api_key") return true;
+  const contract = item.metadata.authContract;
+  if (!contract || typeof contract !== "object" || Array.isArray(contract)) return false;
+  const record = contract as Record<string, unknown>;
+  return (
+    typeof record.headerName === "string" &&
+    /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/.test(record.headerName) &&
+    typeof record.scheme === "string" &&
+    record.scheme.trim().length > 0
+  );
+}
+
+export const CapabilityInstallation = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  capabilityId: z.string().min(1),
+  kind: CapabilityKind,
+  status: CapabilityInstallationStatus,
+  config: z.record(z.string(), z.unknown()),
+  metadata: z.record(z.string(), z.unknown()),
+  enabledAt: z.string(),
+  updatedAt: z.string(),
+});
+export type CapabilityInstallation = z.infer<typeof CapabilityInstallation>;
+
+export const CreateCapabilityCatalogItemRequest = z.object({
+  id: z.string().min(1).optional(),
+  kind: z.literal("mcp"),
+  source: CapabilitySource.default("manual"),
+  name: z.string().min(1),
+  description: z.string().min(1).optional(),
+  category: z.string().min(1).default("custom"),
+  tags: z.array(z.string().min(1)).default([]),
+  homepageUrl: z.string().url().optional(),
+  endpointUrl: z.string().url().optional(),
+  installUrl: z.string().url().optional(),
+  authModel: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+});
+export type CreateCapabilityCatalogItemRequest = z.infer<typeof CreateCapabilityCatalogItemRequest>;
+
+export const EnableCapabilityRequest = z.object({
+  config: z.record(z.string(), z.unknown()).default({}),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  connectionRef: McpServerConnectionRef.optional(),
+  /**
+   * Credential headers for remote MCP capabilities (for example an
+   * Authorization bearer token). Values are encrypted at rest with the
+   * workspace-variable-sets key, injected only into the runtime MCP client,
+   * and never returned by the API — responses expose header names only.
+   */
+  headers: z.record(z.string(), z.string()).default({}),
+});
+export type EnableCapabilityRequest = z.infer<typeof EnableCapabilityRequest>;
+
+export const CapabilityCatalogResponse = z.object({
+  items: z.array(CapabilityCatalogItem),
+  installations: z.array(CapabilityInstallation),
+});
+export type CapabilityCatalogResponse = z.infer<typeof CapabilityCatalogResponse>;
+
+export const DiscoverMcpCapabilitiesResponse = z.object({
+  items: z.array(CapabilityCatalogItem),
+  source: z.literal("official_mcp_registry"),
+  sourceUrl: z.string().url(),
+});
+export type DiscoverMcpCapabilitiesResponse = z.infer<typeof DiscoverMcpCapabilitiesResponse>;
+
+export const SkillImportSource = z.enum(["github", "skills_sh"]);
+export type SkillImportSource = z.infer<typeof SkillImportSource>;
+
+export const SkillInstallationSource = z.enum(["library", "github", "skills_sh", "pack"]);
+export type SkillInstallationSource = z.infer<typeof SkillInstallationSource>;
+
+export const PreviewSkillImportRequest = z.object({
+  url: z.string().url().max(2048),
+});
+export type PreviewSkillImportRequest = z.infer<typeof PreviewSkillImportRequest>;
+
+export const SkillImportFileSummary = z.object({
+  path: z.string().min(1).max(1024),
+  byteSize: z.number().int().nonnegative().max(262144),
+  contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+});
+export type SkillImportFileSummary = z.infer<typeof SkillImportFileSummary>;
+
+export const SkillImportPreview = z.object({
+  source: SkillImportSource,
+  sourceUrl: z.string().url(),
+  repositoryUrl: z.string().url(),
+  owner: z.string().min(1).max(100),
+  repository: z.string().min(1).max(100),
+  sourcePath: z.string().min(1).max(1024),
+  sourceCommit: z.string().regex(/^[0-9a-f]{40,64}$/),
+  name: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/),
+  description: z.string().min(1).max(2048),
+  contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  totalBytes: z.number().int().positive().max(1048576),
+  files: z.array(SkillImportFileSummary).min(1).max(128),
+  warnings: z.array(z.string().min(1).max(500)).max(32).default([]),
+  installed: z.boolean().default(false),
+  installationVersion: z.number().int().positive().nullable().default(null),
+});
+export type SkillImportPreview = z.infer<typeof SkillImportPreview>;
+
+export const InstallSkillRequest = z.object({
+  url: z.string().url().max(2048),
+  expectedSourceCommit: z.string().regex(/^[0-9a-f]{40,64}$/),
+  expectedContentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  expectedInstallationVersion: z.number().int().positive().optional(),
+});
+export type InstallSkillRequest = z.infer<typeof InstallSkillRequest>;
+
+export const InstallLibrarySkillRequest = z
+  .object({
+    expectedVersion: z.string().min(1).max(96),
+    expectedContentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+    expectedInstallationVersion: z.number().int().positive().optional(),
+  })
+  .strict();
+export type InstallLibrarySkillRequest = z.infer<typeof InstallLibrarySkillRequest>;
+
+export const InstalledSkill = z.object({
+  capabilityId: z.string().min(1),
+  pluginId: z.string().uuid(),
+  pluginVersionId: z.string().uuid(),
+  facetId: z.string().uuid(),
+  pluginInstallationId: z.string().uuid(),
+  facetInstallationId: z.string().uuid(),
+  installationVersion: z.number().int().positive(),
+  source: SkillInstallationSource,
+  version: z.string().min(1).max(96),
+  sourceUrl: z.string().url(),
+  sourceCommit: z.string().regex(/^[0-9a-f]{40,64}$/),
+  contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  name: z.string(),
+  status: z.literal("installed"),
+});
+export type InstalledSkill = z.infer<typeof InstalledSkill>;
+
+export const CapabilityComponentOwner = z.object({
+  kind: z.enum(["direct", "plugin", "pack", "migration"]),
+  id: z.string().min(1).max(512),
+  removable: z.boolean(),
+});
+export type CapabilityComponentOwner = z.infer<typeof CapabilityComponentOwner>;
+
+export const InstalledSkillSummary = z
+  .object({
+    capabilityId: z.string().min(1),
+    pluginKey: z.string().min(1).max(200),
+    installationVersion: z.number().int().positive(),
+    name: z.string().min(1).max(200),
+    description: z.string().max(4000),
+    category: z.string().min(1).max(100),
+    tags: z.array(z.string().min(1).max(100)).max(64),
+    provenance: z.string().min(1).max(4000),
+    source: SkillInstallationSource,
+    version: z.string().min(1).max(96),
+    sourceUrl: z.string().url().max(2048),
+    repositoryUrl: z.string().url().max(2048),
+    sourceCommit: z.string().regex(/^[0-9a-f]{40,64}$/),
+    sourcePath: z.string().min(1).max(1024),
+    contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+    fileCount: z.number().int().positive().max(128),
+    totalBytes: z.number().int().positive().max(1048576),
+    license: z.string().min(1).max(200).nullable(),
+    installedAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true }),
+    owners: z.array(CapabilityComponentOwner).min(1),
+  })
+  .strict();
+export type InstalledSkillSummary = z.infer<typeof InstalledSkillSummary>;
+
+export const ListInstalledSkillsResponse = z
+  .object({ skills: z.array(InstalledSkillSummary).max(1000) })
+  .strict();
+export type ListInstalledSkillsResponse = z.infer<typeof ListInstalledSkillsResponse>;
+
+export const SkillUninstallPreview = z.object({
+  capabilityId: z.string().min(1),
+  installed: z.boolean(),
+  installationVersion: z.number().int().positive().nullable(),
+  directOwner: CapabilityComponentOwner.nullable(),
+  remainingOwners: z.array(CapabilityComponentOwner),
+  removesRuntimeSkill: z.boolean(),
+});
+export type SkillUninstallPreview = z.infer<typeof SkillUninstallPreview>;
+
+export const UninstallSkillRequest = z.object({
+  expectedInstallationVersion: z.number().int().positive(),
+});
+export type UninstallSkillRequest = z.infer<typeof UninstallSkillRequest>;
+
+export const UninstallSkillResult = z.object({
+  capabilityId: z.string().min(1),
+  status: z.enum(["not_installed", "uninstalled", "retained_by_other_owners"]),
+  remainingOwners: z.array(CapabilityComponentOwner),
+});
+export type UninstallSkillResult = z.infer<typeof UninstallSkillResult>;
+
+export const ApiIntegrationProtocol = z.enum(["openapi", "graphql"]);
+export type ApiIntegrationProtocol = z.infer<typeof ApiIntegrationProtocol>;
+
+export const IntegrationDefinitionProvenance = z.enum(["curated", "workspace"]);
+export type IntegrationDefinitionProvenance = z.infer<typeof IntegrationDefinitionProvenance>;
+
+export const IntegrationFacetKey = z
+  .string()
+  .min(1)
+  .max(200)
+  .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/);
+export type IntegrationFacetKey = z.infer<typeof IntegrationFacetKey>;
+
+export const IntegrationFacetKind = z.enum([
+  "tools",
+  "knowledge_source",
+  "inbound_trigger",
+  "delivery_destination",
+  "identity_link",
+]);
+export type IntegrationFacetKind = z.infer<typeof IntegrationFacetKind>;
+
+export const IntegrationFacetStatus = z.enum(["active", "paused", "needs_attention", "disabled"]);
+export type IntegrationFacetStatus = z.infer<typeof IntegrationFacetStatus>;
+
+const IntegrationFacetJsonObject = z.record(z.string(), z.unknown()).superRefine((value, ctx) => {
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(value);
+  } catch {
+    ctx.addIssue({ code: "custom", message: "must be JSON serializable" });
+    return;
+  }
+  if (new TextEncoder().encode(serialized).byteLength > 131_072) {
+    ctx.addIssue({
+      code: "custom",
+      message: "must not exceed 131072 UTF-8 bytes",
+    });
+  }
+});
+
+export const IntegrationFacetDefinitionSummary = z
+  .object({
+    facetKey: IntegrationFacetKey,
+    kind: IntegrationFacetKind.exclude(["tools"]),
+    configSchema: IntegrationFacetJsonObject,
+    capabilities: IntegrationFacetJsonObject,
+  })
+  .strict();
+export type IntegrationFacetDefinitionSummary = z.infer<typeof IntegrationFacetDefinitionSummary>;
+
+export const IntegrationDefinitionSummary = z
+  .object({
+    id: z.string().min(1).max(128),
+    name: z.string().min(1).max(200),
+    summary: z.string().min(1).max(1000),
+    protocol: z.literal("openapi"),
+    provider: z
+      .object({
+        id: z.enum(["google", "microsoft"]),
+        domain: z.string().min(1).max(253),
+      })
+      .strict(),
+    authentication: z
+      .object({
+        kind: z.literal("oauth2"),
+        scopes: z.array(z.string().min(1).max(1024)).max(256),
+      })
+      .strict(),
+    facets: z.array(IntegrationFacetDefinitionSummary).max(128),
+  })
+  .strict();
+export type IntegrationDefinitionSummary = z.infer<typeof IntegrationDefinitionSummary>;
+
+export const ListIntegrationDefinitionsResponse = z
+  .object({ definitions: z.array(IntegrationDefinitionSummary).max(128) })
+  .strict();
+export type ListIntegrationDefinitionsResponse = z.infer<typeof ListIntegrationDefinitionsResponse>;
+
+export const IntegrationInstanceKey = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/);
+export type IntegrationInstanceKey = z.infer<typeof IntegrationInstanceKey>;
+
+export const IntegrationFacetBindingSummary = z
+  .object({
+    id: z.string().uuid(),
+    facetKey: IntegrationFacetKey,
+    kind: IntegrationFacetKind.exclude(["tools"]),
+    bindingKey: IntegrationInstanceKey,
+    displayName: z.string().min(1).max(200),
+    connectionId: z.string().uuid().nullable(),
+    status: IntegrationFacetStatus,
+    config: IntegrationFacetJsonObject,
+    version: z.number().int().positive(),
+    hasCursor: z.boolean(),
+    lastSuccessAt: z.string().datetime({ offset: true }).nullable(),
+    lastErrorCode: z.string().min(1).max(120).nullable(),
+    createdAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true }),
+  })
+  .strict();
+export type IntegrationFacetBindingSummary = z.infer<typeof IntegrationFacetBindingSummary>;
+
+export const IntegrationInstanceFacetsResponse = z
+  .object({
+    capabilityId: z.string().min(1).max(512),
+    instanceKey: IntegrationInstanceKey,
+    providerDomain: z.string().min(1).max(253),
+    connectionId: z.string().uuid().nullable(),
+    facets: z
+      .array(
+        z
+          .object({
+            definition: IntegrationFacetDefinitionSummary,
+            binding: IntegrationFacetBindingSummary.nullable(),
+          })
+          .strict(),
+      )
+      .max(128),
+  })
+  .strict();
+export type IntegrationInstanceFacetsResponse = z.infer<typeof IntegrationInstanceFacetsResponse>;
+
+export const UpsertIntegrationFacetRequest = z
+  .object({
+    displayName: z.string().min(1).max(200),
+    config: IntegrationFacetJsonObject.default({}),
+    expectedVersion: z.number().int().positive().optional(),
+    idempotencyKey: z.string().uuid(),
+  })
+  .strict();
+export type UpsertIntegrationFacetRequest = z.infer<typeof UpsertIntegrationFacetRequest>;
+
+export const MutateIntegrationFacetRequest = z
+  .object({
+    expectedVersion: z.number().int().positive(),
+    idempotencyKey: z.string().uuid(),
+  })
+  .strict();
+export type MutateIntegrationFacetRequest = z.infer<typeof MutateIntegrationFacetRequest>;
+
+export const IntegrationFacetMutationResult = z
+  .object({
+    capabilityId: z.string().min(1).max(512),
+    instanceKey: IntegrationInstanceKey,
+    facetKey: IntegrationFacetKey,
+    status: z.enum(["configured", "paused", "active"]),
+    binding: IntegrationFacetBindingSummary,
+  })
+  .strict();
+export type IntegrationFacetMutationResult = z.infer<typeof IntegrationFacetMutationResult>;
+
+export const IntegrationFacetRemovalResult = z
+  .object({
+    capabilityId: z.string().min(1).max(512),
+    instanceKey: IntegrationInstanceKey,
+    facetKey: IntegrationFacetKey,
+    status: z.enum(["not_configured", "removed", "retained_by_other_owners"]),
+    binding: IntegrationFacetBindingSummary.nullable(),
+    remainingOwners: z.array(CapabilityComponentOwner),
+  })
+  .strict();
+export type IntegrationFacetRemovalResult = z.infer<typeof IntegrationFacetRemovalResult>;
+
+export const IntegrationSource = z.discriminatedUnion("kind", [
+  z
+    .object({
+      kind: z.literal("definition"),
+      definitionId: z.string().min(1).max(128),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("openapi"),
+      url: z.string().url().max(2048),
+      baseUrl: z.string().url().max(2048).optional(),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("graphql"),
+      endpoint: z.string().url().max(2048),
+      name: z.string().min(1).max(200).optional(),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("auto"),
+      url: z.string().url().max(2048),
+      baseUrl: z.string().url().max(2048).optional(),
+    })
+    .strict(),
+]);
+export type IntegrationSource = z.infer<typeof IntegrationSource>;
+
+export const PreviewApiIntegrationRequest = z
+  .object({
+    source: IntegrationSource,
+    connectionId: z.string().uuid().optional(),
+    ownership: ConnectionOwnership.optional(),
+  })
+  .strict();
+export type PreviewApiIntegrationRequest = z.infer<typeof PreviewApiIntegrationRequest>;
+
+export const ApiIntegrationOAuthStartRequest = z
+  .object({
+    definitionId: z.string().min(1).max(128),
+    ownership: ConnectionOwnership.optional(),
+    connectionId: z.string().uuid().optional(),
+    returnPath: z.string().min(1).max(2048).optional(),
+  })
+  .strict();
+export type ApiIntegrationOAuthStartRequest = z.infer<typeof ApiIntegrationOAuthStartRequest>;
+
+export const API_INTEGRATION_OAUTH_CREDENTIAL_ROLE = "api_integration_oauth" as const;
+
+export const ApiIntegrationOAuthConnectionMetadata = z
+  .object({
+    credentialRole: z.literal(API_INTEGRATION_OAUTH_CREDENTIAL_ROLE),
+    providerFamily: z.enum(["google", "microsoft"]),
+    providerPrincipalId: z.string().min(1).max(512),
+    providerEmail: z.string().min(1).max(512).nullable(),
+    providerDisplayName: z.string().min(1).max(512).nullable(),
+    authorizedDefinitionIds: z.array(z.string().min(1).max(128)).min(1).max(32),
+    verifiedAt: z.string().datetime({ offset: true }),
+  })
+  .passthrough();
+export type ApiIntegrationOAuthConnectionMetadata = z.infer<
+  typeof ApiIntegrationOAuthConnectionMetadata
+>;
+
+export const ApiIntegrationAuthPreview = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("none") }).strict(),
+  z
+    .object({
+      kind: z.literal("oauth2"),
+      providerDomain: z.string().min(1).max(253),
+      scopes: z.array(z.string().min(1).max(1024)).max(256),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("api_key"),
+      providerDomain: z.string().min(1).max(253),
+      carrier: z.enum(["header", "query", "cookie"]),
+      name: z.string().min(1).max(256),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("http"),
+      providerDomain: z.string().min(1).max(253),
+      scheme: z.string().min(1).max(64),
+    })
+    .strict(),
+]);
+export type ApiIntegrationAuthPreview = z.infer<typeof ApiIntegrationAuthPreview>;
+
+export const ApiIntegrationToolPreview = z
+  .object({
+    id: z.string().min(1).max(200),
+    operationKey: z.string().min(1).max(512),
+    name: z.string().min(1).max(200),
+    description: z.string().max(4000),
+    safety: z.enum(["read", "write", "destructive"]),
+    approvalMode: z.enum(["never", "ask"]),
+    deprecated: z.boolean(),
+  })
+  .strict();
+export type ApiIntegrationToolPreview = z.infer<typeof ApiIntegrationToolPreview>;
+
+export const ApiIntegrationPreview = z
+  .object({
+    source: IntegrationSource,
+    definitionId: z.string().min(1).max(200),
+    definitionProvenance: IntegrationDefinitionProvenance,
+    protocol: ApiIntegrationProtocol,
+    capabilityId: z.string().min(1).max(512),
+    pluginKey: z.string().min(1).max(200),
+    serverId: SessionMcpServerId,
+    name: z.string().min(1).max(200),
+    description: z.string().max(4000).nullable(),
+    provider: z.string().min(1).max(128).nullable(),
+    providerDomain: z.string().min(1).max(253),
+    baseUrl: z.string().url().max(2048),
+    sourceUrl: z.string().url().max(2048).nullable(),
+    revisionId: z.string().min(1).max(96),
+    contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+    auth: ApiIntegrationAuthPreview,
+    connectionId: z.string().uuid().nullable(),
+    connectionOwnership: ConnectionOwnership.nullable(),
+    tools: z.array(ApiIntegrationToolPreview).min(1).max(2000),
+    warnings: z.array(z.string().min(1).max(500)).max(32).default([]),
+  })
+  .strict();
+export type ApiIntegrationPreview = z.infer<typeof ApiIntegrationPreview>;
+
+export const InstallApiIntegrationRequest = z
+  .object({
+    source: IntegrationSource,
+    expectedRevisionId: z.string().min(1).max(96),
+    expectedContentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+    connectionId: z.string().uuid().optional(),
+    ownership: ConnectionOwnership.optional(),
+    instanceKey: IntegrationInstanceKey.optional(),
+    displayName: z.string().min(1).max(200).optional(),
+    expectedInstanceVersion: z.number().int().positive().optional(),
+    allowedTools: z.array(z.string().min(1).max(200)).max(2000).optional(),
+  })
+  .strict();
+export type InstallApiIntegrationRequest = z.infer<typeof InstallApiIntegrationRequest>;
+
+export const InstalledApiIntegration = z
+  .object({
+    capabilityId: z.string().min(1),
+    pluginId: z.string().uuid(),
+    pluginVersionId: z.string().uuid(),
+    integrationFacetId: z.string().uuid(),
+    apiFacetId: z.string().uuid(),
+    pluginInstallationId: z.string().uuid(),
+    integrationFacetInstallationId: z.string().uuid(),
+    apiFacetInstallationId: z.string().uuid(),
+    installationVersion: z.number().int().positive(),
+    instanceId: z.string().uuid(),
+    instanceKey: IntegrationInstanceKey,
+    displayName: z.string().min(1).max(200),
+    instanceVersion: z.number().int().positive(),
+    revisionId: z.string().min(1),
+    serverId: SessionMcpServerId,
+    status: z.literal("installed"),
+  })
+  .strict();
+export type InstalledApiIntegration = z.infer<typeof InstalledApiIntegration>;
+
+export const ApiIntegrationInstallationSummary = z
+  .object({
+    capabilityId: z.string().min(1),
+    pluginKey: z.string().min(1),
+    installationVersion: z.number().int().positive(),
+    instanceId: z.string().uuid(),
+    instanceKey: IntegrationInstanceKey,
+    displayName: z.string().min(1).max(200),
+    instanceVersion: z.number().int().positive(),
+    serverId: SessionMcpServerId,
+    name: z.string().min(1),
+    description: z.string().nullable(),
+    protocol: ApiIntegrationProtocol,
+    definitionId: z.string().min(1).max(200),
+    definitionProvenance: IntegrationDefinitionProvenance,
+    providerDomain: z.string().min(1),
+    baseUrl: z.string().url(),
+    sourceUrl: z.string().url().nullable(),
+    connected: z.boolean(),
+    requiresConnection: z.boolean(),
+    connectionId: z.string().uuid().nullable(),
+    ownership: z.enum(["workspace", "personal", "none"]),
+    allowedTools: z.array(z.string().min(1).max(200)).max(2000),
+    toolCount: z.number().int().nonnegative(),
+    approvalRequiredToolCount: z.number().int().nonnegative(),
+    revisionId: z.string().min(1),
+    contentSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  })
+  .strict();
+export type ApiIntegrationInstallationSummary = z.infer<typeof ApiIntegrationInstallationSummary>;
+
+export const ListApiIntegrationsResponse = z
+  .object({ integrations: z.array(ApiIntegrationInstallationSummary) })
+  .strict();
+export type ListApiIntegrationsResponse = z.infer<typeof ListApiIntegrationsResponse>;
+
+export const ApiIntegrationUninstallPreview = z
+  .object({
+    capabilityId: z.string().min(1),
+    instanceKey: IntegrationInstanceKey,
+    displayName: z.string().min(1).max(200).nullable(),
+    installed: z.boolean(),
+    installationVersion: z.number().int().positive().nullable(),
+    instanceVersion: z.number().int().positive().nullable(),
+    directOwner: CapabilityComponentOwner.nullable(),
+    remainingOwners: z.array(CapabilityComponentOwner),
+    removesRuntimeIntegration: z.boolean(),
+    removesDefinition: z.boolean(),
+  })
+  .strict();
+export type ApiIntegrationUninstallPreview = z.infer<typeof ApiIntegrationUninstallPreview>;
+
+export const UninstallApiIntegrationRequest = z
+  .object({
+    expectedInstallationVersion: z.number().int().positive(),
+    expectedInstanceVersion: z.number().int().positive(),
+  })
+  .strict();
+export type UninstallApiIntegrationRequest = z.infer<typeof UninstallApiIntegrationRequest>;
+
+export const UninstallApiIntegrationResult = z
+  .object({
+    capabilityId: z.string().min(1),
+    instanceKey: IntegrationInstanceKey,
+    status: z.enum(["not_installed", "uninstalled", "retained_by_other_owners"]),
+    remainingOwners: z.array(CapabilityComponentOwner),
+    definitionStatus: z.enum(["retained", "disabled"]),
+  })
+  .strict();
+export type UninstallApiIntegrationResult = z.infer<typeof UninstallApiIntegrationResult>;
+
+const PluginComponentKey = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/);
+
+export const PluginManifest = z
+  .object({
+    schemaVersion: z.literal(1),
+    pluginKey: z
+      .string()
+      .min(1)
+      .max(200)
+      .regex(/^[a-z0-9](?:[a-z0-9._/-]*[a-z0-9])?$/),
+    version: z.string().min(1).max(128),
+    name: z.string().min(1).max(200),
+    description: z.string().max(4000).default(""),
+    category: z.string().min(1).max(100).default("plugins"),
+    tags: z.array(z.string().min(1).max(100)).max(64).default([]),
+    components: z
+      .array(
+        z.discriminatedUnion("kind", [
+          z
+            .object({
+              key: PluginComponentKey,
+              kind: z.literal("skill"),
+              url: z.string().url(),
+            })
+            .strict(),
+          z
+            .object({
+              key: PluginComponentKey,
+              kind: z.literal("integration"),
+              source: IntegrationSource,
+            })
+            .strict(),
+          z
+            .object({
+              key: PluginComponentKey,
+              kind: z.literal("mcp"),
+              serverId: SessionMcpServerId,
+            })
+            .strict(),
+        ]),
+      )
+      .min(1)
+      .max(64),
+  })
+  .strict()
+  .superRefine((manifest, context) => {
+    const seen = new Set<string>();
+    for (const [index, component] of manifest.components.entries()) {
+      if (seen.has(component.key)) {
+        context.addIssue({
+          code: "custom",
+          message: "Plugin component keys must be unique",
+          path: ["components", index, "key"],
+        });
+      }
+      seen.add(component.key);
+    }
+  });
+export type PluginManifest = z.infer<typeof PluginManifest>;
+
+export const PluginComponentBinding = z
+  .object({
+    connectionId: z.string().uuid().optional(),
+    instanceKey: IntegrationInstanceKey.optional(),
+    displayName: z.string().min(1).max(200).optional(),
+  })
+  .strict();
+export type PluginComponentBinding = z.infer<typeof PluginComponentBinding>;
 
-export const CapabilityCatalogAuthKind = z.enum(["oauth2", "api_key", "none", "unknown"]);
-export type CapabilityCatalogAuthKind = z.infer<typeof CapabilityCatalogAuthKind>;
+export const PreviewPluginRequest = z
+  .object({
+    url: z.string().url().max(2048),
+    bindings: z.record(PluginComponentKey, PluginComponentBinding).default({}),
+  })
+  .strict();
+export type PreviewPluginRequest = z.infer<typeof PreviewPluginRequest>;
 
-export const CapabilityCatalogTier = z.enum(["verified", "community"]);
-export type CapabilityCatalogTier = z.infer<typeof CapabilityCatalogTier>;
+export const PluginComponentPreview = z
+  .object({
+    key: PluginComponentKey,
+    kind: z.enum(["skill", "integration", "mcp"]),
+    name: z.string().min(1).max(200),
+    capabilityId: z.string().min(1).max(512),
+    digest: z.string().regex(/^[0-9a-f]{64}$/),
+    connectionRequired: z.boolean(),
+    connectionId: z.string().uuid().nullable(),
+    instanceKey: IntegrationInstanceKey.nullable(),
+    displayName: z.string().min(1).max(200).nullable(),
+    facts: z.record(z.string(), z.unknown()),
+  })
+  .strict();
+export type PluginComponentPreview = z.infer<typeof PluginComponentPreview>;
 
-export const CapabilityRuntime = z.object({
-  available: z.boolean().default(false),
-  mcpServerId: z.string().min(1).optional(),
-  transport: z.string().min(1).optional(),
-  notes: z.string().nullable().default(null),
-  // Registry exposure provenance is server-derived and contains no endpoint or
-  // credential material.
-  catalogTrust: z
-    .object({
-      state: z.enum(["trusted", "legacy_active", "unverified"]),
-      reason: z.enum([
-        "trusted_source",
-        "verified_probe",
-        "active_installation_compatibility",
-        "missing_verification",
-      ]),
-    })
-    .optional(),
-});
-export type CapabilityRuntime = z.infer<typeof CapabilityRuntime>;
+export const PluginUpdateDiff = z
+  .object({
+    fromVersion: z.string().nullable(),
+    toVersion: z.string().min(1),
+    added: z.array(PluginComponentKey),
+    removed: z.array(PluginComponentKey),
+    changed: z.array(PluginComponentKey),
+    unchanged: z.array(PluginComponentKey),
+  })
+  .strict();
+export type PluginUpdateDiff = z.infer<typeof PluginUpdateDiff>;
 
-export const CapabilityCatalogItem = z.object({
-  id: z.string().min(1),
-  accountId: z.string().uuid().optional(),
-  workspaceId: z.string().uuid().optional(),
-  kind: CapabilityKind,
-  source: CapabilitySource,
-  name: z.string().min(1),
-  description: z.string().nullable().default(null),
-  category: z.string().min(1).default("custom"),
-  tags: z.array(z.string().min(1)).default([]),
-  homepageUrl: z.string().url().nullable().default(null),
-  endpointUrl: z.string().url().nullable().default(null),
-  installUrl: z.string().url().nullable().default(null),
-  authModel: z.string().min(1).nullable().default(null),
-  providerDomain: z.string().min(1).nullable().default(null),
-  surfaceType: z.string().min(1).nullable().default(null),
-  transport: z.string().min(1).nullable().default(null),
-  mcpUrl: z.string().url().nullable().default(null),
-  authKind: CapabilityCatalogAuthKind.nullable().default(null),
-  credentialFacts: z.array(z.record(z.string(), z.unknown())).default([]),
-  tier: CapabilityCatalogTier.nullable().default(null),
-  provenance: z.string().min(1).nullable().default(null),
-  logoAssetPath: z.string().min(1).nullable().default(null),
-  importBatchId: z.string().uuid().nullable().default(null),
-  stale: z.boolean().default(false),
-  staleAt: z.string().nullable().default(null),
-  tools: z.array(ToolRef).default([]),
-  runtime: CapabilityRuntime.default({ available: false, notes: null }),
-  enabled: z.boolean().default(false),
-  enabledReason: z.string().nullable().default(null),
-  // The non-secret connection binding stored with an enabled installation.
-  // Workspace refs retain an exact row id. Subject refs deliberately omit it:
-  // each caller resolves their own visible row by provider/kind at runtime.
-  connectionRef: z
-    .object({
-      connectionId: z.string().min(1).optional(),
-      providerDomain: z.string().min(1),
-      kind: z.string().min(1),
-      subjectScope: z.enum(["workspace", "subject"]).optional(),
-    })
-    .nullable()
-    .default(null),
-  metadata: z.record(z.string(), z.unknown()).default({}),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-});
-export type CapabilityCatalogItem = z.infer<typeof CapabilityCatalogItem>;
+export const PluginPreview = z
+  .object({
+    sourceUrl: z.string().url(),
+    manifest: PluginManifest,
+    manifestDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    installed: z.boolean(),
+    installationVersion: z.number().int().positive().nullable(),
+    components: z.array(PluginComponentPreview).min(1).max(64),
+    diff: PluginUpdateDiff,
+  })
+  .strict();
+export type PluginPreview = z.infer<typeof PluginPreview>;
 
-/**
- * Shared trust gate for catalog visibility and runtime selection. Registry rows
- * remain durable for provenance and audit, but only a reviewed real-MCP probe
- * with known authentication is exposable. API-key rows additionally need a
- * machine-actionable header contract; prose credential instructions are not a
- * runtime contract and must fail closed.
- */
-export function capabilityCatalogItemIsTrustedForExposure(
-  item: Pick<CapabilityCatalogItem, "source" | "stale" | "authKind" | "metadata">,
-): boolean {
-  if (item.stale) return false;
-  if (item.source !== "registry") return true;
-  const probe = item.metadata.mcpProbe;
-  if (!probe || typeof probe !== "object" || Array.isArray(probe)) return false;
-  if ((probe as Record<string, unknown>).status !== "real") return false;
-  if (item.authKind === null || item.authKind === "unknown") return false;
-  if (item.authKind !== "api_key") return true;
-  const contract = item.metadata.authContract;
-  if (!contract || typeof contract !== "object" || Array.isArray(contract)) return false;
-  const record = contract as Record<string, unknown>;
-  return (
-    typeof record.headerName === "string" &&
-    /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/.test(record.headerName) &&
-    typeof record.scheme === "string" &&
-    record.scheme.trim().length > 0
-  );
-}
+export const InstallPluginRequest = z
+  .object({
+    url: z.string().url().max(2048),
+    expectedManifestDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    expectedComponents: z
+      .array(
+        z
+          .object({
+            key: PluginComponentKey,
+            digest: z.string().regex(/^[0-9a-f]{64}$/),
+          })
+          .strict(),
+      )
+      .min(1)
+      .max(64),
+    bindings: z.record(PluginComponentKey, PluginComponentBinding).default({}),
+    idempotencyKey: z.string().uuid(),
+    expectedInstallationVersion: z.number().int().positive().optional(),
+  })
+  .strict();
+export type InstallPluginRequest = z.infer<typeof InstallPluginRequest>;
 
-export const CapabilityInstallation = z.object({
-  id: z.string().uuid(),
-  accountId: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  capabilityId: z.string().min(1),
-  kind: CapabilityKind,
-  status: CapabilityInstallationStatus,
-  config: z.record(z.string(), z.unknown()),
-  metadata: z.record(z.string(), z.unknown()),
-  enabledAt: z.string(),
-  updatedAt: z.string(),
-});
-export type CapabilityInstallation = z.infer<typeof CapabilityInstallation>;
+export const InstalledPlugin = z
+  .object({
+    pluginKey: z.string().min(1),
+    version: z.string().min(1),
+    pluginId: z.string().uuid(),
+    pluginVersionId: z.string().uuid(),
+    pluginInstallationId: z.string().uuid(),
+    installationVersion: z.number().int().positive(),
+    componentCount: z.number().int().positive(),
+    status: z.literal("installed"),
+  })
+  .strict();
+export type InstalledPlugin = z.infer<typeof InstalledPlugin>;
 
-export const CreateCapabilityCatalogItemRequest = z.object({
-  id: z.string().min(1).optional(),
-  kind: CapabilityKind.exclude(["pack"]),
-  source: CapabilitySource.default("manual"),
-  name: z.string().min(1),
-  description: z.string().min(1).optional(),
-  category: z.string().min(1).default("custom"),
-  tags: z.array(z.string().min(1)).default([]),
-  homepageUrl: z.string().url().optional(),
-  endpointUrl: z.string().url().optional(),
-  installUrl: z.string().url().optional(),
-  authModel: z.string().min(1).optional(),
-  metadata: z.record(z.string(), z.unknown()).default({}),
-});
-export type CreateCapabilityCatalogItemRequest = z.infer<typeof CreateCapabilityCatalogItemRequest>;
+export const PluginInstallationSummary = z
+  .object({
+    pluginKey: z.string().min(1).max(200),
+    version: z.string().min(1).max(128),
+    name: z.string().min(1).max(200),
+    description: z.string().max(4000),
+    category: z.string().min(1).max(100),
+    tags: z.array(z.string().min(1).max(100)).max(64),
+    sourceUrl: z.string().url().max(2048).nullable(),
+    manifestDigest: z.string().regex(/^[0-9a-f]{64}$/),
+    installationVersion: z.number().int().positive(),
+    componentCount: z.number().int().nonnegative().max(64),
+    status: z.enum(["active", "needs_attention"]),
+    installedAt: z.string().datetime({ offset: true }),
+    updatedAt: z.string().datetime({ offset: true }),
+  })
+  .strict();
+export type PluginInstallationSummary = z.infer<typeof PluginInstallationSummary>;
 
-export const EnableCapabilityRequest = withVariableSetIdAlias({
-  config: z.record(z.string(), z.unknown()).default({}),
-  metadata: z.record(z.string(), z.unknown()).default({}),
-  connectionRef: McpServerConnectionRef.optional(),
-  /**
-   * Credential headers for remote MCP capabilities (for example an
-   * Authorization bearer token). Values are encrypted at rest with the
-   * workspace-variable-sets key, injected only into the runtime MCP client,
-   * and never returned by the API — responses expose header names only.
-   */
-  headers: z.record(z.string(), z.string()).default({}),
-  /**
-   * Initial variableSet attachment for kind=pack capabilities. Mirrors the
-   * dedicated POST /packs/:id/enable body: required to enable an
-   * variableSet.required pack through the unified capability-enable path,
-   * optional otherwise. Ignored by non-pack capabilities.
-   */
-  variableSetId: z.string().uuid().optional(),
-  environmentId: z.string().uuid().optional(),
-});
-export type EnableCapabilityRequest = z.infer<typeof EnableCapabilityRequest>;
+export const ListInstalledPluginsResponse = z
+  .object({ plugins: z.array(PluginInstallationSummary).max(1000) })
+  .strict();
+export type ListInstalledPluginsResponse = z.infer<typeof ListInstalledPluginsResponse>;
 
-export const CapabilityCatalogResponse = z.object({
-  items: z.array(CapabilityCatalogItem),
-  installations: z.array(CapabilityInstallation),
-});
-export type CapabilityCatalogResponse = z.infer<typeof CapabilityCatalogResponse>;
+export const PluginUninstallPreview = z
+  .object({
+    pluginKey: z.string().min(1),
+    installed: z.boolean(),
+    version: z.string().nullable(),
+    installationVersion: z.number().int().positive().nullable(),
+    components: z.array(
+      z.object({
+        capabilityId: z.string().min(1),
+        kind: z.enum(["skill", "integration", "mcp"]),
+        retainedByOtherOwners: z.boolean(),
+      }),
+    ),
+  })
+  .strict();
+export type PluginUninstallPreview = z.infer<typeof PluginUninstallPreview>;
 
-export const DiscoverMcpCapabilitiesResponse = z.object({
-  items: z.array(CapabilityCatalogItem),
-  source: z.literal("official_mcp_registry"),
-  sourceUrl: z.string().url(),
-});
-export type DiscoverMcpCapabilitiesResponse = z.infer<typeof DiscoverMcpCapabilitiesResponse>;
+export const UninstallPluginRequest = z
+  .object({
+    expectedInstallationVersion: z.number().int().positive(),
+    idempotencyKey: z.string().uuid(),
+  })
+  .strict();
+export type UninstallPluginRequest = z.infer<typeof UninstallPluginRequest>;
+
+export const UninstallPluginResult = z
+  .object({
+    pluginKey: z.string().min(1),
+    status: z.enum(["not_installed", "uninstalled"]),
+    retainedComponents: z.array(z.string().min(1)),
+  })
+  .strict();
+export type UninstallPluginResult = z.infer<typeof UninstallPluginResult>;
 
 export const Session = z.object({
   id: z.string().uuid(),
@@ -6399,6 +8840,8 @@ export const Session = z.object({
   // the workspace runtime registry.
   effectiveToolPolicy: SessionEffectiveToolPolicy.optional(),
   metadata: z.record(z.string(), z.unknown()),
+  /** Additive public tenancy projection; omitted by legacy/internal readers. */
+  tenancy: SessionTenancyPublicProjection.optional(),
   /** Frozen creator fact used only for creation attribution/idempotent repair. */
   createdBy: TurnInitiator,
   createdByContext: TurnInitiatorContext,
@@ -6430,6 +8873,9 @@ export const Session = z.object({
   // Both null ⇒ a rig-less session (byte-for-byte today's behavior).
   rigId: z.string().uuid().nullable().default(null),
   rigVersionId: z.string().uuid().nullable().default(null),
+  // Workspace channel this session is filed under (rail organization only;
+  // a session tree is grouped by its ROOT session's channel). Null = unfiled.
+  channelId: z.string().uuid().nullable().default(null),
   // Non-default first-party MCP token permissions (manager-style sessions);
   // null means the fixed worker default set.
   firstPartyMcpPermissions: z.array(Permission).nullable(),
@@ -6535,6 +8981,57 @@ export const SessionListResponse = z.object({
 });
 export type SessionListResponse = z.infer<typeof SessionListResponse>;
 
+/** Compact, bounded session projection for workspace agent-topology browsers. */
+export const AgentTopologySession = z.object({
+  id: z.string().uuid(),
+  title: z.string().nullable(),
+  titleTruncated: z.boolean(),
+  parentSessionId: z.string().uuid().nullable(),
+  rootSessionId: z.string().uuid(),
+  nestedAgentDepth: NestedAgentDepthValue,
+  ancestorPath: z.array(
+    z.object({
+      id: z.string().uuid(),
+      title: z.string().nullable(),
+      titleTruncated: z.boolean(),
+    }),
+  ),
+  status: SessionStatus,
+  pause: z.object({
+    state: z.enum(["active", "paused"]),
+    additionalBlockerCount: z.number().int().nonnegative(),
+    source: z
+      .object({
+        kind: z.enum(["session", "workspace"]),
+        sessionId: z.string().uuid().optional(),
+        displayName: z.string(),
+        displayNameTruncated: z.boolean(),
+      })
+      .nullable(),
+  }),
+  children: z.object({
+    directChildren: z.number().int().nonnegative(),
+    totalDescendants: z.number().int().nonnegative(),
+    runningDescendants: z.number().int().nonnegative(),
+    queuedDescendants: z.number().int().nonnegative(),
+    attentionDescendants: z.number().int().nonnegative(),
+    pausedDescendants: z.number().int().nonnegative(),
+    failedDescendants: z.number().int().nonnegative(),
+    truncated: z.boolean(),
+  }),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+export type AgentTopologySession = z.infer<typeof AgentTopologySession>;
+
+export const AgentTopologyPageResponse = z.object({
+  sessions: z.array(AgentTopologySession),
+  total: z.number().int().nonnegative(),
+  hasMore: z.boolean(),
+  nextCursor: z.string().nullable(),
+});
+export type AgentTopologyPageResponse = z.infer<typeof AgentTopologyPageResponse>;
+
 // Recursive: the TS type is declared first so the schema annotation can carry
 // the FULL recursive shape (a shallow annotation loses type information for
 // contracts consumers after one level of nesting).
@@ -6558,6 +9055,7 @@ export type SessionLineageResponse = z.infer<typeof SessionLineageResponse>;
 
 export const SessionEventType = z.enum([
   "session.created",
+  "session.visibility.changed",
   // Defensive read/transport projection for a malformed or historically
   // oversized retained event envelope. The original row stays durable; this
   // explicit synthetic type prevents unbounded free-form envelope fields from
@@ -6608,6 +9106,9 @@ export const SessionEventType = z.enum([
   "artifact.created",
   "goal.set",
   "goal.updated",
+  "goal.progress",
+  "goal.rewrite.proposed",
+  "goal.rewrite.rejected",
   "goal.completed",
   "goal.paused",
   "goal.resumed",
@@ -6811,6 +9312,9 @@ export const SESSION_EVENT_SEMANTIC_CLASS_TYPES = {
     "user.humanInputResponse",
     "goal.set",
     "goal.updated",
+    "goal.progress",
+    "goal.rewrite.proposed",
+    "goal.rewrite.rejected",
     "goal.completed",
     "goal.paused",
     "goal.resumed",
@@ -6953,6 +9457,21 @@ export const ToolAuthNeededPayload = z.object({
   selectedResources: McpConnectionResourceScopes.optional(),
   authorizationUrl: z.string().url().optional(),
   subjectId: z.string().min(1).nullable().optional(),
+  // A catalog recommendation is still a tool-level authorization condition:
+  // the agent may describe and request it, but only the authenticated host UI
+  // can start setup. Keeping this nested and optional preserves the established
+  // auth-needed event for ordinary failed MCP calls.
+  capability: z
+    .object({
+      id: z.string().min(1).max(512),
+      name: z.string().min(1).max(256),
+      kind: CapabilityKind,
+      source: CapabilitySource,
+      action: z.enum(["connect", "add_credentials", "enable"]),
+      rationale: z.string().min(1).max(2000),
+      requiredVariables: z.array(VariableSetVariableName).max(64).default([]),
+    })
+    .optional(),
 });
 export type ToolAuthNeededPayload = z.infer<typeof ToolAuthNeededPayload>;
 
@@ -7307,6 +9826,9 @@ export type GitStatusRequest = z.infer<typeof GitStatusRequest>;
 export const GitStatusResponse = z.object({
   isRepo: z.boolean(),
   head: z.string().nullable(), // branch name
+  // Exact commit object identity. null for unborn/non-repositories; optional
+  // only so older adapters and serialized captures remain readable.
+  headOid: z.string().nullable().optional(),
   detached: z.boolean().default(false),
   upstream: z.string().nullable(),
   ahead: z.number().int().nonnegative().default(0),
@@ -7432,6 +9954,9 @@ export type WorkspaceCaptureFile = z.infer<typeof WorkspaceCaptureFile>;
 export const WorkspaceCaptureRepo = z.object({
   root: z.string(),
   head: z.string().nullable(),
+  // Exact HEAD commit object identity. null for unborn repositories; optional
+  // for workspace captures written before commit identity was retained.
+  headOid: z.string().nullable().optional(),
   detached: z.boolean().default(false),
   upstream: z.string().nullable(),
   ahead: z.number().int().nonnegative().default(0),
@@ -8763,6 +11288,10 @@ export const CreateSessionRequest = withVariableSetIdAlias({
   // null ⇒ explicitly create a rig-less session; UUID ⇒ bind that exact rig.
   // An id that does not name a rig in the workspace is a 422.
   rigId: z.string().uuid().nullable().optional(),
+  // The workspace channel to file this session under (rail organization only).
+  // Omitted/null ⇒ unfiled (inbox). An id that does not name a channel in the
+  // workspace is a 422.
+  channelId: z.string().uuid().nullable().optional(),
   goal: GoalSpec.optional(),
   clientEventId: SessionOperationKey.optional(),
   // Workspace-scoped CREATE idempotency key: collapses concurrent/retried
@@ -9003,27 +11532,45 @@ export function approvalIdentifier(value: unknown): string | null {
   return String(candidate);
 }
 
+function requireMessageTextOrAnnotations(
+  value: { text: string; annotations: readonly unknown[] },
+  ctx: z.RefinementCtx,
+): void {
+  if (value.text.length === 0 && value.annotations.length === 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["text"],
+      message: "message text or annotations are required",
+    });
+  }
+}
+
+export const SessionUserMessagePayload = z
+  .object({
+    text: z.string().default(""),
+    annotations: SubmittedTimelineAnnotations.default([]),
+    // System-level host context for this exact turn only. Persisted on the
+    // turn for retry/recovery, never copied into the visible user message.
+    turnInstructions: z.string().trim().min(1).max(32768).optional(),
+    resources: z.array(ResourceRef).default([]),
+    model: z.string().min(1).optional(),
+    reasoningEffort: ReasoningEffort.optional(),
+    latencyMode: LatencyMode.optional(),
+    controlEtag: z.string().min(1).optional(),
+    expectedDraftRevision: z.number().int().nonnegative().optional(),
+    // Header-value rotation only. URL/name/tool settings are immutable after
+    // session create; persisted events expose metadata, never header values.
+    mcpCredentialUpdates: z.array(SessionMcpCredentialUpdateInput).optional(),
+  })
+  .strict()
+  .superRefine(requireMessageTextOrAnnotations);
+export type SessionUserMessagePayload = z.infer<typeof SessionUserMessagePayload>;
+
 export const ClientSessionEvent = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("user.message"),
     clientEventId: SessionOperationKey.optional(),
-    payload: z
-      .object({
-        text: z.string().min(1),
-        // System-level host context for this exact turn only. Persisted on the
-        // turn for retry/recovery, never copied into the visible user message.
-        turnInstructions: z.string().trim().min(1).max(32768).optional(),
-        resources: z.array(ResourceRef).default([]),
-        model: z.string().min(1).optional(),
-        reasoningEffort: ReasoningEffort.optional(),
-        latencyMode: LatencyMode.optional(),
-        controlEtag: z.string().min(1).optional(),
-        expectedDraftRevision: z.number().int().nonnegative().optional(),
-        // Header-value rotation only. URL/name/tool settings are immutable after
-        // session create; persisted events expose metadata, never header values.
-        mcpCredentialUpdates: z.array(SessionMcpCredentialUpdateInput).optional(),
-      })
-      .strict(),
+    payload: SessionUserMessagePayload,
   }),
   z.object({
     type: z.literal("user.approvalDecision"),
@@ -9047,7 +11594,8 @@ export type ClientSessionEvent = z.infer<typeof ClientSessionEvent>;
 
 export const SteerSessionMessageRequest = z
   .object({
-    text: z.string().min(1),
+    text: z.string().default(""),
+    annotations: SubmittedTimelineAnnotations.default([]),
     // Same per-turn system-level context as a queued user.message.
     turnInstructions: z.string().trim().min(1).max(32768).optional(),
     resources: z.array(ResourceRef).default([]),
@@ -9059,7 +11607,8 @@ export const SteerSessionMessageRequest = z
     expectedDraftRevision: z.number().int().nonnegative().optional(),
     mcpCredentialUpdates: z.array(SessionMcpCredentialUpdateInput).optional(),
   })
-  .strict();
+  .strict()
+  .superRefine(requireMessageTextOrAnnotations);
 export type SteerSessionMessageRequest = z.infer<typeof SteerSessionMessageRequest>;
 
 export const SteerSessionMessageResponse = z.object({
@@ -9202,7 +11751,7 @@ export const SessionCapabilities = z.object({
     reason: CapabilityUnavailableReason.nullable(),
   }),
   Terminal: z.object({
-    transport: z.enum(["sse-events", "pty-ws"]).nullable(),
+    transport: z.enum(["sse-events", "pty-ws", "relay-pty"]).nullable(),
     ptyCapable: z.boolean(),
     shell: z.string(),
     // The direct-to-provider ttyd PTY-over-websocket URL (pty-ws) resolved on the
@@ -9278,19 +11827,21 @@ export type SessionCapabilities = z.infer<typeof SessionCapabilities>;
 // POST .../viewers — acquire a viewer holder. An omitted viewerId mints a fresh
 // one (returned in the response, to carry through heartbeats + detach).
 //
-// `desktop` declares intent to attach the UN-REDACTED pixel plane (noVNC). ONLY
-// that plane carries the consent gate (the un-redacted/shared acknowledgment). A
-// terminal-only warm attach (`desktop:false`, the default) needs NO consent — a
-// shell is interactive by nature and the gate is the scoped tunnel URL + stream
-// token — so it warms the box and mints the pty-ws terminal cell WITHOUT a 409.
-// Omitted defaults to `false` so a terminal-only client never trips the gate.
-export const AttachViewerRequest = z.object({
+// Each optional plane flag declares exactly which live capability is being
+// acquired. The holder itself is shared liveness; credentials are minted only
+// for explicitly requested planes. `desktop` alone carries the un-redacted pixel
+// consent gate, `terminal` carries terminal:attach, and `files` carries
+// files:write. For compatibility, an entirely omitted plane set retains the old
+// terminal-only meaning; new clients always send all three flags explicitly.
+export const AttachViewerRequest = /* @__PURE__ */ z.object({
   viewerId: z.string().uuid().optional(),
   desktop: z.boolean().optional(),
+  terminal: z.boolean().optional(),
+  files: z.boolean().optional(),
 });
 export type AttachViewerRequest = z.infer<typeof AttachViewerRequest>;
 
-export const ViewerHolder = z.object({
+export const ViewerHolder = /* @__PURE__ */ z.object({
   viewerId: z.string().uuid(),
   sandboxGroupId: z.string().uuid(),
   liveness: z.enum(["cold", "warming", "warm", "draining"]),
@@ -9306,6 +11857,21 @@ export const ViewerHolder = z.object({
 });
 export type ViewerHolder = z.infer<typeof ViewerHolder>;
 
+/** Exact POST /viewers response. Keep the credential cells in the contracts
+ * package so API and zero-runtime SDK mirrors cannot silently drift. */
+export const AttachViewerResponse = /* @__PURE__ */ ViewerHolder.extend({
+  streamToken: z.string().nullable(),
+  streamExpiresAt: z.string().nullable(),
+  resolution: z.tuple([z.number().int().positive(), z.number().int().positive()]).nullable(),
+  transport: z.enum(["vnc-ws", "relay-frames"]).nullable(),
+  client: z.enum(["novnc", "frames"]).nullable(),
+  terminalUrl: z.string().nullable(),
+  terminalToken: z.string().nullable(),
+  terminalExpiresAt: z.string().nullable(),
+  terminalTransport: z.enum(["pty-ws", "relay-pty"]).nullable(),
+});
+export type AttachViewerResponse = z.infer<typeof AttachViewerResponse>;
+
 // POST .../stream-capabilities/acknowledge — record the calling principal's
 // acknowledgment of the un-redacted pixel plane. Reuses the acknowledgment
 // machinery — no new endpoint
@@ -9315,7 +11881,7 @@ export type ViewerHolder = z.infer<typeof ViewerHolder>;
 // session): the un-redacted desktop path returns 409 shared_acknowledgment_required
 // until a shared box is acknowledged WITH the shared-exposure consent. For a
 // solo box `acknowledgeShared` is irrelevant (the un-redacted ack alone gates).
-export const AcknowledgeStreamRequest = z.object({
+export const AcknowledgeStreamRequest = /* @__PURE__ */ z.object({
   // The principal accepts that the desktop pixel plane is un-redacted (can show
   // cloud creds the agent cat's into a terminal). Always true to record consent;
   // present for self-documentation + a future explicit withdraw.
@@ -9326,7 +11892,7 @@ export const AcknowledgeStreamRequest = z.object({
 });
 export type AcknowledgeStreamRequest = z.infer<typeof AcknowledgeStreamRequest>;
 
-export const AcknowledgeStreamResponse = z.object({
+export const AcknowledgeStreamResponse = /* @__PURE__ */ z.object({
   acknowledged: z.boolean(),
   acknowledgedShared: z.boolean(),
 });
@@ -9334,12 +11900,12 @@ export type AcknowledgeStreamResponse = z.infer<typeof AcknowledgeStreamResponse
 
 // POST .../viewers/:viewerId/heartbeat — refresh the holder TTL. Epoch-fenced:
 // a stale-epoch beat (a box re-established under a newer epoch) is rejected.
-export const ViewerHeartbeatRequest = z.object({
+export const ViewerHeartbeatRequest = /* @__PURE__ */ z.object({
   leaseEpoch: z.number().int().nonnegative(),
 });
 export type ViewerHeartbeatRequest = z.infer<typeof ViewerHeartbeatRequest>;
 
-export const ViewerHeartbeatResponse = z.object({
+export const ViewerHeartbeatResponse = /* @__PURE__ */ z.object({
   // false ⇒ the holder was reaped or the epoch is stale; the client re-attaches.
   alive: z.boolean(),
 });
@@ -9508,10 +12074,23 @@ export const RevokeEnrollmentResponse = z.object({
   lastSeenAt: z.string().datetime({ offset: true }).nullable(),
   revokedAt: z.string().datetime({ offset: true }).nullable(),
   code: z
-    .enum(["active_route", "active_commands", "active_lease", "recovery_pending", "not_selfhosted"])
+    .enum([
+      "active_route",
+      "active_commands",
+      "machine_home",
+      "active_lease",
+      "recovery_pending",
+      "not_selfhosted",
+    ])
     .nullable(),
   message: z.string(),
   action: z.string(),
+  dependentSessions: z.array(
+    z.object({
+      id: z.string().uuid(),
+      title: z.string().nullable(),
+    }),
+  ),
 });
 export type RevokeEnrollmentResponse = z.infer<typeof RevokeEnrollmentResponse>;
 
@@ -9829,7 +12408,7 @@ export const ModelCredentialSourceV1 =
       z
         .object({
           kind: z.literal("connected_subscription"),
-          provider: z.literal("codex"),
+          provider: z.enum(["codex", "xai"]),
         })
         .strict(),
       z
@@ -10040,7 +12619,7 @@ export const ClientModel = /* @__PURE__ */ defineModelContractSchema(() =>
     provider: z.string(), // provider id
     providerLabel: z.string(),
     api: z.enum(["responses", "chat"]),
-    source: z.enum(["opengeni", "codex", "workspace_gateway"]).optional(),
+    source: z.enum(["opengeni", "codex", "supergrok", "workspace_gateway"]).optional(),
     contextWindowTokens: z.number().int().positive().optional(),
     // Additive normalized definition metadata. Optional so older server payloads
     // remain parseable; current servers project the complete V1 set.
@@ -10173,7 +12752,7 @@ export type WorkspaceModelCatalogResponse = z.infer<typeof WorkspaceModelCatalog
  * that rollout boundary. Mutating clients send this value in
  * `x-opengeni-api-contract`; the API rejects any other value before routing.
  */
-export const OPENGENI_API_CONTRACT_REVISION = "2026-07-workspace-artifacts-v1" as const;
+export const OPENGENI_API_CONTRACT_REVISION = "2026-08-social-provider-tools-v1" as const;
 export const OPENGENI_API_CONTRACT_HEADER = "x-opengeni-api-contract" as const;
 /** Bounded request/response identifier shared by browser, ingress, and API diagnostics. */
 export const OPENGENI_CORRELATION_HEADER = "x-opengeni-correlation-id" as const;
@@ -10201,6 +12780,15 @@ export const ClientConfig = /* @__PURE__ */ defineModelContractSchema(() =>
         }),
       )
       .default([]),
+    firstPartyMcpTools: z
+      .object({
+        default: z.array(FirstPartyMcpToolName),
+        allowed: z.array(FirstPartyMcpToolName),
+      })
+      .default({
+        default: [...DEFAULT_FIRST_PARTY_MCP_TOOLS],
+        allowed: [...FIRST_PARTY_MCP_TOOL_NAMES],
+      }),
     fileUploads: z.object({
       enabled: z.boolean(),
       maxSizeBytes: z.number().int().positive(),
@@ -10335,7 +12923,13 @@ export function evaluateWorkspaceModelPolicy(
 }
 
 export * from "./codex-fleet-policy";
+export * from "./xai-provider-account-authority";
 export * from "./workspace-instruction-policies";
+export * from "./company-profile";
+export * from "./workspace-learning-policy";
 export * from "./workspace-state";
 export * from "./preference-registry";
 export * from "./scoped-knowledge";
+export * from "./knowledge";
+export * from "./task-notes";
+export * from "./canonical-human-identities";