From 9c80df2cb210b65230e60502026c608d97786eb6 Mon Sep 17 00:00:00 2001
From: TheLarkInn <TheLarkInn@users.noreply.github.com>
Date: Fri, 28 Aug 2026 07:52:04 +0000
Subject: [PATCH 1/5] Add direct Rush reporter demo path

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d6318e80-5da9-4858-a147-817e8692f10e
---
 apps/rush/src/MinimalRushConfiguration.ts     |  42 ++++-
 apps/rush/src/RushFrontend.ts                 |  25 ++-
 apps/rush/src/RushReporterHost.ts             | 168 +++++++++++------
 .../src/test/MinimalRushConfiguration.test.ts |   1 +
 apps/rush/src/test/RushReporterHost.test.ts   |  76 +++++++-
 .../src/test/sandbox/reporter-demo/README.md  |  25 +++
 .../src/test/sandbox/reporter-demo/run.mjs    |  51 ++++++
 ...r-r5b-demo-reporters_2026-08-28-07-10.json |  11 ++
 ...r-r5b-demo-reporters_2026-08-28-07-10.json |  11 ++
 common/reviews/api/rush-lib.api.md            |   2 +
 common/reviews/api/rush-reporter.api.md       |   1 +
 .../reporter/src/reporters/AiReporter.ts      |  25 ++-
 .../reporters/DefaultInteractiveReporter.ts   |  79 +++++---
 .../reporter/src/reporters/FileReporter.ts    | 170 +++++++++++++++++-
 .../reporter/src/reporters/LegacyReporter.ts  |   4 +-
 .../src/reporters/PlaintextReporter.ts        |  71 +++++++-
 .../test/DefaultInteractiveReporter.test.ts   |  32 +++-
 .../reporter/src/test/FileReporter.test.ts    |  64 ++++++-
 .../reporter/src/test/JsonAiReporter.test.ts  |  26 +++
 .../src/test/OperationStreamEmitter.test.ts   |   3 +
 .../src/test/PlaintextReporter.test.ts        |  35 ++++
 libraries/rush-lib/src/api/Rush.ts            |   2 +-
 .../rush-lib/src/cli/RushCommandLineParser.ts | 144 +++++++++++----
 .../src/cli/actions/BaseRushAction.ts         |  11 +-
 .../cli/scriptActions/PhasedScriptAction.ts   |  38 ++--
 .../cli/test/RushCommandLineParser.test.ts    |  30 ++++
 .../rush-lib/src/logic/ProjectWatcher.ts      |  14 +-
 .../operations/ReporterOperationEventSink.ts  |  46 ++++-
 .../test/OperationGraphEventSink.test.ts      |  97 ++++++++++
 .../src/pluginFramework/RushSession.ts        |  25 +++
 30 files changed, 1176 insertions(+), 153 deletions(-)
 create mode 100644 apps/rush/src/test/sandbox/reporter-demo/README.md
 create mode 100644 apps/rush/src/test/sandbox/reporter-demo/run.mjs
 create mode 100644 common/changes/@microsoft/rush/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json
 create mode 100644 common/changes/@rushstack/rush-reporter/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json

diff --git a/apps/rush/src/MinimalRushConfiguration.ts b/apps/rush/src/MinimalRushConfiguration.ts
index 62aef01d11d..8a7ffa0d3b7 100644
--- a/apps/rush/src/MinimalRushConfiguration.ts
+++ b/apps/rush/src/MinimalRushConfiguration.ts
@@ -52,14 +52,29 @@ export class MinimalRushConfiguration {
   }
 
   public static loadFromDefaultLocation(): MinimalRushConfiguration | undefined {
+    const showVerbose: boolean = !RushCommandLineParser.shouldRestrictConsoleOutput();
     const rushJsonLocation: string | undefined = RushConfiguration.tryFindRushJsonLocation({
-      showVerbose: !RushCommandLineParser.shouldRestrictConsoleOutput()
+      showVerbose: false
     });
     if (rushJsonLocation) {
       const minimalRushConfigurationJson: IMinimalRushConfigurationJson | undefined =
         _loadConfigurationJson(rushJsonLocation);
       if (minimalRushConfigurationJson) {
-        return new MinimalRushConfiguration(minimalRushConfigurationJson, rushJsonLocation);
+        const configuration: MinimalRushConfiguration = new MinimalRushConfiguration(
+          minimalRushConfigurationJson,
+          rushJsonLocation
+        );
+        if (
+          showVerbose &&
+          !configuration.useRushReporter &&
+          !_hasExplicitNonLegacyReporter(process.argv.slice(2)) &&
+          path.dirname(rushJsonLocation) !== process.cwd()
+        ) {
+          // Preserve the legacy discovery message exactly when the reporter path is not taking ownership.
+          console.log('Found configuration in ' + rushJsonLocation);
+          console.log('');
+        }
+        return configuration;
       }
       return undefined;
     } else {
@@ -94,6 +109,29 @@ export class MinimalRushConfiguration {
   public get useRushReporter(): boolean {
     return this._useRushReporter;
   }
+
+  /**
+   * The repository's common temp folder, used for invocation-scoped reporter logs.
+   */
+  public get commonTempFolder(): string {
+    return path.resolve(this._commonRushConfigFolder, '..', '..', 'temp');
+  }
+}
+
+function _hasExplicitNonLegacyReporter(argv: readonly string[]): boolean {
+  for (let index: number = 0; index < argv.length; index++) {
+    const argument: string = argv[index];
+    let value: string | undefined;
+    if (argument === '--reporter') {
+      value = argv[index + 1];
+    } else if (argument.startsWith('--reporter=')) {
+      value = argument.slice('--reporter='.length);
+    }
+    if (value !== undefined) {
+      return value.trim().toLowerCase() !== 'legacy';
+    }
+  }
+  return false;
 }
 
 function _loadConfigurationJson(rushJsonFilename: string): IMinimalRushConfigurationJson | undefined {
diff --git a/apps/rush/src/RushFrontend.ts b/apps/rush/src/RushFrontend.ts
index 00caadebf4b..c6088eb195d 100644
--- a/apps/rush/src/RushFrontend.ts
+++ b/apps/rush/src/RushFrontend.ts
@@ -4,7 +4,10 @@
 import { randomUUID } from 'node:crypto';
 
 import type { ILaunchOptions } from '@microsoft/rush-lib';
-import { DEFAULT_SIGNAL_FLUSH_TIMEOUT_MS } from '@rushstack/rush-reporter';
+import {
+  DEFAULT_SIGNAL_FLUSH_TIMEOUT_MS,
+  REPORTER_PROTOCOL_VERSION
+} from '@rushstack/rush-reporter';
 
 import {
   initializeRushReporterHostAsync,
@@ -139,10 +142,13 @@ export async function launchRushFrontendAsync(options: IRushFrontendOptions): Pr
     processLifecycle = createProcessLifecycle()
   } = options;
 
+  const engineArgv: string[] = stripReporterValueControls(process.argv.slice(2));
   const reporterHost: IInitializedRushReporterHost = await initializeReporterHostAsync({
     repositoryOptIn: configuration?.useRushReporter,
     forceLegacy: rushVersionToLoad !== undefined && rushVersionToLoad !== currentPackageVersion,
-    selectedRushVersion: rushVersionToLoad
+    selectedRushVersion: rushVersionToLoad,
+    commonTempFolder: configuration?.commonTempFolder,
+    actionName: engineArgv.find((argument: string) => !argument.startsWith('-'))
   });
   const reporterLifecycle: RushFrontendReporterLifecycle | undefined = reporterHost.selection.enabled
     ? new RushFrontendReporterLifecycle(reporterHost, processLifecycle)
@@ -157,6 +163,21 @@ export async function launchRushFrontendAsync(options: IRushFrontendOptions): Pr
   const reporterCloseAsync: () => Promise<void> = () =>
     reporterLifecycle?.closeAsync() ?? reporterHost.closeAsync();
   const sessionId: string = createSessionId();
+  if (reporterHost.selection.enabled && reporterHost.logArtifact?.path) {
+    reporterHost.sink.emit({
+      protocolVersion: REPORTER_PROTOCOL_VERSION,
+      sessionId,
+      source: { packageName: '@microsoft/rush', packageVersion: currentPackageVersion },
+      privacy: 'local-sensitive',
+      type: 'artifactAvailable',
+      payload: {
+        role: 'log',
+        path: reporterHost.logArtifact.path,
+        format: 'plaintext',
+        complete: false
+      }
+    });
+  }
   const reporterLaunchOptions: IRushFrontendLaunchOptions = {
     ...launchOptions,
     reporter: {
diff --git a/apps/rush/src/RushReporterHost.ts b/apps/rush/src/RushReporterHost.ts
index 82dc2d4f902..fcfc53232cf 100644
--- a/apps/rush/src/RushReporterHost.ts
+++ b/apps/rush/src/RushReporterHost.ts
@@ -20,8 +20,10 @@ import {
   shouldRenderAtLogLevel,
   type IReporter,
   type IReporterContext,
+  type IReporterEmitEventInput,
   type IReporterEventEnvelope,
   type IReporterEventSink,
+  type IFileReporterArtifact,
   type IReporterOutputTarget,
   type ReporterEventType,
   type ReporterLogLevel,
@@ -39,6 +41,9 @@ export interface IRushReporterHostOptions {
   readonly env?: Record<string, string | undefined>;
   readonly cwd?: string;
   readonly stdout?: IRushReporterOutputStream;
+  readonly stderr?: IRushReporterOutputStream;
+  readonly commonTempFolder?: string;
+  readonly actionName?: string;
   readonly includeDefaultFileReporter?: boolean;
   readonly commandName?: 'rush' | 'rush-pnpm' | 'rushx';
   readonly repositoryOptIn?: boolean;
@@ -65,13 +70,14 @@ export interface IInitializedRushReporterHost {
   readonly host: ReporterHost;
   readonly sink: IReporterEventSink;
   readonly selection: IRushReporterSelection;
+  readonly logArtifact: IFileReporterArtifact | undefined;
   closeAsync(timeoutMs?: number): Promise<void>;
 }
 
 const REPORTER_VALUE_FLAGS: ReadonlySet<string> = new Set(['--reporter', '--output', '--log-level']);
 const ALL_REPORTER_VALUE_FLAGS: readonly string[] = ['--reporter', '--output', '--log-level'];
 const REPORTER_SELECTION_FLAG: readonly string[] = ['--reporter'];
-const DEFERRED_OPERATION_EVENT_TYPES: ReadonlySet<ReporterEventType> = new Set([
+const GROUPED_OPERATION_EVENT_TYPES: ReadonlySet<ReporterEventType> = new Set([
   'operationRegistered',
   'operationStatusChanged',
   'operationStreamClosed',
@@ -93,10 +99,16 @@ class LogLevelReporter implements IReporter {
 
   private readonly _reporter: IReporter;
   private readonly _logLevel: ReporterLogLevel;
+  private readonly _preserveOperationStream: boolean;
 
-  public constructor(reporter: IReporter, logLevel: ReporterLogLevel) {
+  public constructor(
+    reporter: IReporter,
+    logLevel: ReporterLogLevel,
+    preserveOperationStream: boolean = false
+  ) {
     this._reporter = reporter;
     this._logLevel = logLevel;
+    this._preserveOperationStream = preserveOperationStream;
     this.name = reporter.name;
   }
 
@@ -105,39 +117,18 @@ class LogLevelReporter implements IReporter {
   }
 
   public report(event: IReporterEventEnvelope<unknown>): void {
-    if (shouldRenderAtLogLevel(this._logLevel, event)) {
-      this._reporter.report(event);
-    }
-  }
-
-  public flushAsync(): Promise<void> {
-    return this._reporter.flushAsync();
-  }
-
-  public closeAsync(): Promise<void> {
-    return this._reporter.closeAsync();
-  }
-}
-
-/**
- * Keeps operation presentation on the legacy collator until R5B transfers terminal ownership.
- */
-class DeferredOperationPresentationReporter implements IReporter {
-  public readonly name: string;
-
-  private readonly _reporter: IReporter;
-
-  public constructor(reporter: IReporter) {
-    this._reporter = reporter;
-    this.name = reporter.name;
-  }
-
-  public initializeAsync(context: IReporterContext): Promise<void> {
-    return this._reporter.initializeAsync(context);
-  }
-
-  public report(event: IReporterEventEnvelope<unknown>): void {
-    if (!DEFERRED_OPERATION_EVENT_TYPES.has(event.type)) {
+    const verboseTerminalMessage: boolean =
+      this._logLevel === 'verbose' &&
+      event.type === 'messageEmitted' &&
+      (event.payload as { severity?: string }).severity === 'debug';
+    if (
+      shouldRenderAtLogLevel(this._logLevel, event) ||
+      verboseTerminalMessage ||
+      event.type === 'artifactAvailable' ||
+      (this._preserveOperationStream &&
+        GROUPED_OPERATION_EVENT_TYPES.has(event.type) &&
+        !(this._logLevel === 'quiet' && event.type === 'externalOutput'))
+    ) {
       this._reporter.report(event);
     }
   }
@@ -202,6 +193,43 @@ class ExplicitOutputReporter implements IReporter {
   }
 }
 
+class FilePathReporter implements IReporter {
+  public readonly name: string = 'file-path';
+
+  private readonly _write: (text: string) => unknown;
+  private _path: string | undefined;
+
+  public constructor(write: (text: string) => unknown) {
+    this._write = write;
+  }
+
+  public async initializeAsync(): Promise<void> {
+    /* no-op */
+  }
+
+  public report(event: IReporterEventEnvelope<unknown>): void {
+    if (event.type === 'artifactAvailable') {
+      const payload: { role?: string; path?: string } = event.payload as {
+        role?: string;
+        path?: string;
+      };
+      if (payload.role === 'log') {
+        this._path = payload.path;
+      }
+    } else if (event.type === 'commandResult' && this._path) {
+      this._write(`Rush full log: ${this._path}\n`);
+    }
+  }
+
+  public async flushAsync(): Promise<void> {
+    /* no-op */
+  }
+
+  public async closeAsync(): Promise<void> {
+    /* no-op */
+  }
+}
+
 function readValue(
   argv: readonly string[],
   index: number,
@@ -397,6 +425,19 @@ function resolveLogLevel(
   }
 
   const environmentLogLevel: string | undefined = includeEnvironment ? env.RUSH_LOG_LEVEL : undefined;
+  const environmentQuiet: boolean =
+    includeEnvironment && (env.RUSH_QUIET_MODE === '1' || env.RUSH_QUIET_MODE?.toLowerCase() === 'true');
+  if (environmentQuiet && environmentLogLevel) {
+    const normalizedLogLevel: string = environmentLogLevel.trim().toLowerCase();
+    if (normalizedLogLevel !== 'quiet') {
+      throw new Error(
+        'RUSH_QUIET_MODE contradicts RUSH_LOG_LEVEL. Remove one of these environment controls.'
+      );
+    }
+  }
+  if (environmentQuiet) {
+    return 'quiet';
+  }
   if (environmentLogLevel) {
     const normalizedLogLevel: string = environmentLogLevel.trim().toLowerCase();
     if (!isSupportedLogLevel(normalizedLogLevel)) {
@@ -527,6 +568,19 @@ export function resolveRushReporterSelection(options: IRushReporterHostOptions =
     };
   }
 
+  if (argv.includes('--help') || argv.includes('-h')) {
+    return {
+      reporter: 'legacy',
+      logLevel: 'normal',
+      outputs: [],
+      commandJson,
+      enabled: false,
+      reporterControlsOwnedByFrontend: requestedReporter !== undefined,
+      reporterValueFlagsToStrip: requestedReporter === undefined ? [] : REPORTER_SELECTION_FLAG,
+      reason: requestedReporter === undefined ? 'pre-major legacy default' : 'explicit --reporter'
+    };
+  }
+
   function getCommandName(): 'rush' | 'rush-pnpm' | 'rushx' {
     const executableName: string = path.basename(process.argv[1] ?? '').toLowerCase();
     if (executableName === 'rush-pnpm') {
@@ -629,11 +683,12 @@ function createPrimaryReporter(
     case 'plaintext':
       return new PlaintextReporter({
         write: (text: string) => stdout.write(text),
-        variant: isCiDetected(env) ? 'detailed' : 'concise',
-        color: false
+        variant: selection.reason === 'explicit --reporter' || isCiDetected(env) ? 'detailed' : 'concise',
+        color: false,
+        logLevel: selection.logLevel
       });
     case 'file':
-      return new FileReporter();
+      return undefined;
     case 'legacy':
       return undefined;
   }
@@ -644,30 +699,36 @@ export async function initializeRushReporterHostAsync(
 ): Promise<IInitializedRushReporterHost> {
   const env: Record<string, string | undefined> = options.env ?? process.env;
   const stdout: IRushReporterOutputStream = options.stdout ?? process.stdout;
+  const stderr: IRushReporterOutputStream = options.stderr ?? process.stderr;
   const selection: IRushReporterSelection = resolveRushReporterSelection({ ...options, env, stdout });
   const host: ReporterHost = new ReporterHost({ env });
+  let fullDetailReporter: FileReporter | undefined;
 
   if (selection.enabled) {
     const primaryReporter: IReporter | undefined = createPrimaryReporter(selection, stdout, env);
     if (primaryReporter) {
-      const presentationReporter: IReporter =
-        selection.reporter === 'file'
-          ? primaryReporter
-          : new DeferredOperationPresentationReporter(primaryReporter);
-      host.manager.addReporter(new LogLevelReporter(presentationReporter, selection.logLevel), {
-        destination: selection.reporter === 'file' ? 'file:auto' : 'stdout'
+      host.manager.addReporter(
+        new LogLevelReporter(primaryReporter, selection.logLevel, selection.reporter === 'plaintext'),
+        {
+          destination: 'stdout'
+        }
+      );
+    }
+
+    if (options.includeDefaultFileReporter !== false || selection.reporter === 'file') {
+      fullDetailReporter = new FileReporter({
+        commonTempFolder: options.commonTempFolder,
+        actionName: options.actionName
+      });
+      host.manager.addReporter(fullDetailReporter, {
+        destination: 'file:auto'
       });
     }
 
-    const hasExplicitFileOutput: boolean = selection.outputs.some(
-      (output: IReporterOutputTarget) => output.reporter === 'file'
-    );
-    if (
-      options.includeDefaultFileReporter !== false &&
-      selection.reporter !== 'file' &&
-      !hasExplicitFileOutput
-    ) {
-      host.manager.addReporter(new FileReporter(), { destination: 'file:auto' });
+    if (selection.reporter === 'file') {
+      host.manager.addReporter(new FilePathReporter((text: string) => stderr.write(text)), {
+        destination: 'stderr'
+      });
     }
 
     for (const output of selection.outputs) {
@@ -689,6 +750,7 @@ export async function initializeRushReporterHostAsync(
     host,
     sink: host.getSink(),
     selection,
+    logArtifact: fullDetailReporter?.getArtifact(),
     closeAsync: (timeoutMs?: number) => {
       closePromise ??= host.manager.closeAsync(timeoutMs);
       return closePromise;
diff --git a/apps/rush/src/test/MinimalRushConfiguration.test.ts b/apps/rush/src/test/MinimalRushConfiguration.test.ts
index 80b95dbd6aa..3f01ee36a9b 100644
--- a/apps/rush/src/test/MinimalRushConfiguration.test.ts
+++ b/apps/rush/src/test/MinimalRushConfiguration.test.ts
@@ -33,6 +33,7 @@ describe(MinimalRushConfiguration.name, () => {
         MinimalRushConfiguration.loadFromDefaultLocation() as MinimalRushConfiguration;
       expect(config.rushVersion).toEqual('4.0.0');
       expect(config.useRushReporter).toBe(true);
+      expect(config.commonTempFolder).toBe(path.resolve(__dirname, 'sandbox', 'repo', 'common', 'temp'));
     });
   });
 });
diff --git a/apps/rush/src/test/RushReporterHost.test.ts b/apps/rush/src/test/RushReporterHost.test.ts
index 7846cb673c6..abd6884bbc2 100644
--- a/apps/rush/src/test/RushReporterHost.test.ts
+++ b/apps/rush/src/test/RushReporterHost.test.ts
@@ -234,6 +234,14 @@ describe(resolveRushReporterSelection.name, () => {
     ).toEqual(['node', 'rush', 'custom', '--output', 'custom.zip', '--log-level', 'custom', '--verbose']);
   });
 
+  it('keeps help on the legacy parser-only path', () => {
+    expect(resolve(['build', '--help', '--reporter=json'], {}, false)).toMatchObject({
+      reporter: 'legacy',
+      enabled: false,
+      reporterControlsOwnedByFrontend: true
+    });
+  });
+
   it('removes reporter-only value controls before invoking a legacy engine', () => {
     expect(
       stripReporterValueControls([
@@ -325,6 +333,13 @@ describe(resolveRushReporterSelection.name, () => {
     );
   });
 
+  it('preserves RUSH_QUIET_MODE as a quiet reporter alias', () => {
+    expect(resolve(['build', '--reporter=plaintext'], { RUSH_QUIET_MODE: 'true' }).logLevel).toBe('quiet');
+    expect(() =>
+      resolve(['build', '--reporter=plaintext'], { RUSH_QUIET_MODE: '1', RUSH_LOG_LEVEL: 'debug' })
+    ).toThrow(/contradicts RUSH_LOG_LEVEL/);
+  });
+
   it('preserves legacy verbosity combinations when the reporter path is disabled', () => {
     expect(resolve(['build', '--quiet', '--debug'])).toMatchObject({
       reporter: 'legacy',
@@ -466,9 +481,61 @@ describe(initializeRushReporterHostAsync.name, () => {
     await initialized.closeAsync();
 
     expect(initialized.selection.enabled).toBe(false);
+    expect(initialized.logArtifact).toBeUndefined();
     expect(output).toBe('');
   });
 
+  it('always creates a repository full-detail log on the enabled path', async () => {
+    const directory: string = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'rush-full-log-'));
+    try {
+      const initialized = await initializeRushReporterHostAsync({
+        argv: ['build', '--reporter=plaintext'],
+        env: {},
+        commonTempFolder: directory,
+        actionName: 'build',
+        stdout: { isTTY: false, write: () => undefined }
+      });
+
+      expect(initialized.logArtifact).toMatchObject({ available: true });
+      expect(initialized.logArtifact?.path).toMatch(
+        new RegExp(`^${directory.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`)
+      );
+      await initialized.closeAsync();
+    } finally {
+      await fs.promises.rm(directory, { recursive: true, force: true });
+    }
+  });
+
+  it('does not render operation output at quiet plaintext log level', async () => {
+    let output: string = '';
+    const quietHost = await initializeRushReporterHostAsync({
+      argv: ['build', '--reporter=plaintext', '--log-level=quiet'],
+      env: {},
+      stdout: {
+        isTTY: false,
+        write: (text: string) => {
+          output += text;
+        }
+      },
+      includeDefaultFileReporter: false
+    });
+
+    emitCommandStarted(quietHost.sink);
+    emitOperationEvents(quietHost.sink);
+    quietHost.sink.emit({
+      protocolVersion: { major: 1, minor: 1 },
+      sessionId: 'session',
+      source: { packageName: '@microsoft/rush-lib', packageVersion: '5.178.1' },
+      privacy: 'public',
+      type: 'commandResult',
+      payload: { commandName: 'build', succeeded: true, exitCode: 0 }
+    });
+    await quietHost.closeAsync();
+
+    expect(output).not.toContain('raw operation output');
+    expect(output).toContain('rush build succeeded');
+  });
+
   it('initializes the explicitly selected reporter and output destinations', async () => {
     const directory: string = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'rush-frontend-'));
     const outputPath: string = path.join(directory, 'events.jsonl');
@@ -505,7 +572,14 @@ describe(initializeRushReporterHostAsync.name, () => {
         .trim()
         .split('\n')
         .map((line: string) => JSON.parse(line) as Record<string, unknown>);
-      expect(stdoutEvents.map(({ type }) => type)).toEqual(['commandStarted']);
+      expect(stdoutEvents.map(({ type }) => type)).toEqual([
+        'commandStarted',
+        'operationRegistered',
+        'operationStatusChanged',
+        'externalOutput',
+        'operationStreamClosed',
+        'operationCompleted'
+      ]);
       expect(fileEvents.map(({ type }) => type)).toEqual([
         'commandStarted',
         'operationRegistered',
diff --git a/apps/rush/src/test/sandbox/reporter-demo/README.md b/apps/rush/src/test/sandbox/reporter-demo/README.md
new file mode 100644
index 00000000000..39eeccdd4fb
--- /dev/null
+++ b/apps/rush/src/test/sandbox/reporter-demo/README.md
@@ -0,0 +1,25 @@
+# Direct Rush reporter demo
+
+Build the three reporter projects, then run the self-checking direct invocation demo:
+
+```sh
+rush build --to @microsoft/rush
+node apps/rush/src/test/sandbox/reporter-demo/run.mjs
+```
+
+The script runs the same `rush build --only @rushstack/rush-reporter` operation stream through legacy,
+plaintext, JSON, and AI modes. It verifies JSON/AI payload-only stdout, confirms the plaintext result
+contains an existing absolute full-log path, and writes captured stdout/stderr files to a temporary folder.
+
+For an individual invocation:
+
+```sh
+node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=plaintext
+node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=json --log-level=debug
+node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=ai
+RUSH_REPORTER=legacy node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=json
+```
+
+Repositories can opt in without a command-line flag by setting `"useRushReporter": true` in
+`common/config/rush/experiments.json`. Remove that setting or use `RUSH_REPORTER=legacy` for immediate
+rollback.
diff --git a/apps/rush/src/test/sandbox/reporter-demo/run.mjs b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
new file mode 100644
index 00000000000..0cf345a6314
--- /dev/null
+++ b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
@@ -0,0 +1,51 @@
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptFolder = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(scriptFolder, '..', '..', '..', '..', '..', '..');
+const rushBin = path.join(repoRoot, 'apps', 'rush', 'bin', 'rush');
+const outputFolder = fs.mkdtempSync(path.join(os.tmpdir(), 'rush-reporter-demo-'));
+const commonArgs = ['build', '--only', '@rushstack/rush-reporter'];
+
+function run(name, args, env = {}) {
+  const result = spawnSync(process.execPath, [rushBin, ...args], {
+    cwd: repoRoot,
+    env: { ...process.env, ...env },
+    encoding: 'utf8'
+  });
+  fs.writeFileSync(path.join(outputFolder, `${name}.stdout`), result.stdout);
+  fs.writeFileSync(path.join(outputFolder, `${name}.stderr`), result.stderr);
+  if (result.status !== 0) {
+    throw new Error(`${name} failed with exit code ${result.status}\n${result.stderr}`);
+  }
+  return result.stdout;
+}
+
+run('warmup', commonArgs);
+const legacy = run('legacy', commonArgs);
+const rollback = run('rollback', [...commonArgs, '--reporter=json'], { RUSH_REPORTER: 'legacy' });
+const normalizeDurations = (text) => text.replace(/\d+\.\d+ seconds/g, '<time> seconds');
+if (normalizeDurations(legacy) !== normalizeDurations(rollback)) {
+  throw new Error('RUSH_REPORTER=legacy did not reproduce the feature-off output.');
+}
+const plaintext = run('plaintext', [...commonArgs, '--reporter=plaintext']);
+const json = run('json', [...commonArgs, '--reporter=json', '--log-level=debug']);
+const ai = run('ai', [...commonArgs, '--reporter=ai']);
+
+for (const line of json.split('\n').filter(Boolean)) {
+  JSON.parse(line);
+}
+for (const line of ai.split('\n').filter(Boolean)) {
+  JSON.parse(line);
+}
+
+const logMatch = plaintext.match(/^Full log: (.+)$/m);
+if (!logMatch || !path.isAbsolute(logMatch[1]) || !fs.existsSync(logMatch[1])) {
+  throw new Error('The plaintext reporter did not expose an existing absolute full-log path.');
+}
+
+console.log(`Reporter demo outputs: ${outputFolder}`);
+console.log(`Full detail log: ${logMatch[1]}`);
diff --git a/common/changes/@microsoft/rush/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json b/common/changes/@microsoft/rush/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json
new file mode 100644
index 00000000000..80d4ffba6fc
--- /dev/null
+++ b/common/changes/@microsoft/rush/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json
@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@microsoft/rush",
+      "comment": "Add the opt-in direct build reporter demo path with reporter-owned output, a complete full-detail log, and an immediate legacy rollback.",
+      "type": "patch"
+    }
+  ],
+  "packageName": "@microsoft/rush",
+  "email": "TheLarkInn@users.noreply.github.com"
+}
diff --git a/common/changes/@rushstack/rush-reporter/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json b/common/changes/@rushstack/rush-reporter/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json
new file mode 100644
index 00000000000..80e9b8a81f0
--- /dev/null
+++ b/common/changes/@rushstack/rush-reporter/copilot-reporter-r5b-demo-reporters_2026-08-28-07-10.json
@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@rushstack/rush-reporter",
+      "comment": "Render phase-aware compact progress and grouped plaintext full logs from the canonical operation stream.",
+      "type": "minor"
+    }
+  ],
+  "packageName": "@rushstack/rush-reporter",
+  "email": "TheLarkInn@users.noreply.github.com"
+}
diff --git a/common/reviews/api/rush-lib.api.md b/common/reviews/api/rush-lib.api.md
index 4b5f481e45c..07d1b73e8ca 100644
--- a/common/reviews/api/rush-lib.api.md
+++ b/common/reviews/api/rush-lib.api.md
@@ -1016,6 +1016,8 @@ export interface IRushSessionOptions {
 export interface IRushSessionReporterOptions {
     readonly eventSink: IReporterEventSink;
     // @internal
+    readonly flushAsync?: () => Promise<void>;
+    // @internal
     readonly operationStreamEnabled?: boolean;
     readonly sessionId: string;
 }
diff --git a/common/reviews/api/rush-reporter.api.md b/common/reviews/api/rush-reporter.api.md
index 087a4ca45fd..473c0636dc8 100644
--- a/common/reviews/api/rush-reporter.api.md
+++ b/common/reviews/api/rush-reporter.api.md
@@ -646,6 +646,7 @@ export interface IOperationStreamEmitterOptions {
 export interface IPlaintextReporterOptions {
     readonly color?: boolean;
     readonly heartbeatIntervalMs?: number;
+    readonly logLevel?: ReporterLogLevel;
     readonly nowMs?: () => number;
     readonly variant?: PlaintextVariant;
     readonly write: (text: string) => void;
diff --git a/libraries/reporter/src/reporters/AiReporter.ts b/libraries/reporter/src/reporters/AiReporter.ts
index fc885273dc1..f74b11466aa 100644
--- a/libraries/reporter/src/reporters/AiReporter.ts
+++ b/libraries/reporter/src/reporters/AiReporter.ts
@@ -16,7 +16,8 @@ const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
   'blocked',
   'skipped',
   'fromCache',
-  'noOp'
+  'noOp',
+  'aborted'
 ]);
 
 /**
@@ -109,6 +110,7 @@ export class AiReporter implements IReporter {
   private _protocolVersion: IReporterProtocolVersion;
   private _commandName: string | undefined;
   private readonly _projectByOperation: Map<string, string>;
+  private readonly _silentOperations: Set<string>;
   private readonly _operationCounts: { [status: string]: number };
   private readonly _failedProjects: string[];
   private readonly _errorDiagnostics: IAiDiagnostic[];
@@ -139,6 +141,7 @@ export class AiReporter implements IReporter {
     this._protocolVersion = REPORTER_PROTOCOL_VERSION;
     this._commandName = undefined;
     this._projectByOperation = new Map();
+    this._silentOperations = new Set();
     this._operationCounts = {};
     this._failedProjects = [];
     this._errorDiagnostics = [];
@@ -174,20 +177,31 @@ export class AiReporter implements IReporter {
         break;
       }
       case 'operationRegistered': {
-        const payload: { operationId: string; projectName?: string } = event.payload as {
+        const payload: { operationId: string; projectName?: string; silent?: boolean } = event.payload as {
           operationId: string;
           projectName?: string;
+          silent?: boolean;
         };
+        if (payload.silent) {
+          this._silentOperations.add(payload.operationId);
+        }
         if (payload.projectName !== undefined) {
           this._projectByOperation.set(payload.operationId, payload.projectName);
         }
         break;
       }
       case 'operationStatusChanged': {
+        break;
+      }
+      case 'operationCompleted': {
         const payload: { operationId: string; status: string } = event.payload as {
           operationId: string;
           status: string;
         };
+        if (this._silentOperations.has(payload.operationId)) {
+          this._silentOperations.delete(payload.operationId);
+          break;
+        }
         if (TERMINAL_STATUSES.has(payload.status)) {
           this._operationCounts[payload.status] = (this._operationCounts[payload.status] ?? 0) + 1;
           if (payload.status === 'failure') {
@@ -222,6 +236,13 @@ export class AiReporter implements IReporter {
         this._emitFinal(payload.succeeded, payload.exitCode);
         break;
       }
+      case 'sessionCompleted': {
+        if (!this._finalEmitted) {
+          const exitCode: number = (event.payload as { exitCode?: number }).exitCode ?? 1;
+          this._emitFinal(exitCode === 0, exitCode);
+        }
+        break;
+      }
       default:
         break;
     }
diff --git a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
index 708322f381b..453b9cd3d06 100644
--- a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
+++ b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
@@ -17,16 +17,6 @@ import {
 const HIDE_CURSOR: string = '\u001b[?25l';
 const SHOW_CURSOR: string = '\u001b[?25h';
 const MAX_FINAL_DIAGNOSTICS: number = 10;
-const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
-  'success',
-  'successWithWarnings',
-  'failure',
-  'blocked',
-  'skipped',
-  'fromCache',
-  'noOp'
-]);
-
 /**
  * The terminal an interactive reporter writes to.
  *
@@ -114,6 +104,7 @@ export class DefaultInteractiveReporter implements IReporter {
   private _completedOperations: number;
   private _failedOperations: number;
   private readonly _projectByOperation: Map<string, string>;
+  private readonly _silentOperations: Set<string>;
   private readonly _activeProjects: Map<string, string>;
   private _latestActivity: string;
   private readonly _diagnostics: string[];
@@ -139,6 +130,7 @@ export class DefaultInteractiveReporter implements IReporter {
     this._completedOperations = 0;
     this._failedOperations = 0;
     this._projectByOperation = new Map();
+    this._silentOperations = new Set();
     this._activeProjects = new Map();
     this._latestActivity = '';
     this._diagnostics = [];
@@ -184,14 +176,23 @@ export class DefaultInteractiveReporter implements IReporter {
         break;
       }
       case 'operationRegistered': {
-        const payload: { operationId: string; projectName?: string } = event.payload as {
-          operationId: string;
-          projectName?: string;
-        };
+        const payload: { operationId: string; projectName?: string; phaseName?: string; silent?: boolean } =
+          event.payload as {
+            operationId: string;
+            projectName?: string;
+            phaseName?: string;
+            silent?: boolean;
+          };
+        if (payload.silent) {
+          this._silentOperations.add(payload.operationId);
+          break;
+        }
+        this._silentOperations.delete(payload.operationId);
         this._totalOperations++;
+        const projectName: string = payload.projectName ?? event.scope?.projectName ?? payload.operationId;
         this._projectByOperation.set(
           payload.operationId,
-          payload.projectName ?? event.scope?.projectName ?? payload.operationId
+          payload.phaseName ? `${projectName} (${payload.phaseName})` : projectName
         );
         break;
       }
@@ -206,14 +207,31 @@ export class DefaultInteractiveReporter implements IReporter {
           event.scope?.projectName ??
           this._projectByOperation.get(payload.operationId) ??
           payload.operationId;
+        if (this._silentOperations.has(payload.operationId)) {
+          break;
+        }
         if (payload.status === 'executing') {
           this._activeProjects.set(payload.operationId, projectName);
-        } else if (TERMINAL_STATUSES.has(payload.status)) {
-          this._activeProjects.delete(payload.operationId);
-          this._completedOperations++;
-          if (payload.status === 'failure') {
-            this._failedOperations++;
-          }
+        }
+        this._latestActivity = `${payload.status} ${projectName}`;
+        break;
+      }
+      case 'operationCompleted': {
+        const payload: { operationId: string; status: string } = event.payload as {
+          operationId: string;
+          status: string;
+        };
+        if (this._silentOperations.delete(payload.operationId)) {
+          break;
+        }
+        const projectName: string =
+          this._projectByOperation.get(payload.operationId) ??
+          event.scope?.projectName ??
+          payload.operationId;
+        this._activeProjects.delete(payload.operationId);
+        this._completedOperations++;
+        if (payload.status === 'failure') {
+          this._failedOperations++;
         }
         this._latestActivity = `${payload.status} ${projectName}`;
         break;
@@ -225,6 +243,22 @@ export class DefaultInteractiveReporter implements IReporter {
         }
         break;
       }
+      case 'messageEmitted': {
+        const payload: { severity?: string; text?: string } = event.payload as {
+          severity?: string;
+          text?: string;
+        };
+        if (payload.text !== undefined) {
+          this._latestActivity = payload.text;
+          if (
+            event.scope?.operationId === undefined &&
+            (payload.severity === 'error' || payload.severity === 'warning')
+          ) {
+            this._diagnostics.push(payload.text.trim());
+          }
+        }
+        break;
+      }
       case 'diagnosticEmitted': {
         const payload: { code?: string; severity?: string } = event.payload as {
           code?: string;
@@ -310,6 +344,9 @@ export class DefaultInteractiveReporter implements IReporter {
         `${this._color.green('✔')} ${this._commandName ?? 'rush'} succeeded — ` +
           `${this._completedOperations}/${this._totalOperations} operations`
       );
+      if (this._logPath !== undefined) {
+        lines.push(this._color.dim(`Log: ${this._logPath}`));
+      }
     } else {
       lines.push(
         `${this._color.red('✖')} ${this._commandName ?? 'rush'} failed — ${this._failedOperations} failed`
diff --git a/libraries/reporter/src/reporters/FileReporter.ts b/libraries/reporter/src/reporters/FileReporter.ts
index 017d85e9a4c..e0d9c3d62c6 100644
--- a/libraries/reporter/src/reporters/FileReporter.ts
+++ b/libraries/reporter/src/reporters/FileReporter.ts
@@ -28,6 +28,22 @@ const DEFAULT_MAX_SESSIONS: number = 20;
 const OWNER_ONLY_MODE: number = 0o600;
 const OWNER_ONLY_DIRECTORY_MODE: number = 0o700;
 const MS_PER_DAY: number = 24 * 60 * 60 * 1000;
+const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
+  'success',
+  'successWithWarnings',
+  'failure',
+  'blocked',
+  'skipped',
+  'fromCache',
+  'noOp',
+  'aborted'
+]);
+
+interface IFileOperationRecord {
+  readonly title: string;
+  readonly spoolPath?: string;
+  readonly spoolFileDescriptor?: number;
+}
 
 function getUserTempDirectoryName(): string {
   const identity: string =
@@ -127,12 +143,14 @@ export class FileReporter implements IReporter {
   private readonly _emergencyWarn: (message: string) => void;
 
   private readonly _lines: string[];
+  private readonly _operations: Map<string, IFileOperationRecord>;
   private _fileDescriptor: number | undefined;
   private _targetResolved: boolean;
   private _available: boolean;
   private _targetPath: string | undefined;
   private _latestCopyPath: string | undefined;
   private readonly _fileName: string;
+  private _nextSpoolId: number;
 
   public constructor(options: IFileReporterOptions = {}) {
     this._commonTempFolder = options.commonTempFolder;
@@ -149,11 +167,13 @@ export class FileReporter implements IReporter {
       });
 
     this._lines = [];
+    this._operations = new Map();
     this._fileDescriptor = undefined;
     this._targetResolved = false;
     this._available = false;
     this._targetPath = undefined;
     this._latestCopyPath = undefined;
+    this._nextSpoolId = 1;
 
     const timestamp: string = new Date(this._nowMs()).toISOString().replace(/[:.]/g, '-');
     this._fileName = `${timestamp}-${this._pid}-${this._actionName}.log`;
@@ -165,14 +185,16 @@ export class FileReporter implements IReporter {
   }
 
   public report(event: IReporterEventEnvelope<unknown>): void {
-    const line: string = this._formatLine(event);
-    if (this._fileDescriptor === undefined) {
-      if (!this._targetResolved) {
-        this._lines.push(line);
+    const lines: readonly string[] = this._formatEvent(event);
+    for (const line of lines) {
+      if (this._fileDescriptor === undefined) {
+        if (!this._targetResolved) {
+          this._lines.push(line);
+        }
+      } else {
+        this._writeLine(line);
       }
-      return;
     }
-    this._writeLine(line);
   }
 
   public async flushAsync(): Promise<void> {
@@ -189,6 +211,10 @@ export class FileReporter implements IReporter {
   }
 
   public async closeAsync(): Promise<void> {
+    for (const [operationId, record] of this._operations) {
+      this._writeGroupedOperation(operationId, record, 'aborted');
+    }
+    this._operations.clear();
     await this.flushAsync();
     if (this._fileDescriptor !== undefined) {
       try {
@@ -214,8 +240,136 @@ export class FileReporter implements IReporter {
       : { available: this._available };
   }
 
-  private _formatLine(event: IReporterEventEnvelope<unknown>): string {
-    return `${JSON.stringify(redactReporterEvent(event))}\n`;
+  private _formatEvent(event: IReporterEventEnvelope<unknown>): readonly string[] {
+    if (event.type === 'operationRegistered') {
+      const payload: {
+        operationId: string;
+        projectName?: string;
+        phaseName?: string;
+      } = event.payload as {
+        operationId: string;
+        projectName?: string;
+        phaseName?: string;
+      };
+      const projectName: string = payload.projectName ?? payload.operationId;
+      this._operations.set(
+        payload.operationId,
+        this._createOperationRecord(payload.phaseName ? `${projectName} (${payload.phaseName})` : projectName)
+      );
+      return [this._formatMetadata(event)];
+    }
+
+    if (event.type === 'externalOutput') {
+      const operationId: string | undefined = event.scope?.operationId;
+      const text: string = (event.payload as { text?: string }).text ?? '';
+      const operation: IFileOperationRecord | undefined =
+        operationId === undefined ? undefined : this._operations.get(operationId);
+      if (operation?.spoolFileDescriptor !== undefined) {
+        try {
+          fs.writeSync(operation.spoolFileDescriptor, text);
+        } catch (error) {
+          this._emergencyWarn(
+            `[reporter] Unable to spool grouped output for ${JSON.stringify(operationId)}: ${(error as Error).message}`
+          );
+          return [`# [${operationId} ${(event.payload as { stream?: string }).stream ?? 'stdout'}]\n`, text];
+        }
+        return [];
+      }
+      return operationId ? [`# [${operationId}]\n`, text] : [text];
+    }
+
+    if (event.type === 'operationStatusChanged') {
+      return [this._formatMetadata(event)];
+    }
+
+    if (event.type === 'operationCompleted') {
+      const payload: { operationId: string; status: string } = event.payload as {
+        operationId: string;
+        status: string;
+      };
+      const operation: IFileOperationRecord | undefined = this._operations.get(payload.operationId);
+      if (operation && TERMINAL_STATUSES.has(payload.status)) {
+        this._operations.delete(payload.operationId);
+        this._writeGroupedOperation(payload.operationId, operation, payload.status);
+        return [];
+      }
+    }
+
+    return [this._formatMetadata(event)];
+  }
+
+  private _formatMetadata(event: IReporterEventEnvelope<unknown>): string {
+    return `# ${JSON.stringify(redactReporterEvent(event))}\n`;
+  }
+
+  private _createOperationRecord(title: string): IFileOperationRecord {
+    if (this._targetPath) {
+      const spoolPath: string = `${this._targetPath}.${this._nextSpoolId++}.operation`;
+      try {
+        const spoolFileDescriptor: number = fs.openSync(spoolPath, 'w+', OWNER_ONLY_MODE);
+        return { title, spoolPath, spoolFileDescriptor };
+      } catch (error) {
+        this._emergencyWarn(
+          `[reporter] Unable to create grouped-output spool file; output will remain ungrouped: ${(error as Error).message}`
+        );
+      }
+    }
+    return { title };
+  }
+
+  private _writeGroupedOperation(operationId: string, operation: IFileOperationRecord, status: string): void {
+    this._writeOrBuffer(`\n==[ ${operation.title} ]==\n`);
+    if (operation.spoolFileDescriptor !== undefined) {
+      try {
+        fs.fsyncSync(operation.spoolFileDescriptor);
+        fs.closeSync(operation.spoolFileDescriptor);
+        if (operation.spoolPath && this._fileDescriptor !== undefined) {
+          const source: number = fs.openSync(operation.spoolPath, 'r');
+          try {
+            const buffer: Buffer = Buffer.allocUnsafe(64 * 1024);
+            let bytesRead: number;
+            let lastByte: number | undefined;
+            while ((bytesRead = fs.readSync(source, buffer, 0, buffer.length, null)) > 0) {
+              fs.writeSync(this._fileDescriptor, buffer, 0, bytesRead);
+              lastByte = buffer[bytesRead - 1];
+            }
+            if (lastByte !== undefined && lastByte !== 0x0a) {
+              this._writeLine('\n');
+            }
+          } finally {
+            fs.closeSync(source);
+          }
+        }
+      } catch (error) {
+        this._emergencyWarn(
+          `[reporter] Unable to append grouped output for ${JSON.stringify(operationId)}: ${(error as Error).message}`
+        );
+      } finally {
+        try {
+          fs.closeSync(operation.spoolFileDescriptor);
+        } catch {
+          /* It was already closed after a successful spool flush. */
+        }
+        if (operation.spoolPath) {
+          try {
+            fs.rmSync(operation.spoolPath, { force: true });
+          } catch {
+            /* Best-effort cleanup. */
+          }
+        }
+      }
+    }
+    this._writeOrBuffer(`==[ ${operationId}: ${status} ]==\n`);
+  }
+
+  private _writeOrBuffer(line: string): void {
+    if (this._fileDescriptor === undefined) {
+      if (!this._targetResolved) {
+        this._lines.push(line);
+      }
+    } else {
+      this._writeLine(line);
+    }
   }
 
   private async _ensureTargetAsync(): Promise<void> {
diff --git a/libraries/reporter/src/reporters/LegacyReporter.ts b/libraries/reporter/src/reporters/LegacyReporter.ts
index 743b33cf387..4a0db0fc52e 100644
--- a/libraries/reporter/src/reporters/LegacyReporter.ts
+++ b/libraries/reporter/src/reporters/LegacyReporter.ts
@@ -12,7 +12,8 @@ const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
   'blocked',
   'skipped',
   'fromCache',
-  'noOp'
+  'noOp',
+  'aborted'
 ]);
 
 /**
@@ -249,5 +250,4 @@ export class LegacyReporter implements IReporter {
   private _seconds(durationMs: number): string {
     return (durationMs / 1000).toFixed(2);
   }
-
 }
diff --git a/libraries/reporter/src/reporters/PlaintextReporter.ts b/libraries/reporter/src/reporters/PlaintextReporter.ts
index 0508f15bcce..9ab14687b7e 100644
--- a/libraries/reporter/src/reporters/PlaintextReporter.ts
+++ b/libraries/reporter/src/reporters/PlaintextReporter.ts
@@ -4,6 +4,7 @@
 import type { IReporterEventEnvelope } from '../events/IReporterEventEnvelope';
 import type { IReporter } from '../manager/IReporter';
 import type { PlaintextVariant } from '../config/AutomaticReporterMatrix';
+import type { ReporterLogLevel } from '../config/ReporterNames';
 import { createColorizer, type IColorizer } from './InteractiveRendering';
 
 const HEARTBEAT_INTERVAL_MS: number = 30000;
@@ -14,12 +15,14 @@ const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
   'blocked',
   'skipped',
   'fromCache',
-  'noOp'
+  'noOp',
+  'aborted'
 ]);
 
 interface IOperationRecord {
   readonly projectName: string;
   readonly phaseName?: string;
+  readonly silent: boolean;
   readonly buffer: string[];
 }
 
@@ -54,6 +57,11 @@ export interface IPlaintextReporterOptions {
    * The heartbeat interval in milliseconds. Defaults to 30000.
    */
   readonly heartbeatIntervalMs?: number;
+
+  /**
+   * The selected reporter log level. Defaults to `normal`.
+   */
+  readonly logLevel?: ReporterLogLevel;
 }
 
 /**
@@ -76,6 +84,7 @@ export class PlaintextReporter implements IReporter {
   private readonly _color: IColorizer;
   private readonly _nowMs: () => number;
   private readonly _heartbeatIntervalMs: number;
+  private readonly _logLevel: ReporterLogLevel;
 
   private _commandName: string | undefined;
   private _total: number;
@@ -83,6 +92,7 @@ export class PlaintextReporter implements IReporter {
   private _failed: number;
   private _lastOutputMs: number;
   private _atLineStart: boolean;
+  private _logPath: string | undefined;
   private readonly _operations: Map<string, IOperationRecord>;
 
   public constructor(options: IPlaintextReporterOptions) {
@@ -91,6 +101,7 @@ export class PlaintextReporter implements IReporter {
     this._color = createColorizer(options.color ?? false);
     this._nowMs = options.nowMs ?? (() => Date.now());
     this._heartbeatIntervalMs = options.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
+    this._logLevel = options.logLevel ?? 'normal';
 
     this._commandName = undefined;
     this._total = 0;
@@ -98,6 +109,7 @@ export class PlaintextReporter implements IReporter {
     this._failed = 0;
     this._lastOutputMs = 0;
     this._atLineStart = true;
+    this._logPath = undefined;
     this._operations = new Map();
   }
 
@@ -113,21 +125,33 @@ export class PlaintextReporter implements IReporter {
         break;
       }
       case 'operationRegistered': {
-        const payload: { operationId: string; projectName?: string; phaseName?: string } = event.payload as {
+        const payload: {
+          operationId: string;
+          projectName?: string;
+          phaseName?: string;
+          silent?: boolean;
+        } = event.payload as {
           operationId: string;
           projectName?: string;
           phaseName?: string;
+          silent?: boolean;
         };
         this._operations.set(payload.operationId, {
           projectName: payload.projectName ?? payload.operationId,
           phaseName: payload.phaseName,
+          silent: payload.silent === true,
           buffer: []
         });
-        this._total++;
+        if (!payload.silent) {
+          this._total++;
+        }
         break;
       }
       case 'operationStatusChanged': {
-        this._onStatusChanged(event);
+        break;
+      }
+      case 'operationCompleted': {
+        this._onOperationCompleted(event);
         break;
       }
       case 'externalOutput': {
@@ -144,6 +168,31 @@ export class PlaintextReporter implements IReporter {
         }
         break;
       }
+      case 'artifactAvailable': {
+        const payload: { role?: string; path?: string } = event.payload as {
+          role?: string;
+          path?: string;
+        };
+        if (payload.role === 'log') {
+          this._logPath = payload.path;
+        }
+        break;
+      }
+      case 'messageEmitted': {
+        if (event.scope?.operationId === undefined) {
+          const payload: { severity?: string; text?: string } = event.payload as {
+            severity?: string;
+            text?: string;
+          };
+          if (
+            payload.text &&
+            (this._logLevel !== 'quiet' || payload.severity === 'warning' || payload.severity === 'error')
+          ) {
+            this._writeRaw(payload.text.endsWith('\n') ? payload.text : `${payload.text}\n`);
+          }
+        }
+        break;
+      }
       case 'watchCycleCompleted': {
         const succeeded: boolean = (event.payload as { succeeded?: boolean }).succeeded === true;
         this._writeLine(`Watch cycle ${succeeded ? 'succeeded' : 'failed'}`);
@@ -180,7 +229,7 @@ export class PlaintextReporter implements IReporter {
     return false;
   }
 
-  private _onStatusChanged(event: IReporterEventEnvelope<unknown>): void {
+  private _onOperationCompleted(event: IReporterEventEnvelope<unknown>): void {
     const payload: { operationId: string; status: string } = event.payload as {
       operationId: string;
       status: string;
@@ -191,12 +240,21 @@ export class PlaintextReporter implements IReporter {
     if (!TERMINAL_STATUSES.has(payload.status)) {
       return;
     }
+    if (record?.silent) {
+      this._operations.delete(payload.operationId);
+      return;
+    }
 
     this._completed++;
     if (payload.status === 'failure') {
       this._failed++;
     }
 
+    if (this._logLevel === 'quiet') {
+      this._operations.delete(payload.operationId);
+      return;
+    }
+
     if (this._variant === 'detailed') {
       const phase: string = record?.phaseName ? ` (${record.phaseName})` : '';
       this._writeLine('');
@@ -238,6 +296,9 @@ export class PlaintextReporter implements IReporter {
     } else {
       this._writeLine(this._color.red(`rush ${commandName} failed (${this._failed} failed)`));
     }
+    if (this._logPath) {
+      this._writeLine(`Full log: ${this._logPath}`);
+    }
   }
 
   private _formatStatus(projectName: string, status: string): string {
diff --git a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
index ff92d80b29f..43b2e53857f 100644
--- a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
+++ b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
@@ -155,6 +155,7 @@ describe('DefaultInteractiveReporter', () => {
     reporter.report(
       ev('operationStatusChanged', { operationId: 'op1', status: 'success' }, { projectName: 'p' })
     );
+    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
     reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
     await reporter.closeAsync();
 
@@ -170,14 +171,40 @@ describe('DefaultInteractiveReporter', () => {
       color: false,
       nowMs: () => 0
     });
-    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
+    reporter.report(
+      ev('operationRegistered', {
+        operationId: 'op1',
+        projectName: 'project-a',
+        phaseName: '_phase:build'
+      })
+    );
     reporter.report(ev('operationStatusChanged', { operationId: 'op1', status: 'executing' }));
+    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
     await reporter.flushAsync();
 
-    expect(terminal.output).toContain('project-a');
+    expect(terminal.output).toContain('project-a (_phase:build)');
     expect(terminal.output).not.toContain('executing op1');
   });
 
+  it('omits silent operations from progress totals', async () => {
+    const terminal: FakeTerminal = new FakeTerminal();
+    const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
+      terminal,
+      color: false,
+      nowMs: () => 0
+    });
+    reporter.report(
+      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+    );
+    reporter.report(ev('operationStatusChanged', { operationId: 'silent', status: 'success' }));
+    reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'success' }));
+    reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
+    await reporter.closeAsync();
+
+    expect(terminal.output).toContain('0/0 operations');
+    expect(terminal.output).not.toContain('hidden');
+  });
+
   it('appends a bounded diagnostic block and log path on failure', async () => {
     const terminal: FakeTerminal = new FakeTerminal();
     const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
@@ -191,6 +218,7 @@ describe('DefaultInteractiveReporter', () => {
     reporter.report(
       ev('operationStatusChanged', { operationId: 'op1', status: 'failure' }, { projectName: 'p' })
     );
+    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
     reporter.report(ev('diagnosticEmitted', { code: 'RUSH_OPERATION_FAILED', severity: 'error' }));
     reporter.report(ev('commandResult', { commandName: 'build', succeeded: false, exitCode: 1 }));
     await reporter.closeAsync();
diff --git a/libraries/reporter/src/test/FileReporter.test.ts b/libraries/reporter/src/test/FileReporter.test.ts
index 9d5b0b7e75c..796255bd85a 100644
--- a/libraries/reporter/src/test/FileReporter.test.ts
+++ b/libraries/reporter/src/test/FileReporter.test.ts
@@ -57,7 +57,7 @@ describe('FileReporter', () => {
     });
   });
 
-  it('writes a debug NDJSON log with owner-only permissions and a latest.log pointer', async () => {
+  it('writes a grouped full-detail log with owner-only permissions and a latest.log pointer', async () => {
     await withTempDir(async (base: string) => {
       const reporter: FileReporter = new FileReporter({
         commonTempFolder: base,
@@ -65,8 +65,21 @@ describe('FileReporter', () => {
         pid: 4242,
         nowMs: () => FIXED_NOW
       });
+      await reporter.initializeAsync();
       reporter.report(ev('commandStarted', { commandName: 'build' }));
-      reporter.report(ev('externalOutput', { stream: 'stdout', text: 'Building...\n' }));
+      reporter.report(
+        ev('operationRegistered', {
+          operationId: 'project#build',
+          projectName: 'project',
+          phaseName: 'build'
+        })
+      );
+      reporter.report({
+        ...ev('externalOutput', { stream: 'stdout', text: 'Building...\n' }),
+        scope: { operationId: 'project#build' }
+      });
+      reporter.report(ev('operationStatusChanged', { operationId: 'project#build', status: 'success' }));
+      reporter.report(ev('operationCompleted', { operationId: 'project#build', status: 'success' }));
       reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
       await reporter.closeAsync();
 
@@ -76,11 +89,10 @@ describe('FileReporter', () => {
       expect(path.basename(artifact.path!)).toBe('2026-07-15T01-00-00-000Z-4242-build.log');
 
       const content: string = await fs.promises.readFile(artifact.path!, 'utf8');
-      const records: Record<string, unknown>[] = content
-        .trim()
-        .split('\n')
-        .map((line: string) => JSON.parse(line) as Record<string, unknown>);
-      expect(records.map((r) => r.type)).toEqual(['commandStarted', 'externalOutput', 'commandResult']);
+      expect(content).toContain('"type":"commandStarted"');
+      expect(content).toContain('==[ project (build) ]==');
+      expect(content).toContain('Building...\n==[ project#build: success ]==');
+      expect(content).toContain('"type":"commandResult"');
 
       const latestPath: string = path.join(base, RUSH_LOGS_DIR_NAME, LATEST_LOG_NAME);
       expect(fs.existsSync(latestPath)).toBe(true);
@@ -128,6 +140,44 @@ describe('FileReporter', () => {
     });
   });
 
+  it('preserves stdout and stderr chunk order while grouping parallel operations', async () => {
+    await withTempDir(async (base: string) => {
+      const reporter: FileReporter = new FileReporter({ commonTempFolder: base, nowMs: () => FIXED_NOW });
+      await reporter.initializeAsync();
+      for (const operationId of ['a', 'b']) {
+        reporter.report(
+          ev('operationRegistered', {
+            operationId,
+            projectName: `project-${operationId}`,
+            phaseName: 'build'
+          })
+        );
+      }
+      reporter.report({
+        ...ev('externalOutput', { stream: 'stdout', text: 'a-out\n' }),
+        scope: { operationId: 'a' }
+      });
+      reporter.report({
+        ...ev('externalOutput', { stream: 'stdout', text: 'b-out\n' }),
+        scope: { operationId: 'b' }
+      });
+      reporter.report({
+        ...ev('externalOutput', { stream: 'stderr', text: 'a-err\n' }),
+        scope: { operationId: 'a' }
+      });
+      reporter.report(ev('operationStatusChanged', { operationId: 'a', status: 'failure' }));
+      reporter.report(ev('operationCompleted', { operationId: 'a', status: 'failure' }));
+      reporter.report(ev('operationStatusChanged', { operationId: 'b', status: 'blocked' }));
+      reporter.report(ev('operationCompleted', { operationId: 'b', status: 'blocked' }));
+      await reporter.closeAsync();
+
+      const content: string = await fs.promises.readFile(reporter.getArtifact().path!, 'utf8');
+      expect(content).toContain('a-out\na-err\n==[ a: failure ]==');
+      expect(content).toContain('b-out\n==[ b: blocked ]==');
+      expect(content.indexOf('a-out')).toBeLessThan(content.indexOf('a-err'));
+    });
+  });
+
   it('excludes secret fields but keeps local-sensitive values', async () => {
     await withTempDir(async (base: string) => {
       const reporter: FileReporter = new FileReporter({ commonTempFolder: base, nowMs: () => FIXED_NOW });
diff --git a/libraries/reporter/src/test/JsonAiReporter.test.ts b/libraries/reporter/src/test/JsonAiReporter.test.ts
index f17a31e482a..9d2a8750804 100644
--- a/libraries/reporter/src/test/JsonAiReporter.test.ts
+++ b/libraries/reporter/src/test/JsonAiReporter.test.ts
@@ -123,11 +123,22 @@ describe('AiReporter', () => {
     expect(final.exitCode).toBe(1);
   });
 
+  it('uses sessionCompleted as the parser-only fallback result', () => {
+    const { final } = run([
+      ev('sessionStarted', { rushVersion: '5.178.1' }),
+      ev('sessionCompleted', { exitCode: 0 })
+    ]);
+
+    expect(final.result).toBe('succeeded');
+    expect(final.exitCode).toBe(0);
+  });
+
   it('emits a status record and a bounded final record with scope, codes, and log', () => {
     const { records, final } = run([
       ev('commandStarted', { commandName: 'build' }),
       ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }),
       ev('operationStatusChanged', { operationId: 'op1', status: 'failure' }),
+      ev('operationCompleted', { operationId: 'op1', status: 'failure' }),
       ev('diagnosticEmitted', {
         code: 'RUSH_OPERATION_FAILED',
         category: 'operation',
@@ -150,6 +161,21 @@ describe('AiReporter', () => {
     expect(final.log).toEqual({ path: '/abs/rush.log', format: 'plaintext', complete: true });
   });
 
+  it('excludes silent operations from AI result counts', () => {
+    const { final } = run([
+      ev('commandStarted', { commandName: 'build' }),
+      ev('operationRegistered', { operationId: 'hidden', projectName: 'hidden', silent: true }),
+      ev('operationStatusChanged', { operationId: 'hidden', status: 'success' }),
+      ev('operationCompleted', { operationId: 'hidden', status: 'success' }),
+      ev('operationRegistered', { operationId: 'visible', projectName: 'visible' }),
+      ev('operationStatusChanged', { operationId: 'visible', status: 'fromCache' }),
+      ev('operationCompleted', { operationId: 'visible', status: 'fromCache' }),
+      ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 })
+    ]);
+
+    expect(final.operationCounts).toEqual({ fromCache: 1 });
+  });
+
   it('caps detailed diagnostics at 20 and marks the record truncated', () => {
     const events: IReporterEventEnvelope<unknown>[] = [ev('commandStarted', { commandName: 'build' })];
     for (let i: number = 0; i < 25; i++) {
diff --git a/libraries/reporter/src/test/OperationStreamEmitter.test.ts b/libraries/reporter/src/test/OperationStreamEmitter.test.ts
index adb5e6c6a93..4eb2a3881d7 100644
--- a/libraries/reporter/src/test/OperationStreamEmitter.test.ts
+++ b/libraries/reporter/src/test/OperationStreamEmitter.test.ts
@@ -178,6 +178,8 @@ describe('reporter parity with StreamCollator', () => {
     emitter.writeOutput('op2', 'stdout', 'B2\n');
     emitter.changeStatus('op1', 'success', 100);
     emitter.changeStatus('op2', 'success', 200);
+    emitter.completeOperation('op1', 'success', 100);
+    emitter.completeOperation('op2', 'success', 200);
     emitter.completeCommand('build', true, 0);
 
     let output: string = '';
@@ -204,6 +206,7 @@ describe('reporter parity with StreamCollator', () => {
     emitter.changeStatus('op1', 'executing');
     emitter.writeOutput('op1', 'stdout', 'RAW-PROJECT-OUTPUT\n');
     emitter.changeStatus('op1', 'success', 100);
+    emitter.completeOperation('op1', 'success', 100);
     emitter.completeCommand('build', true, 0);
 
     const terminal: FakeTerminal = new FakeTerminal();
diff --git a/libraries/reporter/src/test/PlaintextReporter.test.ts b/libraries/reporter/src/test/PlaintextReporter.test.ts
index aa97c7e474a..ece5d37f8c8 100644
--- a/libraries/reporter/src/test/PlaintextReporter.test.ts
+++ b/libraries/reporter/src/test/PlaintextReporter.test.ts
@@ -46,6 +46,7 @@ describe('PlaintextReporter', () => {
     capture.reporter.report(ev('commandStarted', { commandName: 'build' }));
     capture.reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
     capture.reporter.report(ev('operationStatusChanged', { operationId: 'op1', status: 'success' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
     capture.reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
 
     // No escape sequences of any kind (no color, no cursor movement).
@@ -58,10 +59,12 @@ describe('PlaintextReporter', () => {
     capture.reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
     capture.reporter.report(ev('operationRegistered', { operationId: 'op2', projectName: 'project-b' }));
     capture.reporter.report(ev('operationStatusChanged', { operationId: 'op1', status: 'success' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
     capture.reporter.report(
       ev('diagnosticEmitted', { code: 'RUSH_INPUT_UNKNOWN_PROJECT', severity: 'warning' })
     );
     capture.reporter.report(ev('operationStatusChanged', { operationId: 'op2', status: 'failure' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op2', status: 'failure' }));
     capture.reporter.report(ev('commandResult', { commandName: 'build', succeeded: false, exitCode: 1 }));
 
     expect(capture.getOutput()).toMatchSnapshot();
@@ -78,6 +81,7 @@ describe('PlaintextReporter', () => {
       ev('externalOutput', { stream: 'stdout', text: 'Building project-a...\n' }, { operationId: 'op1' })
     );
     capture.reporter.report(ev('operationStatusChanged', { operationId: 'op1', status: 'success' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
     capture.reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
 
     expect(capture.getOutput()).toMatchSnapshot();
@@ -91,11 +95,42 @@ describe('PlaintextReporter', () => {
     capture.reporter.report(ev('externalOutput', { text: 'Building ' }, { operationId: 'op1' }));
     capture.reporter.report(ev('externalOutput', { text: 'project-a' }, { operationId: 'op1' }));
     capture.reporter.report(ev('operationStatusChanged', { operationId: 'op1', status: 'success' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
 
     expect(capture.getOutput()).toContain('Building project-a\nproject-a: success');
     expect(capture.getOutput()).not.toContain('Building \nproject-a');
   });
 
+  it('omits silent operations and exposes the full log path', () => {
+    const capture: ICapture = makeDetailed();
+    capture.reporter.report(ev('commandStarted', { commandName: 'build' }));
+    capture.reporter.report(
+      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+    );
+    capture.reporter.report(ev('operationStatusChanged', { operationId: 'silent', status: 'aborted' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'aborted' }));
+    capture.reporter.report(
+      ev('artifactAvailable', { role: 'log', path: '/abs/common/temp/rush-logs/build.log' })
+    );
+    capture.reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
+
+    expect(capture.getOutput()).toContain('0/0 operations');
+    expect(capture.getOutput()).toContain('Full log: /abs/common/temp/rush-logs/build.log');
+    expect(capture.getOutput()).not.toContain('hidden');
+  });
+
+  it('uses operationCompleted as the authoritative final outcome', () => {
+    const capture: ICapture = makeDetailed();
+    capture.reporter.report(
+      ev('operationRegistered', { operationId: 'op1', projectName: 'project-a', phaseName: 'build' })
+    );
+    capture.reporter.report(ev('operationStatusChanged', { operationId: 'op1', status: 'success' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
+
+    expect(capture.getOutput()).toContain('project-a: failure');
+    expect(capture.getOutput()).not.toContain('project-a: success');
+  });
+
   it('emits a compact heartbeat only after the interval elapses', () => {
     let now: number = 0;
     let output: string = '';
diff --git a/libraries/rush-lib/src/api/Rush.ts b/libraries/rush-lib/src/api/Rush.ts
index e75815484d6..472673f9b97 100644
--- a/libraries/rush-lib/src/api/Rush.ts
+++ b/libraries/rush-lib/src/api/Rush.ts
@@ -96,7 +96,7 @@ export class Rush {
     options = _normalizeLaunchOptions(options);
     const frontendOptions: IRushFrontendLaunchOptions = options;
 
-    if (!RushCommandLineParser.shouldRestrictConsoleOutput()) {
+    if (!options.reporter?.operationStreamEnabled && !RushCommandLineParser.shouldRestrictConsoleOutput()) {
       RushStartupBanner.logBanner(Rush.version, options.isManaged);
     }
 
diff --git a/libraries/rush-lib/src/cli/RushCommandLineParser.ts b/libraries/rush-lib/src/cli/RushCommandLineParser.ts
index ee5f79c8ee5..ea8d99c2314 100644
--- a/libraries/rush-lib/src/cli/RushCommandLineParser.ts
+++ b/libraries/rush-lib/src/cli/RushCommandLineParser.ts
@@ -8,15 +8,23 @@ import {
   type CommandLineFlagParameter,
   CommandLineHelper
 } from '@rushstack/ts-command-line';
+import {
+  createRushDiagnostic,
+  type IRushDiagnostic,
+  type IScopedReporter,
+  type LifecycleEmitter,
+  type ReporterMessageSeverity
+} from '@rushstack/rush-reporter';
 import { InternalError, AlreadyReportedError, Text } from '@rushstack/node-core-library';
 import {
   ConsoleTerminalProvider,
   Terminal,
   PrintUtilities,
   Colorize,
-  type ITerminal
+  type ITerminal,
+  type ITerminalProvider,
+  TerminalProviderSeverity
 } from '@rushstack/terminal';
-import { createRushDiagnostic, type IRushDiagnostic, type LifecycleEmitter } from '@rushstack/rush-reporter';
 
 import { RushConfiguration } from '../api/RushConfiguration';
 import { RushConstants } from '../logic/RushConstants';
@@ -67,9 +75,11 @@ import { measureAsyncFn } from '../utilities/performance';
 import { EnvironmentVariableNames } from '../api/EnvironmentConfiguration';
 import {
   _correlateRushSessionError,
+  _flushRushSessionReporterAsync,
   _getRushSessionDerivedExitStatus,
   _getRushSessionLifecycleEmitter,
   _getRushSessionReporterSourceVersion,
+  _isRushSessionOperationStreamEnabled,
   _isRushSessionErrorRepresented
 } from '../pluginFramework/RushSession';
 
@@ -84,6 +94,62 @@ export interface IRushCommandLineParserOptions {
   reporterCloseAsync?: () => Promise<void>;
 }
 
+class ReporterTerminalProvider implements ITerminalProvider {
+  public verboseEnabled: boolean = true;
+  public debugEnabled: boolean = true;
+  public readonly supportsColor: boolean = false;
+  public readonly eolCharacter: string = '\n';
+
+  private readonly _bufferedMessages: Array<{
+    severity: ReporterMessageSeverity;
+    text: string;
+  }> = [];
+  private _reporter: IScopedReporter | undefined;
+
+  public setReporter(reporter: IScopedReporter | undefined): void {
+    this._reporter = reporter;
+    if (reporter) {
+      for (const message of this._bufferedMessages.splice(0)) {
+        reporter.emitMessage({ ...message, privacy: 'local-sensitive' });
+      }
+    }
+  }
+
+  public write(data: string, severity: TerminalProviderSeverity): void {
+    if (
+      (severity === TerminalProviderSeverity.verbose && !this.verboseEnabled) ||
+      (severity === TerminalProviderSeverity.debug && !this.debugEnabled)
+    ) {
+      return;
+    }
+
+    const message: { severity: ReporterMessageSeverity; text: string } = {
+      severity: this._toReporterSeverity(severity),
+      text: data
+    };
+    if (this._reporter) {
+      this._reporter.emitMessage({ ...message, privacy: 'local-sensitive' });
+    } else {
+      this._bufferedMessages.push(message);
+    }
+  }
+
+  private _toReporterSeverity(severity: TerminalProviderSeverity): ReporterMessageSeverity {
+    switch (severity) {
+      case TerminalProviderSeverity.error:
+        return 'error';
+      case TerminalProviderSeverity.warning:
+        return 'warning';
+      case TerminalProviderSeverity.debug:
+        return 'debug';
+      case TerminalProviderSeverity.verbose:
+        return 'debug';
+      default:
+        return 'info';
+    }
+  }
+}
+
 export class RushCommandLineParser extends CommandLineParser {
   public telemetry: Telemetry | undefined;
   public rushGlobalFolder: RushGlobalFolder;
@@ -95,7 +161,7 @@ export class RushCommandLineParser extends CommandLineParser {
   private readonly _quietParameter: CommandLineFlagParameter;
   private readonly _restrictConsoleOutput: boolean = RushCommandLineParser.shouldRestrictConsoleOutput();
   private readonly _rushOptions: IRushCommandLineParserOptions;
-  private readonly _terminalProvider: ConsoleTerminalProvider;
+  private readonly _terminalProvider: ConsoleTerminalProvider | ReporterTerminalProvider;
   private readonly _terminal: Terminal;
   private readonly _autocreateBuildCommand: boolean;
   private _sessionLifecycleEmitter: LifecycleEmitter | undefined;
@@ -139,18 +205,22 @@ export class RushCommandLineParser extends CommandLineParser {
       description: 'Hide rush startup information'
     });
 
-    const terminalProvider: ConsoleTerminalProvider = new ConsoleTerminalProvider();
-    this._terminalProvider = terminalProvider;
-    const terminal: Terminal = new Terminal(this._terminalProvider);
-    this._terminal = terminal;
     this._rushOptions = this._normalizeOptions(options || {});
     const { cwd, alreadyReportedNodeTooNewError, builtInPluginConfigurations, reporter } = this._rushOptions;
+    const reporterTerminalProvider: ReporterTerminalProvider | undefined = reporter?.operationStreamEnabled
+      ? new ReporterTerminalProvider()
+      : undefined;
+    const terminalProvider: ConsoleTerminalProvider | ReporterTerminalProvider =
+      reporterTerminalProvider ?? new ConsoleTerminalProvider();
+    this._terminalProvider = terminalProvider;
+    const terminal: Terminal = new Terminal(terminalProvider);
+    this._terminal = terminal;
 
     let rushJsonFilePath: string | undefined;
     try {
       rushJsonFilePath = RushConfiguration.tryFindRushJsonLocation({
         startingFolder: cwd,
-        showVerbose: !this._restrictConsoleOutput
+        showVerbose: !this._restrictConsoleOutput && !reporter?.operationStreamEnabled
       });
 
       initializeDotEnv(terminal, rushJsonFilePath);
@@ -175,6 +245,7 @@ export class RushCommandLineParser extends CommandLineParser {
       terminalProvider,
       reporter
     });
+    reporterTerminalProvider?.setReporter(this.rushSession.getReporter());
     this.pluginManager = new PluginManager({
       rushSession: this.rushSession,
       rushConfiguration: this.rushConfiguration,
@@ -255,13 +326,15 @@ export class RushCommandLineParser extends CommandLineParser {
 
   public override async executeAsync(args?: string[]): Promise<boolean> {
     // debugParameter will be correctly parsed during super.executeAsync(), so manually parse here.
-    const passThroughSeparatorIndex: number = process.argv.indexOf('--', 2);
-    const rushArgv: string[] =
-      passThroughSeparatorIndex < 0
-        ? process.argv.slice(2)
-        : process.argv.slice(2, passThroughSeparatorIndex);
-    this._terminalProvider.verboseEnabled = this._terminalProvider.debugEnabled =
-      rushArgv.includes('--debug') || rushArgv.includes('-d');
+    if (this._terminalProvider instanceof ConsoleTerminalProvider) {
+      const passThroughSeparatorIndex: number = process.argv.indexOf('--', 2);
+      const rushArgv: string[] =
+        passThroughSeparatorIndex < 0
+          ? process.argv.slice(2)
+          : process.argv.slice(2, passThroughSeparatorIndex);
+      this._terminalProvider.verboseEnabled = this._terminalProvider.debugEnabled =
+        rushArgv.includes('--debug') || rushArgv.includes('-d');
+    }
 
     this._sessionLifecycleEmitter = _getRushSessionLifecycleEmitter(this.rushSession);
     if (this._sessionLifecycleEmitter) {
@@ -596,15 +669,29 @@ export class RushCommandLineParser extends CommandLineParser {
       const message: string = Text.splitByNewLines(PrintUtilities.wrapWords(prefix + error.message))
         .map((line) => Colorize.red(line))
         .join('\n');
-      // eslint-disable-next-line no-console
-      console.error(`\n${message}`);
+      if (
+        (rushSession && _isRushSessionOperationStreamEnabled(rushSession)) ||
+        this._rushOptions.reporter?.operationStreamEnabled
+      ) {
+        this._terminal.writeErrorLine(message);
+      } else {
+        // eslint-disable-next-line no-console
+        console.error(`\n${message}`);
+      }
     }
 
     if (this._debugParameter.value) {
       // If catchSyncErrors() called this, then show a call stack similar to what Node.js
       // would show for an uncaught error
-      // eslint-disable-next-line no-console
-      console.error(`\n${error.stack}`);
+      if (
+        (rushSession && _isRushSessionOperationStreamEnabled(rushSession)) ||
+        this._rushOptions.reporter?.operationStreamEnabled
+      ) {
+        this._terminal.writeErrorLine(error.stack ?? error.message);
+      } else {
+        // eslint-disable-next-line no-console
+        console.error(`\n${error.stack}`);
+      }
     }
 
     this._emitReporterCompletion(_getNumericProcessExitCode(1));
@@ -629,18 +716,15 @@ export class RushCommandLineParser extends CommandLineParser {
         ? this.telemetry.ensureFlushedAsync()
         : undefined;
 
-    if (this._rushOptions.reporterCloseAsync || telemetryFlushAsync) {
-      const pendingFlushes: Promise<unknown>[] = [];
-      if (this._rushOptions.reporterCloseAsync) {
-        pendingFlushes.push(this._closeReporterAsync());
-      }
-      if (telemetryFlushAsync) {
-        pendingFlushes.push(telemetryFlushAsync);
-      }
-      void Promise.allSettled(pendingFlushes).then(handleExit);
-    } else {
-      handleExit();
+    const pendingFlushes: Promise<unknown>[] = [
+      this._rushOptions.reporterCloseAsync
+        ? this._closeReporterAsync()
+        : _flushRushSessionReporterAsync(rushSession)
+    ];
+    if (telemetryFlushAsync) {
+      pendingFlushes.push(telemetryFlushAsync);
     }
+    void Promise.allSettled(pendingFlushes).then(handleExit);
   }
 
   private _closeReporterAsync(): Promise<void> {
diff --git a/libraries/rush-lib/src/cli/actions/BaseRushAction.ts b/libraries/rush-lib/src/cli/actions/BaseRushAction.ts
index 62222ba7d76..06215cb8ed8 100644
--- a/libraries/rush-lib/src/cli/actions/BaseRushAction.ts
+++ b/libraries/rush-lib/src/cli/actions/BaseRushAction.ts
@@ -4,7 +4,7 @@
 import * as path from 'node:path';
 
 import { CommandLineAction, type ICommandLineActionOptions } from '@rushstack/ts-command-line';
-import { LockFile } from '@rushstack/node-core-library';
+import { AlreadyReportedError, LockFile } from '@rushstack/node-core-library';
 import { Colorize, type ITerminal } from '@rushstack/terminal';
 import type { IScopedReporter } from '@rushstack/rush-reporter';
 
@@ -14,6 +14,7 @@ import { RushCommandLineParser } from '../RushCommandLineParser';
 import { Utilities } from '../../utilities/Utilities';
 import type { RushGlobalFolder } from '../../api/RushGlobalFolder';
 import type { RushSession } from '../../pluginFramework/RushSession';
+import { _isRushSessionOperationStreamEnabled } from '../../pluginFramework/RushSession';
 import type { IRushCommand } from '../../pluginFramework/RushLifeCycle';
 import { measureAsyncFn } from '../../utilities/performance';
 
@@ -72,12 +73,18 @@ export abstract class BaseConfiglessRushAction extends CommandLineAction impleme
           this.terminal.writeLine(
             Colorize.red(`Another Rush command is already running in this repository.`)
           );
+          if (_isRushSessionOperationStreamEnabled(this.rushSession)) {
+            throw new AlreadyReportedError();
+          }
           process.exit(1);
         }
       }
     }
 
-    if (!RushCommandLineParser.shouldRestrictConsoleOutput()) {
+    if (
+      !RushCommandLineParser.shouldRestrictConsoleOutput() &&
+      !_isRushSessionOperationStreamEnabled(this.rushSession)
+    ) {
       this.terminal.write(`Starting "rush ${this.actionName}"\n`);
     }
 
diff --git a/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts b/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts
index 4b7e38eb872..7413b6f4ef3 100644
--- a/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts
+++ b/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts
@@ -6,7 +6,14 @@ import { once } from 'node:events';
 import type { AsyncSeriesHook } from 'tapable';
 
 import { AlreadyReportedError } from '@rushstack/node-core-library';
-import { type ITerminal, Terminal, Colorize, StdioWritable } from '@rushstack/terminal';
+import {
+  type ITerminal,
+  Terminal,
+  Colorize,
+  StdioWritable,
+  CallbackWritable,
+  NoOpTerminalProvider
+} from '@rushstack/terminal';
 import type {
   CommandLineFlagParameter,
   CommandLineParameter,
@@ -62,6 +69,7 @@ import { IgnoredParametersPlugin } from '../../logic/operations/IgnoredParameter
 import { DebugHashesPlugin } from '../../logic/operations/DebugHashesPlugin';
 import { measureAsyncFn, measureFn } from '../../utilities/performance';
 import { attachReporterOperationEventSink } from '../../logic/operations/ReporterOperationEventSink';
+import { _isRushSessionOperationStreamEnabled } from '../../pluginFramework/RushSession';
 
 const PERF_PREFIX: 'rush:phasedScriptAction' = 'rush:phasedScriptAction';
 
@@ -387,6 +395,9 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
 
     const hooks: PhasedCommandHooks = this.hooks;
     const terminal: ITerminal = this._terminal;
+    const presentationTerminal: ITerminal = _isRushSessionOperationStreamEnabled(this.rushSession)
+      ? new Terminal(new NoOpTerminalProvider())
+      : terminal;
 
     // if this is parallelizable, then use the value from the flag (undefined or a number),
     // if parallelism is not enabled, then restrict to 1 core
@@ -414,7 +425,7 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
           /* webpackChunkName: 'ConsoleTimelinePlugin' */
           '../../logic/operations/ConsoleTimelinePlugin'
         );
-        new ConsoleTimelinePlugin(terminal).apply(this.hooks);
+        new ConsoleTimelinePlugin(presentationTerminal).apply(this.hooks);
       }
 
       const diagnosticDir: string | undefined = this._nodeDiagnosticDirParameter.value;
@@ -425,7 +436,7 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
       }
 
       // Enable the standard summary
-      new OperationResultSummarizerPlugin(terminal).apply(this.hooks);
+      new OperationResultSummarizerPlugin(presentationTerminal).apply(this.hooks);
     });
 
     const { hooks: sessionHooks } = this.rushSession;
@@ -597,7 +608,7 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
       const [getInputsSnapshotAsync, initialSnapshot] = await measureAsyncFn(
         `${PERF_PREFIX}:analyzeRepoState`,
         async () => {
-          terminal.write('Analyzing repo state... ');
+          presentationTerminal.write('Analyzing repo state... ');
           const repoStateStopwatch: Stopwatch = new Stopwatch();
           repoStateStopwatch.start();
 
@@ -614,8 +625,8 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
             : undefined;
 
           repoStateStopwatch.stop();
-          terminal.writeLine(`DONE (${repoStateStopwatch.toString()})`);
-          terminal.writeLine();
+          presentationTerminal.writeLine(`DONE (${repoStateStopwatch.toString()})`);
+          presentationTerminal.writeLine();
           return [innerGetInputsSnapshotAsync, innerInitialSnapshot];
         }
       );
@@ -643,7 +654,11 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
       const graphOptions: IOperationGraphOptions = {
         quietMode: isQuietMode,
         debugMode: this.parser.isDebug,
-        destinations: [StdioWritable.instance],
+        destinations: [
+          _isRushSessionOperationStreamEnabled(this.rushSession)
+            ? new CallbackWritable({ onWriteChunk: () => undefined })
+            : StdioWritable.instance
+        ],
         parallelism,
         maxParallelism,
         allowOversubscription: this._allowOversubscription,
@@ -669,14 +684,14 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
       await measureAsyncFn(`${PERF_PREFIX}:executionManager`, async () => {
         await hooks.onGraphCreatedAsync.promise(graph, graphContext);
       });
-      attachReporterOperationEventSink(graph, this.rushSession, this.actionName);
+      attachReporterOperationEventSink(graph, this.rushSession, this.actionName, isWatch);
 
       const executeOptions: IExecuteOperationsOptions = {
         graph,
         ignoreHooks: !!this._ignoreHooksParameter.value,
         isWatch,
         stopwatch,
-        terminal
+        terminal: presentationTerminal
       };
 
       const initialIterationOptions: IOperationGraphIterationOptions = {
@@ -701,8 +716,9 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
           rushConfiguration: this.rushConfiguration,
           graph,
           initialSnapshot,
-          terminal,
-          debounceMs: this._watchDebounceMs
+          terminal: presentationTerminal,
+          debounceMs: this._watchDebounceMs,
+          renderStatusInPlace: !_isRushSessionOperationStreamEnabled(this.rushSession)
         });
         watcher.clearStatus();
 
diff --git a/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts b/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts
index 6f1184c7dde..541ab69a78e 100644
--- a/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts
+++ b/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts
@@ -143,6 +143,36 @@ describe('RushCommandLineParser', () => {
           }
           expect(reporterSink.inputs.some(({ type }) => type === 'externalOutput')).toBe(false);
         });
+
+        it('makes the opted-in reporter stream the sole visible operation writer', async () => {
+          const reporterSink: CapturingReporterSink = new CapturingReporterSink();
+          const stdoutSpy: jest.SpiedFunction<typeof process.stdout.write> = jest
+            .spyOn(process.stdout, 'write')
+            .mockImplementation(() => true);
+          const stderrSpy: jest.SpiedFunction<typeof process.stderr.write> = jest
+            .spyOn(process.stderr, 'write')
+            .mockImplementation(() => true);
+          try {
+            const { parser } = await getCommandLineParserInstanceAsync(
+              'basicAndRunBuildActionRepo',
+              'build',
+              {
+                eventSink: reporterSink,
+                sessionId: 'parser-visible-cutover',
+                operationStreamEnabled: true
+              }
+            );
+
+            await expect(parser.executeAsync()).resolves.toEqual(true);
+
+            expect(stdoutSpy).not.toHaveBeenCalled();
+            expect(stderrSpy).not.toHaveBeenCalled();
+            expect(reporterSink.inputs.some(({ type }) => type === 'operationCompleted')).toBe(true);
+          } finally {
+            stdoutSpy.mockRestore();
+            stderrSpy.mockRestore();
+          }
+        });
       });
 
       describe("'custom-output' action", () => {
diff --git a/libraries/rush-lib/src/logic/ProjectWatcher.ts b/libraries/rush-lib/src/logic/ProjectWatcher.ts
index 0e0c9adb877..f734043e193 100644
--- a/libraries/rush-lib/src/logic/ProjectWatcher.ts
+++ b/libraries/rush-lib/src/logic/ProjectWatcher.ts
@@ -23,6 +23,7 @@ export interface IProjectWatcherOptions {
   debounceMs: number;
   rushConfiguration: RushConfiguration;
   terminal: ITerminal;
+  renderStatusInPlace?: boolean;
   /** Initial inputs snapshot; required so watcher can enumerate nested folders immediately */
   initialSnapshot: IInputsSnapshot;
 }
@@ -70,6 +71,7 @@ export class ProjectWatcher {
   private readonly _rushConfiguration: RushConfiguration;
   private readonly _terminal: ITerminal;
   private readonly _graph: IOperationGraph;
+  private readonly _renderStatusInPlace: boolean;
 
   private _repoRoot: string | undefined;
   private _watchers: Map<string, fs.FSWatcher> | undefined;
@@ -84,11 +86,19 @@ export class ProjectWatcher {
   private _onStdinDataBound: ((chunk: Buffer | string) => void) | undefined;
 
   public constructor(options: IProjectWatcherOptions) {
-    const { graph, debounceMs, rushConfiguration, terminal, initialSnapshot } = options;
+    const {
+      graph,
+      debounceMs,
+      rushConfiguration,
+      terminal,
+      initialSnapshot,
+      renderStatusInPlace = true
+    } = options;
     this._graph = graph;
     this._debounceMs = debounceMs;
     this._rushConfiguration = rushConfiguration;
     this._terminal = terminal;
+    this._renderStatusInPlace = renderStatusInPlace;
     this._lastSnapshot = initialSnapshot; // Seed snapshot
 
     const gitPath: string = new Git(rushConfiguration).getGitPathOrThrow();
@@ -162,7 +172,7 @@ export class ProjectWatcher {
       lines.push(` keys(active): ${KEYBIND_HELP}`);
       statusLines.push(...lines.map((l) => `  ${l}`));
     }
-    if (graph.status !== OperationStatus.Executing) {
+    if (this._renderStatusInPlace && graph.status !== OperationStatus.Executing) {
       // If rendering during execution, don't try to clean previous output.
       if (this._renderedStatusLines > 0) {
         readline.cursorTo(process.stdout, 0);
diff --git a/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts b/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts
index 87e347f7641..4a90ed12710 100644
--- a/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts
+++ b/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts
@@ -19,7 +19,7 @@ import {
 import type { IOperationExecutionResult } from './IOperationExecutionResult';
 import type { IOperationGraphEventSink, IOperationActivityOptions } from './OperationEventSink';
 import type { Operation } from './Operation';
-import { OperationStatus } from './OperationStatus';
+import { OperationStatus, SUCCESS_STATUSES } from './OperationStatus';
 import type { OperationGraph } from './OperationGraph';
 
 interface IReporterOperation {
@@ -45,10 +45,12 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
 
   private readonly _operationsByLegacyId: Map<string, IReporterOperation> = new Map();
   private readonly _diagnosedOperations: Set<string> = new Set();
+  private readonly _commandName: string;
   private readonly _rushSession: RushSession;
 
   public constructor(rushSession: RushSession, commandName: string, operations: Iterable<Operation>) {
     this._rushSession = rushSession;
+    this._commandName = commandName;
     const operationsByReporterId: Map<string, IReporterOperation> = new Map();
 
     for (const operation of operations) {
@@ -112,6 +114,10 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
     return this._operationsByLegacyId.size > 0;
   }
 
+  public get operationStreamEnabled(): boolean {
+    return this.onOperationCompleted !== undefined;
+  }
+
   public onOperationRegistered(operationId: string, silent: boolean): void {
     const operation: IReporterOperation | undefined = this._operationsByLegacyId.get(operationId);
     if (!operation) {
@@ -206,6 +212,27 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
     }
   }
 
+  public onActivity(text: string, options: IOperationActivityOptions = {}): void {
+    if (!this.operationStreamEnabled) {
+      return;
+    }
+    const operation: IReporterOperation | undefined = options.operationId
+      ? this._operationsByLegacyId.get(options.operationId)
+      : undefined;
+    this._rushSession
+      .getReporter({
+        commandName: this._commandName,
+        operationId: operation?.operationId,
+        projectName: operation?.projectName,
+        phaseName: operation?.phaseName
+      })
+      ?.emitMessage({
+        severity: options.stderr ? 'warning' : 'info',
+        text,
+        privacy: 'local-sensitive'
+      });
+  }
+
   private _onOperationChunk(operationId: string, chunk: ITerminalChunk): void {
     const operation: IReporterOperation | undefined = this._operationsByLegacyId.get(operationId);
     if (!operation?.streamEmitter) {
@@ -312,7 +339,8 @@ class CompositeOperationGraphEventSink implements IOperationGraphEventSink {
 export function attachReporterOperationEventSink(
   graph: OperationGraph,
   rushSession: RushSession,
-  commandName: string
+  commandName: string,
+  isWatch: boolean = false
 ): void {
   const reporterSink: ReporterOperationEventSink = new ReporterOperationEventSink(
     rushSession,
@@ -326,6 +354,20 @@ export function attachReporterOperationEventSink(
   graph.eventSink = graph.eventSink
     ? new CompositeOperationGraphEventSink(graph.eventSink, reporterSink)
     : reporterSink;
+
+  if (isWatch && reporterSink.operationStreamEnabled) {
+    const lifecycleEmitter: LifecycleEmitter | undefined = _getRushSessionLifecycleEmitter(rushSession, {
+      commandName
+    });
+    lifecycleEmitter &&
+      graph.hooks.afterExecuteIterationAsync.tapPromise(
+        'RushReporterWatchCycle',
+        async (status: OperationStatus) => {
+          lifecycleEmitter.emitWatchCycleCompleted({ succeeded: SUCCESS_STATUSES.has(status) });
+          return status;
+        }
+      );
+  }
 }
 
 function _toReporterStatus(status: OperationStatus): ReporterOperationStatus {
diff --git a/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts b/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts
index 90e77890cea..8397da555e1 100644
--- a/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts
+++ b/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts
@@ -555,6 +555,103 @@ describe('OperationGraph event sink (dual-emit)', () => {
     );
   });
 
+  it('emits failure and blocked outcomes for a dependency chain', async () => {
+    const reporterSink: CapturingReporterSink = new CapturingReporterSink();
+    const rushSession: RushSession = new RushSession({
+      terminalProvider: new StringBufferTerminalProvider(),
+      getIsDebugMode: () => false,
+      reporter: {
+        eventSink: reporterSink,
+        sessionId: 'failure-and-blocked',
+        operationStreamEnabled: true
+      }
+    });
+    const failing: Operation = createOperation(
+      'failing',
+      new MockOperationRunner('failing', async () => OperationStatus.Failure),
+      mockPhase,
+      '@scope/failing'
+    );
+    const blocked: Operation = createOperation(
+      'blocked',
+      new MockOperationRunner('blocked', async () => OperationStatus.Success),
+      mockPhase,
+      '@scope/blocked'
+    );
+    blocked.addDependency(failing);
+    const graph: OperationGraph = new OperationGraph(
+      new Set([failing, blocked]),
+      createGraphOptions(mockWritable, false)
+    );
+
+    attachReporterOperationEventSink(graph, rushSession, 'build');
+    await graph.executeAsync({});
+
+    const completions: string[] = reporterSink.inputs
+      .filter(({ type }) => type === 'operationCompleted')
+      .map(({ payload }) => (payload as { status: string }).status);
+    expect(completions).toEqual(expect.arrayContaining(['failure', 'blocked']));
+    expect(reporterSink.inputs).toContainEqual(
+      expect.objectContaining({
+        type: 'diagnosticEmitted',
+        payload: expect.objectContaining({ code: 'RUSH_OPERATION_FAILED' })
+      })
+    );
+  });
+
+  it('emits aborted outcomes for a cancelled iteration', async () => {
+    const reporterSink: CapturingReporterSink = new CapturingReporterSink();
+    const rushSession: RushSession = new RushSession({
+      terminalProvider: new StringBufferTerminalProvider(),
+      getIsDebugMode: () => false,
+      reporter: {
+        eventSink: reporterSink,
+        sessionId: 'cancelled-iteration',
+        operationStreamEnabled: true
+      }
+    });
+    const graph: OperationGraph = new OperationGraph(
+      new Set([createOperation('cancelled', new MockOperationRunner('cancelled'))]),
+      createGraphOptions(mockWritable, false)
+    );
+    graph.hooks.beforeExecuteIterationAsync.tap('cancel', () => OperationStatus.Aborted);
+
+    attachReporterOperationEventSink(graph, rushSession, 'build');
+    await graph.executeAsync({});
+
+    expect(reporterSink.inputs).toContainEqual(
+      expect.objectContaining({
+        type: 'operationCompleted',
+        payload: expect.objectContaining({ status: 'aborted' })
+      })
+    );
+  });
+
+  it('emits a watch-cycle result after each opted-in iteration', async () => {
+    const reporterSink: CapturingReporterSink = new CapturingReporterSink();
+    const rushSession: RushSession = new RushSession({
+      terminalProvider: new StringBufferTerminalProvider(),
+      getIsDebugMode: () => false,
+      reporter: {
+        eventSink: reporterSink,
+        sessionId: 'watch-cycle',
+        operationStreamEnabled: true
+      }
+    });
+    const graph: OperationGraph = new OperationGraph(
+      new Set([createOperation('watch', new MockOperationRunner('watch'))]),
+      createGraphOptions(mockWritable, false)
+    );
+
+    attachReporterOperationEventSink(graph, rushSession, 'build', true);
+    await graph.executeAsync({});
+
+    expect(reporterSink.inputs.at(-1)).toMatchObject({
+      type: 'watchCycleCompleted',
+      payload: { succeeded: true }
+    });
+  });
+
   it('does not attach an operation adapter when the session has no reporter sink', () => {
     const rushSession: RushSession = new RushSession({
       terminalProvider: new StringBufferTerminalProvider(),
diff --git a/libraries/rush-lib/src/pluginFramework/RushSession.ts b/libraries/rush-lib/src/pluginFramework/RushSession.ts
index 9525b92dc43..4483f6a3115 100644
--- a/libraries/rush-lib/src/pluginFramework/RushSession.ts
+++ b/libraries/rush-lib/src/pluginFramework/RushSession.ts
@@ -61,6 +61,13 @@ export interface IRushSessionReporterOptions {
    * @internal
    */
   readonly operationStreamEnabled?: boolean;
+
+  /**
+   * Flushes and closes the frontend-owned reporters before an explicit process exit.
+   *
+   * @internal
+   */
+  readonly flushAsync?: () => Promise<void>;
 }
 
 /**
@@ -494,6 +501,24 @@ export function _getRushSessionOperationStreamEmitter(
     : undefined;
 }
 
+/**
+ * Returns whether the frontend enabled reporter-owned operation presentation.
+ *
+ * @internal
+ */
+export function _isRushSessionOperationStreamEnabled(rushSession: RushSession): boolean {
+  return _getSessionState(rushSession).options.reporter?.operationStreamEnabled === true;
+}
+
+/**
+ * Flushes the frontend-owned reporter host, when available.
+ *
+ * @internal
+ */
+export function _flushRushSessionReporterAsync(rushSession: RushSession): Promise<void> {
+  return _getSessionState(rushSession).options.reporter?.flushAsync?.() ?? Promise.resolve();
+}
+
 /**
  * Returns the current allowlisted reporter telemetry projection.
  *

From 93faca8513fc928383e59882a07f740556c57aba Mon Sep 17 00:00:00 2001
From: TheLarkInn <TheLarkInn@users.noreply.github.com>
Date: Fri, 28 Aug 2026 08:35:28 +0000
Subject: [PATCH 2/5] Harden reporter demo integration

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d6318e80-5da9-4858-a147-817e8692f10e
---
 apps/rush/src/test/RushReporterHost.test.ts   |  80 +++++++--
 .../src/test/sandbox/reporter-demo/README.md  |  10 +-
 .../src/test/sandbox/reporter-demo/run.mjs    | 158 ++++++++++++++++--
 common/reviews/api/rush-reporter.api.md       |   3 +
 .../reporter/src/reporters/AiReporter.ts      |  59 ++++++-
 .../reporter/src/reporters/FileReporter.ts    | 116 +++++++++----
 .../src/reporters/PlaintextReporter.ts        | 126 +++++++++++++-
 .../reporter/src/test/FileReporter.test.ts    |  27 +++
 .../reporter/src/test/JsonAiReporter.test.ts  |  21 +++
 .../src/test/PlaintextReporter.test.ts        |  16 ++
 .../cli/scriptActions/PhasedScriptAction.ts   |   2 +-
 11 files changed, 545 insertions(+), 73 deletions(-)

diff --git a/apps/rush/src/test/RushReporterHost.test.ts b/apps/rush/src/test/RushReporterHost.test.ts
index abd6884bbc2..ad330d071fd 100644
--- a/apps/rush/src/test/RushReporterHost.test.ts
+++ b/apps/rush/src/test/RushReporterHost.test.ts
@@ -415,21 +415,24 @@ describe(resolveRushReporterSelection.name, () => {
     expect(resolve(['build', '--reporter=default'], {}, true).reporter).toBe('default');
   });
 
-  it('parses output targets and preserves command-specific --json independently', () => {
+  it('preserves command-specific --json as the sole stdout owner', () => {
+    expect(() => resolve(['list', '--json', '--reporter=json'])).toThrow(
+      /command-specific --json output owns stdout/
+    );
+
     const selection: IRushReporterSelection = resolve(
-      [
-        'list',
-        '--json',
-        '--reporter=json',
-        '--output=file://./rush.log?logLevel=debug',
-        '--output=json://./events.jsonl'
-      ],
+      ['list', '--json', '--output=file://./rush.log?logLevel=debug', '--output=json://./events.jsonl'],
       {},
-      false
+      false,
+      true
     );
 
-    expect(selection.commandJson).toBe(true);
-    expect(selection.reporter).toBe('json');
+    expect(selection).toMatchObject({
+      commandJson: true,
+      reporter: 'file',
+      enabled: true,
+      reason: 'repository experiment'
+    });
     expect(selection.outputs).toEqual([
       {
         reporter: 'file',
@@ -442,6 +445,21 @@ describe(resolveRushReporterSelection.name, () => {
         params: {}
       }
     ]);
+    expect(resolve(['list', '--json', '--reporter=file']).reporter).toBe('file');
+  });
+
+  it('forces legacy selection for an incompatible Rush engine', () => {
+    expect(
+      resolveRushReporterSelection({
+        argv: ['build', '--reporter=json'],
+        env: {},
+        forceLegacy: true
+      })
+    ).toMatchObject({
+      reporter: 'legacy',
+      enabled: false,
+      reporterControlsOwnedByFrontend: true
+    });
   });
 
   it('surfaces unsupported and incomplete controls with actionable errors', () => {
@@ -592,4 +610,44 @@ describe(initializeRushReporterHostAsync.name, () => {
       await fs.promises.rm(directory, { recursive: true, force: true });
     }
   });
+
+  it('publishes a completed artifact before the final AI record', async () => {
+    const directory: string = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'rush-ai-artifact-'));
+    let stdoutText: string = '';
+    try {
+      const initialized = await initializeRushReporterHostAsync({
+        argv: ['build', '--reporter=ai'],
+        env: {},
+        commonTempFolder: directory,
+        actionName: 'build',
+        stdout: {
+          isTTY: false,
+          write: (text: string) => {
+            stdoutText += text;
+          }
+        }
+      });
+
+      emitCommandStarted(initialized.sink);
+      initialized.sink.emit({
+        protocolVersion: { major: 1, minor: 1 },
+        sessionId: 'session',
+        source: { packageName: '@microsoft/rush-lib', packageVersion: '5.178.1' },
+        privacy: 'public',
+        type: 'commandResult',
+        payload: { commandName: 'build', succeeded: true, exitCode: 0 }
+      });
+      await initialized.closeAsync();
+
+      const finalRecord: { log?: { complete?: boolean; path?: string } } = JSON.parse(
+        stdoutText.trim().split('\n').at(-1)!
+      );
+      expect(finalRecord.log).toMatchObject({
+        complete: true,
+        path: initialized.logArtifact?.path
+      });
+    } finally {
+      await fs.promises.rm(directory, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/apps/rush/src/test/sandbox/reporter-demo/README.md b/apps/rush/src/test/sandbox/reporter-demo/README.md
index 39eeccdd4fb..b28e69da7dc 100644
--- a/apps/rush/src/test/sandbox/reporter-demo/README.md
+++ b/apps/rush/src/test/sandbox/reporter-demo/README.md
@@ -8,8 +8,11 @@ node apps/rush/src/test/sandbox/reporter-demo/run.mjs
 ```
 
 The script runs the same `rush build --only @rushstack/rush-reporter` operation stream through legacy,
-plaintext, JSON, and AI modes. It verifies JSON/AI payload-only stdout, confirms the plaintext result
-contains an existing absolute full-log path, and writes captured stdout/stderr files to a temporary folder.
+plaintext, JSON, AI, file, and quiet modes, plus parser failure, help, and command-specific JSON cases.
+It verifies payload-only machine stdout, one visible writer, ordered/lossless plaintext grouping from a
+same-invocation JSON sidecar, final artifact completeness, owner-only log permissions, failure flushing,
+AI parser-error context, command-JSON ownership, and the `RUSH_REPORTER=legacy` rollback transcript. Captured
+stdout/stderr files are written to a temporary folder.
 
 For an individual invocation:
 
@@ -17,7 +20,10 @@ For an individual invocation:
 node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=plaintext
 node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=json --log-level=debug
 node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=ai
+node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=file
+node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=plaintext --log-level=quiet
 RUSH_REPORTER=legacy node apps/rush/bin/rush build --only @rushstack/rush-reporter --reporter=json
+node apps/rush/bin/rush list --json --reporter=file
 ```
 
 Repositories can opt in without a command-line flag by setting `"useRushReporter": true` in
diff --git a/apps/rush/src/test/sandbox/reporter-demo/run.mjs b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
index 0cf345a6314..519562ab5fc 100644
--- a/apps/rush/src/test/sandbox/reporter-demo/run.mjs
+++ b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
@@ -10,7 +10,7 @@ const rushBin = path.join(repoRoot, 'apps', 'rush', 'bin', 'rush');
 const outputFolder = fs.mkdtempSync(path.join(os.tmpdir(), 'rush-reporter-demo-'));
 const commonArgs = ['build', '--only', '@rushstack/rush-reporter'];
 
-function run(name, args, env = {}) {
+function run(name, args, env = {}, expectedStatus = 0) {
   const result = spawnSync(process.execPath, [rushBin, ...args], {
     cwd: repoRoot,
     env: { ...process.env, ...env },
@@ -18,34 +18,166 @@ function run(name, args, env = {}) {
   });
   fs.writeFileSync(path.join(outputFolder, `${name}.stdout`), result.stdout);
   fs.writeFileSync(path.join(outputFolder, `${name}.stderr`), result.stderr);
-  if (result.status !== 0) {
-    throw new Error(`${name} failed with exit code ${result.status}\n${result.stderr}`);
+  if (result.status !== expectedStatus) {
+    throw new Error(
+      `${name} exited with ${result.status}; expected ${expectedStatus}\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`
+    );
   }
-  return result.stdout;
+  return result;
 }
 
 run('warmup', commonArgs);
-const legacy = run('legacy', commonArgs);
-const rollback = run('rollback', [...commonArgs, '--reporter=json'], { RUSH_REPORTER: 'legacy' });
+const legacy = run('legacy', commonArgs).stdout;
+const rollback = run('rollback', [...commonArgs, '--reporter=json'], { RUSH_REPORTER: 'legacy' }).stdout;
 const normalizeDurations = (text) => text.replace(/\d+\.\d+ seconds/g, '<time> seconds');
 if (normalizeDurations(legacy) !== normalizeDurations(rollback)) {
   throw new Error('RUSH_REPORTER=legacy did not reproduce the feature-off output.');
 }
-const plaintext = run('plaintext', [...commonArgs, '--reporter=plaintext']);
-const json = run('json', [...commonArgs, '--reporter=json', '--log-level=debug']);
-const ai = run('ai', [...commonArgs, '--reporter=ai']);
+const plaintextEventsPath = path.join(outputFolder, 'plaintext-events.jsonl');
+const plaintext = run('plaintext', [
+  ...commonArgs,
+  '--reporter=plaintext',
+  `--output=json://${plaintextEventsPath}?logLevel=debug`
+]).stdout;
+const json = run('json', [...commonArgs, '--reporter=json', '--log-level=debug']).stdout;
+const ai = run('ai', [...commonArgs, '--reporter=ai']).stdout;
+const file = run('file', [...commonArgs, '--reporter=file']);
+const quiet = run('quiet', [...commonArgs, '--reporter=plaintext', '--log-level=quiet']).stdout;
+const failureJson = run(
+  'failure-json',
+  ['build', '--only', '@rushstack/does-not-exist', '--reporter=json'],
+  {},
+  1
+).stdout;
+const failureAi = run(
+  'failure-ai',
+  ['build', '--only', '@rushstack/does-not-exist', '--reporter=ai'],
+  {},
+  1
+).stdout;
+const flagOffHelp = run('help-flag-off', ['--help']).stdout;
+const help = run('help', ['--help', '--reporter=json'], { RUSH_REPORTER: 'legacy' }).stdout;
+const commandJson = run('command-json', ['list', '--json', '--reporter=file']);
+const commandJsonConflict = run('command-json-conflict', ['list', '--json', '--reporter=json'], {}, 1);
 
-for (const line of json.split('\n').filter(Boolean)) {
-  JSON.parse(line);
+function parseNdjson(text, name) {
+  if (text.includes('\u001b')) {
+    throw new Error(`${name} stdout contains terminal control sequences.`);
+  }
+  return text
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
 }
-for (const line of ai.split('\n').filter(Boolean)) {
-  JSON.parse(line);
+
+const jsonEvents = parseNdjson(json, 'json');
+const aiRecords = parseNdjson(ai, 'ai');
+const failureJsonEvents = parseNdjson(failureJson, 'failure-json');
+const failureAiRecords = parseNdjson(failureAi, 'failure-ai');
+const plaintextEvents = parseNdjson(fs.readFileSync(plaintextEventsPath, 'utf8'), 'plaintext sidecar');
+
+for (const [name, events] of [
+  ['json', jsonEvents],
+  ['plaintext sidecar', plaintextEvents]
+]) {
+  const completedArtifact = events.findLast(
+    (event) => event.type === 'artifactAvailable' && event.payload?.role === 'log'
+  );
+  if (completedArtifact?.payload?.complete !== true) {
+    throw new Error(`${name} did not publish a complete final log artifact.`);
+  }
+  const operations = new Map();
+  for (const event of events) {
+    const operationId = event.scope?.operationId;
+    if (!operationId) {
+      continue;
+    }
+    const record = operations.get(operationId) ?? { closed: 0, completed: 0 };
+    if (event.type === 'operationStreamClosed') record.closed++;
+    if (event.type === 'operationCompleted') record.completed++;
+    operations.set(operationId, record);
+  }
+  for (const [operationId, record] of operations) {
+    if (record.closed !== 1 || record.completed !== 1) {
+      throw new Error(
+        `${name} operation ${operationId} had ${record.closed} close events and ${record.completed} completion events.`
+      );
+    }
+  }
 }
 
 const logMatch = plaintext.match(/^Full log: (.+)$/m);
 if (!logMatch || !path.isAbsolute(logMatch[1]) || !fs.existsSync(logMatch[1])) {
   throw new Error('The plaintext reporter did not expose an existing absolute full-log path.');
 }
+if (process.platform !== 'win32' && (fs.statSync(logMatch[1]).mode & 0o777) !== 0o600) {
+  throw new Error('The full-detail log is not owner-only.');
+}
+
+const operationId = '@rushstack/rush-reporter#_phase:build';
+const rawOutput = plaintextEvents
+  .filter((event) => event.type === 'externalOutput' && event.scope?.operationId === operationId)
+  .map((event) => event.payload.text)
+  .join('');
+const groupHeader = '==[ @rushstack/rush-reporter (_phase:build) ]==\n';
+const groupStart = plaintext.indexOf(groupHeader);
+const groupEnd = plaintext.indexOf('@rushstack/rush-reporter: success', groupStart);
+if (groupStart < 0 || groupEnd < 0) {
+  throw new Error('The plaintext reporter did not reconstruct the expected operation group.');
+}
+const groupedOutput = plaintext.slice(groupStart + groupHeader.length, groupEnd);
+if (groupedOutput !== rawOutput) {
+  throw new Error('Plaintext grouping lost, duplicated, or reordered operation chunks.');
+}
+if ((rawOutput.match(/---- build started ----/g) ?? []).length !== 1) {
+  throw new Error('The operation output contains a duplicated or missing build-start marker.');
+}
+if (plaintext.includes('Rush Multi-Project Build Tool') || plaintext.includes('1 of 1 ]==')) {
+  throw new Error('The reporter path has more than one visible terminal writer.');
+}
+
+const aiFinal = aiRecords.at(-1);
+if (aiFinal?.kind !== 'ai.final' || aiFinal.log?.complete !== true) {
+  throw new Error('AI output did not include a complete full-log reference.');
+}
+const failureAiFinal = failureAiRecords.at(-1);
+if (
+  failureAiFinal?.result !== 'failed' ||
+  !failureAiFinal.diagnostics?.some((diagnostic) => diagnostic.summary?.includes('does not exist'))
+) {
+  throw new Error('AI failure output did not preserve the actionable parser error.');
+}
+if (
+  !failureJsonEvents.some((event) => event.type === 'commandResult' && event.payload?.exitCode === 1) ||
+  !failureJsonEvents.some((event) => event.type === 'sessionCompleted' && event.payload?.exitCode === 1)
+) {
+  throw new Error('JSON failure output did not flush its final lifecycle records.');
+}
+if (quiet.includes('build started') || quiet.includes('==[ @rushstack/rush-reporter')) {
+  throw new Error('Quiet output leaked detailed operation output.');
+}
+
+const fileLogMatch = file.stderr.match(/^Rush full log: (.+)$/m);
+if (file.stdout !== '' || !fileLogMatch || !fs.existsSync(fileLogMatch[1])) {
+  throw new Error('The file reporter did not keep stdout empty and expose its log path on stderr.');
+}
+if (!help.includes('usage: rush') || help.includes('"type":"')) {
+  throw new Error('Help output did not remain on the legacy parser-only path.');
+}
+if (help !== flagOffHelp) {
+  throw new Error('RUSH_REPORTER=legacy changed the byte-for-byte parser output.');
+}
+const commandJsonPayload = JSON.parse(commandJson.stdout);
+if (!Array.isArray(commandJsonPayload.projects) || commandJson.stdout.includes('"protocolVersion"')) {
+  throw new Error('Command-specific JSON was mixed with reporter records.');
+}
+if (
+  !commandJson.stderr.includes('Rush full log:') ||
+  commandJsonConflict.stdout !== '' ||
+  !commandJsonConflict.stderr.includes('command-specific --json output owns stdout')
+) {
+  throw new Error('Command-specific JSON ownership arbitration failed.');
+}
 
 console.log(`Reporter demo outputs: ${outputFolder}`);
 console.log(`Full detail log: ${logMatch[1]}`);
diff --git a/common/reviews/api/rush-reporter.api.md b/common/reviews/api/rush-reporter.api.md
index 473c0636dc8..421f605acb4 100644
--- a/common/reviews/api/rush-reporter.api.md
+++ b/common/reviews/api/rush-reporter.api.md
@@ -222,6 +222,8 @@ export interface IAiDiagnostic {
     readonly remediation?: readonly IRushRemediationAction[];
     // (undocumented)
     readonly severity: string;
+    // (undocumented)
+    readonly summary?: string;
 }
 
 // @beta
@@ -456,6 +458,7 @@ export interface IExternalOutputChunk {
 // @beta
 export interface IFileReporterArtifact {
     readonly available: boolean;
+    readonly complete: boolean;
     readonly path?: string;
 }
 
diff --git a/libraries/reporter/src/reporters/AiReporter.ts b/libraries/reporter/src/reporters/AiReporter.ts
index f74b11466aa..e522f094fd8 100644
--- a/libraries/reporter/src/reporters/AiReporter.ts
+++ b/libraries/reporter/src/reporters/AiReporter.ts
@@ -29,6 +29,7 @@ export interface IAiDiagnostic {
   readonly code: string;
   readonly category: string;
   readonly severity: string;
+  readonly summary?: string;
   readonly remediation?: readonly IRushRemediationAction[];
 }
 
@@ -117,6 +118,9 @@ export class AiReporter implements IReporter {
   private readonly _warningDiagnostics: IAiDiagnostic[];
   private readonly _errorCodes: Set<string>;
   private readonly _diagnosticCategoryCounts: { [category: string]: number };
+  private readonly _fallbackErrorMessages: string[];
+  private _fallbackErrorCount: number;
+  private _fallbackErrorsTruncated: boolean;
   private _errorDiagnosticsTruncated: boolean;
   private _warningDiagnosticsTruncated: boolean;
   private _errorCount: number;
@@ -148,6 +152,9 @@ export class AiReporter implements IReporter {
     this._warningDiagnostics = [];
     this._errorCodes = new Set();
     this._diagnosticCategoryCounts = {};
+    this._fallbackErrorMessages = [];
+    this._fallbackErrorCount = 0;
+    this._fallbackErrorsTruncated = false;
     this._errorDiagnosticsTruncated = false;
     this._warningDiagnosticsTruncated = false;
     this._errorCount = 0;
@@ -218,6 +225,21 @@ export class AiReporter implements IReporter {
         this._collectDiagnostic(event.payload as IAiDiagnostic);
         break;
       }
+      case 'messageEmitted': {
+        const payload: { severity?: string; text?: string } = event.payload as {
+          severity?: string;
+          text?: string;
+        };
+        if (payload.severity === 'error' && payload.text) {
+          this._fallbackErrorCount++;
+          if (this._fallbackErrorMessages.length < this._maxDetailedDiagnostics) {
+            this._fallbackErrorMessages.push(payload.text.trim());
+          } else {
+            this._fallbackErrorsTruncated = true;
+          }
+        }
+        break;
+      }
       case 'artifactAvailable': {
         const payload: { role?: string; path?: string; format?: string; complete?: boolean } =
           event.payload as { role?: string; path?: string; format?: string; complete?: boolean };
@@ -271,6 +293,7 @@ export class AiReporter implements IReporter {
           code: diagnostic.code,
           category: diagnostic.category,
           severity: 'error',
+          summary: diagnostic.summary,
           remediation: diagnostic.remediation
         });
       } else {
@@ -283,6 +306,7 @@ export class AiReporter implements IReporter {
           code: diagnostic.code,
           category: diagnostic.category,
           severity: 'warning',
+          summary: diagnostic.summary,
           remediation: diagnostic.remediation
         });
       } else {
@@ -297,10 +321,31 @@ export class AiReporter implements IReporter {
     }
     this._finalEmitted = true;
 
-    const hasFailures: boolean = !succeeded || this._errorCount > 0;
+    const fallbackDiagnostics: IAiDiagnostic[] =
+      this._errorCount === 0
+        ? this._fallbackErrorMessages.map((summary) => ({
+            code: 'RUSH_COMMAND_FAILED',
+            category: 'command',
+            severity: 'error',
+            summary
+          }))
+        : [];
+    const errorDiagnostics: IAiDiagnostic[] =
+      fallbackDiagnostics.length > 0 ? fallbackDiagnostics : this._errorDiagnostics;
+    const errorCount: number =
+      this._errorCount + (fallbackDiagnostics.length > 0 ? this._fallbackErrorCount : 0);
+    const errorCodes: string[] =
+      fallbackDiagnostics.length > 0 ? ['RUSH_COMMAND_FAILED'] : [...this._errorCodes].sort();
+    const diagnosticCategoryCounts: { [category: string]: number } = {
+      ...this._diagnosticCategoryCounts
+    };
+    if (fallbackDiagnostics.length > 0) {
+      diagnosticCategoryCounts.command = (diagnosticCategoryCounts.command ?? 0) + fallbackDiagnostics.length;
+    }
+    const hasFailures: boolean = !succeeded || errorCount > 0;
     // When failures exist, warnings are represented by counts only. Warning-only
     // success may include bounded warning details.
-    const detailedSource: IAiDiagnostic[] = hasFailures ? this._errorDiagnostics : this._warningDiagnostics;
+    const detailedSource: IAiDiagnostic[] = hasFailures ? errorDiagnostics : this._warningDiagnostics;
 
     const record: {
       kind: 'ai.final';
@@ -322,13 +367,15 @@ export class AiReporter implements IReporter {
       result: succeeded ? 'succeeded' : 'failed',
       exitCode,
       scope: { commandName: this._commandName, failedProjects: [...this._failedProjects] },
-      errorCodes: [...this._errorCodes].sort(),
-      diagnosticCategoryCounts: { ...this._diagnosticCategoryCounts },
+      errorCodes,
+      diagnosticCategoryCounts,
       diagnostics: detailedSource.slice(0, this._maxDetailedDiagnostics),
-      errorCount: this._errorCount,
+      errorCount,
       warningCount: this._warningCount,
       operationCounts: { ...this._operationCounts },
-      truncated: hasFailures ? this._errorDiagnosticsTruncated : this._warningDiagnosticsTruncated
+      truncated: hasFailures
+        ? this._errorDiagnosticsTruncated || (fallbackDiagnostics.length > 0 && this._fallbackErrorsTruncated)
+        : this._warningDiagnosticsTruncated
     };
 
     if (this._logPath !== undefined) {
diff --git a/libraries/reporter/src/reporters/FileReporter.ts b/libraries/reporter/src/reporters/FileReporter.ts
index e0d9c3d62c6..075cabe7adb 100644
--- a/libraries/reporter/src/reporters/FileReporter.ts
+++ b/libraries/reporter/src/reporters/FileReporter.ts
@@ -41,8 +41,8 @@ const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
 
 interface IFileOperationRecord {
   readonly title: string;
-  readonly spoolPath?: string;
-  readonly spoolFileDescriptor?: number;
+  spoolPath?: string;
+  spoolFailed?: boolean;
 }
 
 function getUserTempDirectoryName(): string {
@@ -66,6 +66,11 @@ export interface IFileReporterArtifact {
    * The absolute path to the log, when available.
    */
   readonly path?: string;
+
+  /**
+   * Whether every event and grouped output chunk has been persisted.
+   */
+  readonly complete: boolean;
 }
 
 /**
@@ -147,6 +152,7 @@ export class FileReporter implements IReporter {
   private _fileDescriptor: number | undefined;
   private _targetResolved: boolean;
   private _available: boolean;
+  private _complete: boolean;
   private _targetPath: string | undefined;
   private _latestCopyPath: string | undefined;
   private readonly _fileName: string;
@@ -171,6 +177,7 @@ export class FileReporter implements IReporter {
     this._fileDescriptor = undefined;
     this._targetResolved = false;
     this._available = false;
+    this._complete = false;
     this._targetPath = undefined;
     this._latestCopyPath = undefined;
     this._nextSpoolId = 1;
@@ -221,6 +228,7 @@ export class FileReporter implements IReporter {
         fs.closeSync(this._fileDescriptor);
       } catch (error) {
         this._available = false;
+        this._complete = false;
         this._emergencyWarn(
           `[reporter] Unable to close the full-detail log; the artifact is unavailable: ${(error as Error).message}`
         );
@@ -236,8 +244,8 @@ export class FileReporter implements IReporter {
    */
   public getArtifact(): IFileReporterArtifact {
     return this._targetPath !== undefined
-      ? { available: this._available, path: this._targetPath }
-      : { available: this._available };
+      ? { available: this._available, path: this._targetPath, complete: this._available && this._complete }
+      : { available: this._available, complete: false };
   }
 
   private _formatEvent(event: IReporterEventEnvelope<unknown>): readonly string[] {
@@ -264,16 +272,13 @@ export class FileReporter implements IReporter {
       const text: string = (event.payload as { text?: string }).text ?? '';
       const operation: IFileOperationRecord | undefined =
         operationId === undefined ? undefined : this._operations.get(operationId);
-      if (operation?.spoolFileDescriptor !== undefined) {
-        try {
-          fs.writeSync(operation.spoolFileDescriptor, text);
-        } catch (error) {
-          this._emergencyWarn(
-            `[reporter] Unable to spool grouped output for ${JSON.stringify(operationId)}: ${(error as Error).message}`
-          );
-          return [`# [${operationId} ${(event.payload as { stream?: string }).stream ?? 'stdout'}]\n`, text];
-        }
-        return [];
+      if (operationId !== undefined && operation) {
+        return this._spoolOperationOutput(
+          operationId,
+          operation,
+          (event.payload as { stream?: string }).stream ?? 'stdout',
+          text
+        );
       }
       return operationId ? [`# [${operationId}]\n`, text] : [text];
     }
@@ -303,27 +308,66 @@ export class FileReporter implements IReporter {
   }
 
   private _createOperationRecord(title: string): IFileOperationRecord {
-    if (this._targetPath) {
-      const spoolPath: string = `${this._targetPath}.${this._nextSpoolId++}.operation`;
+    return { title };
+  }
+
+  private _spoolOperationOutput(
+    operationId: string,
+    operation: IFileOperationRecord,
+    stream: string,
+    text: string
+  ): readonly string[] {
+    if (operation.spoolFailed || !this._targetPath) {
+      return [`# [${operationId} ${stream}]\n`, text];
+    }
+
+    if (!operation.spoolPath) {
+      operation.spoolPath = `${this._targetPath}.${this._nextSpoolId++}.operation`;
       try {
-        const spoolFileDescriptor: number = fs.openSync(spoolPath, 'w+', OWNER_ONLY_MODE);
-        return { title, spoolPath, spoolFileDescriptor };
+        fs.writeFileSync(operation.spoolPath, '', { flag: 'wx', mode: OWNER_ONLY_MODE });
       } catch (error) {
+        operation.spoolFailed = true;
+        operation.spoolPath = undefined;
         this._emergencyWarn(
           `[reporter] Unable to create grouped-output spool file; output will remain ungrouped: ${(error as Error).message}`
         );
+        return [`# [${operationId} ${stream}]\n`, text];
       }
     }
-    return { title };
+
+    try {
+      fs.appendFileSync(operation.spoolPath, text, { encoding: 'utf8', mode: OWNER_ONLY_MODE });
+      return [];
+    } catch (error) {
+      let priorOutput: string = '';
+      try {
+        priorOutput = fs.readFileSync(operation.spoolPath, 'utf8');
+      } catch {
+        this._complete = false;
+      }
+      try {
+        fs.rmSync(operation.spoolPath, { force: true });
+      } catch {
+        /* Best-effort cleanup. */
+      }
+      operation.spoolPath = undefined;
+      operation.spoolFailed = true;
+      this._emergencyWarn(
+        `[reporter] Unable to spool grouped output for ${JSON.stringify(operationId)}; output will remain ungrouped: ${(error as Error).message}`
+      );
+      return [`# [${operationId} ${stream}]\n`, priorOutput, text];
+    }
   }
 
   private _writeGroupedOperation(operationId: string, operation: IFileOperationRecord, status: string): void {
+    if (operation.spoolFailed) {
+      this._writeOrBuffer(`==[ ${operationId}: ${status} ]==\n`);
+      return;
+    }
     this._writeOrBuffer(`\n==[ ${operation.title} ]==\n`);
-    if (operation.spoolFileDescriptor !== undefined) {
+    if (operation.spoolPath !== undefined) {
       try {
-        fs.fsyncSync(operation.spoolFileDescriptor);
-        fs.closeSync(operation.spoolFileDescriptor);
-        if (operation.spoolPath && this._fileDescriptor !== undefined) {
+        if (this._fileDescriptor !== undefined) {
           const source: number = fs.openSync(operation.spoolPath, 'r');
           try {
             const buffer: Buffer = Buffer.allocUnsafe(64 * 1024);
@@ -341,21 +385,15 @@ export class FileReporter implements IReporter {
           }
         }
       } catch (error) {
+        this._complete = false;
         this._emergencyWarn(
           `[reporter] Unable to append grouped output for ${JSON.stringify(operationId)}: ${(error as Error).message}`
         );
       } finally {
         try {
-          fs.closeSync(operation.spoolFileDescriptor);
+          fs.rmSync(operation.spoolPath, { force: true });
         } catch {
-          /* It was already closed after a successful spool flush. */
-        }
-        if (operation.spoolPath) {
-          try {
-            fs.rmSync(operation.spoolPath, { force: true });
-          } catch {
-            /* Best-effort cleanup. */
-          }
+          /* Best-effort cleanup. */
         }
       }
     }
@@ -421,6 +459,7 @@ export class FileReporter implements IReporter {
       return;
     }
     this._available = false;
+    this._complete = false;
     this._lines.length = 0;
     if (this._fileDescriptor !== undefined) {
       try {
@@ -463,6 +502,7 @@ export class FileReporter implements IReporter {
         this._fileDescriptor = fileDescriptor;
         this._targetPath = filePath;
         this._available = true;
+        this._complete = true;
         await this._updateLatestAsync(dir, filePath);
         await this._applyRetentionAsync(dir);
         return;
@@ -472,6 +512,7 @@ export class FileReporter implements IReporter {
     }
 
     this._available = false;
+    this._complete = false;
     this._lines.length = 0;
     this._emergencyWarn(
       `[reporter] Unable to write the full-detail log; the artifact is unavailable: ${lastError?.message ?? 'unknown error'}`
@@ -500,12 +541,21 @@ export class FileReporter implements IReporter {
     const cutoff: number = this._nowMs() - this._retentionDays * MS_PER_DAY;
     const logs: { path: string; mtimeMs: number }[] = [];
     for (const entry of entries) {
-      if (entry === LATEST_LOG_NAME || !entry.endsWith('.log')) {
+      if (entry === LATEST_LOG_NAME) {
         continue;
       }
       const entryPath: string = path.join(dir, entry);
       try {
         const stats: fs.Stats = await fs.promises.stat(entryPath);
+        if (entry.endsWith('.operation')) {
+          if (stats.mtimeMs < cutoff) {
+            await fs.promises.rm(entryPath, { force: true });
+          }
+          continue;
+        }
+        if (!entry.endsWith('.log')) {
+          continue;
+        }
         if (stats.mtimeMs < cutoff) {
           await fs.promises.rm(entryPath, { force: true });
         } else {
diff --git a/libraries/reporter/src/reporters/PlaintextReporter.ts b/libraries/reporter/src/reporters/PlaintextReporter.ts
index 9ab14687b7e..78b4ccebb47 100644
--- a/libraries/reporter/src/reporters/PlaintextReporter.ts
+++ b/libraries/reporter/src/reporters/PlaintextReporter.ts
@@ -1,6 +1,11 @@
 // Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
 // See LICENSE in the project root for license information.
 
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+
 import type { IReporterEventEnvelope } from '../events/IReporterEventEnvelope';
 import type { IReporter } from '../manager/IReporter';
 import type { PlaintextVariant } from '../config/AutomaticReporterMatrix';
@@ -8,6 +13,8 @@ import type { ReporterLogLevel } from '../config/ReporterNames';
 import { createColorizer, type IColorizer } from './InteractiveRendering';
 
 const HEARTBEAT_INTERVAL_MS: number = 30000;
+const OWNER_ONLY_MODE: number = 0o600;
+const OWNER_ONLY_DIRECTORY_MODE: number = 0o700;
 const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
   'success',
   'successWithWarnings',
@@ -23,7 +30,8 @@ interface IOperationRecord {
   readonly projectName: string;
   readonly phaseName?: string;
   readonly silent: boolean;
-  readonly buffer: string[];
+  spoolPath?: string;
+  spoolFailed?: boolean;
 }
 
 /**
@@ -94,6 +102,8 @@ export class PlaintextReporter implements IReporter {
   private _atLineStart: boolean;
   private _logPath: string | undefined;
   private readonly _operations: Map<string, IOperationRecord>;
+  private _spoolDirectory: string | undefined;
+  private _nextSpoolId: number;
 
   public constructor(options: IPlaintextReporterOptions) {
     this._write = options.write;
@@ -111,6 +121,8 @@ export class PlaintextReporter implements IReporter {
     this._atLineStart = true;
     this._logPath = undefined;
     this._operations = new Map();
+    this._spoolDirectory = undefined;
+    this._nextSpoolId = 1;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -139,8 +151,7 @@ export class PlaintextReporter implements IReporter {
         this._operations.set(payload.operationId, {
           projectName: payload.projectName ?? payload.operationId,
           phaseName: payload.phaseName,
-          silent: payload.silent === true,
-          buffer: []
+          silent: payload.silent === true
         });
         if (!payload.silent) {
           this._total++;
@@ -212,7 +223,19 @@ export class PlaintextReporter implements IReporter {
   }
 
   public async closeAsync(): Promise<void> {
-    /* no-op */
+    for (const [operationId, record] of this._operations) {
+      if (!record.silent && this._variant === 'detailed') {
+        const phase: string = record.phaseName ? ` (${record.phaseName})` : '';
+        this._writeLine('');
+        this._writeLine(`==[ ${record.projectName}${phase} ]==`);
+        this._writeSpooledOutput(record);
+        this._writeLine(this._formatStatus(record.projectName, 'aborted'));
+      } else {
+        this._deleteSpool(record);
+      }
+      this._operations.delete(operationId);
+    }
+    this._removeSpoolDirectory();
   }
 
   /**
@@ -241,6 +264,7 @@ export class PlaintextReporter implements IReporter {
       return;
     }
     if (record?.silent) {
+      this._deleteSpool(record);
       this._operations.delete(payload.operationId);
       return;
     }
@@ -251,6 +275,9 @@ export class PlaintextReporter implements IReporter {
     }
 
     if (this._logLevel === 'quiet') {
+      if (record) {
+        this._deleteSpool(record);
+      }
       this._operations.delete(payload.operationId);
       return;
     }
@@ -260,8 +287,7 @@ export class PlaintextReporter implements IReporter {
       this._writeLine('');
       this._writeLine(`==[ ${projectName}${phase} ]==`);
       if (record) {
-        this._writeRaw(record.buffer.join(''));
-        record.buffer.length = 0;
+        this._writeSpooledOutput(record);
       }
       this._writeLine(this._formatStatus(projectName, payload.status));
     } else {
@@ -279,12 +305,98 @@ export class PlaintextReporter implements IReporter {
     const record: IOperationRecord | undefined =
       operationId !== undefined ? this._operations.get(operationId) : undefined;
     if (record) {
-      record.buffer.push(text);
+      this._spoolOutput(record, text);
     } else {
       this._writeRaw(text);
     }
   }
 
+  private _spoolOutput(record: IOperationRecord, text: string): void {
+    if (record.spoolFailed) {
+      this._writeRaw(text);
+      return;
+    }
+
+    try {
+      if (!record.spoolPath) {
+        const spoolDirectory: string = this._ensureSpoolDirectory();
+        record.spoolPath = path.join(spoolDirectory, `${this._nextSpoolId++}.operation`);
+        fs.writeFileSync(record.spoolPath, '', { flag: 'wx', mode: OWNER_ONLY_MODE });
+      }
+      fs.appendFileSync(record.spoolPath, text, { encoding: 'utf8', mode: OWNER_ONLY_MODE });
+    } catch (error) {
+      if (record.spoolPath) {
+        try {
+          this._writeRaw(fs.readFileSync(record.spoolPath, 'utf8'));
+        } catch {
+          /* Preserve subsequent output even if the prior spool cannot be recovered. */
+        }
+      }
+      this._deleteSpool(record);
+      record.spoolFailed = true;
+      this._writeLine(`[reporter] Unable to spool grouped plaintext output: ${(error as Error).message}`);
+      this._writeRaw(text);
+    }
+  }
+
+  private _writeSpooledOutput(record: IOperationRecord): void {
+    if (!record.spoolPath) {
+      return;
+    }
+    let fileDescriptor: number | undefined;
+    try {
+      fileDescriptor = fs.openSync(record.spoolPath, 'r');
+      const decoder: StringDecoder = new StringDecoder('utf8');
+      const buffer: Buffer = Buffer.allocUnsafe(64 * 1024);
+      let bytesRead: number;
+      while ((bytesRead = fs.readSync(fileDescriptor, buffer, 0, buffer.length, null)) > 0) {
+        this._writeRaw(decoder.write(buffer.subarray(0, bytesRead)));
+      }
+      this._writeRaw(decoder.end());
+    } catch (error) {
+      this._writeLine(
+        `[reporter] Unable to read grouped plaintext output; see the full log: ${(error as Error).message}`
+      );
+    } finally {
+      if (fileDescriptor !== undefined) {
+        fs.closeSync(fileDescriptor);
+      }
+      this._deleteSpool(record);
+    }
+  }
+
+  private _ensureSpoolDirectory(): string {
+    if (!this._spoolDirectory) {
+      this._spoolDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'rush-plaintext-reporter-'));
+      fs.chmodSync(this._spoolDirectory, OWNER_ONLY_DIRECTORY_MODE);
+    }
+    return this._spoolDirectory;
+  }
+
+  private _deleteSpool(record: IOperationRecord): void {
+    if (!record.spoolPath) {
+      return;
+    }
+    try {
+      fs.rmSync(record.spoolPath, { force: true });
+    } catch {
+      /* Best-effort cleanup. */
+    }
+    record.spoolPath = undefined;
+  }
+
+  private _removeSpoolDirectory(): void {
+    if (!this._spoolDirectory) {
+      return;
+    }
+    try {
+      fs.rmdirSync(this._spoolDirectory);
+    } catch {
+      /* Best-effort cleanup. */
+    }
+    this._spoolDirectory = undefined;
+  }
+
   private _onResult(payload: { commandName: string; succeeded: boolean; exitCode: number }): void {
     const commandName: string = payload.commandName ?? this._commandName ?? 'rush';
     if (payload.succeeded) {
diff --git a/libraries/reporter/src/test/FileReporter.test.ts b/libraries/reporter/src/test/FileReporter.test.ts
index 796255bd85a..079655c7e11 100644
--- a/libraries/reporter/src/test/FileReporter.test.ts
+++ b/libraries/reporter/src/test/FileReporter.test.ts
@@ -85,6 +85,7 @@ describe('FileReporter', () => {
 
       const artifact: IFileReporterArtifact = reporter.getArtifact();
       expect(artifact.available).toBe(true);
+      expect(artifact.complete).toBe(true);
       expect(artifact.path).toContain(path.join(base, RUSH_LOGS_DIR_NAME));
       expect(path.basename(artifact.path!)).toBe('2026-07-15T01-00-00-000Z-4242-build.log');
 
@@ -178,6 +179,28 @@ describe('FileReporter', () => {
     });
   });
 
+  it('does not retain a file descriptor for every registered operation', async () => {
+    await withTempDir(async (base: string) => {
+      const reporter: FileReporter = new FileReporter({ commonTempFolder: base, nowMs: () => FIXED_NOW });
+      await reporter.initializeAsync();
+      for (let index: number = 0; index < 2000; index++) {
+        reporter.report(
+          ev('operationRegistered', {
+            operationId: `operation-${index}`,
+            projectName: `project-${index}`,
+            phaseName: 'build'
+          })
+        );
+      }
+
+      const logsDir: string = path.join(base, RUSH_LOGS_DIR_NAME);
+      expect((await fs.promises.readdir(logsDir)).filter((entry) => entry.endsWith('.operation'))).toEqual(
+        []
+      );
+      await reporter.closeAsync();
+    });
+  });
+
   it('excludes secret fields but keeps local-sensitive values', async () => {
     await withTempDir(async (base: string) => {
       const reporter: FileReporter = new FileReporter({ commonTempFolder: base, nowMs: () => FIXED_NOW });
@@ -208,8 +231,11 @@ describe('FileReporter', () => {
 
       const oldLog: string = path.join(logsDir, 'old-1-build.log');
       await fs.promises.writeFile(oldLog, '{}\n');
+      const oldSpool: string = path.join(logsDir, 'abandoned.operation');
+      await fs.promises.writeFile(oldSpool, 'abandoned output');
       const oldTime: Date = new Date(FIXED_NOW - 20 * MS_PER_DAY);
       await fs.promises.utimes(oldLog, oldTime, oldTime);
+      await fs.promises.utimes(oldSpool, oldTime, oldTime);
 
       // Create more than the cap of recent logs.
       for (let i: number = 0; i < 22; i++) {
@@ -232,6 +258,7 @@ describe('FileReporter', () => {
       );
       expect(remaining).not.toContain('old-1-build.log');
       expect(remaining.length).toBe(20);
+      expect(fs.existsSync(oldSpool)).toBe(false);
     });
   });
 
diff --git a/libraries/reporter/src/test/JsonAiReporter.test.ts b/libraries/reporter/src/test/JsonAiReporter.test.ts
index 9d2a8750804..c617f11a9aa 100644
--- a/libraries/reporter/src/test/JsonAiReporter.test.ts
+++ b/libraries/reporter/src/test/JsonAiReporter.test.ts
@@ -133,6 +133,27 @@ describe('AiReporter', () => {
     expect(final.exitCode).toBe(0);
   });
 
+  it('preserves an actionable parser error when no structured diagnostic was emitted', () => {
+    const { final } = run([
+      ev('commandStarted', { commandName: 'build' }),
+      ev('messageEmitted', {
+        severity: 'error',
+        text: 'The project \"missing\" passed to \"--only\" does not exist in rush.json.'
+      }),
+      ev('commandResult', { commandName: 'build', succeeded: false, exitCode: 1 })
+    ]);
+
+    expect(final.errorCodes).toEqual(['RUSH_COMMAND_FAILED']);
+    expect(final.errorCount).toBe(1);
+    expect(final.diagnostics).toEqual([
+      expect.objectContaining({
+        category: 'command',
+        severity: 'error',
+        summary: 'The project \"missing\" passed to \"--only\" does not exist in rush.json.'
+      })
+    ]);
+  });
+
   it('emits a status record and a bounded final record with scope, codes, and log', () => {
     const { records, final } = run([
       ev('commandStarted', { commandName: 'build' }),
diff --git a/libraries/reporter/src/test/PlaintextReporter.test.ts b/libraries/reporter/src/test/PlaintextReporter.test.ts
index ece5d37f8c8..34cbb15d61b 100644
--- a/libraries/reporter/src/test/PlaintextReporter.test.ts
+++ b/libraries/reporter/src/test/PlaintextReporter.test.ts
@@ -101,6 +101,22 @@ describe('PlaintextReporter', () => {
     expect(capture.getOutput()).not.toContain('Building \nproject-a');
   });
 
+  it('streams large grouped output from disk without retaining it in the operation record', async () => {
+    const capture: ICapture = makeDetailed();
+    const chunk: string = `${'x'.repeat(256 * 1024)}\n`;
+    capture.reporter.report(
+      ev('operationRegistered', { operationId: 'op1', projectName: 'project-a', phaseName: 'build' })
+    );
+    for (let index: number = 0; index < 8; index++) {
+      capture.reporter.report(ev('externalOutput', { text: chunk }, { operationId: 'op1' }));
+    }
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
+    await capture.reporter.closeAsync();
+
+    expect(capture.getOutput()).toContain(`${'x'.repeat(1024)}x`);
+    expect(capture.getOutput()).toContain('project-a: success');
+  });
+
   it('omits silent operations and exposes the full log path', () => {
     const capture: ICapture = makeDetailed();
     capture.reporter.report(ev('commandStarted', { commandName: 'build' }));
diff --git a/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts b/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts
index 7413b6f4ef3..596ed1b8566 100644
--- a/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts
+++ b/libraries/rush-lib/src/cli/scriptActions/PhasedScriptAction.ts
@@ -716,7 +716,7 @@ export class PhasedScriptAction extends BaseScriptAction<IPhasedCommandConfig> i
           rushConfiguration: this.rushConfiguration,
           graph,
           initialSnapshot,
-          terminal: presentationTerminal,
+          terminal,
           debounceMs: this._watchDebounceMs,
           renderStatusInPlace: !_isRushSessionOperationStreamEnabled(this.rushSession)
         });

From 715990145a68fd8e9b03ce4ecc01b9612c062d87 Mon Sep 17 00:00:00 2001
From: TheLarkInn <TheLarkInn@users.noreply.github.com>
Date: Fri, 28 Aug 2026 20:02:33 +0000
Subject: [PATCH 3/5] Fix reporter demo review findings

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d6318e80-5da9-4858-a147-817e8692f10e
---
 apps/rush/src/MinimalRushConfiguration.ts     |  48 +++-
 apps/rush/src/RushFrontend.ts                 |  12 +-
 apps/rush/src/RushReporterHost.ts             | 214 +++++++++++++++---
 .../src/test/MinimalRushConfiguration.test.ts | 145 ++++++++++++
 apps/rush/src/test/RushFrontend.test.ts       |  40 ++++
 apps/rush/src/test/RushReporterHost.test.ts   | 170 +++++++++++++-
 .../src/test/sandbox/reporter-demo/README.md  |   5 +-
 .../src/test/sandbox/reporter-demo/run.mjs    |  32 +++
 common/reviews/api/rush-lib.api.md            |   2 +
 common/reviews/api/rush-reporter.api.md       |   4 +
 .../reporter/src/config/LogLevelFilter.ts     |   9 +-
 .../src/events/IMessageEmittedPayload.ts      |   6 +
 .../reporter/src/manager/ReporterManager.ts   |  34 +++
 .../reporter/src/producers/IScopedReporter.ts |   6 +
 .../reporter/src/reporters/AiReporter.ts      |  32 +--
 .../reporters/DefaultInteractiveReporter.ts   |  12 +-
 .../reporter/src/reporters/FileReporter.ts    | 147 ++++++++++--
 .../src/reporters/PlaintextReporter.ts        |  59 ++++-
 .../src/session/ScopedReporterFactory.ts      |   8 +-
 .../test/DefaultInteractiveReporter.test.ts   |  15 ++
 .../reporter/src/test/FileReporter.test.ts    | 107 +++++++++
 .../reporter/src/test/JsonAiReporter.test.ts  |  23 ++
 .../reporter/src/test/LogLevelFilter.test.ts  |   5 +
 libraries/reporter/src/test/Manager.test.ts   |  15 ++
 .../src/test/PlaintextReporter.test.ts        |  19 ++
 .../src/api/EnvironmentConfiguration.ts       |  14 +-
 .../rush-lib/src/cli/RushCommandLineParser.ts |  21 +-
 27 files changed, 1096 insertions(+), 108 deletions(-)

diff --git a/apps/rush/src/MinimalRushConfiguration.ts b/apps/rush/src/MinimalRushConfiguration.ts
index 8a7ffa0d3b7..ec283c7b9d0 100644
--- a/apps/rush/src/MinimalRushConfiguration.ts
+++ b/apps/rush/src/MinimalRushConfiguration.ts
@@ -3,10 +3,12 @@
 
 import * as path from 'node:path';
 
-import { FileSystem, JsonFile } from '@rushstack/node-core-library';
+import { FileSystem, JsonFile, PackageJsonLookup } from '@rushstack/node-core-library';
 import { RushConfiguration } from '@microsoft/rush-lib';
+import { EnvironmentConfiguration } from '@microsoft/rush-lib/lib/api/EnvironmentConfiguration';
 import { RushConstants } from '@microsoft/rush-lib/lib/logic/RushConstants';
 import { RushCommandLineParser } from '@microsoft/rush-lib/lib/cli/RushCommandLineParser';
+import { isSupportedReporterName, type ReporterName } from '@rushstack/rush-reporter';
 
 interface IMinimalRushConfigurationJson {
   rushMinimumVersion: string;
@@ -64,11 +66,17 @@ export class MinimalRushConfiguration {
           minimalRushConfigurationJson,
           rushJsonLocation
         );
+        const explicitReporter: ReporterName | undefined = _getExplicitReporter(process.argv.slice(2));
+        const legacyFallbackRequested: boolean =
+          explicitReporter === 'legacy' ||
+          process.env.RUSH_REPORTER?.trim().toLowerCase() === 'legacy' ||
+          _hasHelpControl(process.argv.slice(2)) ||
+          configuration.rushVersion !== PackageJsonLookup.loadOwnPackageJson(__dirname).version;
         if (
           showVerbose &&
-          !configuration.useRushReporter &&
-          !_hasExplicitNonLegacyReporter(process.argv.slice(2)) &&
-          path.dirname(rushJsonLocation) !== process.cwd()
+          (legacyFallbackRequested ||
+            (!configuration.useRushReporter &&
+              (explicitReporter === undefined || explicitReporter === 'legacy')))
         ) {
           // Preserve the legacy discovery message exactly when the reporter path is not taking ownership.
           console.log('Found configuration in ' + rushJsonLocation);
@@ -114,21 +122,45 @@ export class MinimalRushConfiguration {
    * The repository's common temp folder, used for invocation-scoped reporter logs.
    */
   public get commonTempFolder(): string {
-    return path.resolve(this._commonRushConfigFolder, '..', '..', 'temp');
+    return (
+      EnvironmentConfiguration._getRushTempFolderOverride(process.env) ??
+      path.resolve(this._commonRushConfigFolder, '..', '..', 'temp')
+    );
   }
 }
 
-function _hasExplicitNonLegacyReporter(argv: readonly string[]): boolean {
+function _getExplicitReporter(argv: readonly string[]): ReporterName | undefined {
   for (let index: number = 0; index < argv.length; index++) {
     const argument: string = argv[index];
+    if (argument === '--') {
+      break;
+    }
     let value: string | undefined;
     if (argument === '--reporter') {
-      value = argv[index + 1];
+      const nextArgument: string | undefined = argv[index + 1];
+      if (!nextArgument || nextArgument.startsWith('-')) {
+        continue;
+      }
+      value = nextArgument;
+      index++;
     } else if (argument.startsWith('--reporter=')) {
       value = argument.slice('--reporter='.length);
     }
     if (value !== undefined) {
-      return value.trim().toLowerCase() !== 'legacy';
+      const normalizedValue: string = value.trim().toLowerCase();
+      return isSupportedReporterName(normalizedValue) ? normalizedValue : undefined;
+    }
+  }
+  return undefined;
+}
+
+function _hasHelpControl(argv: readonly string[]): boolean {
+  for (const argument of argv) {
+    if (argument === '--') {
+      return false;
+    }
+    if (argument === '--help' || argument === '-h') {
+      return true;
     }
   }
   return false;
diff --git a/apps/rush/src/RushFrontend.ts b/apps/rush/src/RushFrontend.ts
index c6088eb195d..48e04551a5d 100644
--- a/apps/rush/src/RushFrontend.ts
+++ b/apps/rush/src/RushFrontend.ts
@@ -4,10 +4,7 @@
 import { randomUUID } from 'node:crypto';
 
 import type { ILaunchOptions } from '@microsoft/rush-lib';
-import {
-  DEFAULT_SIGNAL_FLUSH_TIMEOUT_MS,
-  REPORTER_PROTOCOL_VERSION
-} from '@rushstack/rush-reporter';
+import { DEFAULT_SIGNAL_FLUSH_TIMEOUT_MS, REPORTER_PROTOCOL_VERSION } from '@rushstack/rush-reporter';
 
 import {
   initializeRushReporterHostAsync,
@@ -143,12 +140,13 @@ export async function launchRushFrontendAsync(options: IRushFrontendOptions): Pr
   } = options;
 
   const engineArgv: string[] = stripReporterValueControls(process.argv.slice(2));
+  const actionName: string | undefined = engineArgv.find((argument: string) => !argument.startsWith('-'));
   const reporterHost: IInitializedRushReporterHost = await initializeReporterHostAsync({
     repositoryOptIn: configuration?.useRushReporter,
     forceLegacy: rushVersionToLoad !== undefined && rushVersionToLoad !== currentPackageVersion,
     selectedRushVersion: rushVersionToLoad,
-    commonTempFolder: configuration?.commonTempFolder,
-    actionName: engineArgv.find((argument: string) => !argument.startsWith('-'))
+    commonTempFolder: actionName === 'purge' ? undefined : configuration?.commonTempFolder,
+    actionName
   });
   const reporterLifecycle: RushFrontendReporterLifecycle | undefined = reporterHost.selection.enabled
     ? new RushFrontendReporterLifecycle(reporterHost, processLifecycle)
@@ -159,6 +157,8 @@ export async function launchRushFrontendAsync(options: IRushFrontendOptions): Pr
       process.argv,
       new Set(reporterHost.selection.reporterValueFlagsToStrip)
     );
+    delete process.env.RUSH_REPORTER;
+    delete process.env.RUSH_LOG_LEVEL;
   }
   const reporterCloseAsync: () => Promise<void> = () =>
     reporterLifecycle?.closeAsync() ?? reporterHost.closeAsync();
diff --git a/apps/rush/src/RushReporterHost.ts b/apps/rush/src/RushReporterHost.ts
index fcfc53232cf..82204ecdc41 100644
--- a/apps/rush/src/RushReporterHost.ts
+++ b/apps/rush/src/RushReporterHost.ts
@@ -27,7 +27,8 @@ import {
   type IReporterOutputTarget,
   type ReporterEventType,
   type ReporterLogLevel,
-  type ReporterName
+  type ReporterName,
+  type ReporterManager
 } from '@rushstack/rush-reporter';
 
 export interface IRushReporterOutputStream {
@@ -49,6 +50,7 @@ export interface IRushReporterHostOptions {
   readonly repositoryOptIn?: boolean;
   readonly forceLegacy?: boolean;
   readonly selectedRushVersion?: string;
+  readonly manager?: ReporterManager;
 }
 
 export interface IRushReporterSelection {
@@ -77,6 +79,7 @@ export interface IInitializedRushReporterHost {
 const REPORTER_VALUE_FLAGS: ReadonlySet<string> = new Set(['--reporter', '--output', '--log-level']);
 const ALL_REPORTER_VALUE_FLAGS: readonly string[] = ['--reporter', '--output', '--log-level'];
 const REPORTER_SELECTION_FLAG: readonly string[] = ['--reporter'];
+const REPORTER_OUTPUT_VALUE_FLAGS: readonly string[] = ['--output', '--log-level'];
 const GROUPED_OPERATION_EVENT_TYPES: ReadonlySet<ReporterEventType> = new Set([
   'operationRegistered',
   'operationStatusChanged',
@@ -117,13 +120,8 @@ class LogLevelReporter implements IReporter {
   }
 
   public report(event: IReporterEventEnvelope<unknown>): void {
-    const verboseTerminalMessage: boolean =
-      this._logLevel === 'verbose' &&
-      event.type === 'messageEmitted' &&
-      (event.payload as { severity?: string }).severity === 'debug';
     if (
       shouldRenderAtLogLevel(this._logLevel, event) ||
-      verboseTerminalMessage ||
       event.type === 'artifactAvailable' ||
       (this._preserveOperationStream &&
         GROUPED_OPERATION_EVENT_TYPES.has(event.type) &&
@@ -198,6 +196,7 @@ class FilePathReporter implements IReporter {
 
   private readonly _write: (text: string) => unknown;
   private _path: string | undefined;
+  private _written: boolean = false;
 
   public constructor(write: (text: string) => unknown) {
     this._write = write;
@@ -216,8 +215,8 @@ class FilePathReporter implements IReporter {
       if (payload.role === 'log') {
         this._path = payload.path;
       }
-    } else if (event.type === 'commandResult' && this._path) {
-      this._write(`Rush full log: ${this._path}\n`);
+    } else if ((event.type === 'commandResult' || event.type === 'sessionCompleted') && this._path) {
+      this._writePathOnce();
     }
   }
 
@@ -226,7 +225,75 @@ class FilePathReporter implements IReporter {
   }
 
   public async closeAsync(): Promise<void> {
-    /* no-op */
+    this._writePathOnce();
+  }
+
+  private _writePathOnce(): void {
+    if (!this._written && this._path) {
+      this._written = true;
+      this._write(`Rush full log: ${this._path}\n`);
+    }
+  }
+}
+
+class ArtifactCompletionReporterSink implements IReporterEventSink {
+  private readonly _host: ReporterHost;
+  private readonly _fullDetailReporter: FileReporter;
+  private _lastComplete: boolean | undefined;
+  private _artifactContext: IReporterEmitEventInput<unknown> | undefined;
+
+  public constructor(host: ReporterHost, fullDetailReporter: FileReporter) {
+    this._host = host;
+    this._fullDetailReporter = fullDetailReporter;
+  }
+
+  public emit<TPayload>(event: IReporterEmitEventInput<TPayload>): string {
+    if (event.type === 'artifactAvailable') {
+      const payload: { role?: string; path?: string; complete?: boolean } = event.payload as {
+        role?: string;
+        path?: string;
+        complete?: boolean;
+      };
+      if (payload.role === 'log' && typeof payload.complete === 'boolean') {
+        this._lastComplete = payload.complete;
+        this._artifactContext = event;
+      }
+    }
+    return this._host.manager.emit(event);
+  }
+
+  public publishIfChanged(
+    context: IReporterEmitEventInput<unknown> | undefined = this._artifactContext
+  ): void {
+    if (!context) {
+      return;
+    }
+    const artifact: IFileReporterArtifact = this._fullDetailReporter.getArtifact();
+    if (!artifact.path || artifact.complete === this._lastComplete) {
+      return;
+    }
+    const complete: boolean = artifact.complete;
+    const payload: Readonly<{
+      role: 'log';
+      path: string;
+      format: 'plaintext';
+      complete: boolean;
+    }> = Object.freeze({
+      role: 'log' as const,
+      path: artifact.path,
+      format: 'plaintext' as const,
+      complete
+    });
+    this._host.manager.emit({
+      protocolVersion: context.protocolVersion,
+      sessionId: context.sessionId,
+      source: context.source,
+      scope: context.scope,
+      privacy: 'local-sensitive',
+      type: 'artifactAvailable',
+      payload
+    });
+    this._lastComplete = complete;
   }
 }
 
@@ -375,6 +442,34 @@ function hasReporterOutputControl(argv: readonly string[]): boolean {
   return false;
 }
 
+function hasReporterLogLevelControl(argv: readonly string[]): boolean {
+  for (let index: number = 0; index < argv.length; index++) {
+    const argument: string = argv[index];
+    if (argument === '--') {
+      break;
+    }
+    if (argument.startsWith('--log-level=') && argument.length > '--log-level='.length) {
+      return true;
+    }
+    if (argument === '--log-level' && argv[index + 1] !== undefined && !argv[index + 1].startsWith('-')) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function hasHelpControl(argv: readonly string[]): boolean {
+  for (const argument of argv) {
+    if (argument === '--') {
+      return false;
+    }
+    if (argument === '--help' || argument === '-h') {
+      return true;
+    }
+  }
+  return false;
+}
+
 function resolveLogLevel(
   controls: IParsedReporterControls,
   env: Record<string, string | undefined>,
@@ -541,7 +636,7 @@ export function resolveRushReporterSelection(options: IRushReporterHostOptions =
       outputs: [],
       commandJson,
       enabled: false,
-      reporterControlsOwnedByFrontend: requestedReporter !== undefined,
+      reporterControlsOwnedByFrontend: true,
       reporterValueFlagsToStrip,
       reason: 'RUSH_REPORTER=legacy'
     };
@@ -568,7 +663,7 @@ export function resolveRushReporterSelection(options: IRushReporterHostOptions =
     };
   }
 
-  if (argv.includes('--help') || argv.includes('-h')) {
+  if (hasHelpControl(argv)) {
     return {
       reporter: 'legacy',
       logLevel: 'normal',
@@ -602,14 +697,53 @@ export function resolveRushReporterSelection(options: IRushReporterHostOptions =
     }
     if (options.repositoryOptIn) {
       const stdout: IRushReporterOutputStream = options.stdout ?? process.stdout;
+      const ownsOutputControls: boolean = hasReporterOutputControl(argv);
+      const ownsLogLevelControls: boolean = hasReporterLogLevelControl(argv);
+      const candidateValueControls: IParsedReporterControls =
+        ownsOutputControls || ownsLogLevelControls ? parseReporterControls(argv, true) : selectionControls;
+      const ownsLogLevelControl: boolean =
+        ownsLogLevelControls &&
+        !ownsOutputControls &&
+        candidateValueControls.logLevels.length > 0 &&
+        candidateValueControls.logLevels.every((logLevel: string) => isSupportedLogLevel(logLevel));
+      const ownsValueControls: boolean = ownsOutputControls || ownsLogLevelControl;
+      const ownsEnvironmentControls: boolean = env.RUSH_LOG_LEVEL !== undefined;
+      const parsedValueControls: IParsedReporterControls = ownsValueControls
+        ? candidateValueControls
+        : selectionControls;
+      const outputControlsAreUnambiguous: boolean =
+        !parsedValueControls.logLevels.some((logLevel: string) => !isSupportedLogLevel(logLevel)) &&
+        parsedValueControls.outputs.every((outputValue: string) => {
+          try {
+            const output: IReporterOutputTarget = parseOutputControl(outputValue);
+            return output.reporter === 'file' || output.reporter === 'json';
+          } catch {
+            return false;
+          }
+        });
+      const implicitControls: IParsedReporterControls =
+        ownsOutputControls && !outputControlsAreUnambiguous
+          ? {
+              ...parsedValueControls,
+              logLevels: [],
+              outputs: []
+            }
+          : parsedValueControls;
+      validateReporterControlMultiplicity(implicitControls, ownsValueControls);
       return {
-        reporter: isCiDetected(env) || !stdout.isTTY ? 'plaintext' : 'default',
-        logLevel: resolveLogLevel(selectionControls, env, true, true),
-        outputs: [],
+        reporter: commandJson ? 'file' : isCiDetected(env) || !stdout.isTTY ? 'plaintext' : 'default',
+        logLevel: resolveLogLevel(implicitControls, env, true, true),
+        outputs: resolveOutputs(implicitControls.outputs, cwd),
         commandJson,
         enabled: true,
-        reporterControlsOwnedByFrontend: false,
-        reporterValueFlagsToStrip: [],
+        reporterControlsOwnedByFrontend:
+          ownsLogLevelControl || ownsEnvironmentControls || implicitControls.outputs.length > 0,
+        reporterValueFlagsToStrip:
+          implicitControls.outputs.length > 0
+            ? REPORTER_OUTPUT_VALUE_FLAGS
+            : ownsLogLevelControl
+              ? ['--log-level']
+              : [],
         reason: 'repository experiment'
       };
     }
@@ -638,6 +772,13 @@ export function resolveRushReporterSelection(options: IRushReporterHostOptions =
     };
   }
 
+  if (commandJson && requestedReporter !== 'file') {
+    throw new Error(
+      `The command-specific --json output owns stdout and cannot be combined with --reporter=${requestedReporter}. ` +
+        'Use --reporter=file or omit --reporter.'
+    );
+  }
+
   const controls: IParsedReporterControls = parseReporterControls(argv, true);
   validateReporterControlMultiplicity(controls, true);
   const stdout: IRushReporterOutputStream = options.stdout ?? process.stdout;
@@ -668,8 +809,12 @@ function createPrimaryReporter(
     case 'default':
       return new DefaultInteractiveReporter({
         terminal: {
-          columns: stdout.columns ?? 80,
-          isTTY: stdout.isTTY === true,
+          get columns() {
+            return stdout.columns && stdout.columns > 0 ? stdout.columns : 80;
+          },
+          get isTTY() {
+            return stdout.isTTY === true;
+          },
           write: (text: string) => {
             stdout.write(text);
           }
@@ -701,19 +846,11 @@ export async function initializeRushReporterHostAsync(
   const stdout: IRushReporterOutputStream = options.stdout ?? process.stdout;
   const stderr: IRushReporterOutputStream = options.stderr ?? process.stderr;
   const selection: IRushReporterSelection = resolveRushReporterSelection({ ...options, env, stdout });
-  const host: ReporterHost = new ReporterHost({ env });
+  const host: ReporterHost = new ReporterHost({ env, manager: options.manager });
   let fullDetailReporter: FileReporter | undefined;
 
   if (selection.enabled) {
     const primaryReporter: IReporter | undefined = createPrimaryReporter(selection, stdout, env);
-    if (primaryReporter) {
-      host.manager.addReporter(
-        new LogLevelReporter(primaryReporter, selection.logLevel, selection.reporter === 'plaintext'),
-        {
-          destination: 'stdout'
-        }
-      );
-    }
 
     if (options.includeDefaultFileReporter !== false || selection.reporter === 'file') {
       fullDetailReporter = new FileReporter({
@@ -725,6 +862,15 @@ export async function initializeRushReporterHostAsync(
       });
     }
 
+    if (primaryReporter) {
+      host.manager.addReporter(
+        new LogLevelReporter(primaryReporter, selection.logLevel, selection.reporter === 'plaintext'),
+        {
+          destination: 'stdout'
+        }
+      );
+    }
+
     if (selection.reporter === 'file') {
       host.manager.addReporter(new FilePathReporter((text: string) => stderr.write(text)), {
         destination: 'stderr'
@@ -745,14 +891,24 @@ export async function initializeRushReporterHostAsync(
   }
 
   await host.manager.initializeAsync();
+  const artifactCompletionSink: ArtifactCompletionReporterSink | undefined = fullDetailReporter
+    ? new ArtifactCompletionReporterSink(host, fullDetailReporter)
+    : undefined;
   let closePromise: Promise<void> | undefined;
   return {
     host,
-    sink: host.getSink(),
+    sink: artifactCompletionSink ?? host.getSink(),
     selection,
     logArtifact: fullDetailReporter?.getArtifact(),
     closeAsync: (timeoutMs?: number) => {
-      closePromise ??= host.manager.closeAsync(timeoutMs);
+      closePromise ??= (async () => {
+        const fullyFlushed: boolean = await host.manager._flushAndConfirmAsync(timeoutMs);
+        if (fullyFlushed) {
+          await fullDetailReporter?.closeAsync();
+          artifactCompletionSink?.publishIfChanged();
+        }
+        await host.manager.closeAsync(timeoutMs);
+      })();
       return closePromise;
     }
   };
diff --git a/apps/rush/src/test/MinimalRushConfiguration.test.ts b/apps/rush/src/test/MinimalRushConfiguration.test.ts
index 3f01ee36a9b..f771cfb8c00 100644
--- a/apps/rush/src/test/MinimalRushConfiguration.test.ts
+++ b/apps/rush/src/test/MinimalRushConfiguration.test.ts
@@ -3,11 +3,24 @@
 
 import * as path from 'node:path';
 
+import { EnvironmentConfiguration } from '@microsoft/rush-lib/lib/api/EnvironmentConfiguration';
+import { PackageJsonLookup } from '@rushstack/node-core-library';
+
 import { MinimalRushConfiguration } from '../MinimalRushConfiguration';
 
 describe(MinimalRushConfiguration.name, () => {
+  const originalArgv: string[] = process.argv;
+  const originalRushTempFolder: string | undefined = process.env.RUSH_TEMP_FOLDER;
+
   afterEach(() => {
     jest.restoreAllMocks();
+    process.argv = originalArgv;
+    if (originalRushTempFolder === undefined) {
+      delete process.env.RUSH_TEMP_FOLDER;
+    } else {
+      process.env.RUSH_TEMP_FOLDER = originalRushTempFolder;
+    }
+    EnvironmentConfiguration.reset();
   });
 
   describe('legacy rush config', () => {
@@ -35,5 +48,137 @@ describe(MinimalRushConfiguration.name, () => {
       expect(config.useRushReporter).toBe(true);
       expect(config.commonTempFolder).toBe(path.resolve(__dirname, 'sandbox', 'repo', 'common', 'temp'));
     });
+
+    it('uses the normalized RUSH_TEMP_FOLDER override', () => {
+      process.env.RUSH_TEMP_FOLDER = path.join(
+        __dirname,
+        'sandbox',
+        'repo',
+        'custom-temp',
+        '..',
+        'rush-temp'
+      );
+      EnvironmentConfiguration.reset();
+
+      const config: MinimalRushConfiguration =
+        MinimalRushConfiguration.loadFromDefaultLocation() as MinimalRushConfiguration;
+
+      expect(config.commonTempFolder).toBe(path.resolve(__dirname, 'sandbox', 'repo', 'rush-temp'));
+    });
+  });
+
+  it('preserves legacy discovery text and blank-line behavior exactly', () => {
+    const legacyRepo: string = path.join(__dirname, 'sandbox', 'legacy-repo');
+    const consoleLog: jest.SpiedFunction<typeof console.log> = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined);
+    jest.spyOn(PackageJsonLookup, 'loadOwnPackageJson').mockReturnValue({
+      name: '@microsoft/rush',
+      version: '2.5.0'
+    });
+    jest.spyOn(process, 'cwd').mockReturnValue(path.join(legacyRepo, 'project'));
+    process.argv = ['node', 'rush', 'build', '--verbose'];
+
+    MinimalRushConfiguration.loadFromDefaultLocation();
+
+    expect(consoleLog.mock.calls).toEqual([
+      [`Found configuration in ${path.join(legacyRepo, 'rush.json')}`],
+      ['']
+    ]);
+  });
+
+  it('prints the legacy discovery line and blank line when rush.json is in the current folder', () => {
+    const legacyRepo: string = path.join(__dirname, 'sandbox', 'legacy-repo');
+    const consoleLog: jest.SpiedFunction<typeof console.log> = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined);
+    jest.spyOn(process, 'cwd').mockReturnValue(legacyRepo);
+    process.argv = ['node', 'rush', 'build', '--verbose'];
+
+    MinimalRushConfiguration.loadFromDefaultLocation();
+
+    expect(consoleLog.mock.calls).toEqual([
+      [`Found configuration in ${path.join(legacyRepo, 'rush.json')}`],
+      ['']
+    ]);
+  });
+
+  it('suppresses legacy discovery output for an explicit reporter', () => {
+    const legacyRepo: string = path.join(__dirname, 'sandbox', 'legacy-repo');
+    const consoleLog: jest.SpiedFunction<typeof console.log> = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined);
+    jest.spyOn(PackageJsonLookup, 'loadOwnPackageJson').mockReturnValue({
+      name: '@microsoft/rush',
+      version: '2.5.0'
+    });
+    jest.spyOn(process, 'cwd').mockReturnValue(path.join(legacyRepo, 'project'));
+    process.argv = ['node', 'rush', 'build', '--verbose', '--reporter=json'];
+
+    MinimalRushConfiguration.loadFromDefaultLocation();
+
+    expect(consoleLog).not.toHaveBeenCalled();
+  });
+
+  it('restores legacy discovery output under the emergency fallback', () => {
+    const legacyRepo: string = path.join(__dirname, 'sandbox', 'legacy-repo');
+    const consoleLog: jest.SpiedFunction<typeof console.log> = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined);
+    jest.spyOn(process, 'cwd').mockReturnValue(path.join(legacyRepo, 'project'));
+    process.argv = ['node', 'rush', 'build', '--reporter=json'];
+    process.env.RUSH_REPORTER = 'legacy';
+
+    MinimalRushConfiguration.loadFromDefaultLocation();
+
+    expect(consoleLog.mock.calls).toEqual([
+      [`Found configuration in ${path.join(legacyRepo, 'rush.json')}`],
+      ['']
+    ]);
+  });
+
+  it.each([
+    ['environment fallback', ['build', '--reporter=json'], 'legacy'],
+    ['explicit legacy reporter', ['build', '--reporter=legacy'], undefined],
+    ['help fallback', ['build', '--reporter=json', '--help'], undefined],
+    ['cross-version fallback', ['build', '--reporter=json'], undefined]
+  ])('restores legacy discovery output in an opted-in repository for %s', (testName, args, envValue) => {
+    void testName;
+    const repo: string = path.join(__dirname, 'sandbox', 'repo');
+    const consoleLog: jest.SpiedFunction<typeof console.log> = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined);
+    jest.spyOn(process, 'cwd').mockReturnValue(path.join(repo, 'project'));
+    process.argv = ['node', 'rush', ...args];
+    if (envValue === undefined) {
+      delete process.env.RUSH_REPORTER;
+    } else {
+      process.env.RUSH_REPORTER = envValue;
+    }
+
+    MinimalRushConfiguration.loadFromDefaultLocation();
+
+    expect(consoleLog.mock.calls).toEqual([[`Found configuration in ${path.join(repo, 'rush.json')}`], ['']]);
+  });
+
+  it.each([
+    ['custom reporter value', ['custom', '--reporter', 'junit']],
+    ['value-less custom reporter flag', ['custom', '--reporter', '--verbose']],
+    ['pass-through reporter flag', ['build', '--', '--reporter=json']]
+  ])('preserves legacy discovery output for %s', (testName, args) => {
+    void testName;
+    const legacyRepo: string = path.join(__dirname, 'sandbox', 'legacy-repo');
+    const consoleLog: jest.SpiedFunction<typeof console.log> = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined);
+    jest.spyOn(process, 'cwd').mockReturnValue(path.join(legacyRepo, 'project'));
+    process.argv = ['node', 'rush', ...args];
+
+    MinimalRushConfiguration.loadFromDefaultLocation();
+
+    expect(consoleLog.mock.calls).toEqual([
+      [`Found configuration in ${path.join(legacyRepo, 'rush.json')}`],
+      ['']
+    ]);
   });
 });
diff --git a/apps/rush/src/test/RushFrontend.test.ts b/apps/rush/src/test/RushFrontend.test.ts
index 4a59142d851..7c0b6ca3ce3 100644
--- a/apps/rush/src/test/RushFrontend.test.ts
+++ b/apps/rush/src/test/RushFrontend.test.ts
@@ -40,6 +40,7 @@ async function createInitializedHostAsync(
   return {
     host,
     sink: host.getSink(),
+    logArtifact: undefined,
     selection: {
       reporter: 'legacy',
       logLevel: 'normal',
@@ -68,6 +69,7 @@ async function createEnabledHostAsync(
   return {
     host,
     sink: host.getSink(),
+    logArtifact: undefined,
     selection: {
       reporter: 'json',
       logLevel: 'normal',
@@ -105,6 +107,7 @@ async function createPhaseHangingHostAsync(
   return {
     host,
     sink: host.getSink(),
+    logArtifact: undefined,
     selection: {
       reporter: 'json',
       logLevel: 'normal',
@@ -261,6 +264,43 @@ describe(launchRushFrontendAsync.name, () => {
     }
   });
 
+  it('keeps an active purge reporter log outside the temp folder being purged', async () => {
+    const order: string[] = [];
+    let commonTempFolder: string | undefined = 'not-captured';
+    let actionName: string | undefined;
+    const originalArgv: string[] = process.argv;
+    process.argv = ['node', 'rush', 'purge', '--reporter=file'];
+
+    try {
+      await launchRushFrontendAsync({
+        currentPackageVersion: '5.178.1',
+        rushVersionToLoad: undefined,
+        configuration: {
+          commonTempFolder: '/repo/common/temp',
+          useRushReporter: false
+        } as MinimalRushConfiguration,
+        launchOptions: { isManaged: false },
+        currentRushLib: rushLib,
+        initializeReporterHostAsync: async (options) => {
+          commonTempFolder = options.commonTempFolder;
+          actionName = options.actionName;
+          return createInitializedHostAsync(order, 'explicit --reporter');
+        },
+        executeCurrentRush: (version, selectedRushLib, launchOptions) => {
+          void version;
+          void selectedRushLib;
+          return launchOptions.reporterCloseAsync();
+        },
+        processLifecycle: createTestProcessLifecycle()
+      });
+
+      expect(actionName).toBe('purge');
+      expect(commonTempFolder).toBeUndefined();
+    } finally {
+      process.argv = originalArgv;
+    }
+  });
+
   it('rejects an explicit reporter before initializing an incompatible selected engine', async () => {
     const directory: string = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'rush-old-engine-'));
     const outputPath: string = path.join(directory, 'events.jsonl');
diff --git a/apps/rush/src/test/RushReporterHost.test.ts b/apps/rush/src/test/RushReporterHost.test.ts
index ad330d071fd..920d7f3a23e 100644
--- a/apps/rush/src/test/RushReporterHost.test.ts
+++ b/apps/rush/src/test/RushReporterHost.test.ts
@@ -5,7 +5,13 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 
-import type { IReporterEventSink } from '@rushstack/rush-reporter';
+import {
+  ReporterManager,
+  type IReporter,
+  type IReporterContext,
+  type IReporterEventEnvelope,
+  type IReporterEventSink
+} from '@rushstack/rush-reporter';
 
 import {
   initializeRushReporterHostAsync,
@@ -156,6 +162,23 @@ describe(resolveRushReporterSelection.name, () => {
     });
   });
 
+  it('owns standalone log-level controls when the repository experiment is enabled', () => {
+    expect(resolve(['build', '--log-level=debug'], {}, false, true)).toMatchObject({
+      reporter: 'plaintext',
+      logLevel: 'debug',
+      enabled: true,
+      reporterControlsOwnedByFrontend: true,
+      reporterValueFlagsToStrip: ['--log-level']
+    });
+    expect(resolve(['build'], { RUSH_LOG_LEVEL: 'debug' }, false, true)).toMatchObject({
+      reporter: 'plaintext',
+      logLevel: 'debug',
+      enabled: true,
+      reporterControlsOwnedByFrontend: true,
+      reporterValueFlagsToStrip: []
+    });
+  });
+
   it('preserves custom value parameters when the repository experiment selects the reporter implicitly', () => {
     expect(
       resolve(
@@ -242,6 +265,14 @@ describe(resolveRushReporterSelection.name, () => {
     });
   });
 
+  it('ignores help controls after the pass-through separator', () => {
+    expect(resolve(['build', '--reporter=json', '--', '--help'])).toMatchObject({
+      reporter: 'json',
+      enabled: true,
+      reporterControlsOwnedByFrontend: true
+    });
+  });
+
   it('removes reporter-only value controls before invoking a legacy engine', () => {
     expect(
       stripReporterValueControls([
@@ -445,21 +476,21 @@ describe(resolveRushReporterSelection.name, () => {
         params: {}
       }
     ]);
+    expect(selection).toMatchObject({
+      reporterControlsOwnedByFrontend: true,
+      reporterValueFlagsToStrip: ['--output', '--log-level']
+    });
     expect(resolve(['list', '--json', '--reporter=file']).reporter).toBe('file');
   });
 
   it('forces legacy selection for an incompatible Rush engine', () => {
-    expect(
+    expect(() =>
       resolveRushReporterSelection({
         argv: ['build', '--reporter=json'],
         env: {},
         forceLegacy: true
       })
-    ).toMatchObject({
-      reporter: 'legacy',
-      enabled: false,
-      reporterControlsOwnedByFrontend: true
-    });
+    ).toThrow(/cannot safely use --reporter=json/);
   });
 
   it('surfaces unsupported and incomplete controls with actionable errors', () => {
@@ -524,6 +555,52 @@ describe(initializeRushReporterHostAsync.name, () => {
     }
   });
 
+  it('prints the file path for a parser-only failure without commandResult', async () => {
+    const directory: string = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'rush-file-only-'));
+    let stderrText: string = '';
+    try {
+      const initialized = await initializeRushReporterHostAsync({
+        argv: ['missing-command', '--reporter=file'],
+        env: {},
+        commonTempFolder: directory,
+        actionName: 'missing-command',
+        stdout: { isTTY: false, write: () => undefined },
+        stderr: {
+          write: (text: string) => {
+            stderrText += text;
+          }
+        }
+      });
+      initialized.sink.emit({
+        protocolVersion: { major: 1, minor: 1 },
+        sessionId: 'session',
+        source: { packageName: '@microsoft/rush', packageVersion: '5.178.1' },
+        privacy: 'local-sensitive',
+        type: 'artifactAvailable',
+        payload: {
+          role: 'log',
+          path: initialized.logArtifact?.path,
+          format: 'plaintext',
+          complete: false
+        }
+      });
+      initialized.sink.emit({
+        protocolVersion: { major: 1, minor: 1 },
+        sessionId: 'session',
+        source: { packageName: '@microsoft/rush-lib', packageVersion: '5.178.1' },
+        privacy: 'public',
+        type: 'sessionCompleted',
+        payload: { exitCode: 1 }
+      });
+      await initialized.closeAsync();
+
+      expect(stderrText.match(/Rush full log:/g)).toHaveLength(1);
+      expect(stderrText).toContain(initialized.logArtifact?.path);
+    } finally {
+      await fs.promises.rm(directory, { recursive: true, force: true });
+    }
+  });
+
   it('does not render operation output at quiet plaintext log level', async () => {
     let output: string = '';
     const quietHost = await initializeRushReporterHostAsync({
@@ -629,6 +706,19 @@ describe(initializeRushReporterHostAsync.name, () => {
       });
 
       emitCommandStarted(initialized.sink);
+      initialized.sink.emit({
+        protocolVersion: { major: 1, minor: 1 },
+        sessionId: 'session',
+        source: { packageName: '@microsoft/rush', packageVersion: '5.178.1' },
+        privacy: 'local-sensitive',
+        type: 'artifactAvailable',
+        payload: {
+          role: 'log',
+          path: initialized.logArtifact?.path,
+          format: 'plaintext',
+          complete: false
+        }
+      });
       initialized.sink.emit({
         protocolVersion: { major: 1, minor: 1 },
         sessionId: 'session',
@@ -650,4 +740,70 @@ describe(initializeRushReporterHostAsync.name, () => {
       await fs.promises.rm(directory, { recursive: true, force: true });
     }
   });
+
+  it('publishes artifact completeness as a frozen boolean snapshot', async () => {
+    const directory: string = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'rush-artifact-snapshot-'));
+    const reported: IReporterEventEnvelope<unknown>[] = [];
+    const manager: ReporterManager = new ReporterManager();
+    const captureReporter: IReporter = {
+      name: 'capture',
+      initializeAsync: async (context: IReporterContext) => {
+        void context;
+      },
+      report: (event: IReporterEventEnvelope<unknown>) => {
+        reported.push(event);
+      },
+      flushAsync: async () => undefined,
+      closeAsync: async () => undefined
+    };
+    manager.addReporter(captureReporter);
+    try {
+      const initialized = await initializeRushReporterHostAsync({
+        argv: ['build', '--reporter=json'],
+        env: {},
+        commonTempFolder: directory,
+        actionName: 'build',
+        stdout: { isTTY: false, write: () => undefined },
+        manager
+      });
+      initialized.sink.emit({
+        protocolVersion: { major: 1, minor: 1 },
+        sessionId: 'session',
+        source: { packageName: '@microsoft/rush', packageVersion: '5.178.1' },
+        privacy: 'local-sensitive',
+        type: 'artifactAvailable',
+        payload: {
+          role: 'log',
+          path: initialized.logArtifact?.path,
+          format: 'plaintext',
+          complete: false
+        }
+      });
+      initialized.sink.emit({
+        protocolVersion: { major: 1, minor: 1 },
+        sessionId: 'session',
+        source: { packageName: '@microsoft/rush-lib', packageVersion: '5.178.1' },
+        privacy: 'public',
+        type: 'commandResult',
+        payload: { commandName: 'build', succeeded: true, exitCode: 0 }
+      });
+      await initialized.closeAsync();
+
+      const finalArtifact: IReporterEventEnvelope<unknown> = reported
+        .filter(({ type }) => type === 'artifactAvailable')
+        .at(-1)!;
+      const descriptor: PropertyDescriptor | undefined = Object.getOwnPropertyDescriptor(
+        finalArtifact.payload as object,
+        'complete'
+      );
+      expect(descriptor).toMatchObject({ value: true, writable: false });
+      expect(typeof (finalArtifact.payload as { complete: unknown }).complete).toBe('boolean');
+      expect(finalArtifact.source).toEqual({
+        packageName: '@microsoft/rush',
+        packageVersion: '5.178.1'
+      });
+    } finally {
+      await fs.promises.rm(directory, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/apps/rush/src/test/sandbox/reporter-demo/README.md b/apps/rush/src/test/sandbox/reporter-demo/README.md
index b28e69da7dc..7879a7bf71c 100644
--- a/apps/rush/src/test/sandbox/reporter-demo/README.md
+++ b/apps/rush/src/test/sandbox/reporter-demo/README.md
@@ -11,8 +11,9 @@ The script runs the same `rush build --only @rushstack/rush-reporter` operation
 plaintext, JSON, AI, file, and quiet modes, plus parser failure, help, and command-specific JSON cases.
 It verifies payload-only machine stdout, one visible writer, ordered/lossless plaintext grouping from a
 same-invocation JSON sidecar, final artifact completeness, owner-only log permissions, failure flushing,
-AI parser-error context, command-JSON ownership, and the `RUSH_REPORTER=legacy` rollback transcript. Captured
-stdout/stderr files are written to a temporary folder.
+AI parser-error context, command-JSON ownership, CI plaintext output, cache-path output, normalized
+`RUSH_TEMP_FOLDER` log placement, matching purge-path selection, and the `RUSH_REPORTER=legacy` rollback
+transcript. Captured stdout/stderr files are written to a temporary folder.
 
 For an individual invocation:
 
diff --git a/apps/rush/src/test/sandbox/reporter-demo/run.mjs b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
index 519562ab5fc..3441b2a491f 100644
--- a/apps/rush/src/test/sandbox/reporter-demo/run.mjs
+++ b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
@@ -43,6 +43,9 @@ const json = run('json', [...commonArgs, '--reporter=json', '--log-level=debug']
 const ai = run('ai', [...commonArgs, '--reporter=ai']).stdout;
 const file = run('file', [...commonArgs, '--reporter=file']);
 const quiet = run('quiet', [...commonArgs, '--reporter=plaintext', '--log-level=quiet']).stdout;
+const verbose = run('verbose', [...commonArgs, '--reporter=plaintext', '--verbose']).stdout;
+const debug = run('debug', [...commonArgs, '--reporter=plaintext', '--log-level=debug']).stdout;
+const ci = run('ci', [...commonArgs, '--reporter=plaintext'], { CI: 'true' }).stdout;
 const failureJson = run(
   'failure-json',
   ['build', '--only', '@rushstack/does-not-exist', '--reporter=json'],
@@ -59,6 +62,26 @@ const flagOffHelp = run('help-flag-off', ['--help']).stdout;
 const help = run('help', ['--help', '--reporter=json'], { RUSH_REPORTER: 'legacy' }).stdout;
 const commandJson = run('command-json', ['list', '--json', '--reporter=file']);
 const commandJsonConflict = run('command-json-conflict', ['list', '--json', '--reporter=json'], {}, 1);
+const tempOverride = path.join(outputFolder, 'rush-temp-override');
+const tempOverrideFile = run('temp-override', [...commonArgs, '--reporter=file'], {
+  RUSH_TEMP_FOLDER: tempOverride
+});
+const tempOverrideLogMatch = tempOverrideFile.stderr.match(/^Rush full log: (.+)$/m);
+if (
+  !tempOverrideLogMatch ||
+  !tempOverrideLogMatch[1].startsWith(path.join(tempOverride, 'rush-logs')) ||
+  !fs.existsSync(tempOverrideLogMatch[1])
+) {
+  throw new Error('RUSH_TEMP_FOLDER did not own the full-detail log path.');
+}
+const tempPurge = run('temp-purge', ['purge', '--reporter=file'], { RUSH_TEMP_FOLDER: tempOverride });
+if (!tempPurge.stdout.includes(`Purging ${tempOverride}`)) {
+  throw new Error('rush purge did not use the same normalized RUSH_TEMP_FOLDER path as the reporter log.');
+}
+const purgeLogMatch = tempPurge.stderr.match(/^Rush full log: (.+)$/m);
+if (!purgeLogMatch || purgeLogMatch[1].startsWith(tempOverride) || !fs.existsSync(purgeLogMatch[1])) {
+  throw new Error('The active purge reporter log was not preserved outside RUSH_TEMP_FOLDER.');
+}
 
 function parseNdjson(text, name) {
   if (text.includes('\u001b')) {
@@ -132,6 +155,9 @@ if (groupedOutput !== rawOutput) {
 if ((rawOutput.match(/---- build started ----/g) ?? []).length !== 1) {
   throw new Error('The operation output contains a duplicated or missing build-start marker.');
 }
+if (!/build cache/i.test(rawOutput)) {
+  throw new Error('Cache-path output was not preserved in the raw operation stream.');
+}
 if (plaintext.includes('Rush Multi-Project Build Tool') || plaintext.includes('1 of 1 ]==')) {
   throw new Error('The reporter path has more than one visible terminal writer.');
 }
@@ -156,6 +182,12 @@ if (
 if (quiet.includes('build started') || quiet.includes('==[ @rushstack/rush-reporter')) {
   throw new Error('Quiet output leaked detailed operation output.');
 }
+if (!verbose.includes('Incremental strategy:') || !debug.includes('Incremental strategy:')) {
+  throw new Error('Verbose and debug reporter output did not preserve Rush terminal verbosity.');
+}
+if (ci.includes('\u001b') || !ci.includes('@rushstack/rush-reporter: success')) {
+  throw new Error('CI output was not append-only plaintext.');
+}
 
 const fileLogMatch = file.stderr.match(/^Rush full log: (.+)$/m);
 if (file.stdout !== '' || !fileLogMatch || !fs.existsSync(fileLogMatch[1])) {
diff --git a/common/reviews/api/rush-lib.api.md b/common/reviews/api/rush-lib.api.md
index 07d1b73e8ca..6c7512de315 100644
--- a/common/reviews/api/rush-lib.api.md
+++ b/common/reviews/api/rush-lib.api.md
@@ -254,6 +254,8 @@ export class EnvironmentConfiguration {
     //
     // @internal
     static _getRushGlobalFolderOverride(processEnv: IEnvironment): string | undefined;
+    // @internal
+    static _getRushTempFolderOverride(processEnv: IEnvironment): string | undefined;
     static get gitBinaryPath(): string | undefined;
     static get hasBeenValidated(): boolean;
     // (undocumented)
diff --git a/common/reviews/api/rush-reporter.api.md b/common/reviews/api/rush-reporter.api.md
index 421f605acb4..61c3428c1dd 100644
--- a/common/reviews/api/rush-reporter.api.md
+++ b/common/reviews/api/rush-reporter.api.md
@@ -583,6 +583,7 @@ export interface ILiveRegionState {
 
 // @beta
 export interface IMessageEmittedPayload {
+    readonly minimumLogLevel?: ReporterLogLevel;
     readonly privacy?: ReporterPrivacyClassification;
     readonly severity: ReporterMessageSeverity;
     readonly text: string;
@@ -1037,6 +1038,7 @@ export interface IScopedLogger {
 
 // @beta
 export interface IScopedMessageOptions {
+    readonly minimumLogLevel?: ReporterLogLevel;
     readonly privacy?: ReporterPrivacyClassification;
     readonly severity: ReporterMessageSeverity;
     readonly text: string;
@@ -1409,6 +1411,8 @@ export class ReporterManager implements IReporterEventSink {
     addReporter(reporter: IReporter, options?: IReporterRegistrationOptions): void;
     closeAsync(timeoutMs?: number): Promise<void>;
     emit<TPayload>(event: IReporterEmitEventInput<TPayload>): string;
+    // @internal
+    _flushAndConfirmAsync(timeoutMs?: number): Promise<boolean>;
     flushAsync(timeoutMs?: number): Promise<void>;
     getPendingEventCount(): number;
     ingestForeignEnvelope(envelope: IReporterEventEnvelope<unknown>): string;
diff --git a/libraries/reporter/src/config/LogLevelFilter.ts b/libraries/reporter/src/config/LogLevelFilter.ts
index 6ea09cdf5f3..b4f48545397 100644
--- a/libraries/reporter/src/config/LogLevelFilter.ts
+++ b/libraries/reporter/src/config/LogLevelFilter.ts
@@ -64,7 +64,14 @@ export function getEventMinimumLogLevel(event: IReporterEventEnvelope<unknown>):
     case 'artifactAvailable':
       return 'normal';
     case 'messageEmitted': {
-      const severity: string | undefined = (event.payload as { severity?: string }).severity;
+      const payload: { severity?: string; minimumLogLevel?: ReporterLogLevel } = event.payload as {
+        severity?: string;
+        minimumLogLevel?: ReporterLogLevel;
+      };
+      if (payload.minimumLogLevel !== undefined) {
+        return payload.minimumLogLevel;
+      }
+      const severity: string | undefined = payload.severity;
       if (severity === 'error' || severity === 'warning') {
         return 'quiet';
       }
diff --git a/libraries/reporter/src/events/IMessageEmittedPayload.ts b/libraries/reporter/src/events/IMessageEmittedPayload.ts
index e45f8c66e3c..beeb041e217 100644
--- a/libraries/reporter/src/events/IMessageEmittedPayload.ts
+++ b/libraries/reporter/src/events/IMessageEmittedPayload.ts
@@ -3,6 +3,7 @@
 
 import type { ReporterPrivacyClassification } from './ReporterPrivacyClassification';
 import type { ReporterMessageSeverity } from '../producers/IScopedReporter';
+import type { ReporterLogLevel } from '../config/ReporterNames';
 
 /**
  * The payload of a `messageEmitted` event: a human-oriented message from a
@@ -30,6 +31,11 @@ export interface IMessageEmittedPayload {
    */
   readonly text: string;
 
+  /**
+   * An optional minimum reporter log level for this message.
+   */
+  readonly minimumLogLevel?: ReporterLogLevel;
+
   /**
    * The privacy classification of {@link IMessageEmittedPayload.text}.
    * Defaults to `local-sensitive`.
diff --git a/libraries/reporter/src/manager/ReporterManager.ts b/libraries/reporter/src/manager/ReporterManager.ts
index 657e88c17a6..26628629218 100644
--- a/libraries/reporter/src/manager/ReporterManager.ts
+++ b/libraries/reporter/src/manager/ReporterManager.ts
@@ -275,6 +275,20 @@ export class ReporterManager implements IReporterEventSink {
     }
   }
 
+  /**
+   * Flushes reporters and reports whether every lifecycle action completed before the timeout.
+   *
+   * @internal
+   */
+  public async _flushAndConfirmAsync(timeoutMs: number = DEFAULT_FLUSH_TIMEOUT_MS): Promise<boolean> {
+    return await this._settleAndConfirmAsync(async (entry: IReporterEntry): Promise<void> => {
+      await entry.drainPromise;
+      if (!entry.disabled) {
+        await entry.reporter.flushAsync();
+      }
+    }, timeoutMs);
+  }
+
   /**
    * Performs a best-effort flush suitable for signal termination.
    *
@@ -432,6 +446,26 @@ export class ReporterManager implements IReporterEventSink {
     }
   }
 
+  private async _settleAndConfirmAsync(
+    action: (entry: IReporterEntry) => Promise<void>,
+    timeoutMs: number
+  ): Promise<boolean> {
+    const work: Promise<true> = Promise.all(
+      this._entries.map((entry: IReporterEntry) => this._scheduleLifecycleAction(entry, action))
+    ).then(() => true as const);
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeout: Promise<false> = new Promise<false>((resolve: (value: false) => void) => {
+      timer = setTimeout(() => resolve(false), timeoutMs);
+    });
+    try {
+      return await Promise.race([work, timeout]);
+    } finally {
+      if (timer !== undefined) {
+        clearTimeout(timer);
+      }
+    }
+  }
+
   private _scheduleLifecycleAction(
     entry: IReporterEntry,
     action: (entry: IReporterEntry) => Promise<void>
diff --git a/libraries/reporter/src/producers/IScopedReporter.ts b/libraries/reporter/src/producers/IScopedReporter.ts
index 2d185cbc858..88f65ff8311 100644
--- a/libraries/reporter/src/producers/IScopedReporter.ts
+++ b/libraries/reporter/src/producers/IScopedReporter.ts
@@ -3,6 +3,7 @@
 
 import type { ReporterPrivacyClassification } from '../events/ReporterPrivacyClassification';
 import type { ReporterJsonValue } from '../events/ReporterJsonValue';
+import type { ReporterLogLevel } from '../config/ReporterNames';
 import type { IRushDiagnostic } from '../diagnostics/IRushDiagnostic';
 import type { ReporterExtensionEventName } from './ReporterExtensionEventName';
 
@@ -33,6 +34,11 @@ export interface IScopedMessageOptions {
    */
   readonly text: string;
 
+  /**
+   * An optional minimum reporter log level for this message.
+   */
+  readonly minimumLogLevel?: ReporterLogLevel;
+
   /**
    * The privacy classification of the message text. Defaults to
    * `local-sensitive`: free-form text fails safe, so a hand-written path or
diff --git a/libraries/reporter/src/reporters/AiReporter.ts b/libraries/reporter/src/reporters/AiReporter.ts
index e522f094fd8..dabf575d1ed 100644
--- a/libraries/reporter/src/reporters/AiReporter.ts
+++ b/libraries/reporter/src/reporters/AiReporter.ts
@@ -129,6 +129,7 @@ export class AiReporter implements IReporter {
   private _logFormat: string | undefined;
   private _artifactComplete: boolean;
   private _finalEmitted: boolean;
+  private _pendingResult: { succeeded: boolean; exitCode: number } | undefined;
 
   public constructor(options: IAiReporterOptions) {
     this._write = options.write;
@@ -163,6 +164,7 @@ export class AiReporter implements IReporter {
     this._logFormat = undefined;
     this._artifactComplete = true;
     this._finalEmitted = false;
+    this._pendingResult = undefined;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -255,13 +257,13 @@ export class AiReporter implements IReporter {
           succeeded: boolean;
           exitCode: number;
         };
-        this._emitFinal(payload.succeeded, payload.exitCode);
+        this._pendingResult = payload;
         break;
       }
       case 'sessionCompleted': {
-        if (!this._finalEmitted) {
+        if (!this._pendingResult) {
           const exitCode: number = (event.payload as { exitCode?: number }).exitCode ?? 1;
-          this._emitFinal(exitCode === 0, exitCode);
+          this._pendingResult = { succeeded: exitCode === 0, exitCode };
         }
         break;
       }
@@ -276,7 +278,11 @@ export class AiReporter implements IReporter {
 
   public async closeAsync(): Promise<void> {
     if (!this._finalEmitted) {
-      this._emitFinal(false, 1);
+      const result: { succeeded: boolean; exitCode: number } = this._pendingResult ?? {
+        succeeded: false,
+        exitCode: 1
+      };
+      this._emitFinal(result.succeeded, result.exitCode);
     }
   }
 
@@ -330,17 +336,17 @@ export class AiReporter implements IReporter {
             summary
           }))
         : [];
-    const errorDiagnostics: IAiDiagnostic[] =
-      fallbackDiagnostics.length > 0 ? fallbackDiagnostics : this._errorDiagnostics;
-    const errorCount: number =
-      this._errorCount + (fallbackDiagnostics.length > 0 ? this._fallbackErrorCount : 0);
-    const errorCodes: string[] =
-      fallbackDiagnostics.length > 0 ? ['RUSH_COMMAND_FAILED'] : [...this._errorCodes].sort();
+    const hasFallbackErrors: boolean = this._errorCount === 0 && this._fallbackErrorCount > 0;
+    const errorDiagnostics: IAiDiagnostic[] = hasFallbackErrors
+      ? fallbackDiagnostics
+      : this._errorDiagnostics;
+    const errorCount: number = this._errorCount + (hasFallbackErrors ? this._fallbackErrorCount : 0);
+    const errorCodes: string[] = hasFallbackErrors ? ['RUSH_COMMAND_FAILED'] : [...this._errorCodes].sort();
     const diagnosticCategoryCounts: { [category: string]: number } = {
       ...this._diagnosticCategoryCounts
     };
-    if (fallbackDiagnostics.length > 0) {
-      diagnosticCategoryCounts.command = (diagnosticCategoryCounts.command ?? 0) + fallbackDiagnostics.length;
+    if (hasFallbackErrors) {
+      diagnosticCategoryCounts.command = (diagnosticCategoryCounts.command ?? 0) + this._fallbackErrorCount;
     }
     const hasFailures: boolean = !succeeded || errorCount > 0;
     // When failures exist, warnings are represented by counts only. Warning-only
@@ -374,7 +380,7 @@ export class AiReporter implements IReporter {
       warningCount: this._warningCount,
       operationCounts: { ...this._operationCounts },
       truncated: hasFailures
-        ? this._errorDiagnosticsTruncated || (fallbackDiagnostics.length > 0 && this._fallbackErrorsTruncated)
+        ? this._errorDiagnosticsTruncated || (hasFallbackErrors && this._fallbackErrorsTruncated)
         : this._warningDiagnosticsTruncated
     };
 
diff --git a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
index 453b9cd3d06..3d1b8438d82 100644
--- a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
+++ b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
@@ -239,7 +239,7 @@ export class DefaultInteractiveReporter implements IReporter {
       case 'activityChanged': {
         const payload: { kind?: string; text?: string } = event.payload as { kind?: string; text?: string };
         if (payload.text !== undefined) {
-          this._latestActivity = payload.text;
+          this._latestActivity = this._toSingleLine(payload.text);
         }
         break;
       }
@@ -249,7 +249,7 @@ export class DefaultInteractiveReporter implements IReporter {
           text?: string;
         };
         if (payload.text !== undefined) {
-          this._latestActivity = payload.text;
+          this._latestActivity = this._toSingleLine(payload.text);
           if (
             event.scope?.operationId === undefined &&
             (payload.severity === 'error' || payload.severity === 'warning')
@@ -285,6 +285,14 @@ export class DefaultInteractiveReporter implements IReporter {
     }
   }
 
+  private _toSingleLine(text: string): string {
+    const lines: string[] = text
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean);
+    return lines.at(-1) ?? '';
+  }
+
   private _snapshot(): ILiveRegionState {
     return {
       commandName: this._commandName,
diff --git a/libraries/reporter/src/reporters/FileReporter.ts b/libraries/reporter/src/reporters/FileReporter.ts
index 075cabe7adb..9e2ca30a902 100644
--- a/libraries/reporter/src/reporters/FileReporter.ts
+++ b/libraries/reporter/src/reporters/FileReporter.ts
@@ -42,6 +42,7 @@ const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
 interface IFileOperationRecord {
   readonly title: string;
   spoolPath?: string;
+  spoolFileDescriptor?: number;
   spoolFailed?: boolean;
 }
 
@@ -51,6 +52,11 @@ function getUserTempDirectoryName(): string {
   return `${RUSH_LOGS_DIR_NAME}-${identity.replace(/[^a-zA-Z0-9_.-]/g, '_')}`;
 }
 
+function sanitizeActionName(actionName: string): string {
+  const sanitized: string = actionName.replace(/[^a-zA-Z0-9_.-]+/g, '_');
+  return sanitized === '.' || sanitized === '..' || sanitized.length === 0 ? 'rush' : sanitized;
+}
+
 /**
  * The resolved full-detail log artifact.
  *
@@ -153,6 +159,7 @@ export class FileReporter implements IReporter {
   private _targetResolved: boolean;
   private _available: boolean;
   private _complete: boolean;
+  private _canComplete: boolean;
   private _targetPath: string | undefined;
   private _latestCopyPath: string | undefined;
   private readonly _fileName: string;
@@ -161,7 +168,7 @@ export class FileReporter implements IReporter {
   public constructor(options: IFileReporterOptions = {}) {
     this._commonTempFolder = options.commonTempFolder;
     this._osTempFolder = options.osTempFolder ?? os.tmpdir();
-    this._actionName = options.actionName ?? 'rush';
+    this._actionName = sanitizeActionName(options.actionName ?? 'rush');
     this._pid = options.pid ?? process.pid;
     this._nowMs = options.nowMs ?? (() => Date.now());
     this._retentionDays = options.retentionDays ?? DEFAULT_RETENTION_DAYS;
@@ -178,6 +185,7 @@ export class FileReporter implements IReporter {
     this._targetResolved = false;
     this._available = false;
     this._complete = false;
+    this._canComplete = true;
     this._targetPath = undefined;
     this._latestCopyPath = undefined;
     this._nextSpoolId = 1;
@@ -229,6 +237,7 @@ export class FileReporter implements IReporter {
       } catch (error) {
         this._available = false;
         this._complete = false;
+        this._canComplete = false;
         this._emergencyWarn(
           `[reporter] Unable to close the full-detail log; the artifact is unavailable: ${(error as Error).message}`
         );
@@ -237,6 +246,7 @@ export class FileReporter implements IReporter {
       }
     }
     await this._refreshLatestCopyAsync();
+    this._complete = this._available && this._canComplete;
   }
 
   /**
@@ -260,6 +270,10 @@ export class FileReporter implements IReporter {
         phaseName?: string;
       };
       const projectName: string = payload.projectName ?? payload.operationId;
+      const previousOperation: IFileOperationRecord | undefined = this._operations.get(payload.operationId);
+      if (previousOperation) {
+        return [this._formatMetadata(event)];
+      }
       this._operations.set(
         payload.operationId,
         this._createOperationRecord(payload.phaseName ? `${projectName} (${payload.phaseName})` : projectName)
@@ -324,10 +338,11 @@ export class FileReporter implements IReporter {
     if (!operation.spoolPath) {
       operation.spoolPath = `${this._targetPath}.${this._nextSpoolId++}.operation`;
       try {
-        fs.writeFileSync(operation.spoolPath, '', { flag: 'wx', mode: OWNER_ONLY_MODE });
+        operation.spoolFileDescriptor = fs.openSync(operation.spoolPath, 'wx', OWNER_ONLY_MODE);
       } catch (error) {
         operation.spoolFailed = true;
         operation.spoolPath = undefined;
+        operation.spoolFileDescriptor = undefined;
         this._emergencyWarn(
           `[reporter] Unable to create grouped-output spool file; output will remain ungrouped: ${(error as Error).message}`
         );
@@ -336,14 +351,23 @@ export class FileReporter implements IReporter {
     }
 
     try {
-      fs.appendFileSync(operation.spoolPath, text, { encoding: 'utf8', mode: OWNER_ONLY_MODE });
+      if (operation.spoolFileDescriptor === undefined) {
+        throw new Error('The grouped-output spool descriptor is not available.');
+      }
+      fs.writeSync(operation.spoolFileDescriptor, text, null, 'utf8');
       return [];
     } catch (error) {
-      let priorOutput: string = '';
-      try {
-        priorOutput = fs.readFileSync(operation.spoolPath, 'utf8');
-      } catch {
+      const closeError: Error | undefined = this._closeOperationSpool(operation, false);
+      if (closeError) {
         this._complete = false;
+        this._canComplete = false;
+      }
+      if (operation.spoolPath) {
+        this._writeOrBuffer(`# [${operationId} ${stream}]\n`);
+        if (!this._appendSpoolFile(operation.spoolPath)) {
+          this._complete = false;
+          this._canComplete = false;
+        }
       }
       try {
         fs.rmSync(operation.spoolPath, { force: true });
@@ -355,7 +379,7 @@ export class FileReporter implements IReporter {
       this._emergencyWarn(
         `[reporter] Unable to spool grouped output for ${JSON.stringify(operationId)}; output will remain ungrouped: ${(error as Error).message}`
       );
-      return [`# [${operationId} ${stream}]\n`, priorOutput, text];
+      return [text];
     }
   }
 
@@ -366,26 +390,21 @@ export class FileReporter implements IReporter {
     }
     this._writeOrBuffer(`\n==[ ${operation.title} ]==\n`);
     if (operation.spoolPath !== undefined) {
+      const closeError: Error | undefined = this._closeOperationSpool(operation, true);
+      if (closeError) {
+        this._complete = false;
+        this._canComplete = false;
+        this._emergencyWarn(
+          `[reporter] Unable to close grouped output for ${JSON.stringify(operationId)}: ${closeError.message}`
+        );
+      }
       try {
-        if (this._fileDescriptor !== undefined) {
-          const source: number = fs.openSync(operation.spoolPath, 'r');
-          try {
-            const buffer: Buffer = Buffer.allocUnsafe(64 * 1024);
-            let bytesRead: number;
-            let lastByte: number | undefined;
-            while ((bytesRead = fs.readSync(source, buffer, 0, buffer.length, null)) > 0) {
-              fs.writeSync(this._fileDescriptor, buffer, 0, bytesRead);
-              lastByte = buffer[bytesRead - 1];
-            }
-            if (lastByte !== undefined && lastByte !== 0x0a) {
-              this._writeLine('\n');
-            }
-          } finally {
-            fs.closeSync(source);
-          }
+        if (!this._appendSpoolFile(operation.spoolPath)) {
+          throw new Error('The grouped output could not be appended to the full-detail log.');
         }
       } catch (error) {
         this._complete = false;
+        this._canComplete = false;
         this._emergencyWarn(
           `[reporter] Unable to append grouped output for ${JSON.stringify(operationId)}: ${(error as Error).message}`
         );
@@ -400,6 +419,40 @@ export class FileReporter implements IReporter {
     this._writeOrBuffer(`==[ ${operationId}: ${status} ]==\n`);
   }
 
+  private _appendSpoolFile(spoolPath: string): boolean {
+    if (this._fileDescriptor === undefined) {
+      return false;
+    }
+    let source: number | undefined;
+    let appended: boolean = false;
+    let closed: boolean = true;
+    try {
+      source = fs.openSync(spoolPath, 'r');
+      const buffer: Buffer = Buffer.allocUnsafe(64 * 1024);
+      let bytesRead: number;
+      let lastByte: number | undefined;
+      while ((bytesRead = fs.readSync(source, buffer, 0, buffer.length, null)) > 0) {
+        fs.writeSync(this._fileDescriptor, buffer, 0, bytesRead);
+        lastByte = buffer[bytesRead - 1];
+      }
+      if (lastByte !== undefined && lastByte !== 0x0a) {
+        this._writeLine('\n');
+      }
+      appended = true;
+    } catch {
+      appended = false;
+    } finally {
+      if (source !== undefined) {
+        try {
+          fs.closeSync(source);
+        } catch {
+          closed = false;
+        }
+      }
+    }
+    return appended && closed;
+  }
+
   private _writeOrBuffer(line: string): void {
     if (this._fileDescriptor === undefined) {
       if (!this._targetResolved) {
@@ -460,7 +513,12 @@ export class FileReporter implements IReporter {
     }
     this._available = false;
     this._complete = false;
+    this._canComplete = false;
     this._lines.length = 0;
+    for (const operation of this._operations.values()) {
+      this._discardOperationSpool(operation);
+      operation.spoolFailed = true;
+    }
     if (this._fileDescriptor !== undefined) {
       try {
         fs.closeSync(this._fileDescriptor);
@@ -474,6 +532,45 @@ export class FileReporter implements IReporter {
     );
   }
 
+  private _closeOperationSpool(operation: IFileOperationRecord, flush: boolean): Error | undefined {
+    const fileDescriptor: number | undefined = operation.spoolFileDescriptor;
+    if (fileDescriptor === undefined) {
+      return undefined;
+    }
+    operation.spoolFileDescriptor = undefined;
+
+    let closeError: Error | undefined;
+    if (flush) {
+      try {
+        fs.fsyncSync(fileDescriptor);
+      } catch (error) {
+        closeError = error as Error;
+      }
+    }
+    try {
+      fs.closeSync(fileDescriptor);
+    } catch (error) {
+      closeError ??= error as Error;
+    }
+    return closeError;
+  }
+
+  private _discardOperationSpool(operation: IFileOperationRecord): void {
+    const closeError: Error | undefined = this._closeOperationSpool(operation, false);
+    if (closeError) {
+      this._complete = false;
+      this._canComplete = false;
+    }
+    if (operation.spoolPath) {
+      try {
+        fs.rmSync(operation.spoolPath, { force: true });
+      } catch {
+        /* Best-effort cleanup. */
+      }
+      operation.spoolPath = undefined;
+    }
+  }
+
   private async _resolveTargetAsync(): Promise<void> {
     const candidateDirs: Array<{ path: string; ownerOnly: boolean }> = [];
     if (this._commonTempFolder !== undefined) {
@@ -502,7 +599,6 @@ export class FileReporter implements IReporter {
         this._fileDescriptor = fileDescriptor;
         this._targetPath = filePath;
         this._available = true;
-        this._complete = true;
         await this._updateLatestAsync(dir, filePath);
         await this._applyRetentionAsync(dir);
         return;
@@ -513,6 +609,7 @@ export class FileReporter implements IReporter {
 
     this._available = false;
     this._complete = false;
+    this._canComplete = false;
     this._lines.length = 0;
     this._emergencyWarn(
       `[reporter] Unable to write the full-detail log; the artifact is unavailable: ${lastError?.message ?? 'unknown error'}`
diff --git a/libraries/reporter/src/reporters/PlaintextReporter.ts b/libraries/reporter/src/reporters/PlaintextReporter.ts
index 78b4ccebb47..ba13e0469bd 100644
--- a/libraries/reporter/src/reporters/PlaintextReporter.ts
+++ b/libraries/reporter/src/reporters/PlaintextReporter.ts
@@ -31,6 +31,7 @@ interface IOperationRecord {
   readonly phaseName?: string;
   readonly silent: boolean;
   spoolPath?: string;
+  spoolFileDescriptor?: number;
   spoolFailed?: boolean;
 }
 
@@ -148,6 +149,10 @@ export class PlaintextReporter implements IReporter {
           phaseName?: string;
           silent?: boolean;
         };
+        const previousRecord: IOperationRecord | undefined = this._operations.get(payload.operationId);
+        if (previousRecord) {
+          break;
+        }
         this._operations.set(payload.operationId, {
           projectName: payload.projectName ?? payload.operationId,
           phaseName: payload.phaseName,
@@ -321,18 +326,15 @@ export class PlaintextReporter implements IReporter {
       if (!record.spoolPath) {
         const spoolDirectory: string = this._ensureSpoolDirectory();
         record.spoolPath = path.join(spoolDirectory, `${this._nextSpoolId++}.operation`);
-        fs.writeFileSync(record.spoolPath, '', { flag: 'wx', mode: OWNER_ONLY_MODE });
+        record.spoolFileDescriptor = fs.openSync(record.spoolPath, 'wx', OWNER_ONLY_MODE);
       }
-      fs.appendFileSync(record.spoolPath, text, { encoding: 'utf8', mode: OWNER_ONLY_MODE });
-    } catch (error) {
-      if (record.spoolPath) {
-        try {
-          this._writeRaw(fs.readFileSync(record.spoolPath, 'utf8'));
-        } catch {
-          /* Preserve subsequent output even if the prior spool cannot be recovered. */
-        }
+      if (record.spoolFileDescriptor === undefined) {
+        throw new Error('The grouped plaintext spool descriptor is not available.');
       }
-      this._deleteSpool(record);
+      fs.writeSync(record.spoolFileDescriptor, text, null, 'utf8');
+    } catch (error) {
+      this._closeSpool(record, false);
+      this._writeSpooledOutput(record);
       record.spoolFailed = true;
       this._writeLine(`[reporter] Unable to spool grouped plaintext output: ${(error as Error).message}`);
       this._writeRaw(text);
@@ -343,7 +345,12 @@ export class PlaintextReporter implements IReporter {
     if (!record.spoolPath) {
       return;
     }
+    const spoolCloseError: Error | undefined = this._closeSpool(record, true);
+    if (spoolCloseError) {
+      this._writeLine(`[reporter] Unable to close grouped plaintext output: ${spoolCloseError.message}`);
+    }
     let fileDescriptor: number | undefined;
+    let readCloseError: Error | undefined;
     try {
       fileDescriptor = fs.openSync(record.spoolPath, 'r');
       const decoder: StringDecoder = new StringDecoder('utf8');
@@ -359,9 +366,16 @@ export class PlaintextReporter implements IReporter {
       );
     } finally {
       if (fileDescriptor !== undefined) {
-        fs.closeSync(fileDescriptor);
+        try {
+          fs.closeSync(fileDescriptor);
+        } catch (error) {
+          readCloseError = error as Error;
+        }
       }
       this._deleteSpool(record);
+      if (readCloseError) {
+        this._writeLine(`[reporter] Unable to close grouped plaintext input: ${readCloseError.message}`);
+      }
     }
   }
 
@@ -374,6 +388,7 @@ export class PlaintextReporter implements IReporter {
   }
 
   private _deleteSpool(record: IOperationRecord): void {
+    this._closeSpool(record, false);
     if (!record.spoolPath) {
       return;
     }
@@ -385,6 +400,28 @@ export class PlaintextReporter implements IReporter {
     record.spoolPath = undefined;
   }
 
+  private _closeSpool(record: IOperationRecord, flush: boolean): Error | undefined {
+    const fileDescriptor: number | undefined = record.spoolFileDescriptor;
+    if (fileDescriptor === undefined) {
+      return undefined;
+    }
+    record.spoolFileDescriptor = undefined;
+    let closeError: Error | undefined;
+    if (flush) {
+      try {
+        fs.fsyncSync(fileDescriptor);
+      } catch (error) {
+        closeError = error as Error;
+      }
+    }
+    try {
+      fs.closeSync(fileDescriptor);
+    } catch (error) {
+      closeError ??= error as Error;
+    }
+    return closeError;
+  }
+
   private _removeSpoolDirectory(): void {
     if (!this._spoolDirectory) {
       return;
diff --git a/libraries/reporter/src/session/ScopedReporterFactory.ts b/libraries/reporter/src/session/ScopedReporterFactory.ts
index ebf3161ee71..f39e7e34f58 100644
--- a/libraries/reporter/src/session/ScopedReporterFactory.ts
+++ b/libraries/reporter/src/session/ScopedReporterFactory.ts
@@ -74,7 +74,13 @@ export function createScopedReporter(options: ICreateScopedReporterOptions): ISc
         // Message text fails safe at local-sensitive by default.
         privacy: messageOptions.privacy ?? 'local-sensitive',
         type: 'messageEmitted',
-        payload: { severity: messageOptions.severity, text: messageOptions.text }
+        payload: {
+          severity: messageOptions.severity,
+          text: messageOptions.text,
+          ...(messageOptions.minimumLogLevel === undefined
+            ? {}
+            : { minimumLogLevel: messageOptions.minimumLogLevel })
+        }
       });
     },
 
diff --git a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
index 43b2e53857f..f08e3ca76ee 100644
--- a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
+++ b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
@@ -186,6 +186,21 @@ describe('DefaultInteractiveReporter', () => {
     expect(terminal.output).not.toContain('executing op1');
   });
 
+  it('normalizes multiline activity to one live-region row', async () => {
+    const terminal: FakeTerminal = new FakeTerminal();
+    const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
+      terminal,
+      color: false,
+      nowMs: () => 0
+    });
+    reporter.report(ev('commandStarted', { commandName: 'build' }));
+    reporter.report(ev('messageEmitted', { severity: 'info', text: 'first line\nsecond line\n' }));
+    await reporter.flushAsync();
+
+    expect(terminal.output).toContain('second line');
+    expect(terminal.output).not.toContain('first line\nsecond line');
+  });
+
   it('omits silent operations from progress totals', async () => {
     const terminal: FakeTerminal = new FakeTerminal();
     const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
diff --git a/libraries/reporter/src/test/FileReporter.test.ts b/libraries/reporter/src/test/FileReporter.test.ts
index 079655c7e11..e6846338d2c 100644
--- a/libraries/reporter/src/test/FileReporter.test.ts
+++ b/libraries/reporter/src/test/FileReporter.test.ts
@@ -105,6 +105,22 @@ describe('FileReporter', () => {
     });
   });
 
+  it('sanitizes action names so the log cannot escape rush-logs', async () => {
+    await withTempDir(async (base: string) => {
+      const reporter: FileReporter = new FileReporter({
+        commonTempFolder: base,
+        actionName: 'x/../../../../victim',
+        nowMs: () => FIXED_NOW
+      });
+      await reporter.initializeAsync();
+      await reporter.closeAsync();
+
+      const artifactPath: string = reporter.getArtifact().path!;
+      expect(path.dirname(artifactPath)).toBe(path.join(base, RUSH_LOGS_DIR_NAME));
+      expect(path.basename(artifactPath)).not.toContain('/');
+    });
+  });
+
   it('maintains latest.log for a failed command too', async () => {
     await withTempDir(async (base: string) => {
       const reporter: FileReporter = new FileReporter({
@@ -179,6 +195,33 @@ describe('FileReporter', () => {
     });
   });
 
+  it('treats duplicate active registration as idempotent without losing spooled output', async () => {
+    await withTempDir(async (base: string) => {
+      const reporter: FileReporter = new FileReporter({ commonTempFolder: base, nowMs: () => FIXED_NOW });
+      await reporter.initializeAsync();
+      const registration = ev('operationRegistered', {
+        operationId: 'duplicate',
+        projectName: 'project',
+        phaseName: 'build'
+      });
+      reporter.report(registration);
+      reporter.report({
+        ...ev('externalOutput', { stream: 'stdout', text: 'first\n' }),
+        scope: { operationId: 'duplicate' }
+      });
+      reporter.report(registration);
+      reporter.report({
+        ...ev('externalOutput', { stream: 'stdout', text: 'second\n' }),
+        scope: { operationId: 'duplicate' }
+      });
+      reporter.report(ev('operationCompleted', { operationId: 'duplicate', status: 'success' }));
+      await reporter.closeAsync();
+
+      const content: string = await fs.promises.readFile(reporter.getArtifact().path!, 'utf8');
+      expect(content).toContain('first\nsecond\n==[ duplicate: success ]==');
+    });
+  });
+
   it('does not retain a file descriptor for every registered operation', async () => {
     await withTempDir(async (base: string) => {
       const reporter: FileReporter = new FileReporter({ commonTempFolder: base, nowMs: () => FIXED_NOW });
@@ -201,6 +244,70 @@ describe('FileReporter', () => {
     });
   });
 
+  it('keeps bounded persistent spool descriptors and closes each one exactly once', async () => {
+    await withTempDir(async (base: string) => {
+      const reporter: FileReporter = new FileReporter({
+        commonTempFolder: base,
+        nowMs: () => FIXED_NOW
+      });
+      await reporter.initializeAsync();
+      const logsDir: string = path.join(base, RUSH_LOGS_DIR_NAME);
+      const countOpenOperationDescriptors = (): number | undefined => {
+        const processFdFolder: string = '/proc/self/fd';
+        if (!fs.existsSync(processFdFolder)) {
+          return undefined;
+        }
+        let count: number = 0;
+        for (const entry of fs.readdirSync(processFdFolder)) {
+          try {
+            if (fs.readlinkSync(path.join(processFdFolder, entry)).endsWith('.operation')) {
+              count++;
+            }
+          } catch {
+            /* Ignore descriptors that close during enumeration. */
+          }
+        }
+        return count;
+      };
+      const baselineOpenDescriptors: number | undefined = countOpenOperationDescriptors();
+
+      for (const operationId of ['completed', 'closed']) {
+        reporter.report(
+          ev('operationRegistered', {
+            operationId,
+            projectName: operationId,
+            phaseName: 'build'
+          })
+        );
+        reporter.report({
+          ...ev('externalOutput', { stream: 'stdout', text: `${operationId}-1\n` }),
+          scope: { operationId }
+        });
+        reporter.report({
+          ...ev('externalOutput', { stream: 'stdout', text: `${operationId}-2\n` }),
+          scope: { operationId }
+        });
+      }
+
+      expect(
+        (await fs.promises.readdir(logsDir)).filter((entry) => entry.endsWith('.operation'))
+      ).toHaveLength(2);
+      if (baselineOpenDescriptors !== undefined) {
+        expect(countOpenOperationDescriptors()).toBe(baselineOpenDescriptors + 2);
+      }
+
+      reporter.report(ev('operationCompleted', { operationId: 'completed', status: 'success' }));
+      await reporter.closeAsync();
+
+      expect((await fs.promises.readdir(logsDir)).filter((entry) => entry.endsWith('.operation'))).toEqual(
+        []
+      );
+      if (baselineOpenDescriptors !== undefined) {
+        expect(countOpenOperationDescriptors()).toBe(baselineOpenDescriptors);
+      }
+    });
+  });
+
   it('excludes secret fields but keeps local-sensitive values', async () => {
     await withTempDir(async (base: string) => {
       const reporter: FileReporter = new FileReporter({ commonTempFolder: base, nowMs: () => FIXED_NOW });
diff --git a/libraries/reporter/src/test/JsonAiReporter.test.ts b/libraries/reporter/src/test/JsonAiReporter.test.ts
index c617f11a9aa..8e36d634dd8 100644
--- a/libraries/reporter/src/test/JsonAiReporter.test.ts
+++ b/libraries/reporter/src/test/JsonAiReporter.test.ts
@@ -108,6 +108,7 @@ describe('AiReporter', () => {
     for (const event of events) {
       reporter.report(event);
     }
+    void reporter.closeAsync();
     const records: Record<string, unknown>[] = parseLines(output);
     return { records, final: records[records.length - 1] as unknown as IAiFinalRecord };
   }
@@ -154,6 +155,25 @@ describe('AiReporter', () => {
     ]);
   });
 
+  it('counts fallback errors even when detailed diagnostics are disabled', async () => {
+    let output: string = '';
+    const reporter: AiReporter = new AiReporter({
+      write: (text: string) => (output += text),
+      maxDetailedDiagnostics: 0
+    });
+    reporter.report(ev('messageEmitted', { severity: 'error', text: 'first error' }));
+    reporter.report(ev('messageEmitted', { severity: 'error', text: 'second error' }));
+    reporter.report(ev('commandResult', { commandName: 'build', succeeded: false, exitCode: 1 }));
+    await reporter.closeAsync();
+
+    const final: IAiFinalRecord = parseLines(output).at(-1)! as unknown as IAiFinalRecord;
+    expect(final.errorCount).toBe(2);
+    expect(final.errorCodes).toEqual(['RUSH_COMMAND_FAILED']);
+    expect(final.diagnosticCategoryCounts.command).toBe(2);
+    expect(final.diagnostics).toEqual([]);
+    expect(final.truncated).toBe(true);
+  });
+
   it('emits a status record and a bounded final record with scope, codes, and log', () => {
     const { records, final } = run([
       ev('commandStarted', { commandName: 'build' }),
@@ -235,6 +255,7 @@ describe('AiReporter', () => {
     for (const event of events) {
       reporter.report(event);
     }
+    void reporter.closeAsync();
     const finalLine: string = output.trim().split('\n').pop() ?? '';
     expect(Buffer.byteLength(finalLine, 'utf8')).toBeLessThanOrEqual(512);
     expect((JSON.parse(finalLine) as IAiFinalRecord).truncated).toBe(true);
@@ -251,6 +272,7 @@ describe('AiReporter', () => {
     for (const event of events) {
       reporter.report(event);
     }
+    void reporter.closeAsync();
 
     const finalLine: string = output.trim().split('\n').pop()!;
     const final: IAiFinalRecord = JSON.parse(finalLine) as IAiFinalRecord;
@@ -299,6 +321,7 @@ describe('AiReporter', () => {
     reporter.report(ev('commandStarted', { commandName: 'build' }));
     reporter.report(ev('externalOutput', { stream: 'stdout', text: 'SENSITIVE-RAW-abc' }));
     reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
+    void reporter.closeAsync();
 
     expect(output).not.toContain('SENSITIVE-RAW-abc');
     // Every emitted line parses as JSON.
diff --git a/libraries/reporter/src/test/LogLevelFilter.test.ts b/libraries/reporter/src/test/LogLevelFilter.test.ts
index a50fa6d3dfa..80804ffe703 100644
--- a/libraries/reporter/src/test/LogLevelFilter.test.ts
+++ b/libraries/reporter/src/test/LogLevelFilter.test.ts
@@ -50,6 +50,11 @@ describe('getEventMinimumLogLevel', () => {
     expect(getEventMinimumLogLevel(ev('externalOutput', { stream: 'stdout', text: 'x' }))).toBe('debug');
     expect(getEventMinimumLogLevel(ev('operationStreamClosed', {}))).toBe('debug');
     expect(getEventMinimumLogLevel(ev('messageEmitted', { severity: 'debug', text: 'd' }))).toBe('debug');
+    expect(
+      getEventMinimumLogLevel(
+        ev('messageEmitted', { severity: 'debug', text: 'v', minimumLogLevel: 'verbose' })
+      )
+    ).toBe('verbose');
     expect(getEventMinimumLogLevel(ev('extension', { name: 'a.b' }, false))).toBe('normal');
   });
 });
diff --git a/libraries/reporter/src/test/Manager.test.ts b/libraries/reporter/src/test/Manager.test.ts
index cd77f28ecda..332b7beb148 100644
--- a/libraries/reporter/src/test/Manager.test.ts
+++ b/libraries/reporter/src/test/Manager.test.ts
@@ -372,6 +372,21 @@ describe('ReporterManager flush and close', () => {
     expect(true).toBe(true);
   });
 
+  it('reports whether a flush completed before its timeout', async () => {
+    let resolveFlush: (() => void) | undefined;
+    const reporter: RecordingReporter = new RecordingReporter('confirm');
+    reporter.flushAsync = () =>
+      new Promise<void>((resolve: () => void) => {
+        resolveFlush = resolve;
+      });
+    const manager: ReporterManager = new ReporterManager();
+    manager.addReporter(reporter);
+    await manager.initializeAsync();
+
+    await expect(manager._flushAndConfirmAsync(10)).resolves.toBe(false);
+    resolveFlush?.();
+  });
+
   it('does not overlap close with a timed-out flush', async () => {
     let resolveFlush: (() => void) | undefined;
     let closeCount: number = 0;
diff --git a/libraries/reporter/src/test/PlaintextReporter.test.ts b/libraries/reporter/src/test/PlaintextReporter.test.ts
index 34cbb15d61b..1a51d6843ef 100644
--- a/libraries/reporter/src/test/PlaintextReporter.test.ts
+++ b/libraries/reporter/src/test/PlaintextReporter.test.ts
@@ -101,6 +101,25 @@ describe('PlaintextReporter', () => {
     expect(capture.getOutput()).not.toContain('Building \nproject-a');
   });
 
+  it('treats duplicate active registration as idempotent', () => {
+    const capture: ICapture = makeDetailed();
+    const registration: IReporterEventEnvelope<unknown> = ev('operationRegistered', {
+      operationId: 'op1',
+      projectName: 'project-a',
+      phaseName: 'build'
+    });
+    capture.reporter.report(ev('commandStarted', { commandName: 'build' }));
+    capture.reporter.report(registration);
+    capture.reporter.report(ev('externalOutput', { text: 'first\n' }, { operationId: 'op1' }));
+    capture.reporter.report(registration);
+    capture.reporter.report(ev('externalOutput', { text: 'second\n' }, { operationId: 'op1' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
+    capture.reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
+
+    expect(capture.getOutput()).toContain('first\nsecond\nproject-a: success');
+    expect(capture.getOutput()).toContain('rush build succeeded (1/1 operations');
+  });
+
   it('streams large grouped output from disk without retaining it in the operation record', async () => {
     const capture: ICapture = makeDetailed();
     const chunk: string = `${'x'.repeat(256 * 1024)}\n`;
diff --git a/libraries/rush-lib/src/api/EnvironmentConfiguration.ts b/libraries/rush-lib/src/api/EnvironmentConfiguration.ts
index 58cdea5a062..fc5ec62eadf 100644
--- a/libraries/rush-lib/src/api/EnvironmentConfiguration.ts
+++ b/libraries/rush-lib/src/api/EnvironmentConfiguration.ts
@@ -488,6 +488,18 @@ export class EnvironmentConfiguration {
     }
   }
 
+  /**
+   * Reads and normalizes `RUSH_TEMP_FOLDER` without initializing the global environment state.
+   *
+   * @internal
+   */
+  public static _getRushTempFolderOverride(processEnv: IEnvironment): string | undefined {
+    const value: string | undefined = processEnv[EnvironmentVariableNames.RUSH_TEMP_FOLDER];
+    if (value) {
+      return _normalizeDeepestParentFolderPath(value) || value;
+    }
+  }
+
   /**
    * Reads and validates environment variables. If any are invalid, this function will throw.
    */
@@ -504,7 +516,7 @@ export class EnvironmentConfiguration {
           case EnvironmentVariableNames.RUSH_TEMP_FOLDER: {
             _rushTempFolderOverride =
               value && !options.doNotNormalizePaths
-                ? _normalizeDeepestParentFolderPath(value) || value
+                ? EnvironmentConfiguration._getRushTempFolderOverride(process.env)
                 : value;
             break;
           }
diff --git a/libraries/rush-lib/src/cli/RushCommandLineParser.ts b/libraries/rush-lib/src/cli/RushCommandLineParser.ts
index ea8d99c2314..b6b81e51b4b 100644
--- a/libraries/rush-lib/src/cli/RushCommandLineParser.ts
+++ b/libraries/rush-lib/src/cli/RushCommandLineParser.ts
@@ -103,6 +103,7 @@ class ReporterTerminalProvider implements ITerminalProvider {
   private readonly _bufferedMessages: Array<{
     severity: ReporterMessageSeverity;
     text: string;
+    minimumLogLevel?: 'verbose' | 'debug';
   }> = [];
   private _reporter: IScopedReporter | undefined;
 
@@ -123,9 +124,14 @@ class ReporterTerminalProvider implements ITerminalProvider {
       return;
     }
 
-    const message: { severity: ReporterMessageSeverity; text: string } = {
+    const message: {
+      severity: ReporterMessageSeverity;
+      text: string;
+      minimumLogLevel?: 'verbose' | 'debug';
+    } = {
       severity: this._toReporterSeverity(severity),
-      text: data
+      text: data,
+      ...this._getMinimumLogLevel(severity)
     };
     if (this._reporter) {
       this._reporter.emitMessage({ ...message, privacy: 'local-sensitive' });
@@ -148,6 +154,17 @@ class ReporterTerminalProvider implements ITerminalProvider {
         return 'info';
     }
   }
+
+  private _getMinimumLogLevel(severity: TerminalProviderSeverity): { minimumLogLevel?: 'verbose' | 'debug' } {
+    switch (severity) {
+      case TerminalProviderSeverity.verbose:
+        return { minimumLogLevel: 'verbose' };
+      case TerminalProviderSeverity.debug:
+        return { minimumLogLevel: 'debug' };
+      default:
+        return {};
+    }
+  }
 }
 
 export class RushCommandLineParser extends CommandLineParser {

From 523124198d221cef9ec72c81dd1cfb26eb67023f Mon Sep 17 00:00:00 2001
From: TheLarkInn <TheLarkInn@users.noreply.github.com>
Date: Fri, 28 Aug 2026 20:48:21 +0000
Subject: [PATCH 4/5] Fix reporter watch and lock handling

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d6318e80-5da9-4858-a147-817e8692f10e
---
 apps/rush/src/MinimalRushConfiguration.ts     |  6 ++-
 apps/rush/src/RushPreviewVersion.ts           | 10 ++++
 apps/rush/src/start.ts                        |  3 +-
 .../src/test/MinimalRushConfiguration.test.ts | 24 ++++++++++
 .../reporter/src/reporters/AiReporter.ts      | 36 ++++++++++++++
 .../reporters/DefaultInteractiveReporter.ts   | 28 ++++++++++-
 .../src/reporters/PlaintextReporter.ts        | 22 ++++++++-
 .../test/DefaultInteractiveReporter.test.ts   | 39 ++++++++++++++-
 .../reporter/src/test/JsonAiReporter.test.ts  | 48 +++++++++++++++++++
 .../src/test/PlaintextReporter.test.ts        | 25 ++++++++++
 .../src/cli/actions/BaseRushAction.ts         |  6 +--
 .../cli/test/RushCommandLineParser.test.ts    | 39 ++++++++++++++-
 12 files changed, 276 insertions(+), 10 deletions(-)
 create mode 100644 apps/rush/src/RushPreviewVersion.ts

diff --git a/apps/rush/src/MinimalRushConfiguration.ts b/apps/rush/src/MinimalRushConfiguration.ts
index ec283c7b9d0..4d84b61e85d 100644
--- a/apps/rush/src/MinimalRushConfiguration.ts
+++ b/apps/rush/src/MinimalRushConfiguration.ts
@@ -10,6 +10,8 @@ import { RushConstants } from '@microsoft/rush-lib/lib/logic/RushConstants';
 import { RushCommandLineParser } from '@microsoft/rush-lib/lib/cli/RushCommandLineParser';
 import { isSupportedReporterName, type ReporterName } from '@rushstack/rush-reporter';
 
+import { getRushPreviewVersion } from './RushPreviewVersion';
+
 interface IMinimalRushConfigurationJson {
   rushMinimumVersion: string;
   rushVersion?: string;
@@ -67,11 +69,13 @@ export class MinimalRushConfiguration {
           rushJsonLocation
         );
         const explicitReporter: ReporterName | undefined = _getExplicitReporter(process.argv.slice(2));
+        const currentPackageVersion: string = PackageJsonLookup.loadOwnPackageJson(__dirname).version;
+        const effectiveRushVersion: string = getRushPreviewVersion() ?? configuration.rushVersion;
         const legacyFallbackRequested: boolean =
           explicitReporter === 'legacy' ||
           process.env.RUSH_REPORTER?.trim().toLowerCase() === 'legacy' ||
           _hasHelpControl(process.argv.slice(2)) ||
-          configuration.rushVersion !== PackageJsonLookup.loadOwnPackageJson(__dirname).version;
+          effectiveRushVersion !== currentPackageVersion;
         if (
           showVerbose &&
           (legacyFallbackRequested ||
diff --git a/apps/rush/src/RushPreviewVersion.ts b/apps/rush/src/RushPreviewVersion.ts
new file mode 100644
index 00000000000..87bae4dc561
--- /dev/null
+++ b/apps/rush/src/RushPreviewVersion.ts
@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+import { EnvironmentVariableNames } from '@microsoft/rush-lib/lib/api/EnvironmentConfiguration';
+
+export function getRushPreviewVersion(
+  env: Record<string, string | undefined> = process.env
+): string | undefined {
+  return env[EnvironmentVariableNames.RUSH_PREVIEW_VERSION] || undefined;
+}
diff --git a/apps/rush/src/start.ts b/apps/rush/src/start.ts
index ff4db06b442..01e8d90f28e 100644
--- a/apps/rush/src/start.ts
+++ b/apps/rush/src/start.ts
@@ -31,6 +31,7 @@ import * as rushLib from '@microsoft/rush-lib';
 
 import { MinimalRushConfiguration } from './MinimalRushConfiguration';
 import { launchRushFrontendAsync } from './RushFrontend';
+import { getRushPreviewVersion } from './RushPreviewVersion';
 
 // Load the configuration
 const configuration: MinimalRushConfiguration | undefined =
@@ -40,7 +41,7 @@ const currentPackageVersion: string = PackageJsonLookup.loadOwnPackageJson(__dir
 
 let rushVersionToLoad: string | undefined = undefined;
 
-const previewVersion: string | undefined = process.env[EnvironmentVariableNames.RUSH_PREVIEW_VERSION];
+const previewVersion: string | undefined = getRushPreviewVersion();
 
 if (previewVersion) {
   if (!semver.valid(previewVersion, false)) {
diff --git a/apps/rush/src/test/MinimalRushConfiguration.test.ts b/apps/rush/src/test/MinimalRushConfiguration.test.ts
index f771cfb8c00..9894396f927 100644
--- a/apps/rush/src/test/MinimalRushConfiguration.test.ts
+++ b/apps/rush/src/test/MinimalRushConfiguration.test.ts
@@ -11,6 +11,7 @@ import { MinimalRushConfiguration } from '../MinimalRushConfiguration';
 describe(MinimalRushConfiguration.name, () => {
   const originalArgv: string[] = process.argv;
   const originalRushTempFolder: string | undefined = process.env.RUSH_TEMP_FOLDER;
+  const originalRushPreviewVersion: string | undefined = process.env.RUSH_PREVIEW_VERSION;
 
   afterEach(() => {
     jest.restoreAllMocks();
@@ -20,6 +21,11 @@ describe(MinimalRushConfiguration.name, () => {
     } else {
       process.env.RUSH_TEMP_FOLDER = originalRushTempFolder;
     }
+    if (originalRushPreviewVersion === undefined) {
+      delete process.env.RUSH_PREVIEW_VERSION;
+    } else {
+      process.env.RUSH_PREVIEW_VERSION = originalRushPreviewVersion;
+    }
     EnvironmentConfiguration.reset();
   });
 
@@ -181,4 +187,22 @@ describe(MinimalRushConfiguration.name, () => {
       ['']
     ]);
   });
+
+  it('uses the effective preview version when deciding discovery ownership', () => {
+    const repo: string = path.join(__dirname, 'sandbox', 'repo');
+    const consoleLog: jest.SpiedFunction<typeof console.log> = jest
+      .spyOn(console, 'log')
+      .mockImplementation(() => undefined);
+    jest.spyOn(PackageJsonLookup, 'loadOwnPackageJson').mockReturnValue({
+      name: '@microsoft/rush',
+      version: '5.178.1'
+    });
+    jest.spyOn(process, 'cwd').mockReturnValue(path.join(repo, 'project'));
+    process.argv = ['node', 'rush', 'build', '--reporter=json'];
+    process.env.RUSH_PREVIEW_VERSION = '5.178.1';
+
+    MinimalRushConfiguration.loadFromDefaultLocation();
+
+    expect(consoleLog).not.toHaveBeenCalled();
+  });
 });
diff --git a/libraries/reporter/src/reporters/AiReporter.ts b/libraries/reporter/src/reporters/AiReporter.ts
index dabf575d1ed..5be2824642f 100644
--- a/libraries/reporter/src/reporters/AiReporter.ts
+++ b/libraries/reporter/src/reporters/AiReporter.ts
@@ -110,6 +110,7 @@ export class AiReporter implements IReporter {
 
   private _protocolVersion: IReporterProtocolVersion;
   private _commandName: string | undefined;
+  private readonly _registeredOperations: Set<string>;
   private readonly _projectByOperation: Map<string, string>;
   private readonly _silentOperations: Set<string>;
   private readonly _operationCounts: { [status: string]: number };
@@ -130,6 +131,7 @@ export class AiReporter implements IReporter {
   private _artifactComplete: boolean;
   private _finalEmitted: boolean;
   private _pendingResult: { succeeded: boolean; exitCode: number } | undefined;
+  private _resetCycleOnNextRegistration: boolean;
 
   public constructor(options: IAiReporterOptions) {
     this._write = options.write;
@@ -145,6 +147,7 @@ export class AiReporter implements IReporter {
 
     this._protocolVersion = REPORTER_PROTOCOL_VERSION;
     this._commandName = undefined;
+    this._registeredOperations = new Set();
     this._projectByOperation = new Map();
     this._silentOperations = new Set();
     this._operationCounts = {};
@@ -165,6 +168,7 @@ export class AiReporter implements IReporter {
     this._artifactComplete = true;
     this._finalEmitted = false;
     this._pendingResult = undefined;
+    this._resetCycleOnNextRegistration = false;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -191,6 +195,13 @@ export class AiReporter implements IReporter {
           projectName?: string;
           silent?: boolean;
         };
+        if (this._resetCycleOnNextRegistration) {
+          this._resetWatchCycle();
+        }
+        if (this._registeredOperations.has(payload.operationId)) {
+          break;
+        }
+        this._registeredOperations.add(payload.operationId);
         if (payload.silent) {
           this._silentOperations.add(payload.operationId);
         }
@@ -227,6 +238,20 @@ export class AiReporter implements IReporter {
         this._collectDiagnostic(event.payload as IAiDiagnostic);
         break;
       }
+      case 'watchCycleCompleted': {
+        const succeeded: boolean = (event.payload as { succeeded?: boolean }).succeeded === true;
+        this._write(
+          `${JSON.stringify({
+            kind: 'ai.watchCycle',
+            protocolVersion: this._protocolVersion,
+            succeeded,
+            operationCounts: { ...this._operationCounts },
+            failedProjects: [...this._failedProjects]
+          })}\n`
+        );
+        this._resetCycleOnNextRegistration = true;
+        break;
+      }
       case 'messageEmitted': {
         const payload: { severity?: string; text?: string } = event.payload as {
           severity?: string;
@@ -321,6 +346,17 @@ export class AiReporter implements IReporter {
     }
   }
 
+  private _resetWatchCycle(): void {
+    this._registeredOperations.clear();
+    this._projectByOperation.clear();
+    this._silentOperations.clear();
+    for (const status of Object.keys(this._operationCounts)) {
+      delete this._operationCounts[status];
+    }
+    this._failedProjects.length = 0;
+    this._resetCycleOnNextRegistration = false;
+  }
+
   private _emitFinal(succeeded: boolean, exitCode: number): void {
     if (this._finalEmitted) {
       return;
diff --git a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
index 3d1b8438d82..2a55abec505 100644
--- a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
+++ b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
@@ -103,6 +103,7 @@ export class DefaultInteractiveReporter implements IReporter {
   private _totalOperations: number;
   private _completedOperations: number;
   private _failedOperations: number;
+  private readonly _registeredOperations: Set<string>;
   private readonly _projectByOperation: Map<string, string>;
   private readonly _silentOperations: Set<string>;
   private readonly _activeProjects: Map<string, string>;
@@ -116,6 +117,7 @@ export class DefaultInteractiveReporter implements IReporter {
   private _paintedRowCount: number;
   private _cursorHidden: boolean;
   private _finalized: boolean;
+  private _resetCycleOnNextRegistration: boolean;
 
   public constructor(options: IDefaultInteractiveReporterOptions) {
     this._terminal = options.terminal;
@@ -129,6 +131,7 @@ export class DefaultInteractiveReporter implements IReporter {
     this._totalOperations = 0;
     this._completedOperations = 0;
     this._failedOperations = 0;
+    this._registeredOperations = new Set();
     this._projectByOperation = new Map();
     this._silentOperations = new Set();
     this._activeProjects = new Map();
@@ -142,6 +145,7 @@ export class DefaultInteractiveReporter implements IReporter {
     this._paintedRowCount = 0;
     this._cursorHidden = false;
     this._finalized = false;
+    this._resetCycleOnNextRegistration = false;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -183,6 +187,13 @@ export class DefaultInteractiveReporter implements IReporter {
             phaseName?: string;
             silent?: boolean;
           };
+        if (this._resetCycleOnNextRegistration) {
+          this._resetWatchCycle();
+        }
+        if (this._registeredOperations.has(payload.operationId)) {
+          break;
+        }
+        this._registeredOperations.add(payload.operationId);
         if (payload.silent) {
           this._silentOperations.add(payload.operationId);
           break;
@@ -331,14 +342,29 @@ export class DefaultInteractiveReporter implements IReporter {
   private _appendWatchSummary(event: IReporterEventEnvelope<unknown>): void {
     const payload: { succeeded?: boolean } = event.payload as { succeeded?: boolean };
     const marker: string = payload.succeeded ? this._color.green('✔') : this._color.red('✖');
-    const summary: string = `${marker} watch cycle ${payload.succeeded ? 'succeeded' : 'failed'}`;
+    const summary: string =
+      `${marker} watch cycle ${payload.succeeded ? 'succeeded' : 'failed'} - ` +
+      `${this._completedOperations}/${this._totalOperations} operations`;
     this._terminal.write(`${this._clearRegion()}${summary}\n`);
     this._paintedRowCount = 0;
+    this._resetCycleOnNextRegistration = true;
     if (this._terminal.isTTY) {
       this._paint();
     }
   }
 
+  private _resetWatchCycle(): void {
+    this._totalOperations = 0;
+    this._completedOperations = 0;
+    this._failedOperations = 0;
+    this._registeredOperations.clear();
+    this._projectByOperation.clear();
+    this._silentOperations.clear();
+    this._activeProjects.clear();
+    this._latestActivity = '';
+    this._resetCycleOnNextRegistration = false;
+  }
+
   private _finalize(): void {
     if (this._finalized) {
       return;
diff --git a/libraries/reporter/src/reporters/PlaintextReporter.ts b/libraries/reporter/src/reporters/PlaintextReporter.ts
index ba13e0469bd..4569dfbc0c1 100644
--- a/libraries/reporter/src/reporters/PlaintextReporter.ts
+++ b/libraries/reporter/src/reporters/PlaintextReporter.ts
@@ -105,6 +105,7 @@ export class PlaintextReporter implements IReporter {
   private readonly _operations: Map<string, IOperationRecord>;
   private _spoolDirectory: string | undefined;
   private _nextSpoolId: number;
+  private _resetCycleOnNextRegistration: boolean;
 
   public constructor(options: IPlaintextReporterOptions) {
     this._write = options.write;
@@ -124,6 +125,7 @@ export class PlaintextReporter implements IReporter {
     this._operations = new Map();
     this._spoolDirectory = undefined;
     this._nextSpoolId = 1;
+    this._resetCycleOnNextRegistration = false;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -149,6 +151,9 @@ export class PlaintextReporter implements IReporter {
           phaseName?: string;
           silent?: boolean;
         };
+        if (this._resetCycleOnNextRegistration) {
+          this._resetWatchCycle();
+        }
         const previousRecord: IOperationRecord | undefined = this._operations.get(payload.operationId);
         if (previousRecord) {
           break;
@@ -211,7 +216,11 @@ export class PlaintextReporter implements IReporter {
       }
       case 'watchCycleCompleted': {
         const succeeded: boolean = (event.payload as { succeeded?: boolean }).succeeded === true;
-        this._writeLine(`Watch cycle ${succeeded ? 'succeeded' : 'failed'}`);
+        this._writeLine(
+          `Watch cycle ${succeeded ? 'succeeded' : 'failed'} ` +
+            `(${this._completed}/${this._total} operations, ${this._failed} failed)`
+        );
+        this._resetCycleOnNextRegistration = true;
         break;
       }
       case 'commandResult': {
@@ -434,6 +443,17 @@ export class PlaintextReporter implements IReporter {
     this._spoolDirectory = undefined;
   }
 
+  private _resetWatchCycle(): void {
+    for (const record of this._operations.values()) {
+      this._deleteSpool(record);
+    }
+    this._operations.clear();
+    this._total = 0;
+    this._completed = 0;
+    this._failed = 0;
+    this._resetCycleOnNextRegistration = false;
+  }
+
   private _onResult(payload: { commandName: string; succeeded: boolean; exitCode: number }): void {
     const commandName: string = payload.commandName ?? this._commandName ?? 'rush';
     if (payload.succeeded) {
diff --git a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
index f08e3ca76ee..c8b8584afdd 100644
--- a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
+++ b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
@@ -244,6 +244,27 @@ describe('DefaultInteractiveReporter', () => {
     expect(terminal.output).toContain('Log: /tmp/rush-logs/latest.log');
   });
 
+  it('preserves actionable lock contention text on failure', async () => {
+    const terminal: FakeTerminal = new FakeTerminal();
+    const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
+      terminal,
+      color: false,
+      nowMs: () => 0
+    });
+    await reporter.initializeAsync();
+    reporter.report(ev('commandStarted', { commandName: 'build' }));
+    reporter.report(
+      ev('messageEmitted', {
+        severity: 'error',
+        text: 'Another Rush command is already running in this repository.\n'
+      })
+    );
+    reporter.report(ev('commandResult', { commandName: 'build', succeeded: false, exitCode: 1 }));
+    await reporter.closeAsync();
+
+    expect(terminal.output).toContain('Another Rush command is already running in this repository.');
+  });
+
   it('fails closed when commandResult is missing', async () => {
     const terminal: FakeTerminal = new FakeTerminal();
     const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
@@ -260,7 +281,7 @@ describe('DefaultInteractiveReporter', () => {
     expect(terminal.output).not.toContain('build succeeded');
   });
 
-  it('appends one summary per completed watch cycle while keeping the live region', async () => {
+  it('reports watch totals per cycle and recovers from failure', async () => {
     const terminal: FakeTerminal = new FakeTerminal();
     const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
       terminal,
@@ -269,9 +290,23 @@ describe('DefaultInteractiveReporter', () => {
     });
     await reporter.initializeAsync();
     reporter.report(ev('commandStarted', { commandName: 'build' }));
+    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
+    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
+    reporter.report(ev('watchCycleCompleted', { succeeded: false }));
+    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
+    reporter.report(
+      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+    );
+    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
+    reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'noOp' }));
     reporter.report(ev('watchCycleCompleted', { succeeded: true }));
+    reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
+    await reporter.closeAsync();
 
-    expect(terminal.output).toContain('watch cycle succeeded');
+    expect(terminal.output).toContain('watch cycle failed - 1/1 operations');
+    expect(terminal.output).toContain('watch cycle succeeded - 1/1 operations');
+    expect(terminal.output).not.toContain('2/2 operations');
+    expect(terminal.output).not.toContain('hidden');
   });
 
   it('does not paint a live region on a non-TTY but still writes the final summary', async () => {
diff --git a/libraries/reporter/src/test/JsonAiReporter.test.ts b/libraries/reporter/src/test/JsonAiReporter.test.ts
index 8e36d634dd8..e4a5cdcb074 100644
--- a/libraries/reporter/src/test/JsonAiReporter.test.ts
+++ b/libraries/reporter/src/test/JsonAiReporter.test.ts
@@ -217,6 +217,54 @@ describe('AiReporter', () => {
     expect(final.operationCounts).toEqual({ fromCache: 1 });
   });
 
+  it('reports AI watch totals per cycle and recovers from failure', async () => {
+    let output: string = '';
+    const reporter: AiReporter = new AiReporter({ write: (text: string) => (output += text) });
+    reporter.report(ev('commandStarted', { commandName: 'build' }));
+    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
+    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
+    reporter.report(ev('watchCycleCompleted', { succeeded: false }));
+    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
+    reporter.report(
+      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+    );
+    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
+    reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'noOp' }));
+    reporter.report(ev('watchCycleCompleted', { succeeded: true }));
+    reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
+    await reporter.closeAsync();
+
+    const records: Record<string, unknown>[] = parseLines(output);
+    const cycles: Array<{
+      succeeded: boolean;
+      operationCounts: Record<string, number>;
+      failedProjects: string[];
+    }> = records.filter(({ kind }) => kind === 'ai.watchCycle') as Array<{
+      succeeded: boolean;
+      operationCounts: Record<string, number>;
+      failedProjects: string[];
+    }>;
+    expect(
+      cycles.map(({ succeeded, operationCounts, failedProjects }) => ({
+        succeeded,
+        operationCounts,
+        failedProjects
+      }))
+    ).toEqual([
+      {
+        succeeded: false,
+        operationCounts: { failure: 1 },
+        failedProjects: ['project-a']
+      },
+      {
+        succeeded: true,
+        operationCounts: { success: 1 },
+        failedProjects: []
+      }
+    ]);
+    expect((records.at(-1) as unknown as IAiFinalRecord).operationCounts).toEqual({ success: 1 });
+  });
+
   it('caps detailed diagnostics at 20 and marks the record truncated', () => {
     const events: IReporterEventEnvelope<unknown>[] = [ev('commandStarted', { commandName: 'build' })];
     for (let i: number = 0; i < 25; i++) {
diff --git a/libraries/reporter/src/test/PlaintextReporter.test.ts b/libraries/reporter/src/test/PlaintextReporter.test.ts
index 1a51d6843ef..d5536a1b840 100644
--- a/libraries/reporter/src/test/PlaintextReporter.test.ts
+++ b/libraries/reporter/src/test/PlaintextReporter.test.ts
@@ -166,6 +166,31 @@ describe('PlaintextReporter', () => {
     expect(capture.getOutput()).not.toContain('project-a: success');
   });
 
+  it('reports watch totals per cycle and recovers from failure', () => {
+    const capture: ICapture = makeDetailed();
+    capture.reporter.report(ev('commandStarted', { commandName: 'build' }));
+    capture.reporter.report(
+      ev('operationRegistered', { operationId: 'op1', projectName: 'project-a', phaseName: 'build' })
+    );
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
+    capture.reporter.report(ev('watchCycleCompleted', { succeeded: false }));
+    capture.reporter.report(
+      ev('operationRegistered', { operationId: 'op1', projectName: 'project-a', phaseName: 'build' })
+    );
+    capture.reporter.report(
+      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+    );
+    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
+    capture.reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'noOp' }));
+    capture.reporter.report(ev('watchCycleCompleted', { succeeded: true }));
+    capture.reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
+
+    expect(capture.getOutput()).toContain('Watch cycle failed (1/1 operations, 1 failed)');
+    expect(capture.getOutput()).toContain('Watch cycle succeeded (1/1 operations, 0 failed)');
+    expect(capture.getOutput()).toContain('rush build succeeded (1/1 operations, 0 failed)');
+    expect(capture.getOutput()).not.toContain('hidden');
+  });
+
   it('emits a compact heartbeat only after the interval elapses', () => {
     let now: number = 0;
     let output: string = '';
diff --git a/libraries/rush-lib/src/cli/actions/BaseRushAction.ts b/libraries/rush-lib/src/cli/actions/BaseRushAction.ts
index 06215cb8ed8..fef1fec8782 100644
--- a/libraries/rush-lib/src/cli/actions/BaseRushAction.ts
+++ b/libraries/rush-lib/src/cli/actions/BaseRushAction.ts
@@ -70,12 +70,12 @@ export abstract class BaseConfiglessRushAction extends CommandLineAction impleme
     if (this.rushConfiguration) {
       if (!this._safeForSimultaneousRushProcesses) {
         if (!LockFile.tryAcquire(this.rushConfiguration.commonTempFolder, 'rush')) {
-          this.terminal.writeLine(
-            Colorize.red(`Another Rush command is already running in this repository.`)
-          );
+          const message: string = 'Another Rush command is already running in this repository.';
           if (_isRushSessionOperationStreamEnabled(this.rushSession)) {
+            this.terminal.writeErrorLine(message);
             throw new AlreadyReportedError();
           }
+          this.terminal.writeLine(Colorize.red(message));
           process.exit(1);
         }
       }
diff --git a/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts b/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts
index 541ab69a78e..590e7a44054 100644
--- a/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts
+++ b/libraries/rush-lib/src/cli/test/RushCommandLineParser.test.ts
@@ -29,7 +29,7 @@ jest.mock(`@rushstack/package-deps-hash`, () => {
 import './mockRushCommandLineParser';
 
 import type { SpawnOptions } from 'node:child_process';
-import { FileSystem, JsonFile, Path } from '@rushstack/node-core-library';
+import { FileSystem, JsonFile, LockFile, Path } from '@rushstack/node-core-library';
 import type { IDetailedRepoState } from '@rushstack/package-deps-hash';
 import type { IReporterEmitEventInput, IReporterEventSink } from '@rushstack/rush-reporter';
 import { Autoinstaller } from '../../logic/Autoinstaller';
@@ -173,6 +173,43 @@ describe('RushCommandLineParser', () => {
             stderrSpy.mockRestore();
           }
         });
+
+        it('preserves the actionable lock contention reason in reporter mode', async () => {
+          const reporterSink: CapturingReporterSink = new CapturingReporterSink();
+          const lockSpy: jest.SpiedFunction<typeof LockFile.tryAcquire> = jest
+            .spyOn(LockFile, 'tryAcquire')
+            .mockReturnValue(undefined);
+          const exitSpy: jest.SpiedFunction<typeof process.exit> = jest
+            .spyOn(process, 'exit')
+            .mockImplementation(() => undefined as never);
+          try {
+            const { parser } = await getCommandLineParserInstanceAsync(
+              'basicAndRunBuildActionRepo',
+              'build',
+              {
+                eventSink: reporterSink,
+                sessionId: 'parser-lock-conflict',
+                operationStreamEnabled: true
+              }
+            );
+
+            await parser.executeAsync();
+            await new Promise<void>((resolve: () => void) => setImmediate(resolve));
+
+            expect(reporterSink.inputs).toContainEqual(
+              expect.objectContaining({
+                type: 'messageEmitted',
+                payload: expect.objectContaining({
+                  severity: 'error',
+                  text: expect.stringContaining('Another Rush command is already running')
+                })
+              })
+            );
+          } finally {
+            exitSpy.mockRestore();
+            lockSpy.mockRestore();
+          }
+        });
       });
 
       describe("'custom-output' action", () => {

From 97f807ed6549387b6aab2eccec197123196b725d Mon Sep 17 00:00:00 2001
From: TheLarkInn <TheLarkInn@users.noreply.github.com>
Date: Fri, 28 Aug 2026 21:43:08 +0000
Subject: [PATCH 5/5] Fix overlapping reporter watch cycles

Track explicit operation graph iteration identities across lifecycle events and isolate reporter totals, diagnostics, and output spools by watch cycle.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d6318e80-5da9-4858-a147-817e8692f10e
---
 .../src/test/sandbox/reporter-demo/run.mjs    |  12 +-
 common/reviews/api/rush-lib.api.md            |   7 +-
 common/reviews/api/rush-reporter.api.md       |  17 +-
 .../src/diagnostics/IRushDiagnostic.ts        |   5 +
 .../reporter/src/lifecycle/LifecycleEvents.ts |  25 ++
 .../reporter/src/reporters/AiReporter.ts      | 236 ++++++++++++------
 .../reporters/DefaultInteractiveReporter.ts   | 180 ++++++++-----
 .../reporter/src/reporters/FileReporter.ts    |  51 ++--
 .../src/reporters/PlaintextReporter.ts        | 152 +++++++----
 .../src/scheduler/OperationOutputGrouping.ts  |   9 +-
 .../src/scheduler/OperationStreamEmitter.ts   |  49 +++-
 .../test/DefaultInteractiveReporter.test.ts   |  39 ++-
 .../reporter/src/test/FileReporter.test.ts    |  17 +-
 .../reporter/src/test/JsonAiReporter.test.ts  |  48 +++-
 .../src/test/OperationStreamEmitter.test.ts   |  16 +-
 .../src/test/PlaintextReporter.test.ts        |  66 ++++-
 .../src/PhasedRequestEventMultiplexer.ts      |  23 +-
 .../operations/IOperationExecutionResult.ts   |   5 +
 .../logic/operations/OperationEventSink.ts    |   6 +-
 .../operations/OperationExecutionRecord.ts    |   9 +-
 .../src/logic/operations/OperationGraph.ts    |  12 +-
 .../operations/ReporterOperationEventSink.ts  | 188 ++++++++------
 .../test/OperationGraphEventSink.test.ts      |  46 +++-
 23 files changed, 836 insertions(+), 382 deletions(-)

diff --git a/apps/rush/src/test/sandbox/reporter-demo/run.mjs b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
index 3441b2a491f..d61c29f4dad 100644
--- a/apps/rush/src/test/sandbox/reporter-demo/run.mjs
+++ b/apps/rush/src/test/sandbox/reporter-demo/run.mjs
@@ -144,8 +144,11 @@ const rawOutput = plaintextEvents
   .join('');
 const groupHeader = '==[ @rushstack/rush-reporter (_phase:build) ]==\n';
 const groupStart = plaintext.indexOf(groupHeader);
-const groupEnd = plaintext.indexOf('@rushstack/rush-reporter: success', groupStart);
-if (groupStart < 0 || groupEnd < 0) {
+const groupEnd = ['success', 'successWithWarnings', 'fromCache']
+  .map((status) => plaintext.indexOf(`@rushstack/rush-reporter: ${status}`, groupStart))
+  .filter((index) => index >= 0)
+  .sort((a, b) => a - b)[0];
+if (groupStart < 0 || groupEnd === undefined) {
   throw new Error('The plaintext reporter did not reconstruct the expected operation group.');
 }
 const groupedOutput = plaintext.slice(groupStart + groupHeader.length, groupEnd);
@@ -185,7 +188,10 @@ if (quiet.includes('build started') || quiet.includes('==[ @rushstack/rush-repor
 if (!verbose.includes('Incremental strategy:') || !debug.includes('Incremental strategy:')) {
   throw new Error('Verbose and debug reporter output did not preserve Rush terminal verbosity.');
 }
-if (ci.includes('\u001b') || !ci.includes('@rushstack/rush-reporter: success')) {
+if (
+  ci.includes('\u001b') ||
+  !/@rushstack\/rush-reporter: (?:success|successWithWarnings|fromCache)/.test(ci)
+) {
   throw new Error('CI output was not append-only plaintext.');
 }
 
diff --git a/common/reviews/api/rush-lib.api.md b/common/reviews/api/rush-lib.api.md
index 6c7512de315..0a0b849e956 100644
--- a/common/reviews/api/rush-lib.api.md
+++ b/common/reviews/api/rush-lib.api.md
@@ -640,6 +640,7 @@ export interface _IOperationBuildCacheOptions {
 export interface IOperationExecutionResult extends IBaseOperationExecutionResult, IOperationLastState {
     readonly enabled: boolean;
     readonly error: Error | undefined;
+    readonly iterationId: number;
     readonly logFilePaths: ILogFilePaths | undefined;
     readonly nonCachedDurationMs: number | undefined;
     readonly problemCollector: IProblemCollector;
@@ -683,12 +684,12 @@ export interface IOperationGraphContext extends ICreateOperationsContext {
 // @internal
 export interface _IOperationGraphEventSink {
     onActivity?(text: string, options?: _IOperationActivityOptions): void;
-    onOperationChunk?(operationId: string, chunk: ITerminalChunk): void;
+    onOperationChunk?(operationId: string, chunk: ITerminalChunk, iterationId: number): void;
     onOperationCompleted?(result: IOperationExecutionResult): void;
     onOperationHeader?(operationId: string, completedOperations: number, totalOperations: number): void;
-    onOperationRegistered?(operationId: string, silent: boolean): void;
+    onOperationRegistered?(operationId: string, silent: boolean, iterationId: number): void;
     onOperationStatusChanged?(result: IOperationExecutionResult, previousStatus: OperationStatus): void;
-    onOperationStreamClosed?(operationId: string): void;
+    onOperationStreamClosed?(operationId: string, iterationId: number): void;
 }
 
 // @alpha
diff --git a/common/reviews/api/rush-reporter.api.md b/common/reviews/api/rush-reporter.api.md
index 61c3428c1dd..a11c6d1b877 100644
--- a/common/reviews/api/rush-reporter.api.md
+++ b/common/reviews/api/rush-reporter.api.md
@@ -450,6 +450,7 @@ export interface IEngineSinkResolution {
 
 // @beta
 export interface IExternalOutputChunk {
+    readonly iterationId?: number;
     readonly operationId?: string;
     readonly stream: string;
     readonly text: string;
@@ -611,12 +612,14 @@ export interface IOldEngineOutputAdapterOptions {
 // @beta
 export interface IOperationCompletedPayload {
     readonly durationMs?: number;
+    readonly iterationId?: number;
     readonly operationId: string;
     readonly status: OperationStatus;
 }
 
 // @beta
 export interface IOperationRegisteredPayload {
+    readonly iterationId?: number;
     readonly operationId: string;
     readonly phaseName?: string;
     readonly projectName?: string;
@@ -626,6 +629,7 @@ export interface IOperationRegisteredPayload {
 // @beta
 export interface IOperationStatusChangedPayload {
     readonly durationMs?: number;
+    readonly iterationId?: number;
     readonly operationId: string;
     readonly previousStatus?: OperationStatus;
     readonly status: OperationStatus;
@@ -633,6 +637,7 @@ export interface IOperationStatusChangedPayload {
 
 // @beta
 export interface IOperationStreamClosedPayload {
+    readonly iterationId?: number;
     readonly operationId: string;
 }
 
@@ -946,6 +951,7 @@ export interface IRushDiagnostic {
     readonly code: RushDiagnosticCode;
     readonly detailKey?: string;
     readonly diagnosticId: string;
+    readonly iterationId?: number;
     readonly parameters?: {
         readonly [name: string]: IClassifiedDiagnosticValue;
     };
@@ -1136,6 +1142,7 @@ export function iterateExternalOutput(events: readonly IReporterEventEnvelope<un
 // @beta
 export interface IWatchCycleCompletedPayload {
     readonly changedProjects?: readonly string[];
+    readonly iterationId?: number;
     readonly succeeded: boolean;
 }
 
@@ -1272,14 +1279,14 @@ export type OperationStatus = 'ready' | 'waiting' | 'queued' | 'executing' | 'su
 // @beta
 export class OperationStreamEmitter {
     constructor(options: IOperationStreamEmitterOptions);
-    changeStatus(operationId: string, status: OperationStatus, durationMs?: number, previousStatus?: OperationStatus): string;
-    closeOperationStream(operationId: string): string;
+    changeStatus(operationId: string, status: OperationStatus, durationMs?: number, previousStatus?: OperationStatus, iterationId?: number): string;
+    closeOperationStream(operationId: string, iterationId?: number): string;
     completeCommand(commandName: string, succeeded: boolean, exitCode: number, operationCounts?: {
         readonly [status: string]: number;
     }): string;
-    completeOperation(operationId: string, status: OperationStatus, durationMs?: number): string;
-    registerOperation(operationId: string, projectName?: string, phaseName?: string, silent?: boolean): string;
-    writeOutput(operationId: string, stream: 'stdout' | 'stderr', text: string): string[];
+    completeOperation(operationId: string, status: OperationStatus, durationMs?: number, iterationId?: number): string;
+    registerOperation(operationId: string, projectName?: string, phaseName?: string, silent?: boolean, iterationId?: number): string;
+    writeOutput(operationId: string, stream: 'stdout' | 'stderr', text: string, iterationId?: number): string[];
 }
 
 // @beta
diff --git a/libraries/reporter/src/diagnostics/IRushDiagnostic.ts b/libraries/reporter/src/diagnostics/IRushDiagnostic.ts
index 59e82f5fcf0..8c54d6a7cbb 100644
--- a/libraries/reporter/src/diagnostics/IRushDiagnostic.ts
+++ b/libraries/reporter/src/diagnostics/IRushDiagnostic.ts
@@ -37,6 +37,11 @@ export interface IRushDiagnostic {
    */
   readonly diagnosticId: string;
 
+  /**
+   * The operation graph iteration that produced this diagnostic, when applicable.
+   */
+  readonly iterationId?: number;
+
   /**
    * A stable, never-reused code of the form `RUSH_<DOMAIN>_<NAME>` that
    * identifies the diagnostic and keys its English template, for example
diff --git a/libraries/reporter/src/lifecycle/LifecycleEvents.ts b/libraries/reporter/src/lifecycle/LifecycleEvents.ts
index 81b27752713..ac017522e80 100644
--- a/libraries/reporter/src/lifecycle/LifecycleEvents.ts
+++ b/libraries/reporter/src/lifecycle/LifecycleEvents.ts
@@ -99,6 +99,11 @@ export interface ICommandCompletedPayload {
  * @beta
  */
 export interface IOperationRegisteredPayload {
+  /**
+   * The graph iteration that owns this event.
+   */
+  readonly iterationId?: number;
+
   /**
    * The operation id.
    */
@@ -126,6 +131,11 @@ export interface IOperationRegisteredPayload {
  * @beta
  */
 export interface IOperationStatusChangedPayload {
+  /**
+   * The graph iteration that owns this event.
+   */
+  readonly iterationId?: number;
+
   /**
    * The operation id.
    */
@@ -153,6 +163,11 @@ export interface IOperationStatusChangedPayload {
  * @beta
  */
 export interface IOperationStreamClosedPayload {
+  /**
+   * The graph iteration that owns this event.
+   */
+  readonly iterationId?: number;
+
   /**
    * The operation whose output stream has closed.
    */
@@ -165,6 +180,11 @@ export interface IOperationStreamClosedPayload {
  * @beta
  */
 export interface IOperationCompletedPayload {
+  /**
+   * The graph iteration that owns this event.
+   */
+  readonly iterationId?: number;
+
   /**
    * The completed operation.
    */
@@ -214,6 +234,11 @@ export interface ICommandResultPayload {
  * @beta
  */
 export interface IWatchCycleCompletedPayload {
+  /**
+   * The completed graph iteration.
+   */
+  readonly iterationId?: number;
+
   /**
    * Whether the watch cycle succeeded.
    */
diff --git a/libraries/reporter/src/reporters/AiReporter.ts b/libraries/reporter/src/reporters/AiReporter.ts
index 5be2824642f..80d9a8f26ed 100644
--- a/libraries/reporter/src/reporters/AiReporter.ts
+++ b/libraries/reporter/src/reporters/AiReporter.ts
@@ -20,6 +20,40 @@ const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
   'aborted'
 ]);
 
+interface IAiDiagnosticState {
+  readonly errorDiagnostics: IAiDiagnostic[];
+  readonly warningDiagnostics: IAiDiagnostic[];
+  readonly errorCodes: Set<string>;
+  readonly diagnosticCategoryCounts: { [category: string]: number };
+  errorDiagnosticsTruncated: boolean;
+  warningDiagnosticsTruncated: boolean;
+  errorCount: number;
+  warningCount: number;
+}
+
+interface IAiWatchCycleState {
+  readonly registeredOperations: Set<string>;
+  readonly projectByOperation: Map<string, string>;
+  readonly silentOperations: Set<string>;
+  readonly operationCounts: { [status: string]: number };
+  readonly failedProjects: string[];
+  readonly diagnostics: IAiDiagnosticState;
+  watchCompleted: boolean;
+}
+
+function createDiagnosticState(): IAiDiagnosticState {
+  return {
+    errorDiagnostics: [],
+    warningDiagnostics: [],
+    errorCodes: new Set(),
+    diagnosticCategoryCounts: {},
+    errorDiagnosticsTruncated: false,
+    warningDiagnosticsTruncated: false,
+    errorCount: 0,
+    warningCount: 0
+  };
+}
+
 /**
  * A bounded diagnostic in an AI record.
  *
@@ -110,28 +144,18 @@ export class AiReporter implements IReporter {
 
   private _protocolVersion: IReporterProtocolVersion;
   private _commandName: string | undefined;
-  private readonly _registeredOperations: Set<string>;
-  private readonly _projectByOperation: Map<string, string>;
-  private readonly _silentOperations: Set<string>;
-  private readonly _operationCounts: { [status: string]: number };
-  private readonly _failedProjects: string[];
-  private readonly _errorDiagnostics: IAiDiagnostic[];
-  private readonly _warningDiagnostics: IAiDiagnostic[];
-  private readonly _errorCodes: Set<string>;
-  private readonly _diagnosticCategoryCounts: { [category: string]: number };
+  private readonly _watchCycles: Map<number, IAiWatchCycleState>;
+  private readonly _globalDiagnostics: IAiDiagnosticState;
   private readonly _fallbackErrorMessages: string[];
   private _fallbackErrorCount: number;
   private _fallbackErrorsTruncated: boolean;
-  private _errorDiagnosticsTruncated: boolean;
-  private _warningDiagnosticsTruncated: boolean;
-  private _errorCount: number;
-  private _warningCount: number;
   private _logPath: string | undefined;
   private _logFormat: string | undefined;
   private _artifactComplete: boolean;
   private _finalEmitted: boolean;
   private _pendingResult: { succeeded: boolean; exitCode: number } | undefined;
-  private _resetCycleOnNextRegistration: boolean;
+  private _legacyIterationId: number;
+  private _latestIterationId: number;
 
   public constructor(options: IAiReporterOptions) {
     this._write = options.write;
@@ -147,28 +171,18 @@ export class AiReporter implements IReporter {
 
     this._protocolVersion = REPORTER_PROTOCOL_VERSION;
     this._commandName = undefined;
-    this._registeredOperations = new Set();
-    this._projectByOperation = new Map();
-    this._silentOperations = new Set();
-    this._operationCounts = {};
-    this._failedProjects = [];
-    this._errorDiagnostics = [];
-    this._warningDiagnostics = [];
-    this._errorCodes = new Set();
-    this._diagnosticCategoryCounts = {};
+    this._watchCycles = new Map();
+    this._globalDiagnostics = createDiagnosticState();
     this._fallbackErrorMessages = [];
     this._fallbackErrorCount = 0;
     this._fallbackErrorsTruncated = false;
-    this._errorDiagnosticsTruncated = false;
-    this._warningDiagnosticsTruncated = false;
-    this._errorCount = 0;
-    this._warningCount = 0;
     this._logPath = undefined;
     this._logFormat = undefined;
     this._artifactComplete = true;
     this._finalEmitted = false;
     this._pendingResult = undefined;
-    this._resetCycleOnNextRegistration = false;
+    this._legacyIterationId = 0;
+    this._latestIterationId = 0;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -190,23 +204,27 @@ export class AiReporter implements IReporter {
         break;
       }
       case 'operationRegistered': {
-        const payload: { operationId: string; projectName?: string; silent?: boolean } = event.payload as {
+        const payload: {
           operationId: string;
           projectName?: string;
           silent?: boolean;
+          iterationId?: number;
+        } = event.payload as {
+          operationId: string;
+          projectName?: string;
+          silent?: boolean;
+          iterationId?: number;
         };
-        if (this._resetCycleOnNextRegistration) {
-          this._resetWatchCycle();
-        }
-        if (this._registeredOperations.has(payload.operationId)) {
+        const cycle: IAiWatchCycleState = this._getWatchCycle(payload.iterationId);
+        if (cycle.registeredOperations.has(payload.operationId)) {
           break;
         }
-        this._registeredOperations.add(payload.operationId);
+        cycle.registeredOperations.add(payload.operationId);
         if (payload.silent) {
-          this._silentOperations.add(payload.operationId);
+          cycle.silentOperations.add(payload.operationId);
         }
         if (payload.projectName !== undefined) {
-          this._projectByOperation.set(payload.operationId, payload.projectName);
+          cycle.projectByOperation.set(payload.operationId, payload.projectName);
         }
         break;
       }
@@ -214,42 +232,61 @@ export class AiReporter implements IReporter {
         break;
       }
       case 'operationCompleted': {
-        const payload: { operationId: string; status: string } = event.payload as {
+        const payload: { operationId: string; status: string; iterationId?: number } = event.payload as {
           operationId: string;
           status: string;
+          iterationId?: number;
         };
-        if (this._silentOperations.has(payload.operationId)) {
-          this._silentOperations.delete(payload.operationId);
+        const cycle: IAiWatchCycleState = this._getWatchCycle(payload.iterationId);
+        if (cycle.silentOperations.has(payload.operationId)) {
+          cycle.silentOperations.delete(payload.operationId);
           break;
         }
         if (TERMINAL_STATUSES.has(payload.status)) {
-          this._operationCounts[payload.status] = (this._operationCounts[payload.status] ?? 0) + 1;
+          cycle.operationCounts[payload.status] = (cycle.operationCounts[payload.status] ?? 0) + 1;
           if (payload.status === 'failure') {
             const projectName: string =
-              this._projectByOperation.get(payload.operationId) ??
+              cycle.projectByOperation.get(payload.operationId) ??
               event.scope?.projectName ??
               payload.operationId;
-            this._failedProjects.push(projectName);
+            cycle.failedProjects.push(projectName);
           }
         }
         break;
       }
       case 'diagnosticEmitted': {
-        this._collectDiagnostic(event.payload as IAiDiagnostic);
+        const diagnostic: IAiDiagnostic & { iterationId?: number } = event.payload as IAiDiagnostic & {
+          iterationId?: number;
+        };
+        this._collectDiagnostic(
+          diagnostic,
+          diagnostic.iterationId === undefined
+            ? this._globalDiagnostics
+            : this._getWatchCycle(diagnostic.iterationId).diagnostics
+        );
         break;
       }
       case 'watchCycleCompleted': {
-        const succeeded: boolean = (event.payload as { succeeded?: boolean }).succeeded === true;
+        const payload: { succeeded?: boolean; iterationId?: number } = event.payload as {
+          succeeded?: boolean;
+          iterationId?: number;
+        };
+        const cycle: IAiWatchCycleState = this._getWatchCycle(payload.iterationId);
+        const succeeded: boolean = payload.succeeded === true;
         this._write(
           `${JSON.stringify({
             kind: 'ai.watchCycle',
             protocolVersion: this._protocolVersion,
             succeeded,
-            operationCounts: { ...this._operationCounts },
-            failedProjects: [...this._failedProjects]
+            operationCounts: { ...cycle.operationCounts },
+            failedProjects: [...cycle.failedProjects]
           })}\n`
         );
-        this._resetCycleOnNextRegistration = true;
+        if (payload.iterationId === undefined) {
+          this._legacyIterationId++;
+        }
+        cycle.watchCompleted = true;
+        this._pruneCompletedWatchCycles();
         break;
       }
       case 'messageEmitted': {
@@ -311,16 +348,16 @@ export class AiReporter implements IReporter {
     }
   }
 
-  private _collectDiagnostic(diagnostic: IAiDiagnostic): void {
+  private _collectDiagnostic(diagnostic: IAiDiagnostic, state: IAiDiagnosticState): void {
     if (diagnostic.category !== undefined) {
-      this._diagnosticCategoryCounts[diagnostic.category] =
-        (this._diagnosticCategoryCounts[diagnostic.category] ?? 0) + 1;
+      state.diagnosticCategoryCounts[diagnostic.category] =
+        (state.diagnosticCategoryCounts[diagnostic.category] ?? 0) + 1;
     }
     if (diagnostic.severity === 'error') {
-      this._errorCount++;
-      this._errorCodes.add(diagnostic.code);
-      if (this._errorDiagnostics.length < this._maxDetailedDiagnostics) {
-        this._errorDiagnostics.push({
+      state.errorCount++;
+      state.errorCodes.add(diagnostic.code);
+      if (state.errorDiagnostics.length < this._maxDetailedDiagnostics) {
+        state.errorDiagnostics.push({
           code: diagnostic.code,
           category: diagnostic.category,
           severity: 'error',
@@ -328,12 +365,12 @@ export class AiReporter implements IReporter {
           remediation: diagnostic.remediation
         });
       } else {
-        this._errorDiagnosticsTruncated = true;
+        state.errorDiagnosticsTruncated = true;
       }
     } else if (diagnostic.severity === 'warning') {
-      this._warningCount++;
-      if (this._warningDiagnostics.length < this._maxDetailedDiagnostics) {
-        this._warningDiagnostics.push({
+      state.warningCount++;
+      if (state.warningDiagnostics.length < this._maxDetailedDiagnostics) {
+        state.warningDiagnostics.push({
           code: diagnostic.code,
           category: diagnostic.category,
           severity: 'warning',
@@ -341,20 +378,41 @@ export class AiReporter implements IReporter {
           remediation: diagnostic.remediation
         });
       } else {
-        this._warningDiagnosticsTruncated = true;
+        state.warningDiagnosticsTruncated = true;
       }
     }
   }
 
-  private _resetWatchCycle(): void {
-    this._registeredOperations.clear();
-    this._projectByOperation.clear();
-    this._silentOperations.clear();
-    for (const status of Object.keys(this._operationCounts)) {
-      delete this._operationCounts[status];
+  private _getWatchCycle(iterationId?: number): IAiWatchCycleState {
+    const resolvedIterationId: number = iterationId ?? this._legacyIterationId;
+    let cycle: IAiWatchCycleState | undefined = this._watchCycles.get(resolvedIterationId);
+    if (!cycle) {
+      cycle = {
+        registeredOperations: new Set(),
+        projectByOperation: new Map(),
+        silentOperations: new Set(),
+        operationCounts: {},
+        failedProjects: [],
+        diagnostics: createDiagnosticState(),
+        watchCompleted: false
+      };
+      this._watchCycles.set(resolvedIterationId, cycle);
+    }
+    this._latestIterationId = Math.max(this._latestIterationId, resolvedIterationId);
+    this._pruneCompletedWatchCycles();
+    return cycle;
+  }
+
+  private _getLatestWatchCycle(): IAiWatchCycleState {
+    return this._getWatchCycle(this._latestIterationId);
+  }
+
+  private _pruneCompletedWatchCycles(): void {
+    for (const [iterationId, cycle] of this._watchCycles) {
+      if (iterationId < this._latestIterationId && cycle.watchCompleted) {
+        this._watchCycles.delete(iterationId);
+      }
     }
-    this._failedProjects.length = 0;
-    this._resetCycleOnNextRegistration = false;
   }
 
   private _emitFinal(succeeded: boolean, exitCode: number): void {
@@ -363,8 +421,21 @@ export class AiReporter implements IReporter {
     }
     this._finalEmitted = true;
 
+    const cycle: IAiWatchCycleState = this._getLatestWatchCycle();
+    const cycleDiagnostics: IAiDiagnosticState = cycle.diagnostics;
+    const errorCountWithoutFallback: number =
+      this._globalDiagnostics.errorCount + cycleDiagnostics.errorCount;
+    const warningCount: number = this._globalDiagnostics.warningCount + cycleDiagnostics.warningCount;
+    const collectedErrorDiagnostics: IAiDiagnostic[] = [
+      ...this._globalDiagnostics.errorDiagnostics,
+      ...cycleDiagnostics.errorDiagnostics
+    ];
+    const collectedWarningDiagnostics: IAiDiagnostic[] = [
+      ...this._globalDiagnostics.warningDiagnostics,
+      ...cycleDiagnostics.warningDiagnostics
+    ];
     const fallbackDiagnostics: IAiDiagnostic[] =
-      this._errorCount === 0
+      errorCountWithoutFallback === 0
         ? this._fallbackErrorMessages.map((summary) => ({
             code: 'RUSH_COMMAND_FAILED',
             category: 'command',
@@ -372,22 +443,27 @@ export class AiReporter implements IReporter {
             summary
           }))
         : [];
-    const hasFallbackErrors: boolean = this._errorCount === 0 && this._fallbackErrorCount > 0;
+    const hasFallbackErrors: boolean = errorCountWithoutFallback === 0 && this._fallbackErrorCount > 0;
     const errorDiagnostics: IAiDiagnostic[] = hasFallbackErrors
       ? fallbackDiagnostics
-      : this._errorDiagnostics;
-    const errorCount: number = this._errorCount + (hasFallbackErrors ? this._fallbackErrorCount : 0);
-    const errorCodes: string[] = hasFallbackErrors ? ['RUSH_COMMAND_FAILED'] : [...this._errorCodes].sort();
+      : collectedErrorDiagnostics;
+    const errorCount: number = errorCountWithoutFallback + (hasFallbackErrors ? this._fallbackErrorCount : 0);
+    const errorCodes: string[] = hasFallbackErrors
+      ? ['RUSH_COMMAND_FAILED']
+      : [...new Set([...this._globalDiagnostics.errorCodes, ...cycleDiagnostics.errorCodes])].sort();
     const diagnosticCategoryCounts: { [category: string]: number } = {
-      ...this._diagnosticCategoryCounts
+      ...this._globalDiagnostics.diagnosticCategoryCounts
     };
+    for (const [category, count] of Object.entries(cycleDiagnostics.diagnosticCategoryCounts)) {
+      diagnosticCategoryCounts[category] = (diagnosticCategoryCounts[category] ?? 0) + count;
+    }
     if (hasFallbackErrors) {
       diagnosticCategoryCounts.command = (diagnosticCategoryCounts.command ?? 0) + this._fallbackErrorCount;
     }
     const hasFailures: boolean = !succeeded || errorCount > 0;
     // When failures exist, warnings are represented by counts only. Warning-only
     // success may include bounded warning details.
-    const detailedSource: IAiDiagnostic[] = hasFailures ? errorDiagnostics : this._warningDiagnostics;
+    const detailedSource: IAiDiagnostic[] = hasFailures ? errorDiagnostics : collectedWarningDiagnostics;
 
     const record: {
       kind: 'ai.final';
@@ -408,16 +484,18 @@ export class AiReporter implements IReporter {
       protocolVersion: this._protocolVersion,
       result: succeeded ? 'succeeded' : 'failed',
       exitCode,
-      scope: { commandName: this._commandName, failedProjects: [...this._failedProjects] },
+      scope: { commandName: this._commandName, failedProjects: [...cycle.failedProjects] },
       errorCodes,
       diagnosticCategoryCounts,
       diagnostics: detailedSource.slice(0, this._maxDetailedDiagnostics),
       errorCount,
-      warningCount: this._warningCount,
-      operationCounts: { ...this._operationCounts },
+      warningCount,
+      operationCounts: { ...cycle.operationCounts },
       truncated: hasFailures
-        ? this._errorDiagnosticsTruncated || (hasFallbackErrors && this._fallbackErrorsTruncated)
-        : this._warningDiagnosticsTruncated
+        ? this._globalDiagnostics.errorDiagnosticsTruncated ||
+          cycleDiagnostics.errorDiagnosticsTruncated ||
+          (hasFallbackErrors && this._fallbackErrorsTruncated)
+        : this._globalDiagnostics.warningDiagnosticsTruncated || cycleDiagnostics.warningDiagnosticsTruncated
     };
 
     if (this._logPath !== undefined) {
diff --git a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
index 2a55abec505..073c82e80c0 100644
--- a/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
+++ b/libraries/reporter/src/reporters/DefaultInteractiveReporter.ts
@@ -17,6 +17,19 @@ import {
 const HIDE_CURSOR: string = '\u001b[?25l';
 const SHOW_CURSOR: string = '\u001b[?25h';
 const MAX_FINAL_DIAGNOSTICS: number = 10;
+
+interface IWatchCycleState {
+  totalOperations: number;
+  completedOperations: number;
+  failedOperations: number;
+  readonly registeredOperations: Set<string>;
+  readonly projectByOperation: Map<string, string>;
+  readonly silentOperations: Set<string>;
+  readonly activeProjects: Map<string, string>;
+  latestActivity: string;
+  watchCompleted: boolean;
+}
+
 /**
  * The terminal an interactive reporter writes to.
  *
@@ -100,13 +113,9 @@ export class DefaultInteractiveReporter implements IReporter {
   private readonly _minRefreshIntervalMs: number;
 
   private _commandName: string | undefined;
-  private _totalOperations: number;
-  private _completedOperations: number;
-  private _failedOperations: number;
-  private readonly _registeredOperations: Set<string>;
-  private readonly _projectByOperation: Map<string, string>;
-  private readonly _silentOperations: Set<string>;
-  private readonly _activeProjects: Map<string, string>;
+  private readonly _watchCycles: Map<number, IWatchCycleState>;
+  private _legacyIterationId: number;
+  private _latestIterationId: number;
   private _latestActivity: string;
   private readonly _diagnostics: string[];
   private _result: { succeeded: boolean; exitCode: number } | undefined;
@@ -117,7 +126,6 @@ export class DefaultInteractiveReporter implements IReporter {
   private _paintedRowCount: number;
   private _cursorHidden: boolean;
   private _finalized: boolean;
-  private _resetCycleOnNextRegistration: boolean;
 
   public constructor(options: IDefaultInteractiveReporterOptions) {
     this._terminal = options.terminal;
@@ -128,13 +136,9 @@ export class DefaultInteractiveReporter implements IReporter {
     this._minRefreshIntervalMs = options.minRefreshIntervalMs ?? MIN_REFRESH_INTERVAL_MS;
 
     this._commandName = undefined;
-    this._totalOperations = 0;
-    this._completedOperations = 0;
-    this._failedOperations = 0;
-    this._registeredOperations = new Set();
-    this._projectByOperation = new Map();
-    this._silentOperations = new Set();
-    this._activeProjects = new Map();
+    this._watchCycles = new Map();
+    this._legacyIterationId = 0;
+    this._latestIterationId = 0;
     this._latestActivity = '';
     this._diagnostics = [];
     this._result = undefined;
@@ -145,7 +149,6 @@ export class DefaultInteractiveReporter implements IReporter {
     this._paintedRowCount = 0;
     this._cursorHidden = false;
     this._finalized = false;
-    this._resetCycleOnNextRegistration = false;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -180,71 +183,84 @@ export class DefaultInteractiveReporter implements IReporter {
         break;
       }
       case 'operationRegistered': {
-        const payload: { operationId: string; projectName?: string; phaseName?: string; silent?: boolean } =
-          event.payload as {
-            operationId: string;
-            projectName?: string;
-            phaseName?: string;
-            silent?: boolean;
-          };
-        if (this._resetCycleOnNextRegistration) {
-          this._resetWatchCycle();
-        }
-        if (this._registeredOperations.has(payload.operationId)) {
+        const payload: {
+          operationId: string;
+          projectName?: string;
+          phaseName?: string;
+          silent?: boolean;
+          iterationId?: number;
+        } = event.payload as {
+          operationId: string;
+          projectName?: string;
+          phaseName?: string;
+          silent?: boolean;
+          iterationId?: number;
+        };
+        const cycle: IWatchCycleState = this._getWatchCycle(payload.iterationId);
+        if (cycle.registeredOperations.has(payload.operationId)) {
           break;
         }
-        this._registeredOperations.add(payload.operationId);
+        cycle.registeredOperations.add(payload.operationId);
         if (payload.silent) {
-          this._silentOperations.add(payload.operationId);
+          cycle.silentOperations.add(payload.operationId);
           break;
         }
-        this._silentOperations.delete(payload.operationId);
-        this._totalOperations++;
+        cycle.silentOperations.delete(payload.operationId);
+        cycle.totalOperations++;
         const projectName: string = payload.projectName ?? event.scope?.projectName ?? payload.operationId;
-        this._projectByOperation.set(
+        cycle.projectByOperation.set(
           payload.operationId,
           payload.phaseName ? `${projectName} (${payload.phaseName})` : projectName
         );
         break;
       }
       case 'operationStatusChanged': {
-        const payload: { operationId: string; status: string; projectName?: string } = event.payload as {
+        const payload: {
+          operationId: string;
+          status: string;
+          projectName?: string;
+          iterationId?: number;
+        } = event.payload as {
           operationId: string;
           status: string;
           projectName?: string;
+          iterationId?: number;
         };
+        const cycle: IWatchCycleState = this._getWatchCycle(payload.iterationId);
         const projectName: string =
           payload.projectName ??
           event.scope?.projectName ??
-          this._projectByOperation.get(payload.operationId) ??
+          cycle.projectByOperation.get(payload.operationId) ??
           payload.operationId;
-        if (this._silentOperations.has(payload.operationId)) {
+        if (cycle.silentOperations.has(payload.operationId)) {
           break;
         }
         if (payload.status === 'executing') {
-          this._activeProjects.set(payload.operationId, projectName);
+          cycle.activeProjects.set(payload.operationId, projectName);
         }
-        this._latestActivity = `${payload.status} ${projectName}`;
+        cycle.latestActivity = `${payload.status} ${projectName}`;
         break;
       }
       case 'operationCompleted': {
-        const payload: { operationId: string; status: string } = event.payload as {
+        const payload: { operationId: string; status: string; iterationId?: number } = event.payload as {
           operationId: string;
           status: string;
+          iterationId?: number;
         };
-        if (this._silentOperations.delete(payload.operationId)) {
+        const cycle: IWatchCycleState = this._getWatchCycle(payload.iterationId);
+        if (cycle.silentOperations.delete(payload.operationId)) {
           break;
         }
         const projectName: string =
-          this._projectByOperation.get(payload.operationId) ??
+          cycle.projectByOperation.get(payload.operationId) ??
           event.scope?.projectName ??
           payload.operationId;
-        this._activeProjects.delete(payload.operationId);
-        this._completedOperations++;
+        cycle.activeProjects.delete(payload.operationId);
+        cycle.completedOperations++;
         if (payload.status === 'failure') {
-          this._failedOperations++;
+          cycle.failedOperations++;
         }
-        this._latestActivity = `${payload.status} ${projectName}`;
+        cycle.latestActivity = `${payload.status} ${projectName}`;
         break;
       }
       case 'activityChanged': {
@@ -260,13 +276,15 @@ export class DefaultInteractiveReporter implements IReporter {
           text?: string;
         };
         if (payload.text !== undefined) {
-          this._latestActivity = this._toSingleLine(payload.text);
           if (
             event.scope?.operationId === undefined &&
             (payload.severity === 'error' || payload.severity === 'warning')
           ) {
             this._diagnostics.push(payload.text.trim());
           }
+          if (event.scope?.operationId !== undefined || payload.severity !== 'error') {
+            this._latestActivity = this._toSingleLine(payload.text);
+          }
         }
         break;
       }
@@ -305,13 +323,14 @@ export class DefaultInteractiveReporter implements IReporter {
   }
 
   private _snapshot(): ILiveRegionState {
+    const cycle: IWatchCycleState = this._getLatestWatchCycle();
     return {
       commandName: this._commandName,
-      totalOperations: this._totalOperations,
-      completedOperations: this._completedOperations,
-      failedOperations: this._failedOperations,
-      activeProjects: [...this._activeProjects.values()],
-      latestActivity: this._latestActivity
+      totalOperations: cycle.totalOperations,
+      completedOperations: cycle.completedOperations,
+      failedOperations: cycle.failedOperations,
+      activeProjects: [...cycle.activeProjects.values()],
+      latestActivity: cycle.latestActivity || this._latestActivity
     };
   }
 
@@ -340,29 +359,59 @@ export class DefaultInteractiveReporter implements IReporter {
   }
 
   private _appendWatchSummary(event: IReporterEventEnvelope<unknown>): void {
-    const payload: { succeeded?: boolean } = event.payload as { succeeded?: boolean };
+    const payload: { succeeded?: boolean; iterationId?: number } = event.payload as {
+      succeeded?: boolean;
+      iterationId?: number;
+    };
+    const cycle: IWatchCycleState = this._getWatchCycle(payload.iterationId);
     const marker: string = payload.succeeded ? this._color.green('✔') : this._color.red('✖');
     const summary: string =
       `${marker} watch cycle ${payload.succeeded ? 'succeeded' : 'failed'} - ` +
-      `${this._completedOperations}/${this._totalOperations} operations`;
+      `${cycle.completedOperations}/${cycle.totalOperations} operations`;
     this._terminal.write(`${this._clearRegion()}${summary}\n`);
     this._paintedRowCount = 0;
-    this._resetCycleOnNextRegistration = true;
+    cycle.watchCompleted = true;
+    this._pruneCompletedWatchCycles();
+    if (payload.iterationId === undefined) {
+      this._legacyIterationId++;
+    }
     if (this._terminal.isTTY) {
       this._paint();
     }
   }
 
-  private _resetWatchCycle(): void {
-    this._totalOperations = 0;
-    this._completedOperations = 0;
-    this._failedOperations = 0;
-    this._registeredOperations.clear();
-    this._projectByOperation.clear();
-    this._silentOperations.clear();
-    this._activeProjects.clear();
-    this._latestActivity = '';
-    this._resetCycleOnNextRegistration = false;
+  private _getWatchCycle(iterationId?: number): IWatchCycleState {
+    const resolvedIterationId: number = iterationId ?? this._legacyIterationId;
+    let cycle: IWatchCycleState | undefined = this._watchCycles.get(resolvedIterationId);
+    if (!cycle) {
+      cycle = {
+        totalOperations: 0,
+        completedOperations: 0,
+        failedOperations: 0,
+        registeredOperations: new Set(),
+        projectByOperation: new Map(),
+        silentOperations: new Set(),
+        activeProjects: new Map(),
+        latestActivity: '',
+        watchCompleted: false
+      };
+      this._watchCycles.set(resolvedIterationId, cycle);
+    }
+    this._latestIterationId = Math.max(this._latestIterationId, resolvedIterationId);
+    this._pruneCompletedWatchCycles();
+    return cycle;
+  }
+
+  private _getLatestWatchCycle(): IWatchCycleState {
+    return this._getWatchCycle(this._latestIterationId);
+  }
+
+  private _pruneCompletedWatchCycles(): void {
+    for (const [iterationId, cycle] of this._watchCycles) {
+      if (iterationId < this._latestIterationId && cycle.watchCompleted) {
+        this._watchCycles.delete(iterationId);
+      }
+    }
   }
 
   private _finalize(): void {
@@ -372,18 +421,19 @@ export class DefaultInteractiveReporter implements IReporter {
     this._finalized = true;
 
     const lines: string[] = [];
+    const cycle: IWatchCycleState = this._getLatestWatchCycle();
     const succeeded: boolean = this._result?.succeeded ?? false;
     if (succeeded) {
       lines.push(
         `${this._color.green('✔')} ${this._commandName ?? 'rush'} succeeded — ` +
-          `${this._completedOperations}/${this._totalOperations} operations`
+          `${cycle.completedOperations}/${cycle.totalOperations} operations`
       );
       if (this._logPath !== undefined) {
         lines.push(this._color.dim(`Log: ${this._logPath}`));
       }
     } else {
       lines.push(
-        `${this._color.red('✖')} ${this._commandName ?? 'rush'} failed — ${this._failedOperations} failed`
+        `${this._color.red('✖')} ${this._commandName ?? 'rush'} failed — ${cycle.failedOperations} failed`
       );
       for (const diagnostic of this._diagnostics.slice(0, MAX_FINAL_DIAGNOSTICS)) {
         lines.push(`  ${diagnostic}`);
diff --git a/libraries/reporter/src/reporters/FileReporter.ts b/libraries/reporter/src/reporters/FileReporter.ts
index 9e2ca30a902..87beecb93d6 100644
--- a/libraries/reporter/src/reporters/FileReporter.ts
+++ b/libraries/reporter/src/reporters/FileReporter.ts
@@ -40,6 +40,7 @@ const TERMINAL_STATUSES: ReadonlySet<string> = new Set([
 ]);
 
 interface IFileOperationRecord {
+  readonly operationId: string;
   readonly title: string;
   spoolPath?: string;
   spoolFileDescriptor?: number;
@@ -57,6 +58,10 @@ function sanitizeActionName(actionName: string): string {
   return sanitized === '.' || sanitized === '..' || sanitized.length === 0 ? 'rush' : sanitized;
 }
 
+function getOperationKey(operationId: string, iterationId: number | undefined): string {
+  return iterationId === undefined ? operationId : `${iterationId}\u0000${operationId}`;
+}
+
 /**
  * The resolved full-detail log artifact.
  *
@@ -226,8 +231,8 @@ export class FileReporter implements IReporter {
   }
 
   public async closeAsync(): Promise<void> {
-    for (const [operationId, record] of this._operations) {
-      this._writeGroupedOperation(operationId, record, 'aborted');
+    for (const record of this._operations.values()) {
+      this._writeGroupedOperation(record.operationId, record, 'aborted');
     }
     this._operations.clear();
     await this.flushAsync();
@@ -264,35 +269,43 @@ export class FileReporter implements IReporter {
         operationId: string;
         projectName?: string;
         phaseName?: string;
+        iterationId?: number;
       } = event.payload as {
         operationId: string;
         projectName?: string;
         phaseName?: string;
+        iterationId?: number;
       };
       const projectName: string = payload.projectName ?? payload.operationId;
-      const previousOperation: IFileOperationRecord | undefined = this._operations.get(payload.operationId);
+      const operationKey: string = getOperationKey(payload.operationId, payload.iterationId);
+      const previousOperation: IFileOperationRecord | undefined = this._operations.get(operationKey);
       if (previousOperation) {
         return [this._formatMetadata(event)];
       }
       this._operations.set(
-        payload.operationId,
-        this._createOperationRecord(payload.phaseName ? `${projectName} (${payload.phaseName})` : projectName)
+        operationKey,
+        this._createOperationRecord(
+          payload.operationId,
+          payload.phaseName ? `${projectName} (${payload.phaseName})` : projectName
+        )
       );
       return [this._formatMetadata(event)];
     }
 
     if (event.type === 'externalOutput') {
       const operationId: string | undefined = event.scope?.operationId;
-      const text: string = (event.payload as { text?: string }).text ?? '';
+      const payload: { text?: string; iterationId?: number; stream?: string } = event.payload as {
+        text?: string;
+        iterationId?: number;
+        stream?: string;
+      };
+      const text: string = payload.text ?? '';
+      const operationKey: string | undefined =
+        operationId === undefined ? undefined : getOperationKey(operationId, payload.iterationId);
       const operation: IFileOperationRecord | undefined =
-        operationId === undefined ? undefined : this._operations.get(operationId);
+        operationKey === undefined ? undefined : this._operations.get(operationKey);
       if (operationId !== undefined && operation) {
-        return this._spoolOperationOutput(
-          operationId,
-          operation,
-          (event.payload as { stream?: string }).stream ?? 'stdout',
-          text
-        );
+        return this._spoolOperationOutput(operationId, operation, payload.stream ?? 'stdout', text);
       }
       return operationId ? [`# [${operationId}]\n`, text] : [text];
     }
@@ -302,13 +315,15 @@ export class FileReporter implements IReporter {
     }
 
     if (event.type === 'operationCompleted') {
-      const payload: { operationId: string; status: string } = event.payload as {
+      const payload: { operationId: string; status: string; iterationId?: number } = event.payload as {
         operationId: string;
         status: string;
+        iterationId?: number;
       };
-      const operation: IFileOperationRecord | undefined = this._operations.get(payload.operationId);
+      const operationKey: string = getOperationKey(payload.operationId, payload.iterationId);
+      const operation: IFileOperationRecord | undefined = this._operations.get(operationKey);
       if (operation && TERMINAL_STATUSES.has(payload.status)) {
-        this._operations.delete(payload.operationId);
+        this._operations.delete(operationKey);
         this._writeGroupedOperation(payload.operationId, operation, payload.status);
         return [];
       }
@@ -321,8 +336,8 @@ export class FileReporter implements IReporter {
     return `# ${JSON.stringify(redactReporterEvent(event))}\n`;
   }
 
-  private _createOperationRecord(title: string): IFileOperationRecord {
-    return { title };
+  private _createOperationRecord(operationId: string, title: string): IFileOperationRecord {
+    return { operationId, title };
   }
 
   private _spoolOperationOutput(
diff --git a/libraries/reporter/src/reporters/PlaintextReporter.ts b/libraries/reporter/src/reporters/PlaintextReporter.ts
index 4569dfbc0c1..b3edb8d8b9f 100644
--- a/libraries/reporter/src/reporters/PlaintextReporter.ts
+++ b/libraries/reporter/src/reporters/PlaintextReporter.ts
@@ -35,6 +35,18 @@ interface IOperationRecord {
   spoolFailed?: boolean;
 }
 
+interface IWatchCycleState {
+  readonly operations: Map<string, IOperationRecord>;
+  total: number;
+  completed: number;
+  failed: number;
+  watchCompleted: boolean;
+}
+
+function getIterationId(payload: { iterationId?: number }, fallback: number): number {
+  return payload.iterationId ?? fallback;
+}
+
 /**
  * Options for {@link PlaintextReporter}.
  *
@@ -96,16 +108,14 @@ export class PlaintextReporter implements IReporter {
   private readonly _logLevel: ReporterLogLevel;
 
   private _commandName: string | undefined;
-  private _total: number;
-  private _completed: number;
-  private _failed: number;
   private _lastOutputMs: number;
   private _atLineStart: boolean;
   private _logPath: string | undefined;
-  private readonly _operations: Map<string, IOperationRecord>;
+  private readonly _watchCycles: Map<number, IWatchCycleState>;
   private _spoolDirectory: string | undefined;
   private _nextSpoolId: number;
-  private _resetCycleOnNextRegistration: boolean;
+  private _legacyIterationId: number;
+  private _latestIterationId: number;
 
   public constructor(options: IPlaintextReporterOptions) {
     this._write = options.write;
@@ -116,16 +126,14 @@ export class PlaintextReporter implements IReporter {
     this._logLevel = options.logLevel ?? 'normal';
 
     this._commandName = undefined;
-    this._total = 0;
-    this._completed = 0;
-    this._failed = 0;
     this._lastOutputMs = 0;
     this._atLineStart = true;
     this._logPath = undefined;
-    this._operations = new Map();
+    this._watchCycles = new Map();
     this._spoolDirectory = undefined;
     this._nextSpoolId = 1;
-    this._resetCycleOnNextRegistration = false;
+    this._legacyIterationId = 0;
+    this._latestIterationId = 0;
   }
 
   public async initializeAsync(): Promise<void> {
@@ -145,26 +153,27 @@ export class PlaintextReporter implements IReporter {
           projectName?: string;
           phaseName?: string;
           silent?: boolean;
+          iterationId?: number;
         } = event.payload as {
           operationId: string;
           projectName?: string;
           phaseName?: string;
           silent?: boolean;
+          iterationId?: number;
         };
-        if (this._resetCycleOnNextRegistration) {
-          this._resetWatchCycle();
-        }
-        const previousRecord: IOperationRecord | undefined = this._operations.get(payload.operationId);
+        const iterationId: number = getIterationId(payload, this._legacyIterationId);
+        const cycle: IWatchCycleState = this._getWatchCycle(iterationId);
+        const previousRecord: IOperationRecord | undefined = cycle.operations.get(payload.operationId);
         if (previousRecord) {
           break;
         }
-        this._operations.set(payload.operationId, {
+        cycle.operations.set(payload.operationId, {
           projectName: payload.projectName ?? payload.operationId,
           phaseName: payload.phaseName,
           silent: payload.silent === true
         });
         if (!payload.silent) {
-          this._total++;
+          cycle.total++;
         }
         break;
       }
@@ -215,12 +224,23 @@ export class PlaintextReporter implements IReporter {
         break;
       }
       case 'watchCycleCompleted': {
-        const succeeded: boolean = (event.payload as { succeeded?: boolean }).succeeded === true;
+        const payload: { succeeded?: boolean; iterationId?: number } = event.payload as {
+          succeeded?: boolean;
+          iterationId?: number;
+        };
+        const iterationId: number = getIterationId(payload, this._legacyIterationId);
+        const cycle: IWatchCycleState = this._getWatchCycle(iterationId);
+        const succeeded: boolean = payload.succeeded === true;
         this._writeLine(
           `Watch cycle ${succeeded ? 'succeeded' : 'failed'} ` +
-            `(${this._completed}/${this._total} operations, ${this._failed} failed)`
+            `(${cycle.completed}/${cycle.total} operations, ${cycle.failed} failed)`
         );
-        this._resetCycleOnNextRegistration = true;
+        this._latestIterationId = Math.max(this._latestIterationId, iterationId);
+        cycle.watchCompleted = true;
+        this._pruneCompletedWatchCycles();
+        if (payload.iterationId === undefined) {
+          this._legacyIterationId++;
+        }
         break;
       }
       case 'commandResult': {
@@ -237,18 +257,21 @@ export class PlaintextReporter implements IReporter {
   }
 
   public async closeAsync(): Promise<void> {
-    for (const [operationId, record] of this._operations) {
-      if (!record.silent && this._variant === 'detailed') {
-        const phase: string = record.phaseName ? ` (${record.phaseName})` : '';
-        this._writeLine('');
-        this._writeLine(`==[ ${record.projectName}${phase} ]==`);
-        this._writeSpooledOutput(record);
-        this._writeLine(this._formatStatus(record.projectName, 'aborted'));
-      } else {
-        this._deleteSpool(record);
+    for (const cycle of this._watchCycles.values()) {
+      for (const [operationId, record] of cycle.operations) {
+        if (!record.silent && this._variant === 'detailed') {
+          const phase: string = record.phaseName ? ` (${record.phaseName})` : '';
+          this._writeLine('');
+          this._writeLine(`==[ ${record.projectName}${phase} ]==`);
+          this._writeSpooledOutput(record);
+          this._writeLine(this._formatStatus(record.projectName, 'aborted'));
+        } else {
+          this._deleteSpool(record);
+        }
+        cycle.operations.delete(operationId);
       }
-      this._operations.delete(operationId);
     }
+    this._watchCycles.clear();
     this._removeSpoolDirectory();
   }
 
@@ -257,9 +280,10 @@ export class PlaintextReporter implements IReporter {
    * last output. Returns whether a heartbeat was emitted.
    */
   public emitHeartbeatIfDue(): boolean {
+    const cycle: IWatchCycleState = this._getLatestWatchCycle();
     if (this._nowMs() - this._lastOutputMs >= this._heartbeatIntervalMs) {
       this._writeLine(
-        `... ${this._commandName ?? 'rush'} still running — ${this._completed}/${this._total} operations`
+        `... ${this._commandName ?? 'rush'} still running — ${cycle.completed}/${cycle.total} operations`
       );
       return true;
     }
@@ -267,11 +291,14 @@ export class PlaintextReporter implements IReporter {
   }
 
   private _onOperationCompleted(event: IReporterEventEnvelope<unknown>): void {
-    const payload: { operationId: string; status: string } = event.payload as {
+    const payload: { operationId: string; status: string; iterationId?: number } = event.payload as {
       operationId: string;
       status: string;
+      iterationId?: number;
     };
-    const record: IOperationRecord | undefined = this._operations.get(payload.operationId);
+    const iterationId: number = getIterationId(payload, this._legacyIterationId);
+    const cycle: IWatchCycleState = this._getWatchCycle(iterationId);
+    const record: IOperationRecord | undefined = cycle.operations.get(payload.operationId);
     const projectName: string = record?.projectName ?? event.scope?.projectName ?? payload.operationId;
 
     if (!TERMINAL_STATUSES.has(payload.status)) {
@@ -279,20 +306,20 @@ export class PlaintextReporter implements IReporter {
     }
     if (record?.silent) {
       this._deleteSpool(record);
-      this._operations.delete(payload.operationId);
+      cycle.operations.delete(payload.operationId);
       return;
     }
 
-    this._completed++;
+    cycle.completed++;
     if (payload.status === 'failure') {
-      this._failed++;
+      cycle.failed++;
     }
 
     if (this._logLevel === 'quiet') {
       if (record) {
         this._deleteSpool(record);
       }
-      this._operations.delete(payload.operationId);
+      cycle.operations.delete(payload.operationId);
       return;
     }
 
@@ -307,7 +334,7 @@ export class PlaintextReporter implements IReporter {
     } else {
       this._writeLine(this._formatStatus(projectName, payload.status));
     }
-    this._operations.delete(payload.operationId);
+    cycle.operations.delete(payload.operationId);
   }
 
   private _onExternalOutput(event: IReporterEventEnvelope<unknown>): void {
@@ -315,9 +342,14 @@ export class PlaintextReporter implements IReporter {
       return;
     }
     const operationId: string | undefined = event.scope?.operationId;
-    const text: string = (event.payload as { text?: string }).text ?? '';
+    const payload: { text?: string; iterationId?: number } = event.payload as {
+      text?: string;
+      iterationId?: number;
+    };
+    const text: string = payload.text ?? '';
+    const cycle: IWatchCycleState = this._getWatchCycle(getIterationId(payload, this._legacyIterationId));
     const record: IOperationRecord | undefined =
-      operationId !== undefined ? this._operations.get(operationId) : undefined;
+      operationId !== undefined ? cycle.operations.get(operationId) : undefined;
     if (record) {
       this._spoolOutput(record, text);
     } else {
@@ -443,27 +475,49 @@ export class PlaintextReporter implements IReporter {
     this._spoolDirectory = undefined;
   }
 
-  private _resetWatchCycle(): void {
-    for (const record of this._operations.values()) {
-      this._deleteSpool(record);
+  private _getWatchCycle(iterationId: number): IWatchCycleState {
+    let cycle: IWatchCycleState | undefined = this._watchCycles.get(iterationId);
+    if (!cycle) {
+      cycle = {
+        operations: new Map(),
+        total: 0,
+        completed: 0,
+        failed: 0,
+        watchCompleted: false
+      };
+      this._watchCycles.set(iterationId, cycle);
+    }
+    this._latestIterationId = Math.max(this._latestIterationId, iterationId);
+    this._pruneCompletedWatchCycles();
+    return cycle;
+  }
+
+  private _getLatestWatchCycle(): IWatchCycleState {
+    return this._getWatchCycle(this._latestIterationId);
+  }
+
+  private _pruneCompletedWatchCycles(): void {
+    for (const [iterationId, cycle] of this._watchCycles) {
+      if (iterationId < this._latestIterationId && cycle.watchCompleted) {
+        for (const record of cycle.operations.values()) {
+          this._deleteSpool(record);
+        }
+        this._watchCycles.delete(iterationId);
+      }
     }
-    this._operations.clear();
-    this._total = 0;
-    this._completed = 0;
-    this._failed = 0;
-    this._resetCycleOnNextRegistration = false;
   }
 
   private _onResult(payload: { commandName: string; succeeded: boolean; exitCode: number }): void {
     const commandName: string = payload.commandName ?? this._commandName ?? 'rush';
+    const cycle: IWatchCycleState = this._getLatestWatchCycle();
     if (payload.succeeded) {
       this._writeLine(
         this._color.green(
-          `rush ${commandName} succeeded (${this._completed}/${this._total} operations, ${this._failed} failed)`
+          `rush ${commandName} succeeded (${cycle.completed}/${cycle.total} operations, ${cycle.failed} failed)`
         )
       );
     } else {
-      this._writeLine(this._color.red(`rush ${commandName} failed (${this._failed} failed)`));
+      this._writeLine(this._color.red(`rush ${commandName} failed (${cycle.failed} failed)`));
     }
     if (this._logPath) {
       this._writeLine(`Full log: ${this._logPath}`);
diff --git a/libraries/reporter/src/scheduler/OperationOutputGrouping.ts b/libraries/reporter/src/scheduler/OperationOutputGrouping.ts
index de22c95edba..91ff01e9e8c 100644
--- a/libraries/reporter/src/scheduler/OperationOutputGrouping.ts
+++ b/libraries/reporter/src/scheduler/OperationOutputGrouping.ts
@@ -9,6 +9,11 @@ import type { IReporterEventEnvelope } from '../events/IReporterEventEnvelope';
  * @beta
  */
 export interface IExternalOutputChunk {
+  /**
+   * The graph iteration that produced this chunk.
+   */
+  readonly iterationId?: number;
+
   /**
    * The operation the chunk belongs to, when scoped.
    */
@@ -41,11 +46,13 @@ export function iterateExternalOutput(
   const chunks: IExternalOutputChunk[] = [];
   for (const event of events) {
     if (event.type === 'externalOutput') {
-      const payload: { stream?: string; text?: string } = event.payload as {
+      const payload: { iterationId?: number; stream?: string; text?: string } = event.payload as {
+        iterationId?: number;
         stream?: string;
         text?: string;
       };
       chunks.push({
+        ...(payload.iterationId === undefined ? {} : { iterationId: payload.iterationId }),
         operationId: event.scope?.operationId,
         stream: payload.stream ?? 'stdout',
         text: payload.text ?? ''
diff --git a/libraries/reporter/src/scheduler/OperationStreamEmitter.ts b/libraries/reporter/src/scheduler/OperationStreamEmitter.ts
index 241217781e2..6936dadd9b8 100644
--- a/libraries/reporter/src/scheduler/OperationStreamEmitter.ts
+++ b/libraries/reporter/src/scheduler/OperationStreamEmitter.ts
@@ -91,7 +91,8 @@ export class OperationStreamEmitter {
     operationId: string,
     projectName?: string,
     phaseName?: string,
-    silent?: boolean
+    silent?: boolean,
+    iterationId?: number
   ): string {
     return this._emit(
       'operationRegistered',
@@ -99,7 +100,8 @@ export class OperationStreamEmitter {
         operationId,
         projectName,
         phaseName,
-        ...(silent === undefined ? {} : { silent })
+        ...(silent === undefined ? {} : { silent }),
+        ...(iterationId === undefined ? {} : { iterationId })
       },
       { operationId, projectName, phaseName },
       'public'
@@ -113,7 +115,8 @@ export class OperationStreamEmitter {
     operationId: string,
     status: OperationStatus,
     durationMs?: number,
-    previousStatus?: OperationStatus
+    previousStatus?: OperationStatus,
+    iterationId?: number
   ): string {
     return this._emit(
       'operationStatusChanged',
@@ -121,7 +124,8 @@ export class OperationStreamEmitter {
         operationId,
         status,
         ...(previousStatus === undefined ? {} : { previousStatus }),
-        ...(durationMs === undefined ? {} : { durationMs })
+        ...(durationMs === undefined ? {} : { durationMs }),
+        ...(iterationId === undefined ? {} : { iterationId })
       },
       { operationId },
       'public'
@@ -136,7 +140,12 @@ export class OperationStreamEmitter {
    * @param text - the raw output text
    * @returns the emitted event ids
    */
-  public writeOutput(operationId: string, stream: 'stdout' | 'stderr', text: string): string[] {
+  public writeOutput(
+    operationId: string,
+    stream: 'stdout' | 'stderr',
+    text: string,
+    iterationId?: number
+  ): string[] {
     const eventIds: string[] = [];
     let offset: number = 0;
     while (offset < text.length) {
@@ -158,7 +167,12 @@ export class OperationStreamEmitter {
       }
       const chunk: string = text.slice(offset, end);
       eventIds.push(
-        this._emit('externalOutput', { stream, text: chunk }, { operationId }, 'local-sensitive')
+        this._emit(
+          'externalOutput',
+          { stream, text: chunk, ...(iterationId === undefined ? {} : { iterationId }) },
+          { operationId },
+          'local-sensitive'
+        )
       );
       offset = end;
     }
@@ -168,17 +182,32 @@ export class OperationStreamEmitter {
   /**
    * Emits the authoritative signal that no more output will be emitted for an operation.
    */
-  public closeOperationStream(operationId: string): string {
-    return this._emit('operationStreamClosed', { operationId }, { operationId }, 'public');
+  public closeOperationStream(operationId: string, iterationId?: number): string {
+    return this._emit(
+      'operationStreamClosed',
+      { operationId, ...(iterationId === undefined ? {} : { iterationId }) },
+      { operationId },
+      'public'
+    );
   }
 
   /**
    * Emits the final outcome of an operation.
    */
-  public completeOperation(operationId: string, status: OperationStatus, durationMs?: number): string {
+  public completeOperation(
+    operationId: string,
+    status: OperationStatus,
+    durationMs?: number,
+    iterationId?: number
+  ): string {
     return this._emit(
       'operationCompleted',
-      { operationId, status, ...(durationMs === undefined ? {} : { durationMs }) },
+      {
+        operationId,
+        status,
+        ...(durationMs === undefined ? {} : { durationMs }),
+        ...(iterationId === undefined ? {} : { iterationId })
+      },
       { operationId },
       'public'
     );
diff --git a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
index c8b8584afdd..6213ea7a34a 100644
--- a/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
+++ b/libraries/reporter/src/test/DefaultInteractiveReporter.test.ts
@@ -262,7 +262,9 @@ describe('DefaultInteractiveReporter', () => {
     reporter.report(ev('commandResult', { commandName: 'build', succeeded: false, exitCode: 1 }));
     await reporter.closeAsync();
 
-    expect(terminal.output).toContain('Another Rush command is already running in this repository.');
+    expect(
+      terminal.output.match(/Another Rush command is already running in this repository\./g)
+    ).toHaveLength(1);
   });
 
   it('fails closed when commandResult is missing', async () => {
@@ -281,7 +283,7 @@ describe('DefaultInteractiveReporter', () => {
     expect(terminal.output).not.toContain('build succeeded');
   });
 
-  it('reports watch totals per cycle and recovers from failure', async () => {
+  it('reports overlapping watch iterations independently and recovers from failure', async () => {
     const terminal: FakeTerminal = new FakeTerminal();
     const reporter: DefaultInteractiveReporter = new DefaultInteractiveReporter({
       terminal,
@@ -290,22 +292,35 @@ describe('DefaultInteractiveReporter', () => {
     });
     await reporter.initializeAsync();
     reporter.report(ev('commandStarted', { commandName: 'build' }));
-    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
-    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
-    reporter.report(ev('watchCycleCompleted', { succeeded: false }));
-    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
     reporter.report(
-      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+      ev('operationRegistered', { iterationId: 1, operationId: 'op1', projectName: 'project-a' })
     );
-    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
-    reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'noOp' }));
-    reporter.report(ev('watchCycleCompleted', { succeeded: true }));
+    reporter.report(
+      ev('operationRegistered', { iterationId: 1, operationId: 'abort', projectName: 'project-abort' })
+    );
+    reporter.report(
+      ev('operationRegistered', { iterationId: 2, operationId: 'op1', projectName: 'project-a' })
+    );
+    reporter.report(
+      ev('operationRegistered', {
+        iterationId: 2,
+        operationId: 'silent',
+        projectName: 'hidden',
+        silent: true
+      })
+    );
+    reporter.report(ev('operationCompleted', { iterationId: 1, operationId: 'op1', status: 'failure' }));
+    reporter.report(ev('operationCompleted', { iterationId: 1, operationId: 'abort', status: 'aborted' }));
+    reporter.report(ev('watchCycleCompleted', { iterationId: 1, succeeded: false }));
+    reporter.report(ev('operationCompleted', { iterationId: 2, operationId: 'op1', status: 'success' }));
+    reporter.report(ev('operationCompleted', { iterationId: 2, operationId: 'silent', status: 'noOp' }));
+    reporter.report(ev('watchCycleCompleted', { iterationId: 2, succeeded: true }));
     reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
     await reporter.closeAsync();
 
-    expect(terminal.output).toContain('watch cycle failed - 1/1 operations');
+    expect(terminal.output).toContain('watch cycle failed - 2/2 operations');
     expect(terminal.output).toContain('watch cycle succeeded - 1/1 operations');
-    expect(terminal.output).not.toContain('2/2 operations');
+    expect(terminal.output).not.toContain('3/3 operations');
     expect(terminal.output).not.toContain('hidden');
   });
 
diff --git a/libraries/reporter/src/test/FileReporter.test.ts b/libraries/reporter/src/test/FileReporter.test.ts
index e6846338d2c..eded1e7b0a4 100644
--- a/libraries/reporter/src/test/FileReporter.test.ts
+++ b/libraries/reporter/src/test/FileReporter.test.ts
@@ -271,20 +271,24 @@ describe('FileReporter', () => {
       };
       const baselineOpenDescriptors: number | undefined = countOpenOperationDescriptors();
 
-      for (const operationId of ['completed', 'closed']) {
+      for (const [operationId, iterationId] of [
+        ['completed', 6],
+        ['closed', 7]
+      ] as const) {
         reporter.report(
           ev('operationRegistered', {
+            iterationId,
             operationId,
             projectName: operationId,
             phaseName: 'build'
           })
         );
         reporter.report({
-          ...ev('externalOutput', { stream: 'stdout', text: `${operationId}-1\n` }),
+          ...ev('externalOutput', { iterationId, stream: 'stdout', text: `${operationId}-1\n` }),
           scope: { operationId }
         });
         reporter.report({
-          ...ev('externalOutput', { stream: 'stdout', text: `${operationId}-2\n` }),
+          ...ev('externalOutput', { iterationId, stream: 'stdout', text: `${operationId}-2\n` }),
           scope: { operationId }
         });
       }
@@ -296,9 +300,14 @@ describe('FileReporter', () => {
         expect(countOpenOperationDescriptors()).toBe(baselineOpenDescriptors + 2);
       }
 
-      reporter.report(ev('operationCompleted', { operationId: 'completed', status: 'success' }));
+      reporter.report(
+        ev('operationCompleted', { iterationId: 6, operationId: 'completed', status: 'success' })
+      );
       await reporter.closeAsync();
 
+      const content: string = await fs.promises.readFile(reporter.getArtifact().path!, 'utf8');
+      expect(content).toContain('closed-1\nclosed-2\n==[ closed: aborted ]==');
+      expect(content).not.toContain('\u0000');
       expect((await fs.promises.readdir(logsDir)).filter((entry) => entry.endsWith('.operation'))).toEqual(
         []
       );
diff --git a/libraries/reporter/src/test/JsonAiReporter.test.ts b/libraries/reporter/src/test/JsonAiReporter.test.ts
index e4a5cdcb074..516cbd9260f 100644
--- a/libraries/reporter/src/test/JsonAiReporter.test.ts
+++ b/libraries/reporter/src/test/JsonAiReporter.test.ts
@@ -217,20 +217,41 @@ describe('AiReporter', () => {
     expect(final.operationCounts).toEqual({ fromCache: 1 });
   });
 
-  it('reports AI watch totals per cycle and recovers from failure', async () => {
+  it('keeps overlapping AI watch iterations and final recovery scope coherent', async () => {
     let output: string = '';
     const reporter: AiReporter = new AiReporter({ write: (text: string) => (output += text) });
     reporter.report(ev('commandStarted', { commandName: 'build' }));
-    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
-    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
-    reporter.report(ev('watchCycleCompleted', { succeeded: false }));
-    reporter.report(ev('operationRegistered', { operationId: 'op1', projectName: 'project-a' }));
     reporter.report(
-      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+      ev('operationRegistered', { iterationId: 1, operationId: 'op1', projectName: 'project-a' })
     );
-    reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
-    reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'noOp' }));
-    reporter.report(ev('watchCycleCompleted', { succeeded: true }));
+    reporter.report(
+      ev('operationRegistered', { iterationId: 1, operationId: 'abort', projectName: 'project-abort' })
+    );
+    reporter.report(
+      ev('operationRegistered', { iterationId: 2, operationId: 'op1', projectName: 'project-a' })
+    );
+    reporter.report(
+      ev('operationRegistered', {
+        iterationId: 2,
+        operationId: 'silent',
+        projectName: 'hidden',
+        silent: true
+      })
+    );
+    reporter.report(ev('operationCompleted', { iterationId: 1, operationId: 'op1', status: 'failure' }));
+    reporter.report(
+      ev('diagnosticEmitted', {
+        iterationId: 1,
+        code: 'RUSH_OPERATION_FAILED',
+        category: 'operation',
+        severity: 'error'
+      })
+    );
+    reporter.report(ev('operationCompleted', { iterationId: 1, operationId: 'abort', status: 'aborted' }));
+    reporter.report(ev('watchCycleCompleted', { iterationId: 1, succeeded: false }));
+    reporter.report(ev('operationCompleted', { iterationId: 2, operationId: 'op1', status: 'success' }));
+    reporter.report(ev('operationCompleted', { iterationId: 2, operationId: 'silent', status: 'noOp' }));
+    reporter.report(ev('watchCycleCompleted', { iterationId: 2, succeeded: true }));
     reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
     await reporter.closeAsync();
 
@@ -253,7 +274,7 @@ describe('AiReporter', () => {
     ).toEqual([
       {
         succeeded: false,
-        operationCounts: { failure: 1 },
+        operationCounts: { failure: 1, aborted: 1 },
         failedProjects: ['project-a']
       },
       {
@@ -262,7 +283,12 @@ describe('AiReporter', () => {
         failedProjects: []
       }
     ]);
-    expect((records.at(-1) as unknown as IAiFinalRecord).operationCounts).toEqual({ success: 1 });
+    const final: IAiFinalRecord = records.at(-1) as unknown as IAiFinalRecord;
+    expect(final.operationCounts).toEqual({ success: 1 });
+    expect(final.scope.failedProjects).toEqual([]);
+    expect(final.errorCount).toBe(0);
+    expect(final.errorCodes).toEqual([]);
+    expect(final.diagnostics).toEqual([]);
   });
 
   it('caps detailed diagnostics at 20 and marks the record truncated', () => {
diff --git a/libraries/reporter/src/test/OperationStreamEmitter.test.ts b/libraries/reporter/src/test/OperationStreamEmitter.test.ts
index 4eb2a3881d7..79f48251cac 100644
--- a/libraries/reporter/src/test/OperationStreamEmitter.test.ts
+++ b/libraries/reporter/src/test/OperationStreamEmitter.test.ts
@@ -61,12 +61,12 @@ describe('OperationStreamEmitter', () => {
   it('emits registration, status, output, and result with operation scope', () => {
     const sink: CapturingSink = new CapturingSink();
     const emitter: OperationStreamEmitter = makeEmitter(sink);
-    emitter.registerOperation('op1', 'project-a', 'build', false);
-    emitter.changeStatus('op1', 'executing', 0, 'queued');
-    emitter.writeOutput('op1', 'stdout', 'hello\n');
-    emitter.changeStatus('op1', 'success', 100, 'executing');
-    emitter.closeOperationStream('op1');
-    emitter.completeOperation('op1', 'success', 100);
+    emitter.registerOperation('op1', 'project-a', 'build', false, 7);
+    emitter.changeStatus('op1', 'executing', 0, 'queued', 7);
+    emitter.writeOutput('op1', 'stdout', 'hello\n', 7);
+    emitter.changeStatus('op1', 'success', 100, 'executing', 7);
+    emitter.closeOperationStream('op1', 7);
+    emitter.completeOperation('op1', 'success', 100, 7);
     emitter.completeCommand('build', true, 0, { success: 1 });
 
     expect(sink.inputs.map((i) => i.type)).toEqual([
@@ -80,6 +80,10 @@ describe('OperationStreamEmitter', () => {
     ]);
     expect(sink.inputs[2].scope).toEqual({ commandName: 'build', operationId: 'op1' });
     expect(sink.inputs[2].privacy).toBe('local-sensitive');
+    for (const input of sink.inputs.slice(0, 6)) {
+      expect(input.payload).toMatchObject({ iterationId: 7 });
+      expect(input.scope?.operationId).toBe('op1');
+    }
     expect(sink.inputs[0].payload).toMatchObject({ operationId: 'op1', silent: false });
     expect(sink.inputs[3].payload).toMatchObject({
       operationId: 'op1',
diff --git a/libraries/reporter/src/test/PlaintextReporter.test.ts b/libraries/reporter/src/test/PlaintextReporter.test.ts
index d5536a1b840..af7e2133240 100644
--- a/libraries/reporter/src/test/PlaintextReporter.test.ts
+++ b/libraries/reporter/src/test/PlaintextReporter.test.ts
@@ -166,29 +166,75 @@ describe('PlaintextReporter', () => {
     expect(capture.getOutput()).not.toContain('project-a: success');
   });
 
-  it('reports watch totals per cycle and recovers from failure', () => {
+  it('keeps overlapping watch totals and grouped output isolated by iteration', () => {
     const capture: ICapture = makeDetailed();
     capture.reporter.report(ev('commandStarted', { commandName: 'build' }));
     capture.reporter.report(
-      ev('operationRegistered', { operationId: 'op1', projectName: 'project-a', phaseName: 'build' })
+      ev('operationRegistered', {
+        iterationId: 1,
+        operationId: 'op1',
+        projectName: 'project-a',
+        phaseName: 'build'
+      })
     );
-    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'failure' }));
-    capture.reporter.report(ev('watchCycleCompleted', { succeeded: false }));
     capture.reporter.report(
-      ev('operationRegistered', { operationId: 'op1', projectName: 'project-a', phaseName: 'build' })
+      ev('operationRegistered', {
+        iterationId: 1,
+        operationId: 'abort',
+        projectName: 'project-abort',
+        phaseName: 'build'
+      })
     );
     capture.reporter.report(
-      ev('operationRegistered', { operationId: 'silent', projectName: 'hidden', silent: true })
+      ev('operationRegistered', {
+        iterationId: 2,
+        operationId: 'op1',
+        projectName: 'project-a',
+        phaseName: 'build'
+      })
     );
-    capture.reporter.report(ev('operationCompleted', { operationId: 'op1', status: 'success' }));
-    capture.reporter.report(ev('operationCompleted', { operationId: 'silent', status: 'noOp' }));
-    capture.reporter.report(ev('watchCycleCompleted', { succeeded: true }));
+    capture.reporter.report(
+      ev('operationRegistered', {
+        iterationId: 2,
+        operationId: 'silent',
+        projectName: 'hidden',
+        silent: true
+      })
+    );
+    capture.reporter.report(
+      ev('externalOutput', { iterationId: 1, stream: 'stdout', text: 'OLD-CYCLE\n' }, { operationId: 'op1' })
+    );
+    capture.reporter.report(
+      ev('externalOutput', { iterationId: 2, stream: 'stdout', text: 'NEW-CYCLE\n' }, { operationId: 'op1' })
+    );
+    capture.reporter.report(
+      ev('operationCompleted', { iterationId: 1, operationId: 'op1', status: 'failure' })
+    );
+    capture.reporter.report(
+      ev('operationCompleted', { iterationId: 1, operationId: 'abort', status: 'aborted' })
+    );
+    capture.reporter.report(ev('watchCycleCompleted', { iterationId: 1, succeeded: false }));
+    capture.reporter.report(
+      ev('operationCompleted', { iterationId: 2, operationId: 'op1', status: 'success' })
+    );
+    capture.reporter.report(
+      ev('operationCompleted', { iterationId: 2, operationId: 'silent', status: 'noOp' })
+    );
+    capture.reporter.report(ev('watchCycleCompleted', { iterationId: 2, succeeded: true }));
     capture.reporter.report(ev('commandResult', { commandName: 'build', succeeded: true, exitCode: 0 }));
 
-    expect(capture.getOutput()).toContain('Watch cycle failed (1/1 operations, 1 failed)');
+    expect(capture.getOutput()).toContain('Watch cycle failed (2/2 operations, 1 failed)');
     expect(capture.getOutput()).toContain('Watch cycle succeeded (1/1 operations, 0 failed)');
     expect(capture.getOutput()).toContain('rush build succeeded (1/1 operations, 0 failed)');
     expect(capture.getOutput()).not.toContain('hidden');
+    expect(capture.getOutput().match(/OLD-CYCLE/g)).toHaveLength(1);
+    expect(capture.getOutput().match(/NEW-CYCLE/g)).toHaveLength(1);
+    expect(capture.getOutput().indexOf('OLD-CYCLE')).toBeLessThan(
+      capture.getOutput().indexOf('project-a: failure')
+    );
+    expect(capture.getOutput().indexOf('project-a: failure')).toBeLessThan(
+      capture.getOutput().indexOf('NEW-CYCLE')
+    );
   });
 
   it('emits a compact heartbeat only after the interval elapses', () => {
diff --git a/libraries/rush-daemon/src/PhasedRequestEventMultiplexer.ts b/libraries/rush-daemon/src/PhasedRequestEventMultiplexer.ts
index 3ac90ca137e..6224916acda 100644
--- a/libraries/rush-daemon/src/PhasedRequestEventMultiplexer.ts
+++ b/libraries/rush-daemon/src/PhasedRequestEventMultiplexer.ts
@@ -39,17 +39,14 @@ export class PhasedRequestEventMultiplexer implements _IOperationGraphEventSink
     }
   }
 
-  public onOperationRegistered(operationId: string, silent: boolean): void {
-    this.#workspaceSink?.onOperationRegistered?.(operationId, silent);
+  public onOperationRegistered(operationId: string, silent: boolean, iterationId: number): void {
+    this.#workspaceSink?.onOperationRegistered?.(operationId, silent, iterationId);
     for (const requestSink of this.#requestSinks) {
-      requestSink.onOperationRegistered?.(operationId, silent);
+      requestSink.onOperationRegistered?.(operationId, silent, iterationId);
     }
   }
 
-  public onOperationStatusChanged(
-    result: IOperationExecutionResult,
-    previousStatus: OperationStatus
-  ): void {
+  public onOperationStatusChanged(result: IOperationExecutionResult, previousStatus: OperationStatus): void {
     this.#workspaceSink?.onOperationStatusChanged?.(result, previousStatus);
     for (const requestSink of this.#requestSinks) {
       requestSink.onOperationStatusChanged?.(result, previousStatus);
@@ -63,17 +60,17 @@ export class PhasedRequestEventMultiplexer implements _IOperationGraphEventSink
     }
   }
 
-  public onOperationChunk(operationId: string, chunk: ITerminalChunk): void {
-    this.#workspaceSink?.onOperationChunk?.(operationId, chunk);
+  public onOperationChunk(operationId: string, chunk: ITerminalChunk, iterationId: number): void {
+    this.#workspaceSink?.onOperationChunk?.(operationId, chunk, iterationId);
     for (const requestSink of this.#requestSinks) {
-      requestSink.onOperationChunk?.(operationId, chunk);
+      requestSink.onOperationChunk?.(operationId, chunk, iterationId);
     }
   }
 
-  public onOperationStreamClosed(operationId: string): void {
-    this.#workspaceSink?.onOperationStreamClosed?.(operationId);
+  public onOperationStreamClosed(operationId: string, iterationId: number): void {
+    this.#workspaceSink?.onOperationStreamClosed?.(operationId, iterationId);
     for (const requestSink of this.#requestSinks) {
-      requestSink.onOperationStreamClosed?.(operationId);
+      requestSink.onOperationStreamClosed?.(operationId, iterationId);
     }
   }
 
diff --git a/libraries/rush-lib/src/logic/operations/IOperationExecutionResult.ts b/libraries/rush-lib/src/logic/operations/IOperationExecutionResult.ts
index dfe8e307156..47769d76d63 100644
--- a/libraries/rush-lib/src/logic/operations/IOperationExecutionResult.ts
+++ b/libraries/rush-lib/src/logic/operations/IOperationExecutionResult.ts
@@ -80,6 +80,11 @@ export interface IConfigurableOperation extends IBaseOperationExecutionResult {
  * @alpha
  */
 export interface IOperationExecutionResult extends IBaseOperationExecutionResult, IOperationLastState {
+  /**
+   * The graph iteration that owns this result.
+   */
+  readonly iterationId: number;
+
   /**
    * The current execution status of an operation. Operations start in the 'ready' state,
    * but can be 'blocked' if an upstream operation failed. It is 'executing' when
diff --git a/libraries/rush-lib/src/logic/operations/OperationEventSink.ts b/libraries/rush-lib/src/logic/operations/OperationEventSink.ts
index 45f9f2a11e3..75f1bfce585 100644
--- a/libraries/rush-lib/src/logic/operations/OperationEventSink.ts
+++ b/libraries/rush-lib/src/logic/operations/OperationEventSink.ts
@@ -40,7 +40,7 @@ export interface IOperationGraphEventSink {
   /**
    * Invoked when an operation is prepared for an iteration.
    */
-  onOperationRegistered?(operationId: string, silent: boolean): void;
+  onOperationRegistered?(operationId: string, silent: boolean, iterationId: number): void;
 
   /**
    * Invoked synchronously on every operation status transition. The result's
@@ -59,14 +59,14 @@ export interface IOperationGraphEventSink {
    * Invoked for each chunk of an operation's raw output, upstream of any
    * newline normalization or quiet-mode filtering.
    */
-  onOperationChunk?(operationId: string, chunk: ITerminalChunk): void;
+  onOperationChunk?(operationId: string, chunk: ITerminalChunk, iterationId: number): void;
 
   /**
    * Invoked when an operation's collated output stream is closed at the end of
    * its execution, after all status lines and output have been written. This
    * is the authoritative "no more output for this operation" signal.
    */
-  onOperationStreamClosed?(operationId: string): void;
+  onOperationStreamClosed?(operationId: string, iterationId: number): void;
 
   /**
    * Invoked after the operation stream is closed and the final outcome is authoritative.
diff --git a/libraries/rush-lib/src/logic/operations/OperationExecutionRecord.ts b/libraries/rush-lib/src/logic/operations/OperationExecutionRecord.ts
index 3276ab4b914..5c0209bdfde 100644
--- a/libraries/rush-lib/src/logic/operations/OperationExecutionRecord.ts
+++ b/libraries/rush-lib/src/logic/operations/OperationExecutionRecord.ts
@@ -44,6 +44,7 @@ import {
  * @internal
  */
 export interface IOperationExecutionRecordContext {
+  iterationId: number;
   streamCollator: StreamCollator;
   onOperationStateChanged?: (record: OperationExecutionRecord) => void;
   createEnvironment?: (record: OperationExecutionRecord) => IEnvironment;
@@ -207,6 +208,10 @@ export class OperationExecutionRecord implements IOperationRunnerContext, IOpera
     return this.runner.name;
   }
 
+  public get iterationId(): number {
+    return this._context.iterationId;
+  }
+
   public get debugMode(): boolean {
     return this._context.debugMode;
   }
@@ -293,7 +298,7 @@ export class OperationExecutionRecord implements IOperationRunnerContext, IOpera
   public closeOperationStream(): void {
     if (!this._operationStreamClosed) {
       this._operationStreamClosed = true;
-      this._context.eventSink?.onOperationStreamClosed?.(this.name);
+      this._context.eventSink?.onOperationStreamClosed?.(this.name, this.iterationId);
     }
   }
 
@@ -334,7 +339,7 @@ export class OperationExecutionRecord implements IOperationRunnerContext, IOpera
       destinations: [
         destination,
         new OperationChunkTap(this.name, (operationId, chunk) =>
-          eventSink.onOperationChunk?.(operationId, chunk)
+          eventSink.onOperationChunk?.(operationId, chunk, this.iterationId)
         )
       ]
     });
diff --git a/libraries/rush-lib/src/logic/operations/OperationGraph.ts b/libraries/rush-lib/src/logic/operations/OperationGraph.ts
index 3d689862534..7d653f00c64 100644
--- a/libraries/rush-lib/src/logic/operations/OperationGraph.ts
+++ b/libraries/rush-lib/src/logic/operations/OperationGraph.ts
@@ -205,6 +205,7 @@ export class OperationGraph implements IOperationGraph {
   /** Tracks if a graph state change notification has been scheduled for next tick. */
   private _graphStateChangeScheduled: boolean = false;
   private _status: OperationStatus = OperationStatus.Ready;
+  private _nextIterationId: number = 1;
 
   public constructor(operations: Set<Operation>, options: IOperationGraphOptions) {
     const {
@@ -533,6 +534,13 @@ export class OperationGraph implements IOperationGraph {
 
     this._currentIteration = iteration;
     this._setScheduledIteration(undefined);
+    for (const executionRecord of iteration.records.values()) {
+      iteration.eventSink?.onOperationRegistered?.(
+        executionRecord.name,
+        executionRecord.silent,
+        executionRecord.iterationId
+      );
+    }
 
     iteration.promise = this._executeInnerAsync(this._currentIteration).finally(() => {
       this._currentIteration = undefined;
@@ -645,6 +653,7 @@ export class OperationGraph implements IOperationGraph {
 
     // Convert the developer graph to the mutable execution graph
     const iterationContext: IExecutionIterationContext = {
+      iterationId: this._nextIterationId++,
       abortController,
       startTime,
       streamCollator,
@@ -726,9 +735,6 @@ export class OperationGraph implements IOperationGraph {
       terminal.writeStderrLine(Colorize.red(errorMessage));
       throw e;
     }
-    for (const executionRecord of executionRecords.values()) {
-      eventSink?.onOperationRegistered?.(executionRecord.name, executionRecord.silent);
-    }
     if (!this._currentIteration) {
       this._setIdleTimeout();
     } else if (!this.pauseNextIteration) {
diff --git a/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts b/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts
index 4a90ed12710..056e480a6a5 100644
--- a/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts
+++ b/libraries/rush-lib/src/logic/operations/ReporterOperationEventSink.ts
@@ -28,9 +28,13 @@ interface IReporterOperation {
   readonly operationId: string;
   readonly phaseName: string;
   readonly projectName: string;
+  readonly streamEmitter: OperationStreamEmitter | undefined;
+  readonly cycles: Map<number, IReporterOperationCycle>;
+}
+
+interface IReporterOperationCycle {
   readonly registeredOperationIds: Set<string>;
   readonly statuses: Map<string, OperationStatus>;
-  readonly streamEmitter: OperationStreamEmitter | undefined;
   readonly closedOperationIds: Set<string>;
   readonly completedResults: Map<string, IOperationExecutionResult>;
   lastEmittedStatus: ReporterOperationStatus | undefined;
@@ -39,14 +43,17 @@ interface IReporterOperation {
 }
 
 class ReporterOperationEventSink implements IOperationGraphEventSink {
-  public readonly onOperationChunk: ((operationId: string, chunk: ITerminalChunk) => void) | undefined;
-  public readonly onOperationStreamClosed: ((operationId: string) => void) | undefined;
+  public readonly onOperationChunk:
+    | ((operationId: string, chunk: ITerminalChunk, iterationId: number) => void)
+    | undefined;
+  public readonly onOperationStreamClosed: ((operationId: string, iterationId: number) => void) | undefined;
   public readonly onOperationCompleted: ((result: IOperationExecutionResult) => void) | undefined;
 
   private readonly _operationsByLegacyId: Map<string, IReporterOperation> = new Map();
   private readonly _diagnosedOperations: Set<string> = new Set();
   private readonly _commandName: string;
   private readonly _rushSession: RushSession;
+  private readonly _operationStreamEnabled: boolean;
 
   public constructor(rushSession: RushSession, commandName: string, operations: Iterable<Operation>) {
     this._rushSession = rushSession;
@@ -83,31 +90,28 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
           operationId,
           phaseName,
           projectName,
-          registeredOperationIds: new Set(),
-          statuses: new Map(),
           streamEmitter,
-          closedOperationIds: new Set(),
-          completedResults: new Map(),
-          lastEmittedStatus: undefined,
-          silent: true,
-          streamClosed: false
+          cycles: new Map()
         };
         operationsByReporterId.set(operationId, reporterOperation);
       }
       reporterOperation.legacyOperationIds.add(operation.name);
-      reporterOperation.silent &&= !operation.enabled || operation.runner?.silent === true;
       this._operationsByLegacyId.set(operation.name, reporterOperation);
     }
 
-    if (Array.from(this._operationsByLegacyId.values()).some(({ streamEmitter }) => !!streamEmitter)) {
-      this.onOperationChunk = (operationId, chunk) => this._onOperationChunk(operationId, chunk);
-      this.onOperationStreamClosed = (operationId) => this._onOperationStreamClosed(operationId);
-      this.onOperationCompleted = (result) => this._onOperationCompleted(result);
+    this._operationStreamEnabled = Array.from(this._operationsByLegacyId.values()).some(
+      ({ streamEmitter }) => !!streamEmitter
+    );
+    if (this._operationStreamEnabled) {
+      this.onOperationChunk = (operationId, chunk, iterationId) =>
+        this._onOperationChunk(operationId, chunk, iterationId);
+      this.onOperationStreamClosed = (operationId, iterationId) =>
+        this._onOperationStreamClosed(operationId, iterationId);
     } else {
       this.onOperationChunk = undefined;
       this.onOperationStreamClosed = undefined;
-      this.onOperationCompleted = undefined;
     }
+    this.onOperationCompleted = this.isEnabled ? (result) => this._onOperationCompleted(result) : undefined;
   }
 
   public get isEnabled(): boolean {
@@ -115,29 +119,20 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
   }
 
   public get operationStreamEnabled(): boolean {
-    return this.onOperationCompleted !== undefined;
+    return this._operationStreamEnabled;
   }
 
-  public onOperationRegistered(operationId: string, silent: boolean): void {
+  public onOperationRegistered(operationId: string, silent: boolean, iterationId: number): void {
     const operation: IReporterOperation | undefined = this._operationsByLegacyId.get(operationId);
     if (!operation) {
       return;
     }
 
-    if (operation.registeredOperationIds.size === operation.legacyOperationIds.size) {
-      operation.registeredOperationIds.clear();
-      operation.statuses.clear();
-      operation.closedOperationIds.clear();
-      operation.completedResults.clear();
-      operation.lastEmittedStatus = undefined;
-      operation.silent = true;
-      operation.streamClosed = false;
-      this._diagnosedOperations.delete(operation.operationId);
-    }
+    const cycle: IReporterOperationCycle = this._getCycle(operation, iterationId);
 
-    operation.registeredOperationIds.add(operationId);
-    operation.silent &&= silent;
-    if (operation.registeredOperationIds.size !== operation.legacyOperationIds.size) {
+    cycle.registeredOperationIds.add(operationId);
+    cycle.silent &&= silent;
+    if (cycle.registeredOperationIds.size !== operation.legacyOperationIds.size) {
       return;
     }
 
@@ -146,10 +141,12 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
         operation.operationId,
         operation.projectName,
         operation.phaseName,
-        operation.silent
+        cycle.silent,
+        iterationId
       );
-    } else if (!operation.silent) {
+    } else if (!cycle.silent) {
       operation.emitter.emitOperationRegistered({
+        iterationId,
         operationId: operation.operationId,
         projectName: operation.projectName,
         phaseName: operation.phaseName
@@ -163,35 +160,37 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
       return;
     }
 
+    const cycle: IReporterOperationCycle = this._getCycle(operation, result.iterationId);
     if (
       result.status === OperationStatus.Ready &&
-      operation.registeredOperationIds.size === operation.legacyOperationIds.size
+      cycle.registeredOperationIds.size === operation.legacyOperationIds.size
     ) {
       return;
     }
 
-    operation.statuses.set(result.operation.name, result.status);
-    if (result.status === OperationStatus.Failure && !this._diagnosedOperations.has(operation.operationId)) {
-      this._diagnosedOperations.add(operation.operationId);
+    cycle.statuses.set(result.operation.name, result.status);
+    const diagnosticKey: string = `${result.iterationId}:${operation.operationId}`;
+    if (result.status === OperationStatus.Failure && !this._diagnosedOperations.has(diagnosticKey)) {
+      this._diagnosedOperations.add(diagnosticKey);
       const diagnostic: IRushDiagnostic = createRushDiagnostic('RUSH_OPERATION_FAILED', {
         parameters: {
           projectName: { value: operation.projectName, privacy: 'public' }
         }
       });
-      operation.emitter.emitDiagnostic(diagnostic);
+      operation.emitter.emitDiagnostic({ ...diagnostic, iterationId: result.iterationId });
       if (result.error) {
         _correlateRushSessionError(this._rushSession, result.error, diagnostic.diagnosticId);
       }
     }
 
-    const status: ReporterOperationStatus | undefined = _getAggregateStatus(operation);
-    if (status === undefined || status === operation.lastEmittedStatus) {
+    const status: ReporterOperationStatus | undefined = _getAggregateStatus(operation, cycle);
+    if (status === undefined || status === cycle.lastEmittedStatus) {
       return;
     }
     const aggregatePreviousStatus: ReporterOperationStatus | undefined =
-      operation.lastEmittedStatus ??
+      cycle.lastEmittedStatus ??
       (operation.legacyOperationIds.size === 1 ? _toReporterStatus(previousStatus) : undefined);
-    operation.lastEmittedStatus = status;
+    cycle.lastEmittedStatus = status;
     const durationMs: number | undefined =
       operation.legacyOperationIds.size === 1 && result.stopwatch.startTime !== undefined
         ? result.stopwatch.duration * 1000
@@ -201,10 +200,12 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
         operation.operationId,
         status,
         durationMs,
-        aggregatePreviousStatus
+        aggregatePreviousStatus,
+        result.iterationId
       );
-    } else if (!operation.silent) {
+    } else if (!cycle.silent) {
       operation.emitter.emitOperationStatusChanged({
+        iterationId: result.iterationId,
         operationId: operation.operationId,
         status,
         ...(durationMs === undefined ? {} : { durationMs })
@@ -233,52 +234,78 @@ class ReporterOperationEventSink implements IOperationGraphEventSink {
       });
   }
 
-  private _onOperationChunk(operationId: string, chunk: ITerminalChunk): void {
+  private _onOperationChunk(operationId: string, chunk: ITerminalChunk, iterationId: number): void {
     const operation: IReporterOperation | undefined = this._operationsByLegacyId.get(operationId);
     if (!operation?.streamEmitter) {
       return;
     }
 
     if (chunk.kind === TerminalChunkKind.Stdout) {
-      operation.streamEmitter.writeOutput(operation.operationId, 'stdout', chunk.text);
+      operation.streamEmitter.writeOutput(operation.operationId, 'stdout', chunk.text, iterationId);
     } else if (chunk.kind === TerminalChunkKind.Stderr) {
-      operation.streamEmitter.writeOutput(operation.operationId, 'stderr', chunk.text);
+      operation.streamEmitter.writeOutput(operation.operationId, 'stderr', chunk.text, iterationId);
     }
   }
 
-  private _onOperationStreamClosed(operationId: string): void {
+  private _onOperationStreamClosed(operationId: string, iterationId: number): void {
     const operation: IReporterOperation | undefined = this._operationsByLegacyId.get(operationId);
-    if (!operation?.streamEmitter || operation.streamClosed) {
+    if (!operation?.streamEmitter) {
       return;
     }
-    operation.closedOperationIds.add(operationId);
-    if (operation.closedOperationIds.size === operation.legacyOperationIds.size) {
-      operation.streamClosed = true;
-      operation.streamEmitter.closeOperationStream(operation.operationId);
+    const cycle: IReporterOperationCycle = this._getCycle(operation, iterationId);
+    if (cycle.streamClosed) {
+      return;
+    }
+    cycle.closedOperationIds.add(operationId);
+    if (cycle.closedOperationIds.size === operation.legacyOperationIds.size) {
+      cycle.streamClosed = true;
+      operation.streamEmitter.closeOperationStream(operation.operationId, iterationId);
     }
   }
 
   private _onOperationCompleted(result: IOperationExecutionResult): void {
     const operation: IReporterOperation | undefined = this._operationsByLegacyId.get(result.operation.name);
-    if (!operation?.streamEmitter) {
+    if (!operation) {
       return;
     }
 
-    operation.completedResults.set(result.operation.name, result);
-    if (operation.completedResults.size !== operation.legacyOperationIds.size) {
+    const cycle: IReporterOperationCycle = this._getCycle(operation, result.iterationId);
+    cycle.completedResults.set(result.operation.name, result);
+    if (cycle.completedResults.size !== operation.legacyOperationIds.size) {
       return;
     }
     const status: ReporterOperationStatus = _getAggregateTerminalStatus(
-      Array.from(operation.completedResults.values(), ({ status: resultStatus }) => resultStatus)
+      Array.from(cycle.completedResults.values(), ({ status: resultStatus }) => resultStatus)
     );
-    const durationMs: number | undefined = _getAggregateDurationMs(operation.completedResults);
-    operation.streamEmitter.completeOperation(operation.operationId, status, durationMs);
+    const durationMs: number | undefined = _getAggregateDurationMs(cycle.completedResults);
+    operation.streamEmitter?.completeOperation(operation.operationId, status, durationMs, result.iterationId);
+    operation.cycles.delete(result.iterationId);
+    this._diagnosedOperations.delete(`${result.iterationId}:${operation.operationId}`);
+  }
+
+  private _getCycle(operation: IReporterOperation, iterationId: number): IReporterOperationCycle {
+    let cycle: IReporterOperationCycle | undefined = operation.cycles.get(iterationId);
+    if (!cycle) {
+      cycle = {
+        registeredOperationIds: new Set(),
+        statuses: new Map(),
+        closedOperationIds: new Set(),
+        completedResults: new Map(),
+        lastEmittedStatus: undefined,
+        silent: true,
+        streamClosed: false
+      };
+      operation.cycles.set(iterationId, cycle);
+    }
+    return cycle;
   }
 }
 
 class CompositeOperationGraphEventSink implements IOperationGraphEventSink {
-  public readonly onOperationChunk: ((operationId: string, chunk: ITerminalChunk) => void) | undefined;
-  public readonly onOperationStreamClosed: ((operationId: string) => void) | undefined;
+  public readonly onOperationChunk:
+    | ((operationId: string, chunk: ITerminalChunk, iterationId: number) => void)
+    | undefined;
+  public readonly onOperationStreamClosed: ((operationId: string, iterationId: number) => void) | undefined;
   public readonly onOperationCompleted: ((result: IOperationExecutionResult) => void) | undefined;
 
   private readonly _first: IOperationGraphEventSink;
@@ -289,16 +316,16 @@ class CompositeOperationGraphEventSink implements IOperationGraphEventSink {
     this._second = second;
     this.onOperationChunk =
       first.onOperationChunk || second.onOperationChunk
-        ? (operationId, chunk) => {
-            first.onOperationChunk?.(operationId, chunk);
-            second.onOperationChunk?.(operationId, chunk);
+        ? (operationId, chunk, iterationId) => {
+            first.onOperationChunk?.(operationId, chunk, iterationId);
+            second.onOperationChunk?.(operationId, chunk, iterationId);
           }
         : undefined;
     this.onOperationStreamClosed =
       first.onOperationStreamClosed || second.onOperationStreamClosed
-        ? (operationId) => {
-            first.onOperationStreamClosed?.(operationId);
-            second.onOperationStreamClosed?.(operationId);
+        ? (operationId, iterationId) => {
+            first.onOperationStreamClosed?.(operationId, iterationId);
+            second.onOperationStreamClosed?.(operationId, iterationId);
           }
         : undefined;
     this.onOperationCompleted =
@@ -310,9 +337,9 @@ class CompositeOperationGraphEventSink implements IOperationGraphEventSink {
         : undefined;
   }
 
-  public onOperationRegistered(operationId: string, silent: boolean): void {
-    this._first.onOperationRegistered?.(operationId, silent);
-    this._second.onOperationRegistered?.(operationId, silent);
+  public onOperationRegistered(operationId: string, silent: boolean, iterationId: number): void {
+    this._first.onOperationRegistered?.(operationId, silent, iterationId);
+    this._second.onOperationRegistered?.(operationId, silent, iterationId);
   }
 
   public onOperationStatusChanged(result: IOperationExecutionResult, previousStatus: OperationStatus): void {
@@ -362,8 +389,12 @@ export function attachReporterOperationEventSink(
     lifecycleEmitter &&
       graph.hooks.afterExecuteIterationAsync.tapPromise(
         'RushReporterWatchCycle',
-        async (status: OperationStatus) => {
-          lifecycleEmitter.emitWatchCycleCompleted({ succeeded: SUCCESS_STATUSES.has(status) });
+        async (status: OperationStatus, records: ReadonlyMap<Operation, IOperationExecutionResult>) => {
+          const iterationId: number | undefined = records.values().next().value?.iterationId;
+          lifecycleEmitter.emitWatchCycleCompleted({
+            succeeded: SUCCESS_STATUSES.has(status),
+            ...(iterationId === undefined ? {} : { iterationId })
+          });
           return status;
         }
       );
@@ -399,21 +430,24 @@ function _toReporterStatus(status: OperationStatus): ReporterOperationStatus {
   }
 }
 
-function _getAggregateStatus(operation: IReporterOperation): ReporterOperationStatus | undefined {
-  const statuses: readonly OperationStatus[] = [...operation.statuses.values()];
+function _getAggregateStatus(
+  operation: IReporterOperation,
+  cycle: IReporterOperationCycle
+): ReporterOperationStatus | undefined {
+  const statuses: readonly OperationStatus[] = [...cycle.statuses.values()];
   if (
     statuses.some((status) => status === OperationStatus.Executing) ||
-    operation.lastEmittedStatus === 'executing'
+    cycle.lastEmittedStatus === 'executing'
   ) {
     if (
-      operation.statuses.size !== operation.legacyOperationIds.size ||
+      cycle.statuses.size !== operation.legacyOperationIds.size ||
       statuses.some((status) => !_isTerminalStatus(status))
     ) {
       return 'executing';
     }
   }
   if (
-    operation.statuses.size === operation.legacyOperationIds.size &&
+    cycle.statuses.size === operation.legacyOperationIds.size &&
     statuses.every((status) => _isTerminalStatus(status))
   ) {
     return _getAggregateTerminalStatus(statuses);
diff --git a/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts b/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts
index 8397da555e1..138a6ab82c8 100644
--- a/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts
+++ b/libraries/rush-lib/src/logic/operations/test/OperationGraphEventSink.test.ts
@@ -86,6 +86,7 @@ function createOperation(
 
 class RecordingSink implements IOperationGraphEventSink {
   public readonly registered: [string, boolean][] = [];
+  public readonly registeredIterations: number[] = [];
   public readonly transitions: [string, string][] = [];
   public readonly headers: [string, number, number][] = [];
   public readonly activities: string[] = [];
@@ -93,8 +94,9 @@ class RecordingSink implements IOperationGraphEventSink {
   public readonly closed: string[] = [];
   public readonly completed: [string, string][] = [];
 
-  public onOperationRegistered(operationId: string, silent: boolean): void {
+  public onOperationRegistered(operationId: string, silent: boolean, iterationId: number): void {
     this.registered.push([operationId, silent]);
+    this.registeredIterations.push(iterationId);
   }
   public onOperationStatusChanged(result: IOperationExecutionResult): void {
     this.transitions.push([result.operation.name, result.status]);
@@ -638,6 +640,7 @@ describe('OperationGraph event sink (dual-emit)', () => {
         operationStreamEnabled: true
       }
     });
+
     const graph: OperationGraph = new OperationGraph(
       new Set([createOperation('watch', new MockOperationRunner('watch'))]),
       createGraphOptions(mockWritable, false)
@@ -648,10 +651,27 @@ describe('OperationGraph event sink (dual-emit)', () => {
 
     expect(reporterSink.inputs.at(-1)).toMatchObject({
       type: 'watchCycleCompleted',
-      payload: { succeeded: true }
+      payload: { iterationId: 1, succeeded: true }
     });
   });
 
+  it('does not register a scheduled iteration until it begins execution', async () => {
+    const sink: RecordingSink = new RecordingSink();
+    const graph: OperationGraph = new OperationGraph(
+      new Set([createOperation('scheduled', new MockOperationRunner('scheduled'))]),
+      createGraphOptions(mockWritable, false)
+    );
+    graph.eventSink = sink;
+
+    await graph.scheduleIterationAsync({});
+    await graph.scheduleIterationAsync({});
+
+    expect(sink.registered).toEqual([]);
+    await graph.executeScheduledIterationAsync();
+    expect(sink.registered).toEqual([['scheduled', false]]);
+    expect(sink.registeredIterations).toEqual([2]);
+  });
+
   it('does not attach an operation adapter when the session has no reporter sink', () => {
     const rushSession: RushSession = new RushSession({
       terminalProvider: new StringBufferTerminalProvider(),
@@ -876,16 +896,26 @@ describe('OperationGraph event sink (dual-emit)', () => {
       '@scope/project#_phase:compile',
       '@scope/project#_phase:test'
     ]);
+    expect(registrations.map(({ payload }) => (payload as { iterationId?: number }).iterationId)).toEqual([
+      1, 1, 2, 2
+    ]);
     expect(
       reporterSink.inputs
         .filter(({ type }) => type === 'operationCompleted')
-        .map(({ scope }) => scope?.operationId)
-        .sort()
+        .map(({ scope, payload }) => ({
+          operationId: scope?.operationId,
+          iterationId: (payload as { iterationId?: number }).iterationId
+        }))
+        .sort((a, b) =>
+          a.operationId === b.operationId
+            ? (a.iterationId ?? 0) - (b.iterationId ?? 0)
+            : (a.operationId ?? '').localeCompare(b.operationId ?? '')
+        )
     ).toEqual([
-      '@scope/project#_phase:compile',
-      '@scope/project#_phase:compile',
-      '@scope/project#_phase:test',
-      '@scope/project#_phase:test'
+      { operationId: '@scope/project#_phase:compile', iterationId: 1 },
+      { operationId: '@scope/project#_phase:compile', iterationId: 2 },
+      { operationId: '@scope/project#_phase:test', iterationId: 1 },
+      { operationId: '@scope/project#_phase:test', iterationId: 2 }
     ]);
     for (const event of reporterSink.inputs.filter(({ type }) => type === 'operationStatusChanged')) {
       expect(event.scope?.operationId).toBe(`@scope/project#${event.scope?.phaseName}`);