plan-06: turn 生命周期收敛 — 取消传播 + 后台任务收割 + 出站配额 (#503)

* feat(runtime): add current turn context to AppState

* feat(daemon): bound turn interaction waits behind TurnScope

* feat(runtime): owner-aware background task registry with real stop

* feat(runtime): owned, stoppable background agents and shells

* feat(daemon): single finish_turn path with scoped child harvest

Interaction-timeout smoke coverage shipped as the late-resolve-rejection
variant (daemon_rejects_resolve_after_turn_finished) plus the Task 2 TurnScope
unit tests, per the plan's fallback; the mock SSE stream was not extended to
emit AskUserQuestion tool_use.

* feat(runtime): per-turn outbound budget and turn-id origin stamping

* fix(desktop): remove double-layer resolver no-ops and silent frontend fallback

Rust corbina suite green (112 passed incl. REGISTERED_TAURI_COMMANDS meta-test).
Playwright E2E not run here (needs a built frontend + browsers); the change is
behavior-preserving for the fake-daemon tests, which already exercised the
error-propagation path since canInvokeTauri() is false in the browser context.

* refactor(runtime): drop redundant cancel and dead BackgroundTaskManager::stop

finish_turn shared the turn's CancelToken with its TurnScope, and
TurnScope::finish already flips the token for every non-Complete reason,
so the explicit handle.cancel.cancel() in finish_turn was dead
duplication — removed, with cancellation ownership documented on scope.

BackgroundTaskManager::stop had no production callers: real stops route
through request_stop / stop_scoped_by_turn -> stop_one (which cancels the
token and kills the process). The bare stop only flipped status, orphaning
the worker/process — a footgun the owner-aware system replaced. Removed it
and reworked the two unit tests that relied on it to exercise the real
convergence paths (request_stop + complete -> Stopped; complete frees a slot).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Milhouszhang

apps/puffer-desktop/src-tauri/src/backend.rs

@@ -294,7 +294,9 @@ impl BackendState {
             | "workflow_runs_list"
             | "workflow_run_show" => workflow_runtime_unavailable(method),
             "run_agent_turn" => self.run_agent_turn(events.clone(), params),
-            "resolve_permission" | "resolve_user_question" => Ok(json!({})),
+            "resolve_permission" | "resolve_user_question" => anyhow::bail!(
+                "{method} requires the daemon turn lifecycle; the in-process backend does not host interactive turns"
+            ),
             "cancel_turn" => {
                 let turn_id = string_param(&params, &["turnId", "turn_id"])?;
                 if let Some(flag) = self.turns.lock().unwrap().get(&turn_id) {
@@ -2323,6 +2325,22 @@ mod tests {
 
     static TEST_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
 
+    #[test]
+    fn resolver_methods_error_instead_of_noop_success() {
+        let backend = BackendState::new();
+        for method in ["resolve_permission", "resolve_user_question"] {
+            let result = backend.handle(
+                EventEmitter::websocket_only(),
+                method,
+                serde_json::json!({
+                    "turnId": "missing-turn",
+                    "requestId": "missing-request"
+                }),
+            );
+            assert!(result.is_err(), "{method} must not silently succeed");
+        }
+    }
+
     #[test]
     fn generate_media_result_serializes_artifacts_array() {
         let result = GenerateMediaResult {

apps/puffer-desktop/src-tauri/src/lib.rs

@@ -434,21 +434,46 @@ fn run_agent_turn(
 
 #[tauri::command]
 fn resolve_permission(
-    _turn_id: String,
-    _request_id: String,
-    _action: String,
+    app: AppHandle,
+    state: State<'_, SharedBackend>,
+    turn_id: String,
+    request_id: String,
+    action: String,
 ) -> Result<(), String> {
-    Ok(())
+    backend_call(
+        app,
+        state,
+        "resolve_permission",
+        json!({
+            "turnId": turn_id,
+            "requestId": request_id,
+            "action": action,
+        }),
+    )
+    .map(|_| ())
 }
 
 #[tauri::command]
 fn resolve_user_question(
-    _turn_id: String,
-    _request_id: String,
-    _answers: Value,
-    _annotations: Value,
+    app: AppHandle,
+    state: State<'_, SharedBackend>,
+    turn_id: String,
+    request_id: String,
+    answers: Value,
+    annotations: Value,
 ) -> Result<(), String> {
-    Ok(())
+    backend_call(
+        app,
+        state,
+        "resolve_user_question",
+        json!({
+            "turnId": turn_id,
+            "requestId": request_id,
+            "answers": answers,
+            "annotations": annotations,
+        }),
+    )
+    .map(|_| ())
 }
 
 #[tauri::command]