@@ -40,6 +40,7 @@ import { isOriginGatedType, managedItemSealedSentence, regimeCDeclaredSaveSenten
 import { SysMetadataRepository } from './sys-metadata-repository.js';
 import { OBJECT_EXTENSION_TYPE } from './protocol-object-extension-item.js';
 import { customizationPairEnsureRefusal, type PairRegistry } from './protocol-customization-package.js';
+import { resolvePackageClosure } from '@objectstack/lint/runtime';
 import { overlayMemberField, overlayMemberOfBody, overlayMemberValue } from './migrations/overlay-index.js';
 import {
     customizationBasePackageId,
@@ -246,12 +247,12 @@ export function packagelessOverlayWriteRefusal(
     closed: { base: string; pair: string },
     operation: PackagelessWriteOperation,
 ): Error {
-    const { item, shipped, pair, declared, writeInto } = closedOverlayWriteClauses(request, closed);
-    const rule = 'A write naming no package is closed where `os migrate packageless-overlays` can move its row '
+    const { item, shipped, pair, declared, writeInto, ceremony } = closedOverlayWriteClauses(request, closed);
+    const rule = `A write naming no package is closed where ${ceremony} can move its row `
         + `(ADR-0146 D11); a package-less row stored before it is served until that command moves it into '${closed.pair}'.`;
     const message = operation === 'rollback'
         ? `${item} ${shipped}, and a rollback of its package-less row is closed (ADR-0146 D11): run `
-            + `\`os migrate packageless-overlays\` to move the row into ${pair}; to restore a version from before `
+            + `${ceremony} to move the row into ${pair}; to restore a version from before `
             + `the move, save that version's body there, declaring ${declared}.`
         : operation === 'delete'
             ? `${item} ${shipped}: remove its customization from ${pair}. ${rule}`
@@ -266,6 +267,13 @@ export function packagelessOverlayWriteRefusal(
  * the declaration, and the fix — write it into the pair, declaring the
  * override. ONE spelling: a writer refused at either address reads the same
  * fix, and only the rule clause that follows it says which address is closed.
+ *
+ * Two more clauses, one spelling each: `ceremony`, the command that moves a
+ * stored row into the pair (both sentences name it), and `boundRowServed`,
+ * what serves a row bound to the base stored before the close until one of
+ * the three open doors acts on it — [#29392] that command, which moves it
+ * into the pair with its declaration, the pair's declared override, or a
+ * delete naming the base.
  */
 function closedOverlayWriteClauses(
     request: { type: string; name: string },
@@ -278,7 +286,9 @@ function closedOverlayWriteClauses(
     const declared = `overrides: { package: '${closed.base}', basedOn }`;
     const writeInto = (operation: 'save' | 'publish') =>
         `${item} ${shipped}: ${operation === 'publish' ? 'publish' : 'save'} it into ${pair}, declaring ${declared}.`;
-    return { item, shipped, pair, declared, writeInto };
+    const ceremony = '`os migrate packageless-overlays`';
+    const boundRowServed = `is served until moved by ${ceremony}, overridden by the pair, or deleted naming the base.`;
+    return { item, shipped, pair, declared, writeInto, ceremony, boundRowServed };
 }
 
 /** `403 NOT_OVERRIDABLE`, the code and status the sealed write already answers, so neither close gains a code. */
@@ -298,11 +308,11 @@ function closedOverlayWriteError(message: string): Error {
  * a row bound to the base. `rollback` is every restore of a stored version:
  * the per-item rollback and [#29390] a commit revert's restore limb (and the
  * package rollback through it), one sentence for both. ⛔ Not `delete`:
- * removing a row bound to the base writes nothing, and it is the one way to
- * clear such a row stored before the close — `os migrate packageless-overlays`
- * reads package-less rows only, so it never moves one. The removal serves the
- * base's own document again, or the pair's declared override where one exists
- * (it is served over the row).
+ * removing a row bound to the base writes nothing, and it is one way to clear
+ * such a row stored before the close; [#29392] `os migrate packageless-overlays`
+ * is the other, moving it into the pair with its declaration. The removal
+ * serves the base's own document again, or the pair's declared override where
+ * one exists (it is served over the row).
  */
 export type NamedBaseWriteOperation = Exclude<PackagelessWriteOperation, 'delete'>;
 
@@ -314,12 +324,14 @@ export type NamedBaseWriteOperation = Exclude<PackagelessWriteOperation, 'delete
  * package itself (`?package=<base>`) onto an item of one of the five overlay
  * types that package ships stored the customization as a row bound to the
  * base, with no declaration: served at the base's address in place of its
- * document, outside the pair D1 puts every customization in, and not seen by
- * `os migrate packageless-overlays`. It is refused with the fix the
- * package-less close names ({@link closedOverlayWriteClauses}): write it into
- * the pair, declaring the override. A row stored that way before the close is
- * still served until the pair declares the override (the declared override is
- * served over it) or a delete naming the base removes it — both open.
+ * document, outside the pair D1 puts every customization in. It is refused
+ * with the fix the package-less close names ({@link closedOverlayWriteClauses}):
+ * write it into the pair, declaring the override. A row stored that way before
+ * the close is still served until one of three open doors acts on it, all
+ * named in the sentence ({@link closedOverlayWriteClauses}' `boundRowServed`):
+ * [#29392] `os migrate packageless-overlays` moves it into the pair with its
+ * declaration, the pair declares the override (served over it), or a delete
+ * naming the base removes it.
  *
  * Fix first, under the REST door's 500-character bound (`CLIENT_MESSAGE_MAX`,
  * `@objectstack/types`), as the package-less sentence.
@@ -329,13 +341,12 @@ export function namedBaseOverlayWriteRefusal(
     closed: { base: string; pair: string },
     operation: NamedBaseWriteOperation,
 ): Error {
-    const { item, shipped, pair, declared, writeInto } = closedOverlayWriteClauses(request, closed);
-    const served = 'is served until the pair declares the override, or a delete naming the base removes it.';
+    const { item, shipped, pair, declared, writeInto, boundRowServed } = closedOverlayWriteClauses(request, closed);
     const message = operation === 'rollback'
         ? `${item} ${shipped}, and a rollback of its row bound to the read-only base is closed (ADR-0146 D1, D11): `
-            + `save the version's body into ${pair}, declaring ${declared}. The row ${served}`
+            + `save the version's body into ${pair}, declaring ${declared}. It ${boundRowServed}`
         : `${writeInto(operation)} The read-only base itself takes no customization (ADR-0146 D1, D11): `
-            + `a row bound to it from before ${served}`;
+            + `a row bound to it ${boundRowServed}`;
     return closedOverlayWriteError(message);
 }
 
@@ -348,8 +359,31 @@ export interface OverlayPairFix {
     readonly base: string;
     readonly pair: string;
     readonly basedOn: string;
+    /**
+     * The closure the pair WILL have, present only while the pair is not
+     * installed: the ensure door declares the pair's one dependency, the base
+     * (`manifest.dependencies: { [base]: range }`), so its closure is the base
+     * and what the base reaches. The gate's own read
+     * (`resolveWritePackageScope`) answers nothing for a package the registry
+     * cannot produce, and its `not_concerned` on a declared body is no verdict
+     * about the write the fix takes.
+     */
+    readonly pendingPairScope?: WrittenPackageScope;
+}
+
+/** A written package and the closure of its declared dependencies, as `resolveWritePackageScope` answers it. */
+export interface WrittenPackageScope {
+    readonly packageId: string;
+    readonly dependencies: readonly string[];
 }
 
+/**
+ * The override write gate as a close asks it: {@link overrideWriteVerdict},
+ * with the written package's closure when the caller holds it (a pair the
+ * ensure step would create, {@link OverlayPairFix.pendingPairScope}).
+ */
+export type OverrideWriteVerdictAsk = (request: OverrideWriteSubject, writtenScope?: WrittenPackageScope) => OverrideWriteVerdict;
+
 /**
  * [ADR-0146 D1, D11] The registry half of whether the fix both overlay-write
  * closes name — write it into `base`'s pair, declaring the override — can be
@@ -382,7 +416,11 @@ export function overlayPairFixOf(
     if (customizationPairEnsureRefusal(host.engine, registry, base, pair) !== undefined) return null; // the ensure door would refuse
     const basedOn = registry.getPackage(base)?.manifest?.version;
     if (typeof basedOn !== 'string' || basedOn === '') return null; // no `basedOn` to declare
-    return { base, pair, basedOn };
+    if (registry.getPackage(pair)) return { base, pair, basedOn };
+    // The pair the ensure door would create: one dependency, the base.
+    const baseClosure = resolvePackageClosure(base, (id) => registry.getPackage(id) as { manifest?: unknown } | undefined);
+    const dependencies = [base, ...(baseClosure?.dependencies ?? []).filter((id) => id !== pair)];
+    return { base, pair, basedOn, pendingPairScope: { packageId: pair, dependencies } };
 }
 
 /**
@@ -392,9 +430,14 @@ export function overlayPairFixOf(
  * identity at `member`, declaring `overrides: { package: base, basedOn }`. An
  * `email_template` member at a locale the base does not ship is refused
  * there, so its write stays open.
+ *
+ * The gate is asked about the pair the fix writes into, installed or not: a
+ * pair not yet ensured (a fresh install) is judged with the closure the
+ * ensure door gives it ({@link OverlayPairFix.pendingPairScope}), so the
+ * answer is the one the write meets once the pair exists.
  */
 export function overlayPairFixAdmits(
-    host: { readonly overrideWriteVerdict: (request: OverrideWriteSubject) => OverrideWriteVerdict },
+    host: { readonly overrideWriteVerdict: OverrideWriteVerdictAsk },
     fix: OverlayPairFix,
     subject: {
         /** The singular type. */
@@ -411,7 +454,7 @@ export function overlayPairFixAdmits(
         ...(body ?? { name, ...(disc && member !== null ? { [disc]: member } : {}) }),
         overrides: { package: fix.base, basedOn: fix.basedOn },
     };
-    const verdict = host.overrideWriteVerdict({ type, name, packageId: fix.pair, item: declaredBody });
+    const verdict = host.overrideWriteVerdict({ type, name, packageId: fix.pair, item: declaredBody }, fix.pendingPairScope);
     return verdict.verdict !== 'refuse';
 }
 
@@ -421,7 +464,7 @@ export interface NamedBaseCloseHost {
     /** The read-only code packages that ship a name of an overlay type ([] for any other type). */
     readonly overlayBaseShippers: (type: string, name: string) => string[];
     /** The override write gate, as the declared write into the pair meets it at the save door. */
-    readonly overrideWriteVerdict: (request: OverrideWriteSubject) => OverrideWriteVerdict;
+    readonly overrideWriteVerdict: OverrideWriteVerdictAsk;
 }
 
 /** The write naming a package that {@link namedBaseCloseSubject} judges. */
@@ -848,17 +891,25 @@ export function overrideWriteRefusalError(
  * member ({@link overrideWriteMemberOf}), and an artifact of another member is
  * no shipper: a registry that ignores `member` can answer one, as
  * `mergeArtifactProtection` guards on the read side.
+ *
+ * `writtenScope`, when given for the written package, is its closure in
+ * place of the registry's read: a close asking about a pair the ensure step
+ * would create ({@link OverlayPairFix.pendingPairScope}). Every door's own
+ * write passes none.
  */
 export function overrideWriteVerdict(
     this: Pick<PackagedBaseRefusalHost, 'isWritablePackage' | 'resolveWritePackageScope' | 'shippedArtifactsOf'>,
     request: OverrideWriteSubject,
+    writtenScope?: WrittenPackageScope,
 ): OverrideWriteVerdict {
     const packageId = typeof request.packageId === 'string' && request.packageId.length > 0
         ? request.packageId
         : undefined;
     const declaration = declarationOf(request.item);
     if (packageId === undefined && !declaration.present) return NOT_CONCERNED;
-    const scope = packageId === undefined ? undefined : this.resolveWritePackageScope(packageId);
+    const scope = packageId === undefined
+        ? undefined
+        : writtenScope?.packageId === packageId ? writtenScope : this.resolveWritePackageScope(packageId);
     // A named package the registry cannot produce is not this gate's to
     // judge: both doors ask `uninstalledNamedBaseRefusal`, which refuses a
     // write naming an uninstalled base (`WRITABLE_PACKAGE_REQUIRED`) — the
 
@@ -25,7 +25,8 @@
  *    draft stays a draft and no active row is written;
  *  - the rollback of a row bound to the base: refused, the row unchanged;
  *  - CONTROLS, open as on `main`: a delete naming the base removes such a row
- *    (the one way to clear it: the ceremony moves package-less rows only), a
+ *    (one way to clear it; [#29392] `os migrate packageless-overlays` moves it
+ *    into the pair, and the sentence names both), a
  *    draft discard naming it, the pair's declared save (served over a row
  *    bound to the base), a server-stated rewrite (`source` set), a writable
  *    package's same name, a name the base does not ship (ADR-0070 D1's own
@@ -211,6 +212,10 @@ function expectClosedSentence(message: string, type: string, name: string, verb:
     expect(message).toContain('ADR-0146 D1, D11');
     if (verb === 'rollback') expect(message).toContain('a rollback of its row bound to the read-only base is closed');
     else expect(message).toContain(`${verb} it into '${PAIR}'`);
+    // [#29392] The ceremony moves a row bound to the base into the pair: the
+    // sentence points an operator holding one to it, beside the other two doors.
+    expect(message).toContain('is served until moved by `os migrate packageless-overlays`, overridden by the pair, '
+        + 'or deleted naming the base.');
     // The REST door cuts a refusal's text at 500 characters
     // (`CLIENT_MESSAGE_MAX`, `@objectstack/types`): the whole sentence fits.
     expect(message.length).toBeLessThan(500);
 
@@ -338,6 +338,7 @@ import type {
     NamedBaseWriteSubject,
     OverrideWriteSubject,
     OverrideWriteVerdict,
+    WrittenPackageScope,
     PackagelessWriteOperation,
 } from './protocol-packaged-base-refusal.js';
 // [ADR-0146 D10, #28564] The `__c` extension-field reservation's one judge.
@@ -8267,8 +8268,8 @@ export class ObjectStackProtocolImplementation implements
      * {@link promoteDraftForPublish}) or a rollback that would land a row bound
      * to the base. D1 puts a read-only package's customizations in its paired
      * `<base>.custom`; such a row is served at the base's address with no
-     * declaration, outside the pair, and `os migrate packageless-overlays`
-     * never sees it (its census reads package-less rows only). Refused with
+     * declaration, outside the pair, until [#29392] `os migrate
+     * packageless-overlays` moves it into the pair. Refused with
      * the fix the package-less close names ({@link packagelessOverlayWriteRefusal},
      * one spelling): write it into the pair, declaring the override.
      *
@@ -8282,9 +8283,10 @@ export class ObjectStackProtocolImplementation implements
      * that could not be taken.
      *
      * ⛔ Not a delete: removing a row bound to the base writes nothing, and it
-     * is the only way to clear such a row stored before the close (the
-     * ceremony moves package-less rows only). A row stored before it stays
-     * served until the pair declares the override, which is served over it.
+     * is one way to clear such a row stored before the close; the ceremony is
+     * the other, moving it into the pair with its declaration. A row stored
+     * before it stays served until one of those, or the pair's declared
+     * override, which is served over it; the sentence names all three.
      *
      * Authoring writes only: the server-stated rewrites (`source` set, the
      * `package-duplicate` write face) name the row they rewrite. Registry
@@ -8316,15 +8318,17 @@ export class ObjectStackProtocolImplementation implements
      *
      * Asked by the save door ahead of {@link refusePackagedBaseOverride}, and
      * by the promotion ({@link promoteDraftForPublish}, so both
-     * `publishMetaItem` and `publishPackageDrafts`) on the draft's body.
+     * `publishMetaItem` and `publishPackageDrafts`) on the draft's body. The
+     * two overlay-write closes ask it about the pair their fix writes into,
+     * with the closure a pair not yet ensured will have (`writtenScope`).
      */
-    private overrideWriteVerdict(request: OverrideWriteSubject): OverrideWriteVerdict {
+    private overrideWriteVerdict(request: OverrideWriteSubject, writtenScope?: WrittenPackageScope): OverrideWriteVerdict {
         const host: ThisParameterType<typeof overrideWriteVerdict> = {
             isWritablePackage: (...a) => this.isWritablePackage(...a),
             resolveWritePackageScope: (...a) => this.resolveWritePackageScope(...a),
             shippedArtifactsOf: (...a) => this.shippedArtifactsOf(...a),
         };
-        return overrideWriteVerdict.call(host, request);
+        return overrideWriteVerdict.call(host, request, writtenScope);
     }
 
     /** Docblock and body: {@link ProtocolWriteGatesFacet.refusePackagedBaseRemoval} in `protocol-write-gates.ts` [#29985 codemod]. */