@@ -151,6 +151,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **A stdio client did not notice its agent process exiting.** `StdioAcpClientTransport` did not
+  implement `awaitTermination()`, so when the agent exited or crashed, pending requests waited out the
+  request timeout. It now completes when the transport is closed, and errors with an
+  `AcpConnectionException` such as `ACP agent process exited with code 137 (signal 9)` once the
+  agent's output has ended and the process has exited on its own; the session fails pending requests
+  with it at once.
 - **A peer's error answer to a message it could not read was logged as an SDK bug.** An error
   response with `"id": null` (what JSON-RPC 2.0 prescribes, and what this SDK and its peers send, for
   a message whose id could not be read) was logged at ERROR as "a bug in the request sender code".
 
@@ -18,6 +18,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import com.agentclientprotocol.sdk.error.AcpConnectionException;
 import com.agentclientprotocol.sdk.json.AcpJsonMapper;
 import com.agentclientprotocol.sdk.json.TypeRef;
 import com.agentclientprotocol.sdk.spec.AcpClientTransport;
@@ -82,13 +83,25 @@ public class StdioAcpClientTransport implements AcpClientTransport {
 
 	private volatile boolean isClosing = false;
 
+	/** Set by {@link #closeGracefully}: the end of the agent process is then expected. */
+	private volatile boolean closedLocally = false;
+
+	/**
+	 * Terminates when the transport can no longer deliver: empty once closed locally, with
+	 * an error naming the exit when the agent process ended on its own.
+	 */
+	private final Sinks.One<Void> terminationSink = Sinks.one();
+
 	/**
 	 * A transport instance carries exactly one session. {@link #connect} subscribes the
 	 * unicast inbound and outbound sinks and starts the agent process; a second call would
 	 * subscribe them again and start a second process, so it is refused up front.
 	 */
 	private final AtomicBoolean isConnected = new AtomicBoolean(false);
 
+	/** How long to wait for the agent process to exit after its standard output ends. */
+	private static final Duration EXIT_WAIT = Duration.ofSeconds(5);
+
 	private volatile Consumer<Throwable> exceptionHandler = t -> logger.error("Transport error", t);
 
 	// visible for tests
@@ -318,8 +331,52 @@ public Mono<Void> sendMessage(JSONRPCMessage message) {
 	 * process's input stream. Messages are deserialized and emitted to the inbound sink.
 	 */
 	private void startInboundProcessing(Process process) {
-		readLines(this.inboundScheduler, process.getInputStream(), "input stream", this::emitInbound,
-				this.inboundSink::tryEmitComplete);
+		readLines(this.inboundScheduler, process.getInputStream(), "input stream", this::emitInbound, () -> {
+			this.inboundSink.tryEmitComplete();
+			terminated(process);
+		});
+	}
+
+	/**
+	 * The agent's standard output has ended: once the process has exited, reports the end of
+	 * the transport, naming the exit, unless it was closed locally.
+	 */
+	private void terminated(Process process) {
+		if (this.closedLocally) {
+			this.terminationSink.tryEmitEmpty();
+			return;
+		}
+		String reason;
+		try {
+			// The agent normally exits right after its output ends; one that closed its
+			// output but goes on running can deliver nothing more either.
+			reason = process.waitFor(EXIT_WAIT.toMillis(), java.util.concurrent.TimeUnit.MILLISECONDS)
+					? exitDescription(process.exitValue())
+					: "ACP agent process closed its standard output but has not exited";
+		}
+		catch (InterruptedException e) {
+			Thread.currentThread().interrupt();
+			reason = "ACP agent process closed its standard output";
+		}
+		if (this.closedLocally) {
+			this.terminationSink.tryEmitEmpty();
+			return;
+		}
+		logger.info("{}", reason);
+		this.terminationSink.tryEmitError(new AcpConnectionException(reason));
+	}
+
+	/**
+	 * Names how the agent process ended. On POSIX systems Java reports a process killed by
+	 * signal {@code n} as exit code {@code 128 + n}.
+	 */
+	static String exitDescription(int exitCode) {
+		String description = "ACP agent process exited with code " + exitCode;
+		boolean windows = System.getProperty("os.name", "").startsWith("Windows");
+		if (!windows && exitCode > 128 && exitCode < 128 + 65) {
+			description += " (signal " + (exitCode - 128) + ")";
+		}
+		return description;
 	}
 
 	/**
@@ -433,6 +490,7 @@ protected void handleOutbound(Function<Flux<JSONRPCMessage>, Flux<JSONRPCMessage
 	@Override
 	public Mono<Void> closeGracefully() {
 		return Mono.fromRunnable(() -> {
+			closedLocally = true;
 			isClosing = true;
 			logger.debug("Initiating graceful shutdown");
 
@@ -457,6 +515,7 @@ public Mono<Void> closeGracefully() {
 			catch (Exception e) {
 				logger.error("Error during graceful shutdown", e);
 			}
+			terminationSink.tryEmitEmpty();
 		});
 	}
 
@@ -493,6 +552,17 @@ private static void logExit(int exitCode) {
 		}
 	}
 
+	/**
+	 * Completes when the transport is closed; errors with an {@link AcpConnectionException}
+	 * naming the exit code (and, on POSIX systems, the signal) when the agent process ends
+	 * on its own, once its standard output has been read to the end.
+	 * @return a Mono that terminates when the transport does
+	 */
+	@Override
+	public Mono<Void> awaitTermination() {
+		return this.terminationSink.asMono();
+	}
+
 	public Sinks.Many<String> getErrorSink() {
 		return this.errorSink;
 	}
 
@@ -14,13 +14,18 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 
 import com.agentclientprotocol.sdk.QuietLoggers;
+import com.agentclientprotocol.sdk.json.TypeRef;
+import com.agentclientprotocol.sdk.spec.AcpClientSession;
 import com.agentclientprotocol.sdk.spec.AcpSchema;
 import com.agentclientprotocol.sdk.spec.AcpSchema.JSONRPCMessage;
 import com.agentclientprotocol.sdk.spec.AcpSchema.JSONRPCNotification;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.OS;
 import reactor.core.publisher.Mono;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -131,6 +136,65 @@ void awaitForExitReturnsWhenTheAgentExits() {
 		Mono.fromRunnable(transport::awaitForExit).block(TIMEOUT);
 	}
 
+	/**
+	 * The agent exits while a request is waiting: the request fails at once, naming the
+	 * exit code, instead of waiting out the request timeout; closing still works.
+	 */
+	@Test
+	void anAgentThatExitsMidRequestFailsThePendingRequestPromptly() {
+		transport = new StdioAcpClientTransport(echoAgent());
+		transport.setStdErrorHandler(line -> {
+		});
+		Duration requestTimeout = Duration.ofMinutes(5);
+		AcpClientSession session = new AcpClientSession(requestTimeout, transport, Map.of(), Map.of(),
+				Function.identity());
+
+		long start = System.nanoTime();
+		try (QuietLoggers quiet = QuietLoggers.of(StdioAcpClientTransport.class, AcpClientSession.class)) {
+			assertThatThrownBy(() -> session.sendRequest(EchoAgent.EXIT_3, Map.of(), new TypeRef<Map<String, Object>>() {
+			}).block(TIMEOUT)).hasMessageContaining("terminated")
+				.rootCause()
+				.hasMessageContaining("ACP agent process exited with code 3");
+		}
+		assertThat(Duration.ofNanos(System.nanoTime() - start)).isLessThan(Duration.ofSeconds(10));
+
+		session.closeGracefully().block(TIMEOUT);
+	}
+
+	/** An agent killed by a signal: the reason names the signal Java reports as 128 + n. */
+	@Test
+	@DisabledOnOs(OS.WINDOWS)
+	void terminationNamesTheSignalThatKilledTheAgent() {
+		transport = new StdioAcpClientTransport(echoAgent());
+		transport.setStdErrorHandler(line -> {
+		});
+		transport.connect(message -> message.then(Mono.empty())).block(TIMEOUT);
+
+		try (QuietLoggers quiet = QuietLoggers.of(StdioAcpClientTransport.class)) {
+			transport.sendMessage(new JSONRPCNotification(EchoAgent.KILL, null)).block(TIMEOUT);
+
+			assertThatThrownBy(() -> transport.awaitTermination().block(TIMEOUT))
+				.hasMessageContaining("ACP agent process exited with code 137 (signal 9)");
+		}
+	}
+
+	/** Closing the transport ends {@code awaitTermination} without an error. */
+	@Test
+	void closingTheTransportCompletesAwaitTermination() {
+		transport = new StdioAcpClientTransport(echoAgent());
+		transport.setStdErrorHandler(line -> {
+		});
+		transport.connect(message -> message.then(Mono.empty())).block(TIMEOUT);
+		Mono<Void> termination = transport.awaitTermination().cache();
+		termination.subscribe(v -> {
+		}, e -> {
+		});
+
+		transport.closeGracefully().block(TIMEOUT);
+
+		termination.block(TIMEOUT);
+	}
+
 	@Test
 	void anAgentThatCannotBeStartedFailsTheConnect() {
 		transport = new StdioAcpClientTransport(AgentParameters.builder("/nonexistent/acp-agent-binary").build());
@@ -147,6 +211,12 @@ public static final class EchoAgent {
 
 		static final String EXIT = "test/exit";
 
+		/** Exits with status 3 instead of echoing. */
+		static final String EXIT_3 = "test/exit3";
+
+		/** Kills itself with SIGKILL instead of echoing. */
+		static final String KILL = "test/kill";
+
 		/** Answered with a line that is not JSON instead of its echo. */
 		static final String MALFORMED = "test/malformed";
 
@@ -162,6 +232,15 @@ public static void main(String[] args) throws Exception {
 				if (line.contains("\"" + EXIT + "\"")) {
 					return;
 				}
+				if (line.contains("\"" + EXIT_3 + "\"")) {
+					System.exit(3);
+				}
+				if (line.contains("\"" + KILL + "\"")) {
+					// A process may not destroy itself through ProcessHandle; ask kill(1).
+					new ProcessBuilder("kill", "-KILL", Long.toString(ProcessHandle.current().pid())).start()
+						.waitFor();
+					Thread.sleep(Long.MAX_VALUE);
+				}
 				String echo = line.contains("\"" + MALFORMED + "\"") ? "{not json" : line;
 				System.out.write((echo + "\n").getBytes(StandardCharsets.UTF_8));
 				System.out.flush();