fix(driver-turso,cli): the OS_ARTIFACT_URL boot gate keeps its warn-and-boot answer on a Turso remote primary

The remote face's schema sync creates no declared NOT NULL, so a healthy
remote database reads as destructive tighten_not_null, and the gate's
remedy cannot run on that transport. TursoDriver declares
driftReportCaveat (a sentence on the remote face, null elsewhere) and the
gate, reading that declaration, warns and boots, applying and refusing
nothing.

Also from the contract review: the embedded-replica drift control is back
beside the remote suite; the remote detector reads its catalog in three
round trips per call; catalog reads refuse a non-row answer; a created
index counts as applied only with the uniqueness and key columns asked
for; the parity suite is cited by its real name.

Co-authored-by: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Lr3rg6qTp9r38exA5DHEEH

Author: claude

packages/cli/src/utils/artifact-boot-migration.test.ts

@@ -214,3 +214,37 @@ describe('formatDestructiveDriftRefusal', () => {
         expect(text).toContain('never skipped in silence');
     });
 });
+
+describe('runArtifactBootMigrationGate — a driver that declares its report must not be acted on', () => {
+    // [#23816] The Turso REMOTE face declares `driftReportCaveat`: its schema
+    // sync does not create a declared NOT NULL, so a healthy remote database
+    // reports destructive `tighten_not_null`, and the refusal's remedy cannot
+    // run on that transport. The gate keeps its "did not run" answer there.
+    const CAVEAT = 'the transport cannot act on its own report';
+
+    it('warns with the reason, applies nothing and refuses nothing, and never reads the report', async () => {
+        const { driver, applyCalls } = fakeDriver([entry('destructive'), entry('safe')]);
+        const declared: SqlDriverLike = { ...driver, driftReportCaveat: CAVEAT };
+        const warned: string[] = [];
+
+        const verdict = await runArtifactBootMigrationGate({
+            driver: declared, artifactDisplay: ARTIFACT, warn: (m) => warned.push(m),
+        });
+
+        expect(verdict).toEqual({ ok: true, applied: [], skipped: [], destructive: [] });
+        expect(driver.detectManagedDrift).not.toHaveBeenCalled();
+        expect(applyCalls).toHaveLength(0);
+        expect(warned).toHaveLength(1);
+        expect(warned[0]).toContain(CAVEAT);
+        expect(warned[0]).toContain('Boot continues');
+    });
+
+    it('the control: a null caveat is no caveat, and the same report refuses the boot', async () => {
+        const { driver } = fakeDriver([entry('destructive')]);
+        const verdict = await runArtifactBootMigrationGate({
+            driver: { ...driver, driftReportCaveat: null }, artifactDisplay: ARTIFACT,
+        });
+        expect(verdict.ok).toBe(false);
+        expect(driver.detectManagedDrift).toHaveBeenCalledTimes(1);
+    });
+});

packages/cli/src/utils/artifact-boot-migration.ts

@@ -25,6 +25,11 @@
  *   - **nothing is skipped silently** — the third state, "shrug and serve", is
  *     the one this gate exists to delete.
  *
+ * One driver-declared exception, and it is loud: a driver whose
+ * `driftReportCaveat` says its report must not be acted on unattended (the
+ * Turso REMOTE face, #23816) gets a warning naming that reason, and the gate
+ * applies and refuses nothing — as when the report cannot be read at all.
+ *
  * `needs_confirm` drift is applied along with `safe`: `os migrate apply`'s own
  * split is `category !== 'destructive' || allowDestructive`, so "the
  * `--allow-destructive` class" the acceptance names is exactly
@@ -120,6 +125,18 @@ export async function runArtifactBootMigrationGate(opts: {
     // no drift to classify and nothing for this policy to decide.
     if (!driver) return { ok: true, applied: [], skipped: [], destructive: [] };
 
+    // [#23816] A driver that declares its report must not be acted on
+    // unattended gets this gate's "did not run" answer: warn, apply nothing,
+    // refuse nothing. The Turso REMOTE face declares one: its schema sync does
+    // not create a declared NOT NULL, so a healthy remote database reads as
+    // destructive drift, and the refusal's remedy cannot run on that transport.
+    // Read from the driver's declaration, never from its transport name.
+    const caveat = driver.driftReportCaveat;
+    if (typeof caveat === 'string' && caveat) {
+        warn(`  ⚠ Did not check the physical schema against the artifact: ${caveat}. Boot continues.`);
+        return { ok: true, applied: [], skipped: [], destructive: [] };
+    }
+
     let drift: ManagedDriftEntry[];
     try {
         drift = await driver.detectManagedDrift();

packages/cli/src/utils/schema-migrate.ts

@@ -80,6 +80,13 @@ export interface SqlDriverLike {
    * caller's own refusal branch can tell an operator which it was.
    */
   planMediaColumnMove?: () => Promise<MediaColumnMoveScan>;
+  /**
+   * [#23816] Why this driver's drift report must not be acted on unattended,
+   * or `null` / absent when it may be — `TursoDriver`'s REMOTE face declares
+   * one. Read by the artifact-pinned boot gate (`./artifact-boot-migration.ts`),
+   * which then neither applies nor refuses on the report.
+   */
+  readonly driftReportCaveat?: string | null;
   /** Deferred-DDL surface (#3917) — optional, so a driver without it still boots. */
   setDeferredDdl?: (deferred: boolean) => void;
   previewDeferredSchemaWork?: () => Promise<PendingSchemaWork[]>;