diff --git a/README.md b/README.md
index f2f08ac..608cdd5 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ Managing several long-lived commands across terminal panes is pesky, especially
 
 - Run each command in its own PTY and group tasks by state, working directory, or named group.
 - Keep tasks running under a daemon across client disconnects.
-- Save and reload task recipes: directories, commands, group assignments, display names, tags, and the flagship.
+- Save and reload task recipes: directories, commands, group assignments, display names, tags, the flagship, and which tasks had finished.
 - Rerun a completed task in place, keeping its identity, group, and name.
 - Launch `claude`, `codex`, `grok`, and `omp` as managed agents and resume their conversations on rerun and reload.
 - Recover the current task set from automatic snapshots.
diff --git a/docs/README.md b/docs/README.md
index fdc5180..a741b7f 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,6 +1,6 @@
 # fleetcom Documentation
 
-The daemon supervises live processes; session files store repeatable launch recipes. Reconnecting returns you to the daemon's running tasks, while loading a session starts new processes from its recipe. Use this guide for storage paths, lifecycle details, and a complete first run.
+Use the daemon to supervise live processes and session files to save repeatable launch recipes, including whether each task had finished. Reconnect to access the daemon's running tasks. Load a session to start new processes for its live entries and restore finished tasks as stopped rows. Use this guide for storage paths, lifecycle details, and a complete first run.
 
 ## Index
 
@@ -150,7 +150,7 @@ Press `w`, type a name, and press `Enter` to save the fleet as a [session](sessi
 | `<runtime>/daemon.lock` | `0666 & ~umask` when new; otherwise unchanged | the owning daemon's PID, trustworthy only while its `flock` is held |
 | `<runtime>/daemon.log` | `0666 & ~umask` when new; otherwise unchanged | stderr from the autostarted daemon |
 | [session directory](#config-directory-sessions) | `0700` | saved recipes |
-| `<sessions>/<name>.json` | `0600` | directories, commands, groups, display names, tags, the flagship |
+| `<sessions>/<name>.json` | `0600` | directories, commands, groups, display names, tags, the flagship, stopped flags |
 | `<sessions>/recovery/` | `0700` | [automatic snapshots](sessions.md#recovery) |
 | `<sessions>/recovery/<snapshot>.json` | `0600` | one automatic session recipe |
 | `<capture-root>/<pid>-<nonce>/` | `0700` | [agent hook, notifier, and extension-module assets plus per-run capture payloads](agent-resume.md#capture-state-and-isolation) |
@@ -165,7 +165,7 @@ The runtime directory is validated before its contents are used. The path must b
 
 Full command lines are persisted in recipes, including any embedded secrets. A token passed as an argument is written to its session file and to every recovery snapshot that captures the task.
 
-The client environment is not persisted. Each client's environment and working directory are sent during the connection handshake and retained in daemon memory. Use session and recovery files to preserve only directories, commands, group assignments, display names, tags, and the flagship.
+The client environment is not persisted. Each client's environment and working directory are sent during the connection handshake and retained in daemon memory. Use session and recovery files to preserve only directories, commands, group assignments, display names, tags, the flagship, and whether each task had finished.
 
 ### Captured IDs
 
diff --git a/docs/commands.md b/docs/commands.md
index b1ba61e..256a87a 100644
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -34,8 +34,8 @@ Choose the operating mode with launch arguments. Use keys to control the dashboa
 | `Ctrl-]` | Attach to the flagship |
 | `g` | Assign the selected task to a group (through the group picker) |
 | `R` | Rename the selected task: a display name shown in place of the command |
-| `r` | Rerun a finished task; resume the conversation for a managed agent |
-| `X` | Kill a running task (`TERM`, then `KILL` after 2 s), or remove a finished one |
+| `r` | Rerun a finished task or start a stopped one; resume the conversation for a managed agent |
+| `X` | Kill a running task (`TERM`, then `KILL` after 2 s), or remove a finished or stopped one |
 | `w` | Save the current tasks as a session |
 | `o` | Load a saved session or a recovery snapshot (through the [session picker](#the-o-session-picker)) |
 | `?` | Open the [controls overlay](#the--controls-overlay) |
@@ -53,6 +53,7 @@ Choose the operating mode with launch arguments. Use keys to control the dashboa
 | `∙` | Idle: running, but quiet |
 | `✓` | Completed, exit 0 |
 | `✗` | Completed, non-zero exit |
+| ` ` | Stopped: restored from a [session](sessions.md) and not yet started |
 | `◆` | Tagged "in use" |
 | `⚑` | The [flagship](#the-flagship) |
 
@@ -108,13 +109,13 @@ Press `Esc`, `Enter`, `q`, or `End`, or scroll to the bottom, to return to live
 
 #### Destroying tasks
 
-Press uppercase `X` to kill a running task or remove a finished one. On removal, remaining processes in the task's process group are also terminated: `TERM`, then `KILL` after two seconds. Lowercase `x` and `Ctrl-X` are unbound.
+Press uppercase `X` to kill a running task or remove a finished or stopped one. On removal of a finished task, remaining processes in its process group are also terminated: `TERM`, then `KILL` after two seconds. A stopped task has no process group to sweep. Lowercase `x` and `Ctrl-X` are unbound.
 
 #### Rerunning tasks
 
-Press `r` to rerun a finished task. Running tasks cannot be rerun without first being killed and are left untouched.
+Press `r` to rerun a finished task or start a stopped one: a task restored from a [session](sessions.md) that had finished when the file was written. Until you start a stopped task, there is no process or output to view in attach or peek. Kill a running task before rerunning it; pressing `r` while it is running has no effect.
 
-On rerun, the replacement is started in the same directory with the requesting client's environment. For a literal task, the exact command text is run again. For a managed agent, the binary is resolved on the current `PATH`, and the captured conversation is resumed when an ID is known; see [agent session resume](agent-resume.md).
+On rerun, start the replacement in the same directory with the requesting client's environment. For a literal task, run the exact command text again. For a managed agent, resolve the binary on the current `PATH` and resume the captured conversation when an ID is known; see [agent session resume](agent-resume.md). For a stopped managed agent, resume its stored session ID. Binary lookup is deferred until you press `r`, so you can load the session without the agent installed.
 
 On rerun, the task's ID, `◆` tag, group, name, and spawn order are preserved; its clock and screen are reset. Under lifecycle sorting, the restarted task may be listed in another section. You can also rerun inside peek without closing the overlay.
 
@@ -128,9 +129,9 @@ Press uppercase `Q` to stop the daemon and terminate each task's process group:
 
 #### Grouping and tagging
 
-Press `s` to cycle through state, dir, and custom grouping. In the header strip `by state · dir · custom`, the active mode is bold and the rest dim.
+Press `s` to cycle through state, dir, and custom grouping. In the header strip `by state · dir · custom`, the active mode is bold and the rest dim. To its left, read the counts as `N running · N idle · N done`, followed by ` · N stopped` only while at least one stopped task is listed.
 
-- By state: In use / Running / Idle / Completed. After 10 s without output, a running task is grouped under Idle. Completed tasks are grouped in one section, with exit status marked `✓`/`✗`.
+- By state: In use / Running / Idle / Completed. After 10 s without output, a running task is grouped under Idle. Completed tasks are grouped in one section, with exit status marked `✓`/`✗`. Stopped tasks are placed in Completed as well, with a blank glyph and a blank age cell: no process has run under the row, so there is no launch, output, or exit time to measure from.
 - By dir: one section per working directory; the invocation directory first, then the remaining labels sorted without regard to case.
 - By custom group: one section per group name, sorted without regard to case, with Unassigned last. Fresh spawns remain unassigned unless they inherit a group, and the Unassigned section exists only while it has a member.
 
@@ -138,7 +139,7 @@ Dashboard section labels and within-section directory tiebreaks use the same cas
 
 Groups belong to task state: an assignment survives client detach and rerun (`r`), and switching grouping modes does not modify it. Press `g` to reassign the selected task through the [group picker](#the-g-group-picker).
 
-Press `m` to toggle the "in use" tag, marked `◆`. In state mode, tagged tasks form the In use section at the top. In custom mode, tagged tasks are placed at the top of their existing groups rather than in a global section. Within a dir or custom section, tasks are sorted as tagged, live, then completed; each class is then sorted by directory and spawn order. Idle state does not affect row order in these modes, so quiet tasks are kept in place and marked `∙`. In state mode, quiet tasks are moved from Running to Idle.
+Press `m` to toggle the "in use" tag, marked `◆`. In state mode, tagged tasks form the In use section at the top. In custom mode, tagged tasks are placed at the top of their existing groups rather than in a global section. Within a dir or custom section, tasks are sorted as tagged, live, then completed or stopped; each class is then sorted by directory and spawn order. Idle state does not affect row order in these modes, so quiet tasks are kept in place and marked `∙`. In state mode, quiet tasks are moved from Running to Idle.
 
 Press `M` to select the next tagged task in dashboard order, wrapping after the last. With no tagged tasks, the selection is unchanged; with one, that task is selected.
 
@@ -146,7 +147,7 @@ In custom mode only, a new command is assigned the selected task's group, throug
 
 #### The flagship
 
-Press `]` to mark the selected task as the flagship, shown as `⚑`; press it again to clear the mark. You can mark only one task at a time. Select another task and press `]` to move the mark. Finished tasks cannot be marked. Sorting is unchanged.
+Press `]` to mark the selected task as the flagship, shown as `⚑`; press it again to clear the mark. You can mark only one task at a time. Select another task and press `]` to move the mark. Finished and stopped tasks cannot be marked. Sorting is unchanged.
 
 Press `Ctrl-]` from the dashboard, peek, or an attached task to attach to the flagship, and again to go back:
 
@@ -155,7 +156,7 @@ Press `Ctrl-]` from the dashboard, peek, or an attached task to attach to the fl
 
 After attaching to the flagship with `Enter`, press `Ctrl-]` to return to the dashboard.
 
-You keep tags set with `m` after task completion, but lose the flagship mark on completion or removal. Save and load [sessions](sessions.md) to preserve and restore both marks. You can also recover both marks from automatic snapshots. When loading with a current flagship, you keep that mark.
+You keep tags set with `m` after task completion, but lose the flagship mark on completion or removal. Save and load [sessions](sessions.md) to preserve and restore both marks. You can also recover both marks from automatic snapshots. When loading with a current flagship, you keep that mark. A stored flagship on a stopped entry is not restored.
 
 #### Renaming
 
@@ -229,7 +230,7 @@ Bindings are arranged in two columns. At limited height, group headers are omitt
 
 ## Peek
 
-Peek shows the selected task's live screen (the last screenful) in a centered box over the dashboard. Use `↑`/`↓` (or `k`/`j`) to switch tasks, `Enter` to attach, `r` to rerun a finished task, or `Space`, `Esc`, or `q` to close.
+Use peek to view the selected task's live screen (the last screenful) in a centered box over the dashboard. Use `↑`/`↓` (or `k`/`j`) to switch tasks, `Enter` to attach, `r` to rerun a finished task or start a stopped one, or `Space`, `Esc`, or `q` to close.
 
 Read the source of the row's dashboard preview in the footer's `preview:` segment: `floor` (the last non-blank row of the live screen), `marker` (a full-screen program with no usable title), `title` (the child's window title), or `anchor/<rule>` (a recognized agent status, tagged with the matcher that produced it). On the alternate screen, any current title is rendered; recognized title formats are normalized first. On the primary screen, only a retained title recognized by the task's agent adapter is rendered. Otherwise, `floor` is used. Most rules name a screen matcher, such as `claude:spinner` or `codex:approval-menu`. The `claude:registry-approval` and `claude:registry-waiting` rules instead come from Claude's on-disk session status.
 
diff --git a/docs/sessions.md b/docs/sessions.md
index b27ada6..fc542f6 100644
--- a/docs/sessions.md
+++ b/docs/sessions.md
@@ -1,6 +1,6 @@
 # Sessions
 
-Save a session to preserve the task set's working directories, commands or managed agents with their session IDs, group assignments, display names, "in use" tags, and flagship mark. You cannot preserve client state (the attached or peeked task, selection, grouping and sort modes, terminal size) or process state (lifecycle, output, timings) in a session. Each time you load a session, you start new processes with the saved settings. To keep live processes running across client disconnects, use the [daemon](README.md#storage-paths).
+Save a session to preserve the task set's working directories, commands or managed agents with their session IDs, group assignments, display names, "in use" tags, flagship mark, and whether each task had finished. You cannot preserve client state (the attached or peeked task, selection, grouping and sort modes, terminal size) or process state (output, timings, exit status) in a session. Each time you load a session, you start new processes for the tasks that were live; a task that had finished is restored as a stopped row, with no process until you press `r`. To keep live processes running across client disconnects, use the [daemon](README.md#storage-paths).
 
 ## Storage
 
@@ -20,10 +20,10 @@ The filename is derived from the session name: leading and trailing whitespace i
 
 A session file is a JSON object with three fields: `version` for the format version, currently 2; `name` for the typed session name, trimmed but not sanitized; and `dirs` for an ordered list of entries per working directory. Use one of two entry forms, according to the task's launch mode:
 
-- A **literal** entry is a typed command. Use a bare string without labels or marks, or an object with `cmd` and optional `group`, `name`, `tagged`, and `flagship` fields. Load a literal entry to run the stored text unchanged through your shell: even `"claude"` is a literal command.
-- A **managed** entry is an object with `agent`, the registered program word (`claude`, `codex`, `grok`, or `omp`), plus optional `resume`, `group`, `name`, `tagged`, and `flagship` fields. Save tasks launched from the Agent page in this form. Load a managed entry with `resume` to reopen the stored session ID, or without it to start a fresh conversation. See [Agent session resume](agent-resume.md).
+- A **literal** entry is a typed command. Use a bare string without labels or marks, or an object with `cmd` and optional `group`, `name`, `tagged`, `flagship`, and `stopped` fields. Load a literal entry to run the stored text unchanged through your shell: even `"claude"` is a literal command.
+- A **managed** entry is an object with `agent`, the registered program word (`claude`, `codex`, `grok`, or `omp`), plus optional `resume`, `group`, `name`, `tagged`, `flagship`, and `stopped` fields. Save tasks launched from the Agent page in this form. Load a managed entry with `resume` to reopen the stored session ID, or without it to start a fresh conversation. See [Agent session resume](agent-resume.md).
 
-Use the optional booleans `tagged` and `flagship` on either object form. Set `tagged` to `true` to tag a task ["in use"](commands.md#grouping-and-tagging), or `flagship` to `true` to mark the [flagship](commands.md#the-flagship). To leave either mark unset, use `false`, `null`, or omit the field. On save, include each field only when true. Mark at most one entry per file as the flagship; with a second, you cannot load the file.
+Use the optional booleans `tagged`, `flagship`, and `stopped` on either object form. Set `tagged` to `true` to tag a task ["in use"](commands.md#grouping-and-tagging), `flagship` to `true` to mark the [flagship](commands.md#the-flagship), or `stopped` to `true` to restore the task as a row with no process. To leave any of them unset, use `false`, `null`, or omit the field. On save, include each field only when true; `stopped` is true for every task that had finished or had not yet been started. Mark at most one entry per file as the flagship; with a second, you cannot load the file.
 
 ```json
 {
@@ -33,6 +33,7 @@ Use the optional booleans `tagged` and `flagship` on either object form. Set `ta
     "~/work/api": [
       "cargo watch -x test",
       { "cmd": "cargo run", "group": "api", "name": "api server", "tagged": true },
+      { "cmd": "cargo build --release", "stopped": true },
       { "agent": "claude", "resume": "c8c4a5cc-0b32-4ba0-a6b4-6ed08c218e0d", "group": "agents", "flagship": true },
       { "agent": "omp" }
     ],
@@ -62,19 +63,23 @@ On load, expect validation of the entire recipe before any commands are started.
 - For each entry, use a command string or an object with a string `cmd` or a string `agent`, never both.
 - For `agent`, use a supported program word. For `resume`, use a lowercase `8-4-4-4-12` UUID, `null`, or omit the field.
 - For the optional entry `group` and `name` fields and the wrapped session's `name`, use strings, `null`, or omit the fields.
-- For `tagged` and `flagship`, use booleans, `null`, or omit the fields. Set `flagship` to `true` on at most one entry; otherwise, both entry locations are reported in the error.
+- For `tagged`, `flagship`, and `stopped`, use booleans, `null`, or omit the fields. Set `flagship` to `true` on at most one entry; otherwise, both entry locations are reported in the error.
 
 You can include unknown fields in wrapped metadata and entry objects; these are ignored. You can also use empty maps, arrays, and strings. With invalid JSON or any malformed field, you cannot load any part of the recipe; your existing tasks and recipe file remain intact. For schema errors, expect the quoted directory key, entry number (starting at 1), and offending field where applicable.
 
-After validation, group and display names are stripped of control characters and surrounding whitespace and limited to 64 characters. `Unassigned` is treated as no group but is a legal display name. Missing directories, entries past the task limit, and literal commands past the length limit are skipped and counted in the load status. A managed entry whose agent is not found on the connected client's `PATH` is reported on the status line and counted as a failed spawn; the remaining entries are still loaded. Spawn failures are reported separately; tasks already started from a structurally valid recipe are left running.
+After validation, group and display names are stripped of control characters and surrounding whitespace and limited to 64 characters. `Unassigned` is treated as no group but is a legal display name. Missing directories, entries past the task limit, and literal commands past the length limit are skipped and counted in the load status. For a live managed entry without an agent binary on the connected client's `PATH`, expect a diagnostic on the status line and a failed-spawn count. The remaining entries are still loaded. Spawn failures are reported separately; tasks already started from a structurally valid recipe are left running.
 
-Use the string form for commands with no group, no name, and no mark. String and object entries can appear in the same directory array.
+A stopped entry is restored as a row with no process: lifecycle `stopped`, a blank glyph, a blank age cell, and an empty screen under attach and peek. The same directory, task-limit, and length rules apply. Load a stopped managed entry by agent word alone; binary lookup on the connected client's `PATH` is deferred until you press `r`, so you can load the file without the agent installed. Press `r` to start the row: run the stored text for a literal entry, or resume the stored session ID for a managed entry. See [Rerunning tasks](commands.md#rerunning-tasks).
+
+Read each outcome on the status line, with the stopped count before the skipped and failed counts: `loaded 'api': 1 task(s), 1 stopped, 1 skipped (missing dir, task limit, or command too long)`. With nothing spawned and at least one other count, expect no `0 task(s)` clause: `loaded 'api': 1 stopped`. After loading a recovery snapshot, expect `loaded recovery snapshot; save to name it, 1 stopped`.
+
+Use the string form for a live command with no group, no name, and no mark. String and object entries can appear in the same directory array.
 
 ## Recovery
 
 The current task set is automatically snapshotted under `recovery/` inside the session directory. A separate file is written for each daemon (or `--foreground` core), named for its start time and process ID. After each write, the new file and files whose process IDs are still live are protected; among the remaining files, the nine newest names are retained. A shared recovery directory can therefore contain more than ten snapshots while multiple writers are live.
 
-Expect a snapshot pass two seconds after the last command that can change a saved recipe, including marking with `m` or `]`. After a burst of commands, count the delay from the last command. You also get a pass after the flagship mark is cleared on task exit, without a command. For a nonempty recipe, expect a write when its content or destination changed, or when the expected snapshot file is missing. For changes made without a command, such as a newly captured session ID for a managed task, expect checks every 60 seconds.
+Expect a snapshot pass two seconds after the last command that can change a saved recipe, including marking with `m` or `]`. After a burst of commands, count the delay from the last command. You also get a pass after a task exits, without a command, to persist the entry's `stopped` flag and clear any flagship mark on that task. For a nonempty recipe, expect a write when its content or destination changed, or when the expected snapshot file is missing. For changes made without a command, such as a newly captured session ID for a managed task, expect checks every 60 seconds.
 
 - No snapshot is written for an empty fleet. After removing every task, the previous snapshot is retained.
 - Snapshots are left in place after quitting, disconnecting, or `fleetcom --kill`.
@@ -87,8 +92,8 @@ As with saved recipes, full command lines are persisted in recovery files, inclu
 
 ## Saving and loading
 
-- Save: press `w` in the dashboard, type a name, and press `Enter` to write `<name>.json` with the session name and each task's directory, command or managed agent and session ID, optional group and name, "in use" tag, and flagship mark.
+- Save: press `w` in the dashboard, type a name, and press `Enter` to write `<name>.json` with the session name and each task's directory, command or managed agent and session ID, optional group and name, "in use" tag, flagship mark, and stopped flag.
 - Load in-app: `o`, pick from the list, `Enter`.
 - Load at launch: `fleetcom <name>`.
 
-Load a session to start new processes from the stored commands. To retain live process state, use the daemon; you cannot store that state in session files. When you load, you keep your existing tasks and marks and recover the tags on every loaded task. You recover a stored flagship only when no task is currently marked. See [Agent session resume](agent-resume.md) for preserving supported agent conversations across relaunch.
+Load a session to start new processes from the live entries and to restore the stopped entries as rows with no process; press `r` on a stopped row to start it. To retain live process state, use the daemon; you cannot store that state in session files. When you load, you keep your existing tasks and marks and recover the tags on every loaded task. You recover a stored flagship only when no task is currently marked, and never on a stopped entry. See [Agent session resume](agent-resume.md) for preserving supported agent conversations across relaunch.
diff --git a/src/app.rs b/src/app.rs
index 2379d2b..2276786 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -364,12 +364,12 @@ fn step_down(sel: usize, len: usize) -> usize {
 fn state_section(v: &TaskView) -> (u8, &'static str) {
     if v.tagged {
         (0, "In use")
+    } else if v.lifecycle.finished() {
+        (3, "Completed")
+    } else if v.lifecycle == Lifecycle::Idle {
+        (2, "Idle")
     } else {
-        match v.lifecycle {
-            Lifecycle::Active => (1, "Running"),
-            Lifecycle::Idle => (2, "Idle"),
-            Lifecycle::Ok | Lifecycle::Failed => (3, "Completed"),
-        }
+        (1, "Running")
     }
 }
 
@@ -379,7 +379,7 @@ fn state_section(v: &TaskView) -> (u8, &'static str) {
 fn row_rank(v: &TaskView) -> u8 {
     if v.tagged {
         0
-    } else if matches!(v.lifecycle, Lifecycle::Ok | Lifecycle::Failed) {
+    } else if v.lifecycle.finished() {
         2
     } else {
         1
@@ -1327,7 +1327,7 @@ impl App {
             // next daemon tick, before inclusion in a snapshot.
             KeyCode::Char(']') => {
                 if let Some(i) = self.selected_task()
-                    && !matches!(self.views[i].lifecycle, Lifecycle::Ok | Lifecycle::Failed)
+                    && !self.views[i].lifecycle.finished()
                 {
                     let v = &self.views[i];
                     let id = (!v.flagship).then_some(v.id);
@@ -1961,7 +1961,7 @@ impl App {
     /// Restart the selected task only when the local snapshot marks it finished.
     fn rerun_selected(&mut self) {
         if let Some(i) = self.selected_task()
-            && matches!(self.views[i].lifecycle, Lifecycle::Ok | Lifecycle::Failed)
+            && self.views[i].lifecycle.finished()
         {
             self.transport.send(Command::Restart {
                 id: self.views[i].id,
@@ -1974,8 +1974,7 @@ impl App {
             return;
         };
         let id = self.views[i].id;
-        let finished = matches!(self.views[i].lifecycle, Lifecycle::Ok | Lifecycle::Failed);
-        if finished {
+        if self.views[i].lifecycle.finished() {
             // Drop it, landing selection on the neighbor (not the top). The
             // removal reflects next tick, so pick the neighbor id from the
             // *current* order now and pin selection to it.
diff --git a/src/app_readme_tests.rs b/src/app_readme_tests.rs
index d51bc55..e2ebb00 100644
--- a/src/app_readme_tests.rs
+++ b/src/app_readme_tests.rs
@@ -144,7 +144,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
                 "Scope small fixes for dashboard and CLI",
                 "claude:action-row",
             ),
-            started_ago: mins(2),
+            started_ago: Some(mins(2)),
             quiet_ago: Some(secs(3)),
             finished_ago: None,
         },
@@ -162,7 +162,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
                 "Fable 5.1 (high) · Inferring… · thinking with high effort",
                 "claude:spinner",
             ),
-            started_ago: mins(5),
+            started_ago: Some(mins(5)),
             quiet_ago: Some(secs(8)),
             finished_ago: None,
         },
@@ -177,7 +177,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: Some("Grok Language".to_string()),
             lifecycle: Lifecycle::Active,
             preview: working("Grok 4.7 (xhigh) · Responding…", "grok:spinner"),
-            started_ago: mins(12),
+            started_ago: Some(mins(12)),
             quiet_ago: Some(secs(4)),
             finished_ago: None,
         },
@@ -192,7 +192,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: Some("Codex Language".to_string()),
             lifecycle: Lifecycle::Active,
             preview: anchor(CODEX_LANGUAGE, "codex:working"),
-            started_ago: mins(18),
+            started_ago: Some(mins(18)),
             quiet_ago: Some(secs(2)),
             finished_ago: None,
         },
@@ -207,7 +207,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: Some("Codex Review".to_string()),
             lifecycle: Lifecycle::Active,
             preview: anchor(CODEX_REVIEW, "codex:working"),
-            started_ago: mins(24),
+            started_ago: Some(mins(24)),
             quiet_ago: Some(secs(6)),
             finished_ago: None,
         },
@@ -222,7 +222,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Ok,
             preview: frozen(FLEETCOM_TESTS),
-            started_ago: mins(2),
+            started_ago: Some(mins(2)),
             quiet_ago: None,
             finished_ago: Some(secs(12)),
         },
@@ -237,7 +237,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Failed,
             preview: frozen(FLEETCOM_CLIPPY),
-            started_ago: mins(5),
+            started_ago: Some(mins(5)),
             quiet_ago: None,
             finished_ago: Some(mins(3)),
         },
@@ -252,7 +252,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: Some("claude agents".to_string()),
             lifecycle: Lifecycle::Active,
             preview: title("2 awaiting input · claude agents"),
-            started_ago: mins(63),
+            started_ago: Some(mins(63)),
             quiet_ago: Some(secs(9)),
             finished_ago: None,
         },
@@ -267,7 +267,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: Some("Zellij".to_string()),
             lifecycle: Lifecycle::Active,
             preview: title("Desktop ¦ Utility"),
-            started_ago: mins(126),
+            started_ago: Some(mins(126)),
             quiet_ago: Some(secs(4)),
             finished_ago: None,
         },
@@ -282,7 +282,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Idle,
             preview: floor(">>>"),
-            started_ago: mins(48),
+            started_ago: Some(mins(48)),
             quiet_ago: Some(mins(41)),
             finished_ago: None,
         },
@@ -297,7 +297,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Ok,
             preview: frozen("Already up-to-date."),
-            started_ago: mins(14),
+            started_ago: Some(mins(14)),
             quiet_ago: None,
             finished_ago: Some(mins(13)),
         },
@@ -312,7 +312,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: Some("Game Infra Review".to_string()),
             lifecycle: Lifecycle::Active,
             preview: title("Turret Game Codebase Organization and Ex… - grok"),
-            started_ago: mins(8),
+            started_ago: Some(mins(8)),
             quiet_ago: Some(secs(5)),
             finished_ago: None,
         },
@@ -329,7 +329,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             // omp has no anchor tier: the primary-screen title tier renders
             // the conversation label omp announces, with no model prefix.
             preview: title("Tuning missile damage falloff"),
-            started_ago: mins(33),
+            started_ago: Some(mins(33)),
             quiet_ago: Some(secs(7)),
             finished_ago: None,
         },
@@ -346,7 +346,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             // At its prompt: the primary-screen title tier renders the
             // conversation label omp announces as `π > <label>`.
             preview: title("EMP arc balance pass"),
-            started_ago: mins(35),
+            started_ago: Some(mins(35)),
             quiet_ago: Some(secs(3)),
             finished_ago: None,
         },
@@ -361,7 +361,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Ok,
             preview: frozen(CRABAPPLE_TESTS),
-            started_ago: mins(18),
+            started_ago: Some(mins(18)),
             quiet_ago: None,
             finished_ago: Some(mins(17)),
         },
@@ -376,7 +376,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Ok,
             preview: frozen(CRABSTEP_TESTS),
-            started_ago: mins(22),
+            started_ago: Some(mins(22)),
             quiet_ago: None,
             finished_ago: Some(mins(21)),
         },
@@ -394,7 +394,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
                 "Opus 5.5 (high) · Review GitHub issue 780",
                 "claude:action-row",
             ),
-            started_ago: mins(6),
+            started_ago: Some(mins(6)),
             quiet_ago: Some(secs(2)),
             finished_ago: None,
         },
@@ -409,7 +409,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Ok,
             preview: frozen(IMESSAGE_TESTS),
-            started_ago: mins(20),
+            started_ago: Some(mins(20)),
             quiet_ago: None,
             finished_ago: Some(mins(19)),
         },
@@ -424,7 +424,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Ok,
             preview: frozen(LOGRIA_TESTS),
-            started_ago: mins(32),
+            started_ago: Some(mins(32)),
             quiet_ago: None,
             finished_ago: Some(mins(31)),
         },
@@ -439,7 +439,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Active,
             preview: floor(LOGRIA_WATCH),
-            started_ago: secs(45),
+            started_ago: Some(secs(45)),
             quiet_ago: Some(secs(2)),
             finished_ago: None,
         },
@@ -454,7 +454,7 @@ fn live_fleet(dirs: &Dirs) -> Vec<TaskView> {
             name: None,
             lifecycle: Lifecycle::Idle,
             preview: floor(LOGRIA_DOC),
-            started_ago: mins(28),
+            started_ago: Some(mins(28)),
             quiet_ago: Some(mins(26)),
             finished_ago: None,
         },
@@ -557,7 +557,7 @@ fn quiet_fleet(dirs: &Dirs) -> Vec<TaskView> {
             panic!("no peek-frame override for task {}", v.id);
         };
         v.lifecycle = q.lifecycle;
-        v.started_ago = q.started_ago;
+        v.started_ago = Some(q.started_ago);
         v.quiet_ago = q.quiet_ago;
         v.finished_ago = q.finished_ago;
         if let Some((text, rule)) = q.preview {
diff --git a/src/app_tests.rs b/src/app_tests.rs
index 1a31046..2f67d77 100644
--- a/src/app_tests.rs
+++ b/src/app_tests.rs
@@ -242,12 +242,42 @@ fn view(id: u64, cwd: PathBuf, tagged: bool, group: Option<&str>) -> TaskView {
         name: None,
         lifecycle: Lifecycle::Active,
         preview: Preview::floor(String::new()),
-        started_ago: Duration::ZERO,
+        started_ago: Some(Duration::ZERO),
         quiet_ago: Some(Duration::ZERO),
         finished_ago: None,
     }
 }
 
+/// Clear the attached viewport for a stopped task: there is no formatted grid to
+/// paint over the dashboard. With a nonempty grid, paint without clearing first.
+#[test]
+fn attached_stopped_task_clears_the_dashboard_beneath() {
+    let mut app = App::new_local(30, 100);
+    app.views.push(TaskView {
+        lifecycle: Lifecycle::Stopped,
+        started_ago: None,
+        quiet_ago: None,
+        ..view(7, crate::testutil::here(), false, None)
+    });
+    app.mode = Mode::Attached;
+    app.focused_id = Some(7);
+
+    app.focused_screen = Some(crate::testutil::screen(7));
+    assert!(
+        painted(&mut app).contains("\x1b[2J"),
+        "an empty screen must clear the dashboard it would otherwise leave visible"
+    );
+
+    app.focused_screen = Some(ScreenView {
+        formatted: b"grid".to_vec(),
+        ..crate::testutil::screen(7)
+    });
+    assert!(
+        !painted(&mut app).contains("\x1b[2J"),
+        "a screen with content covers the viewport itself"
+    );
+}
+
 /// Selection is bound to a task id, so a reorder (here: tagging a task into
 /// the "In use" bucket) must not move the highlight to a different task.
 #[test]
@@ -817,6 +847,72 @@ fn state_mode_ordering_survives_the_row_key_split() {
     );
 }
 
+/// Count stopped rows in the header only when one exists; otherwise, show only
+/// the running, idle, and done counts.
+#[test]
+fn header_counts_stopped_rows_only_when_present() {
+    let mut app = App::new_local(30, 100);
+    let dir = app.invocation_dir.clone();
+    app.views = vec![view(1, dir.clone(), false, None)];
+    app.resolve_selection();
+    let frame = painted(&mut app);
+    assert!(
+        frame.contains("1 running · 0 idle · 0 done      by"),
+        "{frame:?}"
+    );
+
+    app.views.push(TaskView {
+        lifecycle: Lifecycle::Stopped,
+        started_ago: None,
+        quiet_ago: None,
+        ..view(2, dir, false, None)
+    });
+    let frame = painted(&mut app);
+    assert!(
+        frame.contains("1 running · 0 idle · 0 done · 1 stopped      by"),
+        "{frame:?}"
+    );
+}
+
+/// Treat a stopped row as finished for grouping, ranking, and key handling: place
+/// it in Completed at the finished rank, ignore `]`, send `Restart` on `r`, and
+/// send `Remove` on `X`.
+#[test]
+fn stopped_row_is_finished_for_every_client_gate() {
+    let mut app = App::new_local(30, 100);
+    let dir = app.invocation_dir.clone();
+    let stopped = TaskView {
+        lifecycle: Lifecycle::Stopped,
+        started_ago: None,
+        quiet_ago: None,
+        ..view(1, dir.clone(), false, None)
+    };
+    app.views = vec![stopped, view(2, dir, false, None)];
+    app.resolve_selection();
+    assert_eq!(
+        app.section_ids(),
+        vec![
+            ("Running".to_string(), vec![2]),
+            ("Completed".to_string(), vec![1]),
+        ]
+    );
+    assert_eq!(row_rank(&app.views[0]), 2);
+
+    app.selected_id = Some(1);
+    let sent = app.record_sends();
+    app.hit(key(KeyCode::Char(']')));
+    assert!(
+        sent.lock().unwrap().is_empty(),
+        "`]` sends nothing for a stopped row"
+    );
+    app.hit(key(KeyCode::Char('r')));
+    app.hit(key(KeyCode::Char('X')));
+    assert_eq!(
+        *sent.lock().unwrap(),
+        vec![Command::Restart { id: 1 }, Command::Remove { id: 1 }]
+    );
+}
+
 /// `r` sends `Restart` only for a finished selection. On a running task
 /// the key is a client-side no-op: nothing crosses the transport, so no
 /// supervisor complaint lands in the status line. On a finished one the
diff --git a/src/protocol.rs b/src/protocol.rs
index 8363d76..b37c341 100644
--- a/src/protocol.rs
+++ b/src/protocol.rs
@@ -12,7 +12,7 @@ use base64::{Engine as _, engine::general_purpose::STANDARD as B64};
 use crate::frame::{KIND_CONTROL, KIND_HELLO, KIND_SCREEN};
 
 /// Wire-protocol version; mismatched peers are rejected during the handshake.
-pub const PROTOCOL_VERSION: u32 = 15;
+pub const PROTOCOL_VERSION: u32 = 16;
 
 /// Reserved dashboard label for tasks without a custom group.
 pub const UNASSIGNED: &str = "Unassigned";
@@ -267,12 +267,15 @@ pub struct RecoveryEntry {
 
 /// Process-derived lifecycle state, independent of the user's `tagged` intent.
 /// `Idle` means no recent output, not that the process is waiting for input.
+/// `Stopped` means no process at all: the row was restored from a session
+/// file and nothing has run under it in this daemon's lifetime.
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum Lifecycle {
     Active,
     Idle,
     Ok,
     Failed,
+    Stopped,
 }
 
 impl Lifecycle {
@@ -283,6 +286,7 @@ impl Lifecycle {
             Self::Idle => "idle",
             Self::Ok => "ok",
             Self::Failed => "failed",
+            Self::Stopped => "stopped",
         }
     }
 
@@ -293,9 +297,20 @@ impl Lifecycle {
             "idle" => Some(Self::Idle),
             "ok" => Some(Self::Ok),
             "failed" => Some(Self::Failed),
+            "stopped" => Some(Self::Stopped),
             _ => None,
         }
     }
+
+    /// Whether the process has exited (`Ok`, `Failed`) or was never started
+    /// (`Stopped`). Use this predicate for `r`, `X`, `]`, and the Completed
+    /// section; classify new variants here to keep those decisions consistent.
+    pub fn finished(self) -> bool {
+        match self {
+            Self::Active | Self::Idle => false,
+            Self::Ok | Self::Failed | Self::Stopped => true,
+        }
+    }
 }
 
 /// Where a preview's text came from. Declared in ascending authority so the
@@ -391,7 +406,9 @@ pub struct TaskView {
     pub lifecycle: Lifecycle,
     /// The dashboard preview, resolved by the core at snapshot time.
     pub preview: Preview,
-    pub started_ago: Duration,
+    /// Time since launch of the current run; `None` for a stopped task, which
+    /// has no run.
+    pub started_ago: Option<Duration>,
     /// Time since the last PTY output; `Some` only while the task is live.
     pub quiet_ago: Option<Duration>,
     /// Time since the exit latched; `Some` only once the task is finished.
@@ -897,9 +914,9 @@ pub fn encode_event(ev: &Event) -> (u8, Vec<u8>) {
                 // Include `working` on the wire. The dashboard has no `rule` field from
                 // which to derive it.
                 let _ = o.insert("working", tv.preview.working);
-                let _ = o.insert("started_ms", tv.started_ago.as_millis() as u64);
-                // Each age exists in exactly one phase: `quiet_ms` while
-                // live, `finished_ms` once finished.
+                // Include `started_ms` for any run, `quiet_ms` while live, and
+                // `finished_ms` once finished. Omit all ages for stopped tasks.
+                insert_opt_ms(&mut o, "started_ms", tv.started_ago);
                 insert_opt_ms(&mut o, "quiet_ms", tv.quiet_ago);
                 insert_opt_ms(&mut o, "finished_ms", tv.finished_ago);
                 let _ = arr.push(o);
@@ -985,7 +1002,7 @@ pub fn decode_event(kind: u8, payload: &[u8]) -> Option<Event> {
                                 frozen: tv["frozen"].as_bool()?,
                                 working: tv["working"].as_bool()?,
                             },
-                            started_ago: Duration::from_millis(tv["started_ms"].as_u64()?),
+                            started_ago: opt_ms(&tv["started_ms"])?,
                             quiet_ago: opt_ms(&tv["quiet_ms"])?,
                             finished_ago: opt_ms(&tv["finished_ms"])?,
                         });
diff --git a/src/protocol_tests.rs b/src/protocol_tests.rs
index 15e0de4..e861ed6 100644
--- a/src/protocol_tests.rs
+++ b/src/protocol_tests.rs
@@ -374,7 +374,7 @@ fn tv(id: u64) -> TaskView {
         name: None,
         lifecycle: Lifecycle::Ok,
         preview: Preview::floor(String::new()),
-        started_ago: Duration::from_millis(0),
+        started_ago: Some(Duration::from_millis(0)),
         quiet_ago: None,
         finished_ago: None,
     }
@@ -445,7 +445,7 @@ fn tasks_round_trip() {
                 frozen: false,
                 working: false,
             },
-            started_ago: Duration::from_millis(4200),
+            started_ago: Some(Duration::from_millis(4200)),
             quiet_ago: Some(Duration::from_millis(700)),
             finished_ago: None,
         },
@@ -454,7 +454,7 @@ fn tasks_round_trip() {
             // Exercise byte-preserving task-path serialization.
             cwd: PathBuf::from(OsString::from_vec(b"/srv/\xff\xfe".to_vec())),
             lifecycle: Lifecycle::Active,
-            started_ago: Duration::from_millis(10),
+            started_ago: Some(Duration::from_millis(10)),
             ..tv(2)
         },
     ]);
@@ -555,7 +555,7 @@ fn lifecycle_and_age_fields_round_trip() {
             let live = matches!(lifecycle, Lifecycle::Active | Lifecycle::Idle);
             let tasks = Event::Tasks(vec![TaskView {
                 lifecycle,
-                started_ago: Duration::from_millis(60_000),
+                started_ago: Some(Duration::from_millis(60_000)),
                 quiet_ago: if live { age } else { None },
                 finished_ago: if live { None } else { age },
                 ..tv(1)
@@ -578,6 +578,42 @@ fn lifecycle_and_age_fields_round_trip() {
     }
 }
 
+/// Round-trip a stopped task without ages: omit `started_ms` and decode it as
+/// `None`. Decode a present `started_ms` as `Some`.
+#[test]
+fn stopped_round_trips_without_a_start_age() {
+    let stopped = Event::Tasks(vec![TaskView {
+        lifecycle: Lifecycle::Stopped,
+        started_ago: None,
+        ..tv(1)
+    }]);
+    let (k, p) = encode_event(&stopped);
+    let s = std::str::from_utf8(&p).unwrap();
+    assert!(s.contains("\"life\":\"stopped\""), "frame was {s}");
+    assert!(!s.contains("started_ms"), "frame was {s}");
+    assert_eq!(decode_event(k, &p), Some(stopped));
+
+    let started = Event::Tasks(vec![tv(1)]);
+    let (k, p) = encode_event(&started);
+    let s = std::str::from_utf8(&p).unwrap();
+    assert!(s.contains("\"started_ms\":0"), "frame was {s}");
+    assert_eq!(decode_event(k, &p), Some(started));
+}
+
+/// Classify every lifecycle in `finished` for client key handling and grouping.
+#[test]
+fn finished_classifies_every_lifecycle() {
+    for (lifecycle, want) in [
+        (Lifecycle::Active, false),
+        (Lifecycle::Idle, false),
+        (Lifecycle::Ok, true),
+        (Lifecycle::Failed, true),
+        (Lifecycle::Stopped, true),
+    ] {
+        assert_eq!(lifecycle.finished(), want, "{lifecycle:?}");
+    }
+}
+
 /// Null ages remain unknown, just like omitted ages.
 #[test]
 fn tasks_frame_null_ages_decode_as_unknown() {
diff --git a/src/session.rs b/src/session.rs
index 6b8e027..47784e4 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -34,9 +34,9 @@ pub enum EntryKind {
     },
 }
 
-/// One recipe entry. Serialize a literal with no group, no name, and neither mark as a
-/// bare string. Use an object for every other entry, writing optional fields only when
-/// set and marks only when true.
+/// One recipe entry. Serialize a literal with no group, no name, no mark, and not
+/// stopped as a bare string. Use an object for every other entry, writing optional
+/// fields only when set and flags only when true.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct SessionEntry {
     pub kind: EntryKind,
@@ -46,11 +46,14 @@ pub struct SessionEntry {
     pub tagged: bool,
     /// The `]` mark. Allow at most one flagged entry per file; reject a second in `from_json`.
     pub flagship: bool,
+    /// Whether the task had no live process when the file was written. On load,
+    /// restore a stopped entry as a row without a process. Press `r` to start it.
+    pub stopped: bool,
 }
 
 #[cfg(test)]
 impl SessionEntry {
-    /// Unlabelled, unmarked literal entry.
+    /// Unlabelled, unmarked, live literal entry.
     pub fn literal(cmd: &str) -> Self {
         Self {
             kind: EntryKind::Literal(cmd.into()),
@@ -58,10 +61,11 @@ impl SessionEntry {
             name: None,
             tagged: false,
             flagship: false,
+            stopped: false,
         }
     }
 
-    /// Unlabelled, unmarked managed entry.
+    /// Unlabelled, unmarked, live managed entry.
     pub fn managed(agent: &str, resume: Option<&str>) -> Self {
         Self {
             kind: EntryKind::Managed {
@@ -72,6 +76,7 @@ impl SessionEntry {
             name: None,
             tagged: false,
             flagship: false,
+            stopped: false,
         }
     }
 }
@@ -132,9 +137,13 @@ fn dirs_json(cfg: &SessionConfig) -> jzon::JsonValue {
         let mut arr = jzon::JsonValue::new_array();
         for e in entries {
             let mut m = match &e.kind {
-                // Use the string form for a literal without optional labels or marks.
+                // Use the string form for a live literal without optional labels or marks.
                 EntryKind::Literal(cmd)
-                    if e.group.is_none() && e.name.is_none() && !e.tagged && !e.flagship =>
+                    if e.group.is_none()
+                        && e.name.is_none()
+                        && !e.tagged
+                        && !e.flagship
+                        && !e.stopped =>
                 {
                     let _ = arr.push(cmd.as_str());
                     continue;
@@ -148,13 +157,16 @@ fn dirs_json(cfg: &SessionConfig) -> jzon::JsonValue {
             };
             insert_opt_str(&mut m, "group", e.group.as_deref());
             insert_opt_str(&mut m, "name", e.name.as_deref());
-            // Omit false marks to preserve the exact serialization of unmarked entries.
+            // Omit false flags to preserve the exact serialization of unmarked entries.
             if e.tagged {
                 let _ = m.insert("tagged", true);
             }
             if e.flagship {
                 let _ = m.insert("flagship", true);
             }
+            if e.stopped {
+                let _ = m.insert("stopped", true);
+            }
             let _ = arr.push(m);
         }
         let _ = dirs.insert(dir, arr);
@@ -184,8 +196,9 @@ pub fn fingerprint_json(cfg: &SessionConfig) -> String {
 /// through [`FORMAT_VERSION`]. Treat a missing version as 1. Accept entry forms regardless
 /// of version: strings and `{"cmd"}` objects for literals, `{"agent"}` objects for managed
 /// agents. Reject the whole file for objects with both keys, unregistered agents, resume
-/// IDs that are not strict UUIDs, non-boolean `tagged` or `flagship` fields, or a second
-/// `flagship`. Never rewrite an entry: load a v1 file verbatim, with every entry literal.
+/// IDs that are not strict UUIDs, non-boolean `tagged`, `flagship`, or `stopped` fields,
+/// or a second `flagship`. Never rewrite an entry: load a v1 file verbatim, with every
+/// entry literal.
 /// Conversion of v1 agent commands to managed entries (v1 had no managed form) was
 /// introduced in 0.15.0 and retired in the release after it.
 fn from_json(text: &str) -> io::Result<(Option<String>, SessionConfig)> {
@@ -243,6 +256,7 @@ fn from_json(text: &str) -> io::Result<(Option<String>, SessionConfig)> {
                     name: None,
                     tagged: false,
                     flagship: false,
+                    stopped: false,
                 });
                 continue;
             }
@@ -305,6 +319,7 @@ fn from_json(text: &str) -> io::Result<(Option<String>, SessionConfig)> {
                 name: label("name")?,
                 tagged: mark("tagged")?,
                 flagship: mark("flagship")?,
+                stopped: mark("stopped")?,
             };
             if entry.flagship {
                 if let Some(first) = &flagship_at {
@@ -807,6 +822,57 @@ mod tests {
         );
     }
 
+    /// Round-trip stopped entries. Use the object form for a stopped literal, write
+    /// the flag after the marks for a stopped managed entry, and use a bare string
+    /// for a live unmarked literal.
+    #[test]
+    fn round_trips_stopped_entries() {
+        let dir = temp("session_stopped_roundtrip");
+        let mut cfg = SessionConfig::new();
+        cfg.insert(
+            "~/p".into(),
+            vec![
+                SessionEntry {
+                    stopped: true,
+                    ..e("cargo test")
+                },
+                SessionEntry {
+                    tagged: true,
+                    stopped: true,
+                    ..m("claude", Some(ID))
+                },
+                e("vim"),
+            ],
+        );
+
+        save_in(&dir, "stopped", &cfg).unwrap();
+        assert_eq!(load_in(&dir, "stopped").unwrap(), cfg);
+        assert_eq!(
+            fingerprint_json(&cfg),
+            format!(
+                r#"{{"~/p":[{{"cmd":"cargo test","stopped":true}},{{"agent":"claude","resume":"{ID}","tagged":true,"stopped":true}},"vim"]}}"#
+            )
+        );
+    }
+
+    /// Treat `false`, `null`, and omission as live on both entry forms; refuse any
+    /// other type, naming the field.
+    #[test]
+    fn stopped_parses_like_a_mark() {
+        for spelling in ["", r#", "stopped": false"#, r#", "stopped": null"#] {
+            let text =
+                format!(r#"{{"d": [{{"cmd": "vim"{spelling}}}, {{"agent": "omp"{spelling}}}]}}"#);
+            let (_, cfg) = from_json(&text).unwrap();
+            assert_eq!(cfg["d"], vec![e("vim"), m("omp", None)], "{text}");
+        }
+        let err = from_json(r#"{"d": ["vim", {"cmd": "top", "stopped": "yes"}]}"#).unwrap_err();
+        assert_eq!(err.kind(), io::ErrorKind::InvalidData);
+        assert_eq!(
+            err.to_string(),
+            "directory \"d\", entry 2, field \"stopped\": expected a boolean or null"
+        );
+    }
+
     /// Treat `false`, `null`, and omission as an unset mark on both entry forms.
     #[test]
     fn unset_marks_parse_as_false_in_every_spelling() {
diff --git a/src/supervisor.rs b/src/supervisor.rs
index 68d1fdc..b847603 100644
--- a/src/supervisor.rs
+++ b/src/supervisor.rs
@@ -19,11 +19,11 @@ use crate::{
     harness::{self, Harness, Intent, assets},
     path,
     protocol::{
-        Command, Event, FLEETCOM_RUNTIME_DIR, LaunchContext, ScreenView, ScrollAction, TaskView,
-        UNASSIGNED, env_get,
+        Command, Event, FLEETCOM_RUNTIME_DIR, LaunchContext, Lifecycle, ScreenView, ScrollAction,
+        TaskView, UNASSIGNED, env_get,
     },
     session::{self, EntryKind, SessionConfig, SessionEntry},
-    task::{Exec, Task, WriteRefused},
+    task::{Exec, Process, Task, WriteRefused},
 };
 
 /// Quiet period after which a live task becomes idle.
@@ -77,6 +77,8 @@ const SKIP_REASONS: &str = "missing dir, task limit, or command too long";
 #[derive(Default)]
 struct LoadOutcome {
     spawned: usize,
+    /// Entries restored as rows without a process.
+    stopped: usize,
     skipped: usize,
     failed: usize,
     /// Launch notices and failure reasons, in load order.
@@ -84,9 +86,12 @@ struct LoadOutcome {
 }
 
 impl LoadOutcome {
-    /// Format nonzero skipped and failed counts as summary clauses.
+    /// Format nonzero stopped, skipped, and failed counts as summary clauses.
     fn clauses(&self) -> Vec<String> {
         let mut parts = Vec::new();
+        if self.stopped > 0 {
+            parts.push(format!("{} stopped", self.stopped));
+        }
         if self.skipped > 0 {
             parts.push(format!("{} skipped ({SKIP_REASONS})", self.skipped));
         }
@@ -235,8 +240,9 @@ fn affects_recipe(cmd: &Command) -> bool {
         | Command::Flagship { .. }
         | Command::LoadSession { .. }
         | Command::LoadRecovery { .. } => true,
-        // Exclude `Kill`: lifecycle is not part of the recipe. For the remaining input,
-        // view, and meta commands, no fields serialized by `session_config` are changed.
+        // Exclude `Kill`: update the recipe and schedule recovery in `reap` when
+        // latching the exit, not when sending the signal. The remaining input, view,
+        // and meta commands do not change fields serialized by `session_config`.
         Command::Kill { .. }
         | Command::Resize { .. }
         | Command::Watch { .. }
@@ -289,14 +295,15 @@ impl Recovery {
 
 pub struct Supervisor {
     tasks: Vec<Task>,
-    /// Removed tasks whose process groups may still be winding down: `TERMed` at
-    /// removal, escalated to KILL by `reap` at grace end, and dropped once the
-    /// leader's zombie is collected. Invisible to `tick` snapshots, so the row
-    /// disappears instantly while the sweep runs behind it.
+    /// Retired runs awaiting process-group cleanup after removal or rerun. Send
+    /// TERM at retirement, escalate to KILL in `reap` at grace end, and drop each
+    /// run after collecting the leader's zombie. Omit these runs from `tick`
+    /// snapshots: remove the row or display its replacement immediately while
+    /// cleaning up the old process group in the background.
     ///
     /// Retain each leader's zombie until SIGKILL has been sent: collecting it earlier
     /// would release the process-group ID.
-    graveyard: Vec<Task>,
+    graveyard: Vec<Process>,
     next_id: u64,
     /// PTY content size (rows already minus the client's status bar). Every task
     /// runs at this size, so attach never reflows.
@@ -320,7 +327,7 @@ pub struct Supervisor {
     /// Spawning is refused until one is installed.
     launch: Option<LaunchContext>,
     events: Vec<Event>,
-    /// Handed to every `Task` so its reader thread can wake the core loop when the PTY
+    /// Handed to every `Process` so its reader thread can wake the core loop when the PTY
     /// produces output. Install the serving loop's sender on connect (`set_waker`) and
     /// drop it on disconnect (`clear_waker`). Between clients it is `None`; task output
     /// is parsed without waking a serving loop.
@@ -436,11 +443,17 @@ impl Supervisor {
                 group,
             } => self.spawn(&command, &cwd, group),
             Command::SpawnAgent { agent, cwd, group } => self.spawn_agent(&agent, &cwd, group),
-            Command::Kill { id } => self.with_task(id, Task::terminate),
+            // Signals, resizes, and viewport moves have no target on a stopped task.
+            Command::Kill { id } => self.with_task(id, |t| {
+                if let Some(p) = &mut t.process {
+                    p.terminate();
+                }
+            }),
             Command::Remove { id } => {
-                if let Some(i) = self.index_of(id) {
-                    let t = self.tasks.remove(i);
-                    self.retire(t);
+                if let Some(i) = self.index_of(id)
+                    && let Some(p) = self.tasks.remove(i).process
+                {
+                    self.retire(p);
                 }
             }
             Command::Restart { id } => self.rerun(id),
@@ -460,8 +473,8 @@ impl Supervisor {
                 if u32::from(self.rows) * u32::from(self.cols) > MAX_CELLS {
                     self.cols = (MAX_CELLS / u32::from(self.rows)) as u16;
                 }
-                for t in &mut self.tasks {
-                    let _ = t.resize(self.rows, self.cols);
+                for p in self.tasks.iter().filter_map(|t| t.process.as_ref()) {
+                    let _ = p.resize(self.rows, self.cols);
                 }
             }
             Command::Watch { id, attached } => {
@@ -469,15 +482,17 @@ impl Supervisor {
                 if id != self.watched
                     && let Some(old) = self.watched
                     && let Some(t) = self.by_id_mut(old)
+                    && let Some(p) = &t.process
                 {
-                    t.scroll_view(ScrollAction::Live);
+                    p.scroll_view(ScrollAction::Live);
                 }
                 if id != self.watched || attached != self.watch_attached {
                     // Discard stores captured before this watch state took effect.
                     if let Some(new) = id
                         && let Some(t) = self.by_id_mut(new)
+                        && let Some(p) = &t.process
                     {
-                        let _ = t.drain_clipboard();
+                        let _ = p.drain_clipboard();
                     }
                     self.last_screen = None;
                 }
@@ -486,15 +501,23 @@ impl Supervisor {
             }
             // Paste and mouse encoding depend on the child's terminal modes,
             // which only the core's emulator can see.
-            Command::Paste { id, bytes } => self.deliver(id, "paste", |t| t.send_paste(&bytes)),
+            Command::Paste { id, bytes } => {
+                self.deliver(id, "paste", |p| p.send_paste(&bytes));
+            }
             Command::Mouse { id, kind, col, row } => {
-                self.deliver(id, "mouse input", |t| t.send_mouse(kind, col, row));
+                self.deliver(id, "mouse input", |p| p.send_mouse(kind, col, row));
             }
             // Encode keys here because the child's cursor-key mode is core-side.
             Command::Key { id, code, mods } => {
-                self.deliver(id, "key input", |t| t.send_key(code, mods));
+                self.deliver(id, "key input", |p| p.send_key(code, mods));
+            }
+            Command::Scrollback { id, action } => {
+                self.with_task(id, |t| {
+                    if let Some(p) = &t.process {
+                        p.scroll_view(action);
+                    }
+                });
             }
-            Command::Scrollback { id, action } => self.with_task(id, |t| t.scroll_view(action)),
             Command::SaveSession { name } => self.save_session(&name),
             Command::LoadSession { name } => self.load_session(&name),
             Command::LoadRecovery { stem } => self.load_recovery(&stem),
@@ -506,18 +529,26 @@ impl Supervisor {
     /// Latch exits, escalate overdue TERM requests, and collect removed tasks.
     pub fn reap(&mut self) {
         let now = Instant::now();
+        let mut exited = false;
         for t in &mut self.tasks {
+            let Some(p) = &mut t.process else {
+                continue;
+            };
+            let was_live = p.finished.is_none();
             // Swallow a poll error rather than propagate: the task just isn't
             // latched this pass and is retried next. waitid failing is rare and
             // must not take down the loop.
-            let _ = t.poll_exit();
+            let _ = p.poll_exit();
+            exited |= was_live && p.finished.is_some();
             // Freeze the preview from the complete output and final screen.
             t.finalize_preview();
-            if t.overdue(now, self.kill_grace) {
-                t.force_kill();
+            if let Some(p) = &mut t.process
+                && p.overdue(now, self.kill_grace)
+            {
+                p.force_kill();
             }
         }
-        // Removed tasks still need exit handling and escalation.
+        // Continue exit handling and escalation for retired runs.
         for t in &mut self.graveyard {
             let _ = t.poll_exit();
             if t.overdue(now, self.kill_grace) {
@@ -529,22 +560,30 @@ impl Supervisor {
         // already-finished tasks. Check during reaping because `tick` is not called between
         // clients; otherwise, an exited flagship would remain marked in recovery
         // snapshots until the next connection.
-        if self.flagship.is_some() && self.flagship_holder().is_none() {
+        let cleared = self.flagship.is_some() && self.flagship_holder().is_none();
+        if cleared {
             self.flagship = None;
-            // Schedule recovery explicitly after clearing the mark outside `apply`.
-            // Otherwise, a user can restore the old mark from disk before the 60 s
-            // cadence pass.
+        }
+        // Schedule recovery after latching an exit or clearing a flagship mark
+        // outside `apply`: persist the new `stopped` flag and omit the cleared mark.
+        // Otherwise, a user can restore the old recipe from disk before the 60 s
+        // cadence pass.
+        if exited || cleared {
             self.recovery.last_mutation = Some(Instant::now());
         }
     }
 
-    /// Return the flagship ID only for an unfinished task still in the set. Between
-    /// reaps, the stored ID may refer to a removed task or one whose exit is not yet
-    /// latched.
+    /// Return the flagship ID only for a task still in the set with a live process.
+    /// Between reaps, the stored ID may refer to a removed task or one whose exit is
+    /// not yet latched. Exclude stopped tasks, which have no process to mark.
     fn flagship_holder(&self) -> Option<u64> {
         self.flagship.filter(|&id| {
-            self.index_of(id)
-                .is_some_and(|i| self.tasks[i].finished.is_none())
+            self.index_of(id).is_some_and(|i| {
+                self.tasks[i]
+                    .process
+                    .as_ref()
+                    .is_some_and(|p| p.finished.is_none())
+            })
         })
     }
 
@@ -554,8 +593,8 @@ impl Supervisor {
     /// continue through `reap`; a nonempty fleet waits even if leaders exit.
     /// Collection and PTY teardown never block on live processes or workers.
     fn shutdown_all(&mut self) {
-        for t in &mut self.tasks {
-            t.terminate();
+        for p in self.tasks.iter_mut().filter_map(|t| t.process.as_mut()) {
+            p.terminate();
         }
         let deadline = Instant::now() + self.kill_grace;
         while (!self.tasks.is_empty() || !self.graveyard.is_empty()) && Instant::now() < deadline {
@@ -586,12 +625,26 @@ impl Supervisor {
             .tasks
             .iter_mut()
             .map(|t| {
-                t.flush_expired_sync();
-                // Drain all tasks so stores from inactive tasks cannot be forwarded later.
-                let stores = t.drain_clipboard();
-                if forwarding == Some(t.id) {
-                    clipboard = Some((t.id, stores));
-                }
+                // Skip grid operations and age calculations for a stopped task:
+                // no process has run under the row.
+                let (lifecycle, started_ago, quiet_ago, finished_ago) = match &t.process {
+                    Some(p) => {
+                        p.flush_expired_sync();
+                        // Drain all tasks so stores from inactive tasks cannot be
+                        // forwarded later.
+                        let stores = p.drain_clipboard();
+                        if forwarding == Some(t.id) {
+                            clipboard = Some((t.id, stores));
+                        }
+                        (
+                            p.lifecycle(now, IDLE_AFTER),
+                            Some(now.duration_since(p.started)),
+                            p.finished.is_none().then(|| p.quiet_for(now)),
+                            p.finished.map(|f| now.duration_since(f)),
+                        )
+                    }
+                    None => (Lifecycle::Stopped, None, None, None),
+                };
                 TaskView {
                     id: t.id,
                     command: t.command.clone(),
@@ -601,11 +654,11 @@ impl Supervisor {
                     managed: t.harness.is_some(),
                     group: t.group.clone(),
                     name: t.name.clone(),
-                    lifecycle: t.lifecycle(now, IDLE_AFTER),
+                    lifecycle,
                     preview: t.resolve_preview(now),
-                    started_ago: now.duration_since(t.started),
-                    quiet_ago: t.finished.is_none().then(|| t.quiet_for(now)),
-                    finished_ago: t.finished.map(|f| now.duration_since(f)),
+                    started_ago,
+                    quiet_ago,
+                    finished_ago,
                 }
             })
             .collect();
@@ -627,28 +680,47 @@ impl Supervisor {
         if let Some(id) = self.watched
             && let Some(t) = self.tasks.iter().find(|t| t.id == id)
         {
-            let (formatted, cursor, hide) = t.formatted();
-            let (wants_mouse, alt_screen, alt_scroll) = t.input_hints();
-            let sb = t.scroll_offset();
-            let mut view = ScreenView {
-                id,
-                // `lines` stays empty on both the stored and candidate copies
-                // so it never affects equality; it is filled only on the
-                // emitted copy.
-                lines: Vec::new(),
-                formatted,
-                cursor,
-                // Hide the live cursor while displaying scrollback.
-                hide_cursor: hide || sb > 0,
-                wants_mouse,
-                alt_screen,
-                alt_scroll,
-                scrollback: sb,
+            // Allow attach and peek on stopped tasks; send an empty screen with
+            // a hidden cursor because there is no grid to display.
+            let mut view = match &t.process {
+                Some(p) => {
+                    let (formatted, cursor, hide) = p.formatted();
+                    let (wants_mouse, alt_screen, alt_scroll) = p.input_hints();
+                    let sb = p.scroll_offset();
+                    ScreenView {
+                        id,
+                        // Leave `lines` empty on the stored and candidate copies
+                        // to exclude it from equality; fill only the emitted copy.
+                        lines: Vec::new(),
+                        formatted,
+                        cursor,
+                        // Hide the live cursor while displaying scrollback.
+                        hide_cursor: hide || sb > 0,
+                        wants_mouse,
+                        alt_screen,
+                        alt_scroll,
+                        scrollback: sb,
+                    }
+                }
+                None => ScreenView {
+                    id,
+                    lines: Vec::new(),
+                    formatted: Vec::new(),
+                    cursor: (0, 0),
+                    hide_cursor: true,
+                    wants_mouse: false,
+                    alt_screen: false,
+                    alt_scroll: false,
+                    scrollback: 0,
+                },
             };
             // Send only when rendering or input-policy state changes.
             if self.last_screen.as_ref() != Some(&view) {
                 self.last_screen = Some(view.clone());
-                view.lines = t.screen_lines();
+                view.lines = t
+                    .process
+                    .as_ref()
+                    .map_or_else(Vec::new, Process::screen_lines);
                 self.events.push(Event::Screen(view));
             }
         }
@@ -744,24 +816,29 @@ impl Supervisor {
         }
     }
 
-    /// Terminate a removed task, unlink its capture, and retain it for
+    /// Terminate a displaced run, unlink its capture, and retain it for
     /// escalation and reaping.
-    fn retire(&mut self, mut t: Task) {
-        t.terminate();
-        if let Some(cap) = &t.capture_file {
+    fn retire(&mut self, mut p: Process) {
+        p.terminate();
+        if let Some(cap) = &p.capture_file {
             let _ = std::fs::remove_file(cap);
         }
-        self.graveyard.push(t);
+        self.graveyard.push(p);
     }
 
-    /// Route one input send to task `id`, reporting a bounded-queue refusal.
+    /// Route one input send to task `id`'s run, reporting a bounded-queue refusal.
+    /// Silently discard input to stopped tasks and force-killed runs.
     fn deliver(
         &mut self,
         id: u64,
         what: &str,
-        f: impl FnOnce(&mut Task) -> Result<(), WriteRefused>,
+        f: impl FnOnce(&Process) -> Result<(), WriteRefused>,
     ) {
-        if let Some(r) = self.by_id_mut(id).and_then(|t| f(t).err()) {
+        if let Some(r) = self
+            .by_id_mut(id)
+            .and_then(|t| t.process.as_ref())
+            .and_then(|p| f(p).err())
+        {
             self.status(format!(
                 "task {id} is not reading input; dropped {} {what}",
                 crate::format::bytes(r.len)
@@ -884,10 +961,12 @@ impl Supervisor {
         )?;
         if let Some((h, home, capture_file, resume_id)) = meta {
             task.harness = Some(h);
-            // Registry reads must keep using the launch-time configuration.
-            task.harness_home = home;
-            task.capture_file = Some(capture_file);
             task.resume_id = resume_id;
+            if let Some(p) = &mut task.process {
+                // Use the launch-time configuration for registry reads.
+                p.harness_home = home;
+                p.capture_file = Some(capture_file);
+            }
         }
         task.run = run;
         // Return the notice for inclusion in the load summary. A separate status queued
@@ -907,12 +986,19 @@ impl Supervisor {
         name: Option<String>,
     ) -> io::Result<(u64, Option<String>)> {
         let id = self.next_id;
-        let (mut task, notice) = self.spawn_task(id, 0, launch, cwd, env)?;
+        let (task, notice) = self.spawn_task(id, 0, launch, cwd, env)?;
+        self.enroll(task, group, name);
+        Ok((id, notice))
+    }
+
+    /// Append `task`, built under `next_id`, with its labels normalized.
+    /// Increment the ID counter only here.
+    fn enroll(&mut self, mut task: Task, group: Option<String>, name: Option<String>) {
+        debug_assert_eq!(task.id, self.next_id, "task built under a stale id");
         task.group = normalize_group(group);
         task.name = normalize_label(name);
         self.next_id += 1;
         self.tasks.push(task);
-        Ok((id, notice))
     }
 
     /// Report an interactive spawn: send its notice, then acknowledge the new row for
@@ -980,19 +1066,22 @@ impl Supervisor {
         self.report_spawn(admitted);
     }
 
-    /// Rerun a finished task in place, preserving its ID, tag, group, and name. For managed
-    /// tasks, resolve the binary on the current `PATH` and resume the best-known session
-    /// ID, or start fresh if none is known. For literal tasks, rerun the exact text.
+    /// Rerun a finished or stopped task in place, preserving its ID, tag, group, and
+    /// name. For managed tasks, resolve the binary on the current `PATH` and resume the
+    /// best-known session ID, or start fresh if none is known. For literal tasks, rerun
+    /// the exact text.
     fn rerun(&mut self, id: u64) {
         let Some(i) = self.index_of(id) else {
             self.status(format!("rerun failed: no task {id}"));
             return;
         };
-        // A task can exit between the last reap tick and this request.
-        let _ = self.tasks[i].poll_exit();
-        if self.tasks[i].finished.is_none() {
-            self.status("rerun failed: task is still running");
-            return;
+        if let Some(p) = &mut self.tasks[i].process {
+            // A task can exit between the last reap tick and this request.
+            let _ = p.poll_exit();
+            if p.finished.is_none() {
+                self.status("rerun failed: task is still running");
+                return;
+            }
         }
         // Exit may have been latched just above, between ticks. Clear the mark
         // before reusing the id for a live replacement. At the next tick, the
@@ -1019,21 +1108,34 @@ impl Supervisor {
                 Launch::Literal(&command)
             }
         };
-        // Preserve the finished task if its replacement cannot start. Use a distinct
-        // run number to isolate the replacement's capture file.
+        // Preserve the finished or stopped task if its replacement cannot start. Use a
+        // distinct run number to isolate the replacement's capture file.
         let run = self.tasks[i].run + 1;
         match self.spawn_task(id, run, &relaunch, &cwd, &launch.env) {
-            Ok((mut fresh, notice)) => {
+            Ok((fresh, notice)) => {
                 if let Some(notice) = notice {
                     self.status(format!("task {id}: {notice}"));
                 }
-                fresh.tagged = self.tasks[i].tagged;
-                fresh.group.clone_from(&self.tasks[i].group);
-                fresh.name.clone_from(&self.tasks[i].name);
-                // Read the resume ID before retiring the displaced run and removing its
-                // capture file.
-                let old = std::mem::replace(&mut self.tasks[i], fresh);
-                self.retire(old);
+                // Preserve the row's identity; copy only the launch state from
+                // the fresh spawn: harness, run number, planned resume ID, and
+                // process. Read the resume ID above, before retiring the old run
+                // and unlinking its capture file. For a stopped task, there is
+                // no old run to retire.
+                let Task {
+                    harness,
+                    run,
+                    resume_id,
+                    process,
+                    ..
+                } = fresh;
+                let t = &mut self.tasks[i];
+                t.harness = harness;
+                t.run = run;
+                t.resume_id = resume_id;
+                let old = std::mem::replace(&mut t.process, process);
+                if let Some(old) = old {
+                    self.retire(old);
+                }
                 // Reset the fingerprint for the replacement task's screen.
                 if self.watched == Some(id) {
                     self.last_screen = None;
@@ -1045,7 +1147,8 @@ impl Supervisor {
 
     /// Build `{dir: [entries]}` in spawn order, preserving groups, names, tags, and the
     /// flagship mark. Save managed tasks as agent words with the best-known session IDs;
-    /// save literals as their exact text.
+    /// save literals as their exact text. Mark a task with no live process, exited or
+    /// never started, as stopped; on load, restore its row without starting a process.
     fn session_config(&self) -> SessionConfig {
         // `admit` appends monotonic IDs; `rerun` preserves both index and ID;
         // removal preserves relative order.
@@ -1070,6 +1173,7 @@ impl Supervisor {
                     name: t.name.clone(),
                     tagged: t.tagged,
                     flagship: self.flagship == Some(t.id),
+                    stopped: t.process.as_ref().is_none_or(|p| p.finished.is_some()),
                 });
         }
         cfg
@@ -1118,10 +1222,12 @@ impl Supervisor {
 
     /// Spawn each recipe entry in its existing directory; skip missing directories. Resolve
     /// managed binaries as on the Agent page. Record a missing binary as a failed entry
-    /// with a diagnostic, then continue loading. Restore each admitted entry's tag.
-    /// Preserve the current tasks and their marks: restore a stored flagship only when
-    /// no live task is marked. Return the outcome for one summary line, or `None` after
-    /// reporting a missing launch context.
+    /// with a diagnostic, then continue loading. Restore a stopped entry as a row with no
+    /// process; defer managed binary lookup until `rerun`, using the `PATH` of that
+    /// moment. Restore each admitted entry's tag. Preserve the current tasks and
+    /// their marks: restore a stored flagship only when no live task is marked, and
+    /// never on a stopped entry, which has no process to mark. Return the outcome for
+    /// one summary line, or `None` after reporting a missing launch context.
     fn materialize(&mut self, cfg: &SessionConfig) -> Option<LoadOutcome> {
         let launch = self.launch_or_refuse()?;
         let mut out = LoadOutcome::default();
@@ -1136,14 +1242,33 @@ impl Supervisor {
                     out.skipped += 1;
                     continue;
                 }
+                if let EntryKind::Literal(text) = &entry.kind
+                    && text.len() > MAX_COMMAND_LEN
+                {
+                    out.skipped += 1;
+                    continue;
+                }
+                if entry.stopped {
+                    let (command, harness, resume) = match &entry.kind {
+                        EntryKind::Literal(text) => (text.clone(), None, None),
+                        EntryKind::Managed { agent, resume } => match harness::registered(agent) {
+                            Some(h) => (h.shape().0.to_string(), Some(h), resume.clone()),
+                            None => {
+                                out.failed += 1;
+                                out.notes.push(format!("no agent named {agent:?}"));
+                                continue;
+                            }
+                        },
+                    };
+                    let mut task =
+                        Task::stopped(self.next_id, command, resolved.clone(), harness, resume);
+                    task.tagged = entry.tagged;
+                    self.enroll(task, entry.group.clone(), entry.name.clone());
+                    out.stopped += 1;
+                    continue;
+                }
                 let kind = match &entry.kind {
-                    EntryKind::Literal(text) => {
-                        if text.len() > MAX_COMMAND_LEN {
-                            out.skipped += 1;
-                            continue;
-                        }
-                        Launch::Literal(text)
-                    }
+                    EntryKind::Literal(text) => Launch::Literal(text),
                     EntryKind::Managed { agent, resume } => {
                         match resolve_agent(agent, &launch, resume.clone()) {
                             Ok(m) => Launch::Managed(m),
@@ -1223,7 +1348,7 @@ impl Supervisor {
         };
         // Report zero tasks only for an empty recipe.
         let mut parts = Vec::new();
-        if out.spawned > 0 || (out.skipped == 0 && out.failed == 0) {
+        if out.spawned > 0 || (out.stopped == 0 && out.skipped == 0 && out.failed == 0) {
             parts.push(format!("{} task(s)", out.spawned));
         }
         parts.extend(out.clauses());
diff --git a/src/supervisor_capture_tests.rs b/src/supervisor_capture_tests.rs
index 7fbca5e..a42754b 100644
--- a/src/supervisor_capture_tests.rs
+++ b/src/supervisor_capture_tests.rs
@@ -101,7 +101,11 @@ fn install_status_record(home: &Path, pid: u32, cwd: &Path, status: &str) {
 fn stamped(task: &Task, json: &str) -> String {
     format!(
         "{}\n{json}\n",
-        task.pid().expect("a spawned task has a pid")
+        task.process
+            .as_ref()
+            .unwrap()
+            .pid()
+            .expect("a spawned task has a pid")
     )
 }
 
@@ -238,7 +242,13 @@ fn spawn_claude_pins_an_id_and_layers_settings() {
     );
 
     let t = &s.tasks[0];
-    let cap = t.capture_file.clone().expect("capture file set");
+    let cap = t
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     // An explicit runtime directory is used without a discriminator;
     // capture files sit in this incarnation's `<pid>-<nonce>` namespace
     // directly under it.
@@ -284,7 +294,7 @@ fn spawn_non_agent_command_is_not_instrumented() {
     spawn(&mut s, "printf ok", dir.to_path_buf());
     let t = &s.tasks[0];
     assert!(t.harness.is_none());
-    assert!(t.capture_file.is_none());
+    assert!(t.process.as_ref().unwrap().capture_file.is_none());
     assert!(t.resume_id.is_none());
     assert!(
         s.capture.is_empty(),
@@ -328,7 +338,7 @@ fn typed_agent_word_is_literal_runs_verbatim_and_saves_as_text() {
     );
     let t = &s.tasks[0];
     assert!(t.harness.is_none(), "a literal task has no harness channel");
-    assert!(t.capture_file.is_none());
+    assert!(t.process.as_ref().unwrap().capture_file.is_none());
     assert!(t.resume_id.is_none());
     assert_eq!(t.command, "claude");
     assert!(
@@ -340,12 +350,20 @@ fn typed_agent_word_is_literal_runs_verbatim_and_saves_as_text() {
         "no assets are installed for a literal"
     );
     assert!(!runtime.exists());
-    let pid = t.pid().expect("a spawned task has a pid");
+    let pid = t
+        .process
+        .as_ref()
+        .unwrap()
+        .pid()
+        .expect("a spawned task has a pid");
 
     // Install a namespace by launching a managed sibling. Write a capture for task 1 there,
     // stamped with task 1's leader PID, and create a registry record keyed to that PID.
     s.spawn_agent("claude", &dir, None);
     let ns = s.tasks[1]
+        .process
+        .as_ref()
+        .unwrap()
         .capture_file
         .as_deref()
         .and_then(Path::parent)
@@ -363,8 +381,17 @@ fn typed_agent_word_is_literal_runs_verbatim_and_saves_as_text() {
         r#""status":"waiting","waitingFor":"permission prompt""#,
     );
     assert_eq!(s.tasks[0].current_resume_id(), None);
+    // Save the entry as stopped after the stub exits.
+    let exited = s.tasks[0].id;
+    wait_exited(&mut s, exited);
     let entries = saved_entries(&mut s, &config, "typed");
-    assert_eq!(entries[0], SessionEntry::literal("claude"));
+    assert_eq!(
+        entries[0],
+        SessionEntry {
+            stopped: true,
+            ..SessionEntry::literal("claude")
+        }
+    );
     assert!(matches!(
         &entries[1].kind,
         EntryKind::Managed { agent, resume: Some(_) } if agent == "claude"
@@ -392,7 +419,13 @@ fn rerun_cannot_read_the_old_runs_stale_capture() {
     s.spawn_agent("claude", &dir, None);
     let id = s.tasks[0].id;
     // The old run's final capture becomes the new run's launch ID.
-    let old_cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let old_cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     std::fs::write(
         &old_cap,
         stamped(&s.tasks[0], &format!(r#"{{"session_id":"{CAP_ID}"}}"#)),
@@ -401,7 +434,13 @@ fn rerun_cannot_read_the_old_runs_stale_capture() {
     wait_exited(&mut s, id);
 
     s.apply(Command::Restart { id });
-    let new_cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let new_cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     assert_ne!(new_cap, old_cap, "the fresh run needs its own capture file");
     assert_eq!(s.tasks[0].resume_id.as_deref(), Some(CAP_ID));
     assert!(
@@ -429,7 +468,13 @@ fn reconnect_with_unchanged_root_preserves_capture_files() {
     install_stub(&bin, "claude", &dir);
     let mut s = sup_ctx(agent_ctx(&bin, &runtime, dir.to_path_buf()));
     s.spawn_agent("claude", &dir, None);
-    let cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     std::fs::write(&cap, "{}").unwrap();
 
     // The client reconnects with an identical env and spawns again.
@@ -450,7 +495,13 @@ fn returning_to_a_prior_root_preserves_its_live_captures() {
     install_stub(&bin, "claude", &dir);
     let mut s = sup_ctx(agent_ctx(&bin, &root_a, dir.to_path_buf()));
     s.spawn_agent("claude", &dir, None);
-    let cap_a = s.tasks[0].capture_file.clone().expect("capture file set");
+    let cap_a = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     std::fs::write(&cap_a, "{}").unwrap();
 
     // The client reconnects under root B, spawns, then returns to A and
@@ -466,6 +517,9 @@ fn returning_to_a_prior_root_preserves_its_live_captures() {
         "returning to a known root must not disturb its live captures"
     );
     let ns_b = s.tasks[1]
+        .process
+        .as_ref()
+        .unwrap()
         .capture_file
         .as_deref()
         .and_then(|c| c.parent())
@@ -489,7 +543,13 @@ fn remove_deletes_the_capture_file_under_the_spawn_root() {
     let _ = wait_argv(&mut s, &dir.join("argv"));
     let id = s.tasks[0].id;
     wait_for_lifecycle(&mut s, id, |l| l == Lifecycle::Ok);
-    let cap = s.tasks[0].capture_file.clone().unwrap();
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .unwrap();
     std::fs::write(&cap, "{}").unwrap();
 
     // Root B is installed by a newer spawn; a same-id file under it must
@@ -497,6 +557,9 @@ fn remove_deletes_the_capture_file_under_the_spawn_root() {
     s.set_launch_context(agent_ctx(&bin, &root_b, dir.to_path_buf()));
     s.spawn_agent("claude", &dir, None);
     let decoy = s.tasks[1]
+        .process
+        .as_ref()
+        .unwrap()
         .capture_file
         .as_deref()
         .and_then(|c| c.parent())
@@ -560,7 +623,7 @@ fn spawn_codex_installs_the_notify_and_embedded_overrides() {
     let t = &s.tasks[0];
     assert_eq!(t.command, "codex");
     assert!(t.resume_id.is_none(), "codex cannot pin an id at launch");
-    assert!(t.capture_file.is_some());
+    assert!(t.process.as_ref().unwrap().capture_file.is_some());
 }
 
 /// A `grok` spawn receives exactly the pinned ID: no settings overlay,
@@ -604,9 +667,15 @@ fn spawn_grok_pins_an_id_and_injects_nothing_else() {
     );
     assert_eq!(t.resume_id.as_deref(), Some(id.as_str()));
 
+    // Save the entry as stopped after the stub exits.
+    let exited = s.tasks[0].id;
+    wait_exited(&mut s, exited);
     assert_eq!(
         saved_entries(&mut s, &config, "grokpin"),
-        [SessionEntry::managed("grok", Some(&id))],
+        [SessionEntry {
+            stopped: true,
+            ..SessionEntry::managed("grok", Some(&id))
+        }],
         "the recipe must resume the pinned session"
     );
 }
@@ -634,7 +703,13 @@ fn spawn_omp_loads_the_capture_extension() {
         "the module must write to the capture env: {text:?}"
     );
     let t = &s.tasks[0];
-    let cap = t.capture_file.clone().expect("capture file set");
+    let cap = t
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     assert_eq!(
         module.parent(),
         cap.parent(),
@@ -703,7 +778,13 @@ fn printed_resume_hints_do_not_change_saved_recovery_or_rerun_targets() {
         let expected_id = match tool {
             "claude" => {
                 std::fs::write(
-                    s.tasks[0].capture_file.as_ref().unwrap(),
+                    s.tasks[0]
+                        .process
+                        .as_ref()
+                        .unwrap()
+                        .capture_file
+                        .as_ref()
+                        .unwrap(),
                     stamped(&s.tasks[0], &format!(r#"{{"session_id":"{CAP_OTHER}"}}"#)),
                 )
                 .unwrap();
@@ -715,7 +796,8 @@ fn printed_resume_hints_do_not_change_saved_recovery_or_rerun_targets() {
         assert_ne!(expected_id.as_deref(), Some(CAP_ID));
         assert!(
             reap_until(&mut s, Duration::from_secs(5), |s| {
-                s.tasks[0].finished.is_some() && s.tasks[0].reader_done()
+                s.tasks[0].process.as_ref().unwrap().finished.is_some()
+                    && s.tasks[0].process.as_ref().unwrap().reader_done()
             }),
             "{tool}: output never completed"
         );
@@ -723,6 +805,9 @@ fn printed_resume_hints_do_not_change_saved_recovery_or_rerun_targets() {
         s.reap();
         assert!(
             s.tasks[0]
+                .process
+                .as_ref()
+                .unwrap()
                 .screen_lines()
                 .iter()
                 .any(|line| line.contains(CAP_ID)),
@@ -733,6 +818,7 @@ fn printed_resume_hints_do_not_change_saved_recovery_or_rerun_targets() {
             vec![SessionEntry {
                 group: Some("agents".into()),
                 name: Some(tool.into()),
+                stopped: true,
                 ..SessionEntry::managed(tool, expected_id.as_deref())
             }],
         )]);
@@ -785,7 +871,7 @@ fn rerun_latches_exit_without_reap_and_preserves_the_launch_id() {
     assert!(s.tasks[0].harness.is_some());
     assert_eq!(s.tasks[0].resume_id.as_deref(), Some(CAP_OTHER));
     let id = s.tasks[0].id;
-    let pid = Pid::from_raw(s.tasks[0].pid().unwrap() as i32).unwrap();
+    let pid = Pid::from_raw(s.tasks[0].process.as_ref().unwrap().pid().unwrap() as i32).unwrap();
     assert!(
         wait_until(Duration::from_secs(5), || {
             let exited = waitid(
@@ -794,12 +880,12 @@ fn rerun_latches_exit_without_reap_and_preserves_the_launch_id() {
             )
             .unwrap()
             .is_some();
-            exited && s.tasks[0].reader_done()
+            exited && s.tasks[0].process.as_ref().unwrap().reader_done()
         }),
         "the stub never exited and drained its output"
     );
     assert!(
-        s.tasks[0].finished.is_none(),
+        s.tasks[0].process.as_ref().unwrap().finished.is_none(),
         "no exit latch may have run yet"
     );
     std::fs::remove_file(dir.join("argv")).unwrap();
@@ -842,7 +928,12 @@ fn resume_id_precedence_registry_over_spawn_under_capture() {
         .expect("a fresh claude launch pins an id");
     assert_ne!(injected.as_str(), CAP_ID);
     // Key the registry fixture to the spawned task.
-    let pid = s.tasks[0].pid().expect("a live task has a pid");
+    let pid = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .pid()
+        .expect("a live task has a pid");
 
     install_status_record(&claude_home, pid, &dir, r#""status":"idle""#);
     assert_eq!(
@@ -852,7 +943,13 @@ fn resume_id_precedence_registry_over_spawn_under_capture() {
     );
 
     // A capture-file ID outranks the registry ID.
-    let cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     std::fs::write(&cap, stamped(&s.tasks[0], &hook_json(CAP_OTHER, "clear"))).unwrap();
     assert_eq!(
         saved_resume(&mut s, &config, "capture").as_deref(),
@@ -903,8 +1000,19 @@ until [ -e '{d}/done' ]; do sleep 0.05; done"#,
         .resume_id
         .clone()
         .expect("a fresh claude launch pins an id");
-    let pid = s.tasks[0].pid().expect("a live task has a pid");
-    let cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let pid = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .pid()
+        .expect("a live task has a pid");
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
 
     // The foreign stage runs the hook command from the installed overlay.
     let overlay = std::fs::read_to_string(cap.with_file_name("claude-settings.json")).unwrap();
@@ -1006,13 +1114,16 @@ fn silent_codex_tasks_save_and_recover_without_a_resume_id() {
     assert!(reap_until(&mut s, Duration::from_secs(5), |s| s
         .tasks
         .iter()
-        .all(|t| t.finished.is_some())));
+        .all(|t| t.process.as_ref().unwrap().finished.is_some())));
     for task in &s.tasks {
         assert!(
             task.current_resume_id().is_none(),
             "no capture channel fired"
         );
         let spawn_ms = task
+            .process
+            .as_ref()
+            .unwrap()
             .spawned_at
             .duration_since(std::time::SystemTime::UNIX_EPOCH)
             .unwrap()
@@ -1025,8 +1136,14 @@ fn silent_codex_tasks_save_and_recover_without_a_resume_id() {
     let expected = SessionConfig::from([(
         path::abbreviate(&dir),
         vec![
-            SessionEntry::managed("codex", None),
-            SessionEntry::managed("codex", None),
+            SessionEntry {
+                stopped: true,
+                ..SessionEntry::managed("codex", None)
+            },
+            SessionEntry {
+                stopped: true,
+                ..SessionEntry::managed("codex", None)
+            },
         ],
     )]);
     save_and_read(&mut s, &config, "silent");
@@ -1055,7 +1172,13 @@ fn title_turn() -> String {
 /// `codex_home` as the environment. Return the written root, as for a binary invocation
 /// from the injected script.
 fn arrive(s: &Supervisor, codex_home: &Path, payload: &str) -> Option<String> {
-    let cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     crate::harness::record_arrival(payload, &|key| match key {
         crate::harness::CAPTURE_ENV => Some(cap.clone()),
         "CODEX_HOME" => Some(codex_home.to_path_buf()),
@@ -1250,7 +1373,7 @@ fn home_only_launch_env_targets_the_clients_dot_codex() {
     ));
     s.spawn_agent("codex", &dir, None);
     assert_eq!(
-        s.tasks[0].harness_home.as_deref(),
+        s.tasks[0].process.as_ref().unwrap().harness_home.as_deref(),
         Some(codex_home.as_path()),
         "HOME alone must resolve the harness home"
     );
@@ -1265,7 +1388,10 @@ fn home_only_launch_env_targets_the_clients_dot_codex() {
 
     assert_eq!(
         saved_entries(&mut s, &config, "homeonly"),
-        [SessionEntry::managed("codex", None)]
+        [SessionEntry {
+            stopped: true,
+            ..SessionEntry::managed("codex", None)
+        }]
     );
 }
 
@@ -1310,7 +1436,13 @@ fn stale_inherited_notify_chain_is_never_executed() {
     s.spawn_agent("codex", &dir, None);
     let id = s.tasks[0].id;
     wait_exited(&mut s, id);
-    let cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     assert_eq!(
         std::fs::read_to_string(&cap).unwrap(),
         CAP_ID,
@@ -1421,7 +1553,13 @@ fn config_toml_notify_chains_through_the_injected_script() {
         format!("{}\nturn-ended", notifier.display()),
         "the child env must carry the displaced argv, newline-joined"
     );
-    let cap = s.tasks[0].capture_file.clone().unwrap();
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .unwrap();
     assert_eq!(
         std::fs::read_to_string(&cap).unwrap(),
         CAP_ID,
@@ -1541,7 +1679,13 @@ fn recovery_cadence_rewrites_on_capture_drift_and_skips_when_static() {
     assert!(!snapshot(&rec).unwrap().1.contains(CAP_OTHER));
 
     // Change the capture ID without a recipe mutation.
-    let cap = s.tasks[0].capture_file.clone().expect("capture file set");
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .expect("capture file set");
     std::fs::write(&cap, stamped(&s.tasks[0], &hook_json(CAP_OTHER, "clear"))).unwrap();
     assert!(
         wait_until(Duration::from_secs(5), || {
@@ -1571,6 +1715,9 @@ fn recovery_cadence_rewrites_on_capture_drift_and_skips_when_static() {
 /// The settings overlay beside the sole task's capture file.
 fn settings_beside(s: &Supervisor) -> String {
     s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
         .capture_file
         .as_deref()
         .and_then(Path::parent)
@@ -1625,7 +1772,13 @@ fn managed_claude_accepts_its_own_capture_and_refuses_a_foreign_stamp() {
     );
 
     // Reject the same payload when stamped with another process's PID.
-    let cap = s.tasks[0].capture_file.clone().unwrap();
+    let cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .unwrap();
     let text = std::fs::read_to_string(&cap).unwrap();
     let (_, json) = text.split_once('\n').unwrap();
     std::fs::write(&cap, format!("{}\n{json}", dead_pid())).unwrap();
@@ -1684,13 +1837,25 @@ fn managed_rerun_resumes_the_captured_id_from_the_binary_path_finds_now() {
     s.tasks[0].name = Some("pilot".into());
     wait_for_lifecycle(&mut s, id, |l| l == Lifecycle::Ok);
     std::fs::write(
-        s.tasks[0].capture_file.as_ref().unwrap(),
+        s.tasks[0]
+            .process
+            .as_ref()
+            .unwrap()
+            .capture_file
+            .as_ref()
+            .unwrap(),
         stamped(&s.tasks[0], &hook_json(CAP_OTHER, "clear")),
     )
     .unwrap();
     std::fs::remove_file(dir.join("argv")).unwrap();
 
-    let old_cap = s.tasks[0].capture_file.clone().unwrap();
+    let old_cap = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .capture_file
+        .clone()
+        .unwrap();
     s.apply(Command::Restart { id });
     let argv = wait_argv(&mut s, &dir.join("argv"));
     assert_eq!(
@@ -1787,8 +1952,16 @@ fn managed_task_saves_as_a_managed_entry_and_reloads_managed() {
     wait_argv(&mut s, &omp_out.join("argv"));
     let claude = s.tasks[0].id;
     wait_for_lifecycle(&mut s, claude, |l| l == Lifecycle::Ok);
+    let omp = s.tasks[1].id;
+    wait_exited(&mut s, omp);
     std::fs::write(
-        s.tasks[0].capture_file.as_ref().unwrap(),
+        s.tasks[0]
+            .process
+            .as_ref()
+            .unwrap()
+            .capture_file
+            .as_ref()
+            .unwrap(),
         stamped(&s.tasks[0], &format!(r#"{{"session_id":"{CAP_ID}"}}"#)),
     )
     .unwrap();
@@ -1801,17 +1974,28 @@ fn managed_task_saves_as_a_managed_entry_and_reloads_managed() {
             vec![
                 SessionEntry {
                     group: Some("agents".into()),
+                    stopped: true,
                     ..SessionEntry::managed("claude", Some(CAP_ID))
                 },
-                SessionEntry::managed("omp", None),
+                SessionEntry {
+                    stopped: true,
+                    ..SessionEntry::managed("omp", None)
+                },
             ]
         )])
     );
 
+    // Both stubs exited before the save. Clear their stopped flags in a copy of
+    // the recipe, then load that copy to verify the relaunch argv.
+    let mut live = session::load_in(&config.join("sessions"), "managed").unwrap();
+    for entry in live.values_mut().flatten() {
+        entry.stopped = false;
+    }
+    session::save_in(&config.join("sessions"), "managed-live", &live).unwrap();
     std::fs::remove_file(claude_out.join("argv")).unwrap();
     std::fs::remove_file(omp_out.join("argv")).unwrap();
     s.apply(Command::LoadSession {
-        name: "managed".into(),
+        name: "managed-live".into(),
     });
     assert_eq!(s.tasks.len(), 4, "{:?}", notices(s.drain()));
     let reloaded = &s.tasks[2];
@@ -1929,7 +2113,17 @@ fn managed_codex_reports_the_capture_notice_and_leads_a_rerun_with_resume() {
     wait_for_lifecycle(&mut s, id, |l| l == Lifecycle::Ok);
 
     // The v1 slot holds one bare root UUID.
-    std::fs::write(s.tasks[0].capture_file.as_ref().unwrap(), CAP_ID).unwrap();
+    std::fs::write(
+        s.tasks[0]
+            .process
+            .as_ref()
+            .unwrap()
+            .capture_file
+            .as_ref()
+            .unwrap(),
+        CAP_ID,
+    )
+    .unwrap();
     std::fs::remove_file(dir.join("argv")).unwrap();
     s.apply(Command::Restart { id });
     assert_sole_notice(s.drain(), "capture unavailable");
@@ -1980,7 +2174,12 @@ fn registry_waiting_status_reaches_the_dashboard_preview() {
     ));
     s.spawn_agent("claude", &dir, None);
     // Key the record to the task's leader PID.
-    let pid = s.tasks[0].pid().expect("a live task has a pid");
+    let pid = s.tasks[0]
+        .process
+        .as_ref()
+        .unwrap()
+        .pid()
+        .expect("a live task has a pid");
 
     // A non-waiting status must not anchor the preview.
     install_status_record(&claude_home, pid, &dir, r#""status":"idle""#);
diff --git a/src/supervisor_tests.rs b/src/supervisor_tests.rs
index dbecd2b..d2b8f5d 100644
--- a/src/supervisor_tests.rs
+++ b/src/supervisor_tests.rs
@@ -7,7 +7,7 @@ use nix::{
 
 use super::*;
 use crate::{
-    protocol::{ClipboardKind, FLEETCOM_RUNTIME_DIR, Key, Lifecycle, Mods},
+    protocol::{ClipboardKind, FLEETCOM_RUNTIME_DIR, Key, Lifecycle, Mods, Preview},
     testutil::{
         Scratch, here, install_fake_notifier, now_ms, read_pid, screen, sh_env, wait_until,
         write_executable,
@@ -516,7 +516,7 @@ fn ticks_without_copies(s: &mut Supervisor, why: &str) -> bool {
 /// Search the first task's formatted grid for `marker`.
 fn grid_shows(s: &Supervisor, marker: &str) -> bool {
     s.tasks.first().is_some_and(|t| {
-        let (formatted, _, _) = t.formatted();
+        let (formatted, _, _) = t.process.as_ref().unwrap().formatted();
         String::from_utf8_lossy(&formatted).contains(marker)
     })
 }
@@ -536,7 +536,7 @@ fn scrolled_task() -> (Supervisor, u64) {
             id,
             action: ScrollAction::Up(3),
         });
-        s.tasks[0].scroll_offset() > 0
+        s.tasks[0].process.as_ref().unwrap().scroll_offset() > 0
     });
     assert!(scrolled, "the task never accrued scrollback");
     (s, id)
@@ -742,7 +742,7 @@ fn clear_watch_snaps_the_watched_task_live() {
     let (mut s, _) = scrolled_task();
     s.clear_watch();
     assert_eq!(
-        s.tasks[0].scroll_offset(),
+        s.tasks[0].process.as_ref().unwrap().scroll_offset(),
         0,
         "disconnect must return the watched task's viewport to live"
     );
@@ -875,7 +875,11 @@ fn kill_with_an_unknown_id_leaves_the_live_task_alone() {
     s.apply(Command::Kill { id: 999 });
     assert!(s.drain().is_empty(), "unknown-id Kill must stay silent");
     assert!(
-        !s.tasks[0].overdue(Instant::now(), Duration::ZERO),
+        !s.tasks[0]
+            .process
+            .as_ref()
+            .unwrap()
+            .overdue(Instant::now(), Duration::ZERO),
         "unknown-id Kill must not signal the live task"
     );
     assert_eq!(view_of(&mut s, id).lifecycle, before);
@@ -902,7 +906,7 @@ fn tag_with_an_unknown_id_leaves_the_live_task_alone() {
 #[test]
 fn scrollback_with_an_unknown_id_leaves_the_live_task_alone() {
     let (mut s, _) = scrolled_task();
-    let offset = s.tasks[0].scroll_offset();
+    let offset = s.tasks[0].process.as_ref().unwrap().scroll_offset();
 
     s.apply(Command::Scrollback {
         id: 999,
@@ -913,7 +917,7 @@ fn scrollback_with_an_unknown_id_leaves_the_live_task_alone() {
         "unknown-id Scrollback must stay silent"
     );
     assert_eq!(
-        s.tasks[0].scroll_offset(),
+        s.tasks[0].process.as_ref().unwrap().scroll_offset(),
         offset,
         "unknown-id Scrollback must not snap the live task's viewport"
     );
@@ -1160,7 +1164,9 @@ fn reap_until(
 fn wait_exited(s: &mut Supervisor, id: u64) {
     assert!(
         reap_until(s, Duration::from_secs(5), |s| {
-            s.tasks.iter().all(|t| t.id != id || t.finished.is_some())
+            s.tasks
+                .iter()
+                .all(|t| t.id != id || t.process.as_ref().unwrap().finished.is_some())
         }),
         "task {id} never exited"
     );
@@ -1240,7 +1246,7 @@ fn rerun_sweeps_stragglers_of_the_old_run() {
         "rerun never swept the old run's straggler"
     );
     // The fresh run exists under the same id; its own straggler dies with
-    // the supervisor (Task::drop backstop).
+    // the supervisor (Process::drop backstop).
     assert!(s.tasks.iter().any(|t| t.id == id));
 }
 
@@ -1342,7 +1348,10 @@ fn shutdown_waits_the_grace_when_every_task_has_finished() {
         spawn(&mut s, "true", here());
     }
     assert!(reap_until(&mut s, Duration::from_secs(5), |s| {
-        s.tasks.len() == 2 && s.tasks.iter().all(|t| t.finished.is_some())
+        s.tasks.len() == 2
+            && s.tasks
+                .iter()
+                .all(|t| t.process.as_ref().unwrap().finished.is_some())
     }));
     let t0 = Instant::now();
     s.apply(Command::Shutdown);
@@ -1774,7 +1783,7 @@ fn key_command_encodes_against_live_cursor_mode() {
         s.tasks
             .iter()
             .find(|t| t.id == id)
-            .is_some_and(|t| t.input_hints().1)
+            .is_some_and(|t| t.process.as_ref().unwrap().input_hints().1)
     };
     assert!(
         wait_until(Duration::from_secs(5), || app_cursor_on(&s)),
@@ -2331,6 +2340,287 @@ fn load_applies_marks_and_a_live_flagship_wins() {
     );
 }
 
+/// Save `entries` for `dir` as `name` under `config`, load the recipe, and return the
+/// drained events.
+fn load_entries(
+    s: &mut Supervisor,
+    config: &Path,
+    name: &str,
+    dir: &Path,
+    entries: Vec<SessionEntry>,
+) -> Vec<Event> {
+    let cfg = SessionConfig::from([(dir.to_string_lossy().into_owned(), entries)]);
+    session::save_in(&config.join("sessions"), name, &cfg).unwrap();
+    s.apply(Command::LoadSession { name: name.into() });
+    s.drain()
+}
+
+/// A stopped literal entry.
+fn stopped(cmd: &str) -> SessionEntry {
+    SessionEntry {
+        stopped: true,
+        ..SessionEntry::literal(cmd)
+    }
+}
+
+/// Whether `events` contains a status line equal to `msg`.
+fn has_status(events: &[Event], msg: &str) -> bool {
+    events
+        .iter()
+        .any(|e| matches!(e, Event::Status(m) if m == msg))
+}
+
+/// Load a stopped literal beside a live one. Restore the stopped entry without a
+/// process or ages, with an empty frozen preview, and count it separately from
+/// the spawned task. Start it with `r` under the same ID, with no old run to retire.
+#[test]
+fn load_restores_stopped_entries_as_rows_and_rerun_starts_them() {
+    let dir = scratch("load_stopped");
+    let config = dir.join("config");
+    let mut s = sup_ctx(config_ctx(&config, dir.to_path_buf(), &[]));
+    let evs = load_entries(
+        &mut s,
+        &config,
+        "parked",
+        &dir,
+        vec![stopped("sleep 30"), SessionEntry::literal("sleep 31")],
+    );
+    assert!(
+        has_status(&evs, "loaded 'parked': 1 task(s), 1 stopped"),
+        "{evs:?}"
+    );
+    assert_eq!(s.tasks.len(), 2);
+    let views = snapshot(&mut s);
+    let (parked, live) = (&views[0], &views[1]);
+    assert_eq!(parked.command, "sleep 30");
+    assert_eq!(parked.lifecycle, Lifecycle::Stopped);
+    assert_eq!(
+        (parked.started_ago, parked.quiet_ago, parked.finished_ago),
+        (None, None, None)
+    );
+    assert_eq!(
+        parked.preview,
+        Preview {
+            frozen: true,
+            ..Preview::floor(String::new())
+        }
+    );
+    assert_eq!(live.lifecycle, Lifecycle::Active);
+    assert!(live.started_ago.is_some());
+
+    let id = parked.id;
+    s.apply(Command::Restart { id });
+    let v = view_of(&mut s, id);
+    assert_ne!(v.lifecycle, Lifecycle::Stopped);
+    assert!(v.started_ago.is_some());
+    assert_eq!(s.tasks.len(), 2, "rerun keeps the row");
+    assert!(s.graveyard.is_empty(), "a stopped row has no run to retire");
+}
+
+/// Ignore `Kill` on a stopped row, which has no run to retire; drop it on `Remove`.
+#[test]
+fn stopped_row_ignores_kill_and_removes_cleanly() {
+    let dir = scratch("stopped_kill");
+    let config = dir.join("config");
+    let mut s = sup_ctx(config_ctx(&config, dir.to_path_buf(), &[]));
+    load_entries(&mut s, &config, "one", &dir, vec![stopped("sleep 30")]);
+    let id = first_id(&mut s);
+
+    s.apply(Command::Kill { id });
+    assert_eq!(view_of(&mut s, id).lifecycle, Lifecycle::Stopped);
+    assert!(s.graveyard.is_empty());
+
+    s.apply(Command::Remove { id });
+    assert!(snapshot(&mut s).is_empty());
+    assert!(s.graveyard.is_empty());
+}
+
+/// Count stopped rows against the task ceiling on load and subsequent spawns:
+/// enforce the limit on the full list.
+#[test]
+fn stopped_rows_count_against_the_task_ceiling() {
+    let dir = scratch("stopped_ceiling");
+    let config = dir.join("config");
+    let mut s = sup_ctx(config_ctx(&config, dir.to_path_buf(), &[]));
+    s.set_max_tasks(1);
+    let evs = load_entries(
+        &mut s,
+        &config,
+        "cap",
+        &dir,
+        vec![stopped("sleep 30"), stopped("sleep 31")],
+    );
+    assert!(
+        has_status(
+            &evs,
+            "loaded 'cap': 1 stopped, 1 skipped (missing dir, task limit, or command too long)"
+        ),
+        "{evs:?}"
+    );
+    assert_eq!(s.tasks.len(), 1);
+
+    spawn(&mut s, "sleep 32", dir.to_path_buf());
+    assert!(
+        has_status(&s.drain(), "task limit reached (1), not spawning"),
+        "a stopped row must hold the ceiling"
+    );
+}
+
+/// Mark finished and restored tasks stopped in the recipe; leave live tasks unmarked.
+#[test]
+fn session_config_marks_tasks_without_a_live_process_stopped() {
+    let dir = scratch("stopped_cfg");
+    let config = dir.join("config");
+    let mut s = sup_ctx(config_ctx(&config, dir.to_path_buf(), &[]));
+    spawn(&mut s, "true", dir.to_path_buf());
+    spawn(&mut s, "sleep 30", dir.to_path_buf());
+    load_entries(&mut s, &config, "one", &dir, vec![stopped("sleep 31")]);
+    wait_exited(&mut s, 1);
+
+    let mut entries: Vec<(String, bool)> = s
+        .session_config()
+        .into_values()
+        .flatten()
+        .map(|e| match e.kind {
+            EntryKind::Literal(cmd) => (cmd, e.stopped),
+            EntryKind::Managed { .. } => unreachable!("every task here is literal"),
+        })
+        .collect();
+    entries.sort();
+    assert_eq!(
+        entries,
+        [
+            ("sleep 30".to_string(), false),
+            ("sleep 31".to_string(), true),
+            ("true".to_string(), true),
+        ]
+    );
+}
+
+/// Schedule recovery when latching an exit in `reap`, and only on that pass:
+/// update the entry's `stopped` flag after exit, not when applying `Kill`.
+#[test]
+fn reap_arms_recovery_on_the_exit_transition_only() {
+    let mut s = sup(24, 80);
+    spawn(&mut s, "sleep 30", here());
+    let id = first_id(&mut s);
+    s.recovery.last_mutation = None; // Reset after the spawn and the tick in first_id.
+    s.reap();
+    assert!(!take_dirty(&mut s), "a reap with no exit must not arm");
+
+    s.apply(Command::Kill { id });
+    assert!(!take_dirty(&mut s), "Kill itself does not arm");
+    wait_exited(&mut s, id);
+    assert!(
+        take_dirty(&mut s),
+        "the reap that latches the exit must arm"
+    );
+    s.reap();
+    assert!(!take_dirty(&mut s), "a later reap sees no transition");
+}
+
+/// Rewrite the recovery snapshot with `"stopped": true` after an exit, on the
+/// debounce alone: use a cadence far beyond the test's budget.
+#[test]
+fn recovery_snapshot_marks_an_exited_task_stopped() {
+    let dir = scratch("recovery_stopped");
+    let config = dir.join("config");
+    let mut s = recovery_sup(
+        &config,
+        dir.to_path_buf(),
+        Duration::from_millis(100),
+        Duration::from_secs(600),
+    );
+    spawn(&mut s, "sleep 30", dir.to_path_buf());
+    let id = first_id(&mut s);
+    assert!(
+        wait_until(Duration::from_secs(5), || {
+            s.tick();
+            recovery_files(&config).len() == 1
+        }),
+        "the spawn snapshot never landed"
+    );
+    assert!(!recovery_text(&config).contains("\"stopped\": true"));
+
+    s.apply(Command::Kill { id });
+    wait_exited(&mut s, id);
+    assert!(
+        wait_until(Duration::from_secs(5), || {
+            s.tick();
+            recovery_text(&config).contains("\"stopped\": true")
+        }),
+        "the exit never reached the snapshot: {}",
+        recovery_text(&config)
+    );
+}
+
+/// Send an empty screen when watching a stopped task; allow the watch request.
+#[test]
+fn watching_a_stopped_task_yields_an_empty_screen() {
+    let dir = scratch("stopped_watch");
+    let config = dir.join("config");
+    let mut s = sup_ctx(config_ctx(&config, dir.to_path_buf(), &[]));
+    load_entries(&mut s, &config, "one", &dir, vec![stopped("sleep 30")]);
+    let id = first_id(&mut s);
+    watch(&mut s, id);
+    s.tick();
+    let screen = s
+        .drain()
+        .into_iter()
+        .find_map(|e| match e {
+            Event::Screen(v) => Some(v),
+            _ => None,
+        })
+        .expect("a Screen for the watched stopped task");
+    assert_eq!(
+        screen,
+        ScreenView {
+            id,
+            lines: Vec::new(),
+            formatted: Vec::new(),
+            cursor: (0, 0),
+            hide_cursor: true,
+            wants_mouse: false,
+            alt_screen: false,
+            alt_scroll: false,
+            scrollback: 0,
+        }
+    );
+}
+
+/// Load a stopped managed entry without its binary on `PATH`: restore the row as
+/// stopped. At rerun, refuse to start without the binary and preserve the stopped row.
+#[test]
+fn stopped_managed_entry_loads_without_its_binary() {
+    let dir = scratch("stopped_managed");
+    let config = dir.join("config");
+    let mut s = sup_ctx(config_ctx(&config, dir.to_path_buf(), &[("PATH", "")]));
+    let evs = load_entries(
+        &mut s,
+        &config,
+        "agent",
+        &dir,
+        vec![SessionEntry {
+            stopped: true,
+            ..SessionEntry::managed("claude", None)
+        }],
+    );
+    assert!(has_status(&evs, "loaded 'agent': 1 stopped"), "{evs:?}");
+    let v = snapshot(&mut s).remove(0);
+    assert!(v.managed);
+    assert_eq!(v.command, "claude");
+    assert_eq!(v.lifecycle, Lifecycle::Stopped);
+    assert!(s.tasks[0].harness.is_some());
+
+    s.apply(Command::Restart { id: v.id });
+    let evs = s.drain();
+    assert!(
+        has_status(&evs, "claude not found on PATH, not spawning"),
+        "{evs:?}"
+    );
+    assert_eq!(view_of(&mut s, v.id).lifecycle, Lifecycle::Stopped);
+}
+
 /// Rewrite the recovery snapshot with the tag after the debounce interval.
 #[test]
 fn recovery_snapshot_carries_a_tag() {
diff --git a/src/task.rs b/src/task.rs
index f4eff93..e43af1f 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -62,12 +62,45 @@ pub fn positive_pid(field: &str) -> Option<i32> {
     field.parse::<i32>().ok().filter(|p| *p > 0)
 }
 
+/// A dashboard row's identity and optional [`Process`] for its current run.
+/// On rerun, preserve the row's identity and replace `process` as a unit:
+/// the PTY, preview state, and exit latch all belong to one launch.
 pub struct Task {
     pub id: u64,
     pub command: String,
     /// Working directory the command was launched in: the grouping key for
     /// "by dir" mode and the label shown when it differs from the default.
     pub cwd: PathBuf,
+    pub tagged: bool,
+    /// Dashboard group stored with the task; `None` means unassigned.
+    pub group: Option<String>,
+    /// Custom display name; `None` means unnamed.
+    pub name: Option<String>,
+    /// Harness for a managed task's session ID and blocked-status reads. Build the
+    /// argv through this harness on launch and rerun, with no intervening shell.
+    /// `None` for literal tasks: never read a harness channel for those tasks or
+    /// edit their command text.
+    pub harness: Option<&'static dyn crate::harness::Harness>,
+    /// Display-only summary adapter selected from the command's first word,
+    /// for literal and managed tasks alike.
+    pub summary_adapter: Option<&'static dyn crate::preview::SummaryAdapter>,
+    /// Run number used to give each rerun a distinct capture path.
+    pub run: u32,
+    /// Session ID pinned or resumed at spawn. Prefer a captured ID or matching live
+    /// registry ID when available.
+    pub resume_id: Option<String>,
+    /// The current run, or `None` for a stopped task: restored from a session
+    /// file without starting a process. Press `r` to start it.
+    /// Keep the kill backstop in `Process::drop`, with no `Drop` on `Task`,
+    /// so the run can be moved out and retired independently of the row.
+    pub process: Option<Process>,
+}
+
+/// One run of a task: the PTY, writer queue, reader thread, emulator, the
+/// harness paths resolved at launch, preview state, and exit bookkeeping for a
+/// single process group. On drop, send SIGKILL to the group and attempt to reap
+/// the leader, regardless of how the run left scope.
+pub struct Process {
     /// Keep the PTY master open for `resize` (`TIOCSWINSZ`). Split the reader and
     /// writer handles from it at spawn.
     master: Box<dyn MasterPty + Send>,
@@ -90,30 +123,12 @@ pub struct Task {
     parser: Arc<FairMutex<Emulator>>,
     last_activity: Arc<Mutex<Instant>>,
     handle: Option<JoinHandle<()>>,
-    pub tagged: bool,
-    /// Dashboard group stored with the task; `None` means unassigned.
-    pub group: Option<String>,
-    /// Custom display name; `None` means unnamed.
-    pub name: Option<String>,
-    /// Harness for a managed task's session ID and blocked-status reads: the harness built
-    /// the argv, no shell sits between, and a rerun goes through it again. `None` for
-    /// literal tasks: never read a harness channel for those tasks, and never edit their
-    /// command text.
-    pub harness: Option<&'static dyn crate::harness::Harness>,
     /// Harness home resolved from this run's launch environment.
     pub harness_home: Option<PathBuf>,
-    /// Display-only summary adapter selected from the command's first word,
-    /// for literal and managed tasks alike.
-    pub summary_adapter: Option<&'static dyn crate::preview::SummaryAdapter>,
-    /// Run number used to give each rerun a distinct capture path.
-    pub run: u32,
-    /// Session ID pinned or resumed at spawn. Prefer a captured ID or matching live
-    /// registry ID when available.
-    pub resume_id: Option<String>,
-    /// Capture path allocated for this task run.
+    /// Capture path allocated for this run.
     pub capture_file: Option<PathBuf>,
-    /// Dashboard-preview resolution state; resets with the task on rerun
-    /// because a rerun replaces the whole `Task`.
+    /// Dashboard-preview resolution state for this run. Reset on rerun by
+    /// replacing the whole `Process`.
     preview: PreviewState,
     /// Cached blocked-on-user status from the harness registry.
     blocked: Option<(String, &'static str)>,
@@ -150,7 +165,7 @@ fn signal(waker: &Waker) {
 /// Admit one whole message to a writer queue bounded by `MAX_PENDING_WRITE`,
 /// or refuse it whole. The cap check and the `fetch_add` are separate
 /// operations, so racing admitters can overshoot the cap by one message (see
-/// `Task::pending_write`). A failed send means the worker exited; the
+/// `Process::pending_write`). A failed send means the worker exited; the
 /// compensating `fetch_sub` removes that admission so the count never leaks.
 fn admit_write(
     tx: &Sender<Vec<u8>>,
@@ -231,6 +246,132 @@ impl Task {
         scrollback: usize,
         env: &[(OsString, OsString)],
         waker: &Waker,
+    ) -> io::Result<Self> {
+        let process = Process::spawn(command, exec, cwd, rows, cols, scrollback, env, waker)?;
+        Ok(Self {
+            process: Some(process),
+            ..Self::stopped(id, command.to_string(), cwd.to_path_buf(), None, None)
+        })
+    }
+
+    /// Create a task with no run from a stopped session entry. Press `r` to
+    /// start it. Resolve `harness` by name alone; look up the binary at rerun.
+    /// Use the stored `resume_id` to resume the conversation at that point.
+    pub fn stopped(
+        id: u64,
+        command: String,
+        cwd: PathBuf,
+        harness: Option<&'static dyn crate::harness::Harness>,
+        resume_id: Option<String>,
+    ) -> Self {
+        Self {
+            id,
+            summary_adapter: crate::harness::select(&command),
+            command,
+            cwd,
+            tagged: false,
+            group: None,
+            name: None,
+            harness,
+            run: 0,
+            resume_id,
+            process: None,
+        }
+    }
+
+    /// Check the capture file, then the live registry, then the spawn-time ID. A
+    /// managed CLI can select a session after launch, so validate captured IDs
+    /// through the harness with the task leader's PID. If a source has no valid ID,
+    /// check the next source. For literal tasks, return `None`; for stopped
+    /// tasks, the stored ID.
+    pub fn current_resume_id(&self) -> Option<String> {
+        if let (Some(h), Some(p)) = (self.harness, &self.process) {
+            if let Some(path) = &p.capture_file
+                && let Ok(payload) = std::fs::read_to_string(path)
+                && let Some(id) = h.parse_capture(&payload, p.pid())
+            {
+                return Some(id);
+            }
+            if let Some(pid) = p.pid()
+                && let Some(id) =
+                    h.live_session_id(pid, &self.cwd, p.spawned_at, p.harness_home.as_deref())
+            {
+                return Some(id);
+            }
+        }
+        self.resume_id.clone()
+    }
+
+    /// Resolve the dashboard preview through the provenance cascade under
+    /// the grid lock (see [`crate::preview`]). Use the caller's tick instant
+    /// `now` for every task in a snapshot. For a stopped task, return an empty,
+    /// frozen floor preview: there is no grid to inspect.
+    pub fn resolve_preview(&mut self, now: Instant) -> Preview {
+        self.refresh_blocked(now);
+        let Some(p) = &mut self.process else {
+            return Preview {
+                frozen: true,
+                ..Preview::floor(String::new())
+            };
+        };
+        let emu = p.parser.lock();
+        let blocked = p.blocked.as_ref().map(|(text, rule)| (&**text, *rule));
+        p.preview
+            .resolve(now, &*emu, self.summary_adapter, blocked)
+            .clone()
+    }
+
+    /// Refresh the harness's blocked-on-user status at most once per
+    /// [`BLOCKED_PROBE_INTERVAL`]. Skip the probe without a harness or PID;
+    /// clear the cached status for finished tasks.
+    fn refresh_blocked(&mut self, now: Instant) {
+        let Some(p) = &mut self.process else {
+            return;
+        };
+        let (Some(h), Some(pid), None) = (self.harness, p.pid, p.finished) else {
+            p.blocked = None;
+            return;
+        };
+        if p.blocked_probed
+            .is_some_and(|t| now.duration_since(t) < BLOCKED_PROBE_INTERVAL)
+        {
+            return;
+        }
+        p.blocked_probed = Some(now);
+        p.blocked = h.live_blocked_status(pid, &self.cwd, p.spawned_at, p.harness_home.as_deref());
+    }
+
+    /// Freeze the preview once output is complete. Apply any open `?2026` frame
+    /// first to include its buffered output in the preview. Skip stopped tasks,
+    /// which have no output.
+    pub fn finalize_preview(&mut self) {
+        let Some(p) = &mut self.process else {
+            return;
+        };
+        if p.preview.finalized() || !p.output_complete() {
+            return;
+        }
+        let mut emu = p.parser.lock();
+        let _ = emu.finish_output();
+        p.preview.finalize(&*emu, self.summary_adapter);
+    }
+}
+
+impl Process {
+    /// Spawn `exec` in a fresh `rows`×`cols` PTY with `scrollback` history
+    /// rows. For a literal `exec`, run `command` under the launch shell. Pass
+    /// exactly `env` to the child and notify the core through `waker` on
+    /// terminal output.
+    #[allow(clippy::too_many_arguments)] // All arguments define launch state.
+    pub fn spawn(
+        command: &str,
+        exec: Exec,
+        cwd: &Path,
+        rows: u16,
+        cols: u16,
+        scrollback: usize,
+        env: &[(OsString, OsString)],
+        waker: &Waker,
     ) -> io::Result<Self> {
         let pair = native_pty_system()
             .openpty(PtySize {
@@ -338,9 +479,6 @@ impl Task {
         let pid = child.process_id();
         drop(child);
         Ok(Self {
-            id,
-            command: command.to_string(),
-            cwd: cwd.to_path_buf(),
             master: pair.master,
             input_tx: Some(input_tx),
             pending_write,
@@ -348,14 +486,7 @@ impl Task {
             parser,
             last_activity,
             handle: Some(handle),
-            tagged: false,
-            group: None,
-            name: None,
-            harness: None,
             harness_home: None,
-            summary_adapter: crate::harness::select(command),
-            run: 0,
-            resume_id: None,
             capture_file: None,
             preview: PreviewState::new(),
             blocked: None,
@@ -370,39 +501,15 @@ impl Task {
         })
     }
 
-    /// Return the task's session-leader PID.
+    /// Return the session-leader PID.
     pub fn pid(&self) -> Option<u32> {
         self.pid
     }
 
-    /// Check the capture file, then the live registry, then the spawn-time ID. A
-    /// managed CLI can select a session after launch, so validate captured IDs
-    /// through the harness with the task leader's PID. If a source has no valid ID,
-    /// check the next source. For literal tasks, return `None`.
-    pub fn current_resume_id(&self) -> Option<String> {
-        if let (Some(h), Some(path)) = (self.harness, &self.capture_file)
-            && let Ok(payload) = std::fs::read_to_string(path)
-            && let Some(id) = h.parse_capture(&payload, self.pid())
-        {
-            return Some(id);
-        }
-        if let (Some(h), Some(pid)) = (self.harness, self.pid())
-            && let Some(id) = h.live_session_id(
-                pid,
-                &self.cwd,
-                self.spawned_at,
-                self.harness_home.as_deref(),
-            )
-        {
-            return Some(id);
-        }
-        self.resume_id.clone()
-    }
-
     /// Latch the exit code and finish time if the leader has exited, without
     /// reaping it. `WNOWAIT` leaves the zombie in place, which is what keeps
     /// the pid (and therefore the pgid) reserved so the group stays signalable
-    /// for the task's whole life; see the `reaped` field. The zombie is
+    /// for the run's whole life; see the `reaped` field. The zombie is
     /// collected at teardown, after SIGKILL.
     pub fn poll_exit(&mut self) -> io::Result<()> {
         if self.finished.is_some() || self.reaped {
@@ -492,7 +599,7 @@ impl Task {
     }
 
     /// Time since the reader thread last saw PTY output. Zero when the
-    /// activity lock is poisoned, so a task whose reader died mid-update
+    /// activity lock is poisoned, so a run whose reader died mid-update
     /// reads as just-active, never as stuck-idle.
     pub fn quiet_for(&self, now: Instant) -> Duration {
         self.last_activity
@@ -514,57 +621,11 @@ impl Task {
         }
     }
 
-    /// Drain OSC 52 clipboard stores captured by this task's emulator.
+    /// Drain OSC 52 clipboard stores captured by this run's emulator.
     pub fn drain_clipboard(&self) -> ClipboardStores {
         self.parser.lock().drain_clipboard()
     }
 
-    /// The dashboard preview, resolved through the provenance cascade under
-    /// the grid lock (see [`crate::preview`]). `now` is the caller's tick
-    /// instant so every task in one snapshot resolves against the same clock.
-    pub fn resolve_preview(&mut self, now: Instant) -> Preview {
-        self.refresh_blocked(now);
-        let emu = self.parser.lock();
-        let blocked = self.blocked.as_ref().map(|(text, rule)| (&**text, *rule));
-        self.preview
-            .resolve(now, &*emu, self.summary_adapter, blocked)
-            .clone()
-    }
-
-    /// Refresh the harness's blocked-on-user status at most once per
-    /// [`BLOCKED_PROBE_INTERVAL`]. Tasks without a harness or PID do not probe;
-    /// finished tasks clear the cached status.
-    fn refresh_blocked(&mut self, now: Instant) {
-        let (Some(h), Some(pid), None) = (self.harness, self.pid, self.finished) else {
-            self.blocked = None;
-            return;
-        };
-        if self
-            .blocked_probed
-            .is_some_and(|t| now.duration_since(t) < BLOCKED_PROBE_INTERVAL)
-        {
-            return;
-        }
-        self.blocked_probed = Some(now);
-        self.blocked = h.live_blocked_status(
-            pid,
-            &self.cwd,
-            self.spawned_at,
-            self.harness_home.as_deref(),
-        );
-    }
-
-    /// Freeze the preview once output is complete. Apply any open `?2026` frame
-    /// first so the preview includes its buffered output.
-    pub fn finalize_preview(&mut self) {
-        if self.preview.finalized() || !self.output_complete() {
-            return;
-        }
-        let mut emu = self.parser.lock();
-        let _ = emu.finish_output();
-        self.preview.finalize(&*emu, self.summary_adapter);
-    }
-
     /// Full screen as ANSI bytes for attached mode, plus cursor state so we can
     /// place the real cursor where the child put it.
     pub fn formatted(&self) -> (Vec<u8>, (u16, u16), bool) {
@@ -607,7 +668,7 @@ impl Task {
 
     /// Admit one whole message to the writer queue, or refuse it whole.
     fn queue_write(&self, msg: Vec<u8>) -> Result<(), WriteRefused> {
-        // A force-killed task has no writer queue; discard subsequent input.
+        // A force-killed run has no writer queue; discard subsequent input.
         let Some(tx) = &self.input_tx else {
             return Ok(());
         };
@@ -662,10 +723,10 @@ impl Task {
         )
     }
 
-    /// Ask the whole task to exit: SIGTERM to the process *group*, not just the
+    /// Ask the whole run to exit: SIGTERM to the process *group*, not just the
     /// direct child, so every group member gets it, including background
     /// children a `cmd &` left behind (a non-interactive shell's `&` creates no
-    /// new group, so they never leave this one). TERM, not KILL: the task gets a
+    /// new group, so they never leave this one). TERM, not KILL: the child gets a
     /// chance to flush and clean up. The supervisor owns the escalation:
     /// `overdue` turns true once the grace elapses, and `force_kill` finishes it.
     ///
@@ -689,7 +750,7 @@ impl Task {
                 .is_some_and(|t| now.duration_since(t) >= grace)
     }
 
-    /// Send SIGKILL to the task's process group without waiting for it to exit.
+    /// Send SIGKILL to the process group without waiting for it to exit.
     pub fn force_kill(&mut self) {
         if !self.reaped
             && let Some(pid) = self.pid
@@ -706,10 +767,10 @@ impl Task {
     }
 }
 
-impl Drop for Task {
+impl Drop for Process {
     fn drop(&mut self) {
         // The last-resort backstop, not the policy point: guarantees no
-        // orphaned task tree regardless of how a Task leaves scope. Graceful
+        // orphaned process tree regardless of how a run leaves scope. Graceful
         // TERM-first teardown happens above this, in the supervisor. The
         // collect is best-effort: an already-exited leader reaps instantly; one
         // still dying from the KILL reparents to init, which collects it.
diff --git a/src/task_tests.rs b/src/task_tests.rs
index 75f63f1..1eb38f0 100644
--- a/src/task_tests.rs
+++ b/src/task_tests.rs
@@ -34,8 +34,8 @@ fn spawn_sh(id: u64, command: &str) -> Task {
 fn wait_finished(t: &mut Task) {
     assert!(
         wait_until(Duration::from_secs(5), || {
-            t.poll_exit().unwrap();
-            t.finished.is_some()
+            t.process.as_mut().unwrap().poll_exit().unwrap();
+            t.process.as_ref().unwrap().finished.is_some()
         }),
         "task never finished"
     );
@@ -45,8 +45,8 @@ fn wait_finished(t: &mut Task) {
 fn wait_complete(t: &mut Task) {
     assert!(
         wait_until(Duration::from_secs(60), || {
-            t.poll_exit().unwrap();
-            t.output_complete()
+            t.process.as_mut().unwrap().poll_exit().unwrap();
+            t.process.as_ref().unwrap().output_complete()
         }),
         "child never completed"
     );
@@ -59,25 +59,28 @@ fn spawn_reads_output_and_exits_zero() {
     let mut t = spawn(1, "printf 'alpha\\nomega\\n'");
     let mut preview = String::new();
     wait_until(Duration::from_secs(5), || {
-        t.poll_exit().unwrap();
+        t.process.as_mut().unwrap().poll_exit().unwrap();
         preview = t.resolve_preview(Instant::now()).text;
-        t.finished.is_some() && preview.contains("omega")
+        t.process.as_ref().unwrap().finished.is_some() && preview.contains("omega")
     });
-    assert_eq!(t.exit_code, Some(0));
+    assert_eq!(t.process.as_ref().unwrap().exit_code, Some(0));
     assert!(preview.contains("omega"), "preview was {preview:?}");
-    t.terminate();
+    t.process.as_mut().unwrap().terminate();
 }
 
 #[test]
 fn nonzero_exit_is_recorded() {
     let mut t = spawn(2, "exit 3");
     wait_finished(&mut t);
-    assert_eq!(t.exit_code, Some(3));
+    assert_eq!(t.process.as_ref().unwrap().exit_code, Some(3));
     assert_eq!(
-        t.lifecycle(Instant::now(), Duration::from_secs(10)),
+        t.process
+            .as_ref()
+            .unwrap()
+            .lifecycle(Instant::now(), Duration::from_secs(10)),
         Lifecycle::Failed
     );
-    t.terminate();
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// A live task becomes idle only after the quiet threshold; output resets it.
@@ -86,19 +89,34 @@ fn lifecycle_crosses_idle_threshold_and_resets_on_activity() {
     let mut t = spawn(5, "sleep 5");
     // `sleep` writes nothing, so `last_activity` keeps its spawn value
     // and the injected `now`s measure against a fixed instant.
-    let quiet_since = *t.last_activity.lock().unwrap();
+    let quiet_since = *t.process.as_ref().unwrap().last_activity.lock().unwrap();
     let window = Duration::from_secs(10);
 
     let inside = quiet_since + Duration::from_secs(9);
-    assert_eq!(t.lifecycle(inside, window), Lifecycle::Active);
+    assert_eq!(
+        t.process.as_ref().unwrap().lifecycle(inside, window),
+        Lifecycle::Active
+    );
 
-    assert_eq!(t.lifecycle(quiet_since + window, window), Lifecycle::Active);
+    assert_eq!(
+        t.process
+            .as_ref()
+            .unwrap()
+            .lifecycle(quiet_since + window, window),
+        Lifecycle::Active
+    );
 
     let past = quiet_since + Duration::from_secs(11);
-    assert_eq!(t.lifecycle(past, window), Lifecycle::Idle);
-    *t.last_activity.lock().unwrap() = past;
-    assert_eq!(t.lifecycle(past, window), Lifecycle::Active);
-    t.terminate();
+    assert_eq!(
+        t.process.as_ref().unwrap().lifecycle(past, window),
+        Lifecycle::Idle
+    );
+    *t.process.as_ref().unwrap().last_activity.lock().unwrap() = past;
+    assert_eq!(
+        t.process.as_ref().unwrap().lifecycle(past, window),
+        Lifecycle::Active
+    );
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// Keep a task active on repeated output before the quiet threshold.
@@ -106,14 +124,17 @@ fn lifecycle_crosses_idle_threshold_and_resets_on_activity() {
 fn sub_window_quiet_gaps_never_read_as_idle() {
     let mut t = spawn(7, "sleep 5");
     let window = Duration::from_secs(10);
-    let start = *t.last_activity.lock().unwrap();
+    let start = *t.process.as_ref().unwrap().last_activity.lock().unwrap();
     for gaps in 1..=4u32 {
         let probe = start + Duration::from_secs(9) * gaps;
-        assert_eq!(t.lifecycle(probe, window), Lifecycle::Active);
+        assert_eq!(
+            t.process.as_ref().unwrap().lifecycle(probe, window),
+            Lifecycle::Active
+        );
         // Simulate output at the end of each quiet gap.
-        *t.last_activity.lock().unwrap() = probe;
+        *t.process.as_ref().unwrap().last_activity.lock().unwrap() = probe;
     }
-    t.terminate();
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// Exit status takes precedence over elapsed quiet time.
@@ -122,18 +143,25 @@ fn finished_lifecycle_ignores_quiet_time() {
     for (command, expected) in [("exit 0", Lifecycle::Ok), ("exit 3", Lifecycle::Failed)] {
         let mut t = spawn(6, command);
         wait_finished(&mut t);
-        let now = *t.last_activity.lock().unwrap() + Duration::from_secs(11);
-        assert_eq!(t.lifecycle(now, Duration::from_secs(10)), expected);
-        t.terminate();
+        let now =
+            *t.process.as_ref().unwrap().last_activity.lock().unwrap() + Duration::from_secs(11);
+        assert_eq!(
+            t.process
+                .as_ref()
+                .unwrap()
+                .lifecycle(now, Duration::from_secs(10)),
+            expected
+        );
+        t.process.as_mut().unwrap().terminate();
     }
 }
 
 #[test]
 fn resize_is_reflected_in_the_grid() {
     let mut t = spawn(3, "sleep 5");
-    t.resize(30, 100).unwrap();
-    assert_eq!(t.parser.lock().size(), (30, 100));
-    t.terminate();
+    t.process.as_ref().unwrap().resize(30, 100).unwrap();
+    assert_eq!(t.process.as_ref().unwrap().parser.lock().size(), (30, 100));
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// The exit latch must not reap: after `finished` latches, the leader is
@@ -143,8 +171,14 @@ fn resize_is_reflected_in_the_grid() {
 fn exited_leader_stays_a_zombie_until_drop() {
     let mut t = spawn(4, "exit 7");
     wait_finished(&mut t);
-    assert_eq!(t.exit_code, Some(7));
-    let pid = Pid::from_raw(t.pid.expect("spawn always yields a pid") as i32);
+    assert_eq!(t.process.as_ref().unwrap().exit_code, Some(7));
+    let pid = Pid::from_raw(
+        t.process
+            .as_ref()
+            .unwrap()
+            .pid
+            .expect("spawn always yields a pid") as i32,
+    );
     // Signal 0 = existence check; a zombie still exists.
     assert!(
         kill(pid, None).is_ok(),
@@ -181,7 +215,7 @@ fn managed_launch_makes_the_agent_the_task_leader_under_any_shell() {
     wait_finished(&mut t);
     assert_eq!(
         read_pid(&pid_file).as_raw() as u32,
-        t.pid().unwrap(),
+        t.process.as_ref().unwrap().pid().unwrap(),
         "the agent must be the task leader with no shell in between"
     );
 
@@ -191,7 +225,7 @@ fn managed_launch_makes_the_agent_the_task_leader_under_any_shell() {
     wait_finished(&mut t);
     assert_ne!(
         read_pid(&pid_file).as_raw() as u32,
-        t.pid().unwrap(),
+        t.process.as_ref().unwrap().pid().unwrap(),
         "premise: under a resident shell the literal agent is a child, not the leader"
     );
 }
@@ -210,7 +244,7 @@ fn terminate_reaches_stragglers_after_leader_exit() {
     let straggler = read_pid(&spid);
     assert!(kill(straggler, None).is_ok(), "straggler should be alive");
 
-    t.terminate(); // leader already finished: the group signal must still fire
+    t.process.as_mut().unwrap().terminate(); // leader already finished: the group signal must still fire
     assert!(
         wait_until(Duration::from_secs(5), || kill(straggler, None).is_err()),
         "TERM after leader exit never reached the straggler"
@@ -221,12 +255,16 @@ fn terminate_reaches_stragglers_after_leader_exit() {
 #[test]
 fn killed_leader_latches_137_via_collect() {
     let mut t = spawn(8, "sleep 300");
-    t.force_kill(); // sets kill_sent, so try_collect may reap
+    t.process.as_mut().unwrap().force_kill(); // sets kill_sent, so try_collect may reap
     assert!(
-        wait_until(Duration::from_secs(5), || t.try_collect()),
+        wait_until(Duration::from_secs(5), || t
+            .process
+            .as_mut()
+            .unwrap()
+            .try_collect()),
         "KILLed leader was never collected"
     );
-    assert_eq!(t.exit_code, Some(137));
+    assert_eq!(t.process.as_ref().unwrap().exit_code, Some(137));
 }
 
 /// Collection must retain the group reservation until escalation, including
@@ -235,19 +273,25 @@ fn killed_leader_latches_137_via_collect() {
 fn exited_leader_is_collectible_only_after_kill() {
     let mut t = spawn(30, "exit 0");
     wait_finished(&mut t);
-    assert!(!t.try_collect());
-    t.terminate();
-    let term_sent = t.term_sent.unwrap();
-    t.terminate();
+    assert!(!t.process.as_mut().unwrap().try_collect());
+    t.process.as_mut().unwrap().terminate();
+    let term_sent = t.process.as_ref().unwrap().term_sent.unwrap();
+    t.process.as_mut().unwrap().terminate();
     assert_eq!(
-        t.term_sent,
+        t.process.as_ref().unwrap().term_sent,
         Some(term_sent),
         "repeated TERM reset the grace"
     );
-    assert!(!t.try_collect());
-    assert!(kill(Pid::from_raw(t.pid.unwrap() as i32), None).is_ok());
-    t.force_kill();
-    assert!(t.try_collect());
+    assert!(!t.process.as_mut().unwrap().try_collect());
+    assert!(
+        kill(
+            Pid::from_raw(t.process.as_ref().unwrap().pid.unwrap() as i32),
+            None
+        )
+        .is_ok()
+    );
+    t.process.as_mut().unwrap().force_kill();
+    assert!(t.process.as_mut().unwrap().try_collect());
 }
 
 /// Clamp scrollback at both ends; return to live output on input.
@@ -256,53 +300,79 @@ fn viewport_scrolls_and_snaps_live_on_input() {
     let mut t = spawn(9, "cat");
     // Feed enough rows to create scrollback.
     for i in 0..50 {
-        t.parser.lock().process(format!("line{i}\r\n").as_bytes());
+        t.process
+            .as_ref()
+            .unwrap()
+            .parser
+            .lock()
+            .process(format!("line{i}\r\n").as_bytes());
     }
-    assert_eq!(t.scroll_offset(), 0);
-    t.scroll_view(ScrollAction::Up(10));
-    assert_eq!(t.scroll_offset(), 10);
-    t.scroll_view(ScrollAction::Down(4));
-    assert_eq!(t.scroll_offset(), 6);
-    t.scroll_view(ScrollAction::Top);
-    let top = t.scroll_offset();
+    assert_eq!(t.process.as_ref().unwrap().scroll_offset(), 0);
+    t.process
+        .as_ref()
+        .unwrap()
+        .scroll_view(ScrollAction::Up(10));
+    assert_eq!(t.process.as_ref().unwrap().scroll_offset(), 10);
+    t.process
+        .as_ref()
+        .unwrap()
+        .scroll_view(ScrollAction::Down(4));
+    assert_eq!(t.process.as_ref().unwrap().scroll_offset(), 6);
+    t.process.as_ref().unwrap().scroll_view(ScrollAction::Top);
+    let top = t.process.as_ref().unwrap().scroll_offset();
     assert!(top > 0);
     assert!(
-        t.screen_lines()[0].starts_with("line0"),
+        t.process.as_ref().unwrap().screen_lines()[0].starts_with("line0"),
         "Top must show the oldest stored row, got {:?}",
-        t.screen_lines()[0]
+        t.process.as_ref().unwrap().screen_lines()[0]
     );
     // Large upward movement clamps at the oldest row.
-    t.scroll_view(ScrollAction::Live);
-    t.scroll_view(ScrollAction::Up(10_000));
-    assert_eq!(t.scroll_offset(), top);
+    t.process.as_ref().unwrap().scroll_view(ScrollAction::Live);
+    t.process
+        .as_ref()
+        .unwrap()
+        .scroll_view(ScrollAction::Up(10_000));
+    assert_eq!(t.process.as_ref().unwrap().scroll_offset(), top);
     // Return the viewport to live output on input.
-    t.send_input(b"x".to_vec()).unwrap();
-    assert_eq!(t.scroll_offset(), 0);
-    t.terminate();
+    t.process
+        .as_ref()
+        .unwrap()
+        .send_input(b"x".to_vec())
+        .unwrap();
+    assert_eq!(t.process.as_ref().unwrap().scroll_offset(), 0);
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// `screen_lines` returns one entry per grid row, including a blank final row.
 #[test]
 fn screen_lines_yields_one_entry_per_grid_row() {
     let mut t = spawn(60, "sleep 300");
-    t.parser.lock().process(b"top");
-    let lines = t.screen_lines();
+    t.process.as_ref().unwrap().parser.lock().process(b"top");
+    let lines = t.process.as_ref().unwrap().screen_lines();
     // The spawn helper's grid is 24x80.
     assert_eq!(lines.len(), 24, "one entry per grid row");
     assert_eq!(lines[0], "top");
     assert_eq!(lines[23], "", "the blank bottom row keeps its slot");
-    t.terminate();
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// The per-task writer worker delivers queued messages in FIFO order.
 #[test]
 fn queued_writes_reach_the_child_in_order() {
     let mut t = spawn(10, "cat");
-    t.send_input(b"zqfirstqz\n".to_vec()).unwrap();
-    t.send_input(b"zqsecondqz\n".to_vec()).unwrap();
+    t.process
+        .as_ref()
+        .unwrap()
+        .send_input(b"zqfirstqz\n".to_vec())
+        .unwrap();
+    t.process
+        .as_ref()
+        .unwrap()
+        .send_input(b"zqsecondqz\n".to_vec())
+        .unwrap();
     let mut contents = String::new();
     wait_until(Duration::from_secs(5), || {
-        contents = t.parser.lock().contents();
+        contents = t.process.as_ref().unwrap().parser.lock().contents();
         contents.contains("zqsecondqz")
     });
     let first = contents
@@ -312,7 +382,7 @@ fn queued_writes_reach_the_child_in_order() {
         .find("zqsecondqz")
         .expect("second message never echoed");
     assert!(first < second, "queued writes reordered: {contents:?}");
-    t.terminate();
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// Test writer that accepts writes within `limit` bytes, then fails.
@@ -372,14 +442,41 @@ fn write_error_keeps_draining_the_pending_counter() {
 #[test]
 fn input_hints_track_child_modes() {
     let mut t = spawn(8, "sleep 5");
-    assert_eq!(t.input_hints(), (false, false, false));
-    t.parser.lock().process(b"\x1b[?1000h");
-    assert_eq!(t.input_hints(), (true, false, false));
-    t.parser.lock().process(b"\x1b[?1000l\x1b[?1049h");
-    assert_eq!(t.input_hints(), (false, true, true));
-    t.parser.lock().process(b"\x1b[?1007l");
-    assert_eq!(t.input_hints(), (false, true, false));
-    t.terminate();
+    assert_eq!(
+        t.process.as_ref().unwrap().input_hints(),
+        (false, false, false)
+    );
+    t.process
+        .as_ref()
+        .unwrap()
+        .parser
+        .lock()
+        .process(b"\x1b[?1000h");
+    assert_eq!(
+        t.process.as_ref().unwrap().input_hints(),
+        (true, false, false)
+    );
+    t.process
+        .as_ref()
+        .unwrap()
+        .parser
+        .lock()
+        .process(b"\x1b[?1000l\x1b[?1049h");
+    assert_eq!(
+        t.process.as_ref().unwrap().input_hints(),
+        (false, true, true)
+    );
+    t.process
+        .as_ref()
+        .unwrap()
+        .parser
+        .lock()
+        .process(b"\x1b[?1007l");
+    assert_eq!(
+        t.process.as_ref().unwrap().input_hints(),
+        (false, true, false)
+    );
+    t.process.as_mut().unwrap().terminate();
 }
 
 /// A live reader may still hold bytes that have not reached the grid, so
@@ -392,7 +489,7 @@ fn finalize_preview_waits_for_reader_eof() {
     // Reopen the reader gate: a thread outliving the child's exit stands in
     // for a reader still working through bytes the grid has not seen.
     let (release, parked) = channel::<()>();
-    t.handle = Some(thread::spawn(move || {
+    t.process.as_mut().unwrap().handle = Some(thread::spawn(move || {
         let _ = parked.recv();
     }));
     t.finalize_preview();
@@ -400,12 +497,21 @@ fn finalize_preview_waits_for_reader_eof() {
         !t.resolve_preview(Instant::now()).frozen,
         "finalization must wait for reader EOF"
     );
-    t.parser.lock().process(b"late output\r\n");
+    t.process
+        .as_ref()
+        .unwrap()
+        .parser
+        .lock()
+        .process(b"late output\r\n");
 
     // Dropping the sender ends the stand-in: the reader reached EOF.
     drop(release);
     assert!(
-        wait_until(Duration::from_secs(60), || t.reader_done()),
+        wait_until(Duration::from_secs(60), || t
+            .process
+            .as_ref()
+            .unwrap()
+            .reader_done()),
         "the stand-in reader never stopped"
     );
     t.finalize_preview();
@@ -420,11 +526,25 @@ fn finalize_preview_lands_an_open_sync_frame() {
     let mut t = spawn_sh(21, "printf '\\033[?2026htest result: ok\\n'");
     wait_complete(&mut t);
     assert!(
-        !t.parser.lock().contents().contains("test result: ok"),
+        !t.process
+            .as_ref()
+            .unwrap()
+            .parser
+            .lock()
+            .contents()
+            .contains("test result: ok"),
         "premise: the unclosed frame still buffers the final output"
     );
     t.finalize_preview();
-    assert!(t.parser.lock().contents().contains("test result: ok"));
+    assert!(
+        t.process
+            .as_ref()
+            .unwrap()
+            .parser
+            .lock()
+            .contents()
+            .contains("test result: ok")
+    );
     let p = t.resolve_preview(Instant::now());
     assert_eq!((p.text.as_str(), p.frozen), ("test result: ok", true));
 }
@@ -479,7 +599,7 @@ fn finalize_preview_keeps_the_last_render_across_alt_teardown() {
     std::fs::write(&teardown, b"").unwrap();
     assert!(
         wait_until(Duration::from_secs(60), || {
-            !t.parser.lock().alternate_screen()
+            !t.process.as_ref().unwrap().parser.lock().alternate_screen()
         }),
         "teardown never reached the grid"
     );
@@ -494,7 +614,7 @@ fn finalize_preview_keeps_the_last_render_across_alt_teardown() {
     wait_complete(&mut t);
     t.finalize_preview();
     assert_eq!(
-        t.parser.lock().live_floor(),
+        t.process.as_ref().unwrap().parser.lock().live_floor(),
         "prelaunch junk",
         "premise: 1049l restored the pre-launch primary screen"
     );
@@ -615,5 +735,5 @@ fn probe_replies_reach_the_child_through_the_allowlist() {
         got.ends_with(b"R"),
         "CPR reply must follow the DA reply; got {got:?}"
     );
-    t.terminate();
+    t.process.as_mut().unwrap().terminate();
 }
diff --git a/src/transport.rs b/src/transport.rs
index b6b442d..009da06 100644
--- a/src/transport.rs
+++ b/src/transport.rs
@@ -104,8 +104,9 @@ impl ThreadTransport {
                 let _ = wait_tx.send(());
                 true
             });
-            // Loop returned (Shutdown or client gone): `sup` drops here, and with
-            // it every Task (Task::drop → killpg), so no task outlives the core.
+            // On loop exit (Shutdown or client gone), drop `sup` and every task's
+            // `Process`. Kill each process group in `Process::drop` so no task
+            // outlives the core.
         });
         Self {
             wake_tx,
@@ -116,9 +117,9 @@ impl ThreadTransport {
     }
 
     fn stop(&mut self) {
-        // Tell the core to kill tasks and exit, then wait for it. The join is what
-        // guarantees the SIGKILLs have been sent before we return. The core
-        // clears its tasks (Task::drop → killpg) as `run_loop` returns.
+        // Tell the core to kill tasks and exit, then join it to wait for the
+        // SIGKILLs before returning. Clear tasks on exit from `run_loop`;
+        // send SIGKILL to each process group in `Process::drop`.
         let _ = self.wake_tx.send(Wake::Cmd(Command::Shutdown));
         if let Some(h) = self.handle.take() {
             let _ = h.join();
diff --git a/src/ui.rs b/src/ui.rs
index 177e922..558e210 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -12,7 +12,7 @@ use crossterm::{
     cursor::{Hide, MoveTo, Show},
     queue,
     style::{Attribute, Color, Print, SetAttribute, SetBackgroundColor},
-    terminal::{BeginSynchronizedUpdate, EndSynchronizedUpdate},
+    terminal::{BeginSynchronizedUpdate, Clear, ClearType, EndSynchronizedUpdate},
 };
 
 use unicode_width::UnicodeWidthStr;
@@ -100,14 +100,21 @@ fn render_dashboard(out: &mut impl Write, app: &App) -> io::Result<()> {
     queue!(out, Hide, MoveTo(0, 0))?;
 
     // Tally the lifecycle values pre-computed by the core.
-    let (mut running, mut idle, mut done) = (0u32, 0u32, 0u32);
+    let (mut running, mut idle, mut done, mut stopped) = (0u32, 0u32, 0u32, 0u32);
     for v in &app.views {
         match v.lifecycle {
             Lifecycle::Active => running += 1,
             Lifecycle::Idle => idle += 1,
             Lifecycle::Ok | Lifecycle::Failed => done += 1,
+            Lifecycle::Stopped => stopped += 1,
         }
     }
+    // Show the stopped count only when at least one stopped row is present.
+    let stopped_tag = if stopped > 0 {
+        format!(" · {stopped} stopped")
+    } else {
+        String::new()
+    };
     // List region: rows 2..=list_bottom. Command line and footer sit below.
     // Scroll over section and task rows together to keep the selection visible.
     let list_top = 2u16;
@@ -136,7 +143,8 @@ fn render_dashboard(out: &mut impl Write, app: &App) -> io::Result<()> {
         _ => String::new(),
     };
     // Build and pad the complete header before styling each intensity run.
-    let prefix = format!("  fleetcom   {running} running · {idle} idle · {done} done      by ");
+    let prefix =
+        format!("  fleetcom   {running} running · {idle} idle · {done} done{stopped_tag}      by ");
     let suffix = format!("{mode_tag}{scroll_tag}");
     let segs = header_segments(&prefix, app.group_mode, &suffix);
     let plain: String = segs.iter().map(|(t, _)| t.as_str()).collect();
@@ -316,20 +324,27 @@ fn attached_title(v: &TaskView) -> String {
 }
 
 /// Age shown for a task: time since exit when finished, last output when idle, or
-/// launch otherwise. Use launch time when the edge timestamp is missing.
-fn row_age(v: &TaskView) -> Duration {
-    let edge = match v.lifecycle {
-        Lifecycle::Ok | Lifecycle::Failed => v.finished_ago,
-        Lifecycle::Idle => v.quiet_ago,
-        Lifecycle::Active => None,
+/// launch otherwise. Use launch time when the edge timestamp is missing. `None` for a
+/// stopped task: there is no launch, output, or exit time to measure from.
+fn row_age(v: &TaskView) -> Option<Duration> {
+    if v.lifecycle == Lifecycle::Stopped {
+        return None;
+    }
+    let edge = if v.lifecycle.finished() {
+        v.finished_ago
+    } else if v.lifecycle == Lifecycle::Idle {
+        v.quiet_ago
+    } else {
+        None
     };
-    edge.unwrap_or(v.started_ago)
+    edge.or(v.started_ago)
 }
 
 /// A task's lifecycle glyph, shared by the dashboard row and the `/` palette.
 /// Use the agent-reported turn status to choose the glyph: an agent can keep thinking
 /// past the idle window without writing output. Select adapters by command word so
-/// hand-typed agent commands get the same glyph as Agent-page launches.
+/// hand-typed agent commands get the same glyph as Agent-page launches. Leave the
+/// glyph blank for a stopped row: no process has run under it.
 fn status_glyph(v: &TaskView) -> &'static str {
     match v.lifecycle {
         Lifecycle::Active | Lifecycle::Idle if v.preview.working => "●",
@@ -337,6 +352,7 @@ fn status_glyph(v: &TaskView) -> &'static str {
         Lifecycle::Idle => "∙",
         Lifecycle::Ok => "✓",
         Lifecycle::Failed => "✗",
+        Lifecycle::Stopped => " ",
     }
 }
 
@@ -357,7 +373,8 @@ fn task_row_parts(v: &TaskView, cols: usize) -> (String, String, String) {
         .filter_map(|(on, c)| on.then_some(c))
         .collect();
     let glyph = status_glyph(v);
-    let time = rel_time(row_age(v));
+    // Leave the age cell blank for a stopped row; use its columns for the preview.
+    let time = row_age(v).map(rel_time).unwrap_or_default();
     let title_w = title_width(cols);
 
     // marks(2) glyph(1) sp(1) title(title_w) sp(1) preview(prev_w) sp(1) time
@@ -974,6 +991,12 @@ fn render_attached(out: &mut impl Write, app: &App) -> io::Result<()> {
 
     queue!(out, Hide, MoveTo(0, 0))?;
     if let Some(s) = screen {
+        // Clear the viewport for a stopped task: there are no formatted grid bytes
+        // to overwrite the dashboard. Skip identical frames in `render` and wrap
+        // each paint in DECSET 2026 to avoid repeated clears and tearing.
+        if s.formatted.is_empty() {
+            queue!(out, Clear(ClearType::All))?;
+        }
         out.write_all(&s.formatted)?;
         // Repaint selected spans as reverse-video plain text over the child's
         // formatted output.
@@ -1265,7 +1288,7 @@ mod tests {
             name: name.map(str::to_string),
             lifecycle: Lifecycle::Active,
             preview: Preview::floor(String::new()),
-            started_ago: std::time::Duration::from_secs(5),
+            started_ago: Some(std::time::Duration::from_secs(5)),
             quiet_ago: None,
             finished_ago: None,
         }
@@ -1282,7 +1305,7 @@ mod tests {
             lifecycle,
             quiet_ago,
             finished_ago,
-            started_ago: Duration::from_hours(2),
+            started_ago: Some(Duration::from_hours(2)),
             ..view(None)
         }
     }
@@ -1316,6 +1339,7 @@ mod tests {
                     Lifecycle::Idle => "∙",
                     Lifecycle::Ok => "✓",
                     Lifecycle::Failed => "✗",
+                    Lifecycle::Stopped => " ",
                 };
                 // Skip the two-column mark gutter before checking the glyph.
                 let body: String = row.chars().skip(2).collect();
@@ -1348,6 +1372,18 @@ mod tests {
         }
     }
 
+    /// Leave the glyph and age blank for a stopped row, even with the launch-age
+    /// fallback supplied by `timed_view`: no process has run under the row.
+    #[test]
+    fn stopped_row_has_a_blank_glyph_and_time_cell() {
+        let v = timed_view(Lifecycle::Stopped, None, None);
+        let (lead, _, time) = task_row_parts(&v, 80);
+        let body: String = lead.chars().skip(2).collect();
+        assert!(body.starts_with("  "), "{lead:?}");
+        assert_eq!(time, " ", "the time cell is its separator alone");
+        assert_eq!(task_row(&v, 80).width(), 80);
+    }
+
     /// Title a dashboard row with the task's custom name when set.
     #[test]
     fn task_row_prefers_the_custom_name() {
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index eb39d5e..9337c55 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -19,7 +19,7 @@ use base64::{Engine as _, engine::general_purpose::STANDARD as B64};
 
 /// Protocol version used by this test suite; must match
 /// `protocol::PROTOCOL_VERSION`.
-pub const PROTOCOL_VERSION: u32 = 15;
+pub const PROTOCOL_VERSION: u32 = 16;
 
 /// One frame of the given kind: `[u32 len][kind][payload]`.
 pub fn frame(kind: u8, payload: &[u8]) -> Vec<u8> {
diff --git a/tests/daemon_resume.rs b/tests/daemon_resume.rs
index d2a9cb5..c675fe1 100644
--- a/tests/daemon_resume.rs
+++ b/tests/daemon_resume.rs
@@ -9,6 +9,7 @@ use std::{
     os::unix::net::UnixStream,
     path::{Path, PathBuf},
     process::{Command, Stdio},
+    sync::{Arc, Mutex},
     time::Duration,
 };
 
@@ -49,10 +50,32 @@ fn hello(stream: &mut UnixStream, s: &Scratch) {
 
 /// Drain daemon events while a test polls files. Without this reader, snapshot
 /// traffic can fill the socket and block the daemon. The thread exits with the
-/// connection.
-fn drain_events(stream: &UnixStream) {
+/// connection. Return the newest `tasks` snapshot text. Read lifecycle state
+/// through this value in tests; do not compete with the drainer for stream frames.
+fn drain_events(stream: &UnixStream) -> Arc<Mutex<String>> {
     let mut rx = stream.try_clone().unwrap();
-    std::thread::spawn(move || while read_frame(&mut rx).is_ok() {});
+    let latest = Arc::new(Mutex::new(String::new()));
+    let seen = Arc::clone(&latest);
+    std::thread::spawn(move || {
+        while let Ok((kind, payload)) = read_frame(&mut rx) {
+            if kind == 1 && payload.starts_with(br#"{"t":"tasks""#) {
+                *seen.lock().unwrap() = String::from_utf8_lossy(&payload).into_owned();
+            }
+        }
+    });
+    latest
+}
+
+/// Wait for confirmation of a clean exit in the newest snapshot. Latch the exit
+/// before checking the recipe so the sole task is saved as stopped.
+fn wait_sole_task_ok(latest: &Arc<Mutex<String>>) {
+    assert!(
+        wait_until(Duration::from_secs(10), || {
+            latest.lock().unwrap().contains(r#""life":"ok""#)
+        }),
+        "the task never exited: {}",
+        latest.lock().unwrap()
+    );
 }
 
 /// Install a `claude` stub to record argv, write a `SessionStart` payload,
@@ -212,9 +235,12 @@ fn capture_slot(runtime: &Path) -> Option<String> {
         .map(|(_, contents)| contents)
 }
 
-/// Managed entry for `agent` resuming `id`, in the pretty-printed `to_json` format.
-fn managed_entry(agent: &str, id: &str) -> String {
-    format!("{{\n        \"agent\": \"{agent}\",\n        \"resume\": \"{id}\"\n      }}")
+/// Managed entry for `agent` resuming `id`, in the pretty-printed `to_json` format, as
+/// saved after the task exited, with `stopped` set to true.
+fn stopped_managed_entry(agent: &str, id: &str) -> String {
+    format!(
+        "{{\n        \"agent\": \"{agent}\",\n        \"resume\": \"{id}\",\n        \"stopped\": true\n      }}"
+    )
 }
 
 /// Capture a managed Claude ID, save without injected flags in the recipe, and reload the
@@ -225,7 +251,7 @@ fn claude_spawn_save_load_resumes_the_conversation() {
     install_claude_stub(&s);
     let (_dir, mut daemon, mut stream) = start_daemon_raw("resume_claude", |_| {});
     hello(&mut stream, &s);
-    drain_events(&stream);
+    let latest = drain_events(&stream);
 
     stream
         .write_all(&spawn_agent_frame("claude", &s.work()))
@@ -239,10 +265,13 @@ fn claude_spawn_save_load_resumes_the_conversation() {
     let settings = PathBuf::from(value_after(&argv, "--settings"));
     assert_daemon_namespaced(&settings, daemon.0.id(), "settings overlay", &argv);
 
-    // The pinned ID is stored in `resume_id` at spawn: save once to verify it.
+    // Save once to verify the ID pinned in `resume_id` at spawn. Wait for the
+    // stub's exit to save it as stopped. After loading, start the restored row
+    // with `r` to resume the conversation.
+    wait_sole_task_ok(&latest);
     let recipe = save_once(&mut stream, &s.recipe("story"), "story");
     assert!(
-        recipe.contains(&managed_entry("claude", &id)),
+        recipe.contains(&stopped_managed_entry("claude", &id)),
         "the recipe must resume the pinned id: {recipe}"
     );
     assert!(
@@ -253,6 +282,9 @@ fn claude_spawn_save_load_resumes_the_conversation() {
     stream
         .write_all(&control_frame(r#"{"t":"load","name":"story"}"#))
         .unwrap();
+    stream
+        .write_all(&control_frame(r#"{"t":"restart","id":2}"#))
+        .unwrap();
     let argv = wait_run(&rec, 1, |a| a.iter().any(|t| t == "--resume"));
     assert_eq!(
         value_after(&argv, "--resume"),
@@ -280,7 +312,7 @@ fn codex_capture_file_drives_save_and_load_resumes() {
     install_codex_stub(&s);
     let (_dir, mut daemon, mut stream) = start_daemon_raw("resume_codex", |_| {});
     hello(&mut stream, &s);
-    drain_events(&stream);
+    let latest = drain_events(&stream);
 
     stream
         .write_all(&spawn_agent_frame("codex", &s.work()))
@@ -326,15 +358,21 @@ fn codex_capture_file_drives_save_and_load_resumes() {
         Some(CODEX_ID),
         "the slot must hold the bare root after the title thread's notification"
     );
+    // Wait for the stub's exit to save it as stopped. After loading, start the
+    // restored row with `r` to resume the conversation.
+    wait_sole_task_ok(&latest);
     let recipe = save_once(&mut stream, &s.recipe("story"), "story");
     assert!(
-        recipe.contains(&managed_entry("codex", CODEX_ID)),
+        recipe.contains(&stopped_managed_entry("codex", CODEX_ID)),
         "the recipe must resume the captured thread: {recipe}"
     );
 
     stream
         .write_all(&control_frame(r#"{"t":"load","name":"story"}"#))
         .unwrap();
+    stream
+        .write_all(&control_frame(r#"{"t":"restart","id":2}"#))
+        .unwrap();
     let argv = wait_run(&rec, 1, |a| {
         a.first().is_some_and(|t| t == "resume") && a.len() >= 2
     });
@@ -408,15 +446,17 @@ fn saved_recipe_resumes_across_a_daemon_restart() {
 
     let (_dir_a, mut daemon_a, mut stream_a) = start_daemon_raw("resume_restart_a", |_| {});
     hello(&mut stream_a, &s);
-    drain_events(&stream_a);
+    let latest = drain_events(&stream_a);
     stream_a
         .write_all(&spawn_agent_frame("claude", &s.work()))
         .unwrap();
     let argv = wait_run(&rec, 0, |a| a.iter().any(|t| t == "--session-id"));
     let id = value_after(&argv, "--session-id").to_string();
+    // Wait for the stub's exit to save it as stopped.
+    wait_sole_task_ok(&latest);
     let recipe = save_once(&mut stream_a, &s.recipe("overnight"), "overnight");
     assert!(
-        recipe.contains(&managed_entry("claude", &id)),
+        recipe.contains(&stopped_managed_entry("claude", &id)),
         "the recipe must resume the pinned id: {recipe}"
     );
     stop_daemon(&mut daemon_a);
@@ -425,9 +465,14 @@ fn saved_recipe_resumes_across_a_daemon_restart() {
     let (_dir_b, mut daemon_b, mut stream_b) = start_daemon_raw("resume_restart_b", |_| {});
     hello(&mut stream_b, &s);
     drain_events(&stream_b);
+    // Load the stopped entry as task 1 in the fresh daemon; start it with `r`
+    // to resume the conversation.
     stream_b
         .write_all(&control_frame(r#"{"t":"load","name":"overnight"}"#))
         .unwrap();
+    stream_b
+        .write_all(&control_frame(r#"{"t":"restart","id":1}"#))
+        .unwrap();
     let argv = wait_run(&rec, 1, |a| a.iter().any(|t| t == "--resume"));
     assert_eq!(
         value_after(&argv, "--resume"),