feat(core): guarantee terminal output files and add an agent-friendly summary output style

e2e/nx/src/terminal-outputs.test.ts

@@ -0,0 +1,277 @@
+import { existsSync, readFileSync } from 'fs';
+import {
+  cleanupProject,
+  listFiles,
+  newProject,
+  readFile,
+  runCLI,
+  uniq,
+  updateFile,
+} from '@nx/e2e-utils';
+
+const TERMINAL_OUTPUTS_DIR = '.nx/cache/terminalOutputs';
+
+describe('terminal outputs on disk', () => {
+  beforeAll(() => newProject({ packages: [] }));
+
+  afterAll(() => cleanupProject());
+
+  /**
+   * Every task that reaches a terminal state has to leave its output at
+   * `<cacheDir>/terminalOutputs/<hash>`, so the file is found by content
+   * rather than by recomputing the task's hash.
+   */
+  function terminalOutputContains(marker: string): boolean {
+    return listFiles(TERMINAL_OUTPUTS_DIR).some((file) =>
+      readFile(`${TERMINAL_OUTPUTS_DIR}/${file}`).includes(marker)
+    );
+  }
+
+  function createRunCommandsProject(
+    lib: string,
+    marker: string,
+    cache: boolean
+  ) {
+    updateFile(
+      `libs/${lib}/project.json`,
+      JSON.stringify({
+        name: lib,
+        targets: {
+          echo: {
+            executor: 'nx:run-commands',
+            cache,
+            options: { command: `node -e "console.log('${marker}')"` },
+          },
+        },
+      })
+    );
+  }
+
+  it('should write terminal output for a cache:false task with --output-style=stream', () => {
+    const lib = uniq('streamed');
+    const marker = `streamed-marker-${lib}`;
+    createRunCommandsProject(lib, marker, false);
+
+    const results = runCLI(`echo ${lib} --output-style=stream`);
+
+    expect(results).toContain(marker);
+    expect(terminalOutputContains(marker)).toBe(true);
+  }, 120000);
+
+  it('should write terminal output for a cache:false task in batch mode', () => {
+    const plugin = uniq('batch-plugin');
+    const lib = uniq('batched');
+    const marker = `batched-marker-${lib}`;
+
+    // A minimal plugin whose executor supports batching, dropped straight into
+    // node_modules so it resolves like any installed one. Its batch
+    // implementation hands each task's output back over IPC and never touches
+    // disk — exactly the path that used to leave no file behind.
+    const pluginRoot = `node_modules/${plugin}`;
+    updateFile(
+      `${pluginRoot}/package.json`,
+      JSON.stringify({
+        name: plugin,
+        version: '0.0.1',
+        executors: './executors.json',
+      })
+    );
+    updateFile(
+      `${pluginRoot}/executors.json`,
+      JSON.stringify({
+        executors: {
+          echo: {
+            implementation: './impl',
+            batchImplementation: './batch-impl',
+            schema: './schema.json',
+          },
+        },
+      })
+    );
+    updateFile(
+      `${pluginRoot}/schema.json`,
+      JSON.stringify({
+        $schema: 'http://json-schema.org/schema',
+        type: 'object',
+        properties: { text: { type: 'string' } },
+      })
+    );
+    updateFile(
+      `${pluginRoot}/impl.js`,
+      `module.exports = {
+        default: async (options) => {
+          // Distinct from the batch marker on purpose: batching falls back to
+          // this silently when the batch implementation does not resolve
+          // (tasks-schedule.ts returns without a diagnostic), and the
+          // single-task path already wrote the output file before this PR - so
+          // a shared marker would keep the test green on the unfixed code.
+          console.log(options.text + '-single');
+          return { success: true };
+        },
+      };`
+    );
+    updateFile(
+      `${pluginRoot}/batch-impl.js`,
+      `module.exports = {
+        default: async (taskGraph, inputs) => {
+          const results = {};
+          for (const taskId of Object.keys(taskGraph.tasks)) {
+            results[taskId] = {
+              success: true,
+              terminalOutput: inputs[taskId].text + '-batched',
+            };
+          }
+          return results;
+        },
+      };`
+    );
+
+    updateFile(
+      `libs/${lib}/project.json`,
+      JSON.stringify({
+        name: lib,
+        targets: {
+          echo: {
+            executor: `${plugin}:echo`,
+            cache: false,
+            options: { text: marker },
+          },
+        },
+      })
+    );
+
+    runCLI(`echo ${lib}`, { env: { NX_BATCH_MODE: 'true' } });
+
+    // The batched marker specifically: this is the path NXC-4694 is about, and
+    // the non-batch fallback wrote a file at base too.
+    expect(terminalOutputContains(`${marker}-batched`)).toBe(true);
+  }, 120000);
+
+  it('should not replay a task whose output was written without artifacts', () => {
+    const lib = uniq('skipcache');
+    const marker = `skipcache-marker-${lib}`;
+    createRunCommandsProject(lib, marker, true);
+
+    // --skip-nx-cache leaves a terminal output file, and a record of it so the
+    // GC can collect it, but writes no cache entry.
+    const skipped = runCLI(`echo ${lib} --skip-nx-cache`);
+    expect(skipped).not.toContain('read the output from the cache');
+    expect(terminalOutputContains(marker)).toBe(true);
+
+    // That record must never be served as a hit — there are no outputs behind
+    // it, so replaying it would restore nothing while reporting success.
+    const firstRealRun = runCLI(`echo ${lib}`);
+    expect(firstRealRun).not.toContain('read the output from the cache');
+
+    // ...and the real entry it just wrote supersedes the record.
+    const replay = runCLI(`echo ${lib}`);
+    expect(replay).toContain('read the output from the cache');
+  }, 120000);
+
+  describe('--output-style=summary', () => {
+    function createFailingProject(lib: string, marker: string) {
+      updateFile(
+        `libs/${lib}/project.json`,
+        JSON.stringify({
+          name: lib,
+          targets: {
+            echo: {
+              executor: 'nx:run-commands',
+              cache: false,
+              options: {
+                command: `node -e "console.log('${marker}'); process.exit(3)"`,
+              },
+            },
+          },
+        })
+      );
+    }
+
+    function nonEmptyLines(out: string): string[] {
+      return out.split('\n').filter((l) => l.trim().length > 0);
+    }
+
+    it('should collapse a passing run to a handful of lines', () => {
+      const lib = uniq('summary-pass');
+      const marker = `summary-pass-marker-${lib}`;
+      createRunCommandsProject(lib, marker, false);
+
+      const results = runCLI(`echo ${lib} --output-style=summary`);
+
+      // The task's own output is on disk, not in the run's output.
+      expect(results).not.toContain(marker);
+      expect(results).toContain('succeeded');
+      expect(nonEmptyLines(results).length).toBeLessThanOrEqual(10);
+    }, 120000);
+
+    it('should name a failing task and point at its log on disk', () => {
+      const lib = uniq('summary-fail');
+      const marker = `summary-fail-marker-${lib}`;
+      createFailingProject(lib, marker);
+
+      const results = runCLI(`echo ${lib} --output-style=summary`, {
+        silenceError: true,
+        redirectStderr: true,
+      });
+
+      expect(results).toContain('1 failed');
+      expect(results).toContain(`nx run ${lib}:echo`);
+      // No exit code is printed. `completeTasks` rebuilds `TaskResult.code`
+      // from the status rather than carrying the code the process returned, so
+      // every failure reaches a life cycle as 1 - this task exits 3 and would
+      // have rendered `(exit 1)`. Rather than print a number that is always 1
+      // to a reader whose job is to machine-read the line, the style prints
+      // none. Carrying the real code through `TaskResult` would change what
+      // task history and Nx Cloud record, which is its own change.
+      expect(results).not.toContain('(exit');
+      // Bounded regardless of how much the task logged.
+      expect(nonEmptyLines(results).length).toBeLessThanOrEqual(30);
+
+      // The path it prints has to be real, and hold the output it stands in for.
+      const logPath = results.match(/full log: (\S+)/)?.[1];
+      expect(logPath).toBeDefined();
+      expect(existsSync(logPath)).toBe(true);
+      expect(readFileSync(logPath, 'utf-8')).toContain(marker);
+    }, 120000);
+
+    it('should be the default when nx is driven by an AI agent', () => {
+      const lib = uniq('summary-agent');
+      const marker = `summary-agent-marker-${lib}`;
+      createRunCommandsProject(lib, marker, false);
+
+      const results = runCLI(`echo ${lib}`, { env: { CLAUDECODE: '1' } });
+
+      expect(results).not.toContain(marker);
+      expect(results).toContain('succeeded');
+      expect(nonEmptyLines(results).length).toBeLessThanOrEqual(10);
+    }, 120000);
+
+    it('should let an explicit output style beat the AI agent default', () => {
+      const lib = uniq('summary-explicit');
+      const marker = `summary-explicit-marker-${lib}`;
+      createRunCommandsProject(lib, marker, false);
+
+      const results = runCLI(`echo ${lib} --output-style=static`, {
+        env: { CLAUDECODE: '1' },
+      });
+
+      // static prints every task in full, agent or not.
+      expect(results).toContain(marker);
+    }, 120000);
+  });
+
+  it('should keep the cached path intact so a replay still reads its output', () => {
+    const lib = uniq('cached');
+    const marker = `cached-marker-${lib}`;
+    createRunCommandsProject(lib, marker, true);
+
+    const firstRun = runCLI(`echo ${lib}`);
+    expect(firstRun).not.toContain('read the output from the cache');
+    expect(terminalOutputContains(marker)).toBe(true);
+
+    const replay = runCLI(`echo ${lib}`);
+    expect(replay).toContain('read the output from the cache');
+    // The replay reads this very file, so it must still be there afterwards.
+    expect(terminalOutputContains(marker)).toBe(true);
+  }, 120000);
+});

e2e/utils/get-env-info.ts

@@ -188,6 +188,16 @@ export function getStrippedEnvironmentVariables(cwd: string = tmpProjPath()) {
       // Remove AI agent detection env vars to prevent the test runner's
       // environment (e.g., running inside Claude Code) from leaking into
       // e2e test subprocesses. Tests that need these pass them explicitly.
+      //
+      // Every variable `is_ai_agent` reads must be here, or a run started from
+      // that agent resolves to `--output-style=summary`, which prints no task
+      // output and no `Successfully ran target` line — the string ~96 e2e files
+      // assert on. This list has fallen behind `ai.rs` twice as it gained
+      // detectors, so check it rather than trusting it:
+      //   grep -o 'env::var("[^"]*"' packages/nx/src/native/utils/ai.rs
+      // PAGER is deliberately absent: Cursor needs it alongside CURSOR_TRACE_ID
+      // and COMPOSER_NO_INTERACTION, which are both stripped. NX_DAEMON_PROCESS
+      // is already dropped by the NX_ rule above.
       const aiAgentEnvVars = [
         'CLAUDECODE',
         'CLAUDE_CODE',
@@ -196,6 +206,10 @@ export function getStrippedEnvironmentVariables(cwd: string = tmpProjPath()) {
         'CURSOR_TRACE_ID',
         'COMPOSER_NO_INTERACTION',
         'REPL_ID',
+        'VSCODE_AGENT',
+        'CODEX_THREAD_ID',
+        'COPILOT_CLI',
+        'SUPERSET_AGENT_ID',
       ];
       if (aiAgentEnvVars.includes(key)) {
         return false;

packages/nx/src/command-line/release/publish.ts

@@ -307,19 +307,26 @@ async function runPublishOnProjects(
    * NOTE: Force TUI to be disabled for now.
    */
   process.env.NX_TUI = 'false';
+  const publishOutputStyle = (args as any).specifiedOutputStyle ?? 'static';
   const { taskResults } = await runCommandForTasks(
     projectsWithTarget,
     projectGraph,
     { nxJson },
     {
       targets: [requiredTargetName],
+      ...(args as any),
       // Everything this command reports — the registry, the tag, the
       // package.json diff, the dry-run summary — is printed from inside the
       // task, so the failures-only default would swallow all of it (under
-      // --dry-run every task succeeds by definition). An explicit
-      // --output-style still wins, since it comes in through the spread.
-      outputStyle: 'static',
-      ...(args as any),
+      // --dry-run every task succeeds by definition). Set after the spread and
+      // on all three fields: the middleware always writes `resolvedOutputStyle`,
+      // so a value placed before it would be overwritten on every run, and the
+      // renderer reads the new fields rather than the deprecated one. A style
+      // the user actually named still wins, which is what `specifiedOutputStyle`
+      // being set means.
+      outputStyle: publishOutputStyle,
+      specifiedOutputStyle: publishOutputStyle,
+      resolvedOutputStyle: publishOutputStyle,
       // It is possible for workspaces to have circular dependencies between packages and still release them to a registry
       nxIgnoreCycles: true,
     },