@opengeni/contracts 0.35.0 → 0.37.0

package/dist/workspace-instruction-policies.d.ts

@@ -4,6 +4,7 @@ export declare const WORKSPACE_INSTRUCTION_POLICY_PROMPT_MAX_UTF8_BYTES = 131072
 export declare const WORKSPACE_INSTRUCTION_POLICY_REASON_MAX_CHARS = 4096;
 export declare const WORKSPACE_INSTRUCTION_POLICY_ROLE_KEY_MAX_CHARS = 64;
 export declare const WORKSPACE_INSTRUCTION_POLICY_SOURCE_ID_MAX_CHARS = 512;
+export declare const WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_SOURCE_VERSION_MAX_CHARS = 256;
 export declare const WorkspaceInstructionPolicyKind: z.ZodEnum<{
     charter: "charter";
     policy: "policy";
@@ -598,3 +599,215 @@ export declare const WorkspaceInstructionPolicyOperationReuseResponse: z.ZodObje
     message: z.ZodString;
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyOperationReuseResponse = z.infer<typeof WorkspaceInstructionPolicyOperationReuseResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalSource: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    confidenceBps: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalSource = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalSource>;
+export declare const CreateWorkspaceInstructionPolicyOnboardingProposalRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodDefault<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>;
+    content: z.ZodString;
+    sourceId: z.ZodString;
+    sourceVersion: z.ZodString;
+    confidenceBps: z.ZodNumber;
+    expectedCurrentRevisionId: z.ZodNullable<z.ZodString>;
+    expectedActivationVersion: z.ZodNumber;
+}, z.core.$strip>;
+export type CreateWorkspaceInstructionPolicyOnboardingProposalRequest = z.infer<typeof CreateWorkspaceInstructionPolicyOnboardingProposalRequest>;
+export declare const WorkspaceInstructionPolicyOnboardingProposal: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        confidenceBps: z.ZodNumber;
+    }, z.core.$strip>;
+    baseline: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodString;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    draft: z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        content: z.ZodString;
+        provenance: z.ZodObject<{
+            source: z.ZodEnum<{
+                human: "human";
+                knowledge_proposal: "knowledge_proposal";
+                legacy_import: "legacy_import";
+                onboarding: "onboarding";
+            }>;
+            sourceId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        supersedesRevisionId: z.ZodNullable<z.ZodString>;
+        createdBySubjectId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodLiteral<"proposed">;
+    createdBySubjectId: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposal = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposal>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalListQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalListQuery = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalListQuery>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalListResponse: z.ZodObject<{
+    proposals: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            confidenceBps: z.ZodNumber;
+        }, z.core.$strip>;
+        baseline: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            workspaceId: z.ZodString;
+            revisionId: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            activationVersion: z.ZodNumber;
+            activatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        draft: z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            operationId: z.ZodString;
+            accountId: z.ZodString;
+            workspaceId: z.ZodString;
+            content: z.ZodString;
+            provenance: z.ZodObject<{
+                source: z.ZodEnum<{
+                    human: "human";
+                    knowledge_proposal: "knowledge_proposal";
+                    legacy_import: "legacy_import";
+                    onboarding: "onboarding";
+                }>;
+                sourceId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            supersedesRevisionId: z.ZodNullable<z.ZodString>;
+            createdBySubjectId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodLiteral<"proposed">;
+        createdBySubjectId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalListResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalListResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse: z.ZodObject<{
+    code: z.ZodEnum<{
+        WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_EMPTY: "WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_EMPTY";
+        WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_OVERSIZED: "WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_OVERSIZED";
+    }>;
+    message: z.ZodString;
+    maxChars: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalStaleResponse: z.ZodObject<{
+    code: z.ZodLiteral<"WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_STALE">;
+    message: z.ZodString;
+    currentHead: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodString;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalStaleResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalStaleResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalConflictResponse: z.ZodObject<{
+    code: z.ZodLiteral<"WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_CONFLICT">;
+    message: z.ZodString;
+    existingProposalId: z.ZodString;
+    existingDraftRevisionId: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalConflictResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalConflictResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,6 +29,10 @@
     "./google-drive": {
       "types": "./dist/google-drive.d.ts",
       "import": "./dist/google-drive.js"
+    },
+    "./connector-destinations": {
+      "types": "./dist/connector-destinations.d.ts",
+      "import": "./dist/connector-destinations.js"
     }
   },
   "publishConfig": {

package/src/connector-destinations.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+
+export const ConnectorDocumentDestinationAuthority = z.enum([
+  "organization",
+  "workspace",
+  "personal",
+]);
+export type ConnectorDocumentDestinationAuthority = z.infer<
+  typeof ConnectorDocumentDestinationAuthority
+>;
+
+export const ConnectorDocumentDestinationSelection = z.object({
+  authorityKind: ConnectorDocumentDestinationAuthority,
+  collectionId: z.string().uuid().nullable().default(null),
+});
+export type ConnectorDocumentDestinationSelection = z.infer<
+  typeof ConnectorDocumentDestinationSelection
+>;
+
+export const ConnectorDocumentDestination = z
+  .object({
+    authorityKind: ConnectorDocumentDestinationAuthority,
+    authorityAccountId: z.string().uuid(),
+    authorityWorkspaceId: z.string().uuid().nullable(),
+    authoritySubjectId: z.string().trim().min(1).max(1024).nullable(),
+    collectionId: z.string().uuid().nullable().default(null),
+  })
+  .superRefine((destination, context) => {
+    if (destination.authorityKind === "organization") {
+      if (destination.authorityWorkspaceId !== null || destination.authoritySubjectId !== null) {
+        context.addIssue({
+          code: "custom",
+          message: "organization connector destinations cannot bind workspace or subject authority",
+        });
+      }
+      return;
+    }
+    if (destination.authorityWorkspaceId === null) {
+      context.addIssue({
+        code: "custom",
+        message: "workspace and personal connector destinations require workspace authority",
+      });
+    }
+    if (destination.authorityKind === "workspace" && destination.authoritySubjectId !== null) {
+      context.addIssue({
+        code: "custom",
+        message: "workspace connector destinations cannot bind subject authority",
+      });
+    }
+    if (destination.authorityKind === "personal" && destination.authoritySubjectId === null) {
+      context.addIssue({
+        code: "custom",
+        message: "personal connector destinations require immutable subject authority",
+      });
+    }
+  });
+export type ConnectorDocumentDestination = z.infer<typeof ConnectorDocumentDestination>;
+
+export function bindConnectorDocumentDestination(
+  selection: ConnectorDocumentDestinationSelection,
+  context: { accountId: string; workspaceId: string; initiatingSubjectId: string },
+): ConnectorDocumentDestination {
+  return ConnectorDocumentDestination.parse({
+    authorityKind: selection.authorityKind,
+    authorityAccountId: context.accountId,
+    authorityWorkspaceId: selection.authorityKind === "organization" ? null : context.workspaceId,
+    authoritySubjectId: selection.authorityKind === "personal" ? context.initiatingSubjectId : null,
+    collectionId: selection.collectionId,
+  });
+}
+
+export function legacyWorkspaceConnectorDocumentDestination(context: {
+  accountId: string;
+  workspaceId: string;
+}): ConnectorDocumentDestination {
+  return ConnectorDocumentDestination.parse({
+    authorityKind: "workspace",
+    authorityAccountId: context.accountId,
+    authorityWorkspaceId: context.workspaceId,
+    authoritySubjectId: null,
+    collectionId: null,
+  });
+}
+
+export function resolveConnectorDocumentDestination(
+  value: unknown,
+  context: {
+    accountId: string;
+    workspaceId: string;
+    connectionSubjectId?: string | null | undefined;
+  },
+): ConnectorDocumentDestination {
+  if (value === undefined || value === null) {
+    return legacyWorkspaceConnectorDocumentDestination(context);
+  }
+  const destination = ConnectorDocumentDestination.parse(value);
+  if (destination.authorityAccountId !== context.accountId) {
+    throw new Error("connector destination organization authority mismatch");
+  }
+  if (
+    destination.authorityKind !== "organization" &&
+    destination.authorityWorkspaceId !== context.workspaceId
+  ) {
+    throw new Error("connector destination workspace authority mismatch");
+  }
+  if (
+    destination.authorityKind === "personal" &&
+    destination.authoritySubjectId !== context.connectionSubjectId
+  ) {
+    throw new Error("connector destination personal authority mismatch");
+  }
+  return destination;
+}
+
+export function connectorDestinationDocumentAuthority(destination: ConnectorDocumentDestination): {
+  authorityKind: ConnectorDocumentDestinationAuthority;
+  authorityWorkspaceId: string | null;
+  authoritySubjectId: string | null;
+} {
+  return {
+    authorityKind: destination.authorityKind,
+    authorityWorkspaceId: destination.authorityWorkspaceId,
+    authoritySubjectId: destination.authoritySubjectId,
+  };
+}
+
+export function connectorDocumentDestinationCollectionId(
+  destination: ConnectorDocumentDestination,
+  defaultCollectionId: string,
+): string {
+  return destination.collectionId ?? z.string().uuid().parse(defaultCollectionId);
+}

package/src/google-drive.ts

@@ -1,6 +1,10 @@
 import { z } from "zod";
 
 import { ConnectionMetadata } from "./index";
+import {
+  ConnectorDocumentDestination,
+  ConnectorDocumentDestinationSelection,
+} from "./connector-destinations";
 
 export const GOOGLE_DRIVE_PROVIDER_DOMAIN = "googleapis.com" as const;
 export const GOOGLE_DRIVE_FULL_SCOPE = "https://www.googleapis.com/auth/drive" as const;
@@ -63,6 +67,7 @@ export function googleDriveScopesAllowCapability(
   return googleDriveOAuthScopeDecision(grantedScopes).capabilities.includes(capability);
 }
 
+/** @deprecated Connector document destinations use organization/workspace/personal authority. */
 export const GoogleDriveTargetScope = z.enum(["user", "workspace", "organization"]);
 export type GoogleDriveTargetScope = z.infer<typeof GoogleDriveTargetScope>;
 
@@ -130,7 +135,9 @@ export const GoogleDriveSelectedSource = z.object({
   name: z.string().min(1).max(1024),
   mimeType: z.string().min(1).max(256),
   driveId: z.string().min(1).max(256).nullable().default(null),
-  targetScope: GoogleDriveTargetScope,
+  destination: ConnectorDocumentDestination.optional(),
+  /** @deprecated Missing destinations resolve to the current workspace boundary. */
+  targetScope: GoogleDriveTargetScope.optional(),
   syncCadence: GoogleDriveSyncCadence.default("hourly"),
   readPolicy: GoogleDriveReadPolicy.default("allow"),
   selectedAt: z.string().datetime({ offset: true }),
@@ -147,6 +154,7 @@ export const GoogleDriveConnectionMetadata = z
     verifiedAt: z.string().datetime({ offset: true }),
     accessMode: z.enum(["metadata_readonly", "readonly"]),
     lifecycle: GoogleDriveConnectionLifecycle.optional(),
+    documentDestination: ConnectorDocumentDestination.optional(),
     selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),
     /** @deprecated Read `selectedSources`; retained while existing connections migrate. */
     selectedSource: GoogleDriveSelectedSource.nullable().optional(),
@@ -199,22 +207,28 @@ export const GoogleDriveBrowseResponse = z.object({
 });
 export type GoogleDriveBrowseResponse = z.infer<typeof GoogleDriveBrowseResponse>;
 
-export const SaveGoogleDriveSourceRequest = z.object({
-  sources: z
-    .array(
-      GoogleDriveBrowseItem.pick({
-        id: true,
-        name: true,
-        mimeType: true,
-        driveId: true,
+export const SaveGoogleDriveSourceRequest = z
+  .object({
+    sources: z
+      .array(
+        GoogleDriveBrowseItem.pick({
+          id: true,
+          name: true,
+          mimeType: true,
+          driveId: true,
+        }),
+      )
+      .max(100)
+      .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
+        message: "Google Drive sources must be unique",
       }),
-    )
-    .max(100)
-    .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
-      message: "Google Drive sources must be unique",
-    }),
-  targetScope: GoogleDriveTargetScope,
-  syncCadence: GoogleDriveSyncCadence.default("hourly"),
-  readPolicy: GoogleDriveReadPolicy.default("allow"),
-});
+    destination: ConnectorDocumentDestinationSelection.optional(),
+    /** @deprecated Legacy requests are accepted but resolve to workspace authority. */
+    targetScope: GoogleDriveTargetScope.optional(),
+    syncCadence: GoogleDriveSyncCadence.default("hourly"),
+    readPolicy: GoogleDriveReadPolicy.default("allow"),
+  })
+  .refine((request) => request.destination !== undefined || request.targetScope !== undefined, {
+    message: "Google Drive document destination is required",
+  });
 export type SaveGoogleDriveSourceRequest = z.infer<typeof SaveGoogleDriveSourceRequest>;

package/src/index.ts

@@ -8,6 +8,7 @@ import {
 import { WorkspaceInstructionPolicyRoleKeyInput } from "./workspace-instruction-policies";
 
 export * from "./slack-bot-scopes";
+export * from "./connector-destinations";
 
 export {
   CreateWorkspaceArtifactRequest,
@@ -1149,7 +1150,11 @@ export const ClientVoiceInputConfig = z
   .object({
     available: z.boolean(),
     maxDurationSeconds: z.number().int().positive().max(600),
-    maxSizeBytes: z.number().int().positive(),
+    maxSizeBytes: z
+      .number()
+      .int()
+      .positive()
+      .max(25 * 1024 * 1024),
     acceptedMimeTypes: z.array(z.string().trim().min(1).max(128)).min(1).max(32),
   })
   .strict();
@@ -1164,7 +1169,7 @@ export const TranscribeAudioResponse = z
   .strict();
 export type TranscribeAudioResponse = z.infer<typeof TranscribeAudioResponse>;
 
-/** Default ceilings for native voice input (hard-stop recording + upload). */
+/** Default safety ceiling for one-shot native voice input (60 seconds). */
 export const VOICE_INPUT_MAX_DURATION_SECONDS = 60 as const;
 export const VOICE_INPUT_MAX_SIZE_BYTES = 25 * 1024 * 1024;
 export const VOICE_INPUT_ACCEPTED_MIME_TYPES = [

package/src/workspace-instruction-policies.ts

@@ -5,6 +5,7 @@ export const WORKSPACE_INSTRUCTION_POLICY_PROMPT_MAX_UTF8_BYTES = 131_072;
 export const WORKSPACE_INSTRUCTION_POLICY_REASON_MAX_CHARS = 4_096;
 export const WORKSPACE_INSTRUCTION_POLICY_ROLE_KEY_MAX_CHARS = 64;
 export const WORKSPACE_INSTRUCTION_POLICY_SOURCE_ID_MAX_CHARS = 512;
+export const WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_SOURCE_VERSION_MAX_CHARS = 256;
 
 export const WorkspaceInstructionPolicyKind = z.enum(["charter", "policy"]);
 export type WorkspaceInstructionPolicyKind = z.infer<typeof WorkspaceInstructionPolicyKind>;
@@ -353,3 +354,100 @@ export const WorkspaceInstructionPolicyOperationReuseResponse = z.object({
 export type WorkspaceInstructionPolicyOperationReuseResponse = z.infer<
   typeof WorkspaceInstructionPolicyOperationReuseResponse
 >;
+
+export const WorkspaceInstructionPolicyOnboardingProposalSource = z.object({
+  id: z.string().min(1).max(WORKSPACE_INSTRUCTION_POLICY_SOURCE_ID_MAX_CHARS),
+  version: z.string().min(1).max(WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_SOURCE_VERSION_MAX_CHARS),
+  confidenceBps: z.number().int().min(0).max(10_000),
+});
+export type WorkspaceInstructionPolicyOnboardingProposalSource = z.infer<
+  typeof WorkspaceInstructionPolicyOnboardingProposalSource
+>;
+
+export const CreateWorkspaceInstructionPolicyOnboardingProposalRequest = z
+  .object({
+    operationId: z.string().uuid().optional(),
+    kind: WorkspaceInstructionPolicyKind,
+    scope: WorkspaceInstructionPolicyScope,
+    roleKey: WorkspaceInstructionPolicyRoleKeyInput.nullable().default(null),
+    // Content bounds are enforced by the domain layer so empty and oversized
+    // proposals retain their typed API outcomes instead of collapsing into a
+    // generic request-shape error.
+    content: z.string(),
+    sourceId: z.string().trim().min(1).max(WORKSPACE_INSTRUCTION_POLICY_SOURCE_ID_MAX_CHARS),
+    sourceVersion: z
+      .string()
+      .trim()
+      .min(1)
+      .max(WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_SOURCE_VERSION_MAX_CHARS),
+    confidenceBps: z.number().int().min(0).max(10_000),
+    expectedCurrentRevisionId: z.string().uuid().nullable(),
+    expectedActivationVersion: z.number().int().nonnegative(),
+  })
+  .superRefine(validateTarget);
+export type CreateWorkspaceInstructionPolicyOnboardingProposalRequest = z.infer<
+  typeof CreateWorkspaceInstructionPolicyOnboardingProposalRequest
+>;
+
+export const WorkspaceInstructionPolicyOnboardingProposal = z.object({
+  id: z.string().uuid(),
+  operationId: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  ...targetShape,
+  source: WorkspaceInstructionPolicyOnboardingProposalSource,
+  baseline: WorkspaceInstructionPolicyHead.nullable(),
+  draft: WorkspaceInstructionPolicyRevision,
+  status: z.literal("proposed"),
+  createdBySubjectId: z.string().min(1),
+  createdAt: z.string().datetime(),
+});
+export type WorkspaceInstructionPolicyOnboardingProposal = z.infer<
+  typeof WorkspaceInstructionPolicyOnboardingProposal
+>;
+
+export const WorkspaceInstructionPolicyOnboardingProposalListQuery = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+export type WorkspaceInstructionPolicyOnboardingProposalListQuery = z.infer<
+  typeof WorkspaceInstructionPolicyOnboardingProposalListQuery
+>;
+
+export const WorkspaceInstructionPolicyOnboardingProposalListResponse = z.object({
+  proposals: z.array(WorkspaceInstructionPolicyOnboardingProposal),
+  truncated: z.boolean(),
+});
+export type WorkspaceInstructionPolicyOnboardingProposalListResponse = z.infer<
+  typeof WorkspaceInstructionPolicyOnboardingProposalListResponse
+>;
+
+export const WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse = z.object({
+  code: z.enum([
+    "WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_EMPTY",
+    "WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_OVERSIZED",
+  ]),
+  message: z.string(),
+  maxChars: z.number().int().positive(),
+});
+export type WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse = z.infer<
+  typeof WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse
+>;
+
+export const WorkspaceInstructionPolicyOnboardingProposalStaleResponse = z.object({
+  code: z.literal("WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_STALE"),
+  message: z.string(),
+  currentHead: WorkspaceInstructionPolicyHead.nullable(),
+});
+export type WorkspaceInstructionPolicyOnboardingProposalStaleResponse = z.infer<
+  typeof WorkspaceInstructionPolicyOnboardingProposalStaleResponse
+>;
+
+export const WorkspaceInstructionPolicyOnboardingProposalConflictResponse = z.object({
+  code: z.literal("WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_CONFLICT"),
+  message: z.string(),
+  existingProposalId: z.string().uuid(),
+  existingDraftRevisionId: z.string().uuid(),
+});
+export type WorkspaceInstructionPolicyOnboardingProposalConflictResponse = z.infer<
+  typeof WorkspaceInstructionPolicyOnboardingProposalConflictResponse
+>;