291cec2bdae577ab948156a7e6de35a6f3d0c3fb
28 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
291cec2bda |
Show chat tool calls as expandable INPUT/OUTPUT chips
Render each assistant turn's tool calls the way the reference jarvis chat does: one compact chip per call showing the tool name, its duration and a spinner while it runs, with consecutive calls of a turn grouped into one wrapping row so the transcript stays scannable (ChatScreen AssistantParts / ToolCalls). Tapping a chip opens a floating panel over the transcript with INPUT as pretty-printed JSON and OUTPUT as monospace, plus copy actions. The panel is dismissible by tapping outside or its Close action and is positioned by ToolPanelPositionProvider so it never moves the conversation (the transcript scroll position is untouched while the overlay is open). A failed call is shown as failed and renders both its diff (when present) and an ERROR block. ERROR text now comes from the new toolErrorText, which prefers the server's error message over any partial output, while toolOutputText is the OUTPUT derivation again; toolFailed identifies the error state. While a turn streams, the transcript follows the newest content with a hard jump unless the operator has dragged away, driven by listState.interactionSource.interactions (DragInteraction.Start/Stop/Cancel) rather than programmatic scrolls. The running indicator and its live elapsed time derive from the turn's own start (ChatThread.elapsedMillis, an injectable clock in ChatStore) so they survive a chat switch. A reconnecting socket now settles every open chat and re-fetches its history (ChatStore.streamResumed, AppViewModel.observeConnection), and a server-pushed stream error with no session id settles the sole/active running turn with the server's message instead of leaving the indicator spinning. Tests: ChatFormatTest covers toolErrorText; new ChatStreamTest covers the streaming/elapsed/reconnect/stream-error guarantees against an injected clock; new ToolPanelPositionProviderTest covers the panel's below/flip/margin placement. README's chat section documents the follow-the-stream mechanism. |
||
|
|
d7f650032d |
Render assistant text as markdown in the chat transcript
Add a dependency-free CommonMark-subset parser/renderer (ui/chat/Markdown.kt): paragraphs, headings, fenced code, block quotes, bullet/ordered lists, tables, thematic rules and inline code/bold/italic/links/autolinks. The renderer turns blocks into themed, selectable Compose content: fenced code reuses the shared CodeBlock (existing whole-block copy action), tables are a bordered grid with a bold header, links use LinkAnnotation.Url, and inline code/headings use the shared type roles. ChatScreen.MessagePart now calls MarkdownText(part.text) for PART_TEXT instead of a single plain Text; the assistant message stays one SelectionContainer, so all of it remains selectable and long content stays inside the bubble. Geometry reuses the chat tokens (CHAT_ITEM_GAP promoted private -> internal). Add MarkdownTest with 10 unit tests covering fences/language, unterminated fences, soft-wrap joining, headings/rules, lists, tables, inline spans, bare-URL autolinks and snake_case non-emphasis. Document the change in android/README.md. |
||
|
|
0718f5ba6f |
Add the Chat destination and hold several conversations at once
Entry point: the floating destination pill gains a Chat icon between Runs and Settings; it stays a single non-wrapping Row of 48dp targets using the named DESTINATION_ITEM_SIZE/DESTINATION_ITEM_GAP tokens, clear of the existing 88dp reserve, so it stays narrow however many destinations it holds. Protocol/transport: new data/protocol/Chat.kt mirrors the brokered chat wire shapes; Message gains the optional chat_* payloads, PipelinesClient forwards unsolicited frames (chat_event/chat_permission) to a new events flow instead of dropping them, and PipelinesRepository exposes the typed chat calls (sessions, create, messages, prompt, interrupt, reply). State: ui/chat/ChatStore.kt is an Android-free multi-chat holder; every open chat keeps its own conversation, running flag, composer draft and scroll position, open/activate report when history must be re-synced so a running session refreshes on return instead of showing a stale copy, and busy/read-only sessions refuse writes. Surface: ui/chat/ChatScreen.kt lists the server's sessions with running/busy/ read-only status and an open-chat strip to switch between conversations (chip X closes only that chat); the conversation is a bottom-anchored transcript of user bubbles, reasoning, assistant text and tool-call chips that expand to INPUT (pretty JSON)/OUTPUT (monospace), edit-family calls render a diff card derived from oldString/newString, and pending chat_permission frames surface an approval bar answered via chat_reply. New chat creates and opens a session. The manifest sets windowSoftInputMode=adjustResize for the composer. Tests: ChatProtocolTest, ChatFormatTest and MultiChatStateTest cover the wire shapes, formatting and the multi-chat model (switching preserves each conversation, a running session re-syncs on return, per-chat drafts/scroll, busy read-only, background events land on their chat). README documents the slice and its evidence. |
||
|
|
e5bde981ee |
Modernise the workflow graph's visual language
Replace the old terminal-diagram look on the Graph tab with a tonal surface language, keeping the same information and every outcome hue. - Nodes: stages are rounded rectangles from MaterialTheme.shapes.medium, terminals become pills (height/2). Fills are tonal surfaces via the new pure tonalFill(surface, accent, fraction) with a soft outlineVariant border instead of a flat fill plus hard outline. - Type: node names use the cardTitle role and outcome labels the label role, with theme line height/letter spacing; the [brackets] and all-caps are gone (nodeDisplayLabel renders Success/Failure title-cased in colour). - Edges: StrokeCap.Round/StrokeJoin.Round, bends rounded by one ROUTE_CORNER_RADIUS (cornerCutRadius clamps short segments), filled arrowheads scaled as edgeStrokeWidth * ARROW_HEAD_SCALE, and labels on a shared DrawScope tonal chip. - Spacing: named dp tokens instead of ad-hoc literals. Adds pure-logic unit tests (WorkflowGraphTest, GraphPaletteTest) and documents the change in android/README.md. Verified: :app:assembleDebug and :app:testDebugUnitTest both BUILD SUCCESSFUL (207 tests, 0 failures) with no Kotlin warnings. |
||
|
|
8b39c087fd |
Animate the active stage and executed edges in the run graph
Show what is happening while a run is live. The executing stage now carries a subtle pulsing halo (replacing the blink) and a live ticking elapsed badge derived from the run's current visit start. Executed edges carry a directional flow of light dots along the path; a finished stage settles into its static colour. A finished run never animates, the animation pauses when the graph is off screen, and with the system animation setting disabled it falls back to a static but clearly marked running state. The per-frame visual state and should-animate decision live in pure functions (GraphMotion.kt, Format.kt secondsSince; GraphSemantics exposes executing and currentStageStartedAt) with unit tests and no frame-timing assertions. Adds GraphMotionTest and extends GraphSemanticsTest and FormatTest. |
||
|
|
1e7862e7c9 |
Make pass/fail edges the loudest lines in the run graph
Treat `success` and `error` as the emphasised outcomes so pass/fail is obvious at a glance and from a distance. An executed pass/fail edge now uses PASSFAIL_EDGE_STROKE=7f (was 3f), a same-hue, more saturated stroke (PASSFAIL_SATURATION=1.6f via the new pure boostSaturation helper) and a matched PASSFAIL_ARROW_HEAD_SIZE=20f arrowhead. Other executed outcomes keep EDGE_STROKE=3f and not-executed routes the finer INACTIVE_EDGE_STROKE=2.5f, so the two decisive outcomes dominate. All widths, the arrowhead size and the saturation factor are named tokens chosen by edgeStrokeWidth/edgeArrowHeadSize/edgeStrokeColor; the old 12f arrowhead literal at the call site is gone (drawArrowHead now takes the size as a parameter). Outcome hues are unchanged; the boosted stroke keeps the original hue and value. The run Graph tab help line notes that executed success and failure routes are drawn thickest, and the definition-only view gets the same emphasis since every route counts as executed there. New unit tests cover the saturation maths (hue/value/alpha preserved, safe and clamped) and the per-edge width/arrowhead/colour choices. |
||
|
|
9c47527def |
Make executed vs not-executed unmistakable in the run graph
Carry the two states structurally instead of by fading, so the difference
survives a screenshot, a dim screen and a colour-blind reader.
- Executed edges: solid full-colour stroke plus an arrowhead.
- Not-executed edges: dashed muted stroke (INACTIVE_DASH_EFFECT), no arrowhead.
- Executed nodes: keep their fill and normal border.
- Not-executed nodes: no fill, dashed muted border and a muted but legible label.
- Add a one-line legend (GRAPH_LEGEND / GraphLegendEntry / LegendSwatch) pinned
TopStart, rendered only when a run is selected.
- Replace the private EdgeLayout.isExecuted/inline visited check with the shared
edgeIsExecuted/stageIsExecuted predicates and remove the alpha-based dimming.
- Update the KDoc and the run Graph tab help text ("solid ... dashed and outlined").
Tests: executed/inactive predicates over the definition view and a RunGraphState,
the dash pattern as a positive even-length rhythm, and the legend naming both
states with executed first.
|
||
|
|
54af4535d7 |
Add remembered filters to the runs and pipelines lists
Give each list a filter control, remembered per list across restarts like the sort, combined with AND. Filters narrow; the (later) omni search will find, so they are kept distinct. - ui/screens/ListFilter.kt: RunTimeRange (AnyTime default, Today, Last7Days, Last30Days), RunPresence (Any default, HasRuns, NoRuns) and the RunFilters/PipelineFilters data classes, with one pure predicate per facet (runMatchesStatuses, runMatchesPipeline, runMatchesTimeRange, pipelineMatchesPresence, pipelineMatchesLastRunStatus) and the AND-combining filterRuns/filterPipelines. A default narrows nothing; an empty status set means "any"; the time windows are inclusive calendar days; a blank, unparseable or future timestamp never matches a finite window; a runless pipeline has no last-run status; fromStorage tolerates stale/unknown/blank values; encodeRunStates/decodeRunStates round-trip the status set. - ui/components/FilterMenu.kt: the shared top-bar control both screens use - an IconButton with a numeric active-filter count badge opening the caller's sections plus one Clear filters action (disabled when nothing is active), the count folded into the icon description, and a menu capped to the window and clear of the navigation inset so it stays scrollable rather than clipping. - PipelineListScreen.kt/RunHistoryScreen.kt wire the control and predicates; the existing name search on pipelines stays a separate field, and the new pipeline facets depend on the run history. - ui/components/States.kt: EmptyState gains optional actionLabel/onAction so both lists distinguish "nothing exists" from "nothing matches the current filters" and offer Clear filters only in the latter. - data/SettingsRepository.kt + ui/AppViewModel.kt: store each facet under its own stable key as a StateFlow, exactly like the sort keys; the screens resolve the stored strings so the repository stays unaware of the UI enums. Verified on this tree with :app:testDebugUnitTest, assembleDebug, and emulator-5556 persistence and captures; recorded in android/README.md. |
||
|
|
1c925d72f7 |
Remember sort options for the pipelines and runs lists
Add a per-list sort control to each top bar and persist the choice in SharedPreferences so it survives restarts. - ui/screens/ListSort.kt: PipelineSort and RunSort enums plus pure comparators with explicit tie-breaks, and sortPipelines/sortRuns. ServerOrder/NewestFirst remain the defaults; a still-executing or unparseable-timestamp run sorts last. - ui/components/SortMenu.kt: the shared top-bar control, a distinct IconButton opening a Material 3 DropdownMenu of every option plus a divider and Reset, with the active choice checked. - data/SettingsRepository.kt + ui/AppViewModel.kt: store the sort key per list as a StateFlow; fromStorage falls back to the default for a stale/unknown/blank value. - ui/Format.kt: share parseInstant and durationSeconds so the printed duration and the sort key cannot disagree; PipelineLastRun.kt reuses the shared latest-run fold. - PipelineListScreen.kt/RunHistoryScreen.kt wire the control and sort; groupRunsByDay preserves the comparator's order. - ListSortTest.kt covers the comparators and storage fallback; RunGroupingTest.kt gains an explicit-order case. Verified on this tree with :app:testDebugUnitTest (167 tests, 0 failures), assembleDebug, and emulator-5556 persistence, the sort control, and Reset; captured in android/README.md. |
||
|
|
3480461ffb |
Show the last run on every pipeline row
Each pipeline row in the Android list now renders its most recent run: the status chip, how long ago it started, its recorded duration and its run id. Pipelines that have never run say "no runs recorded" instead of leaving a blank line, and the line is withheld until the run history has loaded so a missing history is never reported as "no runs". The list_runs history already arrives whole (id DESC), so the join is client-side: PipelineLastRun.kt folds it onto a Map keyed by pipeline id, recency decided from the timestamps with the higher run id breaking an exact tie, and formats "ago · duration · run N", omitting any genuinely absent fragment. The change is android/-only, adds no server field or dependency, keeps the existing title/secondary structure and selected-row highlight, and never starts a run. PipelineLastRunTest covers most-recent-wins, no runs, unknown pipeline id, equal timestamps, a bad timestamp, an unknown status word, the formatRanAgo scales and the "no runs recorded" wording. README records the verification: :app:testDebugUnitTest (153 tests, 0 failures) and a full --rerun-tasks assembleDebug (17,863,337 bytes, sha256 b2255066…). |
||
|
|
24584d820f |
Give run status an app-owned palette with correct hues
Run status was mapped onto Material roles, so a succeeded run read amber (tertiary) and a running run read mint (primary). Replace that mapping with an app-owned RunStatusPalette: Running/Active blue, Succeeded green, Failed the app error red, Interrupted amber, Canceled muted grey, Queued neutral grey and Unknown a low-key surface grey, each with a one-line rationale. runStateColor is now a pure lookup over the palette. Keep each state's distinct material glyph and text label so status is never colour-only, and add a WCAG-AA contrast test for every status colour against the dark surface plus hue-specific assertions. Leave the graph's stage-outcome palette untouched. The timeline's step chips are a stage outcome, not a run status, so point them at the shared graphColors/ outcomeColor factory (extracted from WorkflowGraph) to agree with the graph, and factor the shared ColoredChip pill out of StatusChip so neither repeats the layout. Document the change and its evidence in android/README.md. |
||
|
|
cd85f6954b |
Render artifact thumbnails with an honest loading/failure state
The artifact grid could show failure placeholders that were never earned: a server-relative artifact url that failed to resolve against the configured server was fetched anyway and blamed with the "!" failure mark, and the loading state was a bare "…" text. - Pass the resolved url (nullable) into ArtifactImage; a null short-circuits to a new distinct Unavailable state (LinkOff glyph) and issues no request, so a fetch that was never attempted is never drawn as a failure. - Reserve Error/"!" for a fetch or decode that was actually attempted. - Replace the "…" text with a real Material 3 CircularProgressIndicator. - Resolve gallery artifact urls in one shared helper (resolvedArtifactUrl) so the image tile and the non-image row cannot disagree; non-image artifacts keep their file-type icon. - Add unit tests covering resolution against the configured server and the null (unconfigured) case. |
||
|
|
3deff18572 |
Render a compact identity for covered Android panes
On a wide window, a covered pane in the stack used to render a squeezed copy of a full pane, so a covered entry showed a truncated title and a crushed tab rail. A covered pane now renders only a compact identity: a centred title plus at most one status/subtitle line, with no tab rail, list, gallery or scroll body drawn into the sliver. - SlidingPaneStack's pane lambda receives a covered flag; on a wide window a covered level composes only the new PaneIdentity, while the list, both detail screens and the stage pane early-return from their covered branch after their data-loading effects. - Adds MIN_COVERED_PANE_WIDTH_DP (112.dp); peekStripsDp shows at most budget / MIN_COVERED_PANE_WIDTH_DP covered peeks and folds the oldest levels into a single "<n> more" edge indicator rather than squeezing them below the minimum. - The fixed PEEK_BUDGET_DP (224.dp) and the constant active-pane width are unchanged; the peek tap, Back and the narrow layout keep the same behaviour. - Rewrites SlidingPaneStackTest (10 cases) for the fold rule, minimum width, constant active width and inset/geometry invariants, and records the evidence and the unreachable-fold gap in android/README.md. |
||
|
|
206953e067 |
Show an Android run stage's Model/Provider in the headline
Surface a run stage's recorded Model and Provider configs in the stage
pane's always-visible headline instead of leaving them inside the
collapsed Definition section, so the operator sees them without expanding
anything, and stop rendering them twice.
- StageDetailPane.kt gains the pure STAGE_CONFIG_HEADLINE_LABELS
({"Model", "Provider"}), stageConfigHeadlineFields(definition) and
remainingDefinitionFields(definition). StageDetailBody renders
headlineFields(runFields) + stageConfigHeadlineFields(definition) as the
headline and remainingDefinitionFields(definition) inside the collapsed
Definition section; both derivations are remember(definition)-keyed and
the run-evidence split stays runStepFields/headlineFields/evidenceFields.
- The definition-only, never-visited stage keeps its existing look; the
Definition section no longer repeats Model/Provider because they are now
headline facts, and everything else stays as before.
- StageDetailSheetTest adds
definitionModelAndProviderArePromotedToTheHeadlineWithoutDuplication and
aDefinitionWithNoConfigsPromotesNothing.
- android/README.md records the pass: the reported "content lost" symptom
is not reproducible at
|
||
|
|
791d3dd3ff |
Swap Android detail sections in place instead of sliding them
Selecting a section in a run or pipeline detail now cross-fades the body in place rather than sliding it sideways, so a tap on the rail or tab row is an ordinary tab change with no lateral motion and nothing to swipe. - DetailTabs.kt drops the HorizontalPager for section bodies and renders only the selected section behind a short Crossfade (SECTION_SWAP_MILLIS = 180). Level navigation (list -> detail -> stage pane) still slides via the unchanged SlidingPaneStack. - Each section's saved state (its LazyColumn scroll) is kept under its stable tab key with rememberSaveableStateHolder().SaveableStateProvider, so returning to a section restores where the operator left off instead of resetting it. - The rail/tab-row selected state and tab semantics are unchanged. - Update the two call sites' stale "pager" comments and refresh the README section describing the section selector. |
||
|
|
0b373d0c65 |
Make Android pane navigation adaptive with a fixed peek budget
Replace the per-level peek with a fixed total peek budget on wide windows and drop the stack entirely on narrow ones, so a folded phone loses no width to dead peek space and a deep stack never reserves more than the budget. - SlidingPaneStack gains a `wide` parameter (the callers pass the existing isWideLayout value). On a narrow window the budget is 0dp, so every pane's open offset is 0 and each opened pane is a full-window screen that springs in over the last; Back, the gesture and the pane's own back control pop one level and nothing is left on the left. - On a wide window peekBudgetDp (PEEK_BUDGET_DP, 224dp) is the fixed total space shared between the covered panes, independent of depth, so the active pane's left edge is always exactly the budget and its width (hostWidth - budget) stays constant as levels are added. paneOpenOffsetsDp widens the leftmost strip first so it stays tappable after the start inset (min of PEEK_WIDTH_DP and the platform minimum interactive size), then splits the rest evenly. peekBudgetDp clamps so the active pane never collapses below MIN_ACTIVE_PANE_WIDTH_DP and paneWidthDp is never negative. All geometry is derived from the named tokens, the measured host width and the system insets - no new literals. - The peek-strip hit targets now come from the shared offsets, and panes remain opaque, inset inside the safe area, hidden from accessibility when covered, and opening/closing stay exact mirrors through the same animators. PaneState documents the narrow (no peek) rule. - SlidingPaneStackTest is rewritten around the pure budget geometry (narrow spends no peek, the wide active pane is constant width, four levels share one budget with every strip tappable, the budget clamps, tiny hosts never go negative), and android/README.md records the pass, its evidence and what was not verified. |
||
|
|
5314542c13 |
Make the Android stage detail a pane and add an artifacts gallery
Turn the stage detail into the rightmost pane of a bounded three-level stack and show every run artifact in a summary gallery. - The stage detail opens as a real level-2 pane from both entry points (a Timeline row and a graph node). StageDetailPane is wrapped in the same Scaffold/TopAppBar with a back arrow as the other panes, and its identity/result facts (status, outcome, target, duration, visit, model target) render outside any collapsible so a fresh pane is never empty. StageDetailSheet, ModalBottomSheet and RightSlidingPanel are removed. - SlidingPaneStack replaces SlidingMasterDetail: pane 0 fills the host, panes 1 and 2 overlay at peek*level, each covered pane keeps one tappable peek strip, and MasterPane/backStep/popTo/MAX_PANE_DEPTH are the pure model. The peek tap, the pane back arrow, the system Back button and the predictive-back gesture all pop exactly one level. - New pure runArtifactGroups(steps) groups a run's artifacts by stage and visit (stable order, duplicates kept, empty run -> empty) and artifactsEmptyMessage distinguishes the running "capture pending" case. ArtifactGallery renders image thumbnails (tap opens full size) and non-image rows with name, size, content type and open/copy; urls resolve through ServerUrl, never a hardcoded host. - Run Summary shows the run gallery and the stage pane shows that visit's group, keeping the existing per-visit artifacts summary and notes. - Tests updated/added (PaneStateTest, SlidingPaneStackTest, ArtifactGroupsTest, ArtifactGalleryTest, StageDetailSheetTest, refreshed DetailTabsTest/PipelinesNavTest, CollapseRemovalTest kept green) and android/README.md records the pass, evidence and not-verified list. |
||
|
|
059c85add8 |
Show per-visit artifacts in the Android client and fix the top inset
Implements four Android-only client changes (no server, Go, installer or
Docker changes; nothing under android/ was left uncommitted).
- Per-visit artifacts: model StageArtifact{name, size_bytes, content_type,
url} plus artifacts/artifacts_skipped/artifacts_truncated on RunStep with the
exact internal/protocol/runs.go wire names, covered by ProtocolModelTest.
Add a dedicated artifacts section to the stage detail sheet: one row per
file with name, humanBytes size and content type, open (ACTION_VIEW) and
copy-link actions, resolving the server-relative url against the configured
server URL (never a hardcoded host) and disabling those actions with a hint
when none is set. Images render an inline thumbnail with a full-size view on
tap; other types get a type icon. Empty/partial copy matches the TUI
("capture pending", "not recorded for this visit", partial-capture notes).
Timeline rows carry a subtle AttachFile indicator via a pure hasArtifacts
helper. Pure helpers (humanBytes, resolveArtifactUrl, isImageContentType,
artifactsSummary, artifactCaptureNotes, artifactMetaLine) carry unit tests.
- Collapsed defaults and self-describing titles: rememberSectionExpansion now
tracks the set of expanded keys (default emptySet) so every inner section in
the run detail and pipeline detail starts collapsed while operator choices
still persist across configuration changes. Evidence sections are titled
from the correlated step/stage/visit and backend identity instead of a bare
index; field sections fall back to their prefix so a blank key never yields
an empty title. Covered by DetailTabsTest.
- Single top inset: zero the outer Scaffold contentWindowInsets so the inner
Material 3 app bars own the status-bar inset once; the connection banner
owns the status-bar inset while visible (NavHost consumes it below), and the
floating destinations pill clears the navigation bar.
- Publish the debug APK as a run artifact named by the short SHA, documented
with the verified LAN URL and sha in android/README.md.
Verification (unit tests, assembleDebug, live-server APK and run 55 step 4
artifact fetches, emulator narrow/wide drives) is recorded in android/README.md.
|
||
|
|
d00bd37833 |
Give every outcome its own colour and reach stage visits from the Timeline
- GraphPalette: a curated fixed palette plus a deterministic outcome-to-index mapping (no hashCode() % n); every colour is measured at >= 4.5:1 against the dark surface. Node fills differ by kind, and selection inverts the fill. - Run detail: the Steps tab becomes Timeline, one compact line per recorded visit. The stage detail sheet takes the ordered visits plus an initialVisitIndex and shows a visit 1..N tab row only when there is more than one visit; the timeline opens the tapped visit, the graph the most recent. - List pane: pipelines and runs share one ListRow (flat surface, thin divider, leading element, title plus secondary line) with a tonal selected row, and the wide list pane collapses to a 56dp strip. - Navigation: the bottom bar becomes a floating three-icon destination pill at the bottom right with Role.Tab selected semantics, used on both window widths, with 88dp reserved so nothing scrolls under it. - Icons come from the already-declared material-icons-extended; no new dependency. Implemented by pipeline run 55 (pipeline 9 v6). Its ui_reviewer stage failed on a malformed model result rather than on this work, so the change was verified by hand: assembleDebug plus 93 unit tests pass, and the run's captures were reviewed (graph colours per outcome, Timeline entries, visit tabs, selected list row, floating pill). |
||
|
|
370eaaed1f |
Let the detail tabs collapse and rebuild the step and source layouts
DetailTabs: give every tab a meaningful ImageVector from the core Material icon set and turn the wide rail into a collapsible one. A rememberSaveable railExpanded flag plus an accessibility-labelled "Collapse tabs"/"Expand tabs" control shrink the rail to a narrow icon-only strip and back; the collapsed tile still names its tab via the icon's content description and still marks the selected tab by container colour and tab semantics, and the content box reclaims the rail width. Narrow windows keep the top PrimaryScrollableTabRow. railWidthDp is a pure, unit-tested predicate. RunDetailScreen: render a step's metadata as aligned label/value rows (KeyValueRow) instead of a ragged stack of lines, paired into two columns on wide windows (status/outcome, duration/visit, target/session, agent/model target) and a single column on narrow ones. Evidence (input, output, transcript, file changes, notifications, control diagnostics) fills its card in full-width monospace with a shared padding/line height, and the vertical rhythm is one bottom gap per step with no doubled gap for a step without expandable detail. The timeline glyph and connector stay aligned with the step title. All previously shown fields are retained. PipelineDetailScreen/CodeBlock: the Source tab now fills the whole tab area with the tab's single LazyColumn owning all scrolling (CodeBlock gains an optional maxHeight = null that renders unbounded; the default bounded behaviour is unchanged for other callers). It renders the parsed definition as one collapsible section per stage (key, type) built from the same stageDefinitionFields/StageFieldRow the stage detail sheet uses, covering prompt, output, tools, configs, edges (outcomes with resolved targets and #success/#failure terminals), memory, limits and notify policy while skipping absent fields. A Raw toggle reveals the exact markdown and a copy action copies the whole definition. Extract shared formatting helpers (fileChangeLine, notificationLine, fileChangesSummary, controlVisitLabel) into Format.kt and expose StageFieldRow/StageTypeChip/stageDefinitionFields so the sheet and the Source tab agree. Add StageDetailSheetTest and StepMetaTest, extend DetailTabsTest (icon distinctness, rail width) and FormatTest, and record the build, unit-test and emulator-screenshot verification in android/README.md; the captures stay in the git-ignored android/captures/space_pass/. Assisted-by: DeepSeek V4.1 Flash |
||
|
|
238f3fbdd8 |
Give every graph edge its own track and open a stage detail sheet on tap
Allocate a distinct source port, target port, across-run lane and vertical track per edge in the pure layoutGraph (stable edge-id order), mirroring the TUI's per-edge routing, so no two routes share a row or column; each outcome label follows its own edge's track. Rewrite routePoints to build every polyline from those precomputed ports/lanes/tracks instead of shared corridor constants, keeping runs axis-aligned and the layout deterministic. Add pure hitTest/toGraphPoint plus a tap detector that maps taps back through the current transform: tapping a node calls onStageTap, tapping empty space does nothing, and pan/zoom keep working. Add StageDetailSheet, a Material 3 ModalBottomSheet overlay (near full height, scrollable, responsive on wide windows) showing the stage definition and, on a run graph, that run's step; wire it into the pipeline and run graph tabs. Extend WorkflowGraphTest with the no-shared-collinear-run invariant, distinct port, determinism and hit-test cases. |
||
|
|
1828171a9c |
Give the detail screens tabs, styled code blocks and a foldable layout
- Pipeline detail and run detail are now tabbed: run detail has Summary, Graph, Input, Output, Evidence and Steps, pipeline detail has Summary, Graph and Source, with the version list in Summary. The graph gets a tab of its own, so it uses the whole content area with its Fit and expand controls. Selection is remembered and the tabs carry real tab semantics. - The code-like blocks (Input, Output, Source, prompt, transcripts) are styled content cards with a label header, monospace body, a copy action and a bounded height that scrolls internally, instead of a raw bordered div. - Content inside a tab breaks down into collapsible inner sections (DetailTabs.kt, CodeBlock.kt), reusing the existing section component with remembered state. - Foldable layout is driven by window width (WindowSize.kt): narrow windows keep the single-pane tabs, wide windows use list-and-detail side by side with the detail capped to a readable width. Verified: :app:assembleDebug and :app:testDebugUnitTest succeed offline with 60 tests and 0 failures (new WindowSizeTest and DetailTabsTest), and the reviewer drove every tab plus both a narrow and a wide window on the emulator (captures in android/captures/tabs_pass/view/). The implementer's own capture set in that directory is unusable: it wrote screencap's multi-display warning into the files (they begin with ASCII '[Warning', not the PNG magic), so only the reviewer's captures were reviewed. |
||
|
|
e843aa08a8 |
Restructure the Runs area and add collapsible sticky sections
Four related UI changes, all requested after using the app on a phone. - Graph pinch zoom is now anchored to the gesture centroid. The handler dropped the centroid and the canvas scaled about the content origin, so a pinch slid the graph away from the fingers. zoomAbout() keeps the content point under the fingers fixed, applies the pan and then clampOffset, with unit tests proving the centroid point is unchanged and the scale and bounds are respected. - Pipeline detail and run detail now use a LazyColumn of collapsible sections (shared Sections.kt header, rotating chevron, animateContentSize) whose titles stick to the top while their content scrolls beneath, with per-section state remembered and exposed to accessibility. Steps and session evidence stay lazy list items instead of nested scrollables. - The Runs list is rebuilt: the raw result preview is gone, failures show a two-line diagnostic in the error colour, each run has a colour-coded status chip with a matching icon per state (RunStatus.kt, core Material icons - no new dependency), the usage aggregates render as a metrics block with a formatted average instead of a run-on line of seconds, and runs are grouped by day under sticky date headers. - Run detail steps are a timeline: a status dot joined to the next step, the stage and visit number, an outcome chip and the duration, with input, output, transcript, file changes and notifications behind a per-step 'Show details'. - One centralised type hierarchy (Typography.kt) for screen title, section header, card title, subtitle, body and monospace data, applied across the list, the cards and both detail screens. Verified: :app:assembleDebug and :app:testDebugUnitTest succeed offline with 53 tests and 0 failures (new FormatTest, RunStatusTest and RunGroupingTest; WorkflowGraphTest 23 to 27), and the app was driven on the emulator with screenshots of the runs list states, the sticky date header, the steps timeline, an expanded step, a collapsed section and the sticky section header. |
||
|
|
1a890d8c31 |
Draw workflow-graph edges as straight runs and give the graph a bigger panel
A user reading the graph on their phone said it was not clear what happened, and asked for the TUI's straight arrows and a larger panel. - Edges are now axis-aligned orthogonal polylines instead of Bezier curves: the stage-to-stage runs and the routes into the bottom-row #success/#failure terminals are horizontal/vertical segments joined at right angles, matching the Go TUI's routing, and every arrowhead now points along the direction of its final segment instead of the straight source-to-target chord (which pointed wrongly as soon as a route turned a corner). Routing is a pure function. - The graph panel is a sensible share of the window height on both screens instead of 360dp/340dp, and a new expand/collapse control beside 'Fit graph to view' grows it to nearly the full height. Verified: :app:assembleDebug and :app:testDebugUnitTest succeed offline with 42 tests and 0 failures (WorkflowGraphTest 15 to 23, covering the orthogonal routing and arrowhead direction), and the app was driven on the emulator with before/after screenshots of a pipeline graph, a run graph with the executed route highlighted, a panned state and the expanded panel. |
||
|
|
9ca775291b |
Give the Android client a dark-first Material 3 look and TUI-style graph terminals
Three UI changes requested after reviewing the first on-device screenshots:
- Dark-first theme: the app now owns its colour scheme instead of following the
system wallpaper. Theme.kt defaults to a deliberate darkColorScheme built from
a mint/teal seed with an amber tertiary (new Color.kt) so it matches the dark
Pipelines TUI; dynamic colour is gone and a complete light scheme is retained
for when it is explicitly requested. themes.xml/colors.xml give the app a dark
window background and dark system bars with light icons, so launching never
flashes light.
- Workflow graph matches the TUI: the #success/#failure terminals now share a
lower row under the stage row, with arrows entering their top borders and the
error -> #failure route leaving the bottom of its source stage, mirroring
internal/tui/graph_layout.go ('Terminals share a lower row...') and graph.go's
'[FAILURE] [SUCCESS]' bottom row. Fit-to-content, pan clamping, the Fit
action, run highlighting and the TalkBack description are preserved.
- More style: consistent Material 3 top app bars for Pipelines, Runs and
Settings, the new colour scheme applied across the screens and state
components, and monospace retained for hashes, source and run input/output.
Verified on the host and on the device: :app:compileDebugKotlin, :app:assembleDebug
and :app:testDebugUnitTest succeed offline with 34 tests and 0 failures
(WorkflowGraphTest grew to 15 tests covering the terminal row, bottom exits and
fit/clamp), and the app was run on the Pixel_Fold_API_36 emulator in dark mode
against the live server: the whole 4-stage graph renders with its terminal row,
and the list, detail and settings screens use the new theme.
|
||
|
|
cee9fb2f79 |
Fix graph fitting, pan bounds, auto-connect and run wording in the Android client
An emulator run against the live server exposed four usability defects and one
legibility defect, all fixed here:
- The workflow graph was not fit-to-content: 3- and 4-stage graphs showed only the
first columns until the user panned. The initial view now fits and centres the
whole graph, scaling down when it is wider than the viewport.
- A panned graph could be dragged completely out of view with no way back. Pan is
now clamped so content stays visible, and a 'Fit graph to view' action restores
the fitted view.
- The app did not connect on launch even with a saved server URL. It now connects
from the saved URL using the existing bounded backoff; an explicit Disconnect
still stays authoritative for the session.
- The runs list said 'N steps' while run detail said 'N recorded visits'. Both now
use the server's own vocabulary ('N completed visits' / 'N recorded visits')
through one shared helper in Format.kt.
- Outcome labels: labels are drawn after all curves so none is crossed, dimmed
labels use onSurfaceVariant, and executed labels no longer resolve to
near-invisible container accents ('rejected' measured ~1.2:1 before).
Verified: :app:compileDebugKotlin, :app:assembleDebug and :app:testDebugUnitTest
succeed offline with 28 tests and 0 failures (WorkflowGraphTest grew to 9 tests
covering fitScale, clampOffset extremes and label slots), and the app was driven
on the Pixel_Fold_API_36 emulator against the live server with before/after
screenshots and no FATAL or Compose exception in logcat.
|
||
|
|
2881256af3 |
Fix workflow-graph crashes and label layout in the Android client
Running the client on an emulator against a live server exposed real defects in the
workflow graph, all fixed here:
- DrawScope.drawText's string overload measured against the draw scope's constraints
and threw when a node or edge label fell outside them (wide or panned graphs),
crashing the pipeline-detail and run-detail screens. Both call sites now draw a
pre-measured TextLayoutResult.
- The graph Canvas was not clipped, so panning drew nodes and edges over the
'Versions' row and the 'Workflow graph' heading. The viewport now clips its
children.
- Outcome labels overprinted when a stage had more than one outgoing edge ('error'
over 'success'). Labels are now laid out in one row per source edge, with a
backing rect for legibility.
- Stage columns followed an iterative rank relaxation, so graphs with a back edge
rendered out of order (planner before reviewer). rankStages now returns
declaration order, matching internal/tui/graph_layout.go.
Verified: :app:compileDebugKotlin, :app:assembleDebug and :app:testDebugUnitTest
succeed offline with 20 tests and 0 failures (new WorkflowGraphTest covers the
rank order and label slots), and the app was driven on the Pixel_Fold_API_36
emulator against the live server with no FATAL or Compose exception in logcat.
|
||
|
|
9a94eabaa3 |
Add the native Android client for the Pipelines server
Kotlin and Jetpack Compose Material 3 client that speaks the existing WebSocket protocol: settings requiring an explicit server URL and workspace, pipeline list and detail with the workflow graph, run history, run detail and evidence, start and cancel run, reconnect, and the loading/empty/error/disconnected states. It stores no credentials and keeps execution, definitions and run history on the server. Verified on the host: :app:compileDebugKotlin and :app:assembleDebug succeed and :app:testDebugUnitTest passes 19 tests. Ignore Gradle outputs and re-include the net.awan.pipelines.data package, which the repository runtime data/ rule would otherwise exclude. |