@company-semantics/contracts 52.1.0 → 53.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@company-semantics/contracts",
-  "version": "52.1.0",
+  "version": "53.0.1",
   "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 = 'd0171aedf623' as const;
-export const SPEC_HASH_FULL = 'd0171aedf623604dc721fb42b626ebc019afcc2fda9be59e1f06360cd6a4fcca' as const;
+export const SPEC_HASH = '691f7bd81d0c' as const;
+export const SPEC_HASH_FULL = '691f7bd81d0c34aebd47c457a170dd48443a3f9eb007312fa97af00d9a4ccf30' as const;

package/src/api/generated.ts

@@ -738,7 +738,7 @@ export interface paths {
         patch: operations["changeMemberRole"];
         trace?: never;
     };
-    "/api/workspace/members/{id}/manager": {
+    "/api/reporting/positions/{positionId}/manager": {
         parameters: {
             query?: never;
             header?: never;
@@ -746,14 +746,13 @@ export interface paths {
             cookie?: never;
         };
         get?: never;
-        put?: never;
+        /** Set or clear a seat's solid-line manager (org-chart reporting edge) */
+        put: operations["setSeatManager"];
         post?: never;
-        /** Clear a member's solid-line manager (org-chart reporting edge) */
-        delete: operations["clearMemberManager"];
+        delete?: never;
         options?: never;
         head?: never;
-        /** Set a member's solid-line manager (org-chart reporting edge) */
-        patch: operations["setMemberManager"];
+        patch?: never;
         trace?: never;
     };
     "/api/reporting/move/preview": {
@@ -1409,6 +1408,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/org/reconciliation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the workspace’s standing disagreements with the connected HRIS
+         * @description The org’s still-open divergences, newest first, whether they arose during a sync run or during app use. Distinct from the run-scoped conflicts view, which reports what one run refused. Read-only: nothing here is sent to the HRIS.
+         */
+        get: operations["getOrgReconciliation"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/org/reconciliation/divergences/{divergenceId}/resolution": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Acknowledge a standing disagreement with the connected HRIS
+         * @description Records LOCALLY that this workspace has seen the disagreement. Nothing is sent to the HRIS — the result’s sentToSource is always false — and the divergence stays open in the ledger, now carrying acknowledgedAt. Idempotent: acknowledging twice returns the first acknowledgement’s timestamp.
+         */
+        post: operations["resolveOrgDivergence"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/company-md/tree": {
         parameters: {
             query?: never;
@@ -4091,6 +4130,7 @@ export interface components {
                 email: string;
                 avatarUrl?: string | null;
                 jobTitle: string | null;
+                seatPositionId: string | null;
                 role: ("owner" | "unit_owner" | "delegate" | "admin") | null;
                 roleNames: string[];
                 joinedAt: string;
@@ -4288,6 +4328,7 @@ export interface components {
             email: string;
             avatarUrl?: string | null;
             jobTitle: string | null;
+            seatPositionId: string | null;
             role: ("owner" | "unit_owner" | "delegate" | "admin") | null;
             roleNames: string[];
             joinedAt: string;
@@ -4340,35 +4381,23 @@ export interface components {
             /** @enum {string} */
             newRole: "admin" | "member";
         };
-        SetMemberManagerResponse: {
+        SetSeatManagerResponse: {
             success: boolean;
-            memberId: string;
-            manager: ({
-                /** @constant */
-                kind: "member";
-                /** Format: uuid */
-                userId: string;
-            } | {
-                /** @constant */
-                kind: "open-role";
+            /** Format: uuid */
+            reportPositionId: string;
+            manager: {
                 /** Format: uuid */
-                openRoleId: string;
-            }) | null;
-            relationshipType: string;
+                positionId: string;
+            } | null;
+            /** @constant */
+            relationshipType: "solid";
             message: string;
         };
-        SetMemberManagerRequest: {
+        SetSeatManagerRequest: {
             manager: {
-                /** @constant */
-                kind: "member";
-                /** Format: uuid */
-                userId: string;
-            } | {
-                /** @constant */
-                kind: "open-role";
                 /** Format: uuid */
-                openRoleId: string;
-            };
+                positionId: string;
+            } | null;
         };
         MovePreviewRequest: {
             /** @constant */
@@ -4934,6 +4963,10 @@ export interface components {
             /** @enum {string} */
             decision: "accept" | "reject";
         };
+        ResolveOrgDivergenceRequest: {
+            /** @constant */
+            resolution: "acknowledged";
+        };
         CompanyMdListResponse: {
             items: {
                 id: string;
@@ -5673,7 +5706,7 @@ export interface components {
                 /** @enum {string} */
                 status: "open" | "hiring" | "filled" | "closed";
                 filledByUserId: string | null;
-                reportsToUserId: string | null;
+                reportsToPositionId: string | null;
                 createdAt: string;
                 updatedAt: string;
             }[];
@@ -5691,7 +5724,7 @@ export interface components {
                 /** @enum {string} */
                 status: "open" | "hiring" | "filled" | "closed";
                 filledByUserId: string | null;
-                reportsToUserId: string | null;
+                reportsToPositionId: string | null;
                 createdAt: string;
                 updatedAt: string;
             };
@@ -5708,7 +5741,8 @@ export interface components {
                 hiring: boolean;
                 occupants: {
                     /** Format: uuid */
-                    userId: string;
+                    personId: string;
+                    userId: string | null;
                     fullName: string;
                     avatarUrl: string | null;
                     primaryUnitId: string | null;
@@ -5720,6 +5754,7 @@ export interface components {
                         mutability: "derived" | "user_managed";
                     }[];
                 }[];
+                integrity: "canonical_placement_conflict" | null;
             }[];
             seatEdges: {
                 /** Format: uuid */
@@ -7926,50 +7961,28 @@ export interface operations {
             };
         };
     };
-    clearMemberManager: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                id: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Manager cleared successfully */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["SetMemberManagerResponse"];
-                };
-            };
-        };
-    };
-    setMemberManager: {
+    setSeatManager: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                id: string;
+                positionId: string;
             };
             cookie?: never;
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["SetMemberManagerRequest"];
+                "application/json": components["schemas"]["SetSeatManagerRequest"];
             };
         };
         responses: {
-            /** @description Manager set successfully */
+            /** @description The seat's solid-line manager edge was set or cleared */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["SetMemberManagerResponse"];
+                    "application/json": components["schemas"]["SetSeatManagerResponse"];
                 };
             };
         };
@@ -8898,6 +8911,55 @@ export interface operations {
             };
         };
     };
+    getOrgReconciliation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The org’s open divergences, newest first — each carrying both sides, the winning tier and the human-readable reason (contracts OrgReconciliationLedger) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    resolveOrgDivergence: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                divergenceId: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ResolveOrgDivergenceRequest"];
+            };
+        };
+        responses: {
+            /** @description The acknowledgement, with sentToSource pinned false (contracts ResolveOrgDivergenceResult) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No open divergence with that id — it belongs to another workspace, a later statement superseded it, or it has since been settled */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     getCompanyMdTree: {
         parameters: {
             query?: {
@@ -10848,17 +10910,10 @@ export interface operations {
         requestBody: {
             content: {
                 "application/json": {
-                    manager: ({
-                        /** @constant */
-                        kind: "member";
-                        /** Format: uuid */
-                        userId: string;
-                    } | {
-                        /** @constant */
-                        kind: "open-role";
+                    manager: {
                         /** Format: uuid */
-                        openRoleId: string;
-                    }) | null;
+                        positionId: string;
+                    } | null;
                 };
             };
         };

package/src/generated/openapi-routes.ts

@@ -138,6 +138,8 @@ export const openApiRoutes = {
   '/api/org/cancel-deletion': ['POST'],
   '/api/org/delete': ['POST'],
   '/api/org/deletion-eligibility': ['GET'],
+  '/api/org/reconciliation': ['GET'],
+  '/api/org/reconciliation/divergences/{divergenceId}/resolution': ['POST'],
   '/api/org/system-events': ['GET'],
   '/api/org/system-events/{id}/acknowledge': ['POST'],
   '/api/org/transfer-eligibility': ['GET'],
@@ -154,6 +156,7 @@ export const openApiRoutes = {
   '/api/rbac/roles': ['GET'],
   '/api/reporting/move/apply': ['POST'],
   '/api/reporting/move/preview': ['POST'],
+  '/api/reporting/positions/{positionId}/manager': ['PUT'],
   '/api/scope/check': ['GET'],
   '/api/scope/check-batch': ['POST'],
   '/api/shared/{token}': ['GET'],
@@ -192,7 +195,6 @@ export const openApiRoutes = {
   '/api/workspace/invites/{id}': ['DELETE'],
   '/api/workspace/members': ['GET'],
   '/api/workspace/members/{id}': ['DELETE', 'GET'],
-  '/api/workspace/members/{id}/manager': ['DELETE', 'PATCH'],
   '/api/workspace/members/{id}/role': ['PATCH'],
   '/api/workspace/name': ['PATCH'],
   '/api/workspace/organization': ['PATCH'],

package/src/identity/README.md

@@ -49,8 +49,6 @@ TypeScript types and functions for user identity and display name resolution.
 - `MeResponse` _(type)_
 - `MeResponseSchema` — Full identity context returned by GET /api/me.
 - `NameSource` _(type)_ — Source of the user's name data.
-- `OrgChartActorRef` _(type)_
-- `OrgChartActorRefSchema`
 - `PeopleOrgChartOwnedUnit` _(type)_
 - `PeopleOrgChartOwnedUnitSchema`
 - `PeopleOrgChartResponse` _(type)_
@@ -65,6 +63,8 @@ TypeScript types and functions for user identity and display name resolution.
 - `PeopleOrgChartSeatStatusSchema`
 - `Person` _(type)_
 - `PersonSchema`
+- `PositionRef` _(type)_
+- `PositionRefSchema` — A reference to a POSITION in the org graph.
 - `ProfileResponse` _(type)_
 - `ProfileResponseSchema`
 - `ReportingRelationshipType` _(type)_

package/src/identity/__tests__/people-org-chart.test.ts

@@ -51,25 +51,60 @@ describe("PeopleOrgChartSeatOccupantSchema", () => {
 });
 
 describe("PeopleOrgChartSeatSchema", () => {
+  const filledSeat = {
+    id: POSITION_ID,
+    unitId: UNIT_ID,
+    title: "Analyst",
+    status: "filled",
+    hiring: false,
+    occupants: [
+      {
+        personId: PERSON_ID,
+        userId: null,
+        fullName: "Ada Lovelace",
+        avatarUrl: null,
+        primaryUnitId: null,
+        ownedUnits: [],
+      },
+    ],
+    integrity: null,
+  };
+
   it("admits a filled seat whose only occupant is accountless", () => {
-    const seat = PeopleOrgChartSeatSchema.parse({
-      id: POSITION_ID,
-      unitId: UNIT_ID,
-      title: "Analyst",
-      status: "filled",
-      hiring: false,
-      occupants: [
-        {
-          personId: PERSON_ID,
-          userId: null,
-          fullName: "Ada Lovelace",
-          avatarUrl: null,
-          primaryUnitId: null,
-          ownedUnits: [],
-        },
-      ],
-    });
+    const seat = PeopleOrgChartSeatSchema.parse(filledSeat);
     expect(seat.occupants).toHaveLength(1);
     expect(seat.occupants[0]?.userId).toBeNull();
+    expect(seat.integrity).toBeNull();
+  });
+
+  // The marker is what separates a breached seat from a vacancy: both carry
+  // `occupants: []`, so a consumer reading only the occupant list would offer
+  // to fill a seat whose holder the server deliberately withheld.
+  it("admits a seat whose withheld holder is flagged as a placement conflict", () => {
+    const seat = PeopleOrgChartSeatSchema.parse({
+      ...filledSeat,
+      occupants: [],
+      integrity: "canonical_placement_conflict",
+    });
+    expect(seat.integrity).toBe("canonical_placement_conflict");
+  });
+
+  // .nullable() WITHOUT .optional(), for the same reason as occupant.userId:
+  // the server always emits the key, so "no marker" must be spelled null rather
+  // than left to an absent field a consumer would read as healthy by default.
+  it("rejects an absent integrity — nullable is not optional", () => {
+    const { integrity: _omitted, ...withoutIntegrity } = filledSeat;
+    expect(PeopleOrgChartSeatSchema.safeParse(withoutIntegrity).success).toBe(
+      false,
+    );
+  });
+
+  it("rejects an unknown integrity marker", () => {
+    expect(
+      PeopleOrgChartSeatSchema.safeParse({
+        ...filledSeat,
+        integrity: "something_else",
+      }).success,
+    ).toBe(false);
   });
 });

package/src/identity/__tests__/position-ref.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+
+import { PositionRefSchema } from "../position-ref.js";
+
+const POSITION_ID = "11111111-1111-4111-8111-111111111111";
+const USER_ID = "22222222-2222-4222-8222-222222222222";
+
+describe("PositionRefSchema", () => {
+  it("accepts a reference carrying a uuid positionId", () => {
+    expect(PositionRefSchema.parse({ positionId: POSITION_ID })).toEqual({
+      positionId: POSITION_ID,
+    });
+  });
+
+  it("rejects a non-uuid positionId", () => {
+    expect(PositionRefSchema.safeParse({ positionId: "seat-1" }).success).toBe(
+      false,
+    );
+  });
+
+  it("rejects an absent positionId", () => {
+    expect(PositionRefSchema.safeParse({}).success).toBe(false);
+  });
+
+  // The retired OrgChartActorRef union spelled a filled seat as
+  // `{ kind: 'member', userId }`. Nothing in the write vocabulary speaks that
+  // shape any more: a user id is not a way to name a chart actor, because most
+  // people in an org graph have no account at all.
+  it("does not admit the retired member arm — a userId is not a position", () => {
+    const result = PositionRefSchema.safeParse({
+      kind: "member",
+      userId: USER_ID,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  // Not strict(): unknown keys are stripped rather than rejected, matching the
+  // rest of the identity vocabulary.
+  it("strips unknown keys rather than rejecting them", () => {
+    expect(
+      PositionRefSchema.parse({ positionId: POSITION_ID, kind: "open-role" }),
+    ).toEqual({ positionId: POSITION_ID });
+  });
+});

package/src/identity/index.ts

@@ -64,7 +64,6 @@ export type {
 // People Org Chart (GET /api/users/org-chart)
 export {
   ReportingRelationshipTypeSchema,
-  OrgChartActorRefSchema,
   PeopleOrgChartOwnedUnitSchema,
   PeopleOrgChartSeatStatusSchema,
   PeopleOrgChartSeatOccupantSchema,
@@ -74,7 +73,6 @@ export {
 } from "./people-org-chart";
 export type {
   ReportingRelationshipType,
-  OrgChartActorRef,
   PeopleOrgChartOwnedUnit,
   PeopleOrgChartSeatStatus,
   PeopleOrgChartSeatOccupant,
@@ -83,6 +81,12 @@ export type {
   PeopleOrgChartResponse,
 } from "./people-org-chart";
 
+// Position Ref — the single org-graph WRITE reference (ADR-CONTRACTS-131).
+// Not chart vocabulary: three write schemas outside the chart speak it, which
+// is why it is named for the Position and exported from its own module.
+export { PositionRefSchema } from "./position-ref";
+export type { PositionRef } from "./position-ref";
+
 // Person — the org-graph node for a human (0..1 User link), per ADR-CTRL-182
 export { PersonSchema } from "./person";
 export type { Person } from "./person";

package/src/identity/people-org-chart.ts

@@ -7,7 +7,10 @@
  * The chart is position-centric (ADR-CONT-093/094): every actor is a `seat`
  * (a `positions` row) carrying its seat-scoped attributes plus an `occupants[]`
  * array; reporting is expressed seat→seat in `seatEdges[]`. A VACANT seat (no
- * occupants) is the old "open role"; an OCCUPIED seat is the old "member".
+ * occupants AND a null `integrity` marker) is the old "open role"; an OCCUPIED
+ * seat is the old "member". A seat whose `integrity` marker is set is neither:
+ * its holder exists but was withheld, so it must never be offered as an open
+ * role.
  *
  * Person-level reporting is intentionally distinct from
  * `org_unit_relationships.type = 'reports_to'` (unit-to-unit graph overlay,
@@ -25,14 +28,6 @@ export type ReportingRelationshipType = z.infer<
   typeof ReportingRelationshipTypeSchema
 >;
 
-// Actor reference (member | open-role). Retained WRITE-ONLY: the set-manager
-// request/response (`org/schemas`) still speaks this vocabulary; the read model
-// is now seat→seat (ADR-CONT-094) and no longer references it. Defined in its
-// own zero-dependency module to avoid a module-init cycle with `org/schemas`,
-// and re-exported here so the existing barrel import site keeps working.
-export { OrgChartActorRefSchema } from "./org-chart-actor";
-export type { OrgChartActorRef } from "./org-chart-actor";
-
 // ---------------------------------------------------------------------------
 // Owned unit — shared by the seat occupant (below)
 // ---------------------------------------------------------------------------
@@ -67,13 +62,14 @@ export type PeopleOrgChartOwnedUnit = z.infer<
 // its SEAT-SCOPED attributes (unit placement, title, seat-existence status,
 // hiring/staffing sub-state) plus an `occupants[]` array of PERSON-SCOPED
 // attributes for whoever currently holds it. The split is structural, not
-// member-vs-open-role: a VACANT seat (`occupants: []`) is the old "open role";
+// member-vs-open-role: a VACANT seat (`occupants: []` with `integrity: null`)
+// is the old "open role";
 // an OCCUPIED seat (`occupants.length >= 1`) is the old "member" (N occupants
 // for a co-occupied seat — forward-compatible; live data is 0/1). Reporting is
 // expressed seat→seat in `seatEdges[]`, NOT on the seat, so the edge list stays
-// the single source of truth for placement (ADR-CTRL-159). `OrgChartActorRef`
-// is retained write-only (set-manager request/response) and is absent from this
-// read model.
+// the single source of truth for placement (ADR-CTRL-159). The write model
+// names the same actors with a `PositionRef` (`identity/position-ref`), so read
+// and write now agree that a chart actor IS a position.
 //
 // `seats[]` + `seatEdges[]` are now the ONLY shape — the legacy
 // `nodes`/`edges`/`openRoles` half was removed in ADR-CONT-094 (breaking).
@@ -144,7 +140,22 @@ export const PeopleOrgChartSeatSchema = z.object({
   // The seat's current holders. [] ⇒ vacant (the old "open role"); >= 1 ⇒
   // occupied (the old "member"). Every canonical occupant appears, account or
   // not — occupancy, not account linkage, is what admits a person here.
+  //
+  // READ WITH `integrity` BELOW: `occupants: []` means vacant ONLY when
+  // `integrity` is null.
   occupants: z.array(PeopleOrgChartSeatOccupantSchema),
+  // Structural integrity of the OCCUPANT LIST above. null ⇒ the list is
+  // complete and `occupants: []` is a true vacancy.
+  //
+  // `canonical_placement_conflict` ⇒ at least one person holding this seat was
+  // WITHHELD from `occupants` because they hold more than one live canonical
+  // placement (ADR-BE-559). The projector refuses to bless one of the
+  // conflicting placements, so the seat renders with its holder unnamed — and
+  // an EMPTY `occupants` on such a seat is NOT a vacancy. A consumer must not
+  // offer to fill, staff, or reorg a flagged seat as an open role: the seat has
+  // a holder the server declines to name, and the breach is recorded
+  // server-side as `org_chart.canonical_placement_conflict`.
+  integrity: z.enum(["canonical_placement_conflict"]).nullable(),
 });
 
 export type PeopleOrgChartSeat = z.infer<typeof PeopleOrgChartSeatSchema>;
@@ -152,8 +163,8 @@ export type PeopleOrgChartSeat = z.infer<typeof PeopleOrgChartSeatSchema>;
 // A seat→seat reporting edge — one row per `position_reporting` row (NOT a
 // member cross-product). Endpoints are positionIds; resolve each to its seat in
 // `seats[]`. Mirrors the legacy person-keyed `PeopleOrgChartEdge`, but keyed by
-// the stable seat identity so a vacant seat's edge is expressible without an
-// `OrgChartActorRef`.
+// the stable seat identity so a vacant or accountless seat's edge is
+// expressible at all — the same identity the write model spells `PositionRef`.
 export const PeopleOrgChartSeatEdgeSchema = z.object({
   reportPositionId: z.string().uuid(),
   managerPositionId: z.string().uuid(),

package/src/identity/position-ref.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+/**
+ * A reference to a POSITION in the org graph.
+ *
+ * Replaces the two-arm OrgChartActorRef union, which was already degenerate:
+ * `openRoleId` WAS a positions.id, and `{ kind:'member', userId }` was only a
+ * slow way to name a seat -- every consumer immediately resolved it through
+ * `resolveSeat`. Once occupants are person-keyed the `member` arm has no
+ * definition at all, because most people in an org graph have no account.
+ *
+ * Named PositionRef, not OrgChartSeatRef: it is consumed by the member-manager
+ * schema, the open-role reports-to schema and the reporting route, so it
+ * already spreads well past the chart. The thing referenced is a Position.
+ *
+ * An OBJECT rather than a bare uuid so `{ manager: PositionRef | null }` keeps
+ * `null` meaning "clear", the field name says what the uuid is, and future edge
+ * attributes have a home.
+ *
+ * Zero-dependency (zod only) to avoid the module-init cycle that caused the
+ * original actor-ref file to be split out.
+ */
+export const PositionRefSchema = z.object({ positionId: z.string().uuid() });
+export type PositionRef = z.infer<typeof PositionRefSchema>;

package/src/index.ts

@@ -175,7 +175,6 @@ export type {
 // People Org Chart (GET /api/users/org-chart)
 export {
   ReportingRelationshipTypeSchema,
-  OrgChartActorRefSchema,
   PeopleOrgChartOwnedUnitSchema,
   PeopleOrgChartSeatStatusSchema,
   PeopleOrgChartSeatOccupantSchema,
@@ -185,7 +184,6 @@ export {
 } from "./identity/index";
 export type {
   ReportingRelationshipType,
-  OrgChartActorRef,
   PeopleOrgChartOwnedUnit,
   PeopleOrgChartSeatStatus,
   PeopleOrgChartSeatOccupant,
@@ -194,6 +192,10 @@ export type {
   PeopleOrgChartResponse,
 } from "./identity/index";
 
+// Position Ref — the single org-graph WRITE reference (ADR-CONTRACTS-131)
+export { PositionRefSchema } from "./identity/index";
+export type { PositionRef } from "./identity/index";
+
 // Person — the org-graph node for a human (0..1 User link), per ADR-CTRL-182
 export { PersonSchema } from "./identity/index";
 export type { Person } from "./identity/index";
@@ -681,6 +683,23 @@ export type {
   OrgStructureInferenceDecisionResult,
 } from "./org/index";
 
+// Org reconciliation ledger: the org's STANDING disagreements with the connected
+// HRIS — the open ones only, sync-time (runId set) and app-time (runId null)
+// alike. Complements the run-scoped conflicts view rather than replacing it, and
+// resolution is a LOCAL decision only. (ADR-BE-564)
+export {
+  OrgDivergenceSchema,
+  OrgReconciliationLedgerSchema,
+  OrgDivergenceResolutionSchema,
+  ResolveOrgDivergenceResultSchema,
+} from "./org/index";
+export type {
+  OrgDivergence,
+  OrgReconciliationLedger,
+  OrgDivergenceResolution,
+  ResolveOrgDivergenceResult,
+} from "./org/index";
+
 // Org transformation wire vocabulary: intent -> simulation -> preview. The
 // engine turns a TransformationRequest into scored mutation bundles and returns
 // a TransformationPreview the operator confirms before apply. (ADR-CONTRACTS-072)

package/src/org/README.md

@@ -178,6 +178,10 @@ Shared type vocabulary for organization ownership, type classification, and tran
 - `OrgBudgetConfigSchema`
 - `OrgDeletionStatus` _(type)_
 - `OrgDeletionStatusSchema`
+- `OrgDivergence` _(type)_
+- `OrgDivergenceResolution` _(type)_
+- `OrgDivergenceResolutionSchema` — What resolving a divergence means today.
+- `OrgDivergenceSchema`
 - `OrgDomain` _(type)_ — Organization domain claim and verification status.
 - `OrgIntent` _(type)_
 - `OrgIntentSchema` — A requested org-graph change expressed as intent.
@@ -191,6 +195,8 @@ Shared type vocabulary for organization ownership, type classification, and tran
 - `OrgLevelIconSchema`
 - `OrgOwnerIcon` _(type)_
 - `OrgOwnerIconSchema` — Icon options for the `owner` org-chart role.
+- `OrgReconciliationLedger` _(type)_
+- `OrgReconciliationLedgerSchema`
 - `OrgScopedContext` _(type)_ — Validated organization-scoped context for policy implementations.
 - `OrgStructureInferenceDecisionResult` _(type)_
 - `OrgStructureInferenceDecisionResultSchema`
@@ -282,6 +288,8 @@ Shared type vocabulary for organization ownership, type classification, and tran
 - `RemoveMemberRequest` _(type)_ — Request payload for removing a member from the workspace.
 - `RemoveMemberResponse` _(type)_
 - `RemoveMemberResponseSchema`
+- `ResolveOrgDivergenceResult` _(type)_
+- `ResolveOrgDivergenceResultSchema`
 - `RoleCatalogEntry` _(type)_ — Entry in the RBAC roles catalog (GET /api/rbac/roles).
 - `RoleCatalogEntrySchema`
 - `RoleCatalogResponseSchema`
@@ -293,8 +301,8 @@ Shared type vocabulary for organization ownership, type classification, and tran
 - `SelectionRationaleSchema`
 - `SetActiveOrgResponse` _(type)_
 - `SetActiveOrgResponseSchema`
-- `SetMemberManagerResponse` _(type)_
-- `SetMemberManagerResponseSchema` — Response for setting (PATCH) or clearing (DELETE) a member's solid-line manager — the reporting edge that the…
+- `SetSeatManagerResponse` _(type)_
+- `SetSeatManagerResponseSchema` — Response for the one idempotent set-or-clear of a seat's solid-line manager — the reporting edge the org…
 - `SharePolicy` _(type)_ — Document sharing policy. - restricted: Only explicit ACL + owning unit + org admins - orgread: All org…
 - `ShareState` _(type)_ — Complete sharing state for a document.
 - `SourceAuthority` _(type)_

package/src/org/__tests__/org-units.test.ts

@@ -129,7 +129,7 @@ describe("OpenRoleSchema", () => {
     targetStartDate: "2026-09-01",
     status: "open",
     filledByUserId: null,
-    reportsToUserId: null,
+    reportsToPositionId: null,
     createdAt: "2026-04-17T00:00:00Z",
     updatedAt: "2026-04-17T00:00:00Z",
     ...overrides,

package/src/org/__tests__/set-seat-manager.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect } from "vitest";
+import {
+  SetSeatManagerResponseSchema,
+  WorkspaceMemberDetailSchema,
+  WorkspaceMembersResponseSchema,
+  OpenRoleSchema,
+} from "../schemas.js";
+
+const REPORT_POSITION_ID = "11111111-1111-4111-8111-111111111111";
+const MANAGER_POSITION_ID = "22222222-2222-4222-8222-222222222222";
+const USER_ID = "33333333-3333-4333-8333-333333333333";
+const UNIT_ID = "44444444-4444-4444-8444-444444444444";
+const ORG_ID = "55555555-5555-4555-8555-555555555555";
+const ROLE_ID = "66666666-6666-4666-8666-666666666666";
+
+const makeResponse = (overrides: Record<string, unknown> = {}) => ({
+  success: true,
+  reportPositionId: REPORT_POSITION_ID,
+  manager: { positionId: MANAGER_POSITION_ID },
+  relationshipType: "solid",
+  message: "Reporting line updated.",
+  ...overrides,
+});
+
+describe("SetSeatManagerResponseSchema", () => {
+  it("accepts a position-keyed set and a position-keyed clear", () => {
+    expect(() =>
+      SetSeatManagerResponseSchema.parse(makeResponse()),
+    ).not.toThrow();
+    expect(() =>
+      SetSeatManagerResponseSchema.parse(
+        makeResponse({ manager: null, message: "Reporting line cleared." }),
+      ),
+    ).not.toThrow();
+  });
+
+  it("requires reportPositionId to be a uuid, not an opaque member id", () => {
+    expect(
+      SetSeatManagerResponseSchema.safeParse(
+        makeResponse({ reportPositionId: "member-1" }),
+      ).success,
+    ).toBe(false);
+  });
+
+  // The whole point of the literal: this route rides
+  // setSolidManagerByPositions, which only ever writes a solid edge. A wider
+  // relationship vocabulary here would promise a dotted-line write the route
+  // cannot perform.
+  it("rejects any relationshipType other than the solid literal", () => {
+    expect(
+      SetSeatManagerResponseSchema.safeParse(
+        makeResponse({ relationshipType: "dotted" }),
+      ).success,
+    ).toBe(false);
+  });
+
+  // The retired shape named the subordinate by user (`memberId`) and the
+  // manager by a member-or-open-role union. Neither survives: a stray memberId
+  // is stripped, and it cannot stand in for the report seat.
+  it("does not admit the retired memberId key as the report reference", () => {
+    expect(
+      SetSeatManagerResponseSchema.parse(makeResponse({ memberId: USER_ID })),
+    ).toEqual(makeResponse());
+    const { reportPositionId: _dropped, ...withoutReport } = makeResponse();
+    expect(
+      SetSeatManagerResponseSchema.safeParse({
+        ...withoutReport,
+        memberId: USER_ID,
+      }).success,
+    ).toBe(false);
+  });
+
+  it("rejects a manager named by userId rather than positionId", () => {
+    expect(
+      SetSeatManagerResponseSchema.safeParse(
+        makeResponse({ manager: { kind: "member", userId: USER_ID } }),
+      ).success,
+    ).toBe(false);
+  });
+});
+
+const makeMember = (overrides: Record<string, unknown> = {}) => ({
+  id: USER_ID,
+  name: "Ada Lovelace",
+  email: "ada@example.com",
+  jobTitle: "Principal Engineer",
+  seatPositionId: REPORT_POSITION_ID,
+  role: null,
+  roleNames: [],
+  joinedAt: "2026-04-17T00:00:00Z",
+  lastActiveAt: null,
+  primaryUnitId: UNIT_ID,
+  unitMemberships: [],
+  unitDesignations: [],
+  unitMembershipsTruncated: false,
+  inviteStatus: "active",
+  ...overrides,
+});
+
+describe("WorkspaceMember seatPositionId", () => {
+  it("carries the seat on the list shape, so a READ resolves it", () => {
+    expect(() =>
+      WorkspaceMembersResponseSchema.parse({
+        items: [makeMember()],
+        nextCursor: null,
+        hasMore: false,
+      }),
+    ).not.toThrow();
+  });
+
+  it("is inherited by the detail shape", () => {
+    expect(() =>
+      WorkspaceMemberDetailSchema.parse({
+        ...makeMember(),
+        effectiveScopes: [],
+        recentActions: [],
+      }),
+    ).not.toThrow();
+  });
+
+  // Null is a real state — a member with no materialized seat. The read reports
+  // it honestly rather than forcing the server to mint one.
+  it("accepts null for a member with no materialized seat", () => {
+    expect(() =>
+      WorkspaceMemberDetailSchema.parse({
+        ...makeMember({ seatPositionId: null }),
+        effectiveScopes: [],
+        recentActions: [],
+      }),
+    ).not.toThrow();
+  });
+
+  it("is required — a member shape without it no longer parses", () => {
+    const { seatPositionId: _dropped, ...withoutSeat } = makeMember();
+    expect(
+      WorkspaceMemberDetailSchema.safeParse({
+        ...withoutSeat,
+        effectiveScopes: [],
+        recentActions: [],
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("OpenRole reportsToPositionId", () => {
+  const makeOpenRole = (overrides: Record<string, unknown> = {}) => ({
+    id: ROLE_ID,
+    orgId: ORG_ID,
+    unitId: UNIT_ID,
+    title: "Senior Engineer",
+    targetStartDate: null,
+    status: "open",
+    filledByUserId: null,
+    reportsToPositionId: MANAGER_POSITION_ID,
+    createdAt: "2026-04-17T00:00:00Z",
+    updatedAt: "2026-04-17T00:00:00Z",
+    ...overrides,
+  });
+
+  it("names the manager by position, and null still means unmanaged", () => {
+    expect(() => OpenRoleSchema.parse(makeOpenRole())).not.toThrow();
+    expect(() =>
+      OpenRoleSchema.parse(makeOpenRole({ reportsToPositionId: null })),
+    ).not.toThrow();
+  });
+
+  // The retired reportsToUserId flattening read null whenever the manager had
+  // no account — which, post-HRIS, is nearly every manager.
+  it("no longer accepts the retired reportsToUserId flattening", () => {
+    const { reportsToPositionId: _dropped, ...withoutPosition } =
+      makeOpenRole();
+    expect(
+      OpenRoleSchema.safeParse({ ...withoutPosition, reportsToUserId: USER_ID })
+        .success,
+    ).toBe(false);
+  });
+});

package/src/org/index.ts

@@ -150,6 +150,24 @@ export type {
   OrgStructureInferenceDecisionResult,
 } from "./reasoning-review";
 
+// Org reconciliation ledger: the org's STANDING disagreements with the connected
+// HRIS — the open ones only, whether they arose during a sync (runId set) or
+// during app use (runId null). Complements the run-scoped conflicts view; does
+// not replace it. Resolution is a LOCAL decision (`sentToSource` is the literal
+// false). (ADR-BE-564)
+export {
+  OrgDivergenceSchema,
+  OrgReconciliationLedgerSchema,
+  OrgDivergenceResolutionSchema,
+  ResolveOrgDivergenceResultSchema,
+} from "./reconciliation";
+export type {
+  OrgDivergence,
+  OrgReconciliationLedger,
+  OrgDivergenceResolution,
+  ResolveOrgDivergenceResult,
+} from "./reconciliation";
+
 // Org transformation wire vocabulary: intent -> simulation -> preview. The
 // engine turns a TransformationRequest into scored mutation bundles and returns
 // a TransformationPreview the operator confirms before apply. (ADR-CONTRACTS-072)
@@ -296,7 +314,7 @@ export {
   TestSsoResultSchema,
   RemoveMemberResponseSchema,
   ChangeMemberRoleResponseSchema,
-  SetMemberManagerResponseSchema,
+  SetSeatManagerResponseSchema,
   SubmitInteractiveTaskResponseSchema,
   UserOrgsResponseSchema,
   SetActiveOrgResponseSchema,
@@ -321,7 +339,7 @@ export type {
   TestSsoResult as TestSsoResultDto,
   RemoveMemberResponse,
   ChangeMemberRoleResponse,
-  SetMemberManagerResponse,
+  SetSeatManagerResponse,
   SubmitInteractiveTaskResponse,
   UserOrgsResponse,
   SetActiveOrgResponse,

package/src/org/reconciliation.ts

@@ -0,0 +1,162 @@
+/**
+ * Org reconciliation ledger — what this workspace currently disagrees with the
+ * connected HRIS about.
+ *
+ * A {@link ConflictRecordSchema} row is the audit trail of ONE reconciliation
+ * event. The ledger is the standing view over those rows: for each contested
+ * `(entityType, entityId, field)` it keeps the workspace's CURRENT word and
+ * drops the ones the two sides have since agreed on. It answers "what is still
+ * open?", where the run-scoped conflicts view answers "what did THIS run
+ * refuse?" — the two coexist and neither replaces the other (ADR-BE-564).
+ *
+ * `runId` is NULLABLE here, and that is the whole reason this is a separate
+ * shape rather than a reuse of `ConflictRecordSchema` (whose `runId` is
+ * required). A divergence can arise OUTSIDE a sync run — at invite acceptance,
+ * or from a canonical-placement integrity breach — and such a row is deliberately
+ * not tied to a run, so it neither disappears when the run is pruned nor
+ * multiplies once per sync.
+ *
+ * Like the sibling org schemas, `entityType` and `field` are OPEN strings (no
+ * enum) so new contested kinds need no schema change, and `winningTier` REUSES
+ * the closed {@link FactSourceTierSchema} precedence axis rather than redefining
+ * it. Both competing values are serialized as strings and are nullable, because
+ * either side may hold no value.
+ *
+ * ## Resolution is LOCAL, always
+ *
+ * {@link ResolveOrgDivergenceResultSchema} is the seam a later write-back phase
+ * plugs into, and it is shaped so that phase cannot arrive by accident:
+ * `sentToSource` is the literal `false`, so any surface claiming a divergence
+ * was pushed upstream fails to typecheck against this contract. Today the HRIS
+ * client is read-only (directory + changed-since over a hardcoded GET) and no
+ * write scope is requested at connect time. Resolving a divergence records a
+ * decision in THIS workspace; nothing may state or imply the HRIS was updated.
+ *
+ * Resolving therefore does NOT close a divergence: the two sides still hold
+ * different values, so the entry stays in the ledger and carries
+ * `acknowledgedAt`. A shape that dropped it on resolution would let a click hide
+ * a live disagreement — the failure this ledger exists to prevent. What DOES
+ * remove an entry is the two sides agreeing.
+ */
+import { z } from "zod";
+
+import { FactSourceTierSchema } from "./structure-facts";
+
+// ---------------------------------------------------------------------------
+// OrgDivergence — one open disagreement between the HRIS and this workspace
+// ---------------------------------------------------------------------------
+
+export const OrgDivergenceSchema = z.object({
+  /** Identifier of the ledger row carrying the workspace's current word. */
+  id: z.string().uuid(),
+  /**
+   * The sync run that observed this disagreement, when one did. `null` marks a
+   * STANDING divergence recorded outside any run (invite acceptance, a
+   * canonical-placement integrity breach).
+   */
+  runId: z.string().uuid().nullable(),
+  /**
+   * Kind of org-graph entity the contested field belongs to (e.g. "person",
+   * "position", "occupancy"). An OPEN string so new entity kinds need no schema
+   * change.
+   */
+  entityType: z.string().min(1),
+  /** Identifier of the specific entity instance in disagreement. */
+  entityId: z.string().uuid(),
+  /** Name of the single contested field. */
+  field: z.string().min(1),
+  /**
+   * What the HRIS asserts for this field, serialized as a string. `null` when
+   * the imported side carries no value.
+   */
+  importedValue: z.string().nullable(),
+  /**
+   * What this workspace currently holds for this field, serialized as a string.
+   * `null` when the workspace holds no value.
+   */
+  currentValue: z.string().nullable(),
+  /**
+   * The value in force, serialized as a string. `null` when the resolution left
+   * the field empty.
+   */
+  winningValue: z.string().nullable(),
+  /**
+   * The precedence tier of the value in force — the same closed truth-hierarchy
+   * axis used across the org model. Reused, not redefined.
+   */
+  winningTier: FactSourceTierSchema,
+  /**
+   * The sentence a human reads: it names BOTH sides and why the winner won.
+   * Capped at 2000 chars to mirror `ConflictRecord.reason`. `null` when the row
+   * was recorded without a narrative.
+   */
+  reason: z.string().max(2000).nullable(),
+  /** ISO timestamp the workspace's current word on this field was recorded. */
+  recordedAt: z.string().datetime(),
+  /**
+   * ISO timestamp someone in this workspace ACKNOWLEDGED this entry, or `null`.
+   *
+   * A triage marker, not a resolution: the two sides still differ and nothing
+   * was sent to the HRIS, so the entry is still open and still listed. It is
+   * keyed to THIS row, so a disagreement that moves — a superseding row becomes
+   * the entry — arrives unacknowledged, which is the right default for a
+   * statement nobody has read yet.
+   */
+  acknowledgedAt: z.string().datetime().nullable(),
+  /** Who acknowledged it. `null` when nobody has, or when that user is gone. */
+  acknowledgedByUserId: z.string().uuid().nullable(),
+});
+
+export type OrgDivergence = z.infer<typeof OrgDivergenceSchema>;
+
+// ---------------------------------------------------------------------------
+// OrgReconciliationLedger — the org's open divergences, newest first
+// ---------------------------------------------------------------------------
+
+export const OrgReconciliationLedgerSchema = z.object({
+  /**
+   * The org's still-open divergences, newest first. One entry per contested
+   * `(entityType, entityId, field)`; settled disagreements are omitted.
+   */
+  divergences: z.array(OrgDivergenceSchema),
+});
+
+export type OrgReconciliationLedger = z.infer<
+  typeof OrgReconciliationLedgerSchema
+>;
+
+// ---------------------------------------------------------------------------
+// Resolution — a LOCAL decision, never an upstream write
+// ---------------------------------------------------------------------------
+
+/**
+ * What resolving a divergence means today. `acknowledged` records that someone
+ * in this workspace has seen and accepted the disagreement; it does not, and
+ * cannot, change anything in the HRIS.
+ */
+export const OrgDivergenceResolutionSchema = z.enum(["acknowledged"]);
+
+export type OrgDivergenceResolution = z.infer<
+  typeof OrgDivergenceResolutionSchema
+>;
+
+export const ResolveOrgDivergenceResultSchema = z.object({
+  /** Identifier of the divergence that was resolved. */
+  id: z.string().uuid(),
+  /** How it was resolved. Local decisions only — see the module docblock. */
+  resolution: OrgDivergenceResolutionSchema,
+  /** ISO timestamp the decision was recorded in this workspace. */
+  resolvedAt: z.string().datetime(),
+  /**
+   * Whether anything was written back to the source system. Pinned to the
+   * literal `false`: the HRIS client is read-only and no write scope is
+   * requested, so a surface that claims otherwise cannot typecheck against this
+   * contract. A future write-back phase widens this deliberately, in its own
+   * decision record — not by accident.
+   */
+  sentToSource: z.literal(false),
+});
+
+export type ResolveOrgDivergenceResult = z.infer<
+  typeof ResolveOrgDivergenceResultSchema
+>;

package/src/org/schemas.ts

@@ -13,7 +13,7 @@
 import { z } from "zod";
 import { CursorPageSchema } from "../api/primitives";
 import { OrgChartRoleSchema } from "../permissions/orgchart-roles";
-import { OrgChartActorRefSchema } from "../identity/org-chart-actor";
+import { PositionRefSchema } from "../identity/position-ref";
 
 // ---------------------------------------------------------------------------
 // Sub-schemas
@@ -90,6 +90,17 @@ const WorkspaceMemberSchema = z.object({
   avatarUrl: z.string().nullable().optional(),
   /** The occupant's Position seat title (org-scoped). Null when the seat is untitled. */
   jobTitle: z.string().nullable(),
+  /**
+   * The member's Position seat in the org graph — the id every reporting write
+   * is keyed on (ADR-CONTRACTS-131). Present here so a user-ADDRESSED surface
+   * (the members table, a person picker) can resolve a seat by READ and hand
+   * the position straight to `PUT /api/reporting/positions/{positionId}/manager`,
+   * instead of a write path minting one with `resolveSeat(create: true)`.
+   *
+   * Nullable: a member with no materialized seat is a legitimate state, and a
+   * read must report that honestly rather than force the server to create one.
+   */
+  seatPositionId: z.string().uuid().nullable(),
   /**
    * Display role — the member's highest org-chart standing, or `null` for a
    * plain member with no org-chart authority. Render via `orgChartRoleLabel`.
@@ -524,30 +535,39 @@ export type ChangeMemberRoleResponse = z.infer<
 >;
 
 // ---------------------------------------------------------------------------
-// PATCH/DELETE /api/workspace/members/:id/manager
+// PUT /api/reporting/positions/:positionId/manager
 // ---------------------------------------------------------------------------
 
 /**
- * Response for setting (PATCH) or clearing (DELETE) a member's solid-line
- * manager — the reporting edge that the org chart is built from. `manager` is
- * the actor the member now reports to: a `member` (person→person) OR an
- * `open-role` seat (person reports to a vacant role — ADR-BE-312); null after a
- * clear.
+ * Response for the one idempotent set-or-clear of a seat's solid-line manager —
+ * the reporting edge the org chart is built from. Position-keyed at BOTH ends
+ * (ADR-CONTRACTS-131): `reportPositionId` is the seat whose edge moved and
+ * `manager` is the POSITION it now reports to, null after a clear. A position
+ * names a vacant seat and an accountless occupant's seat just as well as a
+ * filled one, which the retired member-or-open-role union could not.
+ *
+ * `relationshipType` is a literal rather than the identity-domain
+ * `ReportingRelationshipTypeSchema`: importing that here would invert the
+ * existing people-org-chart → org/schemas dependency and recreate the
+ * module-init cycle. This route only ever writes solid edges, so the narrower
+ * literal is also the truthful shape. (`PositionReportingRelationshipTypeSchema`
+ * in ./position-reporting carries the open {solid, dotted} vocabulary for the
+ * read model.)
  *
  * Distinct from team membership (RBAC scopes) and `primary_unit_id` (home
  * unit): neither of those places a person in the reporting hierarchy.
  * See ADR-BE-253.
  */
-export const SetMemberManagerResponseSchema = z.object({
+export const SetSeatManagerResponseSchema = z.object({
   success: z.boolean(),
-  memberId: z.string(),
-  manager: OrgChartActorRefSchema.nullable(),
-  relationshipType: z.string(),
+  reportPositionId: z.string().uuid(),
+  manager: PositionRefSchema.nullable(),
+  relationshipType: z.literal("solid"),
   message: z.string(),
 });
 
-export type SetMemberManagerResponse = z.infer<
-  typeof SetMemberManagerResponseSchema
+export type SetSeatManagerResponse = z.infer<
+  typeof SetSeatManagerResponseSchema
 >;
 
 // ---------------------------------------------------------------------------
@@ -1134,10 +1154,16 @@ export const OpenRoleSchema = z.object({
   targetStartDate: z.string().nullable(),
   status: OpenRoleStatusSchema,
   filledByUserId: z.string().uuid().nullable(),
-  // The open role's own reporting edge (ADR-BE-291): defaults to its creator,
-  // editable/clearable. Drives chart placement now that the unit-head anchor is
-  // retired (ADR-BE-292). Null → unmanaged (Unassigned bucket).
-  reportsToUserId: z.string().uuid().nullable(),
+  // The open role's own reporting edge (ADR-BE-291): defaults to its creator's
+  // seat, editable/clearable. Drives chart placement now that the unit-head
+  // anchor is retired (ADR-BE-292). Null → unmanaged (Unassigned bucket).
+  //
+  // The manager POSITION, not a user (ADR-CONTRACTS-131). The retired
+  // user-keyed flattening was a lie in two directions: an open-role manager
+  // already surfaced as null because it had no user to collapse to, and
+  // post-HRIS every open role reporting to an imported (accountless) manager
+  // would read null too.
+  reportsToPositionId: z.string().uuid().nullable(),
   createdAt: z.string(),
   updatedAt: z.string(),
 });

package/src/identity/org-chart-actor.ts

@@ -1,24 +0,0 @@
-/**
- * Org-chart actor reference — either endpoint of a reporting edge.
- *
- * A node in the people chart that can sit on EITHER side of a reporting edge: a
- * filled member (keyed by occupant `userId`) OR an unfilled open-role seat
- * (keyed by its own `openRoleId`). A vacant seat is a first-class reporting
- * actor — it can be a manager that real people report to (ADR-BE-312), not just
- * a report. The discriminant lets an edge point at either kind without losing
- * what the id means. Mirrors the app's `ActorIdentity` shape exactly so the app
- * consumes this type directly (one common spine across wire + UI).
- *
- * Lives in its own zero-dependency module (zod only) so both `people-org-chart`
- * (which already depends on `org/schemas` for AuthorityMutability) and
- * `org/schemas` (which needs it for the set-manager request/response) can import
- * it without forming a module-init cycle.
- */
-import { z } from "zod";
-
-export const OrgChartActorRefSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("member"), userId: z.string().uuid() }),
-  z.object({ kind: z.literal("open-role"), openRoleId: z.string().uuid() }),
-]);
-
-export type OrgChartActorRef = z.infer<typeof OrgChartActorRefSchema>;