@company-semantics/contracts 21.1.0 → 21.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@company-semantics/contracts",
-  "version": "21.1.0",
+  "version": "21.3.0",
   "private": false,
   "repository": {
     "type": "git",

package/src/api/generated-spec-hash.ts

@@ -1,3 +1,3 @@
 // AUTO-GENERATED — do not edit. Run pnpm generate:spec-hash to regenerate.
-export const SPEC_HASH = '04f6a4a8fe16' as const;
-export const SPEC_HASH_FULL = '04f6a4a8fe169119fda699f1854d409df278ac5dd7ab16f1d5affff6cd133e47' as const;
+export const SPEC_HASH = '16094a4fcda0' as const;
+export const SPEC_HASH_FULL = '16094a4fcda0647e96289cdc0e104eab13d9539c043207cdda1ad8c8bf5a4dcb' as const;

package/src/api/generated.ts

@@ -3449,6 +3449,8 @@ export interface components {
                     unitName: string;
                     /** @enum {string} */
                     designation: "whole_org" | "admin" | "unit_owner" | "delegate" | "member";
+                    /** @enum {string} */
+                    mutability: "derived" | "user_managed";
                 }[];
                 unitMembershipsTruncated: boolean;
                 inviteStatus: ("active" | "pending" | "expired") | null;
@@ -3644,6 +3646,8 @@ export interface components {
                 unitName: string;
                 /** @enum {string} */
                 designation: "whole_org" | "admin" | "unit_owner" | "delegate" | "member";
+                /** @enum {string} */
+                mutability: "derived" | "user_managed";
             }[];
             unitMembershipsTruncated: boolean;
             inviteStatus: ("active" | "pending" | "expired") | null;
@@ -3774,6 +3778,19 @@ export interface components {
                 homeUnitId?: string;
                 /** @enum {string} */
                 homeUnitRole?: "member" | "unit_owner";
+                stagedPlacement?: {
+                    title?: string;
+                    /** Format: uuid */
+                    managerUserId?: string;
+                    /** Format: uuid */
+                    homeUnitId?: string;
+                    /** @enum {string} */
+                    homeUnitRole?: "member" | "unit_owner";
+                    /** @default [] */
+                    unitOwnerOf: string[];
+                    /** @default [] */
+                    contributesTo: string[];
+                };
                 createdAt: string;
                 expiresAt: string;
                 acceptedAt?: string;
@@ -3805,6 +3822,19 @@ export interface components {
             homeUnitId?: string;
             /** @enum {string} */
             homeUnitRole?: "member" | "unit_owner";
+            stagedPlacement?: {
+                title?: string;
+                /** Format: uuid */
+                managerUserId?: string;
+                /** Format: uuid */
+                homeUnitId?: string;
+                /** @enum {string} */
+                homeUnitRole?: "member" | "unit_owner";
+                /** @default [] */
+                unitOwnerOf: string[];
+                /** @default [] */
+                contributesTo: string[];
+            };
             createdAt: string;
             expiresAt: string;
             acceptedAt?: string;

package/src/org/README.md

@@ -75,6 +75,8 @@ Shared type vocabulary for organization ownership, type classification, and tran
 - `CreateDelegationRequest` _(type)_
 - `CreateDelegationRequestSchema`
 - `CreateInviteRequest` _(type)_ — Request payload for creating an organization invite.
+- `CreateInviteRequestPayload` _(type)_
+- `CreateInviteRequestSchema`
 - `CreateOpenRoleRequest` _(type)_
 - `CreateOpenRoleRequestSchema`
 - `Delegation` _(type)_
@@ -258,6 +260,8 @@ Shared type vocabulary for organization ownership, type classification, and tran
 - `SsoReadinessCheck` _(type)_ — Individual readiness check for SSO activation.
 - `SsoSetupInfo` _(type)_ — SSO setup information for admin configuration UI.
 - `SsoStepperStep` _(type)_ — Backend-authoritative stepper step.
+- `StagedPlacement` _(type)_ — Staged member placement: the fuller org position an invitee is slotted into, applied as deferred grants when…
+- `StagedPlacementSchema` — Staged member placement: the fuller org position an invitee is slotted into, applied as deferred grants when…
 - `SubmitInteractiveTaskResponse` _(type)_
 - `SubmitInteractiveTaskResponseSchema` — Response for submitting a filled-in interactive chat task surface (e.g. the editable "change reporting…
 - `SyncRunSummary` _(type)_

package/src/org/__tests__/invite-schemas.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from "vitest";
+import {
+  StagedPlacementSchema,
+  CreateInviteRequestSchema,
+  InviteResponseSchema,
+} from "../schemas.js";
+
+const UUID_A = "11111111-1111-4111-8111-111111111111";
+const UUID_B = "22222222-2222-4222-8222-222222222222";
+const UUID_C = "33333333-3333-4333-8333-333333333333";
+
+const makeInvite = (overrides: Record<string, unknown> = {}) => ({
+  id: UUID_A,
+  orgId: UUID_B,
+  email: "new.hire@example.com",
+  role: "member",
+  invitedBy: { id: UUID_C, name: "Inviter" },
+  status: "pending",
+  createdAt: "2026-06-24T00:00:00Z",
+  expiresAt: "2026-07-01T00:00:00Z",
+  ...overrides,
+});
+
+describe("CreateInviteRequestSchema", () => {
+  it("parses a minimal payload without stagedPlacement", () => {
+    const parsed = CreateInviteRequestSchema.parse({
+      email: "new.hire@example.com",
+      role: "admin",
+    });
+    expect(parsed.stagedPlacement).toBeUndefined();
+    expect(parsed.homeUnitId).toBeUndefined();
+  });
+
+  it("parses a full stagedPlacement with arrays defaulting to []", () => {
+    const parsed = CreateInviteRequestSchema.parse({
+      email: "new.hire@example.com",
+      role: "member",
+      homeUnitId: UUID_A,
+      homeUnitRole: "unit_owner",
+      stagedPlacement: {
+        title: "Staff Engineer",
+        managerUserId: UUID_B,
+        homeUnitId: UUID_A,
+        homeUnitRole: "unit_owner",
+      },
+    });
+    expect(parsed.stagedPlacement?.title).toBe("Staff Engineer");
+    // unitOwnerOf/contributesTo default to [] when omitted.
+    expect(parsed.stagedPlacement?.unitOwnerOf).toEqual([]);
+    expect(parsed.stagedPlacement?.contributesTo).toEqual([]);
+  });
+});
+
+describe("StagedPlacementSchema", () => {
+  it("defaults unitOwnerOf and contributesTo to []", () => {
+    const parsed = StagedPlacementSchema.parse({});
+    expect(parsed.unitOwnerOf).toEqual([]);
+    expect(parsed.contributesTo).toEqual([]);
+  });
+
+  it("retains provided unit arrays", () => {
+    const parsed = StagedPlacementSchema.parse({
+      unitOwnerOf: [UUID_A],
+      contributesTo: [UUID_B, UUID_C],
+    });
+    expect(parsed.unitOwnerOf).toEqual([UUID_A]);
+    expect(parsed.contributesTo).toEqual([UUID_B, UUID_C]);
+  });
+
+  it("trims the title", () => {
+    const parsed = StagedPlacementSchema.parse({ title: "  Lead  " });
+    expect(parsed.title).toBe("Lead");
+  });
+
+  it("rejects a non-uuid managerUserId", () => {
+    expect(() =>
+      StagedPlacementSchema.parse({ managerUserId: "not-a-uuid" }),
+    ).toThrow();
+  });
+});
+
+describe("OrgInviteSchema (via InviteResponseSchema)", () => {
+  it("parses an invite without stagedPlacement (back-compat)", () => {
+    const parsed = InviteResponseSchema.parse({ invite: makeInvite() });
+    expect(parsed.invite.stagedPlacement).toBeUndefined();
+  });
+
+  it("parses an invite carrying a stagedPlacement", () => {
+    const parsed = InviteResponseSchema.parse({
+      invite: makeInvite({
+        homeUnitId: UUID_A,
+        homeUnitRole: "member",
+        stagedPlacement: {
+          title: "Engineer",
+          unitOwnerOf: [UUID_A],
+        },
+      }),
+    });
+    expect(parsed.invite.stagedPlacement?.title).toBe("Engineer");
+    expect(parsed.invite.stagedPlacement?.unitOwnerOf).toEqual([UUID_A]);
+    // Omitted contributesTo still defaults to [].
+    expect(parsed.invite.stagedPlacement?.contributesTo).toEqual([]);
+  });
+});

package/src/org/index.ts

@@ -249,6 +249,8 @@ export type {
 
 // Org lifecycle response schemas (PRD-00446)
 export {
+  StagedPlacementSchema,
+  CreateInviteRequestSchema,
   InviteResponseSchema,
   InviteListResponseSchema,
   DomainResponseSchema,
@@ -259,6 +261,8 @@ export {
   OwnershipTransferPreviewSchema,
 } from "./schemas";
 export type {
+  StagedPlacement,
+  CreateInviteRequestPayload,
   InviteResponse,
   InviteListResponse,
   DomainResponse,

package/src/org/schemas.ts

@@ -43,10 +43,31 @@ export const OrgUnitDesignationSchema = z.enum([
 ]);
 export type OrgUnitDesignation = z.infer<typeof OrgUnitDesignationSchema>;
 
+/**
+ * Whether the user can change this authority from this surface.
+ *  - `derived`: change the upstream source instead (the org chart, RBAC roles).
+ *  - `user_managed`: removable from this UI.
+ *
+ * Hoisted above {@link WorkspaceMemberUnitDesignationEntrySchema} so the
+ * per-unit designation can carry it; also consumed by {@link OwnerAuthoritySchema}.
+ */
+export const AuthorityMutabilitySchema = z.enum(["derived", "user_managed"]);
+export type AuthorityMutability = z.infer<typeof AuthorityMutabilitySchema>;
+
 export const WorkspaceMemberUnitDesignationEntrySchema = z.object({
   unitId: z.string(),
   unitName: z.string(),
   designation: OrgUnitDesignationSchema,
+  /**
+   * Whether this designation is REMOVABLE in place (`user_managed` — an explicit
+   * overlay grant or `l{N}_unit_owner` membership) or DERIVED from reporting
+   * topology (`derived` — the senior person homed in a unit with no manager
+   * inside it, ADR-BE-267/294). A `derived` owner can't be revoked: the holder
+   * must relinquish it (recorded as a higher-provenance suppression that the
+   * structural projection honors) or the upstream chart must change. Display +
+   * affordance gating only; never an authorization input.
+   */
+  mutability: AuthorityMutabilitySchema,
 });
 export type WorkspaceMemberUnitDesignationEntry = z.infer<
   typeof WorkspaceMemberUnitDesignationEntrySchema
@@ -606,6 +627,46 @@ export type ScopeCheckBatchResponse = z.infer<
 export const HomeUnitRoleSchema = z.enum(["member", "unit_owner"]);
 export type HomeUnitRole = z.infer<typeof HomeUnitRoleSchema>;
 
+/** Established title cap shared with org-unit/open-role titles. */
+const STAGED_PLACEMENT_TITLE_MAX = 255;
+/**
+ * Upper bound on the number of units an invitee can be staged into as owner or
+ * contributor. Bounds the replay cost of applying a staged placement at accept
+ * time (each entry is a deferred membership grant). A generous-but-finite cap.
+ */
+const STAGED_PLACEMENT_UNITS_MAX = 64;
+
+/**
+ * Staged member placement: the fuller org position an invitee is slotted into,
+ * applied as deferred grants when the invite is accepted. A superset of the
+ * legacy top-level `homeUnitId`/`homeUnitRole` fields, carrying the (optional)
+ * intended title, manager, and the units the invitee will own or contribute to.
+ *
+ * Every field is optional or defaulted so a placement can be partially
+ * specified at invite time. The array caps bound downstream replay cost.
+ */
+export const StagedPlacementSchema = z.object({
+  // Intended job/role title for the invitee. Trimmed; non-empty when present.
+  title: z.string().trim().min(1).max(STAGED_PLACEMENT_TITLE_MAX).optional(),
+  // The invitee's manager on acceptance (a `manages` designation).
+  managerUserId: z.string().uuid().optional(),
+  // Home unit the invitee is placed in (their `users.primary_unit_id`).
+  homeUnitId: z.string().uuid().optional(),
+  // Role the invitee takes in `homeUnitId` ('unit_owner' = deferred grant).
+  homeUnitRole: HomeUnitRoleSchema.optional(),
+  // Additional units the invitee becomes a unit owner of on acceptance.
+  unitOwnerOf: z
+    .array(z.string().uuid())
+    .max(STAGED_PLACEMENT_UNITS_MAX)
+    .default([]),
+  // Units the invitee contributes to (non-owner membership) on acceptance.
+  contributesTo: z
+    .array(z.string().uuid())
+    .max(STAGED_PLACEMENT_UNITS_MAX)
+    .default([]),
+});
+export type StagedPlacement = z.infer<typeof StagedPlacementSchema>;
+
 const OrgInviteSchema = z.object({
   id: z.string(),
   orgId: z.string(),
@@ -620,6 +681,10 @@ const OrgInviteSchema = z.object({
   // deferred unit-ownership grant). Optional/'member' for legacy +
   // unit-less invites.
   homeUnitRole: HomeUnitRoleSchema.optional(),
+  // Fuller staged placement applied as deferred grants on acceptance. A
+  // superset of the top-level homeUnitId/homeUnitRole, kept additive/optional
+  // so legacy invites and unit-less invites parse unchanged.
+  stagedPlacement: StagedPlacementSchema.optional(),
   createdAt: z.string(),
   expiresAt: z.string(),
   acceptedAt: z.string().optional(),
@@ -643,6 +708,33 @@ export const InviteListResponseSchema = z.array(OrgInviteSchema);
 
 export type InviteListResponse = z.infer<typeof InviteListResponseSchema>;
 
+// ---------------------------------------------------------------------------
+// POST /api/workspace/invites — request body
+// Request schema colocated with the response schema (narrow deviation from
+// ADR-CONT-044, per the CreateOpenRoleRequestSchema precedent) because the
+// staged-placement shape is the published promise consumers must satisfy.
+// Mirrors the hand-written `CreateInviteRequest` interface in org/types.ts and
+// extends it with the optional `stagedPlacement` superset.
+// ---------------------------------------------------------------------------
+
+export const CreateInviteRequestSchema = z.object({
+  email: z.string().email(),
+  // Invites only grant the restricted {admin, member} domain.
+  role: z.enum(["admin", "member"]),
+  // Home unit the invitee is placed in on acceptance. Optional in the contract
+  // so the field can roll out without breaking older callers.
+  homeUnitId: z.string().uuid().optional(),
+  // Role the invitee takes in homeUnitId — only meaningful with a home unit.
+  homeUnitRole: HomeUnitRoleSchema.optional(),
+  // Fuller staged placement (title, manager, owned/contributed units) applied
+  // as deferred grants on acceptance. Optional/additive for back-compat.
+  stagedPlacement: StagedPlacementSchema.optional(),
+});
+
+export type CreateInviteRequestPayload = z.infer<
+  typeof CreateInviteRequestSchema
+>;
+
 // ---------------------------------------------------------------------------
 // OrgDomain sub-schema
 // ---------------------------------------------------------------------------
@@ -1070,13 +1162,8 @@ export type AuthorityMechanism = z.infer<typeof AuthorityMechanismSchema>;
 export const AuthorityLocalitySchema = z.enum(["local", "inherited"]);
 export type AuthorityLocality = z.infer<typeof AuthorityLocalitySchema>;
 
-/**
- * Whether the user can change this authority from this surface.
- *  - `derived`: change the upstream source instead (the org chart, RBAC roles).
- *  - `user_managed`: removable from this UI.
- */
-export const AuthorityMutabilitySchema = z.enum(["derived", "user_managed"]);
-export type AuthorityMutability = z.infer<typeof AuthorityMutabilitySchema>;
+// AuthorityMutabilitySchema is defined above (hoisted next to
+// WorkspaceMemberUnitDesignationEntrySchema, which also carries it).
 
 export const OwnerAuthoritySchema = z.object({
   mechanism: AuthorityMechanismSchema,

package/src/org/types.ts

@@ -397,6 +397,37 @@ export interface WorkspaceAuditEvent {
  */
 export type OrgInviteStatus = "pending" | "accepted" | "expired" | "revoked";
 
+/**
+ * Staged member placement: the fuller org position an invitee is slotted into,
+ * applied as deferred grants when the invite is accepted. A superset of the
+ * top-level `homeUnitId`/`homeUnitRole` fields, carrying the (optional) intended
+ * title, manager, and the units the invitee will own or contribute to.
+ *
+ * Hand-written mirror of `StagedPlacementSchema` in `org/schemas.ts` — keep in
+ * lockstep. Because the schema defaults `unitOwnerOf`/`contributesTo` to `[]`,
+ * their inferred OUTPUT type is a required `string[]`; the other four fields are
+ * optional. The `homeUnitRole` union is re-typed inline (not imported) to match
+ * the `OrgInvite`/`CreateInviteRequest` convention.
+ *
+ * NOTE: the canonical `StagedPlacement` name is exported package-root from
+ * `org/schemas.ts` (the `z.infer`). This interface is intentionally NOT added to
+ * the `./types` re-export block in `org/index.ts` to avoid a name collision.
+ */
+export interface StagedPlacement {
+  /** Intended job/role title for the invitee. Trimmed; non-empty when present. */
+  title?: string;
+  /** The invitee's manager on acceptance (a `manages` designation) — a member id. */
+  managerUserId?: string;
+  /** Home unit the invitee is placed in (their `users.primary_unit_id`). */
+  homeUnitId?: string;
+  /** Role the invitee takes in `homeUnitId` (`unit_owner` = deferred grant). */
+  homeUnitRole?: "member" | "unit_owner";
+  /** Additional units the invitee becomes a unit owner of on acceptance. */
+  unitOwnerOf: string[];
+  /** Units the invitee contributes to (non-owner membership) on acceptance. */
+  contributesTo: string[];
+}
+
 /**
  * Organization invite for the workspace invites list.
  * Represents a pending or historical invitation.
@@ -425,6 +456,13 @@ export interface OrgInvite {
    * legacy invites and unit-less invites have none (treated as `member`).
    */
   homeUnitRole?: "member" | "unit_owner";
+  /**
+   * Fuller staged placement applied as deferred grants on acceptance. A superset
+   * of the top-level `homeUnitId`/`homeUnitRole`, kept additive/optional so
+   * legacy and unit-less invites parse unchanged. Mirrors
+   * `OrgInviteSchema.stagedPlacement` in `org/schemas.ts`.
+   */
+  stagedPlacement?: StagedPlacement;
   createdAt: string;
   expiresAt: string;
   acceptedAt?: string;
@@ -450,6 +488,12 @@ export interface CreateInviteRequest {
    * rejects `unit_owner` without a home unit. Optional/`member` for older callers.
    */
   homeUnitRole?: "member" | "unit_owner";
+  /**
+   * Fuller staged placement (title, manager, owned/contributed units) applied as
+   * deferred grants on acceptance. Optional/additive for back-compat. Mirrors
+   * `CreateInviteRequestSchema.stagedPlacement` in `org/schemas.ts`.
+   */
+  stagedPlacement?: StagedPlacement;
 }
 
 /**