Core's task/action overhaul (core#21) made long work a run the host owns: the
action's route starts it and answers { runId } instead of doing the work
inside the request. The app had no notion of that, and the failure was silent
in the worst way — with no progressTopic, runAction cleared runningAction and
refetched on any 2xx, so a migrated action reported success the instant the
run was CREATED. A run that then failed showed nothing at all.

The response decides which protocol applies; no schema field selects it. A
body carrying a numeric runId means the work is not over, so the app follows
core:task:<runId> and lets the run's terminal status end the action.

That topic is retained, which is what makes this better than the stream it
replaces rather than merely equivalent:

- The snapshot IS the whole run so far, so subscribing after the POST has no
  race, and following a run that already finished works exactly like
  following one that just started.
- The end is the run reaching a terminal state, not a log line beginning with
  "done" — module output stopped being load-bearing.
- Backgrounding the app and returning resumes from `since`; the old stream
  lost whatever was pushed while it was away.

LiveClient learns retained topics to make that possible: a `snap` frame, the
per-topic `tseq` it carries, and the `epoch` that scopes it to one incarnation
of the topic. Resubscribing sends `since`/`epoch` so the server replays the
gap or re-snapshots. Resync is now emitted only for topics that cannot replay
— sending it for a retained one would tell the caller to go re-read REST and
undo the point of retaining.

Progress entities are the same shape a run reports, so ProgressFeed and
UpdateProgressCard render both paths unchanged. Two gaps closed while wiring
it: `phase` is carried forward on merge (counts from a download and an
extract must never be added together), and ProgressKind gained the kinds core
names plus an OTHER default, because the wire format allows any string and an
unknown kind used to take the whole event down with it.

progressTopic stays. It is deprecated, not gone, and modules and servers that
have not migrated still speak it.

Fields a viewer is not entitled to see arrive empty with their names in
`withheld` — the status still lands, so the button still finishes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

@@ -0,0 +42,4 @@
+    val reason: String? = null,
+    val error: String? = null,
+    val result: JsonElement? = null,
+    val finishedAtMs: Long? = null,

@@ -127,0 +217,4 @@
+     */
+    val resources: List<ProgressEntity>
+        get() = order.mapNotNull { items[it] }.filter {
+            it.kind != ProgressKind.LAYER &&

@@ -129,0 +231,4 @@
+     * counted, which is what that server meant.
+     */
+    private val downloadLayers
+        get() = layers.filter { it.total != null && (it.phase == null || it.phase == "download") }

@@ -178,0 +260,4 @@
+                        if (!sub.gap) {
+                            Log.w(TAG, "event on \"${sub.topic}\" dropped: collector fell behind")
+                        }
+                        sub.gap = true

@@ -248,1 +345,4 @@
         put("topic", sub.topic)
+        // resuming a retained topic: the server replays the gap, or sends a
+        // fresh snapshot when it no longer holds it (or the epoch moved)
+        sub.tseq?.let {

@@ -731,0 +760,4 @@
+        // The buttons are disabled while one runs; this makes that an
+        // invariant of the model rather than a property of the screen — with
+        // a run that lasts half an hour the window is no longer a blink.
+        if (_state.value.runningAction != null) return

@@ -775,3 +813,4 @@
                             actionError = msg ?: "action failed (HTTP $code)",
                         )
                         progressJob?.cancel()
+                    } else if (runId != null) {

@@ -794,0 +856,4 @@
+     * empty with their names in `withheld`. That is deliberate and needs no
+     * handling here — the status still lands, so the button still finishes.
+     */
+    private fun followRun(runId: Long) {

@@ -794,0 +937,4 @@
+        }
+        endRun(
+            if (run.status.isFailure) {
+                run.error ?: run.reason ?: "the run ${run.status.name.lowercase()}"

@@ -794,0 +908,4 @@
+                                    progress = _state.value.progress.pushLine(it),
+                                )
+                            }
+                            "status" -> ev.run?.let { if (it.status.isTerminal) finishRun(it) }

@@ -156,2 +168,4 @@
     }
 
+    @Test
+    fun `the pull rollup is not a layer`() {