Show the stage verdict atop the stage pane, with clickable artifacts

Mirror the server's derived verdict onto RunStep as a nullable
StageVerdict ({option, reason, reason_source, artifacts}, absent -> null),
matching internal/protocol/verdict.go.

Render a StageVerdictBlock at the top of the run pane, below the visit
tabs and above the facts, only when a verdict is present - a null or
empty verdict draws nothing, never an empty heading. The chosen option is
a ColoredChip in the stage outcome's existing colour; the reason is plain
pipelinesText().body that wraps without a maxLines clip.

The artifacts the reason names become inline, tappable references
(image/video open the shared ArtifactViewer, anything else uses the
existing openArtifact action) plus the same references as compact
FlowRow chips. Referenced names resolve to the visit's recorded
artifacts, deduplicated and in recorded order; reason text is split
around those names longest-match-first. No new dependency and no new dp
or sp literal.

android/ only.
This commit is contained in:
2026-10-16 19:17:26 +01:00
parent 8b0d7b1ecb
commit 007639948c
6 changed files with 512 additions and 0 deletions
+59
View File
@@ -3717,3 +3717,62 @@ visual review owns the device); no server that actually sends `title` was
available, so the titled layout is exercised by the unit tests and the fallback
path only.
## Stage verdict atop the stage pane, with clickable artifacts (16 Oct 2026)
A completed run visit now leads its stage pane with the server's derived verdict:
the chosen option as a badge, the concise reason in ordinary body text, and the
recorded artifacts the reason names as inline, tappable references plus the same
references as compact chips. `android/` only; nothing in the Pipelines server, its
Go source, the installer or the Docker files was touched, no run was started from
the app, and no device command was run (build + unit tests only).
- **Protocol.** `data/protocol/Message.kt` gains `StageVerdict` and an optional
`verdict` on `RunStep`, mirroring `internal/protocol/verdict.go`
(`{option, reason, reason_source, artifacts}` under the `verdict` wire name). It
is nullable and defaults to absent, so a running step or a pre-verdict server
parses cleanly to null.
- **One block.** New `ui/graph/StageVerdict.kt` holds the pure helpers and the
composable. `StageVerdictBlock` is rendered at the top of the run pane, below the
visit tabs and above the facts, only when the server reported a verdict; a null
verdict (or one with neither option nor reason) draws nothing — never an empty
heading or placeholder.
- **Badge.** The option is a `ColoredChip` in the *stage outcome's* existing colour
(`outcomeColor(step.outcome)`, the graph's palette the Timeline chips already
use), so the badge agrees with the graph rather than a new colour vocabulary.
- **Reason.** Rendered with `pipelinesText().body`, so it is readable plain
language, never a monospace JSON dump, and it wraps with no `maxLines` clip.
- **References.** `referencedVerdictArtifacts` resolves the verdict's referenced
names to the visit's recorded artifacts (recorded order, deduplicated, an
unrecorded/invented name dropped). `verdictReasonSegments` splits the reason
around those names — by full recorded name or basename, longest match first — and
the segments become inline `LinkAnnotation.Clickable` references coloured
`primary` with an underline. An image/video reference opens the shared
`ArtifactViewer`; anything else goes through the existing `openArtifact` action.
The same references are `FlowRow` chips (`VerdictArtifactChip`) with their type
glyph, so they can be tapped without hunting in the sentence.
- **Geometry.** Only existing tokens (`SPACING_M`/`SPACING_S`/`SPACING_XS`,
`ICON_STATUS_DP`); no new `dp`/`sp` literal and no new dependency.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1 from the wrapper
cache, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--no-daemon`):
- `:app:testDebugUnitTest` → `BUILD SUCCESSFUL`; the result XMLs aggregate to
**282 tests, 0 failures, 0 errors, 0 skipped**. New `StageVerdictTest` (5 cases:
split around every referenced name, basename for a slashed path, longest match
wins, a reason with no references, and name→recorded-artifact resolution) and
`ProtocolModelTest#runStepVerdictParsesWithItsReasonSourceAndReferencedArtifacts`.
- `:app:assembleDebug` → `app-debug.apk` **18,270,824 bytes**, sha256
`85847c6fe32498f38464741ca1b8f592dbbd7a9e1f34dd649121e723836b0903`.
- **APK publish.** `app-debug.apk` copied to
`~/.local/share/pipelines/data/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apk`
(`8b0d7b1` = short `HEAD`); `shasum -a 256` matched. The LAN URL
`http://10.0.0.249:8080/artifacts/167/1/pipelines-debug-wip-8b0d7b1.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18270824`.
Not verified in this pass: device captures of the stage pane at a narrow and a wide
window (the visual review owns the device, per the brief's device policy), so the
verdict layout is exercised by the unit tests and the compile only. No server that
actually sends `verdict` was available to the implementer, so the block's live
rendering against real data is deferred to visual review.
@@ -213,6 +213,22 @@ data class StageArtifact(
val url: String = "",
)
/**
* The plain-language outcome of one completed stage visit, derived server-side
* and mirrored from `internal/protocol/verdict.go` StageVerdict: the chosen
* option (the outcome and the target it routed to), a bounded one-line reason
* with its provenance ([reasonSource]), and the names of the recorded artifacts
* the reason refers to. A null on a step means the server reported no verdict
* (for example a running visit), so the pane shows no block at all.
*/
@Serializable
data class StageVerdict(
val option: String = "",
val reason: String = "",
@SerialName("reason_source") val reasonSource: String = "",
val artifacts: List<String> = emptyList(),
)
@Serializable
data class NotificationReceipt(
val destination: String = "",
@@ -265,6 +281,9 @@ data class RunStep(
val artifacts: List<StageArtifact>? = null,
@SerialName("artifacts_skipped") val artifactsSkipped: Int = 0,
@SerialName("artifacts_truncated") val artifactsTruncated: Int = 0,
// The server's derived plain-language verdict; absent (null) on a running step
// or a pre-verdict server, so the pane shows no block.
val verdict: StageVerdict? = null,
val sequence: Int = 0,
val stage: String = "",
val status: String = "",
@@ -491,6 +491,20 @@ private fun StageDetailBody(
}
}
// The verdict leads the run pane, above the facts: the chosen option,
// the concise reason and the artifacts it names. Absent when the server
// reported none, so no empty heading is ever drawn.
if (runContext && selectedStep != null) {
StageVerdictBlock(
verdict = selectedStep.verdict,
outcome = selectedStep.outcome,
status = selectedStep.status,
artifacts = selectedStep.artifacts.orEmpty(),
configuredServerUrl = configuredServerUrl,
fetchArtifactBytes = fetchArtifactBytes,
)
}
// Identity and result: always visible, never behind a collapse, so a
// freshly opened pane never reads as empty.
headline.forEach { field -> StageFieldRow(field) }
@@ -0,0 +1,279 @@
package net.awan.pipelines.ui.graph
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.LinkAnnotation
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.TextLinkStyles
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.style.TextDecoration
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.text.withLink
import net.awan.pipelines.data.protocol.StageArtifact
import net.awan.pipelines.data.protocol.StageVerdict
import net.awan.pipelines.ui.components.ColoredChip
import net.awan.pipelines.ui.components.runStateIcon
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.theme.ICON_STATUS_DP
import net.awan.pipelines.ui.theme.SPACING_M
import net.awan.pipelines.ui.theme.SPACING_S
import net.awan.pipelines.ui.theme.SPACING_XS
import net.awan.pipelines.ui.theme.pipelinesText
/**
* One piece of a verdict's reason: literal [text], or a reference to a recorded
* [artifact] the reason names. A null [artifact] is plain text.
*/
internal data class VerdictReasonSegment(val text: String, val artifact: StageArtifact? = null)
/**
* The recorded artifacts a [verdict] refers to: its own referenced names resolved
* to the visit's recorded [artifacts], in recorded order and deduplicated. A name
* the server never recorded is dropped, so only real files are ever offered, and
* no verdict or no referenced names yields nothing.
*/
internal fun referencedVerdictArtifacts(
verdict: StageVerdict?,
artifacts: List<StageArtifact>,
): List<StageArtifact> {
val names = verdict?.artifacts.orEmpty()
if (names.isEmpty()) return emptyList()
val wanted = names.toHashSet()
val seen = HashSet<String>()
val referenced = ArrayList<StageArtifact>()
for (artifact in artifacts) {
if (artifact.name.isEmpty() || !seen.add(artifact.name)) continue
if (artifact.name in wanted) referenced += artifact
}
return referenced
}
/**
* Splits [reason] into literal runs and references to the recorded [references]
* it names, by an artifact's full recorded name or its basename (mirroring the
* server's own reference matching). At the same index a longer token wins over a
* shorter one, so a full slashed path is never split inside a longer match. With
* nothing to reference the whole reason is one literal segment; an empty reason
* yields no segments.
*/
internal fun verdictReasonSegments(
reason: String,
references: List<StageArtifact>,
): List<VerdictReasonSegment> {
if (reason.isEmpty()) return emptyList()
if (references.isEmpty()) return listOf(VerdictReasonSegment(reason))
val tokens = ArrayList<Pair<String, StageArtifact>>()
references.forEach { artifact ->
tokens += artifact.name to artifact
val base = artifactBaseName(artifact.name)
if (base.isNotEmpty() && base != artifact.name) tokens += base to artifact
}
// Longest token first (stable), so a full name wins over its basename at the
// same index; a bare basename still resolves to the artifact named exactly so.
tokens.sortByDescending { it.first.length }
val segments = ArrayList<VerdictReasonSegment>()
val literal = StringBuilder()
var index = 0
while (index < reason.length) {
val match = tokens.firstOrNull { reason.startsWith(it.first, index) }
if (match == null) {
literal.append(reason[index])
index++
} else {
if (literal.isNotEmpty()) {
segments += VerdictReasonSegment(literal.toString())
literal.clear()
}
segments += VerdictReasonSegment(match.first, match.second)
index += match.first.length
}
}
if (literal.isNotEmpty()) segments += VerdictReasonSegment(literal.toString())
return segments
}
/** The last path segment of a recorded artifact name (`shots/x.png` -> `x.png`). */
private fun artifactBaseName(name: String): String =
name.substringAfterLast('/').substringAfterLast('\\')
/**
* The stage pane's Verdict block: the completed visit's chosen option as a badge
* in the outcome's existing colour, the concise reason as ordinary body text (never
* a monospace JSON dump, and it wraps rather than clipping), and the recorded
* artifacts the reason names as inline, tappable links plus the same references as
* compact chips. An image or video reference opens the shared full-screen viewer;
* anything else goes through the existing external-open action, so the block reuses
* the gallery's behaviour instead of re-deriving it.
*
* It renders nothing at all when the server reported no verdict ([verdict] null) or
* the verdict carries neither an option nor a reason, so there is never an empty
* heading or placeholder.
*/
@OptIn(ExperimentalLayoutApi::class)
@Composable
internal fun StageVerdictBlock(
verdict: StageVerdict?,
outcome: String,
status: String,
artifacts: List<StageArtifact>,
configuredServerUrl: String,
fetchArtifactBytes: suspend (String) -> ByteArray?,
modifier: Modifier = Modifier,
) {
if (verdict == null) return
val option = verdict.option
val reason = verdict.reason
if (option.isBlank() && reason.isBlank()) return
val text = pipelinesText()
val context = LocalContext.current
val scheme = MaterialTheme.colorScheme
val linkColor = scheme.primary
val colors = remember(scheme) { graphColors(scheme) }
val tint = outcomeColor(outcome.ifBlank { status }, colors)
val references = remember(verdict, artifacts) { referencedVerdictArtifacts(verdict, artifacts) }
val segments = remember(reason, references) { verdictReasonSegments(reason, references) }
var viewerArtifact by remember { mutableStateOf<StageArtifact?>(null) }
// The one tap behaviour the inline links and the chips share: media opens the
// viewer, everything else the existing external-open action.
val open: (StageArtifact) -> Unit = { artifact ->
val resolved = resolvedArtifactUrl(artifact, configuredServerUrl)
val media = artifactKind(artifact.contentType, artifact.name).let {
it == ArtifactKind.Image || it == ArtifactKind.Video
}
if (resolved != null && media) viewerArtifact = artifact else openArtifact(context, resolved)
}
Surface(
modifier = modifier.fillMaxWidth(),
color = MaterialTheme.colorScheme.surfaceContainerHigh,
shape = MaterialTheme.shapes.medium,
) {
Column(
modifier = Modifier.padding(SPACING_M),
verticalArrangement = Arrangement.spacedBy(SPACING_S),
) {
FlowRow(
horizontalArrangement = Arrangement.spacedBy(SPACING_S),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
Text("Verdict", style = text.sectionHeader)
if (option.isNotBlank()) {
ColoredChip(
label = option,
color = tint,
icon = runStateIcon(runStateOf(outcome.ifBlank { status })),
)
}
}
if (reason.isNotBlank()) {
// Rebuilt only when the segments, link colour or configured server
// change, so the tap targets never capture a stale server.
val annotated = remember(segments, linkColor, configuredServerUrl) {
buildAnnotatedString {
segments.forEach { segment ->
val artifact = segment.artifact
if (artifact == null) {
append(segment.text)
} else {
withLink(
LinkAnnotation.Clickable(
tag = "artifact:${artifact.url}",
styles = TextLinkStyles(
style = SpanStyle(
color = linkColor,
textDecoration = TextDecoration.Underline,
),
),
linkInteractionListener = { open(artifact) },
),
) { append(segment.text) }
}
}
}
}
Text(
text = annotated,
style = text.body,
modifier = Modifier.fillMaxWidth(),
)
}
if (references.isNotEmpty()) {
FlowRow(
horizontalArrangement = Arrangement.spacedBy(SPACING_S),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
references.forEach { artifact ->
VerdictArtifactChip(artifact = artifact, onClick = { open(artifact) })
}
}
}
}
}
val viewer = viewerArtifact
val viewerUrl = viewer?.let { resolvedArtifactUrl(it, configuredServerUrl) }
if (viewer != null && viewerUrl != null) {
ArtifactViewer(
url = viewerUrl,
name = viewer.name,
fetchBytes = fetchArtifactBytes,
onDismiss = { viewerArtifact = null },
video = artifactKind(viewer.contentType, viewer.name) == ArtifactKind.Video,
)
}
}
/** A compact, tappable chip naming one referenced artifact, with its type glyph. */
@Composable
private fun VerdictArtifactChip(artifact: StageArtifact, onClick: () -> Unit) {
val text = pipelinesText()
val kind = remember(artifact.contentType, artifact.name) {
artifactKind(artifact.contentType, artifact.name)
}
Surface(
shape = RoundedCornerShape(50),
color = MaterialTheme.colorScheme.surfaceContainerHighest,
modifier = Modifier.clickable(onClick = onClick),
) {
Row(
modifier = Modifier.padding(horizontal = SPACING_S, vertical = SPACING_XS),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
Icon(
imageVector = artifactIcon(kind),
contentDescription = null,
tint = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.size(ICON_STATUS_DP),
)
Text(
text = artifact.name,
style = text.label,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
}
}
@@ -137,6 +137,48 @@ class ProtocolModelTest {
assertEquals(0, without.artifactsTruncated)
}
@Test
fun runStepVerdictParsesWithItsReasonSourceAndReferencedArtifacts() {
val json = """
{
"type": "run",
"run_detail": {
"id": 167,
"steps": [
{
"sequence": 1,
"stage": "ui_reviewer",
"status": "succeeded",
"outcome": "approved",
"target": "#success",
"verdict": {
"option": "approved → success",
"reason": "Layout matches; see review.png",
"reason_source": "model",
"artifacts": ["review.png"]
}
},
{"sequence": 2, "stage": "implementer", "status": "running", "outcome": "", "target": ""}
]
}
}
""".trimIndent()
val run = PipelinesJson.decodeFromString(Message.serializer(), json).runDetail!!
val verdict = run.steps.first().verdict!!
assertEquals("approved → success", verdict.option)
assertEquals("Layout matches; see review.png", verdict.reason)
assertEquals("model", verdict.reasonSource)
assertEquals(listOf("review.png"), verdict.artifacts)
// A running step with no outcome/target carries no verdict, so the pane
// shows no block; a verdict with no artifacts defaults to an empty list.
assertNull(run.steps[1].verdict)
val noArtifacts = PipelinesJson.decodeFromString(
Message.serializer(),
"""{"type":"run","run_detail":{"id":1,"steps":[{"sequence":1,"stage":"a","verdict":{"option":"done → success"}}]}}""",
).runDetail!!.steps.single().verdict!!
assertEquals(emptyList<String>(), noArtifacts.artifacts)
}
@Test
fun pipelineDetailPopulatesInheritedAndWireNameFields() {
val json = """
@@ -0,0 +1,99 @@
package net.awan.pipelines.ui.graph
import net.awan.pipelines.data.protocol.StageArtifact
import net.awan.pipelines.data.protocol.StageVerdict
import org.junit.Assert.assertEquals
import org.junit.Test
class StageVerdictTest {
private fun artifact(name: String, contentType: String = "image/png") = StageArtifact(
name = name,
sizeBytes = 1,
contentType = contentType,
url = "/artifacts/167/1/$name",
)
@Test
fun segmentsSplitTheReasonAroundEveryReferencedName() {
val png = artifact("review.png")
val txt = artifact("report.txt", contentType = "text/plain")
assertEquals(
listOf(
VerdictReasonSegment("Approved: "),
VerdictReasonSegment("review.png", png),
VerdictReasonSegment(" shows the fix; "),
VerdictReasonSegment("report.txt", txt),
VerdictReasonSegment(" lists the checks."),
),
verdictReasonSegments(
"Approved: review.png shows the fix; report.txt lists the checks.",
listOf(png, txt),
),
)
}
@Test
fun segmentsMatchABasenameForASlashedPath() {
val nested = artifact("shots/wide.png")
assertEquals(
listOf(
VerdictReasonSegment("See "),
VerdictReasonSegment("wide.png", nested),
VerdictReasonSegment(" for the wide layout."),
),
verdictReasonSegments("See wide.png for the wide layout.", listOf(nested)),
)
}
@Test
fun aLongerNameWinsOverItsBasenameAtTheSameIndex() {
val bare = artifact("wide.png")
val nested = artifact("shots/wide.png")
// The full slashed path matches whole, not just its basename, so the
// reference resolves to the artifact actually named.
assertEquals(
listOf(
VerdictReasonSegment("shots/wide.png", nested),
VerdictReasonSegment(" is the shot"),
),
verdictReasonSegments("shots/wide.png is the shot", listOf(bare, nested)),
)
// A bare basename still resolves to the artifact named exactly so.
assertEquals(
listOf(
VerdictReasonSegment("wide.png", bare),
VerdictReasonSegment(" was captured"),
),
verdictReasonSegments("wide.png was captured", listOf(bare, nested)),
)
}
@Test
fun aReasonWithoutReferencesIsOneLiteralSegment() {
assertEquals(
listOf(VerdictReasonSegment("nothing referenced here")),
verdictReasonSegments("nothing referenced here", listOf(artifact("x.png"))),
)
assertEquals(
listOf(VerdictReasonSegment("no recorded artifact is named")),
verdictReasonSegments("no recorded artifact is named", emptyList()),
)
assertEquals(emptyList<VerdictReasonSegment>(), verdictReasonSegments("", listOf(artifact("x.png"))))
}
@Test
fun referencedArtifactsResolveNamesToRecordedFilesInRecordedOrder() {
val a = artifact("a.png")
val b = artifact("b.png", contentType = "text/plain")
val verdict = StageVerdict(
option = "approved → success",
reason = "b.png then a.png",
artifacts = listOf("b.png", "a.png", "invented.png"),
)
// Recorded order, the invented name dropped, only real recorded files.
assertEquals(listOf(a, b), referencedVerdictArtifacts(verdict, listOf(a, b)))
assertEquals(emptyList<StageArtifact>(), referencedVerdictArtifacts(null, listOf(a)))
assertEquals(emptyList<StageArtifact>(), referencedVerdictArtifacts(StageVerdict(), listOf(a)))
}
}