@@ -2912,28 +2912,40 @@ async fn timeline_path_orders_synthetic_steps_and_skips_the_job_record() {
 
     // Setup started before the declared steps, and the job record is sent
     // alongside them exactly as the official runner does.
+    //
+    // The three step records deliberately use the three shapes that appear on
+    // the wire: `Task` (official runner), `Step` (which this file's annotation
+    // path already recognises), and no `type` at all (the field is optional).
+    // An allow-list of one type passes a test that only sends that type while
+    // silently dropping the others' conclusions.
     let setup_id = uuid::Uuid::new_v4().to_string();
-    let record = |id: &str, kind: &str, name: &str, start: &str| {
-        json!({
+    let job_record_id = uuid::Uuid::new_v4().to_string();
+    let record = |id: &str, kind: Option<&str>, name: &str, start: &str| {
+        let mut value = json!({
             "id": id,
-            "type": kind,
             "name": name,
             "displayName": name,
             "state": "completed",
             "result": "succeeded",
             "startTime": start,
-        })
+        });
+        match kind {
+            Some(kind) => value["type"] = json!(kind),
+            // Untyped records are identified as steps by their parent.
+            None => value["parentId"] = json!(job_record_id),
+        }
+        value
     };
     let response = request_json(
         &app,
         Method::PATCH,
         &format!("/_apis/v1/Timeline/scope/actions/{plan_id}/{timeline_id}"),
         json!({"count": 5, "value": [
-            record(&uuid::Uuid::new_v4().to_string(), "Job", "build", "2026-01-01T00:00:00Z"),
-            record(&ids[0], "Task", "Run echo one", "2026-01-01T00:00:02Z"),
-            record(&ids[1], "Task", "Run echo two", "2026-01-01T00:00:03Z"),
-            record(&ids[2], "Task", "Run echo three", "2026-01-01T00:00:04Z"),
-            record(&setup_id, "Task", "Set up job", "2026-01-01T00:00:01Z"),
+            record(&job_record_id, Some("Job"), "build", "2026-01-01T00:00:00Z"),
+            record(&ids[0], Some("Task"), "Run echo one", "2026-01-01T00:00:02Z"),
+            record(&ids[1], Some("Step"), "Run echo two", "2026-01-01T00:00:03Z"),
+            record(&ids[2], None, "Run echo three", "2026-01-01T00:00:04Z"),
+            record(&setup_id, Some("Task"), "Set up job", "2026-01-01T00:00:01Z"),
         ]}),
     )
     .await;
@@ -3185,6 +3197,92 @@ async fn step_manifests_survive_a_restart() {
     );
 }
 
+/// A step report made after a restart is still persisted.
+///
+/// The out-of-order write guard compares an in-memory revision against the
+/// persisted one, so the counter has to resume above what is on disk. Left at
+/// zero it hands every post-restart write a revision the stored rows already
+/// exceed, and the upsert discards them — invisibly, because memory stays
+/// authoritative until the next restart drops the conclusion.
+#[tokio::test]
+async fn step_reports_after_a_restart_are_persisted() {
+    let temp = tempfile::tempdir().unwrap();
+    let report = |app: axum::Router, plan_id: String, agent_job_id: String, id: String, n: i64| async move {
+        let response = request_json(
+            &app,
+            Method::POST,
+            "/twirp/github.actions.results.api.v1.WorkflowStepUpdateService/WorkflowStepsUpdate",
+            json!({
+                "workflow_run_backend_id": plan_id,
+                "workflow_job_run_backend_id": agent_job_id,
+                "steps": [{
+                    "external_id": id,
+                    "number": n,
+                    "name": "Run echo one",
+                    "status": 6,
+                    "conclusion": 2
+                }]
+            }),
+        )
+        .await;
+        assert_eq!(response["ok"], true);
+    };
+
+    let (plan_id, agent_job_id, ids) = {
+        let state = AppState::new(temp.path().to_path_buf()).await.unwrap();
+        let app = app(state.clone(), CancellationToken::new());
+        let (run_id, jobs) = three_step_run_for_log_filters(&app, &state).await;
+        let ids = workflow_step_ids(&state, run_id, "build").await;
+        let (plan_id, agent_job_id) = (jobs[0].1.clone(), jobs[0].2.clone());
+        // Two reports before the restart, so the persisted revision is above
+        // the value a fresh counter would hand out first.
+        report(
+            app.clone(),
+            plan_id.clone(),
+            agent_job_id.clone(),
+            ids[0].clone(),
+            2,
+        )
+        .await;
+        report(
+            app.clone(),
+            plan_id.clone(),
+            agent_job_id.clone(),
+            ids[1].clone(),
+            3,
+        )
+        .await;
+        (plan_id, agent_job_id, ids)
+    };
+
+    {
+        let state = AppState::new(temp.path().to_path_buf()).await.unwrap();
+        let app = app(state.clone(), CancellationToken::new());
+        report(
+            app,
+            plan_id.clone(),
+            agent_job_id.clone(),
+            ids[2].clone(),
+            4,
+        )
+        .await;
+    }
+
+    // Only a second restart can tell whether that write reached the store.
+    let state = AppState::new(temp.path().to_path_buf()).await.unwrap();
+    let inner = state.inner.lock().await;
+    let records = &inner.job_steps[&agent_job_id.parse::<uuid::Uuid>().unwrap()];
+    let reported = records
+        .iter()
+        .find(|step| step.id == ids[2])
+        .expect("the post-restart step must be restored");
+    assert_eq!(
+        reported.conclusion, "success",
+        "a report made after a restart must survive the next one"
+    );
+    assert_eq!(reported.runner_number, Some(4));
+}
+
 /// Every surface showing a whole step list uses execution order.
 ///
 /// The stored manifest is seeded with declared steps and then appends
 
@@ -1084,11 +1084,13 @@ pub(crate) async fn submit_run_inner(
                 // message we just built rather than from whatever order the
                 // runner's log blobs happen to land in.
                 //
-                // Not persisted here. Only a runner report writes rows, and an
-                // attempt that was dispatched but never reported has its
-                // manifest rebuilt at startup from the persisted request
-                // message — the same source it was built from — so a restart
-                // in that window keeps its declared steps.
+                // Not persisted here. Rows are written by a runner report, a
+                // job completion, or a full snapshot that happens to flush
+                // them; none of those has necessarily run when a dispatched
+                // attempt is interrupted, so its manifest is rebuilt at startup
+                // from the persisted request message — the same source it was
+                // built from — and a restart in that window keeps its declared
+                // steps.
                 inner.job_steps.insert(
                     job_request.agent_job_id,
                     StepRecord::manifest(&agent_msg.steps),
 
@@ -778,7 +778,13 @@ impl AppState {
                             .iter()
                             .chain(recovered.pending_jobs.iter())
                             .chain(recovered.concurrency_blocked.iter())
-                            .find(|job| job.run_id == record.run_id && job.job_id == record.job_id)
+                            // Keyed by request id, not by (run, job): a
+                            // re-dispatch leaves several requests for one
+                            // logical job, and matching the pair attaches the
+                            // newest queued message to an older attempt —
+                            // rebuilding it with the wrong `TaskStep` ids, so
+                            // its `step-<id>.txt` blobs stop resolving.
+                            .find(|job| job.message.request_id == record.request_id)
                             .map(|job| job.message.steps.as_slice())
                     })?;
                 let manifest = crate::models::StepRecord::manifest(steps);
 
@@ -1437,7 +1437,8 @@ impl SqliteStore {
         // guessing, so the run's step history has to come back here.
         let mut step_stmt = connection.prepare(
             "SELECT agent_job_id, step_id, kind, workflow_index, runner_number,
-                    context_name, name_blob, conclusion, started_at_us, finished_at_us
+                    context_name, name_blob, conclusion, started_at_us, finished_at_us,
+                    revision
              FROM job_steps
              ORDER BY agent_job_id, COALESCE(runner_number, 2147483647),
                       COALESCE(workflow_index, 2147483647), step_id",
@@ -1454,6 +1455,7 @@ impl SqliteStore {
                 row.get::<_, String>(7)?,
                 row.get::<_, Option<i64>>(8)?,
                 row.get::<_, Option<i64>>(9)?,
+                row.get::<_, i64>(10)?,
             ))
         })? {
             let (
@@ -1467,6 +1469,7 @@ impl SqliteStore {
                 conclusion,
                 started_at_us,
                 finished_at_us,
+                revision,
             ) = row?;
             let Ok(agent_job_id) = agent_job_id.parse::<uuid::Uuid>() else {
                 tracing::warn!(%agent_job_id, "dropping step row with an unparseable attempt id");
@@ -1479,6 +1482,12 @@ impl SqliteStore {
                     continue;
                 }
             };
+            // The guard compares against the persisted revision, so the
+            // counter has to resume above it. Left at zero, the first writes
+            // after a restart carry revisions the rows already exceed and are
+            // silently discarded.
+            let seen = inner.job_steps_revision.entry(agent_job_id).or_insert(0);
+            *seen = (*seen).max(revision.max(0) as u64);
             inner
                 .job_steps
                 .entry(agent_job_id)
@@ -2406,19 +2415,28 @@ const MIGRATIONS: &[(u32, &str, &str)] = &[
           conclusion TEXT NOT NULL,
           started_at_us INTEGER,
           finished_at_us INTEGER,
-          -- Monotonic per attempt, bumped on every in-memory mutation. Two
-          -- reports for one attempt snapshot under the lock and then commit
-          -- outside it, so they can commit out of order; the upsert refuses to
-          -- move a row backwards rather than letting the older snapshot
-          -- overwrite the newer conclusions.
-          revision INTEGER NOT NULL DEFAULT 0,
           PRIMARY KEY (agent_job_id, step_id)
         ) STRICT, WITHOUT ROWID;
 
         CREATE INDEX IF NOT EXISTS job_steps_order_idx
           ON job_steps (agent_job_id, kind, workflow_index);
         "#,
     ),
+    (
+        5,
+        "job-steps-revision",
+        // Monotonic per attempt, bumped on every in-memory mutation of the
+        // manifest. Reconciliation snapshots under the state lock and writes
+        // after releasing it, so two reports for one attempt can commit out of
+        // order; the upsert compares this and refuses to move a row backwards.
+        //
+        // Its own version rather than an edit to 4: a database already at 4
+        // from an earlier build of this branch would skip the change entirely
+        // and fail every step write with an undefined column.
+        r#"
+        ALTER TABLE job_steps ADD COLUMN revision INTEGER NOT NULL DEFAULT 0;
+        "#,
+    ),
 ];
 
 pub(crate) fn now_us() -> i64 {
 
@@ -643,7 +643,8 @@ impl Store for PgStore {
         let rows = client
             .query(
                 "SELECT agent_job_id, step_id, kind, workflow_index, runner_number,
-                        context_name, name_blob, conclusion, started_at_us, finished_at_us
+                        context_name, name_blob, conclusion, started_at_us, finished_at_us,
+                        revision
                  FROM job_steps
                  ORDER BY agent_job_id, COALESCE(runner_number, 2147483647),
                           COALESCE(workflow_index, 2147483647), step_id",
@@ -665,13 +666,18 @@ impl Store for PgStore {
             let conclusion: String = row.get(7);
             let started_at_us: Option<i64> = row.get(8);
             let finished_at_us: Option<i64> = row.get(9);
+            let revision: i64 = row.get(10);
             let name = match self.cipher.unseal(&name_blob) {
                 Ok(bytes) => String::from_utf8_lossy(&bytes).into_owned(),
                 Err(error) => {
                     tracing::warn!(%error, %step_id, "dropping step row with an unreadable name");
                     continue;
                 }
             };
+            // See the SQLite twin: the counter must resume above the
+            // persisted revision or the guard discards post-restart writes.
+            let seen = inner.job_steps_revision.entry(agent_job_id).or_insert(0);
+            *seen = (*seen).max(revision.max(0) as u64);
             inner
                 .job_steps
                 .entry(agent_job_id)
@@ -1288,14 +1294,23 @@ const MIGRATIONS: &[(u32, &str, &str)] = &[
           conclusion TEXT NOT NULL,
           started_at_us BIGINT,
           finished_at_us BIGINT,
-          -- See the SQLite twin: guards against two reports for one attempt
-          -- committing out of order.
-          revision BIGINT NOT NULL DEFAULT 0,
           PRIMARY KEY (agent_job_id, step_id)
         );
 
         CREATE INDEX IF NOT EXISTS job_steps_order_idx
           ON job_steps (agent_job_id, kind, workflow_index);
         "#,
     ),
+    (
+        5,
+        "job-steps-revision",
+        // See the SQLite twin: guards two reports for one attempt committing
+        // out of order. Its own version rather than an edit to 4, because a
+        // database already at 4 from an earlier build of this branch would
+        // skip the change and fail every step write on an undefined column.
+        r#"
+        ALTER TABLE job_steps
+          ADD COLUMN IF NOT EXISTS revision BIGINT NOT NULL DEFAULT 0;
+        "#,
+    ),
 ];
@@ -156,16 +156,27 @@ pub(crate) async fn patch_timeline_records(
                     let Some(name) = &record.display_name else {
                         continue;
                     };
-                    // A PATCH carries the job's own record alongside its
-                    // steps. Its id is a UUID and `job_id.0` is the workflow
-                    // job key, so the id comparison below never matched it and
-                    // the job was reconciled in as a synthetic step — showing
-                    // up in run projections as an extra step named after the
-                    // job, and persisted there. Only task records are steps.
-                    if !matches!(record.record_type, Some(azdo::TimelineRecordType::Task)) {
-                        continue;
-                    }
-                    if record.id.to_string() == job_id.0 {
+                    // A PATCH carries the job's own record alongside its steps,
+                    // and reconciling that record in produced a phantom step
+                    // named after the job. Exclude container records rather
+                    // than whitelisting one step type: `type` is optional on
+                    // the wire, the official runner sends `Task` and this file
+                    // already treats `Step` as a step above, so an allow-list
+                    // silently drops real conclusions.
+                    let is_step = match record.record_type {
+                        Some(azdo::TimelineRecordType::Task | azdo::TimelineRecordType::Step) => {
+                            true
+                        }
+                        Some(
+                            azdo::TimelineRecordType::Job
+                            | azdo::TimelineRecordType::Phase
+                            | azdo::TimelineRecordType::Stage,
+                        ) => false,
+                        // Untyped: a step always hangs off the job record, which
+                        // is the same signal the annotation path above uses.
+                        None => record.parent_id.is_some(),
+                    };
+                    if !is_step {
                         continue;
                     }