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.
The per-workspace concurrency added in 2618f0d exposed three places that assumed a
single run, and the second concurrent run failed with 'agent quiescence not
confirmed' because of them.
- ActiveAgentSessionsForRun(runID) scopes the end-of-step quiescence check to the
run's own sessions, so another run's legitimately active agent no longer fails
this one. A run still fails when its own session cannot be confirmed idle.
- The startup guard now uses ActiveSessionOwners (which carries the owning run id)
and refuses only an ORPHANED session - one whose run is not active now - which is
what restart recovery is actually about. A session owned by a currently active
run no longer blocks new work.
- sessionActive examines only the target session: foreign entries in the
/api/session/active map are ignored, the target's absence is inactive, and the
target present with an unsupported state still fails closed.
Verified: go build, go vet and go test ./... pass, including ten concurrency tests
(two workspaces run concurrently, same-workspace refusal, symlink and default-cwd
equivalence, idempotent repeats, restart recovery, retry scoping, overlapping runs
not failing quiescence, and a run's own active session still failing it).
Operator verification, which a stage cannot perform because restarting the server
would abort the run doing it: the service was rebuilt and restarted on this
commit, then two runs in separate workspaces (/tmp/ws-c and /tmp/ws-d) executed
concurrently - both reported executing at the same time, a third run in ws-c was
refused naming run 46, and both finished succeeded with no diagnostic.
Track each active run's resolved workspace alongside its cancel function
in a single runner.active struct map. A new request key is now refused
only when an already-active run is changing the same resolved workspace;
the refusal names the conflicting run id and advises waiting or using a
different workspace. Workspace resolution is unchanged (default cwd,
absolute request workspace, EvalSymlinks), so two spellings of one
directory still compare equal. The conflict check and registration stay
inside the existing r.mu critical section, so concurrent starts for one
workspace cannot both pass. Idempotent repeats of an active request key
and the restart-recovery guard are unchanged.
Add concurrency_test.go covering concurrent different-workspace runs,
same-workspace refusal, symlink/default-cwd equivalence, idempotent
repeats, restart recovery and retry workspace scoping; strengthen the
runner_test.go refusal assertion. Update docs/cli.md,
docs/first-version-testing.md and the packaged operations skill reference
to describe per-workspace concurrency.
Assisted-by: DeepSeek V4.1 Flash
- 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.
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.
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.
The native install hardcoded -addr 127.0.0.1, so the server was unreachable from
the phone: the emulator worked because it proxies to the host loopback, but a
real device could not connect even though ntfy (bound to 0.0.0.0:8090) worked.
The bind address is now a manifest setting (server_address() in manage.py, with
older manifests still defaulting to loopback) and setup-native.py records it,
defaulting to 0.0.0.0 like the Docker install did and offering
--bind-address 127.0.0.1 for a loopback-only server. An invalid address is
rejected, and setup prints the phone client URL.
Verified: scripts test suite 116 tests OK, and after reinstalling the server
listens on *:8080 and answers {"healthy":true} on 127.0.0.1, 10.0.0.75,
10.0.0.249 and the tailnet address.
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.
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.
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.
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.
Add scripts/setup-native.py and make ./install (and --native) build the server, the CLI
and ntfy from source into ~/.local/share/pipelines, detect an existing host OpenCode
and Pi instead of installing them, install the packaged authoring skill, migrate an
existing Docker database and ntfy auth store, save the host client default and start
both services. ./install --docker keeps the previous Docker server + ntfy
installation unchanged.
ntfy is compiled from its pinned Go module on every host because upstream publishes
no macOS server binary (its darwin asset is built with -tags noserver); its cgo
SQLite driver is why a C compiler is now required natively. The ntfy credential
bootstrap and the client default writer are shared by both installers,
installation.Load resolves symlinked prefixes, the Docker migration copies the
SQLite write-ahead log so the newest definitions and runs are not lost, and the
account subcommands read the generated configuration through NTFY_CONFIG_FILE.
Verified on macOS: 115 Python tests, go build/vet/test, and scratch installs that
migrate 9 pipelines and 31 runs, build ntfy v2.30.0 and start both services healthy
on spare ports before stopping them.
Install current verified harness releases inside Docker, preserve persistent accounts and settings, and provide separate interactive and pipeline model defaults with terminal onboarding and fuzzy pickers.
Add Docker-aware authoring transport, Pi stage execution, bounded workflow controls, reliable final-result readback and usage settlement, and finite short-lived CLI pipe draining. Keep dated installation evidence and packaged authoring guidance consistent.
Verified with a real Docker installation, both harness stages and interactive authors, the built-in plan/implement/review starter, independent host race/vet checks, installer tests, and packaged skill tests. Generated release receipts stay ignored in clean checkouts.
Make OpenCode authoring responsive and expand the managed skill references. Add conflict-aware import/export, real-provider reference workflows, and tracked V2 generation for reliable budget accounting.