@@ -47,8 +47,8 @@ subfork execute GRAPH_ID --version v1
 subfork execute GRAPH_ID -o results.json
 ```
 
-`execute` waits for completion and returns JSON. Use `-o` to save results to a
-file; progress stays on stderr. Add `-f` / `--force` to overwrite existing output
+`execute` waits for completion and shows progress on stderr. Results are opt-in:
+use `-o results.json` to save JSON or `-o -` to print it to stdout. Add `-f` / `--force` to overwrite existing output
 files with `execute` or `export`. Run `subfork --help` or `subfork execute --help`
 for more options.
 
 
@@ -38,21 +38,21 @@ subfork execute GRAPH_ID -o results.json
 subfork execute GRAPH_ID -o results.json --force
 ```
 
-Execution waits for completion and prints JSON outputs. `-o` / `--out` writes
-results to a file instead of stdout. Use `-f` / `--force` to overwrite an existing
+Execution waits for completion without printing results. `-o` / `--out` writes
+result JSON to a file; use `-o -` to print it to stdout. Use `-f` / `--force` to overwrite an existing
 file; this flag also works with `export`.
 
 A yellow spinner shows active nodes. Finished nodes remain on stderr with their
-final status. JSON results stay on stdout, so piping works normally:
+final status. Opt in to JSON output for piping:
 
 ```bash
-subfork execute GRAPH_ID > results.json
+subfork execute GRAPH_ID -o - > results.json
 ```
 
 | Option | Behavior |
 | --- | --- |
-| `--no-wait` | Return the submission ID and status immediately |
-| `--raw` | Return the full execution snapshot |
+| `--no-wait` | Report submission ID and status on stderr immediately; use `-o` for JSON |
+| `--raw` | Print the full execution snapshot, or write it to the `-o` destination |
 | `--wait-timeout 300` | Wait up to 300 seconds; the default is 120 |
 | `--poll-interval 1` | Poll every second; the default is 2 |
 
 
@@ -183,7 +183,11 @@ def build_parser() -> argparse.ArgumentParser:
             child.add_argument("--comment", default="")
         elif command == "execute":
             child.add_argument("--version", default="draft")
-            child.add_argument("-o", "--out", help="Write result JSON to a file instead of stdout")
+            child.add_argument(
+                "-o",
+                "--out",
+                help="Write result JSON to a file, or - for stdout (default: no results)",
+            )
             child.add_argument(
                 "--no-wait", action="store_true", help="Return submission status immediately"
             )
@@ -314,7 +318,12 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
             if result_file is not None
             else (export_file if export_file != "-" else None)
         )
-        if destination is not None and Path(destination).exists() and not force:
+        if (
+            destination is not None
+            and destination != "-"
+            and Path(destination).exists()
+            and not force
+        ):
             raise ValueError("Output file already exists; use --force to overwrite.")
         with Subfork(base_url=args.base_url, timeout=args.timeout) as client:
             result = graph_command(client, args)
@@ -333,16 +342,25 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                 }
             else:
                 display = result.get("outputs", {})
-        rendered = json.dumps(display, indent=2, ensure_ascii=False) + "\n"
-        output = getattr(args, "output", "-")
-        if result_file is None and output == "-":
-            sys.stdout.write(rendered)
-        else:
-            # Open only after the request and serialization succeed.
-            with Path(result_file if result_file is not None else output).open(
-                "w" if force else "x", encoding="utf-8", newline="\n"
-            ) as stream:
-                stream.write(rendered)
+        emit_results = args.command != "execute" or result_file is not None or args.raw
+        if emit_results:
+            rendered = json.dumps(display, indent=2, ensure_ascii=False) + "\n"
+            output = result_file if result_file is not None else getattr(args, "output", "-")
+            if output == "-":
+                sys.stdout.write(rendered)
+            else:
+                # Open only after the request and serialization succeed.
+                with Path(output).open(
+                    "w" if force else "x", encoding="utf-8", newline="\n"
+                ) as stream:
+                    stream.write(rendered)
+        elif args.command == "execute" and args.no_wait:
+            print(
+                "Execution {}: {}".format(
+                    result.get("id") or result.get("execution_id"), result.get("status")
+                ),
+                file=sys.stderr,
+            )
         if failed:
             print(
                 "subfork: execution did not complete successfully; use --raw for details",
 
@@ -126,7 +126,7 @@ def test_removed_groups(command: str) -> None:
     assert result.value.code == 2
 
 
-@pytest.mark.parametrize("mode", ["default", "raw", "no-wait", "failed", "timeout"])
+@pytest.mark.parametrize("mode", ["default", "stdout", "raw", "no-wait", "failed", "timeout"])
 def test_execution_output_modes(monkeypatch: pytest.MonkeyPatch, capsys: Any, mode: str) -> None:
     """Wait for results by default and preserve explicit diagnostic output modes."""
     seen = []
@@ -164,23 +164,24 @@ def timeout(*args: Any, **kwargs: Any) -> dict:
     arguments = ["execute", "g_test"]
     if mode in {"raw", "no-wait"}:
         arguments.append("--" + mode)
+    if mode == "stdout":
+        arguments.extend(["-o", "-"])
     assert cli.main(arguments) == (1 if mode in {"failed", "timeout"} else 0)
     captured = capsys.readouterr()
     assert sum(request.method == "POST" for request in seen) == 1
     if mode == "timeout":
         assert captured.out == ""
         assert "e_test" in captured.err and "not canceled" in captured.err
         return
-    output = json.loads(captured.out)
-    if mode == "raw":
-        assert output == completed
-    elif mode == "default":
-        assert output == completed["outputs"]
+    if mode in {"default", "no-wait", "failed"}:
+        assert captured.out == ""
+        if mode == "no-wait":
+            assert "e_test" in captured.err and "running" in captured.err
+        if mode == "failed":
+            assert "did not complete successfully" in captured.err
     else:
-        assert output == {
-            "execution_id": "e_test",
-            "status": "failed" if mode == "failed" else "running",
-        }
+        output = json.loads(captured.out)
+        assert output == (completed if mode == "raw" else completed["outputs"])
     assert len(seen) == (1 if mode == "no-wait" else 2)