diff --git a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/io/private/io-helper.ts b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/io/private/io-helper.ts
index 81cad3616..54d67d608 100644
--- a/packages/@aws-cdk/tmp-toolkit-helpers/src/api/io/private/io-helper.ts
+++ b/packages/@aws-cdk/tmp-toolkit-helpers/src/api/io/private/io-helper.ts
@@ -13,7 +13,6 @@ export type ActionLessRequest<T, U> = Omit<IoRequest<T, U>, 'action'>;
  * Wraps a client provided IoHost and provides additional features & services to toolkit internal classes.
  */
 export interface IoHelper extends IIoHost {
-  action: ToolkitAction;
   notify<T>(msg: ActionLessMessage<T>): Promise<void>;
   requestResponse<T, U>(msg: ActionLessRequest<T, U>): Promise<U>;
 }
@@ -23,7 +22,6 @@ export interface IoHelper extends IIoHost {
  */
 export function asIoHelper(ioHost: IIoHost, action: ToolkitAction): IoHelper {
   return {
-    action,
     notify: async <T>(msg: Omit<IoMessage<T>, 'action'>) => {
       await ioHost.notify({
         ...msg,
diff --git a/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/context-aware-source.ts b/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/context-aware-source.ts
index f4d7ef377..ddc608203 100644
--- a/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/context-aware-source.ts
+++ b/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/context-aware-source.ts
@@ -43,13 +43,13 @@ export class ContextAwareCloudAssembly implements ICloudAssemblySource {
   private canLookup: boolean;
   private context: Context;
   private contextFile: string;
-  private ioHost: IoHelper;
+  private ioHelper: IoHelper;
 
   constructor(private readonly source: ICloudAssemblySource, private readonly props: ContextAwareCloudAssemblyProps) {
     this.canLookup = props.lookups ?? true;
     this.context = props.context;
     this.contextFile = props.contextFile ?? PROJECT_CONTEXT; // @todo new feature not needed right now
-    this.ioHost = props.services.ioHost;
+    this.ioHelper = props.services.ioHelper;
   }
 
   /**
@@ -77,14 +77,14 @@ export class ContextAwareCloudAssembly implements ICloudAssemblySource {
 
         let tryLookup = true;
         if (previouslyMissingKeys && equalSets(missingKeysSet, previouslyMissingKeys)) {
-          await this.ioHost.notify(IO.CDK_ASSEMBLY_I0240.msg('Not making progress trying to resolve environmental context. Giving up.', { missingKeys }));
+          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0240.msg('Not making progress trying to resolve environmental context. Giving up.', { missingKeys }));
           tryLookup = false;
         }
 
         previouslyMissingKeys = missingKeysSet;
 
         if (tryLookup) {
-          await this.ioHost.notify(IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));
+          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0241.msg('Some context information is missing. Fetching...', { missingKeys }));
           await contextproviders.provideContextValues(
             assembly.manifest.missing,
             this.context,
@@ -92,7 +92,7 @@ export class ContextAwareCloudAssembly implements ICloudAssemblySource {
           );
 
           // Cache the new context to disk
-          await this.ioHost.notify(IO.CDK_ASSEMBLY_I0042.msg(`Writing updated context to ${this.contextFile}...`, {
+          await this.ioHelper.notify(IO.CDK_ASSEMBLY_I0042.msg(`Writing updated context to ${this.contextFile}...`, {
             contextFile: this.contextFile,
             context: this.context.all,
           }));
diff --git a/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts b/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts
index b0237c676..593dc5b46 100644
--- a/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts
+++ b/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/prepare-source.ts
@@ -38,7 +38,7 @@ export function determineOutputDirectory(outdir?: string) {
  * @param context The context key/value bash.
  */
 export async function prepareDefaultEnvironment(services: ToolkitServices, props: { outdir?: string } = {}): Promise<Env> {
-  const logFn = (msg: string, ...args: any) => services.ioHost.notify(IO.CDK_ASSEMBLY_I0010.msg(format(msg, ...args)));
+  const logFn = (msg: string, ...args: any) => services.ioHelper.notify(IO.CDK_ASSEMBLY_I0010.msg(format(msg, ...args)));
   const env = await oldPrepare(services.sdkProvider, logFn);
 
   if (props.outdir) {
diff --git a/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/source-builder.ts b/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/source-builder.ts
index cd38fba1b..b36bbfeb6 100644
--- a/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/source-builder.ts
+++ b/packages/@aws-cdk/toolkit-lib/lib/api/cloud-assembly/private/source-builder.ts
@@ -65,7 +65,7 @@ export abstract class CloudAssemblySourceBuilder {
             return assembly;
           }
 
-          return assemblyFromDirectory(assembly.directory, services.ioHost, props.loadAssemblyOptions);
+          return assemblyFromDirectory(assembly.directory, services.ioHelper, props.loadAssemblyOptions);
         },
       },
       contextAssemblyProps,
@@ -89,8 +89,8 @@ export abstract class CloudAssemblySourceBuilder {
       {
         produce: async () => {
           // @todo build
-          await services.ioHost.notify(IO.CDK_ASSEMBLY_I0150.msg('--app points to a cloud assembly, so we bypass synth'));
-          return assemblyFromDirectory(directory, services.ioHost, props.loadAssemblyOptions);
+          await services.ioHelper.notify(IO.CDK_ASSEMBLY_I0150.msg('--app points to a cloud assembly, so we bypass synth'));
+          return assemblyFromDirectory(directory, services.ioHelper, props.loadAssemblyOptions);
         },
       },
       contextAssemblyProps,
@@ -139,17 +139,17 @@ export abstract class CloudAssemblySourceBuilder {
                 eventPublisher: async (type, line) => {
                   switch (type) {
                     case 'data_stdout':
-                      await services.ioHost.notify(IO.CDK_ASSEMBLY_I1001.msg(line));
+                      await services.ioHelper.notify(IO.CDK_ASSEMBLY_I1001.msg(line));
                       break;
                     case 'data_stderr':
-                      await services.ioHost.notify(IO.CDK_ASSEMBLY_E1002.msg(line));
+                      await services.ioHelper.notify(IO.CDK_ASSEMBLY_E1002.msg(line));
                       break;
                   }
                 },
                 extraEnv: envWithContext,
                 cwd: props.workingDirectory,
               });
-              return assemblyFromDirectory(outdir, services.ioHost, props.loadAssemblyOptions);
+              return assemblyFromDirectory(outdir, services.ioHelper, props.loadAssemblyOptions);
             });
           } finally {
             await lock?.release();
diff --git a/packages/@aws-cdk/toolkit-lib/lib/toolkit/private/index.ts b/packages/@aws-cdk/toolkit-lib/lib/toolkit/private/index.ts
index 0439ab2bc..ece7a961b 100644
--- a/packages/@aws-cdk/toolkit-lib/lib/toolkit/private/index.ts
+++ b/packages/@aws-cdk/toolkit-lib/lib/toolkit/private/index.ts
@@ -9,7 +9,7 @@ import type { IoHelper } from '../../api/shared-private';
  */
 export interface ToolkitServices {
   sdkProvider: SdkProvider;
-  ioHost: IoHelper;
+  ioHelper: IoHelper;
 }
 
 /**
diff --git a/packages/@aws-cdk/toolkit-lib/lib/toolkit/toolkit.ts b/packages/@aws-cdk/toolkit-lib/lib/toolkit/toolkit.ts
index 77fff94fb..5438922c9 100644
--- a/packages/@aws-cdk/toolkit-lib/lib/toolkit/toolkit.ts
+++ b/packages/@aws-cdk/toolkit-lib/lib/toolkit/toolkit.ts
@@ -142,7 +142,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    */
   protected override async sourceBuilderServices(): Promise<ToolkitServices> {
     return {
-      ioHost: asIoHelper(this.ioHost, 'assembly'),
+      ioHelper: asIoHelper(this.ioHost, 'assembly'),
       sdkProvider: await this.sdkProvider('assembly'),
     };
   }
@@ -151,17 +151,17 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    * Bootstrap Action
    */
   public async bootstrap(environments: BootstrapEnvironments, options: BootstrapOptions): Promise<void> {
-    const ioHost = asIoHelper(this.ioHost, 'bootstrap');
+    const ioHelper = asIoHelper(this.ioHost, 'bootstrap');
     const bootstrapEnvironments = await environments.getEnvironments();
     const source = options.source ?? BootstrapSource.default();
     const parameters = options.parameters;
-    const bootstrapper = new Bootstrapper(source, { ioHost, action: 'bootstrap' });
+    const bootstrapper = new Bootstrapper(source, ioHelper);
     const sdkProvider = await this.sdkProvider('bootstrap');
     const limit = pLimit(20);
 
     // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
     await Promise.all(bootstrapEnvironments.map((environment: cxapi.Environment, currentIdx) => limit(async () => {
-      await ioHost.notify(IO.CDK_TOOLKIT_I9100.msg(`${chalk.bold(environment.name)}: bootstrapping...`, {
+      await ioHelper.notify(IO.CDK_TOOLKIT_I9100.msg(`${chalk.bold(environment.name)}: bootstrapping...`, {
         total: bootstrapEnvironments.length,
         current: currentIdx+1,
         environment,
@@ -184,10 +184,10 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
           ? ` ✅  ${environment.name} (no changes)`
           : ` ✅  ${environment.name}`;
 
-        await ioHost.notify(IO.CDK_TOOLKIT_I9900.msg(chalk.green('\n' + message), { environment }));
-        await bootstrapTimer.endAs(ioHost, 'bootstrap');
+        await ioHelper.notify(IO.CDK_TOOLKIT_I9900.msg(chalk.green('\n' + message), { environment }));
+        await bootstrapTimer.endAs(ioHelper, 'bootstrap');
       } catch (e: any) {
-        await ioHost.notify(IO.CDK_TOOLKIT_E9900.msg(`\n ❌  ${chalk.bold(environment.name)} failed: ${formatErrorMessage(e)}`, { error: e }));
+        await ioHelper.notify(IO.CDK_TOOLKIT_E9900.msg(`\n ❌  ${chalk.bold(environment.name)} failed: ${formatErrorMessage(e)}`, { error: e }));
         throw e;
       }
     })));
@@ -197,13 +197,13 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    * Synth Action
    */
   public async synth(cx: ICloudAssemblySource, options: SynthOptions = {}): Promise<ICloudAssemblySource> {
-    const ioHost = asIoHelper(this.ioHost, 'synth');
+    const ioHelper = asIoHelper(this.ioHost, 'synth');
     const synthTimer = Timer.start();
     const assembly = await assemblyFromSource(cx);
     const stacks = assembly.selectStacksV2(options.stacks ?? ALL_STACKS);
     const autoValidateStacks = options.validateStacks ? [assembly.selectStacksForValidation()] : [];
-    await this.validateStacksMetadata(stacks.concat(...autoValidateStacks), ioHost);
-    await synthTimer.endAs(ioHost, 'synth');
+    await this.validateStacksMetadata(stacks.concat(...autoValidateStacks), ioHelper);
+    await synthTimer.endAs(ioHelper, 'synth');
 
     // if we have a single stack, print it to STDOUT
     const message = `Successfully synthesized to ${chalk.blue(path.resolve(stacks.assembly.directory))}`;
@@ -217,7 +217,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
       const firstStack = stacks.firstStack!;
       const template = firstStack.template;
       const obscuredTemplate = obscureTemplate(template);
-      await ioHost.notify(IO.CDK_TOOLKIT_I1901.msg(message, {
+      await ioHelper.notify(IO.CDK_TOOLKIT_I1901.msg(message, {
         ...assemblyData,
         stack: {
           stackName: firstStack.stackName,
@@ -229,8 +229,8 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
       }));
     } else {
       // not outputting template to stdout, let's explain things to the user a little bit...
-      await ioHost.notify(IO.CDK_TOOLKIT_I1902.msg(chalk.green(message), assemblyData));
-      await ioHost.notify(IO.DEFAULT_TOOLKIT_INFO.msg(`Supply a stack id (${stacks.stackArtifacts.map((s) => chalk.green(s.hierarchicalId)).join(', ')}) to display its template.`));
+      await ioHelper.notify(IO.CDK_TOOLKIT_I1902.msg(chalk.green(message), assemblyData));
+      await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(`Supply a stack id (${stacks.stackArtifacts.map((s) => chalk.green(s.hierarchicalId)).join(', ')}) to display its template.`));
     }
 
     return new IdentityCloudAssemblySource(assembly.assembly);
@@ -242,16 +242,16 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    * List selected stacks and their dependencies
    */
   public async list(cx: ICloudAssemblySource, options: ListOptions = {}): Promise<StackDetails[]> {
-    const ioHost = asIoHelper(this.ioHost, 'list');
+    const ioHelper = asIoHelper(this.ioHost, 'list');
     const synthTimer = Timer.start();
     const assembly = await assemblyFromSource(cx);
     const stackCollection = await assembly.selectStacksV2(options.stacks ?? ALL_STACKS);
-    await synthTimer.endAs(ioHost, 'synth');
+    await synthTimer.endAs(ioHelper, 'synth');
 
     const stacks = stackCollection.withDependencies();
     const message = stacks.map(s => s.id).join('\n');
 
-    await ioHost.notify(IO.CDK_TOOLKIT_I2901.msg(message, { stacks }));
+    await ioHelper.notify(IO.CDK_TOOLKIT_I2901.msg(message, { stacks }));
     return stacks;
   }
 
@@ -269,19 +269,19 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    * Helper to allow deploy being called as part of the watch action.
    */
   private async _deploy(assembly: StackAssembly, action: 'deploy' | 'watch', options: ExtendedDeployOptions = {}) {
-    const ioHost = asIoHelper(this.ioHost, action);
+    const ioHelper = asIoHelper(this.ioHost, action);
     const synthTimer = Timer.start();
     const stackCollection = assembly.selectStacksV2(options.stacks ?? ALL_STACKS);
-    await this.validateStacksMetadata(stackCollection, ioHost);
-    const synthDuration = await synthTimer.endAs(ioHost, 'synth');
+    await this.validateStacksMetadata(stackCollection, ioHelper);
+    const synthDuration = await synthTimer.endAs(ioHelper, 'synth');
 
     if (stackCollection.stackCount === 0) {
-      await ioHost.notify(IO.CDK_TOOLKIT_E5001.msg('This app contains no stacks'));
+      await ioHelper.notify(IO.CDK_TOOLKIT_E5001.msg('This app contains no stacks'));
       return;
     }
 
     const deployments = await this.deploymentsForAction('deploy');
-    const migrator = new ResourceMigrator({ deployments, ioHost, action });
+    const migrator = new ResourceMigrator({ deployments, ioHelper });
 
     await migrator.tryMigrateResources(stackCollection, options);
 
@@ -289,7 +289,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
 
     const hotswapMode = options.hotswap ?? HotswapMode.FULL_DEPLOYMENT;
     if (hotswapMode !== HotswapMode.FULL_DEPLOYMENT) {
-      await ioHost.notify(IO.CDK_TOOLKIT_W5400.msg([
+      await ioHelper.notify(IO.CDK_TOOLKIT_W5400.msg([
         '⚠️ The --hotswap and --hotswap-fallback flags deliberately introduce CloudFormation drift to speed up deployments',
         '⚠️ They should only be used for development - never use them for your production Stacks!',
       ].join('\n')));
@@ -324,7 +324,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
     const deployStack = async (stackNode: StackNode) => {
       const stack = stackNode.stack;
       if (stackCollection.stackCount !== 1) {
-        await ioHost.notify(IO.DEFAULT_TOOLKIT_INFO.msg(chalk.bold(stack.displayName)));
+        await ioHelper.notify(IO.DEFAULT_TOOLKIT_INFO.msg(chalk.bold(stack.displayName)));
       }
 
       if (!stack.environment) {
@@ -338,11 +338,11 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
         // stack is empty and doesn't exist => do nothing
         const stackExists = await deployments.stackExists({ stack });
         if (!stackExists) {
-          return ioHost.notify(IO.CDK_TOOLKIT_W5021.msg(`${chalk.bold(stack.displayName)}: stack has no resources, skipping deployment.`));
+          return ioHelper.notify(IO.CDK_TOOLKIT_W5021.msg(`${chalk.bold(stack.displayName)}: stack has no resources, skipping deployment.`));
         }
 
         // stack is empty, but exists => delete
-        await ioHost.notify(IO.CDK_TOOLKIT_W5022.msg(`${chalk.bold(stack.displayName)}: stack has no resources, deleting existing stack.`));
+        await ioHelper.notify(IO.CDK_TOOLKIT_W5022.msg(`${chalk.bold(stack.displayName)}: stack has no resources, deleting existing stack.`));
         await this._destroy(assembly, 'deploy', {
           stacks: { patterns: [stack.hierarchicalId], strategy: StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE },
           roleArn: options.roleArn,
@@ -356,7 +356,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
       const permissionChangeType = determinePermissionType(currentTemplate, stack);
       const deployMotivation = '"--require-approval" is enabled and stack includes security-sensitive updates.';
       const deployQuestion = `${deployMotivation}\nDo you wish to deploy these changes`;
-      const deployConfirmed = await ioHost.requestResponse(IO.CDK_TOOLKIT_I5060.req(deployQuestion, {
+      const deployConfirmed = await ioHelper.requestResponse(IO.CDK_TOOLKIT_I5060.req(deployQuestion, {
         motivation: deployMotivation,
         concurrency,
         permissionChangeType: permissionChangeType,
@@ -381,7 +381,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
       }
 
       const stackIndex = stacks.indexOf(stack) + 1;
-      await ioHost.notify(IO.CDK_TOOLKIT_I5100.msg(`${chalk.bold(stack.displayName)}: deploying... [${stackIndex}/${stackCollection.stackCount}]`, {
+      await ioHelper.notify(IO.CDK_TOOLKIT_I5100.msg(`${chalk.bold(stack.displayName)}: deploying... [${stackIndex}/${stackCollection.stackCount}]`, {
         total: stackCollection.stackCount,
         current: stackIndex,
         stack,
@@ -435,9 +435,9 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
               const question = `${motivation}. Perform a regular deployment`;
 
               if (options.force) {
-                await ioHost.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`${motivation}. Rolling back first (--force).`));
+                await ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`${motivation}. Rolling back first (--force).`));
               } else {
-                const confirmed = await ioHost.requestResponse(IO.CDK_TOOLKIT_I5050.req(question, {
+                const confirmed = await ioHelper.requestResponse(IO.CDK_TOOLKIT_I5050.req(question, {
                   motivation,
                   concurrency,
                 }));
@@ -463,9 +463,9 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
 
               // @todo no force here
               if (options.force) {
-                await ioHost.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`${motivation}. Proceeding with regular deployment (--force).`));
+                await ioHelper.notify(IO.DEFAULT_TOOLKIT_WARN.msg(`${motivation}. Proceeding with regular deployment (--force).`));
               } else {
-                const confirmed = await ioHost.requestResponse(IO.CDK_TOOLKIT_I5050.req(question, {
+                const confirmed = await ioHelper.requestResponse(IO.CDK_TOOLKIT_I5050.req(question, {
                   motivation,
                   concurrency,
                 }));
@@ -488,8 +488,8 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
           ? ` ✅  ${stack.displayName} (no changes)`
           : ` ✅  ${stack.displayName}`;
 
-        await ioHost.notify(IO.CDK_TOOLKIT_I5900.msg(chalk.green('\n' + message), deployResult));
-        deployDuration = await deployTimer.endAs(ioHost, 'deploy');
+        await ioHelper.notify(IO.CDK_TOOLKIT_I5900.msg(chalk.green('\n' + message), deployResult));
+        deployDuration = await deployTimer.endAs(ioHelper, 'deploy');
 
         if (Object.keys(deployResult.outputs).length > 0) {
           const buffer = ['Outputs:'];
@@ -499,9 +499,9 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
             const value = deployResult.outputs[name];
             buffer.push(`${chalk.cyan(stack.id)}.${chalk.cyan(name)} = ${chalk.underline(chalk.cyan(value))}`);
           }
-          await ioHost.notify(IO.CDK_TOOLKIT_I5901.msg(buffer.join('\n')));
+          await ioHelper.notify(IO.CDK_TOOLKIT_I5901.msg(buffer.join('\n')));
         }
-        await ioHost.notify(IO.CDK_TOOLKIT_I5901.msg(`Stack ARN:\n${deployResult.stackArn}`));
+        await ioHelper.notify(IO.CDK_TOOLKIT_I5901.msg(`Stack ARN:\n${deployResult.stackArn}`));
       } catch (e: any) {
         // It has to be exactly this string because an integration test tests for
         // "bold(stackname) failed: ResourceNotReady: <error>"
@@ -512,13 +512,13 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
         if (options.traceLogs) {
           // deploy calls that originate from watch will come with their own cloudWatchLogMonitor
           const cloudWatchLogMonitor = options.cloudWatchLogMonitor ?? new CloudWatchLogEventMonitor();
-          const foundLogGroupsResult = await findCloudWatchLogGroups(await this.sdkProvider('deploy'), { ioHost, action }, stack);
+          const foundLogGroupsResult = await findCloudWatchLogGroups(await this.sdkProvider('deploy'), ioHelper, stack);
           cloudWatchLogMonitor.addLogGroups(
             foundLogGroupsResult.env,
             foundLogGroupsResult.sdk,
             foundLogGroupsResult.logGroupNames,
           );
-          await ioHost.notify(IO.CDK_TOOLKIT_I5031.msg(`The following log groups are added: ${foundLogGroupsResult.logGroupNames}`));
+          await ioHelper.notify(IO.CDK_TOOLKIT_I5031.msg(`The following log groups are added: ${foundLogGroupsResult.logGroupNames}`));
         }
 
         // If an outputs file has been specified, create the file path and write stack outputs to it once.
@@ -533,7 +533,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
         }
       }
       const duration = synthDuration.asMs + (deployDuration?.asMs ?? 0);
-      await ioHost.notify(IO.CDK_TOOLKIT_I5001.msg(`\n✨  Total time: ${formatTime(duration)}s\n`, { duration }));
+      await ioHelper.notify(IO.CDK_TOOLKIT_I5001.msg(`\n✨  Total time: ${formatTime(duration)}s\n`, { duration }));
     };
 
     const assetBuildTime = options.assetBuildTime ?? AssetBuildTime.ALL_BEFORE_DEPLOY;
@@ -544,7 +544,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
       stack,
       ...stack.dependencies.filter(x => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x)),
     ]);
-    const workGraph = new WorkGraphBuilder({ ioHost, action }, prebuildAssets).build(stacksAndTheirAssetManifests);
+    const workGraph = new WorkGraphBuilder(ioHelper, prebuildAssets).build(stacksAndTheirAssetManifests);
 
     // Unless we are running with '--force', skip already published assets
     if (!options.force) {
@@ -572,7 +572,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    */
   public async watch(cx: ICloudAssemblySource, options: WatchOptions): Promise<void> {
     const assembly = await assemblyFromSource(cx, false);
-    const ioHost = asIoHelper(this.ioHost, 'watch');
+    const ioHelper = asIoHelper(this.ioHost, 'watch');
     const rootDir = options.watchDir ?? process.cwd();
 
     if (options.include === undefined && options.exclude === undefined) {
@@ -605,7 +605,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
     }).concat(`${outdir}/**`, '**/.*', '**/.*/**', '**/node_modules/**');
 
     // Print some debug information on computed settings
-    await ioHost.notify(IO.CDK_TOOLKIT_I5310.msg([
+    await ioHelper.notify(IO.CDK_TOOLKIT_I5310.msg([
       `root directory used for 'watch' is: ${rootDir}`,
       `'include' patterns for 'watch': ${JSON.stringify(watchIncludes)}`,
       `'exclude' patterns for 'watch': ${JSON.stringify(watchExcludes)}`,
@@ -642,7 +642,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
         // TypeScript doesn't realize latch can change between 'awaits',
         // and thinks the above 'while' condition is always 'false' without the cast
         latch = 'deploying';
-        await ioHost.notify(IO.CDK_TOOLKIT_I5315.msg("Detected file changes during deployment. Invoking 'cdk deploy' again"));
+        await ioHelper.notify(IO.CDK_TOOLKIT_I5315.msg("Detected file changes during deployment. Invoking 'cdk deploy' again"));
         await this.invokeDeployFromWatch(assembly, options, cloudWatchLogMonitor);
       }
       latch = 'open';
@@ -656,8 +656,8 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
       })
       .on('ready', async () => {
         latch = 'open';
-        await ioHost.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg("'watch' received the 'ready' event. From now on, all file changes will trigger a deployment"));
-        await ioHost.notify(IO.CDK_TOOLKIT_I5314.msg("Triggering initial 'cdk deploy'"));
+        await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg("'watch' received the 'ready' event. From now on, all file changes will trigger a deployment"));
+        await ioHelper.notify(IO.CDK_TOOLKIT_I5314.msg("Triggering initial 'cdk deploy'"));
         await deployAndWatch();
       })
       .on('all', async (event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', filePath: string) => {
@@ -666,14 +666,14 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
           path: filePath,
         };
         if (latch === 'pre-ready') {
-          await ioHost.notify(IO.CDK_TOOLKIT_I5311.msg(`'watch' is observing ${event === 'addDir' ? 'directory' : 'the file'} '${filePath}' for changes`, watchEvent));
+          await ioHelper.notify(IO.CDK_TOOLKIT_I5311.msg(`'watch' is observing ${event === 'addDir' ? 'directory' : 'the file'} '${filePath}' for changes`, watchEvent));
         } else if (latch === 'open') {
-          await ioHost.notify(IO.CDK_TOOLKIT_I5312.msg(`Detected change to '${filePath}' (type: ${event}). Triggering 'cdk deploy'`, watchEvent));
+          await ioHelper.notify(IO.CDK_TOOLKIT_I5312.msg(`Detected change to '${filePath}' (type: ${event}). Triggering 'cdk deploy'`, watchEvent));
           await deployAndWatch();
         } else {
           // this means latch is either 'deploying' or 'queued'
           latch = 'queued';
-          await ioHost.notify(IO.CDK_TOOLKIT_I5313.msg(
+          await ioHelper.notify(IO.CDK_TOOLKIT_I5313.msg(
             `Detected change to '${filePath}' (type: ${event}) while 'cdk deploy' is still running. Will queue for another deployment after this one finishes'`,
             watchEvent,
           ));
@@ -695,21 +695,21 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    * Helper to allow rollback being called as part of the deploy or watch action.
    */
   private async _rollback(assembly: StackAssembly, action: 'rollback' | 'deploy' | 'watch', options: RollbackOptions): Promise<void> {
-    const ioHost = asIoHelper(this.ioHost, action);
+    const ioHelper = asIoHelper(this.ioHost, action);
     const synthTimer = Timer.start();
     const stacks = assembly.selectStacksV2(options.stacks);
-    await this.validateStacksMetadata(stacks, ioHost);
-    await synthTimer.endAs(ioHost, 'synth');
+    await this.validateStacksMetadata(stacks, ioHelper);
+    await synthTimer.endAs(ioHelper, 'synth');
 
     if (stacks.stackCount === 0) {
-      await ioHost.notify(IO.CDK_TOOLKIT_E6001.msg('No stacks selected'));
+      await ioHelper.notify(IO.CDK_TOOLKIT_E6001.msg('No stacks selected'));
       return;
     }
 
     let anyRollbackable = false;
 
     for (const [index, stack] of stacks.stackArtifacts.entries()) {
-      await ioHost.notify(IO.CDK_TOOLKIT_I6100.msg(`Rolling back ${chalk.bold(stack.displayName)}`, {
+      await ioHelper.notify(IO.CDK_TOOLKIT_I6100.msg(`Rolling back ${chalk.bold(stack.displayName)}`, {
         total: stacks.stackCount,
         current: index + 1,
         stack,
@@ -728,9 +728,9 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
         if (!stackResult.notInRollbackableState) {
           anyRollbackable = true;
         }
-        await rollbackTimer.endAs(ioHost, 'rollback');
+        await rollbackTimer.endAs(ioHelper, 'rollback');
       } catch (e: any) {
-        await ioHost.notify(IO.CDK_TOOLKIT_E6900.msg(`\n ❌  ${chalk.bold(stack.displayName)} failed: ${formatErrorMessage(e)}`, { error: e }));
+        await ioHelper.notify(IO.CDK_TOOLKIT_E6900.msg(`\n ❌  ${chalk.bold(stack.displayName)} failed: ${formatErrorMessage(e)}`, { error: e }));
         throw new ToolkitError('Rollback failed (use --force to orphan failing resources)');
       }
     }
@@ -753,23 +753,23 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
    * Helper to allow destroy being called as part of the deploy action.
    */
   private async _destroy(assembly: StackAssembly, action: 'deploy' | 'destroy', options: DestroyOptions): Promise<void> {
-    const ioHost = asIoHelper(this.ioHost, action);
+    const ioHelper = asIoHelper(this.ioHost, action);
     const synthTimer = Timer.start();
     // The stacks will have been ordered for deployment, so reverse them for deletion.
     const stacks = await assembly.selectStacksV2(options.stacks).reversed();
-    await synthTimer.endAs(ioHost, 'synth');
+    await synthTimer.endAs(ioHelper, 'synth');
 
     const motivation = 'Destroying stacks is an irreversible action';
     const question = `Are you sure you want to delete: ${chalk.red(stacks.hierarchicalIds.join(', '))}`;
-    const confirmed = await ioHost.requestResponse(IO.CDK_TOOLKIT_I7010.req(question, { motivation }));
+    const confirmed = await ioHelper.requestResponse(IO.CDK_TOOLKIT_I7010.req(question, { motivation }));
     if (!confirmed) {
-      return ioHost.notify(IO.CDK_TOOLKIT_E7010.msg('Aborted by user'));
+      return ioHelper.notify(IO.CDK_TOOLKIT_E7010.msg('Aborted by user'));
     }
 
     const destroyTimer = Timer.start();
     try {
       for (const [index, stack] of stacks.stackArtifacts.entries()) {
-        await ioHost.notify(IO.CDK_TOOLKIT_I7100.msg(chalk.green(`${chalk.blue(stack.displayName)}: destroying... [${index + 1}/${stacks.stackCount}]`), {
+        await ioHelper.notify(IO.CDK_TOOLKIT_I7100.msg(chalk.green(`${chalk.blue(stack.displayName)}: destroying... [${index + 1}/${stacks.stackCount}]`), {
           total: stacks.stackCount,
           current: index + 1,
           stack,
@@ -781,14 +781,14 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
             deployName: stack.stackName,
             roleArn: options.roleArn,
           });
-          await ioHost.notify(IO.CDK_TOOLKIT_I7900.msg(chalk.green(`\n ✅  ${chalk.blue(stack.displayName)}: ${action}ed`), stack));
+          await ioHelper.notify(IO.CDK_TOOLKIT_I7900.msg(chalk.green(`\n ✅  ${chalk.blue(stack.displayName)}: ${action}ed`), stack));
         } catch (e: any) {
-          await ioHost.notify(IO.CDK_TOOLKIT_E7900.msg(`\n ❌  ${chalk.blue(stack.displayName)}: ${action} failed ${e}`, { error: e }));
+          await ioHelper.notify(IO.CDK_TOOLKIT_E7900.msg(`\n ❌  ${chalk.blue(stack.displayName)}: ${action} failed ${e}`, { error: e }));
           throw e;
         }
       }
     } finally {
-      await destroyTimer.endAs(ioHost, 'destroy');
+      await destroyTimer.endAs(ioHelper, 'destroy');
     }
   }
 
@@ -816,8 +816,7 @@ export class Toolkit extends CloudAssemblySourceBuilder implements AsyncDisposab
     return new Deployments({
       sdkProvider: await this.sdkProvider(action),
       toolkitStackName: this.toolkitStackName,
-      ioHost: this.ioHost as any, // @todo temporary while we have to separate IIoHost interfaces
-      action,
+      ioHelper: asIoHelper(this.ioHost, action),
     });
   }
 
diff --git a/packages/aws-cdk/lib/api/aws-auth/sdk-logger.ts b/packages/aws-cdk/lib/api/aws-auth/sdk-logger.ts
index 8582c9618..5de89fa85 100644
--- a/packages/aws-cdk/lib/api/aws-auth/sdk-logger.ts
+++ b/packages/aws-cdk/lib/api/aws-auth/sdk-logger.ts
@@ -1,20 +1,19 @@
 import { inspect, format } from 'util';
 import { Logger } from '@smithy/types';
-import type { IIoHost } from '../../toolkit/cli-io-host';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { replacerBufferWithInfo } from '../../util';
 
 export class SdkToCliLogger implements Logger {
-  private readonly ioHost: IIoHost;
+  private readonly ioHelper: IoHelper;
 
-  public constructor(ioHost: IIoHost) {
-    this.ioHost = ioHost;
+  public constructor(ioHelper: IoHelper) {
+    this.ioHelper = ioHelper;
   }
 
   private notify(level: 'debug' | 'info' | 'warn' | 'error', ...content: any[]) {
-    void this.ioHost.notify({
+    void this.ioHelper.notify({
       time: new Date(),
       level: 'trace', // always log all SDK logs at trace level, no matter what level they are coming from the SDK
-      action: 'none' as any,
       code: 'CDK_SDK_I0000',
       message: format('[SDK %s] %s', level, formatSdkLoggerContent(content)),
     });
diff --git a/packages/aws-cdk/lib/api/bootstrap/bootstrap-environment.ts b/packages/aws-cdk/lib/api/bootstrap/bootstrap-environment.ts
index d62071184..e913e48e5 100644
--- a/packages/aws-cdk/lib/api/bootstrap/bootstrap-environment.ts
+++ b/packages/aws-cdk/lib/api/bootstrap/bootstrap-environment.ts
@@ -4,8 +4,8 @@ import * as cxapi from '@aws-cdk/cx-api';
 import type { BootstrapEnvironmentOptions, BootstrappingParameters } from './bootstrap-props';
 import { BootstrapStack, bootstrapVersionFromTemplate } from './deploy-bootstrap';
 import { legacyBootstrapTemplate } from './legacy-template';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { warn } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { bundledPackageRootDir, loadStructuredFile, serializeStructure } from '../../util';
 import type { SDK, SdkProvider } from '../aws-auth';
@@ -16,10 +16,13 @@ import { DEFAULT_TOOLKIT_STACK_NAME } from '../toolkit-info';
 export type BootstrapSource = { source: 'legacy' } | { source: 'default' } | { source: 'custom'; templateFile: string };
 
 export class Bootstrapper {
+  private readonly ioHelper: IoHelper;
+
   constructor(
     private readonly source: BootstrapSource = { source: 'default' },
-    private readonly msg: IoMessaging,
+    ioHelper: IoHelper,
   ) {
+    this.ioHelper = ioHelper;
   }
 
   public bootstrapEnvironment(
@@ -67,7 +70,7 @@ export class Bootstrapper {
     }
 
     const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
-    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.msg);
+    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper);
     return current.update(
       await this.loadTemplate(params),
       {},
@@ -92,7 +95,7 @@ export class Bootstrapper {
     const bootstrapTemplate = await this.loadTemplate();
 
     const toolkitStackName = options.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
-    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.msg);
+    const current = await BootstrapStack.lookup(sdkProvider, environment, toolkitStackName, this.ioHelper);
     const partition = await current.partition();
 
     if (params.createCustomerMasterKey !== undefined && params.kmsKeyId) {
@@ -148,8 +151,7 @@ export class Bootstrapper {
       // Would leave AdministratorAccess policies with a trust relationship, without the user explicitly
       // approving the trust policy.
       const implicitPolicy = `arn:${partition}:iam::aws:policy/AdministratorAccess`;
-      await this.msg.ioHost.notify(warn(
-        this.msg.action,
+      await this.ioHelper.notify(warn(
         `Using default execution policy of '${implicitPolicy}'. Pass '--cloudformation-execution-policies' to customize.`,
       ));
     } else if (cloudFormationExecutionPolicies.length === 0) {
@@ -197,18 +199,15 @@ export class Bootstrapper {
     }
     if (currentPermissionsBoundary !== policyName) {
       if (!currentPermissionsBoundary) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn(
           `Adding new permissions boundary ${policyName}`,
         ));
       } else if (!policyName) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn(
           `Removing existing permissions boundary ${currentPermissionsBoundary}`,
         ));
       } else {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn(
           `Changing permissions boundary from ${currentPermissionsBoundary} to ${policyName}`,
         ));
       }
diff --git a/packages/aws-cdk/lib/api/bootstrap/deploy-bootstrap.ts b/packages/aws-cdk/lib/api/bootstrap/deploy-bootstrap.ts
index b7044e0b0..0b54689fe 100644
--- a/packages/aws-cdk/lib/api/bootstrap/deploy-bootstrap.ts
+++ b/packages/aws-cdk/lib/api/bootstrap/deploy-bootstrap.ts
@@ -10,8 +10,8 @@ import {
   BootstrapEnvironmentOptions,
   DEFAULT_BOOTSTRAP_VARIANT,
 } from './bootstrap-props';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { warn } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import type { SDK, SdkProvider } from '../aws-auth';
 import { assertIsSuccessfulDeployStackResult, SuccessfulDeployStackResult } from '../deployments';
 import { deployStack } from '../deployments/deploy-stack';
@@ -34,15 +34,15 @@ import { DEFAULT_TOOLKIT_STACK_NAME, ToolkitInfo } from '../toolkit-info';
  * current bootstrap stack and doing something intelligent).
  */
 export class BootstrapStack {
-  public static async lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName: string, msg: IoMessaging) {
+  public static async lookup(sdkProvider: SdkProvider, environment: Environment, toolkitStackName: string, ioHelper: IoHelper) {
     toolkitStackName = toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME;
 
     const resolvedEnvironment = await sdkProvider.resolveEnvironment(environment);
     const sdk = (await sdkProvider.forEnvironment(resolvedEnvironment, Mode.ForWriting)).sdk;
 
-    const currentToolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, sdk, msg, toolkitStackName);
+    const currentToolkitInfo = await ToolkitInfo.lookup(resolvedEnvironment, sdk, ioHelper, toolkitStackName);
 
-    return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, msg);
+    return new BootstrapStack(sdkProvider, sdk, resolvedEnvironment, toolkitStackName, currentToolkitInfo, ioHelper);
   }
 
   protected constructor(
@@ -51,7 +51,7 @@ export class BootstrapStack {
     private readonly resolvedEnvironment: Environment,
     private readonly toolkitStackName: string,
     private readonly currentToolkitInfo: ToolkitInfo,
-    private readonly msg: IoMessaging,
+    private readonly ioHelper: IoHelper,
   ) {
   }
 
@@ -88,8 +88,7 @@ export class BootstrapStack {
       const currentVariant = this.currentToolkitInfo.variant;
       const newVariant = bootstrapVariantFromTemplate(template);
       if (currentVariant !== newVariant) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn(
           `Bootstrap stack already exists, containing '${currentVariant}'. Not overwriting it with a template containing '${newVariant}' (use --force if you intend to overwrite)`,
         ));
         return abortResponse;
@@ -99,15 +98,13 @@ export class BootstrapStack {
       const newVersion = bootstrapVersionFromTemplate(template);
       const currentVersion = this.currentToolkitInfo.version;
       if (newVersion < currentVersion) {
-        await this.msg.ioHost.notify(warn(
-          this.msg.action,
+        await this.ioHelper.notify(warn(
           `Bootstrap stack already at version ${currentVersion}. Not downgrading it to version ${newVersion} (use --force if you intend to downgrade)`,
         ));
         if (newVersion === 0) {
           // A downgrade with 0 as target version means we probably have a new-style bootstrap in the account,
           // and an old-style bootstrap as current target, which means the user probably forgot to put this flag in.
-          await this.msg.ioHost.notify(warn(
-            this.msg.action,
+          await this.ioHelper.notify(warn(
             "(Did you set the '@aws-cdk/core:newStyleStackSynthesis' feature flag in cdk.json?)",
           ));
         }
@@ -145,8 +142,8 @@ export class BootstrapStack {
       parameters,
       usePreviousParameters: options.usePreviousParameters ?? true,
       // Obviously we can't need a bootstrap stack to deploy a bootstrap stack
-      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.msg),
-    }, this.msg);
+      envResources: new NoBootstrapStackEnvironmentResources(this.resolvedEnvironment, this.sdk, this.ioHelper),
+    }, this.ioHelper);
 
     assertIsSuccessfulDeployStackResult(ret);
 
diff --git a/packages/aws-cdk/lib/api/deployments/asset-publishing.ts b/packages/aws-cdk/lib/api/deployments/asset-publishing.ts
index 7417459d8..5579d4e14 100644
--- a/packages/aws-cdk/lib/api/deployments/asset-publishing.ts
+++ b/packages/aws-cdk/lib/api/deployments/asset-publishing.ts
@@ -13,8 +13,9 @@ import {
   type ISecretsManagerClient,
 } from 'cdk-assets';
 import type { SDK } from '..';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { formatMessage } from '../../cli/messages';
-import { IIoHost, IoMessageLevel, IoMessaging } from '../../toolkit/cli-io-host';
+import type { IoMessageLevel } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import type { SdkProvider } from '../aws-auth';
 import { Mode } from '../plugin';
@@ -43,7 +44,7 @@ export async function publishAssets(
   sdk: SdkProvider,
   targetEnv: Environment,
   options: PublishAssetsOptions,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
 ) {
   // This shouldn't really happen (it's a programming error), but we don't have
   // the types here to guide us. Do an runtime validation to be super super sure.
@@ -58,7 +59,7 @@ export async function publishAssets(
 
   const publisher = new AssetPublishing(manifest, {
     aws: new PublishingAws(sdk, targetEnv),
-    progressListener: new PublishingProgressListener({ ioHost, action }),
+    progressListener: new PublishingProgressListener(ioHelper),
     throwOnError: false,
     publishInParallel: options.parallel ?? true,
     buildAssets: true,
@@ -183,12 +184,10 @@ export const EVENT_TO_LEVEL: Record<EventType, IoMessageLevel | false> = {
 };
 
 export abstract class BasePublishProgressListener implements IPublishProgressListener {
-  protected readonly ioHost: IIoHost;
-  protected readonly action: IoMessaging['action'];
+  protected readonly ioHelper: IoHelper;
 
-  constructor({ ioHost, action }: IoMessaging) {
-    this.ioHost = ioHost;
-    this.action = action;
+  constructor(ioHelper: IoHelper) {
+    this.ioHelper = ioHelper;
   }
 
   protected abstract getMessage(type: EventType, event: IPublishProgress): string;
@@ -196,10 +195,9 @@ export abstract class BasePublishProgressListener implements IPublishProgressLis
   public onPublishEvent(type: EventType, event: IPublishProgress): void {
     const level = EVENT_TO_LEVEL[type];
     if (level) {
-      void this.ioHost.notify(
+      void this.ioHelper.notify(
         formatMessage({
           level,
-          action: this.action,
           message: this.getMessage(type, event),
         }),
       );
diff --git a/packages/aws-cdk/lib/api/deployments/assets.ts b/packages/aws-cdk/lib/api/deployments/assets.ts
index 866354367..d600e7a47 100644
--- a/packages/aws-cdk/lib/api/deployments/assets.ts
+++ b/packages/aws-cdk/lib/api/deployments/assets.ts
@@ -4,8 +4,8 @@ import * as cxschema from '@aws-cdk/cloud-assembly-schema';
 import * as cxapi from '@aws-cdk/cx-api';
 import * as chalk from 'chalk';
 import { AssetManifestBuilder } from './asset-manifest-builder';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { EnvironmentResources } from '../environment';
 import { ToolkitInfo } from '../toolkit-info';
@@ -17,7 +17,7 @@ import { ToolkitInfo } from '../toolkit-info';
  * pass Asset coordinates.
  */
 export async function addMetadataAssetsToManifest(
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   stack: cxapi.CloudFormationStackArtifact,
   assetManifest: AssetManifestBuilder,
   envResources: EnvironmentResources,
@@ -44,16 +44,16 @@ export async function addMetadataAssetsToManifest(
     const reuseAsset = reuse.indexOf(asset.id) > -1;
 
     if (reuseAsset) {
-      await ioHost.notify(debug(action, `Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));
+      await ioHelper.notify(debug(`Reusing asset ${asset.id}: ${JSON.stringify(asset)}`));
       continue;
     }
 
-    await ioHost.notify(debug(action, `Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));
+    await ioHelper.notify(debug(`Preparing asset ${asset.id}: ${JSON.stringify(asset)}`));
     if (!stack.assembly) {
       throw new ToolkitError('Unexpected: stack assembly is required in order to find assets in assembly directory');
     }
 
-    Object.assign(params, await prepareAsset({ ioHost, action }, asset, assetManifest, envResources, toolkitInfo));
+    Object.assign(params, await prepareAsset(ioHelper, asset, assetManifest, envResources, toolkitInfo));
   }
 
   return params;
@@ -61,7 +61,7 @@ export async function addMetadataAssetsToManifest(
 
 // eslint-disable-next-line max-len
 async function prepareAsset(
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   asset: cxschema.AssetMetadataEntry,
   assetManifest: AssetManifestBuilder,
   envResources: EnvironmentResources,
@@ -71,7 +71,7 @@ async function prepareAsset(
     case 'zip':
     case 'file':
       return prepareFileAsset(
-        { ioHost, action },
+        ioHelper,
         asset,
         assetManifest,
         toolkitInfo,
@@ -85,7 +85,7 @@ async function prepareAsset(
 }
 
 async function prepareFileAsset(
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   asset: cxschema.FileAssetMetadataEntry,
   assetManifest: AssetManifestBuilder,
   toolkitInfo: ToolkitInfo,
@@ -98,7 +98,7 @@ async function prepareFileAsset(
   const key = `${s3Prefix}${baseName}`;
   const s3url = `s3://${toolkitInfo.bucketName}/${key}`;
 
-  await ioHost.notify(debug(action, `Storing asset ${asset.path} at ${s3url}`));
+  await ioHelper.notify(debug(`Storing asset ${asset.path} at ${s3url}`));
 
   assetManifest.addFileAsset(asset.sourceHash, {
     path: asset.path,
diff --git a/packages/aws-cdk/lib/api/deployments/checks.ts b/packages/aws-cdk/lib/api/deployments/checks.ts
index 35a04e267..92c6f1e41 100644
--- a/packages/aws-cdk/lib/api/deployments/checks.ts
+++ b/packages/aws-cdk/lib/api/deployments/checks.ts
@@ -1,11 +1,11 @@
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { SDK } from '../aws-auth';
 
 export async function determineAllowCrossAccountAssetPublishing(
   sdk: SDK,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   customStackName?: string,
 ): Promise<boolean> {
   try {
@@ -34,8 +34,8 @@ export async function determineAllowCrossAccountAssetPublishing(
     // of creating bootstrap resources. If they do, there's nothing for us to validate,
     // but we can't use that as a reason to disallow cross-account publishing. We'll just
     // have to trust they did their due diligence. So we fail open.
-    await ioHost.notify(debug(action, `Error determining cross account asset publishing: ${e}`));
-    await ioHost.notify(debug(action, 'Defaulting to allowing cross account asset publishing'));
+    await ioHelper.notify(debug(`Error determining cross account asset publishing: ${e}`));
+    await ioHelper.notify(debug('Defaulting to allowing cross account asset publishing'));
     return true;
   }
 }
diff --git a/packages/aws-cdk/lib/api/deployments/cloudformation.ts b/packages/aws-cdk/lib/api/deployments/cloudformation.ts
index e2a2bf030..da4ec7af2 100644
--- a/packages/aws-cdk/lib/api/deployments/cloudformation.ts
+++ b/packages/aws-cdk/lib/api/deployments/cloudformation.ts
@@ -13,8 +13,8 @@ import {
 import { AssetManifest, FileManifestEntry } from 'cdk-assets';
 import { AssetManifestBuilder } from './asset-manifest-builder';
 import type { Deployments } from './deployments';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { formatErrorMessage, deserializeStructure } from '../../util';
 import type { ICloudFormationClient, SdkProvider } from '../aws-auth';
@@ -288,12 +288,12 @@ async function waitFor<T>(
  */
 export async function waitForChangeSet(
   cfn: ICloudFormationClient,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   stackName: string,
   changeSetName: string,
   { fetchAll }: { fetchAll: boolean },
 ): Promise<DescribeChangeSetCommandOutput> {
-  await ioHost.notify(debug(action, format('Waiting for changeset %s on stack %s to finish creating...', changeSetName, stackName)));
+  await ioHelper.notify(debug(format('Waiting for changeset %s on stack %s to finish creating...', changeSetName, stackName)));
   const ret = await waitFor(async () => {
     const description = await describeChangeSet(cfn, stackName, changeSetName, {
       fetchAll,
@@ -301,7 +301,7 @@ export async function waitForChangeSet(
     // The following doesn't use a switch because tsc will not allow fall-through, UNLESS it is allows
     // EVERYWHERE that uses this library directly or indirectly, which is undesirable.
     if (description.Status === 'CREATE_PENDING' || description.Status === 'CREATE_IN_PROGRESS') {
-      await ioHost.notify(debug(action, format('Changeset %s on stack %s is still creating', changeSetName, stackName)));
+      await ioHelper.notify(debug(format('Changeset %s on stack %s is still creating', changeSetName, stackName)));
       return undefined;
     }
 
@@ -350,7 +350,7 @@ export type CreateChangeSetOptions = {
  * Create a changeset for a diff operation
  */
 export async function createDiffChangeSet(
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   options: PrepareChangeSetOptions,
 ): Promise<DescribeChangeSetCommandOutput | undefined> {
   // `options.stack` has been modified to include any nested stack templates directly inline with its own template, under a special `NestedTemplate` property.
@@ -358,13 +358,13 @@ export async function createDiffChangeSet(
   // This causes CreateChangeSet to fail with `Template Error: Fn::Equals cannot be partially collapsed`.
   for (const resource of Object.values(options.stack.template.Resources ?? {})) {
     if ((resource as any).Type === 'AWS::CloudFormation::Stack') {
-      await ioHost.notify(debug(action, 'This stack contains one or more nested stacks, falling back to template-only diff...'));
+      await ioHelper.notify(debug('This stack contains one or more nested stacks, falling back to template-only diff...'));
 
       return undefined;
     }
   }
 
-  return uploadBodyParameterAndCreateChangeSet({ ioHost, action }, options);
+  return uploadBodyParameterAndCreateChangeSet(ioHelper, options);
 }
 
 /**
@@ -394,7 +394,7 @@ function templatesFromAssetManifestArtifact(
 }
 
 async function uploadBodyParameterAndCreateChangeSet(
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   options: PrepareChangeSetOptions,
 ): Promise<DescribeChangeSetCommandOutput | undefined> {
   try {
@@ -415,7 +415,7 @@ async function uploadBodyParameterAndCreateChangeSet(
       'Hold on while we create a read-only change set to get a diff with accurate replacement information (use --no-change-set to use a less accurate but faster template-only diff)\n',
     );
 
-    return await createChangeSet({ ioHost, action }, {
+    return await createChangeSet(ioHelper, {
       cfn,
       changeSetName: 'cdk-diff-change-set',
       stack: options.stack,
@@ -428,7 +428,7 @@ async function uploadBodyParameterAndCreateChangeSet(
       role: executionRoleArn,
     });
   } catch (e: any) {
-    await ioHost.notify(debug(action, e));
+    await ioHelper.notify(debug(e));
     options.stream.write(
       'Could not create a change set, will base the diff on template differences (run again with -v to see the reason)\n',
     );
@@ -465,12 +465,12 @@ export async function uploadStackTemplateAssets(stack: cxapi.CloudFormationStack
 }
 
 export async function createChangeSet(
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   options: CreateChangeSetOptions,
 ): Promise<DescribeChangeSetCommandOutput> {
-  await cleanupOldChangeset(options.cfn, { ioHost, action }, options.changeSetName, options.stack.stackName);
+  await cleanupOldChangeset(options.cfn, ioHelper, options.changeSetName, options.stack.stackName);
 
-  await ioHost.notify(debug(action, `Attempting to create ChangeSet with name ${options.changeSetName} for stack ${options.stack.stackName}`));
+  await ioHelper.notify(debug(`Attempting to create ChangeSet with name ${options.changeSetName} for stack ${options.stack.stackName}`));
 
   const templateParams = TemplateParameters.fromTemplate(options.stack.template);
   const stackParams = templateParams.supplyAll(options.parameters);
@@ -490,12 +490,12 @@ export async function createChangeSet(
     Capabilities: ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM', 'CAPABILITY_AUTO_EXPAND'],
   });
 
-  await ioHost.notify(debug(action, format('Initiated creation of changeset: %s; waiting for it to finish creating...', changeSet.Id)));
+  await ioHelper.notify(debug(format('Initiated creation of changeset: %s; waiting for it to finish creating...', changeSet.Id)));
   // Fetching all pages if we'll execute, so we can have the correct change count when monitoring.
-  const createdChangeSet = await waitForChangeSet(options.cfn, { ioHost, action }, options.stack.stackName, options.changeSetName, {
+  const createdChangeSet = await waitForChangeSet(options.cfn, ioHelper, options.stack.stackName, options.changeSetName, {
     fetchAll: options.willExecute,
   });
-  await cleanupOldChangeset(options.cfn, { ioHost, action }, options.changeSetName, options.stack.stackName);
+  await cleanupOldChangeset(options.cfn, ioHelper, options.changeSetName, options.stack.stackName);
 
   return createdChangeSet;
 }
@@ -509,13 +509,13 @@ function toCfnTags(tags: { [id: string]: string }): Tag[] {
 
 async function cleanupOldChangeset(
   cfn: ICloudFormationClient,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   changeSetName: string,
   stackName: string,
 ) {
   // Delete any existing change sets generated by CDK since change set names must be unique.
   // The delete request is successful as long as the stack exists (even if the change set does not exist).
-  await ioHost.notify(debug(action, `Removing existing change set with name ${changeSetName} if it exists`));
+  await ioHelper.notify(debug(`Removing existing change set with name ${changeSetName} if it exists`));
   await cfn.deleteChangeSet({
     StackName: stackName,
     ChangeSetName: changeSetName,
@@ -556,10 +556,10 @@ export function changeSetHasNoChanges(description: DescribeChangeSetCommandOutpu
  */
 export async function waitForStackDelete(
   cfn: ICloudFormationClient,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   stackName: string,
 ): Promise<CloudFormationStack | undefined> {
-  const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+  const stack = await stabilizeStack(cfn, ioHelper, stackName);
   if (!stack) {
     return undefined;
   }
@@ -588,10 +588,10 @@ export async function waitForStackDelete(
  */
 export async function waitForStackDeploy(
   cfn: ICloudFormationClient,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   stackName: string,
 ): Promise<CloudFormationStack | undefined> {
-  const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+  const stack = await stabilizeStack(cfn, ioHelper, stackName);
   if (!stack) {
     return undefined;
   }
@@ -614,18 +614,19 @@ export async function waitForStackDeploy(
  */
 export async function stabilizeStack(
   cfn: ICloudFormationClient,
-  { ioHost, action }: IoMessaging, stackName: string,
+  ioHelper: IoHelper,
+  stackName: string,
 ) {
-  await ioHost.notify(debug(action, format('Waiting for stack %s to finish creating or updating...', stackName)));
+  await ioHelper.notify(debug(format('Waiting for stack %s to finish creating or updating...', stackName)));
   return waitFor(async () => {
     const stack = await CloudFormationStack.lookup(cfn, stackName);
     if (!stack.exists) {
-      await ioHost.notify(debug(action, format('Stack %s does not exist', stackName)));
+      await ioHelper.notify(debug(format('Stack %s does not exist', stackName)));
       return null;
     }
     const status = stack.stackStatus;
     if (status.isInProgress) {
-      await ioHost.notify(debug(action, format('Stack %s has an ongoing operation in progress and is not stable (%s)', stackName, status)));
+      await ioHelper.notify(debug(format('Stack %s has an ongoing operation in progress and is not stable (%s)', stackName, status)));
       return undefined;
     } else if (status.isReviewInProgress) {
       // This may happen if a stack creation operation is interrupted before the ChangeSet execution starts. Recovering
@@ -634,7 +635,7 @@ export async function stabilizeStack(
       // "forever" we proceed as if the stack was existing and stable. If there is a concurrent operation that just
       // hasn't finished proceeding just yet, either this operation or the concurrent one may fail due to the other one
       // having made progress. Which is fine. I guess.
-      await ioHost.notify(debug(action, format('Stack %s is in REVIEW_IN_PROGRESS state. Considering this is a stable status (%s)', stackName, status)));
+      await ioHelper.notify(debug(format('Stack %s is in REVIEW_IN_PROGRESS state. Considering this is a stable status (%s)', stackName, status)));
     }
 
     return stack;
diff --git a/packages/aws-cdk/lib/api/deployments/deploy-stack.ts b/packages/aws-cdk/lib/api/deployments/deploy-stack.ts
index acef95344..82380c131 100644
--- a/packages/aws-cdk/lib/api/deployments/deploy-stack.ts
+++ b/packages/aws-cdk/lib/api/deployments/deploy-stack.ts
@@ -28,8 +28,8 @@ import {
 import { ChangeSetDeploymentMethod, DeploymentMethod } from './deployment-method';
 import { DeployStackResult, SuccessfulDeployStackResult } from './deployment-result';
 import { tryHotswapDeployment } from './hotswap-deployments';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug, info, warn } from '../../cli/messages';
-import { IIoHost, IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { formatErrorMessage } from '../../util';
 import type { SDK, SdkProvider, ICloudFormationClient } from '../aws-auth';
@@ -201,7 +201,7 @@ export interface DeployStackOptions {
   readonly assetParallelism?: boolean;
 }
 
-export async function deployStack(options: DeployStackOptions, { ioHost, action }: IoMessaging): Promise<DeployStackResult> {
+export async function deployStack(options: DeployStackOptions, ioHelper: IoHelper): Promise<DeployStackResult> {
   const stackArtifact = options.stack;
 
   const stackEnv = options.resolvedEnvironment;
@@ -212,11 +212,11 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
   let cloudFormationStack = await CloudFormationStack.lookup(cfn, deployName);
 
   if (cloudFormationStack.stackStatus.isCreationFailure) {
-    await ioHost.notify(debug(action,
+    await ioHelper.notify(debug(
       `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`,
     ));
     await cfn.deleteStack({ StackName: deployName });
-    const deletedStack = await waitForStackDelete(cfn, { ioHost, action }, deployName);
+    const deletedStack = await waitForStackDelete(cfn, ioHelper, deployName);
     if (deletedStack && deletedStack.stackStatus.name !== 'DELETE_COMPLETE') {
       throw new ToolkitError(
         `Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`,
@@ -233,7 +233,7 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
   // parameters.
   const legacyAssets = new AssetManifestBuilder();
   const assetParams = await addMetadataAssetsToManifest(
-    { ioHost, action },
+    ioHelper,
     stackArtifact,
     legacyAssets,
     options.envResources,
@@ -250,12 +250,12 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
   const hotswapMode = options.hotswap ?? HotswapMode.FULL_DEPLOYMENT;
   const hotswapPropertyOverrides = options.hotswapPropertyOverrides ?? new HotswapPropertyOverrides();
 
-  if (await canSkipDeploy(options, cloudFormationStack, stackParams.hasChanges(cloudFormationStack.parameters), { ioHost, action })) {
-    await ioHost.notify(debug(action, `${deployName}: skipping deployment (use --force to override)`));
+  if (await canSkipDeploy(options, cloudFormationStack, stackParams.hasChanges(cloudFormationStack.parameters), ioHelper)) {
+    await ioHelper.notify(debug(`${deployName}: skipping deployment (use --force to override)`));
     // if we can skip deployment and we are performing a hotswap, let the user know
     // that no hotswap deployment happened
     if (hotswapMode !== HotswapMode.FULL_DEPLOYMENT) {
-      await ioHost.notify(info(action,
+      await ioHelper.notify(info(
         format(
           `\n ${ICON} %s\n`,
           chalk.bold('hotswap deployment skipped - no changes were detected (use --force to override)'),
@@ -269,7 +269,7 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
       stackArn: cloudFormationStack.stackId,
     };
   } else {
-    await ioHost.notify(debug(action, `${deployName}: deploying...`));
+    await ioHelper.notify(debug(`${deployName}: deploying...`));
   }
 
   const bodyParameter = await makeBodyParameter(
@@ -283,19 +283,19 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
   try {
     bootstrapStackName = (await options.envResources.lookupToolkit()).stackName;
   } catch (e) {
-    await ioHost.notify(debug(action, `Could not determine the bootstrap stack name: ${e}`));
+    await ioHelper.notify(debug(`Could not determine the bootstrap stack name: ${e}`));
   }
   await publishAssets(legacyAssets.toManifest(stackArtifact.assembly.directory), options.sdkProvider, stackEnv, {
     parallel: options.assetParallelism,
-    allowCrossAccount: await determineAllowCrossAccountAssetPublishing(options.sdk, { ioHost, action }, bootstrapStackName),
-  }, { ioHost, action });
+    allowCrossAccount: await determineAllowCrossAccountAssetPublishing(options.sdk, ioHelper, bootstrapStackName),
+  }, ioHelper);
 
   if (hotswapMode !== HotswapMode.FULL_DEPLOYMENT) {
     // attempt to short-circuit the deployment if possible
     try {
       const hotswapDeploymentResult = await tryHotswapDeployment(
         options.sdkProvider,
-        { ioHost, action },
+        ioHelper,
         stackParams.values,
         cloudFormationStack,
         stackArtifact,
@@ -304,7 +304,7 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      await ioHost.notify(info(action, format(
+      await ioHelper.notify(info(format(
         'Could not perform a hotswap deployment, as the stack %s contains non-Asset changes',
         stackArtifact.displayName,
       )));
@@ -312,14 +312,14 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
       if (!(e instanceof CfnEvaluationException)) {
         throw e;
       }
-      await ioHost.notify(info(action, format(
+      await ioHelper.notify(info(format(
         'Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s',
         formatErrorMessage(e),
       )));
     }
 
     if (hotswapMode === HotswapMode.FALL_BACK) {
-      await ioHost.notify(info(action, 'Falling back to doing a full deployment'));
+      await ioHelper.notify(info('Falling back to doing a full deployment'));
       options.sdk.appendCustomUserAgent('cdk-hotswap/fallback');
     } else {
       return {
@@ -338,8 +338,7 @@ export async function deployStack(options: DeployStackOptions, { ioHost, action
     stackArtifact,
     stackParams,
     bodyParameter,
-    ioHost,
-    action,
+    ioHelper,
   );
   return fullDeployment.performDeployment();
 }
@@ -367,8 +366,7 @@ class FullCloudFormationDeployment {
     private readonly stackArtifact: cxapi.CloudFormationStackArtifact,
     private readonly stackParams: ParameterValues,
     private readonly bodyParameter: TemplateBodyParameter,
-    private readonly ioHost: IIoHost,
-    private readonly action: IoMessaging['action'],
+    private readonly ioHelper: IoHelper,
   ) {
     this.cfn = options.sdk.cloudFormation();
     this.stackName = options.deployName ?? stackArtifact.stackName;
@@ -404,9 +402,9 @@ class FullCloudFormationDeployment {
     await this.updateTerminationProtection();
 
     if (changeSetHasNoChanges(changeSetDescription)) {
-      await this.ioHost.notify(debug(this.action, format('No changes are to be performed on %s.', this.stackName)));
+      await this.ioHelper.notify(debug(format('No changes are to be performed on %s.', this.stackName)));
       if (execute) {
-        await this.ioHost.notify(debug(this.action, format('Deleting empty change set %s', changeSetDescription.ChangeSetId)));
+        await this.ioHelper.notify(debug(format('Deleting empty change set %s', changeSetDescription.ChangeSetId)));
         await this.cfn.deleteChangeSet({
           StackName: this.stackName,
           ChangeSetName: changeSetName,
@@ -414,8 +412,7 @@ class FullCloudFormationDeployment {
       }
 
       if (this.options.force) {
-        await this.ioHost.notify(warn(
-          this.action,
+        await this.ioHelper.notify(warn(
           [
             'You used the --force flag, but CloudFormation reported that the deployment would not make any changes.',
             'According to CloudFormation, all resources are already up-to-date with the state in your CDK app.',
@@ -435,7 +432,7 @@ class FullCloudFormationDeployment {
     }
 
     if (!execute) {
-      await this.ioHost.notify(info(this.action, format(
+      await this.ioHelper.notify(info(format(
         'Changeset %s created and waiting in review for manual execution (--no-execute)',
         changeSetDescription.ChangeSetId,
       )));
@@ -467,8 +464,8 @@ class FullCloudFormationDeployment {
   private async createChangeSet(changeSetName: string, willExecute: boolean, importExistingResources: boolean) {
     await this.cleanupOldChangeset(changeSetName);
 
-    await this.ioHost.notify(debug(this.action, `Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
-    await this.ioHost.notify(info(this.action, format('%s: creating CloudFormation changeset...', chalk.bold(this.stackName))));
+    await this.ioHelper.notify(debug(`Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`));
+    await this.ioHelper.notify(info(format('%s: creating CloudFormation changeset...', chalk.bold(this.stackName))));
     const changeSet = await this.cfn.createChangeSet({
       StackName: this.stackName,
       ChangeSetName: changeSetName,
@@ -480,15 +477,15 @@ class FullCloudFormationDeployment {
       ...this.commonPrepareOptions(),
     });
 
-    await this.ioHost.notify(debug(this.action, format('Initiated creation of changeset: %s; waiting for it to finish creating...', changeSet.Id)));
+    await this.ioHelper.notify(debug(format('Initiated creation of changeset: %s; waiting for it to finish creating...', changeSet.Id)));
     // Fetching all pages if we'll execute, so we can have the correct change count when monitoring.
-    return waitForChangeSet(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName, changeSetName, {
+    return waitForChangeSet(this.cfn, this.ioHelper, this.stackName, changeSetName, {
       fetchAll: willExecute,
     });
   }
 
   private async executeChangeSet(changeSet: DescribeChangeSetCommandOutput): Promise<SuccessfulDeployStackResult> {
-    await this.ioHost.notify(debug(this.action, format('Initiating execution of changeset %s on stack %s', changeSet.ChangeSetId, this.stackName)));
+    await this.ioHelper.notify(debug(format('Initiating execution of changeset %s on stack %s', changeSet.ChangeSetId, this.stackName)));
 
     await this.cfn.executeChangeSet({
       StackName: this.stackName,
@@ -497,8 +494,7 @@ class FullCloudFormationDeployment {
       ...this.commonExecuteOptions(),
     });
 
-    await this.ioHost.notify(debug(
-      this.action,
+    await this.ioHelper.notify(debug(
       format(
         'Execution of changeset %s on stack %s has started; waiting for the update to complete...',
         changeSet.ChangeSetId,
@@ -515,7 +511,7 @@ class FullCloudFormationDeployment {
     if (this.cloudFormationStack.exists) {
       // Delete any existing change sets generated by CDK since change set names must be unique.
       // The delete request is successful as long as the stack exists (even if the change set does not exist).
-      await this.ioHost.notify(debug(this.action, `Removing existing change set with name ${changeSetName} if it exists`));
+      await this.ioHelper.notify(debug(`Removing existing change set with name ${changeSetName} if it exists`));
       await this.cfn.deleteChangeSet({
         StackName: this.stackName,
         ChangeSetName: changeSetName,
@@ -527,8 +523,7 @@ class FullCloudFormationDeployment {
     // Update termination protection only if it has changed.
     const terminationProtection = this.stackArtifact.terminationProtection ?? false;
     if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
-      await this.ioHost.notify(debug(
-        this.action,
+      await this.ioHelper.notify(debug(
         format (
           'Updating termination protection from %s to %s for stack %s',
           this.cloudFormationStack.terminationProtection,
@@ -540,12 +535,12 @@ class FullCloudFormationDeployment {
         StackName: this.stackName,
         EnableTerminationProtection: terminationProtection,
       });
-      await this.ioHost.notify(debug(this.action, format('Termination protection updated to %s for stack %s', terminationProtection, this.stackName)));
+      await this.ioHelper.notify(debug(format('Termination protection updated to %s for stack %s', terminationProtection, this.stackName)));
     }
   }
 
   private async directDeployment(): Promise<SuccessfulDeployStackResult> {
-    await this.ioHost.notify(info(this.action, format('%s: %s stack...', chalk.bold(this.stackName), this.update ? 'updating' : 'creating')));
+    await this.ioHelper.notify(info(format('%s: %s stack...', chalk.bold(this.stackName), this.update ? 'updating' : 'creating')));
 
     const startTime = new Date();
 
@@ -561,7 +556,7 @@ class FullCloudFormationDeployment {
         });
       } catch (err: any) {
         if (err.message === 'No updates are to be performed.') {
-          await this.ioHost.notify(debug(this.action, format('No updates are to be performed for stack %s', this.stackName)));
+          await this.ioHelper.notify(debug(format('No updates are to be performed for stack %s', this.stackName)));
           return {
             type: 'did-deploy-stack',
             noOp: true,
@@ -595,15 +590,14 @@ class FullCloudFormationDeployment {
       stack: this.stackArtifact,
       stackName: this.stackName,
       resourcesTotal: expectedChanges,
-      ioHost: this.ioHost,
-      action: this.action,
+      ioHelper: this.ioHelper,
       changeSetCreationTime: startTime,
     });
     await monitor.start();
 
     let finalState = this.cloudFormationStack;
     try {
-      const successStack = await waitForStackDeploy(this.cfn, { ioHost: this.ioHost, action: this.action }, this.stackName);
+      const successStack = await waitForStackDeploy(this.cfn, this.ioHelper, this.stackName);
 
       // This shouldn't really happen, but catch it anyway. You never know.
       if (!successStack) {
@@ -615,7 +609,7 @@ class FullCloudFormationDeployment {
     } finally {
       await monitor.stop();
     }
-    debug(this.action, format('Stack %s has completed updating', this.stackName));
+    debug(format('Stack %s has completed updating', this.stackName));
     return {
       type: 'did-deploy-stack',
       noOp: false,
@@ -666,7 +660,7 @@ export interface DestroyStackOptions {
   deployName?: string;
 }
 
-export async function destroyStack(options: DestroyStackOptions, { ioHost, action }: IoMessaging) {
+export async function destroyStack(options: DestroyStackOptions, ioHelper: IoHelper) {
   const deployName = options.deployName || options.stack.stackName;
   const cfn = options.sdk.cloudFormation();
 
@@ -678,14 +672,13 @@ export async function destroyStack(options: DestroyStackOptions, { ioHost, actio
     cfn,
     stack: options.stack,
     stackName: deployName,
-    ioHost,
-    action,
+    ioHelper: ioHelper,
   });
   await monitor.start();
 
   try {
     await cfn.deleteStack({ StackName: deployName, RoleARN: options.roleArn });
-    const destroyedStack = await waitForStackDelete(cfn, { ioHost, action }, deployName);
+    const destroyedStack = await waitForStackDelete(cfn, ioHelper, deployName);
     if (destroyedStack && destroyedStack.stackStatus.name !== 'DELETE_COMPLETE') {
       throw new ToolkitError(`Failed to destroy ${deployName}: ${destroyedStack.stackStatus}`);
     }
@@ -711,14 +704,14 @@ async function canSkipDeploy(
   deployStackOptions: DeployStackOptions,
   cloudFormationStack: CloudFormationStack,
   parameterChanges: ParameterChanges,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
 ): Promise<boolean> {
   const deployName = deployStackOptions.deployName || deployStackOptions.stack.stackName;
-  await ioHost.notify(debug(action, `${deployName}: checking if we can skip deploy`));
+  await ioHelper.notify(debug(`${deployName}: checking if we can skip deploy`));
 
   // Forced deploy
   if (deployStackOptions.force) {
-    await ioHost.notify(debug(action, `${deployName}: forced deployment`));
+    await ioHelper.notify(debug(`${deployName}: forced deployment`));
     return false;
   }
 
@@ -727,53 +720,53 @@ async function canSkipDeploy(
     deployStackOptions.deploymentMethod?.method === 'change-set' &&
     deployStackOptions.deploymentMethod.execute === false
   ) {
-    await ioHost.notify(debug(action, `${deployName}: --no-execute, always creating change set`));
+    await ioHelper.notify(debug(`${deployName}: --no-execute, always creating change set`));
     return false;
   }
 
   // No existing stack
   if (!cloudFormationStack.exists) {
-    await ioHost.notify(debug(action, `${deployName}: no existing stack`));
+    await ioHelper.notify(debug(`${deployName}: no existing stack`));
     return false;
   }
 
   // Template has changed (assets taken into account here)
   if (JSON.stringify(deployStackOptions.stack.template) !== JSON.stringify(await cloudFormationStack.template())) {
-    await ioHost.notify(debug(action, `${deployName}: template has changed`));
+    await ioHelper.notify(debug(`${deployName}: template has changed`));
     return false;
   }
 
   // Tags have changed
   if (!compareTags(cloudFormationStack.tags, deployStackOptions.tags ?? [])) {
-    await ioHost.notify(debug(action, `${deployName}: tags have changed`));
+    await ioHelper.notify(debug(`${deployName}: tags have changed`));
     return false;
   }
 
   // Notification arns have changed
   if (!arrayEquals(cloudFormationStack.notificationArns, deployStackOptions.notificationArns ?? [])) {
-    await ioHost.notify(debug(action, `${deployName}: notification arns have changed`));
+    await ioHelper.notify(debug(`${deployName}: notification arns have changed`));
     return false;
   }
 
   // Termination protection has been updated
   if (!!deployStackOptions.stack.terminationProtection !== !!cloudFormationStack.terminationProtection) {
-    await ioHost.notify(debug(action, `${deployName}: termination protection has been updated`));
+    await ioHelper.notify(debug(`${deployName}: termination protection has been updated`));
     return false;
   }
 
   // Parameters have changed
   if (parameterChanges) {
     if (parameterChanges === 'ssm') {
-      await ioHost.notify(debug(action, `${deployName}: some parameters come from SSM so we have to assume they may have changed`));
+      await ioHelper.notify(debug(`${deployName}: some parameters come from SSM so we have to assume they may have changed`));
     } else {
-      await ioHost.notify(debug(action, `${deployName}: parameters have changed`));
+      await ioHelper.notify(debug(`${deployName}: parameters have changed`));
     }
     return false;
   }
 
   // Existing stack is in a failed state
   if (cloudFormationStack.stackStatus.isFailure) {
-    await ioHost.notify(debug(action, `${deployName}: stack is in a failure state`));
+    await ioHelper.notify(debug(`${deployName}: stack is in a failure state`));
     return false;
   }
 
diff --git a/packages/aws-cdk/lib/api/deployments/deployments.ts b/packages/aws-cdk/lib/api/deployments/deployments.ts
index bfb54c847..828596958 100644
--- a/packages/aws-cdk/lib/api/deployments/deployments.ts
+++ b/packages/aws-cdk/lib/api/deployments/deployments.ts
@@ -24,8 +24,8 @@ import {
   loadCurrentTemplateWithNestedStacks,
   type RootTemplateWithNestedStacks,
 } from './nested-stack-helpers';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug, warn } from '../../cli/messages';
-import { IIoHost, IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { formatErrorMessage } from '../../util';
 import type { SdkProvider } from '../aws-auth/sdk-provider';
@@ -296,8 +296,7 @@ export interface StackExistsOptions {
 export interface DeploymentsProps {
   readonly sdkProvider: SdkProvider;
   readonly toolkitStackName?: string;
-  readonly ioHost: IIoHost;
-  readonly action: IoMessaging['action'];
+  readonly ioHelper: IoHelper;
 }
 
 /**
@@ -332,18 +331,16 @@ export class Deployments {
 
   private _allowCrossAccountAssetPublishing: boolean | undefined;
 
-  private readonly ioHost: IIoHost;
-  private readonly action: IoMessaging['action'];
+  private readonly ioHelper: IoHelper;
 
   constructor(private readonly props: DeploymentsProps) {
     this.assetSdkProvider = props.sdkProvider;
     this.deployStackSdkProvider = props.sdkProvider;
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = props.ioHelper;
     this.envs = new EnvironmentAccess(
       props.sdkProvider,
       props.toolkitStackName ?? DEFAULT_TOOLKIT_STACK_NAME,
-      { ioHost: this.ioHost, action: this.action },
+      this.ioHelper,
     );
   }
 
@@ -363,7 +360,7 @@ export class Deployments {
   }
 
   public async readCurrentTemplate(stackArtifact: cxapi.CloudFormationStackArtifact): Promise<Template> {
-    await this.ioHost.notify(debug(this.action, `Reading existing template for stack ${stackArtifact.displayName}.`));
+    await this.ioHelper.notify(debug(`Reading existing template for stack ${stackArtifact.displayName}.`));
     const env = await this.envs.accessStackForLookupBestEffort(stackArtifact);
     return loadCurrentTemplate(stackArtifact, env.sdk);
   }
@@ -371,7 +368,7 @@ export class Deployments {
   public async resourceIdentifierSummaries(
     stackArtifact: cxapi.CloudFormationStackArtifact,
   ): Promise<ResourceIdentifierSummaries> {
-    await this.ioHost.notify(debug(this.action, `Retrieving template summary for stack ${stackArtifact.displayName}.`));
+    await this.ioHelper.notify(debug(`Retrieving template summary for stack ${stackArtifact.displayName}.`));
     // Currently, needs to use `deploy-role` since it may need to read templates in the staging
     // bucket which have been encrypted with a KMS key (and lookup-role may not read encrypted things)
     const env = await this.envs.accessStackForReadOnlyStackOperations(stackArtifact);
@@ -401,7 +398,7 @@ export class Deployments {
 
     const response = await cfn.getTemplateSummary(cfnParam);
     if (!response.ResourceIdentifierSummaries) {
-      await this.ioHost.notify(debug(this.action, 'GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'));
+      await this.ioHelper.notify(debug('GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'));
     }
     return response.ResourceIdentifierSummaries ?? [];
   }
@@ -454,7 +451,7 @@ export class Deployments {
       resourcesToImport: options.resourcesToImport,
       overrideTemplate: options.overrideTemplate,
       assetParallelism: options.assetParallelism,
-    }, { ioHost: this.ioHost, action: this.action });
+    }, this.ioHelper);
   }
 
   public async rollbackStack(options: RollbackStackOptions): Promise<RollbackStackResult> {
@@ -486,11 +483,11 @@ export class Deployments {
 
       switch (cloudFormationStack.stackStatus.rollbackChoice) {
         case RollbackChoice.NONE:
-          await this.ioHost.notify(warn(this.action, `Stack ${deployName} does not need a rollback: ${cloudFormationStack.stackStatus}`));
+          await this.ioHelper.notify(warn(`Stack ${deployName} does not need a rollback: ${cloudFormationStack.stackStatus}`));
           return { notInRollbackableState: true };
 
         case RollbackChoice.START_ROLLBACK:
-          await this.ioHost.notify(debug(this.action, `Initiating rollback of stack ${deployName}`));
+          await this.ioHelper.notify(debug(`Initiating rollback of stack ${deployName}`));
           await cfn.rollbackStack({
             StackName: deployName,
             RoleARN: executionRoleArn,
@@ -516,7 +513,7 @@ export class Deployments {
           }
 
           const skipDescription = resourcesToSkip.length > 0 ? ` (orphaning: ${resourcesToSkip.join(', ')})` : '';
-          await this.ioHost.notify(warn(this.action, `Continuing rollback of stack ${deployName}${skipDescription}`));
+          await this.ioHelper.notify(warn(`Continuing rollback of stack ${deployName}${skipDescription}`));
           await cfn.continueUpdateRollback({
             StackName: deployName,
             ClientRequestToken: randomUUID(),
@@ -526,8 +523,7 @@ export class Deployments {
           break;
 
         case RollbackChoice.ROLLBACK_FAILED:
-          await this.ioHost.notify(warn(
-            this.action,
+          await this.ioHelper.notify(warn(
             `Stack ${deployName} failed creation and rollback. This state cannot be rolled back. You can recreate this stack by running 'cdk deploy'.`,
           ));
           return { notInRollbackableState: true };
@@ -540,15 +536,14 @@ export class Deployments {
         cfn,
         stack: options.stack,
         stackName: deployName,
-        ioHost: this.ioHost,
-        action: this.action,
+        ioHelper: this.ioHelper,
       });
       await monitor.start();
 
       let stackErrorMessage: string | undefined = undefined;
       let finalStackState = cloudFormationStack;
       try {
-        const successStack = await stabilizeStack(cfn, { ioHost: this.ioHost, action: this.action }, deployName);
+        const successStack = await stabilizeStack(cfn, this.ioHelper, deployName);
 
         // This shouldn't really happen, but catch it anyway. You never know.
         if (!successStack) {
@@ -594,7 +589,7 @@ export class Deployments {
       roleArn: executionRoleArn,
       stack: options.stack,
       deployName: options.deployName,
-    }, { ioHost: this.ioHost, action: this.action });
+    }, this.ioHelper);
   }
 
   public async stackExists(options: StackExistsOptions): Promise<boolean> {
@@ -664,10 +659,7 @@ export class Deployments {
   private async allowCrossAccountAssetPublishingForEnv(stack: cxapi.CloudFormationStackArtifact): Promise<boolean> {
     if (this._allowCrossAccountAssetPublishing === undefined) {
       const env = await this.envs.accessStackForReadOnlyStackOperations(stack);
-      this._allowCrossAccountAssetPublishing = await determineAllowCrossAccountAssetPublishing(env.sdk, {
-        ioHost: this.ioHost,
-        action: this.action,
-      }, this.props.toolkitStackName);
+      this._allowCrossAccountAssetPublishing = await determineAllowCrossAccountAssetPublishing(env.sdk, this.ioHelper, this.props.toolkitStackName);
     }
     return this._allowCrossAccountAssetPublishing;
   }
@@ -713,7 +705,7 @@ export class Deployments {
       // The AssetPublishing class takes care of role assuming etc, so it's okay to
       // give it a direct `SdkProvider`.
       aws: new PublishingAws(this.assetSdkProvider, env),
-      progressListener: new ParallelSafeAssetProgress(prefix, { ioHost: this.ioHost, action: this.action }),
+      progressListener: new ParallelSafeAssetProgress(prefix, this.ioHelper),
     });
     this.publisherCache.set(assetManifest, publisher);
     return publisher;
@@ -726,8 +718,8 @@ export class Deployments {
 class ParallelSafeAssetProgress extends BasePublishProgressListener {
   private readonly prefix: string;
 
-  constructor(prefix: string, { ioHost, action }: IoMessaging) {
-    super({ ioHost, action });
+  constructor(prefix: string, ioHelper: IoHelper) {
+    super(ioHelper);
     this.prefix = prefix;
   }
 
diff --git a/packages/aws-cdk/lib/api/deployments/hotswap-deployments.ts b/packages/aws-cdk/lib/api/deployments/hotswap-deployments.ts
index 0ea64cad0..ef4f06fdb 100644
--- a/packages/aws-cdk/lib/api/deployments/hotswap-deployments.ts
+++ b/packages/aws-cdk/lib/api/deployments/hotswap-deployments.ts
@@ -32,7 +32,7 @@ import {
 import { isHotswappableStateMachineChange } from '../hotswap/stepfunctions-state-machines';
 import { Mode } from '../plugin';
 import { SuccessfulDeployStackResult } from './deployment-result';
-import { IoMessaging } from '../../toolkit/cli-io-host';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 // Must use a require() otherwise esbuild complains about calling a namespace
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -85,7 +85,7 @@ const RESOURCE_DETECTORS: { [key: string]: HotswapDetector } = {
  */
 export async function tryHotswapDeployment(
   sdkProvider: SdkProvider,
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   assetParams: { [key: string]: string },
   cloudFormationStack: CloudFormationStack,
   stackArtifact: cxapi.CloudFormationStackArtifact,
@@ -118,7 +118,7 @@ export async function tryHotswapDeployment(
     currentTemplate.nestedStacks, hotswapPropertyOverrides,
   );
 
-  await logNonHotswappableChanges({ ioHost, action }, nonHotswappableChanges, hotswapMode);
+  await logNonHotswappableChanges(ioHelper, nonHotswappableChanges, hotswapMode);
 
   // preserve classic hotswap behavior
   if (hotswapMode === HotswapMode.FALL_BACK) {
@@ -128,7 +128,7 @@ export async function tryHotswapDeployment(
   }
 
   // apply the short-circuitable changes
-  await applyAllHotswappableChanges(sdk, { ioHost, action }, hotswappableChanges);
+  await applyAllHotswappableChanges(sdk, ioHelper, hotswappableChanges);
 
   return {
     type: 'did-deploy-stack',
@@ -402,24 +402,24 @@ function isCandidateForHotswapping(
   };
 }
 
-async function applyAllHotswappableChanges(sdk: SDK, { ioHost, action }: IoMessaging, hotswappableChanges: HotswappableChange[]): Promise<void[]> {
+async function applyAllHotswappableChanges(sdk: SDK, ioHelper: IoHelper, hotswappableChanges: HotswappableChange[]): Promise<void[]> {
   if (hotswappableChanges.length > 0) {
-    await ioHost.notify(info(action, `\n${ICON} hotswapping resources:`));
+    await ioHelper.notify(info(`\n${ICON} hotswapping resources:`));
   }
   const limit = pLimit(10);
   // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
   return Promise.all(hotswappableChanges.map(hotswapOperation => limit(() => {
-    return applyHotswappableChange(sdk, { ioHost, action }, hotswapOperation);
+    return applyHotswappableChange(sdk, ioHelper, hotswapOperation);
   })));
 }
 
-async function applyHotswappableChange(sdk: SDK, { ioHost, action }: IoMessaging, hotswapOperation: HotswappableChange): Promise<void> {
+async function applyHotswappableChange(sdk: SDK, ioHelper: IoHelper, hotswapOperation: HotswappableChange): Promise<void> {
   // note the type of service that was successfully hotswapped in the User-Agent
   const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;
   sdk.appendCustomUserAgent(customUserAgent);
 
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info(action, format(`   ${ICON} %s`, chalk.bold(name))));
+    await ioHelper.notify(info(format(`   ${ICON} %s`, chalk.bold(name))));
   }
 
   // if the SDK call fails, an error will be thrown by the SDK
@@ -437,7 +437,7 @@ async function applyHotswappableChange(sdk: SDK, { ioHost, action }: IoMessaging
   }
 
   for (const name of hotswapOperation.resourceNames) {
-    await ioHost.notify(info(action, format(`${ICON} %s %s`, chalk.bold(name), chalk.green('hotswapped!'))));
+    await ioHelper.notify(info(format(`${ICON} %s %s`, chalk.bold(name), chalk.green('hotswapped!'))));
   }
 
   sdk.removeCustomUserAgent(customUserAgent);
@@ -462,7 +462,7 @@ function formatWaiterErrorResult(result: WaiterResult) {
 }
 
 async function logNonHotswappableChanges(
-  { ioHost, action }: IoMessaging,
+  ioHelper: IoHelper,
   nonHotswappableChanges: NonHotswappableChange[],
   hotswapMode: HotswapMode,
 ): Promise<void> {
@@ -512,5 +512,5 @@ async function logNonHotswappableChanges(
   }
   messages.push(''); // newline
 
-  await ioHost.notify(info(action, messages.join('\n')));
+  await ioHelper.notify(info(messages.join('\n')));
 }
diff --git a/packages/aws-cdk/lib/api/environment/environment-access.ts b/packages/aws-cdk/lib/api/environment/environment-access.ts
index 1d86f030a..7edbc02d5 100644
--- a/packages/aws-cdk/lib/api/environment/environment-access.ts
+++ b/packages/aws-cdk/lib/api/environment/environment-access.ts
@@ -1,8 +1,8 @@
 import * as cxapi from '@aws-cdk/cx-api';
 import { SDK } from '../aws-auth';
 import { EnvironmentResources, EnvironmentResourcesRegistry } from './environment-resources';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { warn } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { formatErrorMessage } from '../../util';
 import { CredentialsOptions, SdkForEnvironment, SdkProvider } from '../aws-auth/sdk-provider';
@@ -21,13 +21,11 @@ import { replaceEnvPlaceholders, StringWithoutPlaceholders } from '../util/place
 export class EnvironmentAccess {
   private readonly sdkCache = new Map<string, SdkForEnvironment>();
   private readonly environmentResources: EnvironmentResourcesRegistry;
-  private readonly ioHost: IoMessaging['ioHost'];
-  private readonly action: IoMessaging['action'];
+  private readonly ioHelper: IoHelper;
 
-  constructor(private readonly sdkProvider: SdkProvider, toolkitStackName: string, { ioHost, action }: IoMessaging) {
+  constructor(private readonly sdkProvider: SdkProvider, toolkitStackName: string, ioHelper: IoHelper) {
     this.environmentResources = new EnvironmentResourcesRegistry(toolkitStackName);
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
   }
 
   /**
@@ -113,7 +111,7 @@ export class EnvironmentAccess {
     }
     if (lookupEnv.isFallbackCredentials) {
       const arn = await lookupEnv.replacePlaceholders(stack.lookupRole?.arn);
-      await this.ioHost.notify(warn(this.action, `Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
+      await this.ioHelper.notify(warn(`Lookup role ${arn} was not assumed. Proceeding with default credentials.`));
     }
     return lookupEnv;
   }
@@ -137,7 +135,7 @@ export class EnvironmentAccess {
     try {
       return await this.accessStackForLookup(stack);
     } catch (e: any) {
-      await this.ioHost.notify(warn(this.action, `${formatErrorMessage(e)}`));
+      await this.ioHelper.notify(warn(`${formatErrorMessage(e)}`));
     }
     return this.accessStackForStackOperations(stack, Mode.ForReading);
   }
@@ -187,7 +185,7 @@ export class EnvironmentAccess {
     return {
       sdk: stackSdk.sdk,
       resolvedEnvironment,
-      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, { ioHost: this.ioHost, action: this.action }),
+      resources: this.environmentResources.for(resolvedEnvironment, stackSdk.sdk, this.ioHelper),
       // If we asked for a role, did not successfully assume it, and yet got here without an exception: that
       // means we must have fallback credentials.
       isFallbackCredentials: !stackSdk.didAssumeRole && !!assumeRoleArn,
diff --git a/packages/aws-cdk/lib/api/environment/environment-resources.ts b/packages/aws-cdk/lib/api/environment/environment-resources.ts
index f9fbd4324..48b1e087b 100644
--- a/packages/aws-cdk/lib/api/environment/environment-resources.ts
+++ b/packages/aws-cdk/lib/api/environment/environment-resources.ts
@@ -1,7 +1,7 @@
 import type { Environment } from '@aws-cdk/cx-api';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug, warn } from '../../cli/messages';
 import { Notices } from '../../notices';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { formatErrorMessage } from '../../util';
 import type { SDK } from '../aws-auth';
@@ -22,14 +22,14 @@ export class EnvironmentResourcesRegistry {
   constructor(private readonly toolkitStackName?: string) {
   }
 
-  public for(resolvedEnvironment: Environment, sdk: SDK, msg: IoMessaging) {
+  public for(resolvedEnvironment: Environment, sdk: SDK, ioHelper: IoHelper) {
     const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}`;
     let envCache = this.cache.get(key);
     if (!envCache) {
       envCache = emptyCache();
       this.cache.set(key, envCache);
     }
-    return new EnvironmentResources(resolvedEnvironment, sdk, msg, envCache, this.toolkitStackName);
+    return new EnvironmentResources(resolvedEnvironment, sdk, ioHelper, envCache, this.toolkitStackName);
   }
 }
 
@@ -49,7 +49,7 @@ export class EnvironmentResources {
   constructor(
     public readonly environment: Environment,
     private readonly sdk: SDK,
-    private readonly msg: IoMessaging,
+    private readonly ioHelper: IoHelper,
     private readonly cache: EnvironmentCache,
     private readonly toolkitStackName?: string,
   ) {
@@ -60,7 +60,7 @@ export class EnvironmentResources {
    */
   public async lookupToolkit() {
     if (!this.cache.toolkitInfo) {
-      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.msg, this.toolkitStackName);
+      this.cache.toolkitInfo = await ToolkitInfo.lookup(this.environment, this.sdk, this.ioHelper, this.toolkitStackName);
     }
     return this.cache.toolkitInfo;
   }
@@ -99,8 +99,7 @@ export class EnvironmentResources {
         // so let it fail as it would if we didn't have this fallback.
         const bootstrapStack = await this.lookupToolkit();
         if (bootstrapStack.found && bootstrapStack.version < BOOTSTRAP_TEMPLATE_VERSION_INTRODUCING_GETPARAMETER) {
-          await this.msg.ioHost.notify(warn(
-            this.msg.action,
+          await this.ioHelper.notify(warn(
             `Could not read SSM parameter ${ssmParameterName}: ${formatErrorMessage(e)}, falling back to version from ${bootstrapStack}`,
           ));
           doValidate(bootstrapStack.version, this.environment);
@@ -171,7 +170,7 @@ export class EnvironmentResources {
 
     // check if repo already exists
     try {
-      await this.msg.ioHost.notify(debug(this.msg.action, `${repositoryName}: checking if ECR repository already exists`));
+      await this.ioHelper.notify(debug(`${repositoryName}: checking if ECR repository already exists`));
       const describeResponse = await ecr.describeRepositories({
         repositoryNames: [repositoryName],
       });
@@ -186,7 +185,7 @@ export class EnvironmentResources {
     }
 
     // create the repo (tag it so it will be easier to garbage collect in the future)
-    await this.msg.ioHost.notify(debug(this.msg.action, `${repositoryName}: creating ECR repository`));
+    await this.ioHelper.notify(debug(`${repositoryName}: creating ECR repository`));
     const assetTag = { Key: 'awscdk:asset', Value: 'true' };
     const response = await ecr.createRepository({
       repositoryName,
@@ -198,7 +197,7 @@ export class EnvironmentResources {
     }
 
     // configure image scanning on push (helps in identifying software vulnerabilities, no additional charge)
-    await this.msg.ioHost.notify(debug(this.msg.action, `${repositoryName}: enable image scanning`));
+    await this.ioHelper.notify(debug(`${repositoryName}: enable image scanning`));
     await ecr.putImageScanningConfiguration({
       repositoryName,
       imageScanningConfiguration: { scanOnPush: true },
@@ -209,8 +208,8 @@ export class EnvironmentResources {
 }
 
 export class NoBootstrapStackEnvironmentResources extends EnvironmentResources {
-  constructor(environment: Environment, sdk: SDK, msg: IoMessaging) {
-    super(environment, sdk, msg, emptyCache());
+  constructor(environment: Environment, sdk: SDK, ioHelper: IoHelper) {
+    super(environment, sdk, ioHelper, emptyCache());
   }
 
   /**
diff --git a/packages/aws-cdk/lib/api/garbage-collection/garbage-collector.ts b/packages/aws-cdk/lib/api/garbage-collection/garbage-collector.ts
index f8fe42e4b..cab2eb703 100644
--- a/packages/aws-cdk/lib/api/garbage-collection/garbage-collector.ts
+++ b/packages/aws-cdk/lib/api/garbage-collection/garbage-collector.ts
@@ -7,8 +7,8 @@ import { IECRClient, IS3Client, SDK, SdkProvider } from '../aws-auth';
 import { DEFAULT_TOOLKIT_STACK_NAME, ToolkitInfo } from '../toolkit-info';
 import { ProgressPrinter } from './progress-printer';
 import { ActiveAssetCache, BackgroundStackRefresh, refreshStacks } from './stack-refresh';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug, info } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { Mode } from '../plugin/mode';
 
@@ -163,7 +163,7 @@ interface GarbageCollectorProps {
   /**
    * Used to send messages.
    */
-  readonly msg: IoMessaging;
+  readonly ioHelper: IoHelper;
 
   /**
    * The name of the bootstrap stack to look for.
@@ -190,12 +190,10 @@ export class GarbageCollector {
   private permissionToTag: boolean;
   private bootstrapStackName: string;
   private confirm: boolean;
-  private ioHost: IoMessaging['ioHost'];
-  private action: IoMessaging['action'];
+  private ioHelper: IoHelper;
 
   public constructor(readonly props: GarbageCollectorProps) {
-    this.ioHost = props.msg.ioHost;
-    this.action = props.msg.action;
+    this.ioHelper = props.ioHelper;
 
     this.garbageCollectS3Assets = ['s3', 'all'].includes(props.type);
     this.garbageCollectEcrAssets = ['ecr', 'all'].includes(props.type);
@@ -211,7 +209,7 @@ export class GarbageCollector {
    * Perform garbage collection on the resolved environment.
    */
   public async garbageCollect() {
-    await this.ioHost.notify(debug(this.action, `${this.garbageCollectS3Assets} ${this.garbageCollectEcrAssets}`));
+    await this.ioHelper.notify(debug(`${this.garbageCollectS3Assets} ${this.garbageCollectEcrAssets}`));
 
     // SDKs
     const sdk = (await this.props.sdkProvider.forEnvironment(this.props.resolvedEnvironment, Mode.ForWriting)).sdk;
@@ -221,11 +219,11 @@ export class GarbageCollector {
     const activeAssets = new ActiveAssetCache();
 
     // Grab stack templates first
-    await refreshStacks(cfn, this.props.msg, activeAssets, qualifier);
+    await refreshStacks(cfn, this.ioHelper, activeAssets, qualifier);
     // Start the background refresh
     const backgroundStackRefresh = new BackgroundStackRefresh({
       cfn,
-      msg: this.props.msg,
+      ioHelper: this.ioHelper,
       activeAssets,
       qualifier,
     });
@@ -253,9 +251,9 @@ export class GarbageCollector {
     const ecr = sdk.ecr();
     const repo = await this.bootstrapRepositoryName(sdk, this.bootstrapStackName);
     const numImages = await this.numImagesInRepo(ecr, repo);
-    const printer = new ProgressPrinter(this.props.msg, numImages, 1000);
+    const printer = new ProgressPrinter(this.ioHelper, numImages, 1000);
 
-    await this.ioHost.notify(debug(this.action, `Found bootstrap repo ${repo} with ${numImages} images`));
+    await this.ioHelper.notify(debug(`Found bootstrap repo ${repo} with ${numImages} images`));
 
     try {
       // const batches = 1;
@@ -263,7 +261,7 @@ export class GarbageCollector {
       const currentTime = Date.now();
       const graceDays = this.props.rollbackBufferDays;
 
-      await this.ioHost.notify(debug(this.action, `Parsing through ${numImages} images in batches`));
+      await this.ioHelper.notify(debug(`Parsing through ${numImages} images in batches`));
 
       printer.start();
 
@@ -272,16 +270,16 @@ export class GarbageCollector {
 
         const { included: isolated, excluded: notIsolated } = partition(batch, asset => !asset.tags.some(t => activeAssets.contains(t)));
 
-        await this.ioHost.notify(debug(this.action, `${isolated.length} isolated images`));
-        await this.ioHost.notify(debug(this.action, `${notIsolated.length} not isolated images`));
-        await this.ioHost.notify(debug(this.action, `${batch.length} images total`));
+        await this.ioHelper.notify(debug(`${isolated.length} isolated images`));
+        await this.ioHelper.notify(debug(`${notIsolated.length} not isolated images`));
+        await this.ioHelper.notify(debug(`${batch.length} images total`));
 
         let deletables: ImageAsset[] = isolated;
         let taggables: ImageAsset[] = [];
         let untaggables: ImageAsset[] = [];
 
         if (graceDays > 0) {
-          await this.ioHost.notify(debug(this.action, 'Filtering out images that are not old enough to delete'));
+          await this.ioHelper.notify(debug('Filtering out images that are not old enough to delete'));
 
           // We delete images that are not referenced in ActiveAssets and have the Isolated Tag with a date
           // earlier than the current time - grace period.
@@ -294,9 +292,9 @@ export class GarbageCollector {
           untaggables = notIsolated.filter(img => img.hasIsolatedTag());
         }
 
-        await this.ioHost.notify(debug(this.action, `${deletables.length} deletable assets`));
-        await this.ioHost.notify(debug(this.action, `${taggables.length} taggable assets`));
-        await this.ioHost.notify(debug(this.action, `${untaggables.length} assets to untag`));
+        await this.ioHelper.notify(debug(`${deletables.length} deletable assets`));
+        await this.ioHelper.notify(debug(`${taggables.length} taggable assets`));
+        await this.ioHelper.notify(debug(`${untaggables.length} assets to untag`));
 
         if (this.permissionToDelete && deletables.length > 0) {
           await this.confirmationPrompt(printer, deletables, 'image');
@@ -327,16 +325,16 @@ export class GarbageCollector {
     const s3 = sdk.s3();
     const bucket = await this.bootstrapBucketName(sdk, this.bootstrapStackName);
     const numObjects = await this.numObjectsInBucket(s3, bucket);
-    const printer = new ProgressPrinter(this.props.msg, numObjects, 1000);
+    const printer = new ProgressPrinter(this.ioHelper, numObjects, 1000);
 
-    await this.ioHost.notify(debug(this.action, `Found bootstrap bucket ${bucket} with ${numObjects} objects`));
+    await this.ioHelper.notify(debug(`Found bootstrap bucket ${bucket} with ${numObjects} objects`));
 
     try {
       const batchSize = 1000;
       const currentTime = Date.now();
       const graceDays = this.props.rollbackBufferDays;
 
-      await this.ioHost.notify(debug(this.action, `Parsing through ${numObjects} objects in batches`));
+      await this.ioHelper.notify(debug(`Parsing through ${numObjects} objects in batches`));
 
       printer.start();
 
@@ -348,16 +346,16 @@ export class GarbageCollector {
 
         const { included: isolated, excluded: notIsolated } = partition(batch, asset => !activeAssets.contains(asset.fileName()));
 
-        await this.ioHost.notify(debug(this.action, `${isolated.length} isolated assets`));
-        await this.ioHost.notify(debug(this.action, `${notIsolated.length} not isolated assets`));
-        await this.ioHost.notify(debug(this.action, `${batch.length} objects total`));
+        await this.ioHelper.notify(debug(`${isolated.length} isolated assets`));
+        await this.ioHelper.notify(debug(`${notIsolated.length} not isolated assets`));
+        await this.ioHelper.notify(debug(`${batch.length} objects total`));
 
         let deletables: ObjectAsset[] = isolated;
         let taggables: ObjectAsset[] = [];
         let untaggables: ObjectAsset[] = [];
 
         if (graceDays > 0) {
-          await this.ioHost.notify(debug(this.action, 'Filtering out assets that are not old enough to delete'));
+          await this.ioHelper.notify(debug('Filtering out assets that are not old enough to delete'));
           await this.parallelReadAllTags(s3, batch);
 
           // We delete objects that are not referenced in ActiveAssets and have the Isolated Tag with a date
@@ -371,9 +369,9 @@ export class GarbageCollector {
           untaggables = notIsolated.filter(obj => obj.hasIsolatedTag());
         }
 
-        await this.ioHost.notify(debug(this.action, `${deletables.length} deletable assets`));
-        await this.ioHost.notify(debug(this.action, `${taggables.length} taggable assets`));
-        await this.ioHost.notify(debug(this.action, `${untaggables.length} assets to untag`));
+        await this.ioHelper.notify(debug(`${deletables.length} deletable assets`));
+        await this.ioHelper.notify(debug(`${taggables.length} taggable assets`));
+        await this.ioHelper.notify(debug(`${untaggables.length} assets to untag`));
 
         if (this.permissionToDelete && deletables.length > 0) {
           await this.confirmationPrompt(printer, deletables, 'object');
@@ -424,7 +422,7 @@ export class GarbageCollector {
       );
     }
 
-    await this.ioHost.notify(debug(this.action, `Untagged ${untaggables.length} assets`));
+    await this.ioHelper.notify(debug(`Untagged ${untaggables.length} assets`));
   }
 
   /**
@@ -455,7 +453,7 @@ export class GarbageCollector {
       );
     }
 
-    await this.ioHost.notify(debug(this.action, `Untagged ${untaggables.length} assets`));
+    await this.ioHelper.notify(debug(`Untagged ${untaggables.length} assets`));
   }
 
   /**
@@ -478,14 +476,14 @@ export class GarbageCollector {
           // This is a false negative -- an isolated asset is untagged
           // likely due to an imageTag collision. We can safely ignore,
           // and the isolated asset will be tagged next time.
-          await this.ioHost.notify(debug(this.action, `Warning: unable to tag image ${JSON.stringify(img.tags)} with ${img.buildImageTag(i)} due to the following error: ${error}`));
+          await this.ioHelper.notify(debug(`Warning: unable to tag image ${JSON.stringify(img.tags)} with ${img.buildImageTag(i)} due to the following error: ${error}`));
         }
       };
       await limit(() => tagEcr());
     }
 
     printer.reportTaggedAsset(taggables);
-    await this.ioHost.notify(debug(this.action, `Tagged ${taggables.length} assets`));
+    await this.ioHelper.notify(debug(`Tagged ${taggables.length} assets`));
   }
 
   /**
@@ -513,7 +511,7 @@ export class GarbageCollector {
     }
 
     printer.reportTaggedAsset(taggables);
-    await this.ioHost.notify(debug(this.action, `Tagged ${taggables.length} assets`));
+    await this.ioHelper.notify(debug(`Tagged ${taggables.length} assets`));
   }
 
   /**
@@ -538,11 +536,11 @@ export class GarbageCollector {
         });
 
         const deletedCount = batch.length;
-        await this.ioHost.notify(debug(this.action, `Deleted ${deletedCount} assets`));
+        await this.ioHelper.notify(debug(`Deleted ${deletedCount} assets`));
         printer.reportDeletedAsset(deletables.slice(0, deletedCount));
       }
     } catch (err) {
-      await this.ioHost.notify(info(this.action, chalk.red(`Error deleting images: ${err}`)));
+      await this.ioHelper.notify(info(chalk.red(`Error deleting images: ${err}`)));
     }
   }
 
@@ -571,26 +569,26 @@ export class GarbageCollector {
         });
 
         const deletedCount = batch.length;
-        await this.ioHost.notify(debug(this.action, `Deleted ${deletedCount} assets`));
+        await this.ioHelper.notify(debug(`Deleted ${deletedCount} assets`));
         printer.reportDeletedAsset(deletables.slice(0, deletedCount));
       }
     } catch (err) {
-      await this.ioHost.notify(debug(this.action, chalk.red(`Error deleting objects: ${err}`)));
+      await this.ioHelper.notify(debug(chalk.red(`Error deleting objects: ${err}`)));
     }
   }
 
   private async bootstrapBucketName(sdk: SDK, bootstrapStackName: string): Promise<string> {
-    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.props.msg, bootstrapStackName);
+    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);
     return toolkitInfo.bucketName;
   }
 
   private async bootstrapRepositoryName(sdk: SDK, bootstrapStackName: string): Promise<string> {
-    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.props.msg, bootstrapStackName);
+    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);
     return toolkitInfo.repositoryName;
   }
 
   private async bootstrapQualifier(sdk: SDK, bootstrapStackName: string): Promise<string | undefined> {
-    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.props.msg, bootstrapStackName);
+    const toolkitInfo = await ToolkitInfo.lookup(this.props.resolvedEnvironment, sdk, this.ioHelper, bootstrapStackName);
     return toolkitInfo.bootstrapStack.parameters.Qualifier;
   }
 
diff --git a/packages/aws-cdk/lib/api/garbage-collection/progress-printer.ts b/packages/aws-cdk/lib/api/garbage-collection/progress-printer.ts
index 97854dc60..8051af8f3 100644
--- a/packages/aws-cdk/lib/api/garbage-collection/progress-printer.ts
+++ b/packages/aws-cdk/lib/api/garbage-collection/progress-printer.ts
@@ -1,13 +1,11 @@
 import * as chalk from 'chalk';
 import { GcAsset as GCAsset } from './garbage-collector';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { info } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 
 export class ProgressPrinter {
-  private ioHost: IoMessaging['ioHost'];
-  private action: IoMessaging['action'];
-
+  private ioHelper: IoHelper;
   private totalAssets: number;
   private assetsScanned: number;
   private taggedAsset: number;
@@ -18,10 +16,8 @@ export class ProgressPrinter {
   private setInterval?: ReturnType<typeof setTimeout>;
   private isPaused: boolean;
 
-  constructor(msg: IoMessaging, totalAssets: number, interval?: number) {
-    this.ioHost = msg.ioHost;
-    this.action = msg.action;
-
+  constructor(ioHelper: IoHelper, totalAssets: number, interval?: number) {
+    this.ioHelper = ioHelper;
     this.totalAssets = totalAssets;
     this.assetsScanned = 0;
     this.taggedAsset = 0;
@@ -83,9 +79,9 @@ export class ProgressPrinter {
     const percentage = ((this.assetsScanned / this.totalAssets) * 100).toFixed(2);
     // print in MiB until we hit at least 1 GiB of data tagged/deleted
     if (Math.max(this.taggedAssetsSizeMb, this.deletedAssetsSizeMb) >= 1000) {
-      void this.ioHost.notify(info(this.action, chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${(this.taggedAssetsSizeMb / 1000).toFixed(2)} GiB) tagged, ${this.deletedAssets} assets (${(this.deletedAssetsSizeMb / 1000).toFixed(2)} GiB) deleted.`)));
+      void this.ioHelper.notify(info(chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${(this.taggedAssetsSizeMb / 1000).toFixed(2)} GiB) tagged, ${this.deletedAssets} assets (${(this.deletedAssetsSizeMb / 1000).toFixed(2)} GiB) deleted.`)));
     } else {
-      void this.ioHost.notify(info(this.action, chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${this.taggedAssetsSizeMb.toFixed(2)} MiB) tagged, ${this.deletedAssets} assets (${this.deletedAssetsSizeMb.toFixed(2)} MiB) deleted.`)));
+      void this.ioHelper.notify(info(chalk.green(`[${percentage}%] ${this.assetsScanned} files scanned: ${this.taggedAsset} assets (${this.taggedAssetsSizeMb.toFixed(2)} MiB) tagged, ${this.deletedAssets} assets (${this.deletedAssetsSizeMb.toFixed(2)} MiB) deleted.`)));
     }
   }
 }
diff --git a/packages/aws-cdk/lib/api/garbage-collection/stack-refresh.ts b/packages/aws-cdk/lib/api/garbage-collection/stack-refresh.ts
index dcb1ae950..e29d405ff 100644
--- a/packages/aws-cdk/lib/api/garbage-collection/stack-refresh.ts
+++ b/packages/aws-cdk/lib/api/garbage-collection/stack-refresh.ts
@@ -1,6 +1,6 @@
 import { ParameterDeclaration } from '@aws-sdk/client-cloudformation';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { ICloudFormationClient } from '../aws-auth';
 
@@ -37,7 +37,7 @@ async function paginateSdkCall(cb: (nextToken?: string) => Promise<string | unde
  * - stacks in DELETE_COMPLETE or DELETE_IN_PROGRESS stage
  * - stacks that are using a different bootstrap qualifier
  */
-async function fetchAllStackTemplates(cfn: ICloudFormationClient, { ioHost, action }: IoMessaging, qualifier?: string) {
+async function fetchAllStackTemplates(cfn: ICloudFormationClient, ioHelper: IoHelper, qualifier?: string) {
   const stackNames: string[] = [];
   await paginateSdkCall(async (nextToken) => {
     const stacks = await cfn.listStacks({ NextToken: nextToken });
@@ -53,7 +53,7 @@ async function fetchAllStackTemplates(cfn: ICloudFormationClient, { ioHost, acti
     return stacks.NextToken;
   });
 
-  await ioHost.notify(debug(action, `Parsing through ${stackNames.length} stacks`));
+  await ioHelper.notify(debug(`Parsing through ${stackNames.length} stacks`));
 
   const templates: string[] = [];
   for (const stack of stackNames) {
@@ -74,7 +74,7 @@ async function fetchAllStackTemplates(cfn: ICloudFormationClient, { ioHost, acti
     }
   }
 
-  await ioHost.notify(debug(action, 'Done parsing through stacks'));
+  await ioHelper.notify(debug('Done parsing through stacks'));
 
   return templates;
 }
@@ -98,9 +98,9 @@ function bootstrapFilter(parameters?: ParameterDeclaration[], qualifier?: string
           splitBootstrapVersion[2] != qualifier);
 }
 
-export async function refreshStacks(cfn: ICloudFormationClient, { ioHost, action }: IoMessaging, activeAssets: ActiveAssetCache, qualifier?: string) {
+export async function refreshStacks(cfn: ICloudFormationClient, ioHelper: IoHelper, activeAssets: ActiveAssetCache, qualifier?: string) {
   try {
-    const stacks = await fetchAllStackTemplates(cfn, { ioHost, action }, qualifier);
+    const stacks = await fetchAllStackTemplates(cfn, ioHelper, qualifier);
     for (const stack of stacks) {
       activeAssets.rememberStack(stack);
     }
@@ -121,7 +121,7 @@ export interface BackgroundStackRefreshProps {
   /**
    * Used to send messages.
    */
-  readonly msg: IoMessaging;
+  readonly ioHelper: IoHelper;
 
   /**
    * Active Asset storage
@@ -155,7 +155,7 @@ export class BackgroundStackRefresh {
   private async refresh() {
     const startTime = Date.now();
 
-    await refreshStacks(this.props.cfn, this.props.msg, this.props.activeAssets, this.props.qualifier);
+    await refreshStacks(this.props.cfn, this.props.ioHelper, this.props.activeAssets, this.props.qualifier);
     this.justRefreshedStacks();
 
     // If the last invocation of refreshStacks takes <5 minutes, the next invocation starts 5 minutes after the last one started.
diff --git a/packages/aws-cdk/lib/api/logs/find-cloudwatch-logs.ts b/packages/aws-cdk/lib/api/logs/find-cloudwatch-logs.ts
index df98d279b..068f772ab 100644
--- a/packages/aws-cdk/lib/api/logs/find-cloudwatch-logs.ts
+++ b/packages/aws-cdk/lib/api/logs/find-cloudwatch-logs.ts
@@ -1,7 +1,7 @@
 import type { CloudFormationStackArtifact, Environment } from '@aws-cdk/cx-api';
 import type { StackResourceSummary } from '@aws-sdk/client-cloudformation';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug } from '../../logging';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { formatErrorMessage } from '../../util';
 import type { SDK, SdkProvider } from '../aws-auth';
 import { EnvironmentAccess } from '../environment';
@@ -38,14 +38,14 @@ export interface FoundLogGroupsResult {
 
 export async function findCloudWatchLogGroups(
   sdkProvider: SdkProvider,
-  msg: IoMessaging,
+  ioHelper: IoHelper,
   stackArtifact: CloudFormationStackArtifact,
 ): Promise<FoundLogGroupsResult> {
   let sdk: SDK;
   const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
   // try to assume the lookup role and fallback to the default credentials
   try {
-    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, msg).accessStackForLookup(stackArtifact)).sdk;
+    sdk = (await new EnvironmentAccess(sdkProvider, DEFAULT_TOOLKIT_STACK_NAME, ioHelper).accessStackForLookup(stackArtifact)).sdk;
   } catch (e: any) {
     debug(`Failed to access SDK environment: ${formatErrorMessage(e)}`);
     sdk = (await sdkProvider.forEnvironment(resolvedEnv, Mode.ForReading)).sdk;
diff --git a/packages/aws-cdk/lib/api/resource-import/importer.ts b/packages/aws-cdk/lib/api/resource-import/importer.ts
index 1665c04c3..60b1a9c32 100644
--- a/packages/aws-cdk/lib/api/resource-import/importer.ts
+++ b/packages/aws-cdk/lib/api/resource-import/importer.ts
@@ -5,17 +5,15 @@ import * as cxapi from '@aws-cdk/cx-api';
 import * as chalk from 'chalk';
 import * as fs from 'fs-extra';
 import * as promptly from 'promptly';
-import { IoHelper, asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { error, info, warn } from '../../cli/messages';
-import type { IIoHost, IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { assertIsSuccessfulDeployStackResult, type Deployments, DeploymentMethod, ResourceIdentifierProperties, ResourcesToImport } from '../deployments';
 import type { Tag } from '../tags';
 
 export interface ResourceImporterProps {
   deployments: Deployments;
-  ioHost: IIoHost;
-  action: IoMessaging['action'];
+  ioHelper: IoHelper;
 }
 
 export interface ImportDeploymentOptions {
@@ -103,7 +101,7 @@ export class ResourceImporter {
 
   private readonly stack: cxapi.CloudFormationStackArtifact;
   private readonly cfn: Deployments;
-  private readonly ioHost: IoHelper;
+  private readonly ioHelper: IoHelper;
 
   constructor(
     stack: cxapi.CloudFormationStackArtifact,
@@ -111,7 +109,7 @@ export class ResourceImporter {
   ) {
     this.stack = stack;
     this.cfn = props.deployments;
-    this.ioHost = asIoHelper(props.ioHost, props.action as any);
+    this.ioHelper = props.ioHelper;
   }
 
   /**
@@ -145,19 +143,19 @@ export class ResourceImporter {
       const descr = this.describeResource(resource.logicalId);
       const idProps = contents[resource.logicalId];
       if (idProps) {
-        await this.ioHost.notify(info(this.ioHost.action, format('%s: importing using %s', chalk.blue(descr), chalk.blue(fmtdict(idProps)))));
+        await this.ioHelper.notify(info(format('%s: importing using %s', chalk.blue(descr), chalk.blue(fmtdict(idProps)))));
 
         ret.importResources.push(resource);
         ret.resourceMap[resource.logicalId] = idProps;
         delete contents[resource.logicalId];
       } else {
-        await this.ioHost.notify(info(this.ioHost.action, format('%s: skipping', chalk.blue(descr))));
+        await this.ioHelper.notify(info(format('%s: skipping', chalk.blue(descr))));
       }
     }
 
     const unknown = Object.keys(contents);
     if (unknown.length > 0) {
-      await this.ioHost.notify(warn(this.ioHost.action, `Unrecognized resource identifiers in mapping file: ${unknown.join(', ')}`));
+      await this.ioHelper.notify(warn(`Unrecognized resource identifiers in mapping file: ${unknown.join(', ')}`));
     }
 
     return ret;
@@ -207,9 +205,9 @@ export class ResourceImporter {
         ? ' ✅  %s (no changes)'
         : ' ✅  %s';
 
-      await this.ioHost.notify(info(this.ioHost.action, '\n' + chalk.green(format(message, this.stack.displayName))));
+      await this.ioHelper.notify(info('\n' + chalk.green(format(message, this.stack.displayName))));
     } catch (e) {
-      await this.ioHost.notify(error(this.ioHost.action, format('\n ❌  %s failed: %s', chalk.bold(this.stack.displayName), e), 'CDK_TOOLKIT_E3900'));
+      await this.ioHelper.notify(error(format('\n ❌  %s failed: %s', chalk.bold(this.stack.displayName), e), 'CDK_TOOLKIT_E3900'));
       throw e;
     }
   }
@@ -238,7 +236,7 @@ export class ResourceImporter {
       const offendingResources = nonAdditions.map(([logId, _]) => this.describeResource(logId));
 
       if (allowNonAdditions) {
-        await this.ioHost.notify(warn(this.ioHost.action, `Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`));
+        await this.ioHelper.notify(warn(`Ignoring updated/deleted resources (--force): ${offendingResources.join(', ')}`));
       } else {
         throw new ToolkitError('No resource updates or deletes are allowed on import operation. Make sure to resolve pending changes ' +
           `to existing resources, before attempting an import. Updated/deleted resources: ${offendingResources.join(', ')} (--force to override)`);
@@ -326,7 +324,7 @@ export class ResourceImporter {
     // Skip resources that do not support importing
     const resourceType = chg.resourceDiff.newResourceType;
     if (resourceType === undefined || !(resourceType in resourceIdentifiers)) {
-      await this.ioHost.notify(warn(this.ioHost.action, `${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
+      await this.ioHelper.notify(warn(`${resourceName}: unsupported resource type ${resourceType}, skipping import.`));
       return undefined;
     }
 
@@ -352,7 +350,7 @@ export class ResourceImporter {
 
     // If we got here and the user rejected any available identifiers, then apparently they don't want the resource at all
     if (satisfiedPropSets.length > 0) {
-      await this.ioHost.notify(info(this.ioHost.action, chalk.grey(`Skipping import of ${resourceName}`)));
+      await this.ioHelper.notify(info(chalk.grey(`Skipping import of ${resourceName}`)));
       return undefined;
     }
 
@@ -370,7 +368,7 @@ export class ResourceImporter {
 
     // Do the input loop here
     if (preamble) {
-      await this.ioHost.notify(info(this.ioHost.action, preamble));
+      await this.ioHelper.notify(info(preamble));
     }
     for (const idProps of idPropSets) {
       const input: Record<string, string> = {};
@@ -405,7 +403,7 @@ export class ResourceImporter {
       }
     }
 
-    await this.ioHost.notify(info(this.ioHost.action, chalk.grey(`Skipping import of ${resourceName}`)));
+    await this.ioHelper.notify(info(chalk.grey(`Skipping import of ${resourceName}`)));
     return undefined;
   }
 
diff --git a/packages/aws-cdk/lib/api/resource-import/migrator.ts b/packages/aws-cdk/lib/api/resource-import/migrator.ts
index ccb28b2f0..6d3845a68 100644
--- a/packages/aws-cdk/lib/api/resource-import/migrator.ts
+++ b/packages/aws-cdk/lib/api/resource-import/migrator.ts
@@ -2,27 +2,24 @@ import type * as cxapi from '@aws-cdk/cx-api';
 import * as chalk from 'chalk';
 import * as fs from 'fs-extra';
 import { ImportDeploymentOptions, ResourceImporter } from './importer';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { info } from '../../cli/messages';
-import type { IIoHost, IoMessaging } from '../../toolkit/cli-io-host';
 import { formatTime } from '../../util';
 import { StackCollection } from '../cxapp/cloud-assembly';
 import type { Deployments, ResourcesToImport } from '../deployments';
 
 export interface ResourceMigratorProps {
   deployments: Deployments;
-  ioHost: IIoHost;
-  action: IoMessaging['action'];
+  ioHelper: IoHelper;
 }
 
 export class ResourceMigrator {
   private readonly props: ResourceMigratorProps;
-  private readonly ioHost: IIoHost;
-  private readonly action: IoMessaging['action'];
+  private readonly ioHelper: IoHelper;
 
   public constructor(props: ResourceMigratorProps) {
     this.props = props;
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = props.ioHelper;
   }
 
   /**
@@ -35,19 +32,18 @@ export class ResourceMigrator {
     const stack = stacks.stackArtifacts[0];
     const migrateDeployment = new ResourceImporter(stack, {
       deployments: this.props.deployments,
-      ioHost: this.ioHost,
-      action: this.action,
+      ioHelper: this.ioHelper,
     });
     const resourcesToImport = await this.tryGetResources(await migrateDeployment.resolveEnvironment());
 
     if (resourcesToImport) {
-      await this.ioHost.notify(info(this.action, `${chalk.bold(stack.displayName)}: creating stack for resource migration...`));
-      await this.ioHost.notify(info(this.action, `${chalk.bold(stack.displayName)}: importing resources into stack...`));
+      await this.ioHelper.notify(info(`${chalk.bold(stack.displayName)}: creating stack for resource migration...`));
+      await this.ioHelper.notify(info(`${chalk.bold(stack.displayName)}: importing resources into stack...`));
 
       await this.performResourceMigration(migrateDeployment, resourcesToImport, options);
 
       fs.rmSync('migrate.json');
-      await this.ioHost.notify(info(this.action, `${chalk.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
+      await this.ioHelper.notify(info(`${chalk.bold(stack.displayName)}: applying CDKMetadata and Outputs to stack (if applicable)...`));
     }
   }
 
@@ -71,7 +67,7 @@ export class ResourceMigrator {
     });
 
     elapsedDeployTime = new Date().getTime() - startDeployTime;
-    await this.ioHost.notify(info(this.action, `'\n✨  Resource migration time: ${formatTime(elapsedDeployTime)}s\n'`, 'CDK_TOOLKIT_I5002', {
+    await this.ioHelper.notify(info(`'\n✨  Resource migration time: ${formatTime(elapsedDeployTime)}s\n'`, 'CDK_TOOLKIT_I5002', {
       duration: elapsedDeployTime,
     }));
   }
diff --git a/packages/aws-cdk/lib/api/stack-events/stack-activity-monitor.ts b/packages/aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
index 74fb2e751..b5064048a 100644
--- a/packages/aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
+++ b/packages/aws-cdk/lib/api/stack-events/stack-activity-monitor.ts
@@ -6,10 +6,10 @@ import { StackEvent } from '@aws-sdk/client-cloudformation';
 import * as uuid from 'uuid';
 import { StackEventPoller } from './stack-event-poller';
 import { debug, error, info } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { stackEventHasErrorMessage } from '../../util';
 import type { ICloudFormationClient } from '../aws-auth';
 import { StackProgress, StackProgressMonitor } from './stack-progress-monitor';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 /**
  * Payload when stack monitoring is starting or stopping for a given stack deployment.
@@ -77,14 +77,9 @@ export interface StackActivityMonitorProps {
   readonly cfn: ICloudFormationClient;
 
   /**
-   * The IoHost used for messaging
+   * The IoHelper used for messaging
    */
-  readonly ioHost: IoMessaging['ioHost'];
-
-  /**
-   * The current ToolkitAction
-   */
-  readonly action: IoMessaging['action'];
+  readonly ioHelper: IoHelper;
 
   /**
    * The stack artifact that is getting deployed
@@ -156,23 +151,20 @@ export class StackActivityMonitor {
    */
   private readPromise?: Promise<any>;
 
-  private readonly ioHost: IoMessaging['ioHost'];
-  private readonly action: IoMessaging['action'];
+  private readonly ioHelper: IoHelper;
   private readonly stackName: string;
   private readonly stack: CloudFormationStackArtifact;
 
   constructor({
     cfn,
-    ioHost,
-    action,
+    ioHelper,
     stack,
     stackName,
     resourcesTotal,
     changeSetCreationTime,
     pollingInterval = 2_000,
   }: StackActivityMonitorProps) {
-    this.ioHost = ioHost;
-    this.action = action;
+    this.ioHelper = ioHelper;
     this.stack = stack;
     this.stackName = stackName;
 
@@ -186,7 +178,7 @@ export class StackActivityMonitor {
 
   public async start() {
     this.monitorId = uuid.v4();
-    await this.ioHost.notify(debug(this.action, `Deploying ${this.stackName}`, 'CDK_TOOLKIT_I5501', {
+    await this.ioHelper.notify(debug(`Deploying ${this.stackName}`, 'CDK_TOOLKIT_I5501', {
       deployment: this.monitorId,
       stack: this.stack,
       stackName: this.stackName,
@@ -208,7 +200,7 @@ export class StackActivityMonitor {
     // up not printing the failure reason to users.
     await this.finalPollToEnd(oldMonitorId);
 
-    await this.ioHost.notify(debug(this.action, `Completed ${this.stackName}`, 'CDK_TOOLKIT_I5503', {
+    await this.ioHelper.notify(debug(`Completed ${this.stackName}`, 'CDK_TOOLKIT_I5503', {
       deployment: oldMonitorId,
       stack: this.stack,
       stackName: this.stackName,
@@ -239,8 +231,7 @@ export class StackActivityMonitor {
         return;
       }
     } catch (e) {
-      await this.ioHost.notify(error(
-        this.action,
+      await this.ioHelper.notify(error(
         util.format('Error occurred while monitoring stack: %s', e),
         'CDK_TOOLKIT_E5500',
         { error: e },
@@ -289,7 +280,7 @@ export class StackActivityMonitor {
       };
 
       this.checkForErrors(activity);
-      await this.ioHost.notify(info(this.action, this.formatActivity(activity, true), 'CDK_TOOLKIT_I5502', activity));
+      await this.ioHelper.notify(info(this.formatActivity(activity, true), 'CDK_TOOLKIT_I5502', activity));
     }
   }
 
diff --git a/packages/aws-cdk/lib/api/toolkit-info.ts b/packages/aws-cdk/lib/api/toolkit-info.ts
index b013319b0..1e47d1c4f 100644
--- a/packages/aws-cdk/lib/api/toolkit-info.ts
+++ b/packages/aws-cdk/lib/api/toolkit-info.ts
@@ -11,8 +11,8 @@ import {
   REPOSITORY_NAME_OUTPUT,
 } from './bootstrap/bootstrap-props';
 import { type CloudFormationStack, stabilizeStack } from './deployments/cloudformation';
+import { IoHelper } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug } from '../cli/messages';
-import { IoMessaging } from '../toolkit/cli-io-host';
 import { ToolkitError } from '../toolkit/error';
 
 export const DEFAULT_TOOLKIT_STACK_NAME = 'CDKToolkit';
@@ -48,16 +48,15 @@ export abstract class ToolkitInfo {
   public static async lookup(
     environment: cxapi.Environment,
     sdk: SDK,
-    { ioHost, action }: IoMessaging,
+    ioHelper: IoHelper,
     stackName: string | undefined,
   ): Promise<ToolkitInfo> {
     const cfn = sdk.cloudFormation();
     stackName = ToolkitInfo.determineName(stackName);
     try {
-      const stack = await stabilizeStack(cfn, { ioHost, action }, stackName);
+      const stack = await stabilizeStack(cfn, ioHelper, stackName);
       if (!stack) {
-        await ioHost.notify(debug(
-          action,
+        await ioHelper.notify(debug(
           format(
             "The environment %s doesn't have the CDK toolkit stack (%s) installed. Use %s to setup your environment for use with the toolkit.",
             environment.name,
@@ -69,8 +68,7 @@ export abstract class ToolkitInfo {
       }
       if (stack.stackStatus.isCreationFailure) {
         // Treat a "failed to create" bootstrap stack as an absent one.
-        await ioHost.notify(debug(
-          action,
+        await ioHelper.notify(debug(
           format(
             'The environment %s has a CDK toolkit stack (%s) that failed to create. Use %s to try provisioning it again.',
             environment.name,
diff --git a/packages/aws-cdk/lib/api/work-graph/work-graph-builder.ts b/packages/aws-cdk/lib/api/work-graph/work-graph-builder.ts
index b013b5bbf..e37f02473 100644
--- a/packages/aws-cdk/lib/api/work-graph/work-graph-builder.ts
+++ b/packages/aws-cdk/lib/api/work-graph/work-graph-builder.ts
@@ -2,7 +2,7 @@ import * as cxapi from '@aws-cdk/cx-api';
 import { AssetManifest, type IManifestEntry } from 'cdk-assets';
 import { WorkGraph } from './work-graph';
 import { DeploymentState, AssetBuildNode, WorkNode } from './work-graph-types';
-import { IoMessaging } from '../../toolkit/cli-io-host';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { ToolkitError } from '../../toolkit/error';
 import { contentHashAny } from '../../util';
 
@@ -22,17 +22,15 @@ export class WorkGraphBuilder {
     'stack': 5,
   };
   private readonly graph: WorkGraph;
-  private readonly ioHost: IoMessaging['ioHost'];
-  private readonly action: IoMessaging['action'];
+  private readonly ioHelper: IoHelper;
 
   constructor(
-    { ioHost, action }: IoMessaging,
+    ioHelper: IoHelper,
     private readonly prebuildAssets: boolean,
     private readonly idPrefix = '',
   ) {
-    this.graph = new WorkGraph({}, { ioHost, action });
-    this.ioHost = ioHost;
-    this.action = action;
+    this.graph = new WorkGraph({}, ioHelper);
+    this.ioHelper = ioHelper;
   }
 
   private addStack(artifact: cxapi.CloudFormationStackArtifact) {
@@ -130,7 +128,7 @@ export class WorkGraphBuilder {
       } else if (cxapi.NestedCloudAssemblyArtifact.isNestedCloudAssemblyArtifact(artifact)) {
         const assembly = new cxapi.CloudAssembly(artifact.fullPath, { topoSort: false });
         const nestedGraph = new WorkGraphBuilder(
-          { ioHost: this.ioHost, action: this.action },
+          this.ioHelper,
           this.prebuildAssets,
           `${this.idPrefix}${artifact.id}.`,
         ).build(assembly.artifacts);
diff --git a/packages/aws-cdk/lib/api/work-graph/work-graph.ts b/packages/aws-cdk/lib/api/work-graph/work-graph.ts
index 4c1e04207..9500e89fb 100644
--- a/packages/aws-cdk/lib/api/work-graph/work-graph.ts
+++ b/packages/aws-cdk/lib/api/work-graph/work-graph.ts
@@ -1,30 +1,22 @@
 import { WorkNode, DeploymentState, StackNode, AssetBuildNode, AssetPublishNode } from './work-graph-types';
+import { IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { debug, trace } from '../../cli/messages';
-import { IoMessaging } from '../../toolkit/cli-io-host';
 import { ToolkitError } from '../../toolkit/error';
 import { parallelPromises } from '../../util';
 
 export type Concurrency = number | Record<WorkNode['type'], number>;
 
-export interface WorkGraphProps {
-  ioHost: IoMessaging['ioHost'];
-  action: IoMessaging['action'];
-}
-
 export class WorkGraph {
   public readonly nodes: Record<string, WorkNode>;
   private readonly readyPool: Array<WorkNode> = [];
   private readonly lazyDependencies = new Map<string, string[]>();
-  private readonly ioHost: IoMessaging['ioHost'];
-  private readonly action: IoMessaging['action'];
+  private readonly ioHelper: IoHelper;
 
   public error?: Error;
 
-  public constructor(nodes: Record<string, WorkNode>, props: WorkGraphProps) {
+  public constructor(nodes: Record<string, WorkNode>, ioHelper: IoHelper) {
     this.nodes = { ...nodes };
-
-    this.ioHost = props.ioHost;
-    this.action = props.action;
+    this.ioHelper = ioHelper;
   }
 
   public addNodes(...nodes: WorkNode[]) {
@@ -266,7 +258,7 @@ export class WorkGraph {
    * Do this in parallel, because there may be a lot of assets in an application (seen in practice: >100 assets)
    */
   public async removeUnnecessaryAssets(isUnnecessary: (x: AssetPublishNode) => Promise<boolean>) {
-    await this.ioHost.notify(debug(this.action, 'Checking for previously published assets'));
+    await this.ioHelper.notify(debug('Checking for previously published assets'));
 
     const publishes = this.nodesOfType('asset-publish');
 
@@ -279,7 +271,7 @@ export class WorkGraph {
       this.removeNode(assetNode);
     }
 
-    await this.ioHost.notify(debug(this.action, `${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));
+    await this.ioHelper.notify(debug(`${publishes.length} total assets, ${publishes.length - alreadyPublished.length} still need to be published`));
 
     // Now also remove any asset build steps that don't have any dependencies on them anymore
     const unusedBuilds = this.nodesOfType('asset-build').filter(build => this.dependees(build).length === 0);
@@ -310,7 +302,7 @@ export class WorkGraph {
 
     if (this.readyPool.length === 0 && activeCount === 0 && pendingCount > 0) {
       const cycle = this.findCycle() ?? ['No cycle found!'];
-      await this.ioHost.notify(trace(this.action, `Cycle ${cycle.join(' -> ')} in graph ${this}`));
+      await this.ioHelper.notify(trace(`Cycle ${cycle.join(' -> ')} in graph ${this}`));
       throw new ToolkitError(`Unable to make progress anymore, dependency cycle between remaining artifacts: ${cycle.join(' -> ')} (run with -vv for full graph)`);
     }
   }
diff --git a/packages/aws-cdk/lib/cli/cdk-toolkit.ts b/packages/aws-cdk/lib/cli/cdk-toolkit.ts
index dce213b3f..aa9a37725 100644
--- a/packages/aws-cdk/lib/cli/cdk-toolkit.ts
+++ b/packages/aws-cdk/lib/cli/cdk-toolkit.ts
@@ -7,6 +7,7 @@ import * as fs from 'fs-extra';
 import * as promptly from 'promptly';
 import * as uuid from 'uuid';
 import { Configuration, PROJECT_CONFIG } from './user-configuration';
+import { asIoHelper } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { DEFAULT_TOOLKIT_STACK_NAME } from '../api';
 import { SdkProvider } from '../api/aws-auth';
 import { Bootstrapper, BootstrapEnvironmentOptions } from '../api/bootstrap';
@@ -203,8 +204,7 @@ export class CdkToolkit {
 
         const migrator = new ResourceMigrator({
           deployments: this.props.deployments,
-          ioHost: this.ioHost,
-          action: 'diff',
+          ioHelper: asIoHelper(this.ioHost, 'diff'),
         });
         const resourcesToImport = await migrator.tryGetResources(await this.props.deployments.resolveEnvironment(stack));
         if (resourcesToImport) {
@@ -232,7 +232,7 @@ export class CdkToolkit {
           }
 
           if (stackExists) {
-            changeSet = await createDiffChangeSet({ ioHost: this.ioHost, action: 'diff' }, {
+            changeSet = await createDiffChangeSet(asIoHelper(this.ioHost, 'diff'), {
               stack,
               uuid: uuid.v4(),
               deployments: this.props.deployments,
@@ -304,8 +304,7 @@ export class CdkToolkit {
 
     const migrator = new ResourceMigrator({
       deployments: this.props.deployments,
-      ioHost: this.ioHost,
-      action: 'deploy',
+      ioHelper: asIoHelper(this.ioHost, 'deploy'),
     });
     await migrator.tryMigrateResources(stackCollection, {
       toolkitStackName: this.toolkitStackName,
@@ -544,7 +543,7 @@ export class CdkToolkit {
         );
       } finally {
         if (options.cloudWatchLogMonitor) {
-          const foundLogGroupsResult = await findCloudWatchLogGroups(this.props.sdkProvider, { ioHost: this.ioHost, action: 'deploy' }, stack);
+          const foundLogGroupsResult = await findCloudWatchLogGroups(this.props.sdkProvider, asIoHelper(this.ioHost, 'deploy'), stack);
           options.cloudWatchLogMonitor.addLogGroups(
             foundLogGroupsResult.env,
             foundLogGroupsResult.sdk,
@@ -582,10 +581,10 @@ export class CdkToolkit {
       stack,
       ...stack.dependencies.filter(x => cxapi.AssetManifestArtifact.isAssetManifestArtifact(x)),
     ]);
-    const workGraph = new WorkGraphBuilder({
-      ioHost: this.ioHost,
-      action: 'deploy',
-    }, prebuildAssets).build(stacksAndTheirAssetManifests);
+    const workGraph = new WorkGraphBuilder(
+      asIoHelper(this.ioHost, 'deploy'),
+      prebuildAssets,
+    ).build(stacksAndTheirAssetManifests);
 
     // Unless we are running with '--force', skip already published assets
     if (!options.force) {
@@ -767,8 +766,7 @@ export class CdkToolkit {
 
     const resourceImporter = new ResourceImporter(stack, {
       deployments: this.props.deployments,
-      ioHost: this.ioHost,
-      action: 'import',
+      ioHelper: asIoHelper(this.ioHost, 'import'),
     });
     const { additions, hasNonAdditions } = await resourceImporter.discoverImportableResources(options.force);
     if (additions.length === 0) {
@@ -961,7 +959,7 @@ export class CdkToolkit {
     userEnvironmentSpecs: string[],
     options: BootstrapEnvironmentOptions,
   ): Promise<void> {
-    const bootstrapper = new Bootstrapper(options.source, { ioHost: this.ioHost, action: 'bootstrap' });
+    const bootstrapper = new Bootstrapper(options.source, asIoHelper(this.ioHost, 'bootstrap'));
     // If there is an '--app' argument and an environment looks like a glob, we
     // select the environments from the app. Otherwise, use what the user said.
 
@@ -996,10 +994,7 @@ export class CdkToolkit {
       success(' ⏳  Garbage Collecting environment %s...', chalk.blue(environment.name));
       const gc = new GarbageCollector({
         sdkProvider: this.props.sdkProvider,
-        msg: {
-          ioHost: this.ioHost,
-          action: 'gc',
-        },
+        ioHelper: asIoHelper(this.ioHost, 'gc'),
         resolvedEnvironment: environment,
         bootstrapStackName: options.bootstrapStackName,
         rollbackBufferDays: options.rollbackBufferDays,
diff --git a/packages/aws-cdk/lib/cli/cli.ts b/packages/aws-cdk/lib/cli/cli.ts
index a29934858..cbad4687f 100644
--- a/packages/aws-cdk/lib/cli/cli.ts
+++ b/packages/aws-cdk/lib/cli/cli.ts
@@ -5,6 +5,7 @@ import { parseCommandLineArguments } from './parse-command-line-arguments';
 import { checkForPlatformWarnings } from './platform-warnings';
 
 import * as version from './version';
+import { asIoHelper } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { SdkProvider } from '../api/aws-auth';
 import { SdkToCliLogger } from '../api/aws-auth/sdk-logger';
 import { setSdkTracing } from '../api/aws-auth/tracing';
@@ -107,7 +108,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
       proxyAddress: argv.proxy,
       caBundlePath: argv['ca-bundle-path'],
     },
-    logger: new SdkToCliLogger(ioHost),
+    logger: new SdkToCliLogger(asIoHelper(ioHost, ioHost.currentAction as any)),
   });
 
   let outDirLock: ILock | undefined;
@@ -185,8 +186,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
     const cloudFormation = new Deployments({
       sdkProvider,
       toolkitStackName,
-      ioHost,
-      action: ioHost.currentAction,
+      ioHelper: asIoHelper(ioHost, ioHost.currentAction as any),
     });
 
     if (args.all && args.STACKS) {
@@ -265,7 +265,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
         const source: BootstrapSource = determineBootstrapVersion(args);
 
         if (args.showTemplate) {
-          const bootstrapper = new Bootstrapper(source, { ioHost: ioHost, action: ioHost.currentAction });
+          const bootstrapper = new Bootstrapper(source, asIoHelper(ioHost, ioHost.currentAction));
           return bootstrapper.showTemplate(args.json);
         }
 
diff --git a/packages/aws-cdk/lib/cli/messages.ts b/packages/aws-cdk/lib/cli/messages.ts
index d86ddfbc5..76c4d8c0d 100644
--- a/packages/aws-cdk/lib/cli/messages.ts
+++ b/packages/aws-cdk/lib/cli/messages.ts
@@ -2,22 +2,22 @@
 // The CLI cannot depend on the toolkit yet, because the toolkit currently depends on the CLI.
 // Once we have complete the repo split, we will create a temporary, private library package
 // for all code that is shared between CLI and toolkit. This is where this file will then live.
+import { ActionLessMessage } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import type { IoMessageCodeCategory } from '../logging';
-import type { IoMessage, IoMessageCode, IoMessageLevel, IoMessaging } from '../toolkit/cli-io-host';
+import type { IoMessageCode, IoMessageLevel } from '../toolkit/cli-io-host';
 
 type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
-type SimplifiedMessage<T> = Omit<IoMessage<T>, 'time' | 'action'> & { action: IoMessaging['action'] };
+type SimplifiedMessage<T> = Omit<ActionLessMessage<T>, 'time'>;
 
 /**
  * Internal helper that processes log inputs into a consistent format.
  * Handles string interpolation, format strings, and object parameter styles.
  * Applies optional styling and prepares the final message for logging.
  */
-export function formatMessage<T>(msg: Optional<SimplifiedMessage<T>, 'code'>, category: IoMessageCodeCategory = 'TOOLKIT'): IoMessage<T> {
+export function formatMessage<T>(msg: Optional<SimplifiedMessage<T>, 'code'>, category: IoMessageCodeCategory = 'TOOLKIT'): ActionLessMessage<T> {
   return {
     time: new Date(),
     level: msg.level,
-    action: msg.action as any,
     code: msg.code ?? defaultMessageCode(msg.level, category),
     message: msg.message,
     data: msg.data,
@@ -39,10 +39,9 @@ function defaultMessageCode(level: IoMessageLevel, category: IoMessageCodeCatego
  * Creates an error level message.
  * Errors must always have a unique code.
  */
-export const error = <T>(action: IoMessaging['action'], message: string, code: IoMessageCode, payload?: T) => {
+export const error = <T>(message: string, code: IoMessageCode, payload?: T) => {
   return formatMessage({
     level: 'error',
-    action,
     code,
     message,
     data: payload,
@@ -56,10 +55,9 @@ export const error = <T>(action: IoMessaging['action'], message: string, code: I
  * However actions that operate on Cloud Assemblies might include a result per Stack.
  * Unlike other messages, results must always have a code and a payload.
  */
-export const result = <T>(action: IoMessaging['action'], message: string, code: IoMessageCode, payload: T) => {
+export const result = <T>(message: string, code: IoMessageCode, payload: T) => {
   return formatMessage({
     level: 'result',
-    action,
     code,
     message,
     data: payload,
@@ -69,10 +67,9 @@ export const result = <T>(action: IoMessaging['action'], message: string, code:
 /**
  * Creates a warning level message.
  */
-export const warn = <T>(action: IoMessaging['action'], message: string, code?: IoMessageCode, payload?: T) => {
+export const warn = <T>(message: string, code?: IoMessageCode, payload?: T) => {
   return formatMessage({
     level: 'warn',
-    action,
     code,
     message,
     data: payload,
@@ -82,10 +79,9 @@ export const warn = <T>(action: IoMessaging['action'], message: string, code?: I
 /**
  * Creates an info level message.
  */
-export const info = <T>(action: IoMessaging['action'], message: string, code?: IoMessageCode, payload?: T) => {
+export const info = <T>(message: string, code?: IoMessageCode, payload?: T) => {
   return formatMessage({
     level: 'info',
-    action,
     code,
     message,
     data: payload,
@@ -95,10 +91,9 @@ export const info = <T>(action: IoMessaging['action'], message: string, code?: I
 /**
  * Creates a debug level message.
  */
-export const debug = <T>(action: IoMessaging['action'], message: string, code?: IoMessageCode, payload?: T) => {
+export const debug = <T>(message: string, code?: IoMessageCode, payload?: T) => {
   return formatMessage({
     level: 'debug',
-    action,
     code,
     message,
     data: payload,
@@ -108,10 +103,9 @@ export const debug = <T>(action: IoMessaging['action'], message: string, code?:
 /**
  * Creates a trace level message.
  */
-export const trace = <T>(action: IoMessaging['action'], message: string, code?: IoMessageCode, payload?: T) => {
+export const trace = <T>(message: string, code?: IoMessageCode, payload?: T) => {
   return formatMessage({
     level: 'trace',
-    action,
     code,
     message,
     data: payload,
diff --git a/packages/aws-cdk/lib/toolkit/cli-io-host.ts b/packages/aws-cdk/lib/toolkit/cli-io-host.ts
index e3c0efa7c..70bb05be2 100644
--- a/packages/aws-cdk/lib/toolkit/cli-io-host.ts
+++ b/packages/aws-cdk/lib/toolkit/cli-io-host.ts
@@ -19,14 +19,6 @@ type CliAction =
 | 'version'
 | 'none';
 
-/**
- * Temporary helper to group required props for IoMessages
- */
-export interface IoMessaging {
-  ioHost: IIoHost;
-  action: CliAction;
-}
-
 export interface CliIoHostProps {
   /**
    * The initial Toolkit action the hosts starts with.
diff --git a/packages/aws-cdk/test/_helpers/test-io-host.ts b/packages/aws-cdk/test/_helpers/test-io-host.ts
new file mode 100644
index 000000000..1d173c4e8
--- /dev/null
+++ b/packages/aws-cdk/test/_helpers/test-io-host.ts
@@ -0,0 +1,30 @@
+import { IIoHost, IoMessage, IoMessageLevel, IoRequest } from "../../../@aws-cdk/tmp-toolkit-helpers/src/api/io";
+import { isMessageRelevantForLevel } from "../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private";
+
+/**
+ * A test implementation of IIoHost that does nothing but can by spied on.
+ * Optionally set a level to filter out all irrelevant messages.
+ * Optionally set a approval level.
+ */
+export class TestIoHost implements IIoHost {
+  public readonly notifySpy: jest.Mock<any, any, any>;
+  public readonly requestSpy: jest.Mock<any, any, any>;
+
+  constructor(public level: IoMessageLevel = 'info') {
+    this.notifySpy = jest.fn();
+    this.requestSpy = jest.fn();
+  }
+
+  public async notify<T>(msg: IoMessage<T>): Promise<void> {
+    if (isMessageRelevantForLevel(msg, this.level)) {
+      this.notifySpy(msg);
+    }
+  }
+
+  public async requestResponse<T, U>(msg: IoRequest<T, U>): Promise<U> {
+    if (isMessageRelevantForLevel(msg, this.level)) {
+      this.requestSpy(msg);
+    }
+    return msg.defaultResponse;
+  }
+}
diff --git a/packages/aws-cdk/test/api/_helpers/hotswap-test-setup.ts b/packages/aws-cdk/test/api/_helpers/hotswap-test-setup.ts
index 5ea31c57d..bfb68d674 100644
--- a/packages/aws-cdk/test/api/_helpers/hotswap-test-setup.ts
+++ b/packages/aws-cdk/test/api/_helpers/hotswap-test-setup.ts
@@ -5,7 +5,6 @@ import { ICloudFormationClient, SuccessfulDeployStackResult } from '../../../lib
 import { CloudFormationStack, Template } from '../../../lib/api/deployments';
 import * as deployments from '../../../lib/api/deployments/hotswap-deployments';
 import { HotswapMode, HotswapPropertyOverrides } from '../../../lib/api/hotswap/common';
-import { CliIoHost, IoMessaging } from '../../../lib/toolkit/cli-io-host';
 import { testStack, TestStackArtifact } from '../../util';
 import {
   mockCloudFormationClient,
@@ -15,6 +14,8 @@ import {
   setDefaultSTSMocks,
 } from '../../util/mock-sdk';
 import { FakeCloudformationStack } from './fake-cloudformation-stack';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 const STACK_NAME = 'withouterrors';
 export const STACK_ID = 'stackId';
@@ -24,11 +25,7 @@ let currentCfnStack: FakeCloudformationStack;
 const currentCfnStackResources: StackResourceSummary[] = [];
 let stackTemplates: { [stackName: string]: any };
 let currentNestedCfnStackResources: { [stackName: string]: StackResourceSummary[] };
-
-let mockMsg: IoMessaging = {
-  ioHost: CliIoHost.instance(),
-  action: 'deploy',
-};
+let ioHost = new TestIoHost();
 
 export function setupHotswapTests(): HotswapMockSdkProvider {
   restoreSdkMocksToDefault();
@@ -149,6 +146,6 @@ export class HotswapMockSdkProvider extends MockSdkProvider {
     hotswapPropertyOverrides?: HotswapPropertyOverrides,
   ): Promise<SuccessfulDeployStackResult | undefined> {
     let hotswapProps = hotswapPropertyOverrides || new HotswapPropertyOverrides();
-    return deployments.tryHotswapDeployment(this, mockMsg, assetParams, currentCfnStack, stackArtifact, hotswapMode, hotswapProps);
+    return deployments.tryHotswapDeployment(this, asIoHelper(ioHost, 'deploy'), assetParams, currentCfnStack, stackArtifact, hotswapMode, hotswapProps);
   }
 }
diff --git a/packages/aws-cdk/test/api/bootstrap/bootstrap.test.ts b/packages/aws-cdk/test/api/bootstrap/bootstrap.test.ts
index b8c49505f..8ca91e524 100644
--- a/packages/aws-cdk/test/api/bootstrap/bootstrap.test.ts
+++ b/packages/aws-cdk/test/api/bootstrap/bootstrap.test.ts
@@ -13,8 +13,9 @@ import { parse } from 'yaml';
 import { Bootstrapper } from '../../../lib/api/bootstrap';
 import { legacyBootstrapTemplate } from '../../../lib/api/bootstrap/legacy-template';
 import { deserializeStructure, serializeStructure, toYAML } from '../../../lib/util';
-import { CliIoHost } from '../../../lib/toolkit/cli-io-host';
 import { MockSdkProvider, mockCloudFormationClient, restoreSdkMocksToDefault } from '../../util/mock-sdk';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 const env = {
   account: '123456789012',
@@ -31,9 +32,12 @@ jest.mock('../../../lib/api/deployments/checks', () => ({
 let sdk: MockSdkProvider;
 let changeSetTemplate: any | undefined;
 let bootstrapper: Bootstrapper;
+let ioHost = new TestIoHost();
+let ioHelper = asIoHelper(ioHost, 'bootstrap');
+
 beforeEach(() => {
   sdk = new MockSdkProvider();
-  bootstrapper = new Bootstrapper({ source: 'legacy' }, { ioHost: CliIoHost.instance(), action: 'bootstrap' });
+  bootstrapper = new Bootstrapper({ source: 'legacy' }, ioHelper);
   mockCloudFormationClient.reset();
   restoreSdkMocksToDefault();
   // First two calls, no stacks exist (first is for version checking, second is in deploy-stack.ts)
diff --git a/packages/aws-cdk/test/api/bootstrap/bootstrap2.test.ts b/packages/aws-cdk/test/api/bootstrap/bootstrap2.test.ts
index 723319370..572a31015 100644
--- a/packages/aws-cdk/test/api/bootstrap/bootstrap2.test.ts
+++ b/packages/aws-cdk/test/api/bootstrap/bootstrap2.test.ts
@@ -10,16 +10,28 @@ import {
   MockSdkProvider,
   restoreSdkMocksToDefault, setDefaultSTSMocks,
 } from '../../util/mock-sdk';
-import { CliIoHost } from '../../../lib/toolkit/cli-io-host';
+import { IIoHost } from '../../../lib/toolkit/cli-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 const mockDeployStack = jest.spyOn(deployStack, 'deployStack');
 
 let bootstrapper: Bootstrapper;
 let stderrMock: jest.SpyInstance;
+let ioHost: IIoHost = {
+  notify: jest.fn().mockImplementation((msg) => {
+    process.stderr.write(msg.message + '\n');
+  }),
+  requestResponse: jest.fn().mockImplementation((msg) => {
+    process.stderr.write(msg.message + '\n');
+    return msg.defaultResponses
+  }),
+};
+let ioHelper = asIoHelper(ioHost, 'bootstrap');
 
 beforeEach(() => {
-  CliIoHost.instance().isCI = false;
-  bootstrapper = new Bootstrapper({ source: 'default' }, { ioHost: CliIoHost.instance(), action: 'bootstrap' });
+  jest.mocked(ioHost.notify).mockClear();
+  jest.mocked(ioHost.requestResponse).mockClear();
+  bootstrapper = new Bootstrapper({ source: 'default' }, ioHelper);
   stderrMock = jest.spyOn(process.stderr, 'write').mockImplementation(() => {
     return true;
   });
diff --git a/packages/aws-cdk/test/api/deployments/assets.test.ts b/packages/aws-cdk/test/api/deployments/assets.test.ts
index 23765f31a..77ebf8ecc 100644
--- a/packages/aws-cdk/test/api/deployments/assets.test.ts
+++ b/packages/aws-cdk/test/api/deployments/assets.test.ts
@@ -6,20 +6,25 @@ import { AssetManifestBuilder } from '../../../lib/api/deployments';
 import { EnvironmentResources, EnvironmentResourcesRegistry } from '../../../lib/api/environment';
 import { MockSdk } from '../../util/mock-sdk';
 import { MockToolkitInfo } from '../../util/mock-toolkitinfo';
-import { CliIoHost, IoMessaging } from '../../../lib/toolkit/cli-io-host';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 let assets: AssetManifestBuilder;
 let envRegistry: EnvironmentResourcesRegistry;
 let envResources: EnvironmentResources;
 let toolkitMock: ReturnType<typeof MockToolkitInfo.setup>;
-let mockMsg: IoMessaging = { ioHost: CliIoHost.instance(), action: 'deploy' };
+let ioHost = new TestIoHost();
+let ioHelper = asIoHelper(ioHost, 'deploy');
 
 beforeEach(() => {
+  ioHost.notifySpy.mockClear();
+  ioHost.requestSpy.mockClear();
+
   assets = new AssetManifestBuilder();
   envRegistry = new EnvironmentResourcesRegistry();
 
   const sdk = new MockSdk();
-  envResources = envRegistry.for({ account: '11111111', region: 'us-nowhere', name: 'aws://11111111/us-nowhere' }, sdk, mockMsg);
+  envResources = envRegistry.for({ account: '11111111', region: 'us-nowhere', name: 'aws://11111111/us-nowhere' }, sdk, ioHelper);
   toolkitMock = MockToolkitInfo.setup();
 });
 
@@ -44,7 +49,7 @@ describe('file assets', () => {
     ]);
 
     // WHEN
-    const params = await addMetadataAssetsToManifest(mockMsg, stack, assets, envResources);
+    const params = await addMetadataAssetsToManifest(ioHelper, stack, assets, envResources);
 
     // THEN
     expect(params).toEqual({
@@ -83,7 +88,7 @@ describe('file assets', () => {
     ]);
 
     // WHEN
-    await addMetadataAssetsToManifest(mockMsg, stack, assets, envResources);
+    await addMetadataAssetsToManifest(ioHelper, stack, assets, envResources);
 
     // THEN
     expect(assets.toManifest('.').entries).toEqual([
@@ -111,7 +116,7 @@ describe('file assets', () => {
     ]);
 
     // WHEN
-    const params = await addMetadataAssetsToManifest(mockMsg, stack, assets, envResources, ['SomeStackSomeResource4567']);
+    const params = await addMetadataAssetsToManifest(ioHelper, stack, assets, envResources, ['SomeStackSomeResource4567']);
 
     // THEN
     expect(params).toEqual({
@@ -137,7 +142,7 @@ describe('docker assets', () => {
       mockFn(envResources.prepareEcrRepository).mockResolvedValue({ repositoryUri: 'docker.uri' });
 
       // WHEN
-      const params = await addMetadataAssetsToManifest(mockMsg, stack, assets, envResources);
+      const params = await addMetadataAssetsToManifest(ioHelper, stack, assets, envResources);
 
       // THEN
       expect(envResources.prepareEcrRepository).toHaveBeenCalledWith('cdk/stack-construct-abc123');
@@ -170,7 +175,7 @@ describe('docker assets', () => {
       },
     ]);
 
-    await expect(addMetadataAssetsToManifest(mockMsg, stack, assets, envResources)).rejects.toThrow('Invalid Docker image asset');
+    await expect(addMetadataAssetsToManifest(ioHelper, stack, assets, envResources)).rejects.toThrow('Invalid Docker image asset');
   });
 
   test('no parameter and repo/tag name (new)', async () => {
@@ -189,7 +194,7 @@ describe('docker assets', () => {
       mockFn(envResources.prepareEcrRepository).mockResolvedValue({ repositoryUri: 'docker.uri' });
 
       // WHEN
-      const params = await addMetadataAssetsToManifest(mockMsg, stack, assets, envResources);
+      const params = await addMetadataAssetsToManifest(ioHelper, stack, assets, envResources);
 
       // THEN
       expect(envResources.prepareEcrRepository).toHaveBeenCalledWith('reponame');
@@ -222,7 +227,7 @@ describe('docker assets', () => {
     ]);
 
     // WHEN
-    const params = await addMetadataAssetsToManifest(mockMsg, stack, assets, envResources, ['SomeStackSomeResource4567']);
+    const params = await addMetadataAssetsToManifest(ioHelper, stack, assets, envResources, ['SomeStackSomeResource4567']);
 
     // THEN
     expect(params).toEqual({
diff --git a/packages/aws-cdk/test/api/deployments/checks.test.ts b/packages/aws-cdk/test/api/deployments/checks.test.ts
index cb4c90434..af6fce0a3 100644
--- a/packages/aws-cdk/test/api/deployments/checks.test.ts
+++ b/packages/aws-cdk/test/api/deployments/checks.test.ts
@@ -1,12 +1,10 @@
 import { DescribeStacksCommand, StackStatus } from '@aws-sdk/client-cloudformation';
 import { determineAllowCrossAccountAssetPublishing, getBootstrapStackInfo } from '../../../lib/api/deployments/checks';
-import { CliIoHost, IoMessaging } from '../../../lib/toolkit/cli-io-host';
 import { mockCloudFormationClient, MockSdk } from '../../util/mock-sdk';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
-let mockMsg: IoMessaging = {
-  ioHost: CliIoHost.instance(),
-  action: 'deploy',
-};
+let ioHelper = asIoHelper(new TestIoHost(), 'deploy');
 
 describe('determineAllowCrossAccountAssetPublishing', () => {
   it('should return true when hasStagingBucket is false', async () => {
@@ -20,7 +18,7 @@ describe('determineAllowCrossAccountAssetPublishing', () => {
       }],
     });
 
-    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, mockMsg);
+    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, ioHelper);
     expect(result).toBe(true);
   });
 
@@ -38,7 +36,7 @@ describe('determineAllowCrossAccountAssetPublishing', () => {
       }],
     });
 
-    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, mockMsg);
+    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, ioHelper);
     expect(result).toBe(true);
   });
 
@@ -57,7 +55,7 @@ describe('determineAllowCrossAccountAssetPublishing', () => {
       }],
     });
 
-    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, mockMsg);
+    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, ioHelper);
     expect(result).toBe(true);
   });
 
@@ -65,7 +63,7 @@ describe('determineAllowCrossAccountAssetPublishing', () => {
     const mockSDK = new MockSdk();
     mockCloudFormationClient.on(DescribeStacksCommand).rejects(new Error('Could not read bootstrap stack'));
 
-    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, mockMsg);
+    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, ioHelper);
     expect(result).toBe(true);
   });
 
@@ -73,7 +71,7 @@ describe('determineAllowCrossAccountAssetPublishing', () => {
     const mockSDK = new MockSdk();
     mockCloudFormationClient.on(DescribeStacksCommand).rejects(new Error('Could not read bootstrap stack'));
 
-    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, mockMsg);
+    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, ioHelper);
     expect(result).toBe(true);
   });
 
@@ -91,7 +89,7 @@ describe('determineAllowCrossAccountAssetPublishing', () => {
       }],
     });
 
-    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, mockMsg);
+    const result = await determineAllowCrossAccountAssetPublishing(mockSDK, ioHelper);
     expect(result).toBe(false);
   });
 });
diff --git a/packages/aws-cdk/test/api/deployments/cloudformation-deployments.test.ts b/packages/aws-cdk/test/api/deployments/cloudformation-deployments.test.ts
index 4043a7163..943055aa0 100644
--- a/packages/aws-cdk/test/api/deployments/cloudformation-deployments.test.ts
+++ b/packages/aws-cdk/test/api/deployments/cloudformation-deployments.test.ts
@@ -16,7 +16,6 @@ import { CloudFormationStack, createChangeSet, Deployments } from '../../../lib/
 import { deployStack } from '../../../lib/api/deployments/deploy-stack';
 import { HotswapMode } from '../../../lib/api/hotswap/common';
 import { ToolkitInfo } from '../../../lib/api/toolkit-info';
-import { CliIoHost } from '../../../lib/toolkit/cli-io-host';
 import { testStack } from '../../util';
 import {
   mockBootstrapStack,
@@ -28,6 +27,8 @@ import {
   setDefaultSTSMocks,
 } from '../../util/mock-sdk';
 import { FakeCloudformationStack } from '../_helpers/fake-cloudformation-stack';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 jest.mock('../../../lib/api/deployments/deploy-stack');
 jest.mock('../../../lib/api/deployments/asset-publishing');
@@ -37,11 +38,16 @@ let sdk: MockSdk;
 let deployments: Deployments;
 let mockToolkitInfoLookup: jest.Mock;
 let currentCfnStackResources: { [key: string]: StackResourceSummary[] };
+let ioHost = new TestIoHost();
+let ioHelper = asIoHelper(ioHost, 'deploy');
+
 beforeEach(() => {
   jest.resetAllMocks();
   sdkProvider = new MockSdkProvider();
   sdk = new MockSdk();
-  deployments = new Deployments({ sdkProvider, ioHost: CliIoHost.instance(), action: 'deploy' });
+  ioHost.notifySpy.mockClear();
+  ioHost.requestSpy.mockClear();
+  deployments = new Deployments({ sdkProvider, ioHelper });
 
   currentCfnStackResources = {};
   restoreSdkMocksToDefault();
@@ -1151,7 +1157,7 @@ test('tags are passed along to create change set', async () => {
   }
 
   await createChangeSet(
-    { ioHost: CliIoHost.instance(), action: 'deploy' },
+    ioHelper,
     {
       stack: stack,
       cfn: new MockSdk().cloudFormation(),
diff --git a/packages/aws-cdk/test/api/deployments/deploy-stack.test.ts b/packages/aws-cdk/test/api/deployments/deploy-stack.test.ts
index b90b6d929..2478a353c 100644
--- a/packages/aws-cdk/test/api/deployments/deploy-stack.test.ts
+++ b/packages/aws-cdk/test/api/deployments/deploy-stack.test.ts
@@ -21,7 +21,6 @@ import { deployStack, DeployStackOptions } from '../../../lib/api/deployments/de
 import { tryHotswapDeployment } from '../../../lib/api/deployments/hotswap-deployments';
 import { NoBootstrapStackEnvironmentResources } from '../../../lib/api/environment';
 import { HotswapMode } from '../../../lib/api/hotswap/common';
-import { CliIoHost, IoMessaging } from '../../../lib/toolkit/cli-io-host';
 import { DEFAULT_FAKE_TEMPLATE, testStack } from '../../util';
 import {
   mockCloudFormationClient,
@@ -30,11 +29,14 @@ import {
   MockSdkProvider,
   restoreSdkMocksToDefault,
 } from '../../util/mock-sdk';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
-const mockMsg: IoMessaging = { ioHost: CliIoHost.instance(), action: 'deploy' };
+let ioHost = new TestIoHost();
+let ioHelper = asIoHelper(ioHost, 'deploy');
 
 function testDeployStack(options: DeployStackOptions) {
-  return deployStack(options, mockMsg);
+  return deployStack(options, ioHelper);
 }
 
 jest.mock('../../../lib/api/deployments/hotswap-deployments');
@@ -118,7 +120,7 @@ function standardDeployStackArguments(): DeployStackOptions {
     sdk,
     sdkProvider,
     resolvedEnvironment,
-    envResources: new NoBootstrapStackEnvironmentResources(resolvedEnvironment, sdk, mockMsg),
+    envResources: new NoBootstrapStackEnvironmentResources(resolvedEnvironment, sdk, ioHelper),
   };
 }
 
@@ -391,35 +393,6 @@ test('reuse previous parameters if requested', async () => {
   } as CreateChangeSetCommandInput);
 });
 
-describe('ci=true', () => {
-  let stderrMock: jest.SpyInstance;
-  let stdoutMock: jest.SpyInstance;
-  beforeEach(() => {
-    CliIoHost.instance().isCI = true;
-    jest.resetAllMocks();
-    stderrMock = jest.spyOn(process.stderr, 'write').mockImplementation(() => {
-      return true;
-    });
-    stdoutMock = jest.spyOn(process.stdout, 'write').mockImplementation(() => {
-      return true;
-    });
-  });
-  afterEach(() => {
-    CliIoHost.instance().isCI = false;
-  });
-  test('output written to stdout', async () => {
-    // GIVEN
-
-    await testDeployStack({
-      ...standardDeployStackArguments(),
-    });
-
-    // THEN
-    expect(stderrMock.mock.calls).toEqual([]);
-    expect(stdoutMock.mock.calls).not.toEqual([]);
-  });
-});
-
 test('do not reuse previous parameters if not requested', async () => {
   // GIVEN
   mockCloudFormationClient.on(DescribeStacksCommand).resolves({
@@ -759,7 +732,7 @@ test('deploy not skipped if template did not change but tags changed', async ()
         Value: 'NewValue',
       },
     ],
-    envResources: new NoBootstrapStackEnvironmentResources(resolvedEnvironment, sdk, mockMsg),
+    envResources: new NoBootstrapStackEnvironmentResources(resolvedEnvironment, sdk, ioHelper),
   });
 
   // THEN
diff --git a/packages/aws-cdk/test/api/environment/environment-resources.test.ts b/packages/aws-cdk/test/api/environment/environment-resources.test.ts
index 6a9e4207f..b46f1ea11 100644
--- a/packages/aws-cdk/test/api/environment/environment-resources.test.ts
+++ b/packages/aws-cdk/test/api/environment/environment-resources.test.ts
@@ -4,14 +4,17 @@ import { Context } from '../../../lib/api/context';
 import { EnvironmentResourcesRegistry } from '../../../lib/api/environment';
 import * as version from '../../../lib/cli/version';
 import { CachedDataSource, Notices, NoticesFilter } from '../../../lib/notices';
-import { CliIoHost, IoMessaging } from '../../../lib/toolkit/cli-io-host';
 import { MockSdk, mockBootstrapStack, mockSSMClient } from '../../util/mock-sdk';
 import { MockToolkitInfo } from '../../util/mock-toolkitinfo';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 let mockSdk: MockSdk;
 let envRegistry: EnvironmentResourcesRegistry;
 let toolkitMock: ReturnType<typeof MockToolkitInfo.setup>;
-let mockMsg: IoMessaging = { ioHost: CliIoHost.instance(), action: 'deploy' };
+
+let ioHost = new TestIoHost();
+let ioHelper = asIoHelper(ioHost, 'deploy');
 
 beforeEach(() => {
   mockSdk = new MockSdk();
@@ -35,7 +38,7 @@ function envResources() {
       name: 'aws://11111111/us-nowhere',
     },
     mockSdk,
-    mockMsg,
+    ioHelper,
   );
 }
 
diff --git a/packages/aws-cdk/test/api/garbage-collection/garbage-collection.test.ts b/packages/aws-cdk/test/api/garbage-collection/garbage-collection.test.ts
index 1315721b4..1de27b4b7 100644
--- a/packages/aws-cdk/test/api/garbage-collection/garbage-collection.test.ts
+++ b/packages/aws-cdk/test/api/garbage-collection/garbage-collection.test.ts
@@ -21,6 +21,7 @@ import {
   BackgroundStackRefreshProps,
 } from '../../../lib/api/garbage-collection/stack-refresh';
 import { ProgressPrinter } from '../../../lib/api/garbage-collection/progress-printer';
+import { TestIoHost } from '../../_helpers/test-io-host';
 import {
   BatchDeleteImageCommand,
   BatchGetImageCommand,
@@ -28,7 +29,7 @@ import {
   ListImagesCommand,
   PutImageCommand,
 } from '@aws-sdk/client-ecr';
-import { CliIoHost } from '../../../lib/toolkit/cli-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 let garbageCollector: GarbageCollector;
 
@@ -36,10 +37,14 @@ let stderrMock: jest.SpyInstance;
 const cfnClient = mockCloudFormationClient;
 const s3Client = mockS3Client;
 const ecrClient = mockECRClient;
+const ioHost = new TestIoHost();
 
 const DAY = 24 * 60 * 60 * 1000; // Number of milliseconds in a day
 
 beforeEach(() => {
+  ioHost.notifySpy.mockClear();
+  ioHost.requestSpy.mockClear();
+
   // By default, we'll return a non-found toolkit info
   jest.spyOn(ToolkitInfo, 'lookup').mockResolvedValue(ToolkitInfo.bootstrapStackNotFoundInfo('GarbageStack'));
 
@@ -69,10 +74,7 @@ function gc(props: {
 }): GarbageCollector {
   return new GarbageCollector({
     sdkProvider: new MockSdkProvider(),
-    msg: {
-      ioHost: CliIoHost.instance(),
-      action: 'gc',
-    },
+    ioHelper: asIoHelper(ioHost, 'gc'),
     action: props.action,
     resolvedEnvironment: {
       account: '123456789012',
@@ -891,7 +893,7 @@ describe('Garbage Collection with large # of objects', () => {
 
     // add every 5th asset hash to the mock template body: 8000 assets are isolated
     const mockTemplateBody = [];
-    for (let i = 0; i < keyCount; i+=5) {
+    for (let i = 0; i < keyCount; i += 5) {
       mockTemplateBody.push(`asset${i}hash`);
     }
     cfnClient.on(GetTemplateCommand).resolves({
@@ -934,10 +936,7 @@ describe('BackgroundStackRefresh', () => {
 
     refreshProps = {
       cfn: foo.cloudFormation(),
-      msg: {
-        ioHost: CliIoHost.instance(),
-        action: 'gc',
-      },
+      ioHelper: asIoHelper(ioHost, 'gc'),
       activeAssets: new ActiveAssetCache(),
     };
 
@@ -1022,10 +1021,7 @@ describe('ProgressPrinter', () => {
     setInterval = jest.spyOn(global, 'setInterval');
     clearInterval = jest.spyOn(global, 'clearInterval');
 
-    progressPrinter = new ProgressPrinter({
-      ioHost: CliIoHost.instance(),
-      action: 'gc',
-    }, 0, 1000);
+    progressPrinter = new ProgressPrinter(asIoHelper(ioHost, 'gc'), 0, 1000);
   });
 
   afterEach(() => {
diff --git a/packages/aws-cdk/test/api/resource-import/import.test.ts b/packages/aws-cdk/test/api/resource-import/import.test.ts
index e73ccf133..f9d4e0f21 100644
--- a/packages/aws-cdk/test/api/resource-import/import.test.ts
+++ b/packages/aws-cdk/test/api/resource-import/import.test.ts
@@ -17,9 +17,10 @@ import {
 import * as promptly from 'promptly';
 import { Deployments } from '../../../lib/api/deployments';
 import { ResourceImporter, ImportMap, ResourceImporterProps } from '../../../lib/api/resource-import';
-import { CliIoHost, IIoHost } from '../../../lib/toolkit/cli-io-host';
 import { testStack } from '../../util';
 import { MockSdkProvider, mockCloudFormationClient, restoreSdkMocksToDefault } from '../../util/mock-sdk';
+import { TestIoHost } from '../../_helpers/test-io-host';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 const promptlyConfirm = promptly.confirm as jest.Mock;
 const promptlyPrompt = promptly.prompt as jest.Mock;
@@ -74,7 +75,7 @@ function stackWithKeySigningKey(props: Record<string, unknown>) {
 
 let sdkProvider: MockSdkProvider;
 let deployments: Deployments;
-let ioHost: IIoHost;
+let ioHost = new TestIoHost();
 let props: ResourceImporterProps;
 beforeEach(() => {
   restoreSdkMocksToDefault();
@@ -82,14 +83,11 @@ beforeEach(() => {
   sdkProvider = new MockSdkProvider();
   deployments = new Deployments({
     sdkProvider,
-    ioHost: CliIoHost.instance(),
-    action: 'deploy',
+    ioHelper: asIoHelper(ioHost, 'deploy'),
   });
-  ioHost = CliIoHost.instance();
   props = {
     deployments,
-    ioHost,
-    action: 'import',
+    ioHelper: asIoHelper(ioHost, 'deploy'),
   };
 });
 
diff --git a/packages/aws-cdk/test/api/stack-events/stack-activity-monitor.test.ts b/packages/aws-cdk/test/api/stack-events/stack-activity-monitor.test.ts
index 19bca77d2..ff155f10e 100644
--- a/packages/aws-cdk/test/api/stack-events/stack-activity-monitor.test.ts
+++ b/packages/aws-cdk/test/api/stack-events/stack-activity-monitor.test.ts
@@ -6,8 +6,9 @@ import {
 } from '@aws-sdk/client-cloudformation';
 import { MockSdk, mockCloudFormationClient, restoreSdkMocksToDefault } from '../../util/mock-sdk';
 import { StackActivityMonitor } from '../../../lib/api/stack-events';
-import { IIoHost } from '../../../lib/toolkit/cli-io-host';
 import { testStack } from '../../util';
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
+import { IIoHost } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io';
 
 let sdk: MockSdk;
 let monitor: StackActivityMonitor;
@@ -20,8 +21,7 @@ beforeEach(async () => {
 
   monitor = await new StackActivityMonitor({
     cfn: sdk.cloudFormation(),
-    ioHost,
-    action: 'deploy',
+    ioHelper: asIoHelper(ioHost, 'deploy'),
     stack: testStack({
       stackName: 'StackName',
     }),
diff --git a/packages/aws-cdk/test/api/work-graph/work-graph.test.ts b/packages/aws-cdk/test/api/work-graph/work-graph.test.ts
index 71e86fceb..ac2a4d658 100644
--- a/packages/aws-cdk/test/api/work-graph/work-graph.test.ts
+++ b/packages/aws-cdk/test/api/work-graph/work-graph.test.ts
@@ -1,6 +1,7 @@
+import { asIoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 import { WorkGraph, DeploymentState } from '../../../lib/api/work-graph';
 import type { AssetBuildNode, AssetPublishNode, StackNode } from '../../../lib/api/work-graph';
-import { CliIoHost, IoMessaging } from '../../../lib/toolkit/cli-io-host';
+import { TestIoHost } from '../../_helpers/test-io-host';
 
 const DUMMY: any = 'DUMMY';
 
@@ -10,10 +11,7 @@ const sleep = async (duration: number) => new Promise<void>((resolve) => setTime
 // a chance to start new tasks.
 const SLOW = 200;
 
-let mockMsg: IoMessaging = {
-  ioHost: CliIoHost.instance(),
-  action: 'deploy'
-}
+let ioHost = new TestIoHost();
 
 /**
  * Repurposing unused stack attributes to create specific test scenarios
@@ -249,7 +247,7 @@ describe('WorkGraph', () => {
       expected: ['c-build', 'c-publish', 'A', 'b-build', 'b-publish', 'B'],
     },
   ])('Success - Concurrency: $concurrency - $scenario', async ({ concurrency, expected, toDeploy }) => {
-    const graph = new WorkGraph({}, mockMsg);
+    const graph = new WorkGraph({}, asIoHelper(ioHost, 'deploy'));
     addTestArtifactsToGraph(toDeploy, graph);
 
     await graph.doParallel(concurrency, callbacks);
@@ -258,7 +256,7 @@ describe('WorkGraph', () => {
   });
 
   test('can remove unnecessary assets', async () => {
-    const graph = new WorkGraph({}, mockMsg);
+    const graph = new WorkGraph({}, asIoHelper(ioHost, 'deploy'));
     addTestArtifactsToGraph([
       { id: 'a', type: 'asset' },
       { id: 'b', type: 'asset' },
@@ -381,7 +379,7 @@ describe('WorkGraph', () => {
       expected: ['b-build', 'C'],
     },
   ])('Failure - Concurrency: $concurrency - $scenario', async ({ concurrency, expectedError, toDeploy, expected }) => {
-    const graph = new WorkGraph({}, mockMsg);
+    const graph = new WorkGraph({}, asIoHelper(ioHost, 'deploy'));
     addTestArtifactsToGraph(toDeploy, graph);
 
     await expect(graph.doParallel(concurrency, callbacks)).rejects.toThrow(expectedError);
@@ -417,7 +415,7 @@ describe('WorkGraph', () => {
       expectedError: 'B -> C -> D -> B',
     },
   ])('Failure - Graph Circular Dependencies - $scenario', async ({ toDeploy, expectedError }) => {
-    const graph = new WorkGraph({}, mockMsg);
+    const graph = new WorkGraph({}, asIoHelper(ioHost, 'deploy'));
     addTestArtifactsToGraph(toDeploy, graph);
 
     await expect(graph.doParallel(1, callbacks)).rejects.toThrow(new RegExp(`Unable to make progress.*${expectedError}`));
diff --git a/packages/aws-cdk/test/cli/cdk-toolkit.test.ts b/packages/aws-cdk/test/cli/cdk-toolkit.test.ts
index 43bec370b..f3c911f63 100644
--- a/packages/aws-cdk/test/cli/cdk-toolkit.test.ts
+++ b/packages/aws-cdk/test/cli/cdk-toolkit.test.ts
@@ -18,8 +18,8 @@ const fakeChokidarWatcherOn = {
   },
 
   get fileEventCallback(): (
-  event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',
-  path: string,
+    event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',
+    path: string,
   ) => Promise<void> {
     expect(mockChokidarWatcherOn.mock.calls.length).toBeGreaterThanOrEqual(2);
     const secondCall = mockChokidarWatcherOn.mock.calls[1];
@@ -96,6 +96,7 @@ import {
   mockSSMClient,
   restoreSdkMocksToDefault,
 } from '../util/mock-sdk';
+import { asIoHelper } from '../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 
 markTesting();
 
@@ -103,6 +104,8 @@ const defaultBootstrapSource: BootstrapSource = { source: 'default' };
 const bootstrapEnvironmentMock = jest.spyOn(Bootstrapper.prototype, 'bootstrapEnvironment');
 let cloudExecutable: MockCloudExecutable;
 let stderrMock: jest.SpyInstance;
+let ioHelper = asIoHelper(CliIoHost.instance(), 'deploy');
+
 beforeEach(() => {
   jest.resetAllMocks();
   restoreSdkMocksToDefault();
@@ -224,8 +227,7 @@ describe('readCurrentTemplate', () => {
       sdkProvider: mockCloudExecutable.sdkProvider,
       deployments: new Deployments({
         sdkProvider: mockCloudExecutable.sdkProvider,
-        ioHost: CliIoHost.instance(),
-        action: 'deploy',
+        ioHelper,
       }),
     });
 
@@ -265,8 +267,7 @@ describe('readCurrentTemplate', () => {
       sdkProvider: mockCloudExecutable.sdkProvider,
       deployments: new Deployments({
         sdkProvider: mockCloudExecutable.sdkProvider,
-        ioHost: CliIoHost.instance(),
-        action: 'deploy',
+        ioHelper,
       }),
     });
 
@@ -331,8 +332,7 @@ describe('readCurrentTemplate', () => {
       sdkProvider: mockCloudExecutable.sdkProvider,
       deployments: new Deployments({
         sdkProvider: mockCloudExecutable.sdkProvider,
-        ioHost: CliIoHost.instance(),
-        action: 'deploy',
+        ioHelper,
       }),
     });
 
@@ -388,8 +388,7 @@ describe('readCurrentTemplate', () => {
       sdkProvider: mockCloudExecutable.sdkProvider,
       deployments: new Deployments({
         sdkProvider: mockCloudExecutable.sdkProvider,
-        ioHost: CliIoHost.instance(),
-        action: 'deploy',
+        ioHelper,
       }),
     });
 
@@ -445,8 +444,7 @@ describe('readCurrentTemplate', () => {
       sdkProvider: mockCloudExecutable.sdkProvider,
       deployments: new Deployments({
         sdkProvider: mockCloudExecutable.sdkProvider,
-        ioHost: CliIoHost.instance(),
-        action: 'deploy',
+        ioHelper,
       }),
     });
 
@@ -499,8 +497,7 @@ describe('readCurrentTemplate', () => {
       sdkProvider: mockCloudExecutable.sdkProvider,
       deployments: new Deployments({
         sdkProvider: mockCloudExecutable.sdkProvider,
-        ioHost: CliIoHost.instance(),
-        action: 'deploy',
+        ioHelper,
       }),
     });
 
@@ -1038,7 +1035,7 @@ describe('watch', () => {
       });
     }).rejects.toThrow(
       "Cannot use the 'watch' command without specifying at least one directory to monitor. " +
-        'Make sure to add a "watch" key to your cdk.json',
+      'Make sure to add a "watch" key to your cdk.json',
     );
   });
 
@@ -1336,8 +1333,7 @@ describe('synth', () => {
         cloudExecutable: mockCloudExecutable,
         deployments: new Deployments({
           sdkProvider: mockSdkProvider,
-          ioHost: CliIoHost.instance(),
-          action: 'deploy',
+          ioHelper: asIoHelper(CliIoHost.instance(), 'deploy'),
         }),
         sdkProvider: mockSdkProvider,
         configuration: mockCloudExecutable.configuration,
@@ -1539,8 +1535,7 @@ describe('synth', () => {
       sdkProvider: cloudExecutable.sdkProvider,
       deployments: new Deployments({
         sdkProvider: new MockSdkProvider(),
-        ioHost: CliIoHost.instance(),
-        action: 'deploy',
+        ioHelper,
       }),
     });
 
@@ -1566,8 +1561,7 @@ describe('synth', () => {
 
     const deployments = new Deployments({
       sdkProvider: new MockSdkProvider(),
-      ioHost: CliIoHost.instance(),
-      action: 'deploy',
+      ioHelper,
     });
 
     // Rollback might be called -- just don't do anything.
@@ -1751,8 +1745,7 @@ class FakeCloudFormation extends Deployments {
   ) {
     super({
       sdkProvider: new MockSdkProvider(),
-      ioHost: CliIoHost.instance(),
-      action: 'deploy',
+      ioHelper,
     });
 
     for (const [stackName, tags] of Object.entries(expectedTags)) {