@williamthorsen/release-kit 18.1.1 → 18.3.0

package/dist/esm/reportPrepare.js

@@ -19,42 +19,12 @@ function formatSingleWorkspace(result, options) {
     if (workspace === undefined || workspace.kind === 'composite') {
         return '';
     }
-    const sinceLabel = workspace.previousTag === undefined ? 'the beginning' : workspace.previousTag;
-    lines.push(dim(`Found ${workspace.commitCount} commits since ${sinceLabel}`));
-    if (workspace.parsedCommitCount !== undefined) {
-        lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
-    }
-    formatUnparseableWarning(lines, workspace, style);
-    formatPolicyViolations(lines, workspace.policyViolations, style);
+    const sinceLabel = `since ${workspace.previousTag ?? 'the beginning'}`;
+    formatTargetSection(lines, workspace, { indent: '', sinceLabel }, isDryRun, style);
     if (workspace.status === 'skipped') {
-        formatChangeRecordWarnings(lines, workspace, style);
-        lines.push(formatStatusLine(style, 'skipped', workspace.skipReason));
         formatWarnings(lines, result, style);
         return lines.join('\n');
     }
-    if (workspace.versionOverride !== undefined) {
-        lines.push(`  Using version override: ${workspace.versionOverride}`);
-    }
-    else if (workspace.bumpOverride !== undefined) {
-        lines.push(`  Using bump override: ${workspace.bumpOverride}`);
-    }
-    if (workspace.releaseType !== undefined) {
-        lines.push(dim(`Bumping versions (${workspace.releaseType})...`));
-    }
-    else if (workspace.versionOverride !== undefined) {
-        lines.push(dim(`Bumping versions (version override)...`));
-    }
-    if (workspace.versionOverride !== undefined) {
-        lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (version override)`));
-    }
-    else if (workspace.releaseType !== undefined) {
-        lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (${workspace.releaseType})`));
-    }
-    formatChangeRecordWarnings(lines, workspace, style);
-    formatBumpFiles(lines, workspace, isDryRun);
-    lines.push(dim('Generating changelogs...'));
-    formatChangelogFiles(lines, workspace, isDryRun, style);
-    formatPreviewFiles(lines, workspace, isDryRun);
     formatFormatCommand(lines, result, options);
     formatWarnings(lines, result, style);
     lines.push(formatStatusLine(style, 'passed', 'Release preparation complete.'), `   ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
@@ -65,11 +35,14 @@ function formatMultiWorkspace(result, options) {
     const { style } = options;
     const lines = [];
     for (const target of result.targets) {
-        if (target.kind === 'composite') {
-            formatProjectSection(lines, target, isDryRun, style);
+        const title = getSectionTitle(target);
+        if (title !== undefined) {
+            lines.push(`\n${renderSectionHeader(title)}`);
         }
-        else {
-            formatWorkspaceSection(lines, target, isDryRun, style);
+        const sinceLabel = target.previousTag === undefined ? '(no previous release found)' : `since ${target.previousTag}`;
+        formatTargetSection(lines, target, { indent: '  ', sinceLabel }, isDryRun, style);
+        if (target.status === 'released') {
+            lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(target.tag))}`);
         }
     }
     formatFormatCommand(lines, result, options);
@@ -85,98 +58,79 @@ function formatMultiWorkspace(result, options) {
     }
     return lines.join('\n');
 }
-function formatProjectSection(lines, project, isDryRun, style) {
-    lines.push(`\n${renderSectionHeader(project.targetId === PROJECT_TARGET_ID ? 'project' : project.targetId)}`);
-    const sinceLabel = project.previousTag === undefined ? '(no previous release found)' : `since ${project.previousTag}`;
-    lines.push(dim(`  Found ${project.commitCount} commits ${sinceLabel}`));
-    formatPolicyViolations(lines, project.policyViolations, style, '  ');
-    if (project.status === 'skipped') {
-        formatUnparseableWarning(lines, project, style, '  ');
-        formatChangeRecordWarnings(lines, project, style, '  ');
-        lines.push(`  ${formatStatusLine(style, 'skipped', project.skipReason)}`);
-        return;
-    }
-    const { releaseType, currentVersion, newVersion, tag } = project;
-    if (project.parsedCommitCount > 0) {
-        lines.push(dim(`  Parsed ${project.parsedCommitCount} typed commits`));
+function getSectionTitle(target) {
+    if (target.kind === 'composite') {
+        return target.targetId === PROJECT_TARGET_ID ? 'project' : target.targetId;
     }
-    if (project.bumpOverride !== undefined) {
-        lines.push(`  Using bump override: ${project.bumpOverride}`);
-    }
-    formatUnparseableWarning(lines, project, style, '  ');
-    formatChangeRecordWarnings(lines, project, style, '  ');
-    lines.push(dim(`  Bumping versions (${releaseType})...`), `  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${currentVersion} → ${bold(newVersion)} (${releaseType})`)}`);
-    for (const file of project.bumpedFiles) {
-        if (isDryRun) {
-            lines.push(dim(`    [dry-run] Would bump ${file}`));
-        }
-        else {
-            lines.push(dim(`    Bumped ${file}`));
-        }
-    }
-    lines.push(dim('  Generating changelogs...'));
-    formatChangelogFiles(lines, project, isDryRun, style, '  ');
-    formatPreviewFiles(lines, project, isDryRun, '  ');
-    lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(tag))}`);
+    return target.name;
 }
-function formatWorkspaceSection(lines, workspace, isDryRun, style) {
-    if (workspace.name !== undefined) {
-        lines.push(`\n${renderSectionHeader(workspace.name)}`);
-    }
-    const sinceLabel = workspace.previousTag === undefined ? '(no previous release found)' : `since ${workspace.previousTag}`;
-    lines.push(dim(`  Found ${workspace.commitCount} commits ${sinceLabel}`));
-    if (workspace.status === 'skipped') {
-        formatUnparseableWarning(lines, workspace, style, '  ');
-        formatPolicyViolations(lines, workspace.policyViolations, style, '  ');
-        formatChangeRecordWarnings(lines, workspace, style, '  ');
-        lines.push(`  ${formatStatusLine(style, 'skipped', workspace.skipReason)}`);
+function formatTargetSection(lines, target, layout, isDryRun, style) {
+    const { indent, sinceLabel } = layout;
+    lines.push(dim(`${indent}Found ${target.commitCount} commits ${sinceLabel}`));
+    if (target.status === 'skipped') {
+        formatTargetWarnings(lines, target, style, indent);
+        lines.push(`${indent}${formatStatusLine(style, 'skipped', target.skipReason)}`);
         return;
     }
-    const propagatedFrom = workspace.kind === 'package' ? workspace.propagatedFrom : undefined;
-    const isPropagatedOnly = workspace.kind === 'package' && workspace.propagatedOnly === true;
-    formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly);
-    formatUnparseableWarning(lines, workspace, style, '  ');
-    formatPolicyViolations(lines, workspace.policyViolations, style, '  ');
-    formatChangeRecordWarnings(lines, workspace, style, '  ');
-    formatBumpLabels(lines, workspace, isPropagatedOnly);
-    formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style);
-    formatBumpFiles(lines, workspace, isDryRun, '  ');
-    lines.push(dim('  Generating changelogs...'));
-    formatChangelogFiles(lines, workspace, isDryRun, style, '  ');
-    formatPreviewFiles(lines, workspace, isDryRun, '  ');
-    lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
+    const origin = describeBumpOrigin(target);
+    formatCommitSummary(lines, target, origin);
+    formatTargetWarnings(lines, target, style, indent);
+    formatBumpLabels(lines, target, origin, indent);
+    formatVersionLine(lines, target, origin, indent, style);
+    formatBumpFiles(lines, target, isDryRun, indent);
+    lines.push(dim(`${indent}Generating changelogs...`));
+    formatChangelogFiles(lines, target, isDryRun, style, indent);
+    formatPreviewFiles(lines, target, isDryRun, indent);
+}
+function formatTargetWarnings(lines, target, style, indent) {
+    formatUnparseableWarning(lines, target, style, indent);
+    formatPolicyViolations(lines, target.policyViolations, style, indent);
+    formatChangeRecordWarnings(lines, target, style, indent);
+}
+function describeBumpOrigin(target) {
+    if (target.kind === 'composite') {
+        return { propagatedFrom: undefined, isPropagatedOnly: false, versionOverride: undefined };
+    }
+    if (target.kind === 'directory') {
+        return { propagatedFrom: undefined, isPropagatedOnly: false, versionOverride: target.versionOverride };
+    }
+    return {
+        propagatedFrom: target.propagatedFrom,
+        isPropagatedOnly: target.propagatedOnly === true,
+        versionOverride: target.versionOverride,
+    };
 }
-function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
-    if (isPropagatedOnly && propagatedFrom !== undefined) {
-        const dependencyNames = propagatedFrom.map((p) => p.packageName).join(', ');
+function formatCommitSummary(lines, target, origin) {
+    if (origin.isPropagatedOnly && origin.propagatedFrom !== undefined) {
+        const dependencyNames = origin.propagatedFrom.map((p) => p.packageName).join(', ');
         lines.push(dim(`  Bumped via dependency: ${dependencyNames}`));
     }
-    else if (workspace.parsedCommitCount !== undefined && workspace.parsedCommitCount > 0) {
-        lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
+    else if (target.parsedCommitCount !== undefined && target.parsedCommitCount > 0) {
+        lines.push(dim(`  Parsed ${target.parsedCommitCount} typed commits`));
     }
 }
-function formatBumpLabels(lines, workspace, isPropagatedOnly) {
-    if (workspace.versionOverride !== undefined) {
-        lines.push(`  Using version override: ${workspace.versionOverride}`);
+function formatBumpLabels(lines, target, origin, indent) {
+    if (origin.versionOverride !== undefined) {
+        lines.push(`  Using version override: ${origin.versionOverride}`);
     }
-    else if (workspace.bumpOverride !== undefined && !isPropagatedOnly) {
-        lines.push(`  Using bump override: ${workspace.bumpOverride}`);
+    else if (target.bumpOverride !== undefined && !origin.isPropagatedOnly) {
+        lines.push(`  Using bump override: ${target.bumpOverride}`);
     }
-    if (workspace.releaseType !== undefined) {
-        lines.push(dim(`  Bumping versions (${workspace.releaseType})...`));
+    if (target.releaseType !== undefined) {
+        lines.push(dim(`${indent}Bumping versions (${target.releaseType})...`));
     }
-    else if (workspace.versionOverride !== undefined) {
-        lines.push(dim(`  Bumping versions (version override)...`));
+    else if (origin.versionOverride !== undefined) {
+        lines.push(dim(`${indent}Bumping versions (version override)...`));
     }
 }
-function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style) {
-    const versions = `${workspace.currentVersion} → ${bold(workspace.newVersion)}`;
-    if (workspace.versionOverride !== undefined) {
-        lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (version override)`)}`);
-    }
-    else if (workspace.releaseType !== undefined) {
-        const suffix = isPropagatedOnly ? formatPropagationSuffix(propagatedFrom) : '';
-        lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (${workspace.releaseType}${suffix})`)}`);
+function formatVersionLine(lines, target, origin, indent, style) {
+    const versions = `${target.currentVersion} → ${bold(target.newVersion)}`;
+    if (origin.versionOverride !== undefined) {
+        lines.push(`${indent}${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (version override)`)}`);
+    }
+    else if (target.releaseType !== undefined) {
+        const suffix = origin.isPropagatedOnly ? formatPropagationSuffix(origin.propagatedFrom) : '';
+        lines.push(`${indent}${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (${target.releaseType}${suffix})`)}`);
     }
 }
 function formatPropagationSuffix(propagatedFrom) {

package/dist/esm/resolveReleaseTags.d.ts

@@ -1,3 +1,4 @@
+import { type Git } from './git.js';
 import type { DirectoryConfig, ResolvedProjectConfig, WorkspaceConfig } from './types.js';
 export interface ResolvedTag {
     tag: string;
@@ -41,5 +42,5 @@ type ResolveReleaseTagsArgs = {
  * matching without needing `isPublishable` propagation; resolved tags default to
  * `isPublishable: true`. Production callers should pass one of the named forms.
  */
-export declare function resolveReleaseTags(args?: ResolveReleaseTagsArgs): ResolvedTag[];
+export declare function resolveReleaseTags(args?: ResolveReleaseTagsArgs, git?: Git): ResolvedTag[];
 export {};

package/dist/esm/resolveReleaseTags.js

@@ -1,25 +1,17 @@
-import { execFileSync } from 'node:child_process';
-import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
+import { realGit } from "./git.js";
 import { getTargetName } from "./resolveReleaseDeclaration.js";
 import { PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
 import { asUserError } from "./user-error-chaining.js";
 const VERSION_PATTERN = /^v\d+\.\d+\.\d+/;
 const SEMVER_SUFFIX_PATTERN = /^\d+\.\d+\.\d+/;
-export function resolveReleaseTags(args) {
-    let output;
+export function resolveReleaseTags(args, git = realGit) {
+    let tags;
     try {
-        output = execFileSync('git', ['tag', '--points-at', 'HEAD'], {
-            encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
-        });
+        tags = git.listTagsAtHead();
     }
     catch (error) {
         throw asUserError(error);
     }
-    const tags = output
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
     if (args === undefined) {
         return resolveSinglePackageTags(tags);
     }

package/dist/esm/showTagPrefixesCommand.d.ts

@@ -2,11 +2,11 @@ import { type StreamStyles } from '@williamthorsen/nmr-core';
 /**
  * Runs the CLI `show-tag-prefixes` command and returns its exit code.
  *
- * Prints a per-workspace table of derived prefixes, tag counts, and declared legacy entries, followed by an
- * "Undeclared tag prefixes" section when candidate-shaped tags exist outside the known set. Returns `1` on any
- * derivation failure or collision and `0` otherwise; undeclared candidates do not affect the exit code. When a config
- * exists and either fails to load or fails validation, the command reports it to stderr and returns `1` in both repo
- * modes, because a default-config preview would understate the declared legacy prefixes. When the default config is
- * absent, the command previews against derived defaults.
+ * Prints one block per target, with its derived prefix and declared legacy identities and their tag counts, then the
+ * declared retired packages, the candidate-shaped tags outside the known set, and a footer on creating the first tag
+ * when a target does not have any. Returns `1` on any derivation failure or collision and `0` otherwise; undeclared
+ * candidates do not affect the exit code. When a config exists and either fails to load or fails validation, the
+ * command reports it to stderr and returns `1` in both repo modes, because a default-config preview would understate
+ * the declared legacy prefixes. When the default config is absent, the command previews against derived defaults.
  */
 export declare function showTagPrefixesCommand(styles: StreamStyles, configPath?: string): Promise<number>;

package/dist/esm/showTagPrefixesCommand.js

@@ -2,7 +2,7 @@ import { formatStatusLine, isAnticipatedFailure, reportError, } from '@williamth
 import { BIN } from "./bin.js";
 import { detectRepoType } from "./init/detectRepoType.js";
 import { loadValidatedConfig, reportConfigProblem } from "./loadValidatedConfig.js";
-import { previewTagPrefixes } from "./previewTagPrefixes.js";
+import { previewTagPrefixes, } from "./previewTagPrefixes.js";
 export async function showTagPrefixesCommand(styles, configPath) {
     const result = await loadValidatedConfig(configPath);
     if (result.status === 'invalid') {
@@ -27,59 +27,114 @@ export async function showTagPrefixesCommand(styles, configPath) {
     process.stdout.write(renderMonorepo(preview, styles.stdout));
     return computeExitCode(preview);
 }
-function renderSinglePackage() {
-    const lines = [
-        'Workspace   Derived prefix   Status',
-        '.           v                (single-package mode)',
-        '',
-    ];
-    return lines.join('\n');
+const LABEL_WIDTH = 'legacy identity'.length;
+const FIRST_TAG_FOOTER = 'A workspace marked "no derived tags yet" has not been released under its derived prefix. `release-kit tag` creates its first tag from the tags file that `release-kit prepare` writes.';
+function computeExitCode(preview) {
+    const hasDerivationFailure = preview.workspaces.some((row) => row.derivedPrefix === null);
+    const hasCollision = preview.collisions.length > 0;
+    return hasDerivationFailure || hasCollision ? 1 : 0;
+}
+function formatPrefixColumns(columns, prefix, tagCount, note) {
+    const cells = `${prefix.padEnd(columns.prefixWidth)}  ${String(tagCount).padStart(columns.countDigits)} tags`;
+    return note === undefined ? cells : `${cells}  ${note}`;
+}
+function formatRow(label, body) {
+    return `  ${label.padEnd(LABEL_WIDTH)}   ${body}`;
+}
+function measureColumns(preview) {
+    const entries = preview.retiredPackages.map((entry) => ({
+        prefix: entry.tagPrefix,
+        tagCount: entry.tagCount,
+    }));
+    for (const row of preview.workspaces) {
+        if (row.derivedPrefix !== null)
+            entries.push({ prefix: row.derivedPrefix, tagCount: row.derivedTagCount });
+        entries.push(...row.legacyEntries);
+    }
+    return {
+        prefixWidth: Math.max(0, ...entries.map((entry) => entry.prefix.length)),
+        countDigits: Math.max(1, ...entries.map((entry) => String(entry.tagCount).length)),
+    };
 }
 function renderMonorepo(preview, style) {
-    const lines = ['Workspace tag prefixes:', ''];
+    const columns = measureColumns(preview);
+    const lines = ['Workspace tag prefixes'];
     for (const row of preview.workspaces) {
-        lines.push(...renderWorkspaceRow(row, style));
+        lines.push('', ...renderTargetBlock(row, preview.collisions, columns, style));
     }
-    if (preview.collisions.length > 0) {
-        lines.push('', ...preview.collisions.map((collision) => formatStatusLine(style, 'failed', `tag prefix collision: '${collision.tagPrefix}' used by ${collision.workspacePaths.join(', ')}`)));
+    if (preview.retiredPackages.length > 0) {
+        lines.push('', 'Retired packages', '', ...renderRetiredLines(preview.retiredPackages, columns, style));
     }
-    if (preview.undeclaredCandidates.length > 0) {
-        lines.push('', 'Undeclared tag prefixes:', '', ...preview.undeclaredCandidates.map((candidate) => `  '${candidate.prefix}': ${candidate.tagCount} tags (e.g., ${candidate.exampleTags.join(', ')})`), '', 'Suggested config snippet (adjust `dir` to match the workspace if the guess is wrong, and replace the `name` placeholder with the legacy npm name):', '', renderSuggestedSnippet(preview.undeclaredCandidates), '', "If the suggested `dir` does not match the workspace, adjust it before pasting. Each legacy identity requires a `name`: Replace the `TODO-fill-in-legacy-npm-name` placeholder with the package's prior npm name.");
+    lines.push('', 'Undeclared tag prefixes', '', ...renderUndeclaredSection(preview.undeclaredCandidates, style));
+    if (preview.workspaces.some((row) => row.derivedPrefix !== null && row.derivedTagCount === 0)) {
+        lines.push('', formatStatusLine(style, 'info', FIRST_TAG_FOOTER));
     }
     lines.push('');
     return lines.join('\n');
 }
-function renderWorkspaceRow(row, style) {
-    const lines = [];
+function renderRetiredLines(retiredPackages, columns, style) {
+    return retiredPackages.map((entry) => {
+        const identity = entry.successor === undefined ? entry.name : `${entry.name}, successor: ${entry.successor}`;
+        const status = entry.tagCount > 0 ? 'passed' : 'warning';
+        return `  ${formatStatusLine(style, status, formatPrefixColumns(columns, entry.tagPrefix, entry.tagCount, identity))}`;
+    });
+}
+function renderSinglePackage() {
+    const lines = [
+        'Workspace tag prefixes',
+        '',
+        '. (single-package mode)',
+        formatRow('derived prefix', 'v'),
+        '',
+    ];
+    return lines.join('\n');
+}
+function renderSuggestedSnippet(candidates) {
+    const entries = candidates
+        .map((candidate) => `    { dir: '${candidate.suggestedDir}', legacyIdentities: [{ name: 'TODO-fill-in-legacy-npm-name', tagPrefix: '${candidate.prefix}' }] },`)
+        .join('\n');
+    return `  workspaces: [\n${entries}\n  ],`;
+}
+function renderTargetBlock(row, collisions, columns, style) {
+    const lines = [row.name === null ? row.workspacePath : `${row.workspacePath} (${row.name})`];
     if (row.derivedPrefix === null) {
         const failure = formatStatusLine(style, 'failed', `derivation failed: ${row.derivationError ?? 'unknown error'}`);
-        lines.push(`  ${row.workspacePath}: ${failure}`);
+        lines.push(formatRow('derived prefix', failure));
         return lines;
     }
-    const statusMarker = row.derivedTagCount > 0
-        ? formatStatusLine(style, 'passed', `${row.derivedTagCount} tags`)
-        : formatStatusLine(style, 'warning', 'no existing tags');
-    lines.push(`  ${row.workspacePath}: derived prefix '${row.derivedPrefix}', ${statusMarker}`);
+    const collidingPaths = collisions
+        .filter((collision) => collision.tagPrefix === row.derivedPrefix)
+        .flatMap((collision) => collision.workspacePaths)
+        .filter((path) => path !== row.workspacePath);
+    let derivedStatus = 'passed';
+    let derivedNote;
+    if (collidingPaths.length > 0) {
+        derivedStatus = 'failed';
+        derivedNote = `collides with ${collidingPaths.join(', ')}`;
+    }
+    else if (row.derivedTagCount === 0) {
+        derivedStatus = 'warning';
+        derivedNote = 'no derived tags yet';
+    }
+    const derivedCells = formatPrefixColumns(columns, row.derivedPrefix, row.derivedTagCount, derivedNote);
+    lines.push(formatRow('derived prefix', formatStatusLine(style, derivedStatus, derivedCells)));
     for (const entry of row.legacyEntries) {
-        if (entry.tagCount > 0) {
-            const recognizedMessage = `${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`;
-            lines.push(`      ${formatStatusLine(style, 'passed', recognizedMessage)}`);
-        }
-        else {
-            const taglessMessage = `recorded legacy prefix '${entry.prefix}' does not have any tags`;
-            lines.push(`      ${formatStatusLine(style, 'warning', taglessMessage)}`);
-        }
+        const status = entry.tagCount > 0 ? 'passed' : 'warning';
+        const legacyCells = formatPrefixColumns(columns, entry.prefix, entry.tagCount, entry.name);
+        lines.push(formatRow('legacy identity', formatStatusLine(style, status, legacyCells)));
     }
     return lines;
 }
-function renderSuggestedSnippet(candidates) {
-    const entries = candidates
-        .map((candidate) => `    { dir: '${candidate.suggestedDir}', legacyIdentities: [{ name: 'TODO-fill-in-legacy-npm-name', tagPrefix: '${candidate.prefix}' }] },`)
-        .join('\n');
-    return `  workspaces: [\n${entries}\n  ],`;
-}
-function computeExitCode(preview) {
-    const hasDerivationFailure = preview.workspaces.some((row) => row.derivedPrefix === null);
-    const hasCollision = preview.collisions.length > 0;
-    return hasDerivationFailure || hasCollision ? 1 : 0;
+function renderUndeclaredSection(candidates, style) {
+    if (candidates.length === 0)
+        return ['  (none)'];
+    return [
+        ...candidates.map((candidate) => `  ${formatStatusLine(style, 'warning', `'${candidate.prefix}': ${candidate.tagCount} tags (e.g., ${candidate.exampleTags.join(', ')})`)}`),
+        '',
+        'Suggested config snippet (adjust `dir` to match the workspace if the guess is wrong, and replace the `name` placeholder with the legacy npm name):',
+        '',
+        renderSuggestedSnippet(candidates),
+        '',
+        "If the suggested `dir` does not match the workspace, adjust it before pasting. Each legacy identity requires a `name`: Replace the `TODO-fill-in-legacy-npm-name` placeholder with the package's prior npm name.",
+    ];
 }

package/dist/esm/sync-labels/generateCommand.js

@@ -8,7 +8,6 @@ import { CONFIG_FILE_PATH } from "../loadConfig.js";
 import { loadValidatedConfig, reportConfigProblem } from "../loadValidatedConfig.js";
 import { hashPreset } from "./presets.js";
 import { resolveLabels } from "./resolveLabels.js";
-import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
 export const LABELS_OUTPUT_PATH = '.github/labels.yaml';
 export function formatLabelsYaml(labels, presetHashes, configFilePath = CONFIG_FILE_PATH) {
     const headerLines = ['# Generated by release-kit sync-labels — do not edit.', `# Source: ${configFilePath}`];
@@ -43,9 +42,6 @@ export async function loadRepoLabelsConfig(stderrStyle, configPath) {
     return result.config.repoLabels;
 }
 export async function generateCommand({ shouldCheck = false, configPath, styles }) {
-    if (checkRetiredSyncLabelsConfig(configPath)) {
-        return 1;
-    }
     const repoLabels = await loadRepoLabelsConfig(styles.stderr, configPath);
     if (repoLabels === undefined) {
         return 1;

package/dist/esm/sync-labels/initCommand.js

@@ -5,14 +5,10 @@ import { describeEmptyWorkspace, discoverWorkspaces } from "../discoverWorkspace
 import { CONFIG_FILE_PATH } from "../loadConfig.js";
 import { loadValidatedConfig, reportConfigProblem } from "../loadValidatedConfig.js";
 import { generateCommand, LABELS_OUTPUT_PATH } from "./generateCommand.js";
-import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
 import { buildScopeLabels, readSyncLabelsWorkflowTemplate, renderRepoLabelsBlock, renderRepoLabelsConfigScript, } from "./templates.js";
 const WORKFLOW_PATH = '.github/workflows/sync-labels.yaml';
 export async function syncLabelsInitCommand({ configPath, isDryRun, shouldForce, styles, }) {
     const configFilePath = configPath ?? CONFIG_FILE_PATH;
-    if (checkRetiredSyncLabelsConfig(configPath)) {
-        return 1;
-    }
     if (isDryRun) {
         console.info('[dry-run mode]');
     }

package/dist/esm/sync-labels/syncCommand.js

@@ -3,7 +3,6 @@ import { existsSync } from 'node:fs';
 import { GIT_OUTPUT_LIMIT_BYTES, reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { BIN } from "../bin.js";
-import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
 const WORKFLOW_FILE = '.github/workflows/sync-labels.yaml';
 function checkGhAvailable() {
     try {
@@ -15,9 +14,6 @@ function checkGhAvailable() {
     }
 }
 export function syncLabelsCommand() {
-    if (checkRetiredSyncLabelsConfig()) {
-        return 1;
-    }
     if (!checkGhAvailable()) {
         reportError(BIN, 'The `gh` CLI is not installed or not in PATH. Install it from https://cli.github.com/');
         return 1;

package/dist/esm/types.d.ts

@@ -355,8 +355,9 @@ export interface WorkTypeConfig {
     excludedFromChangelog?: boolean | undefined;
 }
 /**
- * Defines which commit types trigger major or minor version bumps.
- * Any recognized commit type not listed defaults to a patch bump.
+ * Defines which commit types trigger major or minor version bumps, and which trigger none.
+ * Any recognized commit type not listed in `major`, `minor`, or `none` (the default list when omitted) defaults to a
+ * patch bump.
  * The sentinel `'!'` in `major` means "any breaking commit triggers a major bump".
  */
 export interface VersionPatterns {
@@ -364,6 +365,11 @@ export interface VersionPatterns {
     major: string[];
     /** Commit types that trigger a minor bump. */
     minor: string[];
+    /**
+     * Commit types that do not trigger a bump unless breaking. Defaults to `DEFAULT_VERSION_PATTERNS.none` when omitted;
+     * `[]` gives every unlisted type a patch bump.
+     */
+    none?: string[] | undefined;
 }
 /** A raw commit from the git log. */
 export interface Commit {

package/docs/configuration.md

@@ -22,7 +22,7 @@ The two paths differ in what an absent file means. An absent default path means
 | `workspaces`          | `WorkspaceOverride[]`                       | Override or exclude discovered workspaces (matched by `dir`)                                                                                                                                                                                                                             |
 | `devExportConditions` | `string[]`                                  | Export conditions that resolve only inside the repo, such as one that points at unpublished source; the [tarball check](releasing.md#packages-whose-tarball-would-lack-a-manifest-file) does not require their targets in the tarball. `source` is exempt without being listed           |
 | `formatCommand`       | `string`                                    | Shell command to run after changelog generation; modified file paths are appended as arguments                                                                                                                                                                                           |
-| `versionPatterns`     | `VersionPatterns`                           | Rules for which commit types trigger major/minor bumps                                                                                                                                                                                                                                   |
+| `versionPatterns`     | `VersionPatterns`                           | Rules for which commit types trigger major, minor, or no bumps                                                                                                                                                                                                                           |
 | `scopeAliases`        | `Record<string, string>`                    | Maps shorthand scope names to canonical names in commit titles and in change-record entry `scopes`, which [route items to workspaces](changelogs.md#routing-to-workspaces). A renamed workspace directory or [release target](#releases) needs an entry from its old name to its new one |
 | `workTypes`           | `Record<string, WorkTypeConfig>`            | Work type definitions, merged with defaults by key                                                                                                                                                                                                                                       |
 | `breakingPolicies`    | `Record<string, 'forbidden' \| 'optional'>` | Per-type `!`-policy lookup. Defaults to `DEFAULT_BREAKING_POLICIES`. Replaces the default entirely when provided. Set to `{}` to disable enforcement                                                                                                                                     |
@@ -143,7 +143,7 @@ Validation rules:
 - Full-tuple `(name, tagPrefix)` duplicates within `retiredPackages` are rejected.
 - Two entries sharing the same `tagPrefix` but different `name`s are accepted: Such a pair documents a package renamed within the repo before being retired.
 
-`show-tag-prefixes` currently does not render a dedicated "Retired packages" section (deferred). Declaring a retired entry is verifiable by confirming that its `tagPrefix` stops appearing under "Undeclared tag prefixes" in the `show-tag-prefixes` output.
+`show-tag-prefixes` lists each retired entry under "Retired packages", with its tag count and successor.
 
 ## Tag prefix collisions
 
@@ -160,26 +160,35 @@ The rule is enforced at config load; the resulting error identifies both collidi
 
 ## `release-kit show-tag-prefixes`
 
-Prints a per-workspace table of derived tag prefixes, tag counts, and declared legacy prefixes, with a row for each directory target. Also reports any release-shaped tag prefix in the repo that is neither a derived prefix nor declared via `legacyIdentities`, along with a copy-pasteable `workspaces: [...]` config snippet. The snippet uses a `TODO-fill-in-legacy-npm-name` placeholder for each identity's `name`; replace it with the package's prior npm name before pasting.
+Prints one block per workspace and directory target, titled with its path and its package name or `releases` key, with its derived tag prefix and each declared legacy identity, their tag counts, and a status. Prefixes and counts are aligned in columns across the whole output. A "Retired packages" section follows when the config declares `retiredPackages`. An "Undeclared tag prefixes" section always follows: It reports any release-shaped tag prefix in the repo that is neither derived nor declared, along with a copy-pasteable `workspaces: [...]` config snippet, or `(none)`. The snippet uses a `TODO-fill-in-legacy-npm-name` placeholder for each identity's `name`; replace it with the package's prior npm name before pasting. When a derived prefix does not have any tags yet, a closing note explains that `release-kit tag` creates the first tag from the tags file that `release-kit prepare` writes.
 
 Exits `0` when every workspace derives a prefix and the workspaces' prefixes don't collide; exits `1` on any derivation failure or collision. Undeclared candidates do not affect the exit code; the `legacy tag prefixes are declared` readyup check reports them as a warning.
 
 When a config file exists and either fails to load or fails schema validation, the command reports the failure on stderr and exits `1` without printing a preview, because a config that cannot be read leaves the declared-versus-undeclared verdict wrong in the one dimension on which the command exists to report. That holds on the default path and under `--config`, and in single-package mode as well as monorepo mode. An absent default config is a supported state and still previews against derived defaults.
 
-In single-package mode, prints a single row with `workspacePath = .` and `derivedPrefix = v`; legacy entries and undeclared-candidate scanning are not applicable.
+In single-package mode, prints a single block for `.` with the derived prefix `v`; legacy entries and undeclared-candidate scanning are not applicable.
 
 ## `VersionPatterns`
 
-Defines which work types trigger major or minor bumps. `prepare` applies it to each changelog item of the unreleased window and takes the highest level. An item of a type not listed bumps patch.
+Defines which work types trigger major or minor bumps, and which trigger none. `prepare` applies it to each changelog item of the unreleased window and takes the highest level. An item of a type that `none` lists doesn't bump, and an item of any other type not listed bumps patch. A window whose items don't call for any bump doesn't release unless `--force` is passed, and its items wait in the unreleased window for the next release.
 
 ```typescript
 interface VersionPatterns {
   major: string[]; // Patterns triggering a major bump ('!' = any breaking change)
   minor: string[]; // Commit types triggering a minor bump
+  none?: string[]; // Commit types triggering no bump unless breaking
 }
 ```
 
-Default: `{ major: ['!'], minor: ['feat'] }`
+Default: `{ major: ['!'], minor: ['feat'], none: ['ai', 'ci', 'docs', 'tests', 'tooling'] }`
+
+The default `none` types don't change the code that a consumer runs. `refactor`, `internal`, and `deps` bump patch, because they change shipped code or installed dependencies. A `docs` change to a file that the package publishes reaches the registry with the next release.
+
+A config that sets `versionPatterns` replaces `major` and `minor`, but an omitted `none` keeps the default list. To give every type not listed in `major` or `minor` a patch bump, as release-kit did before `none` existed, set `none: []`:
+
+```typescript
+versionPatterns: { major: ['!'], minor: ['feat'], none: [] },
+```
 
 ## Output style
 

package/docs/labels.md

@@ -10,8 +10,6 @@ Manages GitHub label definitions via the `repoLabels` block of `.config/release-
 
 `init` and `generate` accept `--config <path>` to read a config elsewhere; `sync` reads none and rejects the flag. Under `--config`, `init` reads the named file and prints the block for manual paste, and fails when that file does not exist rather than scaffolding one, so its write target stays `.config/release-kit.config.ts`. See [Config file location](configuration.md#config-file-location).
 
-Every `sync-labels` subcommand refuses to run while the retired `.config/sync-labels.config.ts` is present, so that custom labels cannot be silently dropped mid-migration, and the refusal names what to move and where.
-
 ### Label configuration
 
 ```typescript
@@ -40,6 +38,8 @@ The bundled file's `confidence:` family grades how advisable a recommendation is
 
 The `urgency:` family states how soon an item needs attention, apart from how valuable it is, which the `value:` family states. Its labels replace the earlier `priority:` family and name the old labels in `aliases`, so a repository that has `priority:` labels has them renamed in place by the first sync after it regenerates `.github/labels.yaml` (see [Renaming a label](#renaming-a-label)).
 
+The `effort:` family states an item's size in points, apart from its urgency and value: one label for each value of the scale 1, 2, 3, 5, 8, and 13, from `effort:1` to `effort:13`.
+
 The `status:` family marks where an item stands in its work: `status:in-progress` once work on it has started, `status:blocked` while it waits on another item, and `status:on-hold` while it is deliberately paused.
 
 Names match case-insensitively, as GitHub matches them: `Bug` in the `labels` record replaces a preset's `bug`, and `Bug: null` removes it. A label takes the spelling of the last layer to write it.