@smoothbricks/cli 0.2.0 → 0.3.1

package/src/monorepo/publish-workflow.ts

@@ -341,8 +341,7 @@ function yamlLinesForStep(step: PublishWorkflowStep): string[] {
     case PublishWorkflowStepKind.BuildSelfHostedCli:
       return [
         `      - name: ${step.name}`,
-        '        # SmoothBricks self-hosts smoo from source, but Nx release loads',
-        '        # @smoothbricks/cli/nx-version-actions through the built package export.',
+        '        # SmoothBricks self-hosts smoo from source for release commands.',
         '        run: nx build cli',
       ];
     case PublishWorkflowStepKind.RepairPendingReleases:
@@ -379,7 +378,7 @@ function yamlLinesForStep(step: PublishWorkflowStep): string[] {
       return [
         `      - name: ${step.name}`,
         `        if: ${githubExpression('failure()')}`,
-        '        uses: actions/upload-artifact@v4',
+        '        uses: actions/upload-artifact@v7.0.1',
         '        with:',
         `          name: trace-results-${githubExpression('github.run_id')}`,
         '          path: packages/*/.trace-results.db',

package/src/nx/index.test.ts

@@ -5,6 +5,7 @@ import {
   nxCacheDirectories,
   nxResetCommand,
   nxShowProjectCommand,
+  projectNamesFromNxShowProjectsOutput,
   projectNamesWithTarget,
   targetNamesFromNxProjectJson,
 } from './index.js';
@@ -50,6 +51,14 @@ describe('Nx helper output formatting', () => {
     ).toEqual(['cli', 'web']);
   });
 
+  it('parses JSON project lists from nx show projects', () => {
+    expect(projectNamesFromNxShowProjectsOutput('["web","cli"]\n')).toEqual(['cli', 'web']);
+  });
+
+  it('parses legacy newline project lists from nx show projects', () => {
+    expect(projectNamesFromNxShowProjectsOutput('web\ncli\n')).toEqual(['cli', 'web']);
+  });
+
   it('extracts sorted target names from Nx project JSON', () => {
     expect(targetNamesFromNxProjectJson({ targets: { test: {}, build: {}, lint: {} } })).toEqual([
       'build',

package/src/nx/index.ts

@@ -56,6 +56,30 @@ export function projectNamesWithTarget(projects: ProjectTargets[], target: strin
     .sort((a, b) => a.localeCompare(b));
 }
 
+export function projectNamesFromNxShowProjectsOutput(output: string): string[] {
+  const trimmed = output.trim();
+  if (!trimmed) {
+    return [];
+  }
+
+  if (trimmed.startsWith('[')) {
+    try {
+      const parsed: unknown = JSON.parse(trimmed);
+      if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === 'string')) {
+        return parsed.sort((a, b) => a.localeCompare(b));
+      }
+    } catch {
+      // Fall through to legacy newline parsing for older Nx output shapes.
+    }
+  }
+
+  return trimmed
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .sort((a, b) => a.localeCompare(b));
+}
+
 export async function listTargets(root: string): Promise<void> {
   const output = formatProjectTargetLines(await readProjectTargets(root));
   if (output) {
@@ -100,11 +124,7 @@ export async function readProjectTargets(root: string): Promise<ProjectTargets[]
 
 async function readNxProjectNames(root: string): Promise<string[]> {
   const result = await $`nx show projects`.cwd(root).quiet();
-  return decode(result.stdout)
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .sort((a, b) => a.localeCompare(b));
+  return projectNamesFromNxShowProjectsOutput(decode(result.stdout));
 }
 
 async function readProjectTarget(root: string, project: string): Promise<ProjectTargets> {

package/src/release/__tests__/candidates.test.ts

@@ -11,6 +11,13 @@ const a: ReleasePackageInfo = { name: '@scope/a', projectName: 'a', path: 'packa
 const b: ReleasePackageInfo = { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '1.0.0' };
 const c: ReleasePackageInfo = { name: '@scope/c', projectName: 'c', path: 'packages/c', version: '0.1.0' };
 const d: ReleasePackageInfo = { name: '@scope/d', projectName: 'd', path: 'packages/d', version: '0.1.0' };
+const cli: ReleasePackageInfo = { name: '@scope/cli', projectName: 'cli', path: 'packages/cli', version: '0.2.0' };
+const next: ReleasePackageInfo = {
+  name: '@scope/next',
+  projectName: 'next',
+  path: 'packages/next',
+  version: '1.1.0-next.0',
+};
 
 describe('auto release candidate filtering', () => {
   it('selects tagged packages only when their package path changed', async () => {
@@ -19,8 +26,8 @@ describe('auto release candidate filtering', () => {
       await writePackage(root, b.name, b.path, b.version);
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial packages']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
-      await tag(root, '@scope/b@1.0.0', '2025-01-01T00:00:01Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'b@1.0.0', '2025-01-01T00:00:01Z');
 
       await writeFile(join(root, 'README.md'), 'root-only change\n');
       await git(root, ['add', 'README.md']);
@@ -42,7 +49,7 @@ describe('auto release candidate filtering', () => {
       await writePackage(root, a.name, a.path, a.version);
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial package']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
 
       await mkdir(join(root, a.path), { recursive: true });
       await writeFile(
@@ -72,7 +79,7 @@ describe('auto release candidate filtering', () => {
       await writePackage(root, a.name, a.path, a.version);
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial package']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
 
       await writeFile(
         join(root, a.path, 'package.json'),
@@ -105,7 +112,7 @@ describe('auto release candidate filtering', () => {
       await writeFile(join(root, a.path, 'schema/index.json'), '{}\n');
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial package']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
 
       await writeFile(join(root, a.path, 'schema/index.json'), '{"changed":true}\n');
       await git(root, ['add', join(a.path, 'schema/index.json')]);
@@ -120,7 +127,7 @@ describe('auto release candidate filtering', () => {
       await writePackage(root, a.name, a.path, a.version);
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial package']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
 
       await mkdir(join(root, a.path, 'generated'), { recursive: true });
       await writeFile(join(root, a.path, 'generated/schema.ts'), 'export const schema = 1;\n');
@@ -138,7 +145,7 @@ describe('auto release candidate filtering', () => {
       await writePackage(root, a.name, a.path, a.version);
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial package']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
 
       const shell = gitCandidateShell(root, { buildInputPatterns: ['src/**/*.ts', '!src/**/*.test.ts'] });
 
@@ -167,14 +174,108 @@ describe('auto release candidate filtering', () => {
       await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [c, d])).resolves.toEqual([c]);
     });
   });
+
+  it('does not auto-release an untagged next prerelease package version with no prior stable release', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, next.name, next.path, next.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): prepare next prerelease']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [next])).resolves.toEqual([]);
+    });
+  });
+
+  it('selects a prerelease package when releasable changes exist since the last stable tag', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, next.name, next.path, '1.0.0');
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): publish']);
+      await tag(root, 'next@1.0.0', '2025-01-01T00:00:00Z');
+
+      // Simulate the post-release prerelease bump
+      await writePackage(root, next.name, next.path, next.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): prepare next prerelease']);
+
+      // A real fix lands on the prerelease version
+      await mkdir(join(root, next.path, 'src'), { recursive: true });
+      await writeFile(join(root, next.path, 'src/index.ts'), 'export const fix = true;\n');
+      await git(root, ['add', join(next.path, 'src/index.ts')]);
+      await git(root, ['commit', '-m', 'fix(next): repair something']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [next])).resolves.toEqual([next]);
+    });
+  });
+
+  it('does not select a prerelease package when no releasable changes exist since the last stable tag', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, next.name, next.path, '1.0.0');
+      await mkdir(join(root, next.path, 'src'), { recursive: true });
+      await writeFile(join(root, next.path, 'src/index.ts'), 'export const v1 = true;\n');
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): publish']);
+      await tag(root, 'next@1.0.0', '2025-01-01T00:00:00Z');
+
+      // Only the prerelease bump, no releasable source changes
+      await writePackage(root, next.name, next.path, next.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): prepare next prerelease']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [next])).resolves.toEqual([]);
+    });
+  });
+
+  it('uses a repaired project-name tag as the follow-up auto release baseline for a scoped package', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, cli.name, cli.path, cli.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): publish']);
+      await tag(root, 'cli@0.2.0', '2025-01-01T00:00:00Z');
+
+      await mkdir(join(root, cli.path, 'src'), { recursive: true });
+      await writeFile(join(root, cli.path, 'src/index.ts'), 'export const fixed = true;\n');
+      await git(root, ['add', join(cli.path, 'src/index.ts')]);
+      await git(root, ['commit', '-m', 'fix(cli): repair publish flow']);
+
+      const queriedRefs: string[] = [];
+      const candidates = await autoReleaseCandidatePackages(
+        gitCandidateShell(root, { buildInputPatterns: ['src/**/*.ts'], queriedRefs }),
+        [cli],
+      );
+
+      expect(candidates).toEqual([cli]);
+      expect(queriedRefs).toEqual(['refs/tags/cli@0.2.0']);
+      expect(queriedRefs).not.toContain('refs/tags/@scope/cli@0.2.0');
+    });
+  });
 });
 
-function gitCandidateShell(root: string, options: { buildInputPatterns?: string[] } = {}): AutoReleaseCandidateShell {
+function gitCandidateShell(
+  root: string,
+  options: { buildInputPatterns?: string[]; queriedRefs?: string[] } = {},
+): AutoReleaseCandidateShell {
   return {
     gitRefExists: async (ref) => {
+      options.queriedRefs?.push(ref);
       const result = await $`git rev-parse --verify ${ref}`.cwd(root).quiet().nothrow();
       return result.exitCode === 0;
     },
+    latestStableReleaseRef: async (projectName) => {
+      const pattern = `${projectName}@*`;
+      const result = await $`git tag --list ${pattern} --sort=-v:refname`.cwd(root).quiet().nothrow();
+      if (result.exitCode !== 0) {
+        return null;
+      }
+      const prefix = `${projectName}@`;
+      for (const line of new TextDecoder().decode(result.stdout).split('\n')) {
+        const tagName = line.trim();
+        const version = tagName.slice(prefix.length);
+        if (version && !version.includes('-')) {
+          return `refs/tags/${tagName}`;
+        }
+      }
+      return null;
+    },
     packageChangedFilesSince: async (ref, packagePath) => {
       const result = await $`git diff --name-only ${`${ref}..HEAD`} -- ${packagePath}`.cwd(root).quiet().nothrow();
       if (result.exitCode === 0) {

package/src/release/__tests__/core-properties.test.ts

@@ -122,7 +122,7 @@ function releaseRecords(): fc.Arbitrary<ReleaseTagRecord[]> {
         }
         seen.add(key);
         records.push({
-          tag: `${pkg.name}@${pkg.version}`,
+          tag: `${pkg.projectName}@${pkg.version}`,
           sha,
           timestamp: row.timestamp,
           pkg,
@@ -139,7 +139,7 @@ function record(pkg: ReleasePackageInfo | undefined, sha: string): ReleaseTagRec
     throw new Error('Missing test package fixture.');
   }
   return {
-    tag: `${pkg.name}@${pkg.version}`,
+    tag: `${pkg.projectName}@${pkg.version}`,
     sha,
     timestamp: 1,
     pkg,

package/src/release/__tests__/core-scenarios.test.ts

@@ -30,7 +30,7 @@ function record(
   needs: { npm?: boolean; github?: boolean },
 ): ReleaseTagRecord {
   return {
-    tag: `${pkg.name}@${pkg.version}`,
+    tag: `${pkg.projectName}@${pkg.version}`,
     sha,
     timestamp,
     pkg,
@@ -99,9 +99,9 @@ describe('release core scenario coverage', () => {
     ]);
     const shell: ReleasePlanningShell = {
       listReleaseTagsByCreatorDate: async () => [
-        tag('@scope/stable@1.0.0', 'reachable', 30),
+        tag('stable@1.0.0', 'reachable', 30),
         tag('@other/pkg@9.9.9', 'reachable', 20),
-        tag('@scope/stable@1.0.1', 'unreachable', 10),
+        tag('stable@1.0.1', 'unreachable', 10),
       ],
       isAncestor: async (ancestor) => ancestor === 'reachable',
       packageVersionAtRef: async (packagePath, ref) => {
@@ -120,9 +120,9 @@ describe('release core scenario coverage', () => {
       shell,
     );
 
-    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['@scope/stable@1.0.0']);
+    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['stable@1.0.0']);
     expect(packageVersionRefs).toEqual(['packages/stable:reachable']);
-    expect(durableTags).toEqual(['@scope/stable@1.0.0']);
+    expect(durableTags).toEqual(['stable@1.0.0']);
   });
 
   it('stops querying older package tags after the newest tag for that package is fully durable', async () => {
@@ -134,9 +134,9 @@ describe('release core scenario coverage', () => {
     ]);
     const shell: ReleasePlanningShell = {
       listReleaseTagsByCreatorDate: async () => [
-        tag('@scope/stable@1.1.0', 'newer-stable', 30),
-        tag('@scope/prerelease@2.0.0-beta.1', 'older-prerelease', 20),
-        tag('@scope/stable@1.0.0', 'older-stable', 10),
+        tag('stable@1.1.0', 'newer-stable', 30),
+        tag('prerelease@2.0.0-beta.1', 'older-prerelease', 20),
+        tag('stable@1.0.0', 'older-stable', 10),
       ],
       isAncestor: async () => true,
       packageVersionAtRef: async (packagePath, ref) => versions.get(`${packagePath}:${ref}`) ?? null,
@@ -155,16 +155,13 @@ describe('release core scenario coverage', () => {
       shell,
     );
 
-    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual([
-      '@scope/stable@1.1.0',
-      '@scope/prerelease@2.0.0-beta.1',
-    ]);
-    expect(durableTags).toEqual(['@scope/stable@1.1.0', '@scope/prerelease@2.0.0-beta.1']);
+    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['stable@1.1.0', 'prerelease@2.0.0-beta.1']);
+    expect(durableTags).toEqual(['stable@1.1.0', 'prerelease@2.0.0-beta.1']);
   });
 
   it('throws when a release tag version does not match package.json at the peeled commit', async () => {
     const shell: ReleasePlanningShell = {
-      listReleaseTagsByCreatorDate: async () => [tag('@scope/stable@1.0.0', 'mismatch', 10)],
+      listReleaseTagsByCreatorDate: async () => [tag('stable@1.0.0', 'mismatch', 10)],
       isAncestor: async () => true,
       packageVersionAtRef: async () => '1.0.1',
       durableTagState: async () => ({ npmPublished: true, githubReleaseExists: true }),
@@ -177,7 +174,7 @@ describe('release core scenario coverage', () => {
         shell,
       ),
     ).rejects.toThrow(
-      'Release tag @scope/stable@1.0.0 points at mismatch, but packages/stable/package.json has version 1.0.1.',
+      'Release tag stable@1.0.0 points at mismatch, but packages/stable/package.json has version 1.0.1.',
     );
   });
 });

package/src/release/__tests__/core.test.ts

@@ -1,11 +1,15 @@
 import { describe, expect, it } from 'bun:test';
 import {
+  collectOwnedReleaseTagRecords,
   groupReleaseTargets,
+  legacyReleaseTag,
   npmDistTagForVersion,
   pendingReleaseTargets,
   type ReleasePackageInfo,
   type ReleaseTagRecord,
   releasePackageForTag,
+  releaseTag,
+  releaseTagAliases,
 } from '../core.js';
 
 const a: ReleasePackageInfo = { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '1.0.0' };
@@ -18,7 +22,7 @@ function record(
   needs: { npm?: boolean; github?: boolean },
 ): ReleaseTagRecord {
   return {
-    tag: `${pkg.name}@${pkg.version}`,
+    tag: `${pkg.projectName}@${pkg.version}`,
     sha,
     timestamp,
     pkg,
@@ -29,8 +33,9 @@ function record(
 
 describe('release core planning', () => {
   it('matches owned release tags without semantic version parsing', () => {
-    expect(releasePackageForTag([a], '@scope/a@1.2.3')?.version).toBe('1.2.3');
-    expect(releasePackageForTag([a], '@scope/c@1.2.3')).toBeNull();
+    expect(releasePackageForTag([a], 'a@1.2.3')?.version).toBe('1.2.3');
+    expect(releasePackageForTag([a], '@scope/a@1.2.3')).toBeNull();
+    expect(releasePackageForTag([a], 'c@1.2.3')).toBeNull();
   });
 
   it('groups only repair-needed tags by commit', () => {
@@ -70,4 +75,46 @@ describe('release core planning', () => {
     expect(npmDistTagForVersion('1.0.0')).toBe('latest');
     expect(npmDistTagForVersion('1.0.0-beta.1')).toBe('next');
   });
+
+  it('keeps project-name release tags canonical while recognizing legacy package-name aliases', () => {
+    const scoped = { name: '@scope/a', projectName: 'a', version: '1.0.0' };
+
+    expect(releaseTag(scoped)).toBe('a@1.0.0');
+    expect(legacyReleaseTag(scoped)).toBe('@scope/a@1.0.0');
+    expect(releaseTagAliases(scoped)).toEqual(['a@1.0.0', '@scope/a@1.0.0']);
+  });
+
+  it('checks durable release state concurrently while preserving tag-order records', async () => {
+    const durableCalls: string[] = [];
+    let active = 0;
+    let maxActive = 0;
+    let unblockDurableCalls: (() => void) | undefined;
+    const durableCallsBlocked = new Promise<void>((resolve) => {
+      unblockDurableCalls = resolve;
+    });
+
+    const records = await collectOwnedReleaseTagRecords([a, b], 'head', {
+      listReleaseTagsByCreatorDate: async () => [
+        { name: 'a@1.0.0', sha: 'newer', timestamp: 2 },
+        { name: 'b@2.0.0-beta.1', sha: 'older', timestamp: 1 },
+      ],
+      isAncestor: async () => true,
+      packageVersionAtRef: async (packagePath) => (packagePath === a.path ? a.version : b.version),
+      durableTagState: async (_pkg, tag) => {
+        durableCalls.push(tag);
+        active += 1;
+        maxActive = Math.max(maxActive, active);
+        if (durableCalls.length === 2) {
+          unblockDurableCalls?.();
+        }
+        await durableCallsBlocked;
+        active -= 1;
+        return { npmPublished: false, githubReleaseExists: false };
+      },
+    });
+
+    expect(durableCalls).toEqual(['a@1.0.0', 'b@2.0.0-beta.1']);
+    expect(maxActive).toBeGreaterThan(1);
+    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['a@1.0.0', 'b@2.0.0-beta.1']);
+  });
 });

package/src/release/__tests__/fixture-repo.test.ts

@@ -25,14 +25,14 @@ describe('release planning with fixture git repositories', () => {
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'initial release']);
       const first = await gitOutput(root, ['rev-parse', 'HEAD']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
-      await tag(root, '@scope/b@1.0.0', '2025-01-01T00:00:01Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'b@1.0.0', '2025-01-01T00:00:01Z');
 
       await writePackage(root, '@scope/a', 'packages/a', '1.1.0');
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'second release']);
       const second = await gitOutput(root, ['rev-parse', 'HEAD']);
-      await tag(root, '@scope/a@1.1.0', '2025-01-02T00:00:00Z');
+      await tag(root, 'a@1.1.0', '2025-01-02T00:00:00Z');
 
       await writeFile(join(root, 'readme.md'), 'not a release\n');
       await git(root, ['add', '.']);
@@ -41,7 +41,7 @@ describe('release planning with fixture git repositories', () => {
       await tag(root, 'not-owned@9.9.9', '2025-01-03T00:00:00Z');
 
       const npmPublished = new Set(['@scope/a@1.0.0', '@scope/b@1.0.0']);
-      const githubReleases = new Set(['@scope/a@1.0.0']);
+      const githubReleases = new Set(['a@1.0.0']);
       const records = await collectOwnedReleaseTagRecords(
         [
           { name: '@scope/a', projectName: 'a', path: 'packages/a' },
@@ -59,7 +59,7 @@ describe('release planning with fixture git repositories', () => {
         },
       );
 
-      expect(records.map((record) => record.tag)).toEqual(['@scope/a@1.1.0', '@scope/b@1.0.0', '@scope/a@1.0.0']);
+      expect(records.map((record) => record.tag)).toEqual(['a@1.1.0', 'b@1.0.0', 'a@1.0.0']);
       const pending = pendingReleaseTargets(records, head);
       expect(pending.map((target) => target.sha)).toEqual([first, second]);
       expect(pending[0]?.packages.map((pkg) => pkg.name)).toEqual(['@scope/b']);
@@ -74,7 +74,7 @@ describe('release planning with fixture git repositories', () => {
       await writePackage(root, '@scope/a', 'packages/a', '1.0.0');
       await git(root, ['add', '.']);
       await git(root, ['commit', '-m', 'release a']);
-      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, 'a@1.0.0', '2025-01-01T00:00:00Z');
       await git(root, ['init', '--bare', 'remote.git']);
       await git(root, ['remote', 'add', 'origin', join(root, 'remote.git')]);
       await git(root, ['push', 'origin', 'main', '--tags']);
@@ -94,7 +94,7 @@ describe('release planning with fixture git repositories', () => {
         },
       );
 
-      expect(records.map((record) => record.tag)).toEqual(['@scope/a@1.0.0']);
+      expect(records.map((record) => record.tag)).toEqual(['a@1.0.0']);
       expect(pendingReleaseTargets(records, 'not-head').map((target) => target.sha)).toEqual([head]);
     });
   });
@@ -119,26 +119,26 @@ describe('release planning with fixture git repositories', () => {
       await writeBuildablePackage(author, '@scope/b', 'packages/b', '1.0.0');
       await git(author, ['add', '.']);
       await git(author, ['commit', '-m', 'initial release']);
-      await tag(author, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
-      await tag(author, '@scope/b@1.0.0', '2025-01-01T00:00:01Z');
+      await tag(author, 'a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(author, 'b@1.0.0', '2025-01-01T00:00:01Z');
 
       await writeBuildablePackage(author, '@scope/a', 'packages/a', '1.1.0');
       await git(author, ['add', 'packages/a/package.json']);
       await git(author, ['commit', '-m', 'release a 1.1.0']);
       const githubOnlySha = await gitOutput(author, ['rev-parse', 'HEAD']);
-      await tag(author, '@scope/a@1.1.0', '2025-01-02T00:00:00Z');
+      await tag(author, 'a@1.1.0', '2025-01-02T00:00:00Z');
 
       await writeBuildablePackage(author, '@scope/b', 'packages/b', '2.0.0-beta.1');
       await git(author, ['add', 'packages/b/package.json']);
       await git(author, ['commit', '-m', 'release b prerelease']);
       const npmAndGithubSha = await gitOutput(author, ['rev-parse', 'HEAD']);
-      await tag(author, '@scope/b@2.0.0-beta.1', '2025-01-03T00:00:00Z');
+      await tag(author, 'b@2.0.0-beta.1', '2025-01-03T00:00:00Z');
 
       await writeBuildablePackage(author, '@scope/a', 'packages/a', '1.2.0');
       await git(author, ['add', 'packages/a/package.json']);
       await git(author, ['commit', '-m', 'head release a 1.2.0']);
       const headSha = await gitOutput(author, ['rev-parse', 'HEAD']);
-      await tag(author, '@scope/a@1.2.0', '2025-01-04T00:00:00Z');
+      await tag(author, 'a@1.2.0', '2025-01-04T00:00:00Z');
 
       await git(author, ['init', '--bare', 'remote.git']);
       await git(author, ['remote', 'add', 'origin', join(author, 'remote.git')]);
@@ -151,7 +151,7 @@ describe('release planning with fixture git repositories', () => {
       const restoreRef = 'origin/main';
       const packages = releaseFixturePackages();
       const npmPublished = new Set(['@scope/a@1.0.0', '@scope/b@1.0.0', '@scope/a@1.1.0']);
-      const githubReleases = new Set(['@scope/a@1.0.0', '@scope/b@1.0.0']);
+      const githubReleases = new Set(['a@1.0.0', 'b@1.0.0']);
 
       const records = await collectOwnedReleaseTagRecords(packages, restoreRef, {
         listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(runner),
@@ -181,7 +181,7 @@ describe('release planning with fixture git repositories', () => {
         { name: '@scope/a', version: '1.1.0', dryRun: false },
         { name: '@scope/b', version: '2.0.0-beta.1', dryRun: false },
       ]);
-      expect(shell.pushes).toEqual([['@scope/a@1.1.0'], ['@scope/b@2.0.0-beta.1']]);
+      expect(shell.pushes).toEqual([['a@1.1.0'], ['b@2.0.0-beta.1']]);
       expect(summaries.map((summary) => summary.sha)).toEqual([githubOnlySha, npmAndGithubSha]);
       await expect(readFile(join(runner, 'packages/b/dist/index.js'), 'utf8')).resolves.toBe('{}\n');
       await expect(readFile(join(runner, 'packages/a/dist/index.js'), 'utf8')).rejects.toThrow();
@@ -212,13 +212,62 @@ describe('release planning with fixture git repositories', () => {
       const summary = await completeReleaseAtHead(shell, [pkg], false, false);
 
       expect(summary.pushed).toBe(true);
-      expect(shell.pushes).toEqual([['@scope/pushed@1.0.0']]);
+      expect(shell.pushes).toEqual([['pushed@1.0.0']]);
       await $`git clone --branch main ${join(author, 'remote.git')} auditor`.cwd(author).quiet();
       const auditor = join(author, 'auditor');
       await git(auditor, ['fetch', '--tags', 'origin', 'main']);
-      await expect(gitOutput(auditor, ['rev-parse', 'refs/tags/@scope/pushed@1.0.0^{}'])).resolves.toBe(
+      await expect(gitOutput(auditor, ['rev-parse', 'refs/tags/pushed@1.0.0^{}'])).resolves.toBe(
         await gitOutput(runner, ['rev-parse', 'HEAD']),
       );
+      await expect(gitSucceeds(auditor, ['rev-parse', '--verify', 'refs/tags/@scope/pushed@1.0.0'])).resolves.toBe(
+        false,
+      );
+    });
+  });
+
+  it('repairs a scoped package from its project-name release tag without creating a package-name tag', async () => {
+    await withFixtureRepo(async (author) => {
+      await writeWorkspace(author);
+      await writeBuildablePackage(author, '@scope/cli', 'packages/cli', '0.2.0');
+      await git(author, ['add', '.']);
+      await git(author, ['commit', '-m', 'release cli 0.2.0']);
+      const releaseSha = await gitOutput(author, ['rev-parse', 'HEAD']);
+      await tag(author, 'cli@0.2.0', '2025-01-01T00:00:00Z');
+
+      await git(author, ['init', '--bare', 'remote.git']);
+      await git(author, ['remote', 'add', 'origin', join(author, 'remote.git')]);
+      await git(author, ['push', 'origin', 'main', '--tags']);
+      await $`git clone --branch main ${join(author, 'remote.git')} runner`.cwd(author).quiet();
+      const runner = join(author, 'runner');
+      await git(runner, ['config', 'user.name', 'Test User']);
+      await git(runner, ['config', 'user.email', 'test@example.com']);
+      await git(runner, ['fetch', '--tags', 'origin', 'main']);
+
+      const pkg: ReleasePackageInfo = {
+        name: '@scope/cli',
+        projectName: 'cli',
+        path: 'packages/cli',
+        version: '0.0.0',
+      };
+      const records = await collectOwnedReleaseTagRecords([pkg], 'origin/main', {
+        listReleaseTagsByCreatorDate: () => gitReleaseTagsByCreatorDate(runner),
+        isAncestor: (ancestor, descendant) => gitIsAncestor(runner, ancestor, descendant),
+        packageVersionAtRef: (packagePath, ref) => packageVersionAtRef(runner, packagePath, ref),
+        durableTagState: async () => ({ npmPublished: false, githubReleaseExists: false }),
+      });
+      const pending = pendingReleaseTargets(records, 'not-head');
+
+      const shell = new LocalGitRepairShell(runner);
+      const summaries = await repairPendingTargets(shell, pending, 'origin/main', false);
+
+      expect(records.map((record) => record.tag)).toEqual(['cli@0.2.0']);
+      expect(pending.map((target) => target.sha)).toEqual([releaseSha]);
+      expect(shell.pushes).toEqual([['cli@0.2.0']]);
+      expect(shell.publishes).toEqual([{ name: '@scope/cli', version: '0.2.0', distTag: 'latest', dryRun: false }]);
+      expect(shell.githubCreates).toEqual([{ name: '@scope/cli', version: '0.2.0', dryRun: false }]);
+      expect(summaries[0]?.packages.map((releasePackage) => releasePackage.name)).toEqual(['@scope/cli']);
+      await expect(gitSucceeds(runner, ['rev-parse', '--verify', 'refs/tags/cli@0.2.0'])).resolves.toBe(true);
+      await expect(gitSucceeds(runner, ['rev-parse', '--verify', 'refs/tags/@scope/cli@0.2.0'])).resolves.toBe(false);
     });
   });
 });
@@ -245,7 +294,7 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
   }
 
   async pushReleaseRefs(packages: ReleasePackageInfo[]): Promise<boolean> {
-    this.pushes.push(packages.map((pkg) => `${pkg.name}@${pkg.version}`));
+    this.pushes.push(packages.map((pkg) => releaseTag(pkg)));
     await git(this.root, ['fetch', '--tags', 'origin', 'main']);
     for (const pkg of packages) {
       await this.ensureLocalReleaseTag(pkg);
@@ -285,8 +334,9 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
     return [];
   }
 
-  async createGithubRelease(pkg: ReleasePackageInfo, dryRun: boolean): Promise<void> {
+  async createGithubRelease(pkg: ReleasePackageInfo, dryRun: boolean): Promise<string | null> {
     this.githubCreates.push({ name: pkg.name, version: pkg.version, dryRun });
+    return dryRun ? null : `https://github.test/${releaseTag(pkg)}`;
   }
 
   async checkout(ref: string): Promise<void> {