@@ -19,6 +19,11 @@
 - Required task inspection recognizes successful native database reads. Small
   model contexts can use a shorter, enforced response budget while retaining
   required input; requests that still cannot fit fail before contacting the model.
+- The native desktop can queue follow-up messages while the current task streams,
+  show waiting work across project conversations and cancel individual queued
+  tasks. Reloads select the running task first; queue cancellation cannot stop a
+  task that has already begun. Sidebar activity and transcript progress now
+  distinguish queued, running and completed work.
 - Native goals preserve milestone results, pause and resume, require recorded
   inspection/verification for the default checklist, and stop on failed checks.
   Goal tasks appear live in the conversation; results and progress are accessible
 
@@ -20,6 +20,7 @@ workflows, [managed background processes](docs/NATIVE_BACKGROUND.md), and
 [project inspection and diagnostics](docs/NATIVE_INSPECTION.md),
 [project and task notes](docs/NATIVE_MEMORY.md),
 [native SQLite inspection](docs/NATIVE_SQLITE.md),
+[queued follow-ups](docs/NATIVE_QUEUE.md),
 [approved MCP stdio and HTTP tools](docs/NATIVE_MCP.md), a
 [native MCP stdio server](docs/NATIVE_MCP.md#connect-another-coding-tool-to-shadowcode), and a
 [native CLI](docs/NATIVE_CLI.md) that shares the active desktop engine or runs
 
@@ -66,6 +66,11 @@ ID so a navigation change cannot send the decision to another task.
 tools, also available through the CLI and MCP server, with parameter binding,
 live WAL support, cancellation and result limits.
 
+[Queued follow-ups](NATIVE_QUEUE.md) let you send the next instruction while the
+current task streams. The project queue shows waiting messages across
+conversations, retains their model/mode choices and supports cancellation.
+Reloads return to the running task before waiting follow-ups.
+
 Project [lifecycle commands](NATIVE_HOOKS.md) can be reviewed and enabled in
 Settings → Hooks or through the same native CLI. Their command gates and
 completion checks run inside the native task lifecycle without Python callbacks.
 
@@ -104,6 +104,11 @@ Implemented foundation:
   workspaces, scoped approvals, cancellation that waits for cleanup, restart
   recovery, and atomic completion/usage/event commits. Continuation and branching
   retain valid function-call histories; interrupted calls are never blindly replayed.
+- A [desktop follow-up queue](NATIVE_QUEUE.md) with visible project-wide waiting
+  messages, model/mode snapshots, independent queued cancellation, continued
+  streaming, conversation switching and reload recovery. Active history remains
+  discoverable beyond recent-list limits; a stale queue action cannot cancel a
+  task that has started running.
 - Native filesystem, search, patch, shell, Git, and plan tools with durable audit
   events. Patches preflight every file, reject ambiguous context, preserve line
   endings, and journal edits for conflict-aware rewind. Shell and Git side effects
 
@@ -0,0 +1,53 @@
+# Queued follow-ups — native 0.20 development
+
+Keep working on the next instruction while ShadowCode runs a task. In the native
+desktop, enter a message and press Enter or **Queue follow-up**. The running
+response continues to stream; **Up next** shows the project's waiting messages
+in execution order. Expand a message to read it in full, or use its cancel button
+to remove it from the queue.
+
+Model and mode choices apply to the new follow-up. The queued task retains those
+choices and uses the completed conversation when it starts, including the
+previous task's actual tool results. Plan and Review keep their read-only
+permissions. Queuing does not grant approvals or run two tasks in one project
+at once.
+
+## Conversations and navigation
+
+The queue belongs to the project. A new conversation in the same project waits
+for its earlier tasks; conversations in other projects can run independently,
+within the engine's four-project concurrency limit. Queue rows from another
+conversation include a link to it. The sidebar distinguishes waiting tasks from
+running tasks and does not label completed history as active.
+
+Switching conversations or reloading the window retains the queue. Returning to
+a conversation selects its running task first, then its oldest waiting task.
+When a task finishes, the desktop loads the next task and its intervening
+history. Cancelling a waiting message does not replace the active task's plan,
+usage or progress state. Prompts appear in execution order when their tasks
+start, without duplicate user messages.
+
+The queue cancel button only cancels work that is still queued. If the task has
+started since the button was displayed, ShadowCode reports that change and
+leaves it running. Open its conversation and use **Stop task** to stop it.
+Stopping a running task leaves other queued tasks eligible to run; cancel those
+messages too if they are no longer wanted.
+
+## Limits and recovery
+
+- Up to 64 tasks can be running or queued across the application. Excess
+  submissions return an error and restore the draft.
+- Slash commands and new file uploads wait until the project is idle. Ordinary
+  follow-up messages can refer to files already in the project.
+- The active-job listing includes old running/queued tasks even when another
+  project has produced many newer completed tasks.
+- Reloading a window does not stop jobs. Closing the native application performs
+  managed shutdown and cancels its active and queued work. After an abrupt exit,
+  unfinished tasks are marked interrupted for review; they are not replayed
+  automatically.
+- This desktop queue uses the native engine. The supported 0.19 Python/browser
+  release retains its existing one-task composer. The native CLI also supports
+  queued submissions; see [NATIVE_CLI.md](NATIVE_CLI.md).
+
+See [NATIVE_VERIFICATION.md](NATIVE_VERIFICATION.md) for the engine and real-window
+checks and [NATIVE_MIGRATION.md](NATIVE_MIGRATION.md) for the remaining release gates.
@@ -6,7 +6,7 @@ remain in [NATIVE_MIGRATION.md](NATIVE_MIGRATION.md).
 
 ## Automated checks
 
-`cargo fmt --all --check`, Clippy with warnings denied, and all **182 native
+`cargo fmt --all --check`, Clippy with warnings denied, and all **183 native
 integration tests** pass on the development machine. The suite covers:
 
 - Config validation, private secrets, untrusted project overlays, profile locks,
@@ -22,6 +22,11 @@ integration tests** pass on the development machine. The suite covers:
   conflict preflight that preserves unrelated edits.
 - Approval isolation, expiry, cancellation, aborted futures, read-only tasks,
   queued cancellation, hung providers, and managed shutdown.
+- Queued-only cancellation refuses tasks that have already started and preserves
+  their running state. Task startup and cancellation share a transition lock.
+  Active work remains listed behind 10,005 newer completed jobs; conversation
+  selection prefers running work, then FIFO waiting work, then actual completion
+  time, including when a newer submission was cancelled before its predecessor.
 - Tool-call/result pairing across compaction and recovery, live file attachments,
   verification retries, token limits, and labelled estimates for absent usage.
 - Smaller response reserves for constrained models, enforced in the actual
@@ -273,13 +278,26 @@ passed Rust, CLI and MCP checks but caught a notification mid-fade at insufficie
 contrast. Toasts now animate position with fully opaque text. The rebuilt native
 window passes all twelve accessibility views and the complete twenty-request
 workflow locally, including the changed-selection goal approval regression.
-Seventeen interface unit tests cover ordered replay, pagination, stream finalization,
+Twenty interface unit tests cover ordered replay, pagination, stream finalization,
 listener cleanup, interruption, native tool cards, routing/fallback replay,
 workflow provenance, durable command/hook cards, completion checks between
 answers and task results, and disambiguated model labels that omit URL credentials. The seven existing browser
 tests continue to pass through the legacy transport.
 
-The same native window workflow also passes when launched from the local optimized
+The queued-follow-up update extends the real native-window probe to 22 scripted
+model requests and 15 passing Axe views. While a model response is deliberately
+held open, the UI queues two follow-ups, creates another conversation in the
+same project, queues and cancels its message, returns to the original task and
+reloads. The running task stays selected and visible; the queue survives.
+The probe cancels a waiting message without interrupting the first task, then
+releases it and observes the second task start automatically with its selected
+model, read-only Review tools and the completed predecessor's conversation.
+Cancelled messages never contact the model. Queue screenshots and accessibility
+reports cover light, dark and compact layouts; the sidebar returns to idle after
+completion. UI unit tests also cover interleaved queue cancellation without
+resetting the running task's plan/usage, and prompt ordering without duplication.
+
+The earlier twenty-request window workflow also passed from the local optimized
 AppImage in FUSE-free extraction mode with the legacy `ui` argument. The package
 checker confirms that AppImage and Debian packages contain native ELF application
 code with matching versions and no Python runtime or sidecars. Packaging now
 
@@ -503,23 +503,37 @@ impl Engine {
         self.request_cancel(id)?;
         self.wait(id).await
     }
+    pub async fn cancel_queued(&self, id: &str) -> Result<Job> {
+        self.request_cancel_if(id, true)?;
+        self.wait(id).await
+    }
     pub(crate) fn request_cancel(&self, id: &str) -> Result<()> {
+        self.request_cancel_if(id, false)
+    }
+    fn request_cancel_if(&self, id: &str, only_if_queued: bool) -> Result<()> {
+        const LEFT_QUEUE: &str = "This task has already left the queue. Open its conversation to review it or stop active work.";
         let Some(job) = self.running(id)? else {
-            self.job(id)?.context("Job not found")?;
+            let previous = self.job(id)?.context("Job not found")?;
+            ensure!(
+                !only_if_queued || previous.status == "cancelled",
+                LEFT_QUEUE
+            );
             return Ok(());
         };
-        job.cancel.cancel();
-        self.0.approvals.deny_task(&job.snapshot()?.task_id);
-        {
+        let task_id = {
             let mut record = job
                 .record
                 .lock()
                 .map_err(|_| anyhow!("Job lock poisoned"))?;
+            ensure!(!only_if_queued || record.status == "queued", LEFT_QUEUE);
+            job.cancel.cancel();
             if matches!(record.status.as_str(), "queued" | "running") {
                 record.status = "cancelling".into();
                 self.0.store.save_job(&json!(*record))?;
             }
-        }
+            record.task_id.clone()
+        };
+        self.0.approvals.deny_task(&task_id);
         // A queued cancellation should not wait for the current coding task.
         let is_front = {
             let queues = self
@@ -740,18 +754,22 @@ impl Engine {
         Ok(())
     }
     async fn run(&self, running: &Running) -> Result<(String, Value)> {
-        ensure!(
-            !running.cancel.is_cancelled(),
-            "Task cancelled before starting"
-        );
-        let mut job = running.snapshot()?;
-        job.status = "running".into();
-        job.started_at = crate::now();
-        *running
-            .record
-            .lock()
-            .map_err(|_| anyhow!("Job lock poisoned"))? = job.clone();
-        self.0.store.save_job(&json!(job))?;
+        // Queue removal and starting work share this lock. A stale queue button
+        // can never cancel a task that has already transitioned to running.
+        let job = {
+            let mut record = running
+                .record
+                .lock()
+                .map_err(|_| anyhow!("Job lock poisoned"))?;
+            ensure!(
+                !running.cancel.is_cancelled(),
+                "Task cancelled before starting"
+            );
+            record.status = "running".into();
+            record.started_at = crate::now();
+            self.0.store.save_job(&json!(*record))?;
+            record.clone()
+        };
         self.0.store.execute(
             "UPDATE tasks SET status='running' WHERE id=?",
             [&job.task_id],
 
@@ -624,13 +624,9 @@ impl Service {
                 self.select(&workspace, session["id"].as_str().map(str::to_owned))?;
                 return Ok(session);
             }
-            ("GET", "/api/jobs") => return Ok(json!({"jobs":store.jobs(1000)?})),
+            ("GET", "/api/jobs") => return Ok(json!({"jobs":store.active_and_recent_jobs(1000)?})),
             ("GET", "/api/jobs/current") => {
-                let jobs = store.jobs(10000)?;
-                let job = jobs.into_iter().find(|job| {
-                    job["session_id"] == q("session_id")
-                        && (q("include_finished") == "true" || active(job))
-                });
+                let job = store.current_job(q("session_id"), q("include_finished") == "true")?;
                 return Ok(json!({"job":job}));
             }
             ("POST", "/api/jobs/test") => {
@@ -1038,7 +1034,13 @@ impl Service {
             let job = self.engine.job(parts[2])?.context("Job not found")?;
             match (request.method.as_str(), parts.get(3).copied()) {
                 ("GET", None) => return Ok(json!(job)),
-                ("POST", Some("cancel")) => return Ok(json!(self.engine.cancel(&job.id).await?)),
+                ("POST", Some("cancel")) => {
+                    return Ok(json!(if body["only_if_queued"] == true {
+                        self.engine.cancel_queued(&job.id).await?
+                    } else {
+                        self.engine.cancel(&job.id).await?
+                    }))
+                }
                 ("GET", Some("events")) => {
                     return Ok(
                         json!({"events":store.events_after(&job.session_id,q("after").parse().unwrap_or(0),job.finished_at.map(|_|job.event_cursor),query_limit(&query,512,2000))?,"job":job}),
 
@@ -531,6 +531,20 @@ impl Store {
             .pop()
             .map(|v| v["payload"].clone()))
     }
+    /// Keep active work visible even after unrelated projects produce a large
+    /// amount of completed history. Insertion order is the workspace FIFO order.
+    pub fn active_and_recent_jobs(&self, limit: usize) -> Result<Vec<Value>> {
+        Ok(self.query(
+            "SELECT payload FROM desktop_jobs WHERE rowid IN (SELECT rowid FROM desktop_jobs ORDER BY rowid DESC LIMIT ?) OR json_extract(payload,'$.status') IN ('queued','running','cancelling') ORDER BY rowid DESC",
+            [limit.clamp(1, 10000)],
+        )?.into_iter().map(|row|row["payload"].clone()).collect())
+    }
+    pub fn current_job(&self, session: &str, include_finished: bool) -> Result<Option<Value>> {
+        Ok(self.query(
+            "SELECT payload FROM desktop_jobs WHERE json_extract(payload,'$.session_id')=? AND (? OR json_extract(payload,'$.status') IN ('queued','running','cancelling')) ORDER BY CASE json_extract(payload,'$.status') WHEN 'running' THEN 0 WHEN 'cancelling' THEN 1 WHEN 'queued' THEN 2 ELSE 3 END, CASE WHEN json_extract(payload,'$.status')='queued' THEN rowid END ASC, json_extract(payload,'$.finished_at') DESC, rowid DESC LIMIT 1",
+            rusqlite::params![session,include_finished],
+        )?.pop().map(|row|row["payload"].clone()))
+    }
     /// Called only by the profile-lock owner, before accepting new work.
     pub fn recover_jobs(&self) -> Result<usize> {
         let mut db = self.lock()?;
 
@@ -182,6 +182,13 @@ async fn queued_followups_run_in_order_and_duplicate_active_work_is_rejected() {
         assert_eq!(result.summary, expected);
     }
     assert_eq!(server.requests.lock().unwrap().len(), 4);
+    assert!(engine
+        .cancel_queued(&first.id)
+        .await
+        .unwrap_err()
+        .to_string()
+        .contains("left the queue"));
+    assert_eq!(engine.job(&first.id).unwrap().unwrap().status, "completed");
     engine.shutdown().await.unwrap();
 }
 
@@ -197,11 +204,25 @@ async fn queued_cancel_is_immediate_and_shutdown_cancels_a_stalled_provider() {
     let mut req = request(root.path(), "queued", Some(first.session_id.clone()));
     req.queue = true;
     let queued = engine.start(req).await.unwrap();
-    let result = tokio::time::timeout(Duration::from_secs(1), engine.cancel(&queued.id))
+    let result = tokio::time::timeout(Duration::from_secs(1), engine.cancel_queued(&queued.id))
         .await
         .unwrap()
         .unwrap();
     assert_eq!(result.status, "cancelled");
+    tokio::time::timeout(Duration::from_secs(3), async {
+        while engine.job(&first.id).unwrap().unwrap().status != "running" {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .unwrap();
+    assert!(engine
+        .cancel_queued(&first.id)
+        .await
+        .unwrap_err()
+        .to_string()
+        .contains("left the queue"));
+    assert_eq!(engine.job(&first.id).unwrap().unwrap().status, "running");
     tokio::time::timeout(Duration::from_secs(3), engine.shutdown())
         .await
         .unwrap()