@temporalio/core-bridge 1.8.4 → 1.8.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
   "types": "lib/index.d.ts",
@@ -23,7 +23,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.4.1",
-    "@temporalio/common": "1.8.4",
+    "@temporalio/common": "1.8.6",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
@@ -53,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7e65cf816b1deef72973dc64ccbf2c93916a3eb1"
+  "gitHead": "1e95cf92ec5e6efffb7aedb064ea46be05df0c14"
 }

package/sdk-core/core/src/core_tests/local_activities.rs

@@ -3,7 +3,7 @@ use crate::{
     replay::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE},
     test_help::{
         hist_to_poll_resp, mock_sdk, mock_sdk_cfg, mock_worker, single_hist_mock_sg, MockPollCfg,
-        ResponseType,
+        ResponseType, WorkerExt,
     },
     worker::{client::mocks::mock_workflow_client, LEGACY_QUERY_ID},
 };
@@ -32,9 +32,7 @@ use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::ActivityExecutionResult,
         workflow_activation::{workflow_activation_job, WorkflowActivationJob},
-        workflow_commands::{
-            ActivityCancellationType, QueryResult, QuerySuccess, ScheduleLocalActivity,
-        },
+        workflow_commands::{ActivityCancellationType, ScheduleLocalActivity},
         workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion, AsJsonPayloadExt,
     },
@@ -47,7 +45,7 @@ use temporal_sdk_core_protos::{
     DEFAULT_ACTIVITY_TYPE,
 };
 use temporal_sdk_core_test_utils::{
-    schedule_local_activity_cmd, start_timer_cmd, WorkerTestHelpers,
+    query_ok, schedule_local_activity_cmd, start_timer_cmd, WorkerTestHelpers,
 };
 use tokio::{join, select, sync::Barrier};
 
@@ -527,16 +525,7 @@ async fn query_during_wft_heartbeat_doesnt_accidentally_fail_to_continue_heartbe
         barrier.wait().await;
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             task.run_id,
-            QueryResult {
-                query_id: query.query_id.clone(),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some("whatever".into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
+            query_ok(&query.query_id, "whatev"),
         ))
         .await
         .unwrap();
@@ -582,10 +571,8 @@ async fn la_resolve_during_legacy_query_does_not_combine(#[case] impossible_quer
     t.add_timer_fired(timer_started_event_id, "1".to_string());
 
     // nonlegacy query got here & LA started here
+    // then next task is incremental w/ legacy query (for impossible query case)
     t.add_full_wf_task();
-    // legacy query got here, at the same time that the LA is resolved
-    t.add_local_activity_result_marker(1, "1", "whatever".into());
-    t.add_workflow_execution_completed();
 
     let barr = Arc::new(Barrier::new(2));
     let barr_c = barr.clone();
@@ -612,9 +599,6 @@ async fn la_resolve_during_legacy_query_does_not_combine(#[case] impossible_quer
                 ResponseType::UntilResolved(
                     async move {
                         barr_c.wait().await;
-                        // This sleep is the only not-incredibly-invasive way to ensure the LA
-                        // resolves & updates machines before we process this task
-                        tokio::time::sleep(Duration::from_secs(1)).await;
                     }
                     .boxed(),
                     2,
@@ -662,42 +646,26 @@ async fn la_resolve_during_legacy_query_does_not_combine(#[case] impossible_quer
         ))
         .await
         .unwrap();
+
         let task = core.poll_workflow_activation().await.unwrap();
         assert_matches!(
             task.jobs.as_slice(),
-            &[
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-                },
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(_)),
-                }
-            ]
+            &[WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::FireTimer(_)),
+            },]
         );
-        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             task.run_id,
-            vec![
-                schedule_local_activity_cmd(
-                    1,
-                    "act-id",
-                    ActivityCancellationType::TryCancel,
-                    Duration::from_secs(60),
-                ),
-                QueryResult {
-                    query_id: "q1".to_string(),
-                    variant: Some(
-                        QuerySuccess {
-                            response: Some("whatev".into()),
-                        }
-                        .into(),
-                    ),
-                }
-                .into(),
-            ],
+            schedule_local_activity_cmd(
+                1,
+                "act-id",
+                ActivityCancellationType::TryCancel,
+                Duration::from_secs(60),
+            ),
         ))
         .await
         .unwrap();
-        barr.wait().await;
+
         let task = core.poll_workflow_activation().await.unwrap();
         // The next task needs to be resolve, since the LA is completed immediately
         assert_matches!(
@@ -708,21 +676,30 @@ async fn la_resolve_during_legacy_query_does_not_combine(#[case] impossible_quer
         );
         // Complete workflow
         core.complete_execution(&task.run_id).await;
+
+        // Now we will get the query
+        let task = core.poll_workflow_activation().await.unwrap();
+        assert_matches!(
+            task.jobs.as_slice(),
+            &[WorkflowActivationJob {
+                variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)),
+            }]
+            if q.query_id == "q1"
+        );
+        core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+            task.run_id,
+            query_ok("q1", "whatev"),
+        ))
+        .await
+        .unwrap();
+        barr.wait().await;
+
         if impossible_query_in_task {
             // finish last query
             let task = core.poll_workflow_activation().await.unwrap();
-            core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+            core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
                 task.run_id,
-                vec![QueryResult {
-                    query_id: LEGACY_QUERY_ID.to_string(),
-                    variant: Some(
-                        QuerySuccess {
-                            response: Some("whatev".into()),
-                        }
-                        .into(),
-                    ),
-                }
-                .into()],
+                query_ok(LEGACY_QUERY_ID, "whatev"),
             ))
             .await
             .unwrap();
@@ -738,8 +715,8 @@ async fn la_resolve_during_legacy_query_does_not_combine(#[case] impossible_quer
         .unwrap();
     };
 
-    tokio::join!(wf_fut, act_fut);
-    core.shutdown().await;
+    join!(wf_fut, act_fut);
+    core.drain_pollers_and_shutdown().await;
 }
 
 #[tokio::test]
@@ -1215,3 +1192,106 @@ async fn local_activities_can_be_delivered_during_shutdown() {
     assert_matches!(wf_r.unwrap_err(), PollWfError::ShutDown);
     assert_matches!(act_r.unwrap_err(), PollActivityError::ShutDown);
 }
+
+#[tokio::test]
+async fn queries_can_be_received_while_heartbeating() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_wfe_started_with_wft_timeout(Duration::from_millis(200));
+    t.add_full_wf_task();
+    t.add_full_wf_task();
+    t.add_full_wf_task();
+
+    let tasks = [
+        hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::ToTaskNum(1)),
+        {
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::OneTask(2));
+            pr.queries = HashMap::new();
+            pr.queries.insert(
+                "q1".to_string(),
+                WorkflowQuery {
+                    query_type: "query-type".to_string(),
+                    query_args: Some(b"hi".into()),
+                    header: None,
+                },
+            );
+            pr
+        },
+        {
+            let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::OneTask(3));
+            pr.query = Some(WorkflowQuery {
+                query_type: "query-type".to_string(),
+                query_args: Some(b"hi".into()),
+                header: None,
+            });
+            pr
+        },
+    ];
+    let mut mock = mock_workflow_client();
+    mock.expect_respond_legacy_query()
+        .times(1)
+        .returning(move |_, _| Ok(Default::default()));
+    let mut mock = single_hist_mock_sg(wfid, t, tasks, mock, true);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 1);
+    let core = mock_worker(mock);
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        &[WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::StartWorkflow(_)),
+        },]
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        schedule_local_activity_cmd(
+            1,
+            "act-id",
+            ActivityCancellationType::TryCancel,
+            Duration::from_secs(60),
+        ),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        &[WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)),
+        }]
+        if q.query_id == "q1"
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        query_ok("q1", "whatev"),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        &[WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)),
+        }]
+        if q.query_id == LEGACY_QUERY_ID
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        query_ok(LEGACY_QUERY_ID, "whatev"),
+    ))
+    .await
+    .unwrap();
+
+    // Handle the activity so we can shut down cleanly
+    let act_task = core.poll_activity_task().await.unwrap();
+    core.complete_activity_task(ActivityTaskCompletion {
+        task_token: act_task.task_token,
+        result: Some(ActivityExecutionResult::ok(vec![1].into())),
+    })
+    .await
+    .unwrap();
+
+    core.drain_pollers_and_shutdown().await;
+}

package/sdk-core/core/src/core_tests/queries.rs

@@ -17,7 +17,7 @@ use temporal_sdk_core_protos::{
         },
         workflow_commands::{
             query_result, ActivityCancellationType, CompleteWorkflowExecution,
-            ContinueAsNewWorkflowExecution, QueryResult, QuerySuccess, RequestCancelActivity,
+            ContinueAsNewWorkflowExecution, QueryResult, RequestCancelActivity,
         },
         workflow_completion::WorkflowActivationCompletion,
     },
@@ -33,7 +33,9 @@ use temporal_sdk_core_protos::{
     },
     TestHistoryBuilder,
 };
-use temporal_sdk_core_test_utils::{schedule_activity_cmd, start_timer_cmd, WorkerTestHelpers};
+use temporal_sdk_core_test_utils::{
+    query_ok, schedule_activity_cmd, start_timer_cmd, WorkerTestHelpers,
+};
 
 #[rstest::rstest]
 #[case::with_history(true)]
@@ -111,16 +113,7 @@ async fn legacy_query(#[case] include_history: bool) {
     worker
         .complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             task.run_id,
-            QueryResult {
-                query_id: query.query_id.clone(),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some(query_resp.into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
+            query_ok(&query.query_id, query_resp),
         ))
         .await
         .unwrap();
@@ -149,10 +142,7 @@ async fn legacy_query(#[case] include_history: bool) {
 
 #[rstest::rstest]
 #[tokio::test]
-async fn new_queries(
-    #[values(1, 3)] num_queries: usize,
-    #[values(false, true)] query_results_after_complete: bool,
-) {
+async fn new_queries(#[values(1, 3)] num_queries: usize) {
     let wfid = "fake_wf_id";
     let query_resp = "response";
     let t = canned_histories::single_timer("1");
@@ -200,12 +190,20 @@ async fn new_queries(
 
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
-        task.jobs[0],
-        WorkflowActivationJob {
+        task.jobs.as_slice(),
+        &[WorkflowActivationJob {
             variant: Some(workflow_activation_job::Variant::FireTimer(_)),
-        }
+        }]
     );
-    for i in 1..=num_queries {
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        CompleteWorkflowExecution { result: None }.into(),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    for i in 0..num_queries {
         assert_matches!(
             task.jobs[i],
             WorkflowActivationJob {
@@ -217,25 +215,8 @@ async fn new_queries(
     }
 
     let mut commands = vec![];
-    if query_results_after_complete {
-        commands.push(CompleteWorkflowExecution { result: None }.into());
-    }
     for i in 1..=num_queries {
-        commands.push(
-            QueryResult {
-                query_id: format!("q{i}"),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some(query_resp.into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
-        );
-    }
-    if !query_results_after_complete {
-        commands.push(CompleteWorkflowExecution { result: None }.into());
+        commands.push(query_ok(format!("q{i}"), query_resp));
     }
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -411,16 +392,7 @@ async fn legacy_query_after_complete(#[values(false, true)] full_history: bool)
         );
         core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
             task.run_id,
-            QueryResult {
-                query_id: query.query_id.clone(),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some("whatever".into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
+            query_ok(query.query_id.clone(), "whatever"),
         ))
         .await
         .unwrap();
@@ -534,16 +506,7 @@ async fn query_cache_miss_causes_page_fetch_dont_reply_wft_too_early(
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         task.run_id,
-        QueryResult {
-            query_id: "the-query".to_string(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some(query_resp.into()),
-                }
-                .into(),
-            ),
-        }
-        .into(),
+        query_ok("the-query".to_string(), query_resp),
     ))
     .await
     .unwrap();
@@ -632,16 +595,7 @@ async fn query_replay_with_continue_as_new_doesnt_reply_empty_command() {
 
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         task.run_id,
-        QueryResult {
-            query_id: query.query_id.clone(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some("whatever".into()),
-                }
-                .into(),
-            ),
-        }
-        .into(),
+        query_ok(query.query_id.clone(), "whatever"),
     ))
     .await
     .unwrap();
@@ -690,16 +644,7 @@ async fn legacy_query_response_gets_not_found_not_fatal() {
     // Fail wft which should result in query being failed
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         task.run_id,
-        QueryResult {
-            query_id: LEGACY_QUERY_ID.to_string(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some("hi".into()),
-                }
-                .into(),
-            ),
-        }
-        .into(),
+        query_ok(LEGACY_QUERY_ID.to_string(), "hi"),
     ))
     .await
     .unwrap();
@@ -856,21 +801,9 @@ async fn legacy_query_combined_with_timer_fire_repro() {
     .unwrap();
 
     let task = core.poll_workflow_activation().await.unwrap();
-    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         task.run_id,
-        vec![
-            RequestCancelActivity { seq: 1 }.into(),
-            QueryResult {
-                query_id: "the-query".to_string(),
-                variant: Some(
-                    QuerySuccess {
-                        response: Some("whatever".into()),
-                    }
-                    .into(),
-                ),
-            }
-            .into(),
-        ],
+        RequestCancelActivity { seq: 1 }.into(),
     ))
     .await
     .unwrap();
@@ -885,26 +818,33 @@ async fn legacy_query_combined_with_timer_fire_repro() {
     );
     core.complete_execution(&task.run_id).await;
 
-    // Then the query
+    // Then the queries
     let task = core.poll_workflow_activation().await.unwrap();
     assert_matches!(
         task.jobs.as_slice(),
         [WorkflowActivationJob {
-            variant: Some(workflow_activation_job::Variant::QueryWorkflow(_)),
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)),
         }]
+        if q.query_id == "the-query"
     );
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         task.run_id,
-        QueryResult {
-            query_id: LEGACY_QUERY_ID.to_string(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some("whatever".into()),
-                }
-                .into(),
-            ),
-        }
-        .into(),
+        query_ok("the-query".to_string(), "whatever"),
+    ))
+    .await
+    .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(ref q)),
+        }]
+        if q.query_id == LEGACY_QUERY_ID
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        query_ok(LEGACY_QUERY_ID.to_string(), "whatever"),
     ))
     .await
     .unwrap();

package/sdk-core/core/src/core_tests/replay_flag.rs

@@ -1,6 +1,7 @@
 use crate::{
     test_help::{
         build_mock_pollers, canned_histories, hist_to_poll_resp, mock_worker, MockPollCfg,
+        ResponseType,
     },
     worker::{client::mocks::mock_workflow_client, ManagedWFFunc, LEGACY_QUERY_ID},
 };
@@ -10,12 +11,16 @@ use temporal_sdk::{WfContext, WorkflowFunction};
 use temporal_sdk_core_api::Worker;
 use temporal_sdk_core_protos::{
     coresdk::{
-        workflow_commands::{workflow_command::Variant::RespondToQuery, QueryResult, QuerySuccess},
+        workflow_activation::{workflow_activation_job, WorkflowActivationJob},
         workflow_completion::WorkflowActivationCompletion,
     },
-    temporal::api::{enums::v1::CommandType, query::v1::WorkflowQuery},
+    temporal::api::{
+        enums::v1::{CommandType, EventType},
+        query::v1::WorkflowQuery,
+    },
+    TestHistoryBuilder,
 };
-use temporal_sdk_core_test_utils::start_timer_cmd;
+use temporal_sdk_core_test_utils::{query_ok, start_timer_cmd};
 
 fn timers_wf(num_timers: u32) -> WorkflowFunction {
     WorkflowFunction::new(move |command_sink: WfContext| async move {
@@ -117,15 +122,7 @@ async fn replay_flag_correct_with_query() {
     assert!(task.is_replaying);
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
         task.run_id,
-        RespondToQuery(QueryResult {
-            query_id: LEGACY_QUERY_ID.to_string(),
-            variant: Some(
-                QuerySuccess {
-                    response: Some("hi".into()),
-                }
-                .into(),
-            ),
-        }),
+        query_ok(LEGACY_QUERY_ID, "hi"),
     ))
     .await
     .unwrap();
@@ -133,3 +130,60 @@ async fn replay_flag_correct_with_query() {
     let task = core.poll_workflow_activation().await.unwrap();
     assert!(!task.is_replaying);
 }
+
+#[tokio::test]
+async fn replay_flag_correct_signal_before_query_ending_on_wft_completed() {
+    let wfid = "fake_wf_id";
+    let mut t = TestHistoryBuilder::default();
+    t.add_by_type(EventType::WorkflowExecutionStarted);
+    t.add_full_wf_task();
+    t.add_we_signaled("signal", vec![]);
+    t.add_full_wf_task();
+    let task = {
+        let mut pr = hist_to_poll_resp(&t, wfid.to_owned(), ResponseType::AllHistory);
+        pr.query = Some(WorkflowQuery {
+            query_type: "query-type".to_string(),
+            query_args: Some(b"hi".into()),
+            header: None,
+        });
+        pr
+    };
+
+    let mut mock = MockPollCfg::from_resp_batches(wfid, t, [task], mock_workflow_client());
+    mock.num_expected_legacy_query_resps = 1;
+    let mut mock = build_mock_pollers(mock);
+    mock.worker_cfg(|wc| wc.max_cached_workflows = 10);
+    let core = mock_worker(mock);
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+        .await
+        .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert!(task.is_replaying);
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
+        }]
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::empty(task.run_id))
+        .await
+        .unwrap();
+
+    let task = core.poll_workflow_activation().await.unwrap();
+    assert!(task.is_replaying);
+    assert_matches!(
+        task.jobs.as_slice(),
+        [WorkflowActivationJob {
+            variant: Some(workflow_activation_job::Variant::QueryWorkflow(_)),
+        }]
+    );
+    core.complete_workflow_activation(WorkflowActivationCompletion::from_cmd(
+        task.run_id,
+        query_ok(LEGACY_QUERY_ID, "hi"),
+    ))
+    .await
+    .unwrap();
+}

package/sdk-core/core/src/worker/workflow/machines/workflow_machines.rs

@@ -520,6 +520,7 @@ impl WorkflowMachines {
             // them.
             if self.replaying
                 && has_final_event
+                && event.event_id > self.last_history_from_server.previous_wft_started_id
                 && event.event_type() != EventType::WorkflowTaskCompleted
                 && !event.is_command_event()
             {

package/sdk-core/core/src/worker/workflow/managed_run.rs

@@ -148,7 +148,7 @@ impl ManagedRun {
     /// Called whenever a new workflow task is obtained for this run
     pub(super) fn incoming_wft(&mut self, pwft: PermittedWFT) -> RunUpdateAct {
         let res = self._incoming_wft(pwft);
-        self.update_to_acts(res.map(Into::into), true)
+        self.update_to_acts(res.map(Into::into))
     }
 
     fn _incoming_wft(
@@ -161,7 +161,6 @@ impl ManagedRun {
         let start_time = Instant::now();
 
         let work = pwft.work;
-        let did_miss_cache = !work.is_incremental() || !work.update.is_real();
         debug!(
             run_id = %work.execution.run_id,
             task_token = %&work.task_token,
@@ -200,7 +199,6 @@ impl ManagedRun {
         self.paginator = Some(pwft.paginator);
         self.wft = Some(OutstandingTask {
             info: wft_info,
-            hit_cache: !did_miss_cache,
             pending_queries,
             start_time,
             permit: pwft.permit,
@@ -284,7 +282,7 @@ impl ManagedRun {
     /// Checks if any further activations need to go out for this run and produces them if so.
     pub(super) fn check_more_activations(&mut self) -> RunUpdateAct {
         let res = self._check_more_activations();
-        self.update_to_acts(res.map(Into::into), false)
+        self.update_to_acts(res.map(Into::into))
     }
 
     fn _check_more_activations(&mut self) -> Result<Option<ActivationOrAuto>, RunUpdateErr> {
@@ -445,17 +443,14 @@ impl ManagedRun {
                         span: Span::current(),
                     })
                 } else {
-                    Ok(self.update_to_acts(
-                        Err(RunUpdateErr {
-                            source: WFMachinesError::Fatal(
-                                "Run's paginator was absent when attempting to fetch next history \
+                    Ok(self.update_to_acts(Err(RunUpdateErr {
+                        source: WFMachinesError::Fatal(
+                            "Run's paginator was absent when attempting to fetch next history \
                                 page. This is a Core SDK bug."
-                                    .to_string(),
-                            ),
-                            complete_resp_chan: rac.resp_chan,
-                        }),
-                        false,
-                    ))
+                                .to_string(),
+                        ),
+                        complete_resp_chan: rac.resp_chan,
+                    })))
                 };
             }
 
@@ -473,7 +468,7 @@ impl ManagedRun {
         paginator: HistoryPaginator,
     ) -> RunUpdateAct {
         let res = self._fetched_page_completion(update, paginator);
-        self.update_to_acts(res.map(Into::into), false)
+        self.update_to_acts(res.map(Into::into))
     }
     fn _fetched_page_completion(
         &mut self,
@@ -564,12 +559,12 @@ impl ManagedRun {
     /// Called when local activities resolve
     pub(super) fn local_resolution(&mut self, res: LocalResolution) -> RunUpdateAct {
         let res = self._local_resolution(res);
-        self.update_to_acts(res.map(Into::into), false)
+        self.update_to_acts(res.map(Into::into))
     }
 
     fn process_completion(&mut self, completion: RunActivationCompletion) -> RunUpdateAct {
         let res = self._process_completion(completion, None);
-        self.update_to_acts(res.map(Into::into), false)
+        self.update_to_acts(res.map(Into::into))
     }
 
     fn _process_completion(
@@ -688,7 +683,7 @@ impl ManagedRun {
         } else {
             None
         };
-        self.update_to_acts(Ok(maybe_act).map(Into::into), false)
+        self.update_to_acts(Ok(maybe_act).map(Into::into))
     }
     /// Returns `true` if autocompletion should be issued, which will actually cause us to end up
     /// in [completion] again, at which point we'll start a new heartbeat timeout, which will
@@ -812,11 +807,7 @@ impl ManagedRun {
 
     /// Take the result of some update to ourselves and turn it into a return value of zero or more
     /// actions
-    fn update_to_acts(
-        &mut self,
-        outcome: Result<ActOrFulfill, RunUpdateErr>,
-        in_response_to_wft: bool,
-    ) -> RunUpdateAct {
+    fn update_to_acts(&mut self, outcome: Result<ActOrFulfill, RunUpdateErr>) -> RunUpdateAct {
         match outcome {
             Ok(act_or_fulfill) => {
                 let (mut maybe_act, maybe_fulfill) = match act_or_fulfill {
@@ -828,25 +819,12 @@ impl ManagedRun {
                     match self._check_more_activations() {
                         Ok(oa) => maybe_act = oa,
                         Err(e) => {
-                            return self.update_to_acts(Err(e), in_response_to_wft);
+                            return self.update_to_acts(Err(e));
                         }
                     }
                 }
                 let r = match maybe_act {
-                    Some(ActivationOrAuto::LangActivation(mut activation)) => {
-                        if in_response_to_wft {
-                            let wft = self
-                                .wft
-                                .as_mut()
-                                .expect("WFT must exist for run just updated with one");
-                            // If there are in-poll queries, insert jobs for those queries into the
-                            // activation, but only if we hit the cache. If we didn't, those queries
-                            // will need to be dealt with once replay is over
-                            if wft.hit_cache {
-                                put_queries_in_act(&mut activation, wft);
-                            }
-                        }
-
+                    Some(ActivationOrAuto::LangActivation(activation)) => {
                         if activation.jobs.is_empty() {
                             dbg_panic!("Should not send lang activation with no jobs");
                         }

package/sdk-core/core/src/worker/workflow/mod.rs

@@ -270,7 +270,7 @@ impl Workflows {
             match al {
                 ActivationOrAuto::LangActivation(mut act)
                 | ActivationOrAuto::ReadyForQueries(mut act) => {
-                    sort_act_jobs(&mut act);
+                    prepare_to_ship_activation(&mut act);
                     debug!(activation=%act, "Sending activation to lang");
                     break Ok(act);
                 }
@@ -527,7 +527,10 @@ impl Workflows {
                     r
                 })
             );
-            jh_res?.map_err(|e| anyhow!("Error joining workflow processing thread: {e:?}"))?;
+            jh_res?.map_err(|e| {
+                let as_str = e.downcast::<&str>();
+                anyhow!("Error joining workflow processing thread: {as_str:?}")
+            })?;
         }
         Ok(())
     }
@@ -795,7 +798,6 @@ impl PreparedWFT {
 #[derive(Debug)]
 pub(crate) struct OutstandingTask {
     pub info: WorkflowTaskInfo,
-    pub hit_cache: bool,
     /// Set if the outstanding task has quer(ies) which must be fulfilled upon finishing replay
     pub pending_queries: Vec<QueryWorkflow>,
     pub start_time: Instant,
@@ -1334,9 +1336,33 @@ impl LocalActivityRequestSink for LAReqSink {
     }
 }
 
-/// Sorts jobs in an activation to be in the order lang expects:
-/// `patches -> signals -> other -> queries`
-fn sort_act_jobs(wfa: &mut WorkflowActivation) {
+/// Sorts jobs in an activation to be in the order lang expects, and confirms any invariants
+/// activations must uphold.
+///
+/// ## Ordering
+/// `patches -> signals -> other -X-> queries`
+///
+/// ## Invariants:
+/// * Queries always go in their own activation
+fn prepare_to_ship_activation(wfa: &mut WorkflowActivation) {
+    let any_job_is_query = wfa.jobs.iter().any(|j| {
+        matches!(
+            j.variant,
+            Some(workflow_activation_job::Variant::QueryWorkflow(_))
+        )
+    });
+    let all_jobs_are_query = wfa.jobs.iter().all(|j| {
+        matches!(
+            j.variant,
+            Some(workflow_activation_job::Variant::QueryWorkflow(_))
+        )
+    });
+    if any_job_is_query && !all_jobs_are_query {
+        dbg_panic!(
+            "About to issue an activation that contains query jobs with non-query jobs: {:?}",
+            &wfa
+        );
+    }
     wfa.jobs.sort_by(|j1, j2| {
         // Unwrapping is fine here since we'll never issue empty variants
         let j1v = j1.variant.as_ref().unwrap();
@@ -1348,6 +1374,9 @@ fn sort_act_jobs(wfa: &mut WorkflowActivation) {
             match v {
                 workflow_activation_job::Variant::NotifyHasPatch(_) => 1,
                 workflow_activation_job::Variant::SignalWorkflow(_) => 2,
+                // In principle we should never actually need to sort these with the others, since
+                // queries always get their own activation, but, maintaining the semantic is
+                // reasonable.
                 workflow_activation_job::Variant::QueryWorkflow(_) => 4,
                 _ => 3,
             }
@@ -1375,11 +1404,6 @@ mod tests {
                         Default::default(),
                     )),
                 },
-                WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(
-                        Default::default(),
-                    )),
-                },
                 WorkflowActivationJob {
                     variant: Some(workflow_activation_job::Variant::FireTimer(
                         Default::default(),
@@ -1393,7 +1417,7 @@ mod tests {
             ],
             ..Default::default()
         };
-        sort_act_jobs(&mut act);
+        prepare_to_ship_activation(&mut act);
         let variants = act
             .jobs
             .into_iter()
@@ -1406,8 +1430,28 @@ mod tests {
                 workflow_activation_job::Variant::SignalWorkflow(_),
                 workflow_activation_job::Variant::FireTimer(_),
                 workflow_activation_job::Variant::ResolveActivity(_),
-                workflow_activation_job::Variant::QueryWorkflow(_)
             ]
         )
     }
+
+    #[test]
+    #[should_panic]
+    fn queries_cannot_go_with_other_jobs() {
+        let mut act = WorkflowActivation {
+            jobs: vec![
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(
+                        Default::default(),
+                    )),
+                },
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::QueryWorkflow(
+                        Default::default(),
+                    )),
+                },
+            ],
+            ..Default::default()
+        };
+        prepare_to_ship_activation(&mut act);
+    }
 }

package/sdk-core/test-utils/src/lib.rs

@@ -46,8 +46,8 @@ use temporal_sdk_core_api::{
 use temporal_sdk_core_protos::{
     coresdk::{
         workflow_commands::{
-            workflow_command, ActivityCancellationType, CompleteWorkflowExecution,
-            ScheduleActivity, ScheduleLocalActivity, StartTimer,
+            workflow_command, ActivityCancellationType, CompleteWorkflowExecution, QueryResult,
+            QuerySuccess, ScheduleActivity, ScheduleLocalActivity, StartTimer,
         },
         workflow_completion::WorkflowActivationCompletion,
     },
@@ -669,6 +669,19 @@ pub fn start_timer_cmd(seq: u32, duration: Duration) -> workflow_command::Varian
     .into()
 }
 
+pub fn query_ok(id: impl Into<String>, response: impl Into<Payload>) -> workflow_command::Variant {
+    QueryResult {
+        query_id: id.into(),
+        variant: Some(
+            QuerySuccess {
+                response: Some(response.into()),
+            }
+            .into(),
+        ),
+    }
+    .into()
+}
+
 /// Given a desired number of concurrent executions and a provided function that produces a future,
 /// run that many instances of the future concurrently.
 ///

package/sdk-core/tests/integ_tests/workflow_tests/local_activities.rs

@@ -22,8 +22,7 @@ use temporal_sdk_core_protos::{
     TestHistoryBuilder,
 };
 use temporal_sdk_core_test_utils::{
-    history_from_proto_binary, init_integ_telem, replay_sdk_worker, workflows::la_problem_workflow,
-    CoreWfStarter,
+    history_from_proto_binary, replay_sdk_worker, workflows::la_problem_workflow, CoreWfStarter,
 };
 use tokio_util::sync::CancellationToken;
 
@@ -589,7 +588,6 @@ async fn repro_nondeterminism_with_timer_bug() {
 #[rstest::rstest]
 #[tokio::test]
 async fn weird_la_nondeterminism_repro(#[values(true, false)] fix_hist: bool) {
-    init_integ_telem();
     let mut hist = history_from_proto_binary(
         "histories/evict_while_la_running_no_interference-85_history.bin",
     )
@@ -618,7 +616,6 @@ async fn weird_la_nondeterminism_repro(#[values(true, false)] fix_hist: bool) {
 
 #[tokio::test]
 async fn second_weird_la_nondeterminism_repro() {
-    init_integ_telem();
     let mut hist = history_from_proto_binary(
         "histories/evict_while_la_running_no_interference-23_history.bin",
     )
@@ -644,7 +641,6 @@ async fn second_weird_la_nondeterminism_repro() {
 
 #[tokio::test]
 async fn third_weird_la_nondeterminism_repro() {
-    init_integ_telem();
     let mut hist = history_from_proto_binary(
         "histories/evict_while_la_running_no_interference-16_history.bin",
     )