@@ -0,0 +1,11 @@
+---
+'@objectstack/cli': patch
+---
+
+fix(cli): `os migrate plan`'s unmanaged-tables sweep runs whenever the plan's object set mirrors what `os serve` registers, covers every database the plan diffs, and states only a reason that holds when it does not run (#22580)
+
+On a project with a compiled artifact and no `objectstack.config.ts`, `os migrate plan` composes what `os serve` registers, platform included. The sweep for platform-prefixed tables that no object declares was still withheld there (`unmanagedTables.status: "unreadable"` in `--json`), with a reason claiming the plan's object set was only the artifact plus the platform floor. On a project with neither a config nor a compiled artifact, the same untrue reason was given.
+
+The plan's composition now records whether its object set mirrors the served boot, and why when it does not. The sweep runs exactly when it does, the compiled-artifact project included. When it does not run, the `detail` names the composition's own reason: the host config that did not load, or a project with neither a config nor a compiled artifact.
+
+The sweep also reads every database the plan diffs. Where the serving boot keeps lifecycle-classed objects in the `telemetry` sibling database, a table stranded there is now reported too, where before the sweep answered `read` over the primary database alone. A sibling whose catalog cannot be read makes the whole sweep `unreadable`, and the `detail` names that database. The `--json` shape of `unmanagedTables` is unchanged. `physicalTables` counts the tables of every database swept, and the human line says "in the database(s) this plan covers".
@@ -38,8 +38,9 @@ import Database from 'better-sqlite3';
  *  - the boot's tables, a rotation shard read as its object, number exactly
  *    the plan's examined objects plus `sys_packages` (boot ⊆ plan, app tables
  *    included) — with `pending` empty, equal counts are equal sets;
- *  - where the unmanaged-tables sweep runs (a project with a host config), it
- *    names nothing but `sys_packages`.
+ *  - the unmanaged-tables sweep RUNS on every shape — the composition says it
+ *    mirrors the served boot, the compiled-artifact project with no config
+ *    included (#22580) — and names nothing but `sys_packages`.
  *
  * `sys_packages` is the one table outside the object set, by construction:
  * `PackageServicePlugin.start()` creates it with raw DDL (`package-table.ts`),
@@ -141,12 +142,13 @@ function expectParity(r: Reading): void {
   const rawDdl = r.tables.filter((t) => NOT_AN_OBJECT.includes(t));
   expect(rawDdl).toEqual(NOT_AN_OBJECT);
   expect(r.tables.length).toBe(r.plan.managedTables + rawDdl.length);
-  // … and platform tables by name, where the unmanaged sweep runs (it reports
-  // itself `unreadable` on a project with no host config).
-  if (r.plan.unmanagedTables?.status === 'read') {
-    const unmanaged = (r.plan.unmanagedTables.tables ?? []).map((t: any) => (typeof t === 'string' ? t : t.table ?? t.name));
-    expect(unmanaged.filter((t: string) => !NOT_AN_OBJECT.includes(t))).toEqual([]);
-  }
+  // … and platform tables by name: [#22580] the unmanaged sweep runs on every
+  // shape, because the composition records that it mirrors the served boot —
+  // the compiled artifact with no config included, which it used to withhold
+  // with a reason that no longer held.
+  expect(r.plan.unmanagedTables?.status, JSON.stringify(r.plan.unmanagedTables)).toBe('read');
+  const unmanaged = (r.plan.unmanagedTables.tables ?? []).map((t: any) => t.table);
+  expect(unmanaged).toEqual(NOT_AN_OBJECT);
 }
 
 describe('os migrate plan examines exactly what os serve registers, per app shape (#22506)', () => {
 
@@ -29,6 +29,9 @@ import Database from 'better-sqlite3';
  *  - after a development boot, the plan names the sibling, lists no
  *    lifecycle-classed object for the primary, and examines both databases'
  *    objects; `apply` creates nothing, and neither database moves;
+ *  - [#22580] its unmanaged-tables sweep reads the sibling's catalog too: a
+ *    retired lifecycle-classed object strands its table there, and a sweep of
+ *    the primary alone answered `read` without ever looking;
  *  - the CONTROL: a deployment with no sibling (`OS_TELEMETRY_DB=0`) plans as
  *    it always did — no sibling named, nothing pending;
  *  - a plan with the sibling on over a deployment that has none yet plans the
@@ -159,6 +162,11 @@ describe('os migrate plan / apply plan each object against the database it lives
     const siblingTables = tables(f.sibling);
     expect(siblingTables).toEqual(expect.arrayContaining(['sys_audit_log', 'sys_metadata_audit']));
     expect(primaryTables.filter((t) => siblingTables.includes(t)), 'one table in both databases').toEqual([]);
+    // [#22580] What a retired lifecycle-classed object leaves behind: its table,
+    // in the sibling, declared by nothing.
+    const retired = 'sys_os22580_retired_event';
+    const db = new Database(f.sibling);
+    try { db.exec(`CREATE TABLE ${retired} (id TEXT PRIMARY KEY)`); } finally { db.close(); }
     const before = { primary: state(f.primary), sibling: state(f.sibling) };
 
     const plan = command(f, ['plan', '--json']);
@@ -170,6 +178,10 @@ describe('os migrate plan / apply plan each object against the database it lives
     expect(plan.payload.composition?.coverage?.unexaminedObjects).toBe(0);
     // Both databases' objects examined: their tables, less the raw-DDL one.
     expect(plan.payload.managedTables).toBe(primaryTables.length - NOT_AN_OBJECT.length + siblingTables.length);
+    // [#22580] Both databases' catalogs swept: the sibling's stranded table is
+    // reported beside the primary's raw-DDL one.
+    expect(plan.payload.unmanagedTables?.status, JSON.stringify(plan.payload.unmanagedTables)).toBe('read');
+    expect(plan.payload.unmanagedTables.tables.map((t: any) => t.table)).toEqual([...NOT_AN_OBJECT, retired].sort());
     // A plan writes nothing, to either database.
     expect({ primary: state(f.primary), sibling: state(f.sibling) }).toEqual(before);
 
 
@@ -185,6 +185,8 @@ describe('buildSchemaMigrationPlugins', () => {
     expect(out.notes).toEqual([]);
     expect(out.hostConfigPath).toBeNull();
     expect(out.hostConfigLoaded).toBe(false);
+    // [#22580] …and it says so: there is no deployment here to mirror.
+    expect(out.servedBoot).toEqual({ mirrored: false, reason: 'nothing-to-compose' });
   });
 
   it('composes the platform floor once an artifact app is present, and not twice', async () => {
@@ -468,7 +470,7 @@ describe('describeUnloadableHostConfig (#12953)', () => {
   function composition(over: Partial<SchemaMigrationComposition>): SchemaMigrationComposition {
     return {
       plugins: [], hostConfigPath: null, hostConfigLoaded: false, hostConfigError: null,
-      notes: [], coverage: null, ...over,
+      servedBoot: { mirrored: false, reason: 'nothing-to-compose' }, notes: [], coverage: null, ...over,
     };
   }
 
@@ -537,7 +539,7 @@ describe('describeUnloadableHostConfig — the no-DDL notice (#13118)', () => {
   function composition(over: Partial<SchemaMigrationComposition>): SchemaMigrationComposition {
     return {
       plugins: [], hostConfigPath: null, hostConfigLoaded: false, hostConfigError: null,
-      notes: [], coverage: null, ...over,
+      servedBoot: { mirrored: false, reason: 'nothing-to-compose' }, notes: [], coverage: null, ...over,
     };
   }
 
@@ -917,6 +919,36 @@ describe('servedPlatform (#22506)', () => {
       'com.objectstack.platform-objects',
     ]);
   }, 60_000);
+
+  /**
+   * [#22580] The composition records, where it decides it, whether its set
+   * mirrors the served boot — the fact `os migrate plan`'s unmanaged-tables
+   * sweep gates on. Every shape a project can be in, each answer its own.
+   */
+  it('[#22580] records whether the set mirrors the served boot — per project shape, never from hostConfigLoaded', async () => {
+    // A compiled artifact and NO config: `hostConfigLoaded` is false, and the
+    // set IS the served boot's once the served platform is composed.
+    const artifactApp = { type: 'app', name: 'plugin.app.demo' };
+    const artifact = await buildSchemaMigrationPlugins({ basePlugins: [artifactApp], cwd: tempProject(), servedPlatform: {} });
+    expect(artifact.hostConfigLoaded).toBe(false);
+    expect(artifact.servedBoot).toEqual({ mirrored: true });
+
+    const config = await buildSchemaMigrationPlugins({ basePlugins: [], cwd: project(APP), servedPlatform: {} });
+    expect(config.servedBoot).toEqual({ mirrored: true });
+
+    // The controls: each set that does NOT mirror the served boot, with its reason.
+    const stackOnly = await buildSchemaMigrationPlugins({ basePlugins: [], cwd: project(APP) });
+    expect(stackOnly.servedBoot).toEqual({ mirrored: false, reason: 'stack-only' });
+
+    const unloadable = await buildSchemaMigrationPlugins({
+      basePlugins: [], cwd: project("throw new Error('fixture: os22580 unloadable');\n"), servedPlatform: {},
+    });
+    expect(unloadable.hostConfigLoaded).toBe(false);
+    expect(unloadable.servedBoot).toEqual({ mirrored: false, reason: 'config-unloadable' });
+
+    const nothing = await buildSchemaMigrationPlugins({ basePlugins: [], cwd: tempProject(), servedPlatform: {} });
+    expect(nothing.servedBoot).toEqual({ mirrored: false, reason: 'nothing-to-compose' });
+  }, 120_000);
 });
 
 describe('composeProviderForDeclarations (#22506)', () => {
 
@@ -130,12 +130,15 @@ describe('os migrate plan — unmanaged tables, against a real database (#13204)
     deferSchemaDdl: true,
     readOnlyProbe: true,
     composeHostStack: true,
+    // [#22506] `plan` composes what `os serve` mounts around the stack too —
+    // and [#22580] the sweep runs only over a set that mirrors the served boot.
+    composeServedPlatform: true,
   });
 
   async function sweep(): Promise<UnmanagedTablesReport> {
     const { normalizeRows } = await import('@objectstack/metadata-protocol');
     return collectUnmanagedTables({
-      driver: stack!.driver,
+      drivers: stack!.drivers,
       declaredObjects: stack!.allObjects(),
       composition: stack!.composition,
       normalize: normalizeRows,
@@ -198,6 +201,7 @@ describe('os migrate plan — unmanaged tables, against a real database (#13204)
     // assertion below pass for the wrong reason.
     expect(stack!.driver).not.toBeNull();
     expect(stack!.composition.hostConfigLoaded).toBe(true);
+    expect(stack!.composition.servedBoot).toEqual({ mirrored: true });
     expect(stack!.managedTableCount).toBeGreaterThan(0);
     const declared = (stack!.allObjects() as Array<{ name?: string }>).map((o) => o?.name);
     expect(declared).toContain('sys_permission_set');