@@ -0,0 +1,23 @@
+---
+'@objectstack/cli': patch
+---
+
+feat(cli)!: `os migrate plan` / `apply` refuse a config whose AI plugin only `os serve` would mount, reading serve's own AI auto-inject rule
+
+Clause-②: no (narrowing)
+Metadata-protocol: none
+Skills-docs: none — no file under `skills/**` teaches that `os serve` auto-injects the AI plugin or that `os migrate` composes it: `skills/objectstack-platform` names `AIServicePlugin` as cloud / EE only and mounted by the cloud host, which is the explicit mount the refusal asks for; `content/docs/` does not describe the migrate composition's AI handling either.
+
+<!-- adr-0087: not-required (no-migration-prescription) No key of any schema or export is added, removed, renamed or re-shaped. What moves is the migrate commands' answer to a config that relies on serve's AI auto-inject: they refuse it before planning, and the remedy is one line in the config, not a rewrite of anything at rest. -->
+
+`os serve` auto-injects the AI service plugin (`@objectstack/service-ai`) when the stack's `requires` names `ai` or `ai-studio`, or the app's own `package.json` declares `@objectstack/service-ai` or `@objectstack/service-ai-studio`, unless the `ai` tier is off. That rule now lives in one exported predicate (`resolveAiServiceLoad`, with `mountsAiServicePlugin` for "the config already mounts it"). `serve` decides what it loads with it, unchanged for every input, and the composition the migrate commands share (`os migrate plan`, `os migrate apply`, the organization-ownership ceremony's `--apply`, and `os migrate unmapped-columns`) refuses with it.
+
+**BREAKING** the migrate commands refuse a config they used to plan without the AI tables.
+
+- **Why.** The migrate commands compose what `serve` composes so they plan the same tables, but they did not compose the AI plugin `serve` injects. A config with `requires: ['ai']` and no AI plugin got a plan with none of the `ai_*` tables `serve` declares, and `apply` applied it.
+- **Before.** That config planned and applied with exit 0, and the AI tables were missing from the plan.
+- **Now.** The run stops before planning with exit 1. The JSON `error` (and the ceremony's `boot-failed` detail) says that `os serve` auto-injects the AI plugin for this config, why (the `requires` token or the `package.json` dependency), and the remedy: mount the AI plugin explicitly in the config (`plugins: [new AIServicePlugin()]`, from `@objectstack/service-ai`), then re-run.
+- **Who moves.** An app that relies on `serve`'s AI auto-inject and runs `os migrate`. Add the plugin to the config's `plugins`; `serve` then counts it as mounted and injects nothing, so it boots the same.
+- **Unchanged.** A config that mounts the AI plugin plans as today. A config with the `ai` tier off (`tiers` without `ai`, or a preset without it) plans as today, as does a config that neither requires nor declares AI. `os serve` loads the same plugins for every config.
+
+A composition that refuses (this one or any other) now hands stdout back before it throws, so the reservation the migrate boot takes for its JSON document no longer outlives the command.
@@ -0,0 +1,240 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isExitSignal } from '../../utils/format.js';
+import MigratePlan from './plan.js';
+import MigrateApply from './apply.js';
+import MigrateOrganizationOwnership from './organization-ownership.js';
+
+// Pay the first transform of the dist-resolved workspace deps the commands
+// reach through dynamic `import()`s at MODULE LOAD, not inside a case.
+import '@objectstack/runtime';
+import '@objectstack/objectql';
+import '@objectstack/plugin-auth';
+import '@objectstack/plugin-security';
+import '@objectstack/metadata-protocol';
+import '@objectstack/platform-objects/plugin';
+import '@objectstack/platform-objects/system';
+import '@objectstack/spec/automation';
+import '@objectstack/rest';
+import '@objectstack/service-datasource';
+import '@objectstack/driver-sql';
+import '@objectstack/driver-turso';
+
+/**
+ * `os migrate plan` / `apply` and the organization-ownership ceremony compose
+ * what `os serve` mounts around a stack (`composeServedPlatform`). `serve`
+ * auto-injects `@objectstack/service-ai` when the config mounts no AI plugin
+ * and declares `requires: ['ai']` (or `['ai-studio']`), or when the app's
+ * `package.json` declares the package, unless the `ai` tier is off. The
+ * migrate commands compose no AI plugin, so on such a host they plan without
+ * the `ai_*` tables `serve` would declare.
+ *
+ * Ruled B (the maintainer's 「以上都同意」, recorded on the card): the
+ * migrate commands refuse that config, naming the reason and the remedy —
+ * mount the AI plugin explicitly in the config — through the one predicate
+ * `serve` itself reads (`resolveAiServiceLoad`).
+ *
+ * Controls: a config that mounts the AI plugin explicitly, a config whose
+ * `ai` tier is off, and a config that asks for no AI, all plan as before.
+ */
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const CLI_ROOT = resolve(HERE, '..', '..', '..');
+const CASE_TIMEOUT_MS = 240_000;
+const REMEDY = /mount the AI plugin explicitly in the config/;
+
+const ENV_KEYS = [
+  'OS_DATABASE_URL', 'DATABASE_URL', 'TURSO_DATABASE_URL', 'OS_DATABASE_DRIVER', 'OS_HOME',
+  'OS_TELEMETRY_DB', 'OS_AUTH_SECRET', 'AUTH_SECRET', 'BETTER_AUTH_SECRET', 'OS_ARTIFACT_PATH', 'NODE_ENV',
+] as const;
+
+type Invoke = (argv: string[]) => Promise<unknown>;
+const invoke = (command: { run: (argv: string[], opts: { root: string }) => Promise<unknown> }): Invoke =>
+  (argv) => command.run(argv, { root: CLI_ROOT });
+
+/** Run a command with stdout captured, its exits trapped, and its JSON document parsed. */
+async function runJson(command: Invoke, argv: string[]): Promise<{ payload: any; exitCode: number }> {
+  const savedExit = process.exitCode;
+  const swallow = ((_chunk: unknown, ...rest: unknown[]) => {
+    const cb = rest.find((a) => typeof a === 'function') as (() => void) | undefined;
+    if (cb) cb();
+    return true;
+  }) as typeof process.stdout.write;
+  const stdout = vi.spyOn(process.stdout, 'write').mockImplementation(swallow);
+  vi.spyOn(process.stderr, 'write').mockImplementation(swallow);
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'warn').mockImplementation(() => {});
+  let processExit: number | undefined;
+  vi.spyOn(process, 'exit').mockImplementation(((code?: number) => {
+    processExit = code ?? 0;
+    throw new Error(`__PROCESS_EXIT__:${processExit}`);
+  }) as never);
+  let thrownExit: number | undefined;
+  try {
+    try {
+      await command(argv);
+    } catch (error) {
+      const trapped = error instanceof Error && error.message.startsWith('__PROCESS_EXIT__');
+      if (!trapped && !isExitSignal(error)) throw error;
+      if (!trapped) thrownExit = (error as { oclif?: { exit?: number } }).oclif?.exit;
+    }
+    const out = stdout.mock.calls.map((c) => String(c[0])).join('').trim();
+    // The boot's log lines share stdout with the document on some paths: the
+    // document is the last whole line that parses as a JSON object.
+    let payload: any = { unparsed: out.slice(-400) };
+    for (const line of out.split('\n').reverse()) {
+      if (!line.startsWith('{')) continue;
+      try {
+        payload = JSON.parse(line);
+        break;
+      } catch { /* a log fragment */ }
+    }
+    if (payload.unparsed !== undefined) {
+      try { payload = JSON.parse(out); } catch { /* left unparsed */ }
+    }
+    return { payload, exitCode: processExit ?? thrownExit ?? (process.exitCode as number | undefined) ?? 0 };
+  } finally {
+    process.exitCode = savedExit;
+    vi.restoreAllMocks();
+  }
+}
+
+const dirs: string[] = [];
+const savedEnv: Record<string, string | undefined> = {};
+let savedCwd: string;
+
+/**
+ * A config-only project. `config` is the config's extra keys, as source text;
+ * `dependencies` is the app's own `package.json` dependencies.
+ */
+function project(config: string[], dependencies: Record<string, string> = {}): string {
+  const dir = mkdtempSync(join(tmpdir(), 'os-31411-ai-'));
+  dirs.push(dir);
+  mkdirSync(join(dir, 'dist'), { recursive: true });
+  writeFileSync(
+    join(dir, 'objectstack.config.ts'),
+    [
+      'export default {',
+      "  manifest: { id: 'com.example.os31411ai', name: 'ai', version: '0.0.0', type: 'app' },",
+      "  objects: [{ name: 'os31411_thing', fields: { title: { type: 'text' } } }],",
+      ...config.map((line) => `  ${line}`),
+      '};',
+      '',
+    ].join('\n'),
+  );
+  writeFileSync(
+    join(dir, 'package.json'),
+    `${JSON.stringify({ name: 'os31411-ai-host', version: '0.0.0', private: true, dependencies }, null, 2)}\n`,
+  );
+  return dir;
+}
+
+/** Enter the fixture as the operator's shell would. */
+function enter(dir: string): void {
+  process.env.NODE_ENV = 'production';
+  process.env.OS_TELEMETRY_DB = '0';
+  process.env.OS_ARTIFACT_PATH = join(dir, 'dist', 'objectstack.json');
+  process.env.OS_DATABASE_URL = `file:${join(dir, 'app.db')}`;
+  process.chdir(dir);
+}
+
+/** The AI plugin, mounted explicitly: `serve` reads it by its registered name. */
+const EXPLICIT_AI_PLUGIN =
+  "plugins: [{ name: 'com.objectstack.service-ai', version: '0.0.0', init: async () => {}, start: async () => {} }],";
+
+beforeAll(() => {
+  savedCwd = process.cwd();
+  for (const key of ENV_KEYS) savedEnv[key] = process.env[key];
+});
+
+beforeEach(() => {
+  for (const key of ENV_KEYS) delete process.env[key];
+});
+
+afterEach(() => {
+  process.chdir(savedCwd);
+  for (const key of ENV_KEYS) {
+    const value = savedEnv[key];
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
+
+afterAll(() => {
+  for (const d of dirs) {
+    try { rmSync(d, { recursive: true, force: true }); } catch { /* best-effort */ }
+  }
+});
+
+describe('os migrate refuses a config that relies on serve\'s AI auto-inject', () => {
+  it('⭐ requires: [ai] and no AI plugin: plan and apply refuse, naming the reason and the remedy', async () => {
+    enter(project(["requires: ['ai'],"]));
+
+    const plan = await runJson(invoke(MigratePlan), ['--json']);
+    expect(plan.exitCode, JSON.stringify(plan.payload).slice(0, 400)).toBe(1);
+    expect(plan.payload.error).toMatch(/requires/);
+    expect(plan.payload.error).toMatch(/@objectstack\/service-ai/);
+    expect(plan.payload.error).toMatch(REMEDY);
+
+    const apply = await runJson(invoke(MigrateApply), ['--json']);
+    expect(apply.exitCode, JSON.stringify(apply.payload).slice(0, 400)).toBe(1);
+    expect(apply.payload.error, JSON.stringify(apply.payload).slice(0, 600)).toMatch(REMEDY);
+  }, CASE_TIMEOUT_MS);
+
+  it('⭐ the app\'s package.json declares @objectstack/service-ai and the config mounts no AI plugin: plan refuses', async () => {
+    enter(project([], { '@objectstack/service-ai': '*' }));
+
+    const plan = await runJson(invoke(MigratePlan), ['--json']);
+    expect(plan.exitCode, JSON.stringify(plan.payload).slice(0, 400)).toBe(1);
+    expect(plan.payload.error, JSON.stringify(plan.payload).slice(0, 600)).toMatch(/package\.json/);
+    expect(plan.payload.error).toMatch(REMEDY);
+  }, CASE_TIMEOUT_MS);
+
+  it('⭐ the organization-ownership ceremony\'s --apply refuses the same config at its boot', async () => {
+    const dir = project(["requires: ['ai-studio'],"]);
+    enter(dir);
+    // A well-formed plan file: the refusal comes at the boot, before any plan is compared.
+    const planFile = join(dir, 'plan.json');
+    writeFileSync(planFile, JSON.stringify({
+      kind: 'organization-ownership-plan', ceremony: 'ADR-0131 D10', inventoryDigest: 'sha256:fixture',
+      database: join(dir, 'app.db'), generatedAt: '2026-11-08T00:00:00.000Z', posture: 'single',
+    }));
+
+    const ceremony = await runJson(
+      invoke(MigrateOrganizationOwnership),
+      ['--apply', '--backup-taken', '--plan-file', planFile, '--out', join(dir, 'apply.json'), '--json'],
+    );
+    expect(ceremony.exitCode, JSON.stringify(ceremony.payload).slice(0, 400)).toBe(1);
+    expect(ceremony.payload, JSON.stringify(ceremony.payload).slice(0, 600)).toMatchObject({ reason: 'boot-failed', detail: expect.stringMatching(REMEDY) });
+  }, CASE_TIMEOUT_MS);
+
+  it('control: the AI plugin mounted explicitly plans as before', async () => {
+    enter(project(["requires: ['ai'],", EXPLICIT_AI_PLUGIN], { '@objectstack/service-ai': '*' }));
+
+    const plan = await runJson(invoke(MigratePlan), ['--json']);
+    expect(plan.exitCode, JSON.stringify(plan.payload).slice(0, 400)).toBe(0);
+    expect(plan.payload.error).toBeUndefined();
+  }, CASE_TIMEOUT_MS);
+
+  it('control: the ai tier off — serve injects nothing for a declared dependency — plans as before', async () => {
+    enter(project(["tiers: ['core', 'i18n', 'ui', 'auth'],"], { '@objectstack/service-ai': '*' }));
+
+    const plan = await runJson(invoke(MigratePlan), ['--json']);
+    expect(plan.exitCode, JSON.stringify(plan.payload).slice(0, 400)).toBe(0);
+    expect(plan.payload.error).toBeUndefined();
+  }, CASE_TIMEOUT_MS);
+
+  it('control: a config that asks for no AI plans as before', async () => {
+    enter(project([]));
+
+    const plan = await runJson(invoke(MigratePlan), ['--json']);
+    expect(plan.exitCode, JSON.stringify(plan.payload).slice(0, 400)).toBe(0);
+    expect(plan.payload.error).toBeUndefined();
+  }, CASE_TIMEOUT_MS);
+});
@@ -10,6 +10,7 @@ import { loadConfig, bundleConfigModule } from '../utils/config.js';
 import { mergeBootConfig } from '../utils/merge-boot-config.js';
 import { provisionTelemetryDatasource, standaloneTelemetryPrimary } from '../utils/telemetry-datasource.js';
 import { isHostConfig, shouldBootWithLibrary } from '../utils/plugin-detection.js';
+import { mountsAiServicePlugin, resolveAiServiceLoad, resolveOptionalPluginLoad } from '../utils/ai-service-auto-inject.js';
 import { registerInstalledPlugins } from '../utils/installed-plugins-boot.js';
 import { readInternalArtifactPath, readInternalConfigOutputPath } from '../utils/internal-artifact-channel.js';
 import { readAuthSecretFileChannel } from '../utils/internal-auth-secret-channel.js';
@@ -1650,10 +1651,8 @@ export default class Serve extends Command {
     required: boolean;
     declared: boolean;
   }): 'required' | 'auto' | 'off' {
-    if (!opts.tierAllowed) return 'off';
-    if (opts.required) return 'required';
-    if (opts.declared) return 'auto';
-    return 'off';
+    // [#31411] The rule's one home, shared with `os migrate`.
+    return resolveOptionalPluginLoad(opts);
   }
 
   /**
@@ -4970,10 +4969,7 @@ export default class Serve extends Command {
       // 4. Auto-register AIServicePlugin if not already loaded by config plugins.
       // Registered AFTER Dispatcher so that the ai:routes hook listener is
       // already in place when AIServicePlugin.start() fires the hook.
-      const hasAIPlugin = plugins.some(
-        (p: any) => p.name === 'com.objectstack.service-ai'
-            || p.constructor?.name === 'AIServicePlugin'
-      );
+      const hasAIPlugin = mountsAiServicePlugin(plugins);
       // `importFromHost` (module scope, hoisted over this whole file — it is no
       // longer "declared above" anything, which is the point) resolves optional
       // plugin packages from the HOST APP's context — the app being served
@@ -4996,16 +4992,14 @@ export default class Serve extends Command {
       // now go through the one owner in `@objectstack/types/node`, so "declared"
       // cannot mean two different things in one file (Prime Directive #12).
       const hostDeclaresDependency = (pkg: string): boolean => isDeclaredByHost(pkg, hostRoot);
-      // `wantsAiService` is the AUTO (opt-in) signal: the host app listed the base
-      // AI service — or the Studio that builds on it — in its OWN package.json. This
-      // is a package.json READ (a deliberate authoring act), not a speculative
-      // import: gating on a *declared* dep, not mere resolvability, is reliable in a
+      // The AUTO (opt-in) signal is the host app listing the base AI service — or
+      // the Studio that builds on it — in its OWN package.json. This is a
+      // package.json READ (a deliberate authoring act), not a speculative import:
+      // gating on a *declared* dep, not mere resolvability, is reliable in a
       // workspace/monorepo where a package stays hoist-resolvable when undeclared.
       // Studio implies the base service (it attaches via the `ai:ready` hook the base
       // fires; the base is a transitive dep of Studio, so it stays resolvable).
-      const wantsAiService =
-        hostDeclaresDependency('@objectstack/service-ai')
-        || hostDeclaresDependency('@objectstack/service-ai-studio');
+      // `resolveAiServiceLoad` below reads it.
 
       // Load an optional, separately-published service plugin by INTENT (#1597).
       // `required` (from an explicit `requires: [...]` capability) makes a missing
@@ -5069,12 +5063,12 @@ export default class Serve extends Command {
       // `tiers` omit `ai` never loads it, whatever the intent — so a CE app that
       // omits AI gets no AI service, no agents, and no `services.ai` in discovery
       // (the console hides its AI surface), while every other capability is unaffected.
-      const aiRequired =
-        declaredRequires.has('ai') || declaredRequires.has('ai-studio');
-      const aiDecision = Serve.resolveOptionalPluginLoad({
-        tierAllowed: tierEnabled('ai'),
-        required: aiRequired,
-        declared: wantsAiService,
+      // [#31411] The rule's one reading, shared with `os migrate`, which refuses a
+      // config whose AI plugin only this auto-inject would mount.
+      const aiDecision = resolveAiServiceLoad({
+        declaredRequires,
+        aiTierEnabled: tierEnabled('ai'),
+        hostDeclaresDependency,
       });
       if (!hasAIPlugin && aiDecision !== 'off') {
         // AIServicePlugin auto-detects its LLM provider from environment