Fix: propagate per-run runtime failures

Read each completed a2a3 run's existing orchestration and scheduler
status latch after its event fence. A nonzero status now enters the same
runner recovery, validation logging, and force-reset path that stream sync
previously triggered, without waiting for a queued successor.

Author: Crane-Liu

src/a2a3/platform/onboard/host/device_runner.cpp

@@ -632,11 +632,6 @@ int DeviceRunner::wait_run_completion_events(const PreparedExecution &prepared)
             return static_cast<int>(rc);
         }
     }
-    // Event completion does not propagate a failed predecessor task. A stream
-    // query preserves that sticky error while NOT_READY remains valid when a
-    // healthy successor is queued after this run's event.
-    const int stream_status = query_stream_pair_nonblocking(run_streams_.aicpu(), run_streams_.aicore());
-    if (stream_status == SIMPLER_NATIVE_RUN_POLL_ERROR) return PTO_RUNTIME_ERR_INTERNAL;
     return 0;
 }
 

src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp

@@ -275,6 +275,11 @@ static int32_t read_runtime_status(Runtime *runtime, const HostApi *api, SharedM
     return runtime_status_from_error_codes(orch_error_code, sched_error_code);
 }
 
+extern "C" int completed_runtime_status_impl(Runtime *runtime, const HostApi *api) {
+    SharedMemoryHeader host_header{};
+    return read_runtime_status(runtime, api, &host_header);
+}
+
 namespace {
 
 // host_build_graph is host-orchestration-first: the HOST dlopens the

src/a2a3/runtime/tensormap_and_ringbuffer/host/runtime_maker.cpp

@@ -221,6 +221,11 @@ static int32_t read_runtime_status(Runtime *runtime, const HostApi *api, SharedM
     return runtime_status_from_error_codes(orch_error_code, sched_error_code);
 }
 
+extern "C" int completed_runtime_status_impl(Runtime *runtime, const HostApi *api) {
+    SharedMemoryHeader host_header{};
+    return read_runtime_status(runtime, api, &host_header);
+}
+
 static void release_tensor_leases(Runtime *runtime, const HostApi *api) {
     int freed = 0;
     int buffer_noop = 0;

src/common/platform/onboard/host/c_api_shared.cpp

@@ -66,6 +66,7 @@ extern "C" {
  * =========================================================================== */
 int register_callable_impl(const ChipCallable *callable, const HostApi *api, CallableArtifacts *out);
 int validate_runtime_impl(Runtime *runtime, const HostApi *api, int execution_rc);
+__attribute__((weak)) int completed_runtime_status_impl(Runtime * /*runtime*/, const HostApi * /*api*/) { return 0; }
 __attribute__((weak)) int concurrent_native_prepare_supported_impl(void) { return 0; }
 __attribute__((weak)) int prepared_run_config_compatible_impl(
     const HostApi * /*api*/, const uint64_t * /*ring_task_window*/, const uint64_t * /*ring_heap*/,
@@ -643,6 +644,14 @@ static void emit_native_run_runner_wall(OnboardNativeRunContext *state) {
     state->runner_trace_start_ns = 0;
 }
 
+static int completed_execution_rc(OnboardNativeRunContext *state, int drain_rc) {
+    if (drain_rc != 0) return drain_rc;
+    const int runtime_status = completed_runtime_status_impl(&state->runtime, &state->host_api);
+    if (runtime_status == 0) return 0;
+    state->runner->recover_device_or_mark_unusable(runtime_status);
+    return runtime_status;
+}
+
 int supports_concurrent_native_prepare_ctx(DeviceContextHandle ctx) {
     return ctx != nullptr && concurrent_native_prepare_supported_impl() != 0 ? 1 : 0;
 }
@@ -937,6 +946,7 @@ int simpler_wait_run(DeviceContextHandle ctx, RuntimeHandle runtime) {
         drain_rc = PTO_RUNTIME_ERR_INTERNAL;
         LOG_ERROR("simpler_wait_run: drain threw (%s)", state->trace_attrs);
     }
+    drain_rc = completed_execution_rc(state, drain_rc);
     if (state->completion_rc == 0) state->completion_rc = drain_rc;
     state->phase.store(NativeRunPhase::Complete, std::memory_order_release);
     emit_native_run_runner_wall(state);
@@ -985,6 +995,7 @@ int simpler_finalize_run(DeviceContextHandle ctx, RuntimeHandle runtime) {
                 LOG_ERROR("simpler_finalize_run: drain_execution threw (%s)", state->trace_attrs);
             }
         }
+        drain_rc = completed_execution_rc(state, drain_rc);
         if (execution_rc == 0) execution_rc = drain_rc;
         state->completion_rc = execution_rc;
         state->phase.store(NativeRunPhase::Complete, std::memory_order_release);