@@ -0,0 +1,35 @@
+---
+'@objectstack/verify': minor
+'@objectstack/cli': minor
+---
+
+feat(verify): the unique-scope family — every field declared `unique` collides as its declared scope says, runnable as `os verify --unique-scopes` (#15953)
+
+Clause-②: yes
+
+A fifth derived proof family beside `runCrudVerification`, `runRlsProofs`, `runReferenceShapeProofs` and `runDeleteBehaviorProofs`. It needs no hand-written test: from the app's own objects it takes every field whose `unique` the spec's own parse of the field (`FieldSchema`) declares — the value a built artifact carries, so an `autonumber` that authors no `unique` states `'organization'` — and asks the engine what a second holder of one value meets, through two doors: the REST data route as a signed-in caller, and the engine's own write as the system principal.
+
+- **Within one organization** — by insert and by update — the second holder must be refused, whatever the scope. On a `single`-posture boot that organization is the install's one: the untenanted install, where every write lands in it.
+- **Across two organizations** — on an org-scoped boot only — the family provisions a second organization the way a user makes one (a sign-up that creates its own) and offers it the value. A `true` or `'organization'` field must admit it; a `'global'` field, or any field of an object with no organization column (`tenancy.enabled: false`), must refuse it. On a boot with one organization this leg is reported not run, with the reason, on the report's `boot`.
+
+A refusal proves the collision only when it is the platform's unique refusal (`UNIQUE_VIOLATION` at the REST door, `DUPLICATE_RECORD` at the system door) and it is this field's: it names the field, or it names none and the same record with only the probed value changed is admitted. A per-organization constraint is an expression index, which the driver reports by index name, so its refusal carries no `field`, and that twin is what attributes it. Any other refusal (an app hook's own dedupe, a validation rule, a permission, a constraint on another field) is `unattributed`, so an engine that refused every write would not read as a proven scope. A field is `proven`, `contradicted` (a second holder met something other than its scope), `failed` (a door faulted), `inconclusive`, `excluded` or `not-derivable`. `contradicted + failed` is the report's `hardFailures`.
+
+A field the caller cannot set (`readonly`, `system`, a runtime-issued `autonumber`) is probed through the system door only, which keeps an explicit value. A derived value (`formula`, `summary`) is `excluded`; a field with no fresh values to offer (a `boolean`, a `select`, a multi-valued reference, a target the app does not declare) is `not-derivable`. The population is the field-level declaration: a unique `indexes[]` entry is a different surface, with its own meaning of bare `true`, and is not in it.
+
+**`@objectstack/verify` — new exports.**
+
+- `runUniqueScopeProofs(stack, token, config, { doors? })` → `UniqueScopeReport`. Run it on a fresh stack of its own: it writes duplicates on purpose. Boot the stack with `{ multiTenant: true }` to run the cross-organization leg.
+- `deriveUniqueScopeCases(config)`, `formatUniqueScopeReport(report)`.
+- Types: `DeclaredUniqueScope`, `UniqueScopeCase`, `UniqueScopeDoor`, `UniqueScopeLeg`, `UniqueScopeOperation`, `UniqueScopeAnswer`, `UniqueScopeProbeResult`, `UniqueScopeFieldStatus`, `UniqueScopeFieldResult`, `UniqueScopeReport`, `UniqueScopeProofOptions`.
+
+```ts
+import { bootStack, runUniqueScopeProofs, formatUniqueScopeReport } from '@objectstack/verify';
+
+const stack = await bootStack(myApp, { multiTenant: true });
+const report = await runUniqueScopeProofs(stack, await stack.signIn(), myApp);
+console.log(formatUniqueScopeReport(report)); // report.boot names the legs this boot ran
+expect(report.summary.hardFailures).toBe(0);
+await stack.stop();
+```
+
+**`@objectstack/cli` — `os verify --unique-scopes`.** Opt-in, like `--reference-shapes` and `--delete-behaviors`, on a fresh boot of its own; with `--multi-tenant` it runs both legs. A second holder met wrongly, or a door that faulted, counts in `hardFailures` and fails the run. The `--json` document carries the report as `uniqueScopes` when the flag is given; without the flag the run and its document are unchanged.
@@ -1924,6 +1924,7 @@ os verify --app ./objectstack.config.ts --rls  # Also prove the cross-owner RLS
 os verify --rls --multi-tenant --json          # Org-scoped boot, structured report
 os verify --reference-shapes                   # Also prove reference fields refuse non-id values
 os verify --delete-behaviors                   # Also prove each declared deleteBehavior is what a delete does
+os verify --unique-scopes --multi-tenant       # Also prove each declared unique collides where its scope says
 ```
 
 1. **Author-time rules.** The rule registry `os validate` runs, over the stack
@@ -1966,6 +1967,24 @@ os verify --delete-behaviors                   # Also prove each declared delete
    `excluded` rather than compared, because an engine rule decides their
    outcome, not the declaration. It is opt-in, and a `tree` field's delete is
    not honoured today, so an app that declares one would fail.
+   With `--unique-scopes`, another fresh boot proves that every field declared
+   `unique` collides as its scope says: per field, a first record holds a value
+   and a second one is offered it, by insert and by update, through the REST
+   door and the system door. Within one organization the second holder must be
+   refused with the platform's unique refusal, attributed to the field (it
+   names the field, or it names none and the same record with only that value
+   changed is admitted). With `--multi-tenant` the run also provisions a second
+   organization (a sign-up that creates its own) and offers it the value: a
+   `true` or `'organization'` field must admit it, and a `'global'` field, or
+   any field of an object with no organization column, must refuse it. Without
+   `--multi-tenant` there is one organization, so that leg is reported **not
+   run** with the reason rather than skipped. The scope is read as the spec's
+   parse of the field states it (an `autonumber` that authors no `unique`
+   states `'organization'`); a field the caller cannot set — `readonly`,
+   `system`, a runtime-issued `autonumber` — is probed through the system door
+   only. A second holder met wrongly fails the run; a refusal that is not the
+   field's own constraint (an app hook's dedupe, a rule, a permission) is
+   reported inconclusive, never proven.
    `--multi-tenant` boots org-scoped so tenant-isolation RLS policies
    apply; a walled tenancy posture (`OS_TENANCY_POSTURE` set to `isolated` or
    `group`) asks for the same boot.
@@ -1994,7 +2013,9 @@ document carries depends on where the run ended:
   package of the artifact), or the schema issues when the stack does not parse.
 - **Reached the runtime stage:** the report — `app`, `config`, `multiTenant`,
   `crud`, `rls` (with `--rls`), `referenceShapes` (with `--reference-shapes`),
-  `deleteBehaviors` (with `--delete-behaviors`) and `hardFailures`, the count
+  `deleteBehaviors` (with `--delete-behaviors`), `uniqueScopes` (with
+  `--unique-scopes`; its `boot` names the legs the run could prove) and
+  `hardFailures`, the count
   the exit status is read from.
 - **Could not run:** `{ "error": "<sentence>" }`, plus `code` and `httpStatus`
   when the failure carries them.
 
@@ -19,10 +19,13 @@ import {
   formatReferenceShapeReport,
   runDeleteBehaviorProofs,
   formatDeleteBehaviorReport,
+  runUniqueScopeProofs,
+  formatUniqueScopeReport,
   type VerifyReport,
   type RlsReport,
   type ReferenceShapeReport,
   type DeleteBehaviorReport,
+  type UniqueScopeReport,
   type RlsProbeDescriptor,
   type RlsPositionPersonaInput,
 } from '@objectstack/verify';
@@ -91,19 +94,25 @@ export function resolveVerifyMultiTenant(flags: { 'multi-tenant'?: boolean }): b
  *        - delete behaviour (--delete-behaviors): every `deleteBehavior` a
  *          reference field declares is what a by-id delete of the referenced
  *          record does, through the REST door and the system door
+ *        - unique scope (--unique-scopes, ADR-0120 D1): every field declared
+ *          `unique` refuses a second holder within one organization, through
+ *          the REST door and the system door, and — on an org-scoped boot
+ *          (--multi-tenant) — admits or refuses one in another organization
+ *          as its declared scope says
  *
  * Exits non-zero on either stage's failures so it drops straight into CI.
  */
 export default class Verify extends Command {
   static override description =
-    'Run the author-time rules os validate runs, then boot the app in-process and verify it through the real HTTP stack (CRUD round-trip fidelity, plus the cross-owner RLS invariant, the reference-value shape proofs and the declared delete-behaviour proofs on request)';
+    'Run the author-time rules os validate runs, then boot the app in-process and verify it through the real HTTP stack (CRUD round-trip fidelity, plus the cross-owner RLS invariant, the reference-value shape proofs, the declared delete-behaviour proofs and the declared unique-scope proofs on request)';
 
   static override examples = [
     '<%= config.bin %> verify',
     '<%= config.bin %> verify --app ./objectstack.config.ts --rls',
     '<%= config.bin %> verify --rls --multi-tenant --json',
     '<%= config.bin %> verify --reference-shapes',
     '<%= config.bin %> verify --delete-behaviors',
+    '<%= config.bin %> verify --unique-scopes --multi-tenant',
   ];
 
   static override flags = {
@@ -123,6 +132,10 @@ export default class Verify extends Command {
       description: 'Also prove every deleteBehavior a reference field declares (cascade, set_null, restrict) is what a delete of the referenced record does, through the REST door and the system door',
       default: false,
     }),
+    'unique-scopes': Flags.boolean({
+      description: "Also prove every field declared unique collides as its scope says (true / 'organization': within one organization only; 'global': across the installation), through the REST door and the system door; the cross-organization half needs --multi-tenant and is reported not run without it (ADR-0120 unique scopes)",
+      default: false,
+    }),
     'multi-tenant': Flags.boolean({
       description: 'Boot org-scoped (register the @objectstack/organizations plugin) so tenant-isolation RLS policies apply (also honors a walled $OS_TENANCY_POSTURE, and the legacy $OS_MULTI_ORG_ENABLED it falls back to)',
       default: false,
@@ -202,6 +215,7 @@ export default class Verify extends Command {
     rls: boolean;
     'reference-shapes': boolean;
     'delete-behaviors': boolean;
+    'unique-scopes': boolean;
     'multi-tenant': boolean;
     json: boolean;
   }): Promise<void> {
@@ -331,6 +345,20 @@ export default class Verify extends Command {
       }
     }
 
+    // The unique-scope proofs run on a fresh stack of their own as well: they
+    // write duplicates on purpose, and on an org-scoped boot they sign up a
+    // second organization, neither of which another phase should meet.
+    let uniqueScopes: UniqueScopeReport | undefined;
+    if (flags['unique-scopes']) {
+      const uniqueStack = await bootStack(config, { multiTenant, hostRoot });
+      try {
+        const adminToken = await uniqueStack.signIn();
+        uniqueScopes = await runUniqueScopeProofs(uniqueStack, adminToken, config);
+      } finally {
+        await uniqueStack.stop();
+      }
+    }
+
     // Failure contract: a "real" runtime break the app's author must see.
     // A degraded RLS probe counts: the run reported verdicts it could not have
     // established, which is worse than no verifier at all.
@@ -355,18 +383,23 @@ export default class Verify extends Command {
       // A declared deleteBehavior a delete contradicted, or a door that
       // faulted on one. Inconclusive, excluded and not-derivable fields are
       // reported, not counted.
-      (deleteBehaviors?.summary.hardFailures ?? 0);
+      (deleteBehaviors?.summary.hardFailures ?? 0) +
+      // A second holder a declared unique scope met wrongly, or a door that
+      // faulted on one. A leg this boot cannot run is reported on the report's
+      // `boot`, not counted.
+      (uniqueScopes?.summary.hardFailures ?? 0);
 
     if (flags.json) {
       // `emitJson`, not `this.log`: stdout is reserved (see `run()`), so the
       // report has to leave through the real stream — and awaiting the write
       // drains a report larger than one pipe buffer before `this.exit` below.
-      await emitJson({ app: crud.app, config: absolutePath, multiTenant, crud, rls, referenceShapes, deleteBehaviors, hardFailures });
+      await emitJson({ app: crud.app, config: absolutePath, multiTenant, crud, rls, referenceShapes, deleteBehaviors, uniqueScopes, hardFailures });
     } else {
       this.log(formatReport(crud));
       if (rls) this.log(formatRlsReport(rls));
       if (referenceShapes) this.log(formatReferenceShapeReport(referenceShapes));
       if (deleteBehaviors) this.log(formatDeleteBehaviorReport(deleteBehaviors));
+      if (uniqueScopes) this.log(formatUniqueScopeReport(uniqueScopes));
       this.log('');
       this.log(
         hardFailures > 0