@astryxdesign/cli 0.6.3 → 0.6.4-canary.0e1fbdb

package/api/upgrade/_adapter.mjs

@@ -19,7 +19,10 @@ import * as path from 'node:path';
 import {execFile} from 'node:child_process';
 import {promisify} from 'node:util';
 import {ensureJscodeshift} from '../../assets/codemods/ensure-jscodeshift.mjs';
-import {getTransformsBetween, latestVersion} from '../../assets/codemods/registry.mjs';
+import {
+  getTransformsBetween,
+  latestVersion,
+} from '../../assets/codemods/registry.mjs';
 import {runCodemods} from '../../assets/codemods/runner.mjs';
 import {
   discoverIntegrationCodemods,
@@ -32,14 +35,15 @@ import {
   renderAgentDocsBlock,
 } from '../../foundation/agent-docs/agent-docs.mjs';
 import {formatCliCommand} from '../../foundation/env/package-manager.mjs';
-import {Project} from '../../foundation/config/project.mjs';
+import {Project, providerLedgerOf} from '../../foundation/config/project.mjs';
 import {loadIntegrations} from '../../foundation/integrations/integrations.mjs';
+import {resolveProviders} from '../../foundation/integrations/provider-resolution.mjs';
 import {warnOnIntegrationIssues} from '../../foundation/integrations/integration-warnings.mjs';
 import {logger} from '../logger.mjs';
 
 // Re-exported for the run leaf's lightweight agent-docs inspection path
 // (config_fixable short-circuit, where the full render cannot load config).
-export { inspectAgentDocs };
+export {inspectAgentDocs};
 
 const execFileAsync = promisify(execFile);
 
@@ -101,6 +105,27 @@ export function uniqueFiles(files) {
   ];
 }
 
+/**
+ * Run app code with its stdout writes sent to stderr. Stdout carries only the
+ * command's own output, so a hook that prints cannot corrupt `--json`.
+ * @template T
+ * @param {() => T | Promise<T>} fn
+ * @returns {Promise<T>}
+ */
+async function withStdoutOnStderr(fn) {
+  const realWrite = process.stdout.write;
+  process.stdout.write = /** @type {any} */ (
+    function (/** @type {any} */ chunk, /** @type {any[]} */ ...rest) {
+      return process.stderr.write(chunk, ...rest);
+    }
+  );
+  try {
+    return await fn();
+  } finally {
+    process.stdout.write = realWrite;
+  }
+}
+
 /**
  * Run the app config's post-codemod hooks (config.hooks.postCodemod).
  * Dry-run PREVIEWS (buildCommand still called, so a throw fails); apply executes.
@@ -120,7 +145,9 @@ export async function runPostCodemodHooks(hooks, context) {
       );
     }
 
-    const cmd = await hook.buildCommand({packageDir, files});
+    const cmd = await withStdoutOnStderr(() =>
+      hook.buildCommand({packageDir, files}),
+    );
     if (!cmd) {
       logger.log(`Post-codemod hook ${label} produced no command; skipping.`);
       continue;
@@ -144,7 +171,7 @@ export async function runPostCodemodHooks(hooks, context) {
         env: {...process.env, ...(cmd.options?.env ?? {})},
       }),
     );
-    logger.log(`✓ Post-codemod hook ${label} completed.`);
+    logger.log(`[ok] Post-codemod hook ${label} completed.`);
   }
 }
 
@@ -183,7 +210,7 @@ export async function prepareAgentDocsRefresh({
   if (initial.status === 'missing') {
     summary.action = 'nudge-init';
     logger.warn(
-      `No Astryx agent-docs block found — AI agents have no component index. Run \`${formatCliCommand('astryx init --features agents')}\` to install it.`,
+      `No Astryx agent-docs block found - AI agents have no component index. Run \`${formatCliCommand('astryx init --features agents')}\` to install it.`,
     );
     return {cwd, renderedBlock: null, summary};
   }
@@ -237,7 +264,7 @@ export function applyAgentDocsRefresh(plan) {
     summary.files = written;
     summary.action = summary.refreshed ? 'refreshed' : 'error';
     if (summary.refreshed) {
-      logger.log(`✓ Agent docs refreshed → ${written.join(', ')}`);
+      logger.log(`[ok] Agent docs refreshed -> ${written.join(', ')}`);
     } else {
       logger.warn(
         `Agent docs look stale but couldn't be refreshed. Run \`${formatCliCommand('astryx init --features agents')}\` to reinstall the block.`,
@@ -265,7 +292,13 @@ export async function collectAllCodemods() {
   );
   for (const {version, transforms} of manifests) {
     for (const {name, meta, optional} of transforms) {
-      codemods.push({name, title: meta.title, version, pr: meta.pr, optional: !!optional});
+      codemods.push({
+        name,
+        title: meta.title,
+        version,
+        pr: meta.pr,
+        optional: !!optional,
+      });
     }
   }
   return codemods;
@@ -296,24 +329,36 @@ export async function ensureCodemodDeps({installDeps} = {}) {
  * Run the CORE registry codemods. Runs BEFORE the config is loaded so a core
  * CONFIG codemod can repair a config the strict loader would otherwise reject.
  * @param {CoreVersionManifest[]} versionManifests
- * @param {{apply: boolean, path: string, codemod?: string, skipCodemods: Set<string>}} options
+ * @param {{apply: boolean, path: string, codemod?: string, skipCodemods: Set<string>, root?: string, protection?: {root: string, classify: (file: string) => import('../../foundation/fs/file-protection.mjs').FileProtection[]}, silent?: boolean}} options
  */
-export async function runCoreCodemods(versionManifests, {apply, path: srcPath, codemod, skipCodemods}) {
+export async function runCoreCodemods(
+  versionManifests,
+  {apply, path: srcPath, codemod, skipCodemods, root, protection, silent},
+) {
   return runCodemods(versionManifests, {
     apply,
     path: srcPath,
     codemod,
     skipCodemods,
-    silent: logger.silent,
+    silent: silent ?? logger.silent,
+    root,
+    protection,
   });
 }
 
 /**
  * Load the consumer project's config + integrations. Throws on invalid config;
  * the run leaf decides between the config_fixable preview and a hard abort.
+ *
+ * Provider identity is resolved by the same resolver Project uses, on top of
+ * Project's ledger, under the codemod policy: a package that lists itself runs
+ * its installed copy's released codemods, never the work in progress being
+ * authored, and autolinked and local packages claim provider IDs without
+ * running codemods.
+ *
  * @param {string} cwd
  * @param {string[]} [extraIntegrationSpecs] explicit `--integration` specs
- * @returns {Promise<{postCodemodHooks: import('../../authoring/config/type').PostCodemodHook[], integrations: import('../../foundation/integrations/integrations.mjs').LoadedIntegration[]}>}
+ * @returns {Promise<{postCodemodHooks: import('../../authoring/config/type').PostCodemodHook[], integrations: import('../../foundation/integrations/integrations.mjs').LoadedIntegration[], ledger: import('../../foundation/integrations/provider-resolution.mjs').ProviderLedger}>}
  */
 export async function loadProjectContext(cwd, extraIntegrationSpecs = []) {
   // The CLI debug preflight may already have imported this config before core
@@ -321,12 +366,66 @@ export async function loadProjectContext(cwd, extraIntegrationSpecs = []) {
   // cache entry; ordinary Project discovery remains cached by default.
   const project = await Project.load(cwd, {fresh: true});
   const postCodemodHooks = project.config.hooks?.postCodemod ?? [];
-  const integrationSpecs = uniqueFiles([
-    ...(project.integrations ?? []),
-    ...(extraIntegrationSpecs ?? []),
-  ]);
-  const integrations = await loadIntegrations(integrationSpecs);
-  return {postCodemodHooks, integrations};
+  const configuredSpecs = new Set(project.integrations ?? []);
+  // Configured packages come from Project, which has already resolved provider
+  // identity over configured, autolinked, and local packages. Loading them
+  // again here would let upgrade run codemods from a package Project set aside.
+  // Autolinked packages and the package being authored join only as claimants:
+  // every other command uses them for their provider IDs, but upgrade has
+  // never run their codemods.
+  const candidates = project.loadedIntegrations.flatMap(integration => {
+    const source =
+      !integration.__autolinked && configuredSpecs.has(integration.__spec)
+        ? /** @type {const} */ ('configured')
+        : integration.__autolinked
+          ? /** @type {const} */ ('autolinked')
+          : integration.__local
+            ? /** @type {const} */ ('local')
+            : null;
+    return source == null
+      ? []
+      : [{source, integration, spec: integration.__spec}];
+  });
+  // A package that lists itself runs its installed copy's released codemods,
+  // never the work in progress being authored; the resolver puts that copy in
+  // its place. Naming the package being authored with --integration asks for
+  // the installed copy too.
+  const local = project.loadedIntegrations.find(
+    integration => integration.__local,
+  );
+  const selfListed =
+    local != null && !local.__autolinked && configuredSpecs.has(local.__spec);
+  const installed =
+    local != null && selfListed && project.configPath
+      ? await loadIntegrations([local.__spec], {
+          cwd: path.dirname(project.configPath),
+          resolveProviders: false,
+        })
+      : [];
+  const extraSpecs = uniqueFiles(extraIntegrationSpecs ?? []).filter(
+    spec => !configuredSpecs.has(spec),
+  );
+  const extras =
+    extraSpecs.length === 0
+      ? []
+      : await loadIntegrations(extraSpecs, {resolveProviders: false});
+  const {integrations, ledger} = resolveProviders(
+    [
+      ...candidates,
+      ...installed.map(integration => ({
+        source: /** @type {const} */ ('installed'),
+        integration,
+        spec: integration.__spec,
+      })),
+      ...extras.map(integration => ({
+        source: /** @type {const} */ ('extra'),
+        integration,
+        spec: integration.__spec,
+      })),
+    ],
+    {codemods: true, prior: providerLedgerOf(project)},
+  );
+  return {postCodemodHooks, integrations, ledger};
 }
 
 /**
@@ -361,7 +460,10 @@ export async function selectIntegrationCodemodsFor(integrations, from, to) {
     try {
       const byVersion = await discoverIntegrationCodemods([integration]);
       for (const [version, rawList] of byVersion) {
-        const list = /** @type {Array<import('../../authoring/codemod/type').CodemodEntry>} */ (/** @type {unknown} */ (rawList));
+        const list =
+          /** @type {Array<import('../../authoring/codemod/type').CodemodEntry>} */ (
+            /** @type {unknown} */ (rawList)
+          );
         const existing = integrationCodemodsByVersion.get(version);
         if (existing) existing.push(...list);
         else integrationCodemodsByVersion.set(version, [...list]);
@@ -378,9 +480,21 @@ export async function selectIntegrationCodemodsFor(integrations, from, to) {
 /**
  * Run the file-based INTEGRATION codemods (config codemods first, then code).
  * @param {Array<{version: string, codemods: import('../../authoring/codemod/type').CodemodEntry[]}>} versionGroups
- * @param {{apply: boolean, path: string, codemod?: string, skipCodemods: Set<string>}} options
+ * @param {{apply: boolean, path: string, codemod?: string, skipCodemods: Set<string>, root?: string, protection?: {root: string, classify: (file: string) => import('../../foundation/fs/file-protection.mjs').FileProtection[]}, contents?: Map<string, string>, silent?: boolean}} options
  */
-export async function runIntegrationCodemodsStep(versionGroups, {apply, path: srcPath, codemod, skipCodemods}) {
+export async function runIntegrationCodemodsStep(
+  versionGroups,
+  {
+    apply,
+    path: srcPath,
+    codemod,
+    skipCodemods,
+    root,
+    protection,
+    contents,
+    silent,
+  },
+) {
   const jscodeshift = (await import('jscodeshift')).default;
   return runIntegrationCodemods(versionGroups, {
     apply,
@@ -388,6 +502,9 @@ export async function runIntegrationCodemodsStep(versionGroups, {apply, path: sr
     codemod,
     skipCodemods,
     jscodeshift,
-    silent: logger.silent,
+    silent: silent ?? logger.silent,
+    root,
+    protection,
+    contents,
   });
 }

package/api/upgrade/list/list.mjs

@@ -10,6 +10,7 @@
 
 import {collectAllCodemods} from '../_adapter.mjs';
 import {logger} from '../../logger.mjs';
+import {toAscii} from '../../../assets/codemods/term-log.mjs';
 
 /**
  * List every available codemod (oldest→newest).
@@ -19,7 +20,7 @@ export async function list() {
   const codemods = await collectAllCodemods();
   logger.log('Available codemods:');
   for (const {name, title, pr, optional} of codemods) {
-    logger.log(`  ${name} — ${title}${optional ? ' (optional)' : ''} (${pr})`);
+    logger.log(`  ${name} - ${toAscii(title)}${optional ? ' (optional)' : ''} (${pr})`);
   }
   logger.log('Done\n');
   return {

package/api/upgrade/list/list.test.mjs

@@ -0,0 +1,73 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Colocated tests for the upgrade.list leaf: every field an entry
+ * carries is declared on the canonical `UpgradeListEntry` type, and every
+ * declared field is present on every entry.
+ */
+
+import {describe, it, expect} from 'vitest';
+import * as fs from 'node:fs';
+import {fileURLToPath} from 'node:url';
+import ts from 'typescript';
+import {list} from './list.mjs';
+
+const TYPE_FILE = fileURLToPath(
+  new URL('../upgrade.type.mjs', import.meta.url),
+);
+
+/**
+ * Property names a JSDoc `@typedef {object}` declares, parsed from the file.
+ * @param {string} typedefName
+ * @returns {string[]}
+ */
+function declaredProperties(typedefName) {
+  const source = ts.createSourceFile(
+    TYPE_FILE,
+    fs.readFileSync(TYPE_FILE, 'utf8'),
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.JS,
+  );
+  /** @type {string[]} */
+  const names = [];
+  for (const statement of source.statements) {
+    for (const doc of /** @type {any} */ (statement).jsDoc ?? []) {
+      for (const tag of doc.tags ?? []) {
+        if (
+          !ts.isJSDocTypedefTag(tag) ||
+          tag.name?.getText(source) !== typedefName
+        ) {
+          continue;
+        }
+        const literal = tag.typeExpression;
+        if (literal && ts.isJSDocTypeLiteral(literal)) {
+          for (const property of literal.jsDocPropertyTags ?? []) {
+            names.push(property.name.getText(source));
+          }
+        }
+      }
+    }
+  }
+  return names.sort();
+}
+
+describe('upgrade.list entries', () => {
+  it('carry exactly the fields UpgradeListEntry declares', async () => {
+    const declared = declaredProperties('UpgradeListEntry');
+    expect(declared.length).toBeGreaterThan(0);
+
+    const {type, data} = await list();
+    expect(type).toBe('upgrade.list');
+    expect(data.length).toBeGreaterThan(0);
+    for (const entry of data) {
+      expect(Object.keys(entry).sort()).toEqual(declared);
+    }
+  });
+
+  it('marks optional codemods with a boolean', async () => {
+    const {data} = await list();
+    for (const entry of data) expect(typeof entry.optional).toBe('boolean');
+    expect(data.some(entry => entry.optional)).toBe(true);
+  });
+});

package/api/upgrade/project-context.test.mjs

@@ -0,0 +1,272 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file `loadProjectContext` agrees with Project on provider identity, so
+ * `astryx upgrade` never runs codemods from a package Project set aside.
+ *
+ * Fixtures live under a repo-local temp dir, not /tmp, because Vite refuses to
+ * dynamically import a module from outside the project root.
+ */
+
+import {afterEach, beforeEach, describe, expect, it} from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {loadProjectContext, selectIntegrationCodemodsFor} from './_adapter.mjs';
+
+let tmpDir;
+let originalCwd;
+
+beforeEach(() => {
+  originalCwd = process.cwd();
+  tmpDir = fs.mkdtempSync(path.join(process.cwd(), '.astryx-upgrade-context-'));
+});
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  fs.rmSync(tmpDir, {recursive: true, force: true});
+});
+
+/**
+ * Install an integration package that ships one 0.2.0 codemod.
+ * @param {string} name
+ * @param {string} version
+ * @param {Record<string, unknown>} [manifest]
+ */
+function installWithCodemod(name, version, manifest = {}) {
+  const pkgDir = path.join(tmpDir, 'node_modules', ...name.split('/'));
+  const codemodDir = path.join(pkgDir, 'codemods', '0.2.0');
+  fs.mkdirSync(codemodDir, {recursive: true});
+  fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify({name, version}));
+  fs.writeFileSync(
+    path.join(pkgDir, 'astryx.integration.mjs'),
+    `export default ${JSON.stringify({codemods: './codemods', ...manifest})};\n`,
+  );
+  fs.writeFileSync(
+    path.join(codemodDir, 'rename.mjs'),
+    "export default {type: 'code', title: 'Rename', transform: file => file.source};\n",
+  );
+}
+
+/** @param {string[]} integrations */
+function configure(integrations) {
+  fs.writeFileSync(
+    path.join(tmpDir, 'astryx.config.mjs'),
+    `export default ${JSON.stringify({integrations})};\n`,
+  );
+}
+
+describe('loadProjectContext provider identity', () => {
+  it('keeps codemods from a configured package the authored package sets aside', async () => {
+    installWithCodemod('@acme/widgets', '1.0.0');
+    configure(['@acme/widgets']);
+    fs.writeFileSync(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({name: '@acme/renamed', version: '2.0.0-dev'}),
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'astryx.integration.mjs'),
+      "export default {providerId: '@acme/widgets'};\n",
+    );
+
+    const {integrations} = await loadProjectContext(tmpDir);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        Boolean(integration.__providerConflict),
+      ]),
+    ).toEqual([['@acme/widgets', true]]);
+    expect(
+      await selectIntegrationCodemodsFor(integrations, '0.1.0', '0.3.0'),
+    ).toEqual([]);
+  });
+
+  it('still selects codemods from a configured package nothing else claims', async () => {
+    installWithCodemod('@acme/widgets', '1.0.0');
+    configure(['@acme/widgets']);
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({name: 'consumer'}));
+
+    const {integrations} = await loadProjectContext(tmpDir);
+    const selected = await selectIntegrationCodemodsFor(integrations, '0.1.0', '0.3.0');
+    expect(selected.map(entry => entry.version)).toEqual(['0.2.0']);
+  });
+
+  it('sets aside an --integration extra that claims a configured provider ID', async () => {
+    installWithCodemod('@acme/widgets', '1.0.0');
+    installWithCodemod('@acme/other', '1.0.0', {providerId: '@acme/widgets'});
+    configure(['@acme/widgets']);
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({name: 'consumer'}));
+    // `--integration` specs resolve from the process cwd, as they always have.
+    process.chdir(tmpDir);
+
+    const {integrations} = await loadProjectContext(tmpDir, ['@acme/other']);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        integration.__providerConflict?.claimedBy ?? null,
+      ]),
+    ).toEqual([
+      ['@acme/widgets', null],
+      ['@acme/other', '@acme/widgets'],
+    ]);
+  });
+
+  it('runs the installed copy of a package that lists itself, not its work in progress', async () => {
+    installWithCodemod('@acme/widgets', '1.0.0');
+    configure(['@acme/widgets']);
+    fs.writeFileSync(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({name: '@acme/widgets', version: '3.0.0-dev'}),
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'astryx.integration.mjs'),
+      "export default {codemods: './codemods'};\n",
+    );
+    fs.mkdirSync(path.join(tmpDir, 'codemods', '0.2.0'), {recursive: true});
+    fs.writeFileSync(
+      path.join(tmpDir, 'codemods', '0.2.0', 'local-wip.mjs'),
+      "export default {type: 'code', title: 'Local WIP', transform: file => file.source};\n",
+    );
+
+    const {integrations} = await loadProjectContext(tmpDir);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        integration.version,
+        Boolean(integration.__local),
+        Boolean(integration.__providerConflict),
+      ]),
+    ).toEqual([['@acme/widgets', '1.0.0', false, false]]);
+    const selected = JSON.stringify(
+      await selectIntegrationCodemodsFor(integrations, '0.1.0', '0.3.0'),
+    );
+    expect(selected).toContain('rename');
+    expect(selected).not.toContain('local-wip');
+  });
+
+  it('runs the installed copy when the authored package is named with --integration', async () => {
+    installWithCodemod('@acme/widgets', '1.0.0');
+    configure([]);
+    fs.writeFileSync(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({name: '@acme/widgets', version: '3.0.0-dev'}),
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'astryx.integration.mjs'),
+      "export default {codemods: './codemods'};\n",
+    );
+    fs.mkdirSync(path.join(tmpDir, 'codemods', '0.2.0'), {recursive: true});
+    fs.writeFileSync(
+      path.join(tmpDir, 'codemods', '0.2.0', 'local-wip.mjs'),
+      "export default {type: 'code', title: 'Local WIP', transform: file => file.source};\n",
+    );
+    process.chdir(tmpDir);
+
+    const {integrations} = await loadProjectContext(tmpDir, ['@acme/widgets']);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        integration.version,
+        Boolean(integration.__local),
+        integration.__providerConflict?.claimedBy ?? null,
+      ]),
+    ).toEqual([['@acme/widgets', '1.0.0', false, null]]);
+    const selected = JSON.stringify(
+      await selectIntegrationCodemodsFor(integrations, '0.1.0', '0.3.0'),
+    );
+    expect(selected).toContain('rename');
+    expect(selected).not.toContain('local-wip');
+  });
+
+  it("sets aside an --integration extra that claims an autolinked package's ID", async () => {
+    installWithCodemod('@acme/a', '1.0.0');
+    installWithCodemod('@acme/b', '1.0.0', {providerId: '@acme/a'});
+    configure([]);
+    fs.writeFileSync(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({name: 'consumer', dependencies: {'@acme/a': '1.0.0'}}),
+    );
+    process.chdir(tmpDir);
+
+    const {integrations} = await loadProjectContext(tmpDir, ['@acme/b']);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        integration.__providerConflict?.claimedBy ?? null,
+      ]),
+    ).toEqual([['@acme/b', '@acme/a']]);
+    expect(
+      await selectIntegrationCodemodsFor(integrations, '0.1.0', '0.3.0'),
+    ).toEqual([]);
+  });
+
+  it('runs an autolinked package the user names with --integration', async () => {
+    installWithCodemod('@acme/a', '1.0.0');
+    fs.writeFileSync(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({name: 'consumer', dependencies: {'@acme/a': '1.0.0'}}),
+    );
+    process.chdir(tmpDir);
+
+    const {integrations} = await loadProjectContext(tmpDir, ['@acme/a']);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        integration.__providerConflict?.claimedBy ?? null,
+      ]),
+    ).toEqual([['@acme/a', null]]);
+    const selected = await selectIntegrationCodemodsFor(integrations, '0.1.0', '0.3.0');
+    expect(selected.map(entry => entry.version)).toEqual(['0.2.0']);
+  });
+
+  it('never reports a claimant that every other command uses as set aside', async () => {
+    installWithCodemod('@acme/widgets', '1.0.0');
+    installWithCodemod('@acme/renamed', '2.0.0', {providerId: '@acme/widgets'});
+    configure(['@acme/widgets']);
+    fs.writeFileSync(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({
+        name: '@acme/widgets',
+        version: '3.0.0-dev',
+        dependencies: {'@acme/renamed': '2.0.0'},
+      }),
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'astryx.integration.mjs'),
+      "export default {providerId: '@acme/widgets-next'};\n",
+    );
+
+    const {integrations} = await loadProjectContext(tmpDir);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        integration.version,
+        integration.__providerConflict?.claimedBy ?? null,
+      ]),
+    ).toEqual([['@acme/widgets', '1.0.0', null]]);
+  });
+
+  it("sets aside an --integration extra that claims the authored package's ID", async () => {
+    installWithCodemod('@acme/widgets', '1.0.0');
+    configure([]);
+    fs.writeFileSync(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({name: '@acme/renamed', version: '2.0.0-dev'}),
+    );
+    fs.writeFileSync(
+      path.join(tmpDir, 'astryx.integration.mjs'),
+      "export default {providerId: '@acme/widgets'};\n",
+    );
+    process.chdir(tmpDir);
+
+    const {integrations} = await loadProjectContext(tmpDir, ['@acme/widgets']);
+    expect(
+      integrations.map(integration => [
+        integration.name,
+        integration.__providerConflict?.claimedBy ?? null,
+      ]),
+    ).toEqual([['@acme/widgets', '@acme/renamed']]);
+    expect(
+      await selectIntegrationCodemodsFor(integrations, '0.1.0', '0.3.0'),
+    ).toEqual([]);
+  });
+});