@smoothbricks/cli 0.10.1 → 0.10.3

package/src/monorepo/tool-validation.test.ts

@@ -12,12 +12,13 @@ import {
 
 const registryVersions: Record<string, string[]> = {
   '@biomejs/biome': ['2.3.5'],
-  '@nx/js': ['22.5.4'],
-  '@smoothbricks/nx-plugin': ['0.0.1'],
+  '@nx/js': ['23.1.0'],
+  '@smoothbricks/nx-plugin': ['0.3.0'],
   eslint: ['9.39.1'],
   'eslint-stdout': ['1.1.1', '1.1.2'],
-  nx: ['22.5.4'],
+  nx: ['23.1.0'],
   prettier: ['3.6.1'],
+  ttsc: ['0.18.4'],
   typescript: ['5.9.3'],
 };
 
@@ -25,7 +26,7 @@ const realFetch = globalThis.fetch;
 
 describe('tool configuration validation', () => {
   beforeEach(() => {
-    globalThis.fetch = mockRegistryFetch as typeof fetch;
+    globalThis.fetch = mockRegistryFetch;
   });
 
   afterEach(() => {
@@ -67,7 +68,7 @@ describe('tool configuration validation', () => {
       expect(rootPackage.devDependencies['@smoothbricks/cli']).toBeUndefined();
       expect(rootPackage.devDependencies['@smoothbricks/nx-plugin']).toBe('workspace:*');
       expect(rootPackage.devDependencies['eslint-stdout']).toBe('workspace:*');
-      expect(rootPackage.devDependencies.nx).toBe('22.5.4');
+      expect(rootPackage.devDependencies.nx).toBe('23.1.0');
       expect(rootPackage.workspaces).toContain('tooling');
       expect(toolingPackage.name).toBe('@smoothbricks/tooling');
       expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe('workspace:*');
@@ -89,13 +90,14 @@ describe('tool configuration validation', () => {
         workspaces: ['packages/*', 'tooling'],
         devDependencies: {
           '@biomejs/biome': '^3.0.0',
-          '@nx/js': '22.6.0',
-          '@smoothbricks/nx-plugin': '^0.1.0',
+          '@nx/js': '23.2.0',
+          '@smoothbricks/nx-plugin': '^0.4.0',
           '@types/bun': '1.3.99',
           eslint: '^10.0.0',
           'eslint-stdout': await currentEslintStdoutRange(),
-          nx: '23.0.0',
+          nx: '24.0.0',
           prettier: '^3.7.0',
+          ttsc: '^0.19.0',
           typescript: '^6.0.0',
         },
       });
@@ -132,6 +134,35 @@ describe('tool configuration validation', () => {
     }
   });
 
+  it('preserves an installable CLI range when the running CLI is a linked prerelease', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
+    try {
+      const configuredRange = '^0.10.1';
+      const runningRange = await currentCliRange();
+      const expectedRange = runningRange.includes('-') ? configuredRange : runningRange;
+      await writeJson(join(root, 'package.json'), {
+        name: '@fixture/app',
+        version: '0.0.0',
+        private: true,
+        workspaces: ['packages/*', 'tooling'],
+      });
+      await writeJson(join(root, 'tooling/package.json'), {
+        name: '@fixture/tooling',
+        private: true,
+        dependencies: { '@smoothbricks/cli': configuredRange },
+      });
+
+      const context = readToolContext(root);
+      expect(context.policy.cliDependencyRange).toBe(expectedRange);
+      applyToolingPackageDefaults(root, context.policy);
+
+      const toolingPackage = JSON.parse(await readFile(join(root, 'tooling/package.json'), 'utf8'));
+      expect(toolingPackage.dependencies['@smoothbricks/cli']).toBe(expectedRange);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
   it('uses workspace smoo in the SmoothBricks codebase repo', async () => {
     const root = await mkdtemp(join(tmpdir(), 'smoo-tool-validation-'));
     try {
@@ -161,10 +192,11 @@ describe('tool configuration validation', () => {
         workspaces: ['packages/*', 'tooling'],
         devDependencies: {
           '@biomejs/biome': '^3.0.0',
-          '@nx/js': '22.6.0',
+          '@nx/js': '23.2.0',
           eslint: '^10.0.0',
-          nx: '23.0.0',
+          nx: '24.0.0',
           prettier: '^3.7.0',
+          ttsc: '^0.19.0',
           typescript: '^6.0.0',
         },
       });
@@ -195,20 +227,23 @@ async function currentEslintStdoutRange(): Promise<string> {
   return `^${latestPatchVersion('eslint-stdout', pkg.version) ?? pkg.version}`;
 }
 
-function mockRegistryFetch(input: Parameters<typeof fetch>[0]): Promise<Response> {
-  const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
-  const packageName = decodeURIComponent(new URL(url).pathname.slice(1));
-  const versions = registryVersions[packageName];
-  if (!versions) {
-    return Promise.resolve(new Response('{}', { status: 404 }));
-  }
-  return Promise.resolve(
-    new Response(JSON.stringify({ versions: Object.fromEntries(versions.map((version) => [version, {}])) }), {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    }),
-  );
-}
+const mockRegistryFetch = Object.assign(
+  (input: string | URL | Request): Promise<Response> => {
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+    const packageName = decodeURIComponent(new URL(url).pathname.slice(1));
+    const versions = registryVersions[packageName];
+    if (!versions) {
+      return Promise.resolve(new Response('{}', { status: 404 }));
+    }
+    return Promise.resolve(
+      new Response(JSON.stringify({ versions: Object.fromEntries(versions.map((version) => [version, {}])) }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      }),
+    );
+  },
+  { preconnect: realFetch.preconnect },
+) satisfies typeof fetch;
 
 function latestPatchVersion(packageName: string, version: string): string | null {
   const [major, minor] = version.split('.');

package/src/monorepo/tool-validation.ts

@@ -25,11 +25,11 @@ export interface ToolContext {
 
 const rootDevDependencies: RequiredDependency[] = [
   { name: '@biomejs/biome', fallbackVersion: '^2.3.5', minimumVersion: '2.3.0', prefix: '^' },
-  { name: '@nx/js', fallbackVersion: '22.0.3', minimumVersion: '22.0.0' },
+  { name: '@nx/js', fallbackVersion: '23.1.0', minimumVersion: '23.1.0' },
   {
     name: '@smoothbricks/nx-plugin',
-    fallbackVersion: '^0.0.1',
-    minimumVersion: '0.0.1',
+    fallbackVersion: '^0.3.0',
+    minimumVersion: '0.3.0',
     prefix: '^',
     useWorkspaceRangeInCodebase: true,
   },
@@ -41,8 +41,11 @@ const rootDevDependencies: RequiredDependency[] = [
     prefix: '^',
     useWorkspaceRangeInCodebase: true,
   },
-  { name: 'nx', fallbackVersion: '22.5.4', minimumVersion: '22.5.0' },
+  { name: 'nx', fallbackVersion: '23.1.0', minimumVersion: '23.1.0' },
   { name: 'prettier', fallbackVersion: '^3.6.1', minimumVersion: '3.6.0', prefix: '^' },
+  { name: 'ttsc', fallbackVersion: '^0.18.4', minimumVersion: '0.18.4', prefix: '^' },
+  // Nx and typescript-eslint still load the TypeScript 5.x JavaScript API.
+  // Compilation is exclusively delegated to ttsc by the Nx plugin targets.
   { name: 'typescript', fallbackVersion: '^5.9.3', minimumVersion: '5.9.0', prefix: '^' },
 ];
 
@@ -330,17 +333,28 @@ function formatExpectedDependency(policy: ToolPolicy, dependency: RequiredDepend
 
 export function readToolContext(root: string): ToolContext {
   const rootPackage = readPackageJsonObject(join(root, 'package.json'));
-  return { rootPackage, policy: toolPolicy(rootPackage) };
+  const toolingPackage = readJsonObject(join(root, 'tooling', 'package.json'));
+  const configuredCliRange = recordProperty(toolingPackage ?? {}, 'dependencies')?.[cliPackageName];
+  return {
+    rootPackage,
+    policy: toolPolicy(rootPackage, typeof configuredCliRange === 'string' ? configuredCliRange : null),
+  };
 }
 
-function toolPolicy(rootPackage: PackageJson | null): ToolPolicy {
+function toolPolicy(rootPackage: PackageJson | null, configuredCliRange: string | null): ToolPolicy {
   const name = typeof rootPackage?.name === 'string' ? rootPackage.name : null;
   const isCodebase = isSmoothBricksCodebasePackageName(name ?? undefined);
   const toolingName = toolingPackageName(name);
+  // A locally linked prerelease can be newer than every published CLI. Keep an existing
+  // installable range instead of rewriting the consumer manifest to an unpublished version.
+  const publishedCliRange =
+    cliPackageVersion.includes('-') && configuredCliRange && parseVersion(configuredCliRange)
+      ? configuredCliRange
+      : `^${cliPackageVersion}`;
   return {
     isSmoothBricksCodebase: isCodebase,
     toolingPackageName: toolingName,
-    cliDependencyRange: isCodebase ? 'workspace:*' : `^${cliPackageVersion}`,
+    cliDependencyRange: isCodebase ? 'workspace:*' : publishedCliRange,
   };
 }
 

package/src/monorepo/wrangler.test.ts

@@ -21,7 +21,12 @@ describe('firstWranglerEnv', () => {
 describe('applyWranglerDefaults', () => {
   it('injects the wrangler-types target and wires typecheck, idempotently', async () => {
     const root = await createWorkspace([
-      { dir: 'api', name: '@acme/api', toml: '[env.production]\n', nx: { targets: { typecheck: { dependsOn: ['^build'] } } } },
+      {
+        dir: 'api',
+        name: '@acme/api',
+        toml: '[env.production]\n',
+        nx: { targets: { typecheck: { dependsOn: ['^build'] } } },
+      },
     ]);
     try {
       applyWranglerDefaults(root);
@@ -51,7 +56,9 @@ describe('applyWranglerDefaults', () => {
   });
 
   it('omits --env from the command when the wrangler.toml declares no env block', async () => {
-    const root = await createWorkspace([{ dir: 'api', name: '@acme/api', toml: 'name = "svc"\nmain = "src/index.ts"\n' }]);
+    const root = await createWorkspace([
+      { dir: 'api', name: '@acme/api', toml: 'name = "svc"\nmain = "src/index.ts"\n' },
+    ]);
     captureConsoleLogs();
     try {
       applyWranglerDefaults(root);

package/src/nx/index.test.ts

@@ -7,7 +7,10 @@ import {
   nxShowProjectCommand,
   projectNamesFromNxShowProjectsOutput,
   projectNamesWithTarget,
+  projectRootFromNxProjectJson,
+  targetDependenciesFromNxProjectJson,
   targetNamesFromNxProjectJson,
+  targetOutputsFromNxProjectJson,
 } from './index.js';
 
 describe('Nx helper command construction', () => {
@@ -67,6 +70,42 @@ describe('Nx helper output formatting', () => {
     ]);
   });
 
+  it('extracts resolved roots, output declarations, and same-project target dependencies', () => {
+    const metadata = {
+      root: 'packages/native',
+      targets: {
+        'build-macos': {
+          outputs: ['{projectRoot}/dist/*.dmg'],
+          dependsOn: ['^build', 'compile-macos', { target: 'package-macos', projects: 'self' }],
+        },
+        test: { outputs: [] },
+      },
+    };
+
+    expect(projectRootFromNxProjectJson(metadata)).toBe('packages/native');
+    expect(targetOutputsFromNxProjectJson(metadata)).toEqual(
+      new Map([
+        ['build-macos', ['{projectRoot}/dist/*.dmg']],
+        ['test', []],
+      ]),
+    );
+    expect(targetDependenciesFromNxProjectJson(metadata)).toEqual(
+      new Map([['build-macos', ['^build', 'compile-macos', 'package-macos']]]),
+    );
+  });
+
+  it('rejects unsupported cross-project object target dependencies', () => {
+    expect(() =>
+      targetDependenciesFromNxProjectJson({
+        targets: {
+          build: {
+            dependsOn: [{ target: 'build', projects: 'dependencies' }],
+          },
+        },
+      }),
+    ).toThrow('unsupported cross-project dependsOn');
+  });
+
   it('treats missing target metadata as an empty project', () => {
     expect(targetNamesFromNxProjectJson({ name: 'cli' })).toEqual([]);
   });

package/src/nx/index.ts

@@ -7,9 +7,12 @@ import { decode, run } from '../lib/run.js';
 
 export interface ProjectTargets {
   project: string;
+  root?: string;
   targets: string[];
   buildDependsOn?: string[];
+  targetDependencies?: Map<string, string[]>;
   targetExecutors?: Map<string, string>;
+  targetOutputs?: Map<string, string[]>;
   targetScripts?: Map<string, string>;
 }
 
@@ -35,13 +38,41 @@ export function targetNamesFromNxProjectJson(value: unknown): string[] {
   return targets ? Object.keys(targets).sort((a, b) => a.localeCompare(b)) : [];
 }
 
+export function projectRootFromNxProjectJson(value: unknown): string | undefined {
+  return isRecord(value) && typeof value.root === 'string' ? value.root : undefined;
+}
+
 export function buildDependsOnFromNxProjectJson(value: unknown): string[] | undefined {
+  return targetDependenciesFromNxProjectJson(value).get('build');
+}
+
+export function targetDependenciesFromNxProjectJson(value: unknown): Map<string, string[]> {
   const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
-  const build = targets ? recordProperty(targets, 'build') : null;
-  if (!Array.isArray(build?.dependsOn) || !build.dependsOn.every((entry) => typeof entry === 'string')) {
-    return undefined;
+  const dependencies = new Map<string, string[]>();
+  if (!targets) {
+    return dependencies;
+  }
+  for (const [targetName, target] of Object.entries(targets)) {
+    if (!isRecord(target) || !Array.isArray(target.dependsOn)) {
+      continue;
+    }
+    const entries: string[] = [];
+    for (const dependency of target.dependsOn) {
+      if (typeof dependency === 'string') {
+        entries.push(dependency);
+        continue;
+      }
+      if (!isRecord(dependency) || typeof dependency.target !== 'string') {
+        throw new Error(`Nx target ${targetName} has an invalid dependsOn entry.`);
+      }
+      if (dependency.projects !== undefined && dependency.projects !== 'self') {
+        throw new Error(`Nx target ${targetName} uses unsupported cross-project dependsOn for ${dependency.target}.`);
+      }
+      entries.push(dependency.target);
+    }
+    dependencies.set(targetName, entries);
   }
-  return build.dependsOn;
+  return dependencies;
 }
 
 export function targetExecutorsFromNxProjectJson(value: unknown): Map<string, string> {
@@ -58,6 +89,10 @@ export function targetExecutorsFromNxProjectJson(value: unknown): Map<string, st
   return executors;
 }
 
+export function targetOutputsFromNxProjectJson(value: unknown): Map<string, string[]> {
+  return targetStringArraysFromNxProjectJson(value, 'outputs');
+}
+
 export function targetScriptsFromNxProjectJson(value: unknown): Map<string, string> {
   const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
   const scripts = new Map<string, string>();
@@ -76,6 +111,27 @@ export function targetScriptsFromNxProjectJson(value: unknown): Map<string, stri
   return scripts;
 }
 
+function targetStringArraysFromNxProjectJson(value: unknown, property: string): Map<string, string[]> {
+  const targets = isRecord(value) ? recordProperty(value, 'targets') : null;
+  const values = new Map<string, string[]>();
+  if (!targets) {
+    return values;
+  }
+  for (const [targetName, target] of Object.entries(targets)) {
+    if (!isRecord(target)) {
+      continue;
+    }
+    const entries = target[property];
+    if (Array.isArray(entries)) {
+      values.set(
+        targetName,
+        entries.filter((entry): entry is string => typeof entry === 'string'),
+      );
+    }
+  }
+  return values;
+}
+
 export function formatProjectTargetLines(projects: ProjectTargets[]): string {
   return projects
     .flatMap((project) => project.targets.map((target) => `${project.project}:${target}`))
@@ -165,11 +221,15 @@ async function readProjectTarget(root: string, project: string): Promise<Project
   const command = nxShowProjectCommand(project);
   const result = await $`${command.command} ${command.args}`.cwd(root).quiet();
   const parsed: unknown = JSON.parse(decode(result.stdout));
+  const targetDependencies = targetDependenciesFromNxProjectJson(parsed);
   return {
     project,
+    root: projectRootFromNxProjectJson(parsed),
     targets: targetNamesFromNxProjectJson(parsed),
-    buildDependsOn: buildDependsOnFromNxProjectJson(parsed),
+    buildDependsOn: targetDependencies.get('build'),
+    targetDependencies,
     targetExecutors: targetExecutorsFromNxProjectJson(parsed),
+    targetOutputs: targetOutputsFromNxProjectJson(parsed),
     targetScripts: targetScriptsFromNxProjectJson(parsed),
   };
 }

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

@@ -175,7 +175,9 @@ describe('release planning with fixture git repositories', () => {
       const summaries = await repairPendingTargets(shell, pending, restoreRef, false);
 
       expect(shell.checkouts).toEqual([githubOnlySha, npmAndGithubSha, restoreRef]);
-      expect(shell.devenvLoads).toBe(2);
+      expect(shell.devenvLoads).toBe(3);
+      expect(shell.devenvRefs).toEqual([githubOnlySha, npmAndGithubSha, headSha]);
+      await expect(readFile(join(runner, '.generated-tool-ref'), 'utf8')).resolves.toBe(`${headSha}\n`);
       expect(shell.builds).toEqual([['@scope/b']]);
       expect(shell.publishes).toEqual([{ name: '@scope/b', version: '2.0.0-beta.1', distTag: 'next', dryRun: false }]);
       expect(shell.githubCreates).toEqual([
@@ -189,40 +191,36 @@ describe('release planning with fixture git repositories', () => {
     });
   });
 
-  it('pushes current release refs to a local bare remote and another clone can fetch them', async () => {
+  it('pushes current release refs to a local bare remote', async () => {
     await withFixtureRepo(async (author) => {
       await writeWorkspace(author);
       await writeBuildablePackage(author, '@scope/pushed', 'packages/pushed', '1.0.0');
       await git(author, ['add', '.']);
       await git(author, ['commit', '-m', 'release pushed package']);
+      const releaseSha = await gitOutput(author, ['rev-parse', 'HEAD']);
       await git(author, ['init', '--bare', 'remote.git']);
       await git(author, ['remote', 'add', 'origin', join(author, 'remote.git')]);
       await git(author, ['push', 'origin', 'main']);
-      await git(author, ['clone', '--branch', 'main', join(author, 'remote.git'), 'runner']);
-      const runner = join(author, 'runner');
-      await git(runner, ['config', 'user.name', 'Test User']);
-      await git(runner, ['config', 'user.email', 'test@example.com']);
       const pkg: ReleasePackageInfo = {
         name: '@scope/pushed',
         projectName: 'pushed',
         path: 'packages/pushed',
         version: '1.0.0',
       };
-      const shell = new LocalGitRepairShell(runner);
+      const shell = new LocalGitRepairShell(author);
 
       const summary = await completeReleaseAtHead(shell, [pkg], false, false);
 
       expect(summary.pushed).toBe(true);
       expect(shell.pushes).toEqual([['pushed@1.0.0']]);
-      await git(author, ['clone', '--branch', 'main', join(author, 'remote.git'), 'auditor']);
-      const auditor = join(author, 'auditor');
-      await git(auditor, ['fetch', '--tags', 'origin', 'main']);
-      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,
-      );
+      const remoteTags = await gitOutput(author, [
+        'ls-remote',
+        '--tags',
+        'origin',
+        'refs/tags/pushed@1.0.0^{}',
+        'refs/tags/@scope/pushed@1.0.0^{}',
+      ]);
+      expect(remoteTags).toBe(`${releaseSha}\trefs/tags/pushed@1.0.0^{}`);
     });
   });
 
@@ -295,6 +293,7 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
   readonly publishes: Array<{ name: string; version: string; distTag: string; dryRun: boolean }> = [];
   readonly githubCreates: Array<{ name: string; version: string; dryRun: boolean }> = [];
   devenvLoads = 0;
+  readonly devenvRefs: string[] = [];
 
   constructor(private readonly root: string) {}
 
@@ -360,6 +359,9 @@ class LocalGitRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
 
   async withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T> {
     this.devenvLoads += 1;
+    const currentRef = await this.gitHead();
+    this.devenvRefs.push(currentRef);
+    await writeFile(join(this.root, '.generated-tool-ref'), `${currentRef}\n`);
     return runWithEnv();
   }
 

package/src/release/__tests__/github-release.test.ts

@@ -4,6 +4,7 @@ import type { ReleasePackageInfo } from '../core.js';
 import {
   createOrUpdateGithubRelease,
   type GithubReleaseWriteShell,
+  githubReleaseLookupExists,
   nxProjectChangelogArgs,
   projectChangelogContents,
 } from '../github-release.js';
@@ -26,6 +27,7 @@ describe('GitHub release helpers', () => {
       gitPush: false,
       stageChanges: false,
       createRelease: false,
+      forceChangelogGeneration: true,
       deleteVersionPlans: false,
       dryRun: false,
       from: 'pkg@1.2.2',
@@ -41,6 +43,7 @@ describe('GitHub release helpers', () => {
       gitPush: false,
       stageChanges: false,
       createRelease: false,
+      forceChangelogGeneration: true,
       deleteVersionPlans: false,
       dryRun: true,
       firstRelease: true,
@@ -66,6 +69,14 @@ describe('GitHub release helpers', () => {
     );
   });
 
+  it('distinguishes missing releases from transient GitHub lookup failures', () => {
+    expect(githubReleaseLookupExists('pkg@1.2.3', 0, '{"tagName":"pkg@1.2.3"}', '')).toBe(true);
+    expect(githubReleaseLookupExists('pkg@1.2.3', 1, '', 'HTTP 404: release not found')).toBe(false);
+    expect(() => githubReleaseLookupExists('pkg@1.2.3', 1, '', 'HTTP 503: Service Unavailable')).toThrow(
+      'Unable to inspect GitHub Release pkg@1.2.3.\nHTTP 503: Service Unavailable',
+    );
+  });
+
   it('creates a missing stable GitHub Release from the generated notes file', async () => {
     const shell = new RecordingGithubReleaseShell(false);
 

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

@@ -2,7 +2,9 @@ import { describe, expect, it } from 'bun:test';
 import { type ReleasePackageInfo, type ReleaseTarget, releaseTag } from '../core.js';
 import {
   bumpStableReleaseToNext,
+  collectRepairPlatformOutputs,
   completeReleaseAtHead,
+  type ReleaseRepairOutputsShell,
   type ReleaseRepairShell,
   type ReleaseVersionShell,
   repairPendingTargets,
@@ -23,14 +25,16 @@ const prerelease: ReleasePackageInfo = {
 };
 
 describe('release orchestration', () => {
-  it('repairs an older target with one checkout, one devenv load, npm-only build, and GitHub create calls', async () => {
+  it('repairs an older target and refreshes devenv after restoring the caller ref', async () => {
     const target = releaseTarget('older-release', [stable, prerelease], [stable], [prerelease]);
     const shell = new RecordingRepairShell();
 
     const summaries = await repairPendingTargets(shell, [target], 'restore-ref', false);
 
     expect(shell.checkouts).toEqual(['older-release', 'restore-ref']);
-    expect(shell.devenvLoads).toBe(1);
+    expect(shell.devenvLoads).toBe(2);
+    expect(shell.devenvRefs).toEqual(['older-release', 'restore-ref']);
+    expect(shell.prepares).toEqual(['older-release']);
     expect(shell.builds).toEqual([['@scope/stable']]);
     expect(shell.publishes).toEqual([{ name: '@scope/stable', distTag: 'latest', dryRun: false }]);
     expect(shell.githubCreates).toEqual([{ name: '@scope/prerelease', dryRun: false }]);
@@ -78,6 +82,29 @@ describe('release orchestration', () => {
     ]);
   });
 
+  it('collects historical platform outputs only for npm-missing repair targets', async () => {
+    const githubOnly = releaseTarget('github-only', [prerelease], [], [prerelease]);
+    const npmMissing = releaseTarget('npm-missing', [stable], [stable], []);
+    const shell = new RecordingRepairOutputsShell();
+
+    await collectRepairPlatformOutputs(shell, [githubOnly, npmMissing], 'restore-ref');
+
+    expect(shell.checkouts).toEqual(['npm-missing', 'restore-ref']);
+    expect(shell.devenvRefs).toEqual(['npm-missing', 'restore-ref']);
+    expect(shell.collected).toEqual(['npm-missing']);
+  });
+
+  it('does nothing when no pending release needs npm platform outputs', async () => {
+    const shell = new RecordingRepairOutputsShell();
+    const githubOnly = releaseTarget('github-only', [prerelease], [], [prerelease]);
+
+    await collectRepairPlatformOutputs(shell, [githubOnly], 'restore-ref');
+
+    expect(shell.checkouts).toEqual([]);
+    expect(shell.devenvRefs).toEqual([]);
+    expect(shell.collected).toEqual([]);
+  });
+
   it('publishes a partial HEAD release by building npm-missing packages and creating missing GitHub Releases', async () => {
     const shell = new RecordingRepairShell({ npmMissing: ['@scope/stable'], githubMissing: ['@scope/prerelease'] });
 
@@ -216,15 +243,21 @@ class RecordingRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
   readonly npmQueries: string[][] = [];
   readonly githubQueries: string[][] = [];
   devenvLoads = 0;
+  readonly devenvRefs: string[] = [];
   currentRef = 'head';
   private readonly npmMissing: Set<string>;
   private readonly githubMissing: Set<string>;
+  readonly prepares: string[] = [];
 
   constructor(options: { npmMissing?: string[]; githubMissing?: string[] } = {}) {
     this.npmMissing = new Set(options.npmMissing ?? []);
     this.githubMissing = new Set(options.githubMissing ?? []);
   }
 
+  async prepareRepairTarget(target: ReleaseTarget<ReleasePackageInfo>): Promise<void> {
+    this.prepares.push(target.sha);
+  }
+
   async gitHead(): Promise<string> {
     return this.currentRef;
   }
@@ -264,10 +297,32 @@ class RecordingRepairShell implements ReleaseRepairShell<ReleasePackageInfo> {
 
   async withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T> {
     this.devenvLoads += 1;
+    this.devenvRefs.push(this.currentRef);
     return runWithEnv();
   }
 }
 
+class RecordingRepairOutputsShell implements ReleaseRepairOutputsShell<ReleasePackageInfo> {
+  readonly checkouts: string[] = [];
+  readonly collected: string[] = [];
+  readonly devenvRefs: string[] = [];
+  private currentRef = 'head';
+
+  async checkout(ref: string): Promise<void> {
+    this.currentRef = ref;
+    this.checkouts.push(ref);
+  }
+
+  async withDevenvEnv<T>(runWithEnv: () => Promise<T>): Promise<T> {
+    this.devenvRefs.push(this.currentRef);
+    return runWithEnv();
+  }
+
+  async collectRepairTargetOutputs(target: ReleaseTarget<ReleasePackageInfo>): Promise<void> {
+    this.collected.push(target.sha);
+  }
+}
+
 class RecordingVersionShell implements ReleaseVersionShell<ReleasePackageInfo> {
   readonly ensureCalls: string[][] = [];
   readonly nxRuns: Array<{ packages: string[]; bump: string; dryRun: boolean }> = [];