Keep the running indicator and Needs you flow, but remove the failed-count badge and its tab count plumbing until unseen-state behavior is addressed. Preserve the unfinished seen-state work separately. Verify application, Runs, attention and shell regressions.
Give the Runs tab separate activity and failure indicators so neither suppresses the other. Reuse known summaries and pushed updates, keep failed states separate from decisions and dismissal counts, and update across tabs even when total attention is unchanged.
Remove obsolete control-family flags and icon metadata across all callers, dead alternate themes and host helpers, obsolete test setup, and the unused icon-font dependency. Preserve native Material Back transitions. Make navigation fixtures independent of update plugins and answer auxiliary shell snapshots so the complete application suite can run deterministically.
Keep the probe suite on the Material composition so browser fixtures and capture drivers no longer render or select Cupertino hosts. Record the final residual legacy arguments and implementation checks for the delivery gate.
Keep the assigned runs and pipelines UI Material-only by removing alternate icons, host branches, and Cupertino color usage while preserving compatibility parameters needed by other callers. Update mirrored tests and record focused verification for the cleanup.
Use the shared anchored choices and bounded details dialogs for diff form and artifact facts while preserving narrow Material sheets. Cover both width branches and dismissal behavior.
Keep the shared UI primitive tests focused on the app's Material-only behavior and remove alternate-host fixtures that no longer represent supported rendering.
Keep the optional legacy icon parameter available for callers that have not yet migrated while rendering remains Material-only. The reviewed chat cleanup is already present in the preceding commit.
Remove alternate application hosts, page scaffolds, connection controls and icon metadata while preserving Material routing. Isolate navigation fixtures from native update plugins and retain separate startup-update regressions.
Keep capture and probe tooling on the app's single Material surface by removing obsolete platform switches, hosts, and documentation. Preserve the existing Material routes and fixture behavior while retaining compatibility APIs outside this lane.
Keep the chat and graph fixtures aligned with the app's Material-only UI by removing alternate Cupertino hosts, imports, and query-controlled rendering paths. Preserve the existing Material scenarios and document the focused probe coverage.
Keep chat and folder-picker UI on the Material path by removing obsolete Cupertino imports, icon metadata, flags, and alternate control handling while preserving existing behavior and focused test coverage.
Keep the audited runs filter, chat colour picker, and Needs you flows as Material bottom sheets on narrow or touch layouts while presenting bounded desktop dialogs on wide layouts. Remove obsolete Cupertino flags and add focused route regressions and notes.
Keep the existing Material rendering, semantics, and interaction paths while removing obsolete Cupertino imports, alternate widgets, and dynamic-color dependencies. Record focused verification and remaining fixture limitations for final integration.
Expose platform-aware shortcut help from Settings, keep narrow layouts scrollable, share Search tooltip labels, and document Terminal-to-chat composer focus. Integrate together with the separately reviewed Alt-slash handler.
Keep the existing Material terminal and chat-shell behavior while removing live Cupertino widgets, icon metadata, and alternate-host branches. Retain only the documented optional compatibility parameters until remaining callers migrate.
Keep the chat transcript and toolbar on their existing Material behavior while removing obsolete Cupertino-only helpers, arguments, and icon metadata. Preserve compatibility parameters where callers outside this lane still require them.
Update the keyboard focus regression coverage so Alt+/ is verified as the shell Search destination shortcut while preserving the existing Ctrl+/ behavior. Record the expanded focused-check result in the implementation note.
Give the FilesHeader sort control a recognizable Material sort glyph while preserving the default overflow icon for other menus. Add focused widget coverage for sort key and direction behavior.
Raise the most recently used chat when Ctrl+Y is invoked from another window, then rely on the existing host lifecycle to focus its composer. Preserve toggle behavior while chat is active and retain the Apple shortcut aliases.
Use the permission selector's shared popup and choice-row primitives for model and thinking controls while preserving catalog, search, and next-turn behavior. Remove the obsolete Cupertino model chooser parameter and cover current-model dismissal.
Accept the physical slash key for exact Alt+/ delivery, including macOS Option dead-key values, while preserving existing Ctrl+/ and Command+/ behavior. Add focused regression coverage and document the verified checks.
Paint a theme-derived one-pixel outline as a foreground overlay so the full floating window perimeter remains visible over navigator content without changing existing interaction geometry.
Report each pane's active explorer width to the center-stage layout so the reading column stays at its preferred width while constrained workspaces still make room for side strips. Restore the allocation when switching panes or closing the explorer.
Recognize Option+E by physical key position so macOS dead-key delivery works, including from focused composers, while preserving existing platform aliases and shell behavior. Update labels, notes, and focused coverage.
Ensure /new and chat close stop native foreground and background work before changing registry state. Preserve transcripts while surfacing release and recovery cleanup failures instead of reporting false success, with focused adapter and server regressions.
Keep the public cupertino parameters for existing callers while making the layout widgets and focused tests Material-only. Remove unreachable Cupertino imports, helpers, widgets, and test variants without changing the Material path.
Keep the Material-only changes feature while preserving public Cupertino parameters for callers. Remove Cupertino-only widgets, imports, hosts, and tests because the app never reaches that path.
Keep the public cupertino parameters for compatibility while retaining only the Material rendering paths. Remove Cupertino-only widgets, routes, styling, and tests because the application runs under Material hosts.
Keep the Material-only session UI and narrow its tests to the supported host. Preserve public Cupertino parameters for callers while removing unreachable Cupertino widgets and variants.
Keep the Material-only conversation implementation while preserving public Cupertino parameters for callers. Narrow affected tests to Material hosts so the dead platform paths are no longer exercised.
Remove Cupertino-only fixtures, test variants, and the obsolete readable-text test now that the app is Material-only. Preserve the Material coverage while avoiding unreachable platform branches.
Keep the existing Material transcript path while preserving public Cupertino parameters for callers. Narrow transcript tests to the Material-only behavior and remove Cupertino-only fixtures.
Keep the Material-only folder picker implementation while preserving public cupertino parameters for callers. Narrow the matching tests to the supported Material host.
RedactEvidence truncates at 16 KB and appends a line break, which cut long
stream-json records in two. The session export parses that stream, so the
first real Claude stage (run 346) parked on "Session export pending". The
stream is now redacted record by record without truncation.
The open chat acknowledged after 20 ms of real time, so on a loaded machine
it could fire before the assertion that the other device still shows New.
That failed the delivery gate of runs 304 and 318.
A model stage with harness=claude, provider=anthropic and a Claude model id
runs one claude -p process per visit with the server user's Claude sign-in.
Only the declared tools exist (--tools) and nothing else is approved
(--permission-mode dontAsk); edits are approved only below the run directory
and the stage's artifacts directory. A permissions block, run write paths,
delivery=true and reasoning_effort none/minimal are refused, not widened.
Usage comes from the CLI's final result and counts toward budgets. Failures
are fixed text; billing, quota and rate-limit refusals map to
ErrProviderQuota. The redacted stream is the session export and evidence.
provider-check --harness claude and model overrides are covered.
Ten runs each burned five visits in seconds on "OpenCode agent reported an
execution error": the provider answered HTTP 402 provider.quota and the
classifier read neither field. That refusal is now its own error with fixed
text, is not retried inside the stage, and ends the run instead of
following the error edge.
Keep the Material settings implementation while preserving public Cupertino parameters for later cleanup. Narrow settings tests to the Material-only behavior.
Keep the Material-only chat conversation implementation while preserving public Cupertino parameters for downstream compatibility. Narrow the matching tests to the Material path.
Keep the Material-only run detail implementation while preserving public parameters for callers. Narrow the corresponding widget tests to the supported Material host and remove unused Cupertino-only code.
Keep the Material-only settings implementation and its focused tests while preserving public cupertino parameters for later cleanup. This removes unreachable platform-specific widgets and test variants without changing the Material path.
Keep the pipeline feature on its existing Material path because the app runs under MaterialApp and never selects Cupertino hosts. Preserve public cupertino parameters and required Cupertino icon values for later cleanup and shared controls.
Keep the Material implementation while preserving public parameters needed by callers. Remove Cupertino-only tests and variants because the app runs exclusively under MaterialApp.
Keep the Material-only schedules implementation while preserving public Cupertino parameters for callers. Remove Cupertino-only test hosts and variants because the app runs every schedule screen under MaterialApp.
Keep the Material-only run action behavior while preserving public Cupertino parameters for callers that will be cleaned up separately. Narrow the related tests to the supported Material path.
Keep the Material-only terminal implementation while preserving public Cupertino parameters for callers. This removes unreachable Cupertino widgets and imports without changing the Material path.
Keep the Material-only shell path while preserving public cupertino parameters for callers. Narrow matching tests to Material hosts and behavior because the app always runs under MaterialApp.
Round fitted window frames to whole logical pixels and accumulate drag deltas from the gesture start. This prevents floating-point size noise from rebuilding window content while preserving fractional pointer movement and resizing behavior.
Keep the Material-only template implementation and narrow its tests to the runtime path. Retain public Cupertino parameters for compatibility while removing unreachable hosts, widgets, and test variants.
Keep the public Cupertino-compatible parameters while retaining only the Material implementations and tests. The app is Material-only, so deleting unreachable Cupertino branches reduces dead code without changing the active path.
Keep the Material graph implementation while preserving public Cupertino parameters for callers. Remove unreachable Cupertino widgets, routes, theme branches, imports, and Cupertino-only tests because the app runs exclusively under MaterialApp.
Keep window content scope independent from frame changes, and retain the page theme and root page across layer rebuilds. Add repaint boundaries and regression coverage so dragging and resizing avoid unrelated content work while content changes still propagate.
Keep the app's Material-only chat workspace path while retaining public cupertino parameters for callers. Narrow the affected widget tests to the supported Material host.
interaction_bench.mjs gains 1280x800 scenarios (dragging, resizing, hiding
and floating chat windows, a probe window drag, chat scroll, typing, chat
switch, the terminal panel), key, drag and wheel steps, a per-scenario size
and --gpu, which keeps WebGL so raster time reads as on a desktop.
Keep the public compatibility parameters while retaining only the Material UI path. Remove Cupertino-only tests so the reviewed settings and server code matches the app's Material-only runtime.
Keep the reviewed attention surfaces on their Material implementations while preserving public cupertino parameters for remaining callers. Remove the unreachable Cupertino sheet and narrow tests to the Material path.
Keep the Material-only file explorer path while preserving public APIs used by callers. Remove unreachable Cupertino widgets, hosts, routes, and tests so the app remains behaviorally unchanged on Material screens.
Keep onboarding on the app's Material-only path and remove unreachable Cupertino widgets and host-specific tests. Preserve the reviewed Material behavior while documenting the focused checks and verification limits.
Keep the Material update dialogs as the only reachable implementation while preserving public cupertino parameters for callers. Update focused tests and document the verified checks.
A failed visit was recorded on its step only, so a landing gate that sent
the run back to implement gave the implementer nothing about which checks
failed. The diagnostic (bounded) is now the next stage's previous output
and a memory entry.
A browser keeps Ctrl+Shift+C for its developer tools, so on Linux and
Windows web nothing copied. With text selected Ctrl+C now copies it (and
clears the selection) instead of interrupting the process; Ctrl+Insert
copies too, and a finished run's read-only output answers the copy keys.
The terminal's options menu names the key.
Phase 4 of docs/plans/floating-windows.md. A bar button lists the app's
windows on every tab (show one, Show all, Minimise all, Close all). Alt+`
and Alt+Shift+` bring the next or previous window to the front. Dropping a
title at the left or right edge fills that half, at the top it maximises.
A new window of a kind opens at the size that kind was last given.
Phase 2b.2 of docs/plans/floating-windows.md, implemented by pipeline run
303: both use showAppChoiceMenu (a menu anchored to its button on a wide
app, a bottom sheet on a phone).
A dialog only in the tiled app on a wide layout: a phone keeps its
full-screen page (run 304 had turned it into a sheet and rewritten the
tests), and a floating window opens it as a page of that window so a diff
or command output it opens stays in the window.
The add-pane picker is opened from a pane, not a button; with no room
above or below the anchor the panel was laid out with no height (found by
run 303's UI review).
Phase 2b.4 of docs/plans/floating-windows.md: both use showAppDetails (a
dialog on a wide app, a bottom sheet on a phone). Implemented by pipeline
run 305; landed by hand after its UI review found the dialog clipped, which
the helper now scrolls.
Phase 3 of docs/plans/floating-windows.md. The terminal window kind reuses
TerminalHub; TerminalWindows keeps the window in step with TerminalLayout
(show opens or shows it, hide minimises it, Minimise and Close hide the
terminal). The bottom panel stays a shell panel. The first window takes the
frame and maximised state pipelines.terminal-layout.v1 saved.
The terminal's own float chrome and FloatingLayer are deleted.
Present chat turn and shell-history detail surfaces through the shared adaptive popup helpers so desktop uses dialogs while phone layouts retain bottom sheets. Update focused tests and document the verified behavior.
Use Material popup menus for file actions and anchor Runs sorting choices to the sort button while retaining the phone fallback. Update callers, tests, and implementation notes to match the desktop behavior.
Phase 2b.1 of docs/plans/floating-windows.md. showAppChoiceMenu is a menu
panel anchored to its button on a wide app and a bottom sheet on a phone;
showAppDetails is a dialog or a bottom sheet. Both are on the root
navigator, and the app's width decides, so content in a narrow floating
window still gets desktop popups. The probe window exercises both.
AppMenuAnchor is the app's one MenuAnchor: root overlay, takes the keyboard
while open (Escape and arrows work wherever focus was) and gives it back.
A window no longer takes the keyboard back from a popup its own press
opened. In a window, Files opens as a page of that window and Chat details
is in the More menu.
Phase 2.3 and 2.4 of docs/plans/floating-windows.md. A floating chat is a
window of the chat kind over the app's WindowManager, built from the
app-lifetime ChatRuntime, so it shows over every destination and at start
without the Chat destination being built. Float and Dock move the same
keyed view between the tiling and the window host. The pipelines app keeps
one runtime and one ChatWindows; saved chatFloat records (v1 and v2) are
brought over once.
ChatFloatHost, ChatFloatWindow, the float frames and binding, the
controller's float list and FloatingFocusRoot are gone; the workspace only
asks whether a chat is out in a window. Every MenuAnchor targets the root
overlay (guarded by a test), and menus and tooltips name the Alt chords.
Phase 2.2 of docs/plans/floating-windows.md: buildChatPaneContent wraps a
conversation in the scopes it needs and keys it by the runtime, so the
tiling and (next) a floating window build the same subtree. The tiling uses
it; behaviour is unchanged.
Phase 2.1 of docs/plans/floating-windows.md. The session list controller,
opened rows, accepted models, transcript positions and caches, composer
focus requests and list folds move from ChatScreen's state to ChatRuntime.
ChatScreen builds its own unless one is passed; behaviour is unchanged.
Phase 1.3 and 1.4 of docs/plans/floating-windows.md. Windows are plain
children of the terminal stage's stack in the shell page, outside every
destination, so popups opened from one are above all of them. Each window
has its own page navigator: pushed pages open inside the window, and popup
routes go to the root navigator. One WindowFrame chrome (move, resize,
minimise, maximise, close), a focus scope per window, a ScaffoldMessenger
per window.
No feature uses it yet. The capture fixture opens probe windows with
?windows=N, and window_layering_test.dart covers every popup type from a
window over Chat and over another destination.
Provide composable shown/current visibility for retained surfaces and migrate visibility readers away from TickerMode. This keeps ticker muting separate from painted and current-surface state.
Phase 1.2 of docs/plans/floating-windows.md: an app-lifetime WindowManager
with ordered WindowEntry values, a WindowKind registry and a device-local
versioned WindowStore whose server-scoped entries carry their server key.
Nothing uses it yet.
The app builds one Material UI for every platform. Cupertino code, tests and
captures are being removed, so the agreement, the capture recipe and the
floating-windows plan no longer ask for them.
Model, mode and thinking buttons carry 12 px horizontal padding, replacing
the pill inset from 440995e3. Alt+Y (Option+Y by key position) toggles the
floating chats, like Alt+T for the terminal.
Why popups open behind floating chats, why the chat float is still tied to
the Chat tab, and a phased plan for one window host that terminal, chats
and later runs and pipelines share.
Every run in this repository reported an incomplete file-change capture
because the tracked .env.example matched the secret-file rules and was
skipped. Committed templates (.example, .sample, .template, .dist) hold
placeholders, so they are captured like any file; real secret files and
protected directories stay excluded.
Run 299 removed the model and mode buttons' horizontal padding on desktop
so the island's gap sets the spacing, which left their text touching the
pill's rounded ends. The island now insets its content by 12 px.
Add a uniform desktop gap between header control groups and remove duplicated horizontal padding from model and mode controls. Preserve compact-layout touch targets and add Material/Cupertino regression coverage.
A fresh run started from a repository's main checkout gets its own
worktree and branch next to the repository, so runs never share a tree
or see the operator's uncommitted work, and several can run at once.
Retries and runs started in a linked worktree keep their directory. A
clean, landed run tree is removed after success; anything else is kept.
The delivery gate commits what the land stage left uncommitted in a run
worktree, and no longer requires the operator's main checkout to be
clean: Git's fast-forward refuses safely when a local change conflicts.
The clipboard bridge gave every paste to the active tiled chat while
another composer had focus, so a floating chat (never the active pane)
could not receive pasted text or files. A floating chat's composer now
owns the paste while it has the keyboard, and the paste target yields to
it. A focused composer in an inactive tiled pane still leaves the paste
to the active pane, as before.
Floating chats were stuck on other destinations: the hidden Chat tab
muted the window's hide animation, so the window stayed painted but took
no input. The reveal now uses its own ticker, each floating pane's focus
scope hangs from a FloatingFocusRoot above the destination stack, and the
windows show over every destination like the terminal.
Any number of chats can float; the shortcut, a window's X and the menu
show or hide them together. Each pane keeps its own frame (also while
docked), saved in record version 2; version 1 records still load. Drags
read the live frame so fast pointer events no longer lose movement.
On center stage, pressing or focusing a live side pane's header controls
(actions, More menu, model/mode/effort) no longer activates that pane.
Strips, keyboard activation and the normal split are unchanged.
Pipelines run 298 (reviewed and UI-reviewed); landed by hand because the
land stage's file capture was incomplete.
On a wide window (both sides at least 600 logical px) every SegmentedBar
keeps the floating tab bar's 16px from the top and the sides, in every
pane and page. A root WindowMargins scope adds the extra 8px to the top
media padding, so Cupertino's fixed reserved bar height, list clearances,
pinned headers and measured overlays all move together; the bar and the
TopGlassStrip read the 16px side inset from the same scope, and sticky
section chevrons keep 16px from the trailing edge. Phones keep 8/12.
A coloured chat's own messages blend 22% of its shade over the host's
neutral bubble fill; text keeps the host colours and uncoloured chats
are unchanged.
Replace the identity-avatar Hero with a container transform: the row's
surface, tint and edge marker morph into the full page while the content
cross-fades, and Back, the Cupertino edge swipe or Android predictive back
shrink the page into the open chat's row. Reduced motion or a row off
screen fades instead; wide layouts are unchanged.
The proxy forwards an HMAC-derived session id (X-Pipelines-Session) on
/connect and POST /files; the server trusts it only on token-authenticated
requests and keys elevation by it, so reconnects stay elevated up to a 24 h
cap. Terminals rely on their su -l login. The app no longer forgets the
elevation on disconnect and asks again only on a fresh refusal.
A coloured chat's send button uses the chat's seeded primary and its
on-colour, like the focus ring; stop stays the host's error red and
uncoloured chats keep the host button.
The shortcut no longer waits for a running shell: on the Chat page it opens
the terminal, starting one at its login prompt when none is open, and shows
a count when more than one shell runs.
The __Host- session cookie name now goes to browsers only. Native clients
(no Origin or fetch metadata), including app builds from before the change,
get the plain cookie name, still Secure over https, so they find their
session after signing in.
Carry the protocol error code, wrap each machine's gateway so an
elevation_required refusal shows one native password dialog, elevates that
connection and retries; send the upload token with file uploads; add a Settings
sign-in security section with the weak-password warning and sign out
everywhere; accept the __Host- session cookie.
Store a scrypt hash (migrating a plaintext password without changing it),
sign sessions with a generation that ./password and --revoke-all rotate,
make logout a same-origin POST that revokes the token, add sign out everywhere,
and close proxied websockets whose session ends. Enforce a strength rule for
new passwords, back off logins per client and server-wide, check Origin on
login, tighten next, add security headers and a __Host- cookie over https.
A new elevate request verifies the web sign-in password (scrypt hash, read-only,
rate-limited, constant time) and elevates that connection for 15 minutes.
chat_shell_run/input, rename/move/delete, terminal_open/input and POST /files
(via a per-connection upload token) are refused with code elevation_required
until then.
The web proxy binds the wildcard and drops connections that are not
loopback or Tailscale at both ends. A LAN listener is opt-in (web.lan) and
refuses sign-in and signed-in pages over plain HTTP unless
web.lan_plain_login is set. Existing installs keep their bind address with
a warning. Without the LAN the mDNS advert carries only the tailnet and
public routes (lan=0).
The proxy adds the shared token to every upstream request and drops any
client copy. The peer relay accepts only tailnet, LAN, ts.net and discovered
hosts, resolves each name once and pins the checked address, and flags
ws:// endpoints with insecure_transport.
The server answered any Host, so a DNS-rebinding page reached /connect (101)
and could drive terminals. Every route now refuses a non-loopback Host on a
loopback connection (421), /connect refuses any Origin (403), and a server
started with -token-file requires X-Pipelines-Token (401; /mcp and /healthz
exempt). The CLI/TUI send the token only to loopback URLs.
Each installation generates a private Ed25519 key once (0600, under
~/.config/pipelines), signs version.json with a detached version.json.sig
when publishing APK and desktop builds, and embeds its own and listed
trusted public keys in app builds. The app verifies the feed signature
before trusting the artifact sha256, refuses unsigned or foreign feeds when
it has keys, and requires the sha256 and Android signer in signed feeds.
The first show of an app run starts one terminal (the machine's login
prompt) unless one is running; later toggles never open another. Drop
the tmux field and restart note, and update the Settings copy and the
terminal notes.
A new terminal runs su -l for the server's own account in its PTY, so the
operator types the account password before getting a shell. Opening is
refused when su is missing, the server runs as root, or su opens a shell
without asking. The Pipelines-owned tmux backing, its reattach and its
persisted session names are removed: terminals end with the server and
are listed as ended. A starting server ends leftover pipelines-term_*
sessions on tmux -L pipelines only.
While shells are running and the full-screen terminal is closed, a small
floating button under the right end of the top bar reopens it, with a count
when more than one shell runs. The surface's stack is always present so the
app never remounts when the shortcut comes or goes.
On Android and iOS a tap on a terminal (a chat command card or the terminal
panel) now opens the soft keyboard and typing goes to the process, with no
autocorrect. Desktop keeps raw key events. Desktop keyboard tests now run
as macOS, since tests default to Android.
Tint the bar's glass pieces with the chat shade over the raised surface
(0.16 light and dark, then the 0.82 glass opacity) and draw its labels in
the seeded scheme's onPrimaryContainer; Cupertino takes it as the bar's
primary colour. Inactive split panes keep half the tint. Remove
ChatColorWash. The composer focus ring is the seeded primary at full
opacity, 2 px, with no glow. Contrast test asserts AA for every palette
colour on both hosts in light and dark.
Terminals are marked as typing surfaces. While one has focus, the chat's
"/ jumps to the composer", the Search tab's Escape, Ctrl+/, Ctrl+1…9 and
Ctrl+Shift+arrow pane moves leave the key to the terminal, like they do for
text fields.
Opening a file from the Files panel now passes the folder's previewable
files in their shown order, so the arrows, swipes and Previous/Next step
through them and Escape closes the viewer. Download follows the file on
screen.
Dismissed shell runs leave the transcript and fold into a "N commands"
chip in the footer of the first answer at or after each run (the last
answer for newer runs, or a row of its own without any answer). The chip
opens the turn sheet (wide) or a full-screen page (narrow) listing the
commands; each opens its output read-only with Copy output, Send to agent
and Restore.
On a wide conversation the answer's Copy button moves out of the footer
into a 48 px gutter left of the reading column (chatCopyGutter), shown on
hover or focus on desktops and always on touch; narrow widths keep it in
the footer.
Alt+T, Ctrl+T and Cmd+T join Ctrl+` as early focus-manager key handlers, so
they toggle the panel, window or narrow page from anywhere without reaching
the shell or a text field. Opening with no terminal starts one. The shown
terminal takes the keyboard (also on reload and tab changes) and hiding gives
it back. The panel slides from the bottom edge as the app shrinks, the window
scales and fades, both on Motion.standard and off under reduced motion.
While shown, Ctrl+Tab/Ctrl+Shift+Tab move between terminal tabs instead of
chat panes. The tooltip and menu list the shortcuts the platform delivers.
docs/feature-changes.md records how cross-layer features (protocol,
persistence, server, harness adapters, web proxy, app, fixtures) were built
and verified in this session; docs/workflows/feature.md is the reviewed
prepare → plan → implement → review → ui-review → land definition that
follows it, with a delivery gate for Go, web and app checks.
A dismissed run keeps its command, status, times and output within the
usual history bounds. chat_shell_runs lists dismissed runs apart
(chat_shell_dismissed_runs), chat_shell_run_output still reads them, and
the purge timer and startup purge are gone. Rows an older server purged
are listed with purged set and cannot be restored.
Finished command cards get a Dismiss button and the chat's More menu a
Dismiss all finished commands entry. Dismissal applies to every client of
the chat; a SnackBar (Material) or transient notice (Cupertino) offers Undo
for 5 s. Running commands cannot be dismissed until they end.
chat_shell_dismiss hides finished runs from every readback and pushes a
dismissal frame to every watcher; chat_shell_restore undoes it within a
30 s window, after which the command, output and error are purged and only
a tombstone remains, reported by chat_shell_runs for clients that missed
the event.
Finished terminals are sized synchronously from their rows at the view's
width (the post-frame fit made the transcript re-anchor forever); blank rows
xterm.dart keeps when rewrapping are dropped; desktop typing uses key events;
the composer leaves Cmd/Ctrl-V to a focused terminal; Ctrl-A reaches the
process. The probe fixture gains coloured terminal runs and an interactive
login. Notes record behaviour, protocol, security and verification.
On macOS, Linux, Windows and desktop browsers the "Thought · tool calls ·
background tasks" row is as wide as its label, so its hover and click area
no longer span the transcript. Phones keep the full-width touch row. The
check uses the device platform because web themes are pinned to Android.
The scroll fixture gains ?turnactivity=1 for captures.
Material menu or Cupertino action sheet of the levels the chat's model
accepts, sent with chat_effort through the chat's own gateway. Hidden when
the model has none; says when a running turn keeps its level; re-reads the
levels after a model switch.
The card's output area is now an xterm.dart emulator kept per run by the
controller: it is fed the raw stream in order, takes typing and paste while
the command runs (with a key toolbar and a soft-keyboard field on touch
platforms), resizes the process to its layout, opens printed links, shrinks
finished runs to their output and opens full screen. A reconnect resumes from
the byte the card holds; Copy output copies the server's plain text.
Codex: model/list supportedReasoningEfforts per model, turn/start effort,
thread reasoningEffort as the current level. Claude Code: initialize
supportedEffortLevels, apply_flag_settings effortLevel at the next turn
start. OpenCode v2: model variants via the session model endpoint.
chat_effort sets a level; rows and chat_models carry the levels; Codex and
Claude levels persist in operator_sessions.chat_effort and are re-applied
before every turn.
Commands start in a PTY (creack/pty; macOS and Linux) of the client's size
with TERM=xterm-256color in their own session. chat_shell_input writes typed
UTF-8 text in order through a bounded queue; chat_shell_resize sets the size.
Output stays the raw terminal stream with byte offsets as sequence numbers,
chat_shell_run_output resumes from an offset, and a plain-text rendering is
persisted for Copy output and Send to agent. Input is never stored or logged.
scripts/install-linux-app.sh installs a release archive into
~/.local/share/pipelines-app (writable, so in-app updates can swap it), with
a ~/.local/bin launcher, icon and desktop entry, and checks for missing
system libraries first.
The Linux app now downloads the release archive to a temporary folder,
verifies its checksum, extracts it beside the install folder, swaps the
bundle in with two renames (keeping <install>.previous for rollback) and
relaunches. A read-only install location is reported with how to fix it.
The prompt and Settings button say "Install and restart".
Double-clicking the divider between two chat panes flips that split between
side by side and stacked, keeping its proportion, instead of resetting it to
50/50. Screen readers get the same action.
Show Expand only when output can overflow and drop the final newline from
the drawn output. The full-app probe lists shell runs with ?shell=1 so the
cards, Shell mode and Run command dialog can be captured in Chrome.
A draft starting with ! shows a Shell mode indicator and runs through
chat_shell_run instead of being sent to the agent; the chat's actions menu
gains Run command. Each run is a terminal-style card among the turns with
live output, Stop, its exit status, Copy output and Send to agent.
The answer footer shows '3 files changed +9 -2'; tapping opens the turn's
files in the sheet (wide) or a full-screen page (narrow), and a file opens
the run Changes diff viewer. Patches load through the chat's own gateway.
Snapshot the chat directory with internal/filediff when a turn starts and
compare it when the turn ends; store changed turns (newest 100 per chat),
push chat_turn_diffs summaries, attach them to chat_messages replies and
serve one turn's patches through chat_turn_diff.
chat_shell_run starts $SHELL -lc in the chat session's directory in its own
process group, streams merged output to every watcher of the session, keeps a
1 MiB tail and persists each run; chat_shell_stop interrupts the group and
kills it after a grace period. chat_shell_share queues an ordinary prompt
with the command and a bounded output tail.
The sandboxed app downloads its update zip to ~/Downloads, which needs the
downloads read-write entitlement; without it the download failed with
"Operation not permitted".
Settings > Appearance > Interface size scales every dimension, text, icon
and dialog on this device. The app lays out in a smaller or larger viewport
and paints it scaled to the window, so hit testing and layout stay
consistent; the value is saved per device and applies when the slider is
released.
The native APK build no longer sets ANDROID_SDK_HOME beside
ANDROID_USER_HOME (AGP rejects the conflict). integration_test/
discovery_probe_test.dart runs the real Bonsoir discovery on a desktop
host and prints what the platform delivers.
The server compares its LAN and tailnet addresses every 30 seconds and
republishes the advert when they change, so a machine that moves networks
stops advertising the address it had at startup.
./install --apk builds on this machine with the host Flutter and Android SDK
when both exist (--docker forces the container build), signing with the same
shared debug keystore so phones keep accepting updates.
Saved machines' state and sign-in live in Settings; the chat no longer shows
"<machine> · Connected" above both panes, which also pushed the thread pane
below a bar that belongs to neither pane.
Every row and tile menu gains Rename…, Move… and Delete… (folders now
have a menu too). Rename prefills the name with the file's stem selected
and applies the server's name rules inline. Move reuses the chat folder
picker through a FolderPickerPurpose: titled for the entry, confirmed
with Move here, never offering the entry's current folder and keeping a
moved folder's own subtree out of reach. Delete confirms, and when the
server reports a folder with contents asks once more before deleting
recursively. Holding an entry and dropping it on a folder row or tile
moves it there; the target highlights and refuses itself and ancestors.
FilesController performs each request through files_mutations.dart,
shows Renaming…/Moving…/Deleting… progress, reloads the shown folder
afterwards and keeps a refusal in the server's words in the panel's
notice until dismissed.
The chat Files panel needs to rename, move and delete entries. Three
websocket requests, dispatched beside list_directory, operate on one
entry inside the operator's home and reply with path_mutated {path} or
an error frame (does not exist, already exists, is not empty, outside
the home directory, cannot be moved into itself).
The entry's parent folder and the move destination are resolved through
symlinks and must stay inside home; the entry's own symlink is never
followed, so a link is renamed, moved or removed as a link. The home
directory itself, anything outside it and pseudo filesystems are
refused. A folder is deleted only when empty unless recursive is set;
os.RemoveAll unlinks symlinks rather than descending into them.
The header gains an Upload button that uses the host file picker (disabled
with its reason where no picker exists), and the panel body becomes a drop
target: on web, document drag events are observed through a dart:js_interop
seam and a file drag over the panel shows a highlight naming the folder.
Each file is posted to POST /files?path=<folder> through an injectable
transport; refusals (exists, sign in, too large) stay visible until dismissed
and the folder reloads afterwards. The list/grid builders move to
files_entries.dart to keep the panel small.
The direct proxy already forwards every /files method behind the sign-in
gate; the peer relay now allows POST /files beside /chat-uploads. Tests cover
the name header, body and refusal of other POST targets.
- Removing the primary machine hands pipelines/runs to the next saved machine
on native hosts; removing the last machine returns to the connect screen
instead of stranding the app on "Server endpoint not configured".
- Add server probes the new machine and asks for its own password in the same
page; Settings rows show Connected / Sign in required / Unreachable with the
reason and offer Sign in; no other machine's credential is ever reused.
- Unreachable addresses explain why: a TLS failure against an IP points at the
Tailscale name, a non-Pipelines answer points at the port.
- Discovered machines list every advertised route (LAN, Tailscale IP, Tailscale
name) as a checklist; chosen routes are saved as one machine.
- tool/connection_probe.dart replays the native login and websocket against
real addresses for diagnosis.
The mDNS record now carries ts= (tailnet IPv4 addresses) and public= (the
installer's HTTPS origin from PIPELINES_WEB_PUBLIC_URL) in TXT, and browse,
the discover_servers RPC and /discovery return every route to a machine as
addresses with kinds lan, tailscale and public. Endpoint stays the LAN route
for older clients. Unsafe ts/public values are dropped.
The handler reuses the home-path resolution of GET /files, refuses special
filesystems and non-directories, writes with O_EXCL so an existing name is
answered 409 instead of overwritten, enforces the chat upload size limit and
replies with the stored name, path and size.
The inactive (peek) pane no longer shows the chat's bar: ChatPanePresentation
tells the conversation its role and ChatPaneBarReveal keeps a resting peek's
bar offstage (zero height, not painted), so the peek reads its transcript from
the top. A drag on the peek scrolls that transcript; a tap anywhere on it,
even over a button or link, activates the chat (ChatPeekTapRecognizer accepts
on release ahead of the arena sweep and yields to drags past the slop). The
'chat-peek-<id>' semantics stay a labelled button.
Switching animates (260 ms, Cubic(.2,.8,.2,1)): the tapped chat rises over the
active one with its bottom edge pinned, then the covered chat slides up into
the slot from the bottom edge; each bar fades and slides in or out over the
rise. Content boxes keep their fixed size, so ticks move and clip retained
pictures without laying a transcript out again. Reduced motion jumps. The
old focus stripe is gone.
While the field has focus the composer pill shows a thin translucent ring
and soft glow in the chat's accent (its own colour, else the theme
primary), fading in and out; nothing is drawn unfocused. On desktop hosts
the composer keeps 24 px from the window's bottom edge instead of 12
(phones unchanged), split by the same host test as Enter-sends.
A bare / typed outside any text field puts the keyboard in the active
chat's composer through the existing focus request, after the frame, so
the slash is not typed into it. Ctrl+Tab with a single pane now swaps in
the chat shown before the current one and back; two or more panes keep
cycling panes. The visit remembers its shown chats most-recent-first,
dropping closed, /new-moved and other-server ids.
The pipeline's bar gets a Pipeline actions menu with Archive (confirm
dialog: history is kept) or Unarchive; an archived detail says so and
offers no Run. The list hides archived pipelines and the scope control
gains an Archived view. Server refusals (enabled schedule, newer
version) are shown verbatim. The capture fixture answers archive
requests.
archived_at on pipelines (migrated in place). archive_pipeline and
unarchive_pipeline by id or name with an expected-version guard;
list_pipelines hides archived unless include_archived. Archived
pipelines refuse runs, retries, new versions and name reuse, and
cannot be archived while an enabled schedule points at them.
CLI archive/unarchive and list --archived/--all, docs and skill note.
file_picker's web picker treated the window regaining focus as a cancel when
the files arrived more than 500 ms later, so a real dialog could return an
empty pick and Add font did nothing. The web now uses its own file input that
completes only on change or cancel; mobile browsers get no accept filter.
Picker, check and save failures are shown in a dialog, and the row is busy
only after files were chosen.
A row click or tap, Next chat and a created chat put the keyboard in the
composer, as Ctrl+1-9 does, on desktop hosts (native or desktop browser, any
window width) and after a mouse or trackpad click anywhere. A finger tap on a
phone or tablet (Android, iOS, mobile browsers) leaves focus alone so the
on-screen keyboard does not cover the transcript. Closed chats are not
focused, and a request yields when another control took focus meanwhile.
Add font… picks one or more files, checks them with a bounded sfnt reader
(name table family, OS/2 weight), registers them with FontLoader before
storing, and chooses the new family. Added fonts list below the bundled ones
with Rename and Remove; removing the chosen one falls back to System default.
Bytes live in the app support directory natively and in IndexedDB on the web
(localStorage is too small); a shared_preferences index names them. Limits:
10 MB per file, 40 MB total. The capture kit gains a files= step.
Resolve the run workspace's environment with workenv (direnv, parent
.envrc, mise; same account rule as Claude chats) at run start and resume,
and apply it to Pi stage processes, a per-environment Pipelines-owned
OpenCode stage service (keyed by a hash of the change, reused across runs,
idle ones stopped after PIPELINES_OPENCODE_STAGE_IDLE_TIMEOUT, revived per
registration), delivery-gate checks and merges, plain-stage opencode CLI
calls and file-change capture git reads. Record the directory, .envrc
files, sources and variable names (never values) on the run detail; a
blocked .envrc becomes a run warning.
Each recorded artifact now carries a server group (deliverable or debug).
public/ files are deliverables; input/memory/history/output.md, session
exports and private/ scratch are debugging files. The app's Artifacts tab
lists deliverables and the Debug toggle reveals a separate Debugging files
group (older servers fall back to the filename rule); the TUI lists
deliverables first and marks debug rows; artifact search excludes debug
files unless include_debug / --debug-files is set.
One shared ElapsedClock (single timer, only while a visible running item
is watched and the app is visible; cadence follows formatDuration
precision) and a LiveElapsedBuilder that repaints only its own text.
Running list rows, the Summary Duration and running timeline visits
tick. A stage start re-reads the open detail, since step deltas carry
no started_at. Fixture ?running=1 for captures.
Rewrite format.md around turn files, the output.md order (# outcome, edge word, # handoff, detail), checks, configs, human stages and the land stage delivery gate (sh -c in a fresh detached worktree, clean checkouts incl. untracked, 64 KB output cap, opencode only). Align review guidance across practices, verification, orchestration and the feedback-loop example. Fix loop-limit semantics in control.md against runner.go, budget_tokens sizing, read for large inputs, blocked-else-error and one stage naming set. Move dated verification logs to docs/verification-history.md and brokered chat, TUI keys and harness internals to docs/operator-reference.md; label operator-only references in SKILL.md.
Timeline stage rows add the cached share (when cache_known) and a positive
cost: 20.1M tokens · 97% cached · $1.42. The file viewer words each server
no_patch_reason, keeping the old truncated/binary text as the fallback.
The prompt now says output.md must start with # outcome and the outcome
word alone on the next line, then # handoff, then detail. Runs 241/243
followed the old "start with # handoff" wording and dropped the outcome.
When a completed turn lacks a valid outcome, the OpenCode/agent and Pi
clients send one short follow-up in the same session asking only for the
outcome line. An outcome-only reply goes at the top of the original report;
a still-invalid reply fails with the same validation error as before. The
follow-up's tokens accrue to the session usage. No outcome is inferred.
Missing tools/evidence now name blocked when declared, else error. The
parser tolerates a trailing period on the outcome word.
On a large Git workspace the 32 MiB retained-text budget was spent
alphabetically on files that never change, so small late edits were
recorded with no_patch. The stage-start snapshot now keeps text only for
files dirty or untracked at start; a clean tracked file keeps its hash and
stage-0 index blob id. When it changes or is deleted, the after capture
reads that blob in one `git cat-file --batch` and uses it only if its
SHA-256 matches the start read, so stage commits/resets do not move the
baseline and filters or assume-unchanged never yield a wrong patch. The
after capture shares unchanged files' representation instead of spending
budget on them again.
FileChange gains no_patch_reason (binary, file_size, budget, lines,
evidence_size, git_status, baseline). Non-Git workspaces keep their
behaviour.
OpenCode and Codex chats implement Detach (called by chatManager.Close)
instead of a parallel DetachSessions interface. Docs follow the Claude Code
host and the systemd KillMode=process unit. The opt-in live restart check
copies only the stage provider's login row into its scratch OpenCode
database, builds the CLI for skill install and removes its scratch tree.
A stopping server no longer interrupts harness sessions. Runs are canceled
with a shutdown cause, so stage clients leave admitted sessions running and
owned; start-up recovery re-adopts live OpenCode V2 stage sessions (wait,
read back the result, continue the graph), restarts unadmitted visits,
continues runs between stages, and falls back to interrupted with a reason
when the harness is gone. Chats with live work are recorded on shutdown and
reattached on start; turns that ended during the downtime are folded in
from history. The server-spawned V2 chat serve is now a detached owned
service. PIPELINES_SHUTDOWN_SESSIONS=stop restores the old behaviour.
A pipelines-claude-host process owns each claude -p CLI and its pipes,
spools its stream-json output with offsets and serves a private Unix
socket. The server detaches on shutdown and reattaches on start,
replaying the spool to rebuild turns, approvals, questions, background
tasks and the live model. Explicit close, idle release and CLI exit stop
the host; a crashed host falls back to --resume with a notice.
Stages now run on a detached Pipelines-owned opencode serve started with
OPENCODE_CONFIG_CONTENT carrying stage tool_output (16384 bytes / 400 lines)
and compaction.auto defaults, configurable through PIPELINES_OPENCODE_STAGE_*.
Chats keep their existing service and configuration; a server-spawned chat
serve can take PIPELINES_OPENCODE_CHAT_CONFIG. The service shares the user's
OpenCode config, credentials and session database, keeps a stable private
registration so retained references (recovery, interrupt, export) stay valid,
revives on the same port after a crash, replaces itself when idle after a
settings change, and is stopped on shutdown only when idle.
PIPELINES_OPENCODE_STAGE_SERVICE=shared restores the previous behaviour.
run.sh now records flutter's JSON results beside the log and prints a
summary from tool/memwatch/summary.dart: one verdict line (pass/fail/skip
counts, peak MB, duration, exit status), only failing tests with their
error and app stack frames (framework frames dropped, per-test and total
caps, tail of printed output), the tests still running when killed, and
the log and JSON paths. Quiet is the default when stdout is not a
terminal; MEMWATCH_OUTPUT=full also prints the whole log. The watchdog
loop and exit status are unchanged.
tool/analyze.sh bounds flutter analyze to a verdict line and the first
40 issues. Tests: test/tool/memwatch/summary_test.dart and the
end-to-end tool/memwatch/quiet_test.sh over fixture suites.
Every stage used to be told to read memory.md, the full output of every
earlier turn (19 KB average, 92 KB max), and paid for it on each model call.
memory.md is now essential memory, hard-capped at 4 KB and inlined in the
prompt: the task, the previous stage's # handoff section (or its truncated
output head), a one-line-per-stage outcome ledger and the server-captured
changed files. history.md keeps the old full memory on disk; read-capable
stages are pointed at it and input.md for on-demand detail, and it is never
inlined. The prompt asks each stage for a short # handoff section.
The server skip fallback for stages with a skipped edge now applies only
when every earlier visit recorded a complete file-change capture with no
changed files and no image artifact. Any change (no repo-specific UI path
or extension list), any partial/unavailable/missing capture, a human
decision or a checkpoint-retry prefix runs the model. auto_skip=false opts
a stage out. The fallback verdict names the server fallback.
Capture compares over-budget text by hash and, in Git, lists paths it
could not compare when their git status changes, marked no_patch, so a
large workspace no longer records files: [] for a real edit. Run detail
gains a warnings list for partial/unavailable captures, also printed by
inspect on stderr.
System default plus Inter, IBM Plex Sans, Source Sans 3 and Atkinson
Hyperlegible Next (OFL 1.1, bundled as on-demand assets and loaded with
FontLoader, so the web fetches only the previewed/chosen files). Stored in
shared_preferences, applied live to Material and Cupertino text themes;
RobotoMono styles unchanged. Licences registered with LicenseRegistry.
The list applies chat_activity pushes and each row's activity by seq, so
every listed chat shows a running turn, not only the chat open here. An
idle chat with running background tasks wears a quiet badge with tooltip and
semantics "Background tasks running (N)". Older servers keep the old
behaviour. List rows that never changed carry the server's current seq so
they order after snapshots kept from an earlier server process.
chat_sessions rows carry activity (turn_running, background_tasks, seq) from
the hub's own state, and chat_activity is pushed to every connection when a
session's turn starts or ends or its running background-task count changes.
A room whose last viewer left stays observed while background tasks run,
bounded by the unattended limits; a Claude Code process exit ends its tasks.
The template catalog is now Example 1-4: one stage, two stages (handoff),
feedback loop (runner-owned limits, retries, timeout) and human decision
(type=human approve/revise/abort with notify hooks). All read-only or leave
changes uncommitted; none commits, pushes or deploys.
A brand-new database (schema created by this Open) gets the examples once at
server start, bound to the configured default model and harness. A
server_settings marker records the decision, so removed examples never come
back and existing installs are marked without any pipeline being added or
rewritten.
Full screen button in the viewer's bottom bar opens a root full-screen route
with the same bar and top bar; exit by the bar, Close, Escape or back. It
renders the already fetched bytes, never the system browser. The external
Open action is now labelled Open in browser.
Native web views claim their gestures (vertical drags inline, every pointer
in full screen) so the page swipe no longer starves them. On the web, full
screen adds zoom buttons that scale the live sandboxed frame. Links: in-page
anchors scroll, http(s)/mailto open outside, everything else is inert.
Capture kit: --touch, swipe=, pinch=, tabs=; html=1 fixture artifact.
The selection area claimed a primary mouse press on a link as a selection
drag once the pointer moved 2 px, so in the browser ordinary clicks with a
little hand or trackpad movement opened nothing. A link's recognizer now
accepts a primary mouse press on pointer down, as an anchor does; the click
still cancels past the tap slop, drags from plain text still select across
links, and touch long press keeps Copy link.
Only visible assistant reply text, a pending form or an unresolved
permission request is unread. Tool results, user prompts, harness
notices/agent reports and blank deltas only drive the working state.
Flutter's safe area leaves out the window controls of a windowed iPad app,
so they covered the list pane's title pill and took its taps. A small Runner
plugin reports their corner from UIKit's corner-adapted safe-area regions
over a method channel, and SegmentedBar pads the side they overlap. No-op
off iOS and when there are no controls.
The floating bar keeps the title at its own width (up to half the bar) and
moves overflowable actions into one More menu instead of squeezing them
below their touch targets. List rows keep their leading status avatar and
More actions at any list-pane width; the time moves under the subtitle.
Run the full-app fixture entry on an iOS simulator: options from a file in
the app's tmp dir or the environment, route via a route provider, a narrow
strip for Split View widths, and a small in-app tap/type driver.
At a tab's root the system Back now returns to the tab opened before it,
through a most-recent-first stack of visited tabs without duplicates.
Every tab change (tap, Ctrl+Tab, a routed open) records it. Pages over
the shell, Settings and a page in the open item's pane still close
first; with no history Back reaches the platform as before. Only the
shown tab's detail pane answers Back now.
Top highlight, rim and shadow are much fainter in both themes, the
highlight fades out sooner (0.55 -> 0.4), the backdrop saturation boost
drops from 1.6 to 1.25 and the fill opacity rises from 0.78 to 0.82.
One backdrop filter per piece and the solid high-contrast piece stay.
Markdown links, autolinks and bare http(s)/www. URLs open externally through
url_launcher (http, https and mailto only) in assistant markdown and operator
messages; code is never linkified. Links use the host primary colour with an
underline that thickens on hover, and offer Copy link on long press and
right-click without breaking text selection.
GlassPill (segmented bars, floating tabs, composer, viewer control bars,
top strips) now composes blur with a saturation boost in one backdrop
filter, paints a soft top highlight, a thin luminous gradient rim and an
outer-only depth shadow, tuned separately for light and dark fills
(GlassLook in glass_surface.dart). Fill opacity 0.84 -> 0.78; blur stays
at sigma 4 and one filter per piece. High contrast keeps the solid piece.
iOS and macOS no longer switch to the Cupertino host or Cupertino controls by
target platform; they render the same Material UI as web and Android.
Cupertino paths remain for an explicit cupertino: true host. Flutter's
automatic platform behaviours (scroll physics, text selection, back-swipe
transitions) are unchanged.
The just-sent (or queued) message slides up 20px, fades and grows from
0.96 over 280ms on an emphasized decelerate curve. Only a send marks it:
history, scroll restore, other devices, replies and the server copy
replacing the local one appear in place. Row keys follow the operation
id so the server copy keeps the row. Reduced motion shows it at once.
The capture fixture now accepts chat_prompt.
Server: internal/discovery publishes a DNS-SD record (hashicorp/mdns) with
the port LAN clients dial (the web proxy via -mdns-port, which the
supervisor passes, or a non-loopback -addr) and TXT v, name, path, tls, auth.
On by default; -mdns=false or PIPELINES_MDNS=off disables it. Failures are
logged and never block startup; the advert is withdrawn on shutdown.
App: the Connect to Pipelines screen gets 'Find servers on this network'
behind a ServerDiscovery interface (Bonsoir: Android NSD with multicast lock,
iOS Bonjour with NSLocalNetworkUsageDescription and NSBonjourServices).
Tapping a server fills the address and connects; manual entry stays. Web has
no scan.
The composer's /new used to create a separate chat. It now sends
chat_new_session. The server starts a fresh native session on the chat's
own harness (OpenCode, Codex or Claude Code) and re-keys the
operator_sessions row in one transaction. The chat keeps its title,
directory, backend, colour, star, model and mode. The old row is kept
unlisted with replaced_by, and its native session stays resumable.
The reply and the chat_session_changed push carry previous_id, so every
client swaps the row in place and an open conversation follows it to the
fresh, empty transcript with a notice.
Chat hits sort by the chat's last use whatever field matched, and run,
step, field, artifact and pipeline hits sort by their own date, before
the result cap applies so the cap drops the oldest. Each kind's row scan
also walks newest first. Score still reports the match tier. The app
sorts both groups newest first as well.
A search with kind chat matches the operator-session registry's titles and
directories and the newest messages of recent transcripts through the chat
broker (bounded count, concurrency and one-second budget), answered off the
connection's read loop. The all-kind search is unchanged for older clients.
The app sends the chat search after its run search and shows a Chats group
with title, harness, directory and snippet; a chat hit opens that chat in the
Chat tab. The probe fixture answers chat searches over ?chats=N.
Two or more consecutive Claude Code task notices fold into one
task_notices row: a chip 'N background tasks' (tinted when one failed)
that opens a sheet with one compact row per task (outcome icon, summary,
outcome word), like the tools and permissions chips. A lone notice stays
one line. The server also treats Claude Code's [SYSTEM NOTIFICATION]
banner as harness text, so a bannered notification without an origin is
still a notice, never the operator's turn. The chat fixture gains
?tasks=N.
A chat opened from the keyboard asks its composer for focus; the composer
takes it after the frame it is built in (new detail pane or phone page), or
at once when that chat is already open. Taps and other opens cancel the
request, so they keep focus where it was. The capture kit's press step
accepts modifier chords such as Control+2.
Spawns pass the session title with --name (Claude Code records it as the
transcript's custom-title). A rename tells the harness the new title for its
next spawn, and the first routing of a session after a restart hands it the
registry title.
The four destination buttons move from the bottom right over the detail
pane to the bottom of the list pane, centred in the (dragged) list width.
The list now keeps the bar's height as bottom clearance; the detail pane
clears only the system inset, so its tabs, the chat composer and the
artifact actions sit at its bottom edge. Phone layout is unchanged.
kStackedBarGap is gone with the stacked bars.
A chat's colour is picked from its row menu (Colour...), a long-press or
the chat information sheet. The list shows it as a leading bar, a faint
row tint and a coloured avatar; the open chat shows a faint wash under its
top bar. Shades are Cupertino's dynamic system colours and Material
swatches tuned per brightness. Changes from other devices apply live.
Ctrl+1...Ctrl+9 open the Nth item of the open tab's list (chats, runs,
pipelines) in on-screen order, also while typing. Starred chats are sorted
by name, case-insensitively, as one alphabetical group.
After a send the view jumps to the end of the conversation and resumes
following, even when the operator had scrolled up or the message is taller
than the screen, so the message's end and the reply stay in view.
The chat information sheet gains a Session section: the harness's native
session id (copy), harness, directory, a verified resume command (copy)
and Export conversation (Markdown), Export JSON and, for Claude Code,
Export native session (the JSONL transcript).
Server: chat_sessions rows carry resume_command and native_export; new
chat_export command builds Markdown/JSON from the same paged history
chat_messages serves (bounded at 8 MiB), refuses non-operator sessions.
App: exports go through the artifact file bridge (web download, share
sheet on phones).
chat_color {session_id, color|null} stores a palette name (red, orange,
amber, green, teal, blue, purple, pink) on the operator-session row; rows
and replies carry it as color. Colour, star and rename changes are pushed
to every other connection as chat_session_changed.
A 12 px grab area over the divider line resizes the list live (mouse,
touch, arrow keys; double tap resets to the default policy). The shell bar
over the list follows. Widths persist per destination in SharedPreferences
and clamp to the window without overwriting the saved value. Capture kit
gains hover= and drag= steps.
At the field's line limit, a newline at the end left the caret on an empty
line the field only scrolled to after the next character. The field now
scrolls to the end right after such an edit.
The message field grows up to 12 lines (was 6) before it scrolls, capped at
about 40% of the visible height with the keyboard excluded, so the
conversation stays in view on a phone.
One shared pop (pop_entrance.dart: PopTransition, popWindow, PopEntrance)
drives the floating tab buttons and the top bar, on Motion.tabEntrance*
(0.6 -> 1, 260 ms, 70 ms stagger, ease-out-back, glass fading in).
SegmentedEntrance and the barEntrance* constants are gone.
Back, the title, the actions pill and each action pop in turn from the
leading edge (SegmentedEntrancePlanner). A lone action pops once, with its
pill. A newcomer pops alone. Rebuilds and title changes never replay it.
The shell passes published actions one by one, keyed by their screen
(actionsKey), not as one cross-fading Row. The chat thread's model and mode
are separate actions. The folder picker now uses SegmentedBar.
The selected tab's whole button (62 px Material, 60 px Cupertino, from 52/50)
and its icon grow with the selection in the layout, so the other buttons move
over and every gap stays the same; the previous selection shrinks back. The
row is as tall as the selected button with the others centred on it.
The selected icon grows to 1.15x with the selection tint (220 ms, same curve)
and shrinks back when another tab is selected, on every floating tab bar;
reduced motion jumps straight to the size.
Root causes found in release web captures (1280x800 and 560x900):
- Follow mode undid small wheel/trackpad ticks at the end: each tick is its
own scroll, re-judged as following within 32 px and jumped back. A user
scroll toward older rows now releases the end however small; the jump
control appears once streamed content moves the end beyond the threshold.
- The end-of-scroll jump ran inside the position's activity switch, so a
touch or scrollbar drag released near the end recursed without end (stack
overflow during the gesture). The jump now runs after the notification.
- Horizontally scrolling code blocks and tables claimed diagonal trackpad
gestures whole. HorizontalScrollView gives mostly vertical gestures to the
enclosing list; sideways and Shift + wheel still scroll the block.
- The wheel over the floating chat bar, composer and jump control moved
nothing. VerticalWheelForwarder scrolls the transcript from them unless
something under the pointer claims the event.
Adds widget tests per content kind and scroll mode, follow/touch/Load older
tests, a capture-kit check (tool/capture/examples/chat-wheel-scroll.json)
with eval/expect steps, wheel dx/repeat, --params and eval: targets, a
transcript scroll probe and fixture options, and fixes the kit ignoring a
script's size. Notes in notes/chat-wheel-scroll.md.
Usage frames carry optional usage.account {harness, source, plan, as_of,
windows[{id,label,used_percent,resets_at}], unsupported}. Claude Code quota
comes from its rate_limit_event stream lines and the initialize account
(plan), shared across chats on the same account. Codex reads
account/rateLimits/read once per connection (re-read when a chat opens after
5 min) and merges account/rateLimits/updated. OpenCode exposes no quota API
and says so. The app's chat info sheet shows an Account usage section with a
progress bar and reset countdown per window, Material and Cupertino.
Replace the single glass pill (host NavigationBar/CupertinoTabBar with one
gliding highlight) with a row of separate circular GlassPill buttons, 52/50 px
with 12/10 px gaps, at the same bottom-right place. The selected button fills
with the host selection tint and cross-fades; each button pops in on its own,
staggered, only when the bar appears or its tabs change; presses sink like the
top bar's. Tab semantics, keys, tooltips and badges are kept; the row shares
one BackdropGroup for its blurs.
On a phone-width window the open run is its own page pushed on the app
navigator, so RunDetailTabs was not a descendant of the shell's
RunSearchSelectionScope (which wraps only the Runs tab body). The field or
artifact selection was never seen and the run opened at its plain Summary.
The previous widget tests injected the scope directly above RunDetailView at
900 px, where the detail is an inline pane, so they could not catch it.
- RunsScreen relays the shell's search scope into the detail it builds, so
the pushed page sees the selection too (also fixes field hits on phones).
- An artifact hit now opens the run's Artifacts tab and the gallery opens
that artifact exactly as a tap there does: selected, scrolled into view
(ArtifactVisitReveal) and in the viewer. Back returns to the tab with the
artifact highlighted. An unknown URL leaves the tab open with the existing
"That artifact is no longer available." notice.
- New test/application/search_artifact_open_test.dart drives the real Search
tab -> typed query -> result tap -> run read -> viewer on a 390x844 phone,
Material and Cupertino; it fails without the scope relay.
Inside a glass bar the first and last controls now keep the same gap from
the pill's sides as from its top and bottom, from shared GlassBarMetrics
(48/44 targets, 8 edge gap). Applies to the artifact viewer bar (hugs its
actions without a pager), the chevron pagers (position text inset like an
icon), and the chat composer's Cupertino Send/Stop (centred circle).
Run 7 in the full-app probe now records change captures for diff captures.
Adds the copy-paste prerequisites for Linux (Docker group, Go from go.dev,
OpenCode), the PATH line for the installed CLI, and enable-linger so the
systemd --user service survives logout.
The finished-reply notification now carries up to 1000 characters of the reply
(was 200), keeping its paragraph breaks for the app's expanded notification;
ntfy still gets it on one line within its 2048-byte limit.
Each island (Back, title, actions pill, each action) scales in from 0.85
with a gentle overshoot, staggered from the leading edge on first show and
at once when it newly appears; rebuilds and title changes keep it. Glass
fades its fill and blur together so backdrop grouping is unchanged.
Every tappable piece sinks to 0.94 under a stadium tint while pressed and
springs back. Reduced motion skips the animation.
Claude Code records subagent/peer reports, task notifications, reminders and
skill bodies as user-role entries. Classify them server-side (history and live
stream) by origin/isMeta/queued_command mode: reports become kind agent_report,
task notifications kind notice, harness meta is hidden, and the mid-turn
wrapper is unwrapped to the operator's text. The app draws a collapsed Agent
report card and a one-line system notice on the agent's side.
The viewer's top-bar Details action reused the compact bottom-bar button, so
its icon sat off-centre in the bar's round pill on Material. Bar actions now
use the standard bar button size.
A created chat's reply carried no mode, and the chat destination kept the
first row it opened for the whole visit, ignoring later list re-reads, so the
mode control only appeared after closing and reopening the chat. The server
now names the mode on a created row, and the destination adopts each listed
row that a re-read changed (excluding the live running flag), so the open
conversation follows new, refreshed and other-device mode changes in place.
Claude Code chats now start with the chat directory's own environment:
direnv (allowed .envrc only, via direnv export json) and mise (mise env
--json), cached per directory and invalidated when config, watched files or
allow records change. A blocked .envrc is logged and shown in the chat as a
notice and never applied. When the directory chooses the Claude account
(CLAUDE_CONFIG_DIR, API key or token variables), the server's service token
and login-file fallbacks are skipped and inherited credentials dropped.
Transcripts in a directory's CLAUDE_CONFIG_DIR are found for history,
resume and after a restart. PWD is set to the chat directory.
On very wide windows (a 4K monitor) the list took 40% of the window; past
440 px the extra width now goes to the open item. Fold and laptop widths
keep the 60/40 split.
Checks the CLI on the server's PATH (install command when missing), signs in
with the harness's own login only when needed (--login forces it), keeps the
OpenCode/Pi model pickers, and verifies with the server's check. Works on
native and Docker installs (Docker delegates to the container setup); --host
is a hidden compatibility alias. harness list shows all four harnesses'
installed/signed-in/configured/default status. ./install --opencode|--pi now
point to the command; ./install ends with the next-step hint.
Chat attention notifications (questions, approvals, finished replies) come
from a session's event stream, which the hub only read while a room existed;
detach destroyed the room when the last client left, so a turn that finished
or asked with the app closed notified nobody.
A room whose last client leaves now stays observing, unattended, while its
turn is in flight or it holds an unanswered question/approval, and is torn
down when the turn ends (or after 6h for a stuck turn); at most 16 such rooms.
At server start, recently used open sessions whose harness reports a running
turn (OpenCode /api/session/active, Codex thread/turns/list) are observed
again so their reply still notifies. Settings, dedupe and app_notifications
recording are unchanged.
The per-tab entrance pop lived in each icon, but the hosts swap a tab's
icon subtree when it is selected or deselected (Material wrapped the
selected icon in its own circle; Cupertino did the same in activeIcon),
so every tab switch remounted those icons and replayed their pop.
The bar now owns the entrance, highlight slide and bounce animations and
restarts the entrance only when its set of tabs changes.
One highlight behind the icons glides to the new tab (250 ms, stretching
to 1.25x wide mid-move) and the new icon bounces (1.08x, 180 ms); reduced
motion jumps. Cupertino paints it from tab 0 above the host's backdrop
blur.
Rewrite the README around the server, web/Android app and CLI, and
replace docs/install.md with the current native install (all-or-nothing
Docker web build, flags from setup-native.py, lifecycle commands, data
locations, password, upgrading). Add docs/harnesses.md and
docs/notifications.md; point ntfy.md at the new overview and fix its
topic name.
A waiting human stage has no outcome yet, so its notification read
"… · waiting ()". The outcome is now shown only when recorded, and a
waiting stage reads "waiting for your decision".
Chat sections are slivers: a lazy, keyed SliverList under the same heading,
with SliverAnimatedExtent reproducing the clipped AnimatedSize for open,
close and arriving rows. The first Chat tab visit no longer builds every row
(150 chats: worst build frame 116 ms to 19 ms).
FadeThroughStack(lazy: true) builds only the shown page first and the rest
one per frame once no animation runs. Opening a run detail no longer lays out
Timeline, Artifacts and Changes offstage during the route transition
(transition build 62-103 ms -> 38-59 ms); first tab switches are unchanged.
Adds tool/perf/interaction_bench.mjs (FrameTiming per interaction over the
full-app fixture, CPU profiles mapped to Dart files), fixture options for
hits/chats/graph, and notes/perf-round3.md with the survey.
Blur sigma 16 -> 4 keeps CanvasKit on its direct blur path; under the 84%
fill the look is unchanged (max 13/255 inside the pieces). SegmentedBar's
pieces share a BackdropGroup so Impeller reads the content behind them once.
Adds a scroll frame-time bench, a backdrop census and filler rows to the
full-app probe. CPU CanvasKit, 560x900: run timeline p50 31.8 -> 22.1 ms,
runs list 25.3 -> 19.9 ms.
After opening an artifact from search the pending flag was never cleared, so
later visit selections stopped syncing. It is cleared once the visit page is
installed. Adds widget tests: the hit opens the viewer on that artifact, Back
lands on its visit and another visit still opens, and a missing artifact shows
the notice. Finishes run #231.
Runs and chat session rows are memoized on their own data (MemoSubtree), so
a run event or a chat's running change rebuilds one row instead of every
built row. The artifact gallery's open sections are lazy slivers revealed
by a sliver open/close animation, and thumbnails decode at display size.
Benches in test/perf measure both.
Reuse unchanged transcript rows, the composer bar and the header across
streamed deltas, and share parsed markdown by text so rows scrolled back
into view are not parsed again. Adds a rebuild/parse harness and a
release-web frame-timing probe with a long-transcript fixture.
Relative-time labels follow one wall-minute RelativeTimeClock instead of a
timer per row, skip ticks while their tab is offstage and rebuild only when
their text changes. The shell rebuilds its top bar only for the focused
destination's published bar and its tab bar only for badge changes. Run
events that repeat a row's state no longer notify, and the runs list filters
and sorts once per build. Adds a rebuild/timer benchmark.
Server: list_directory returns a directory_listing (path, home, parent,
entries with is_dir/is_git_repo/hidden, truncated) confined to the server
user's home subtree after cleaning and resolving symlinks, refusing pseudo
filesystems and capping entries at 2000. Documented in docs/cli.md.
App: "Choose folder…" in the create dialog opens a picker (full-screen page
on phones, large dialog on wide windows, Material and Cupertino) with
breadcrumbs, filter, Show hidden, git badges, dimmed files, recent folders,
inline errors and "Start chat here". The probe app gains a folder fixture
for captures.
Every preview (image, text, markdown, HTML, video) now fills the space between
the viewer's top bar and its bottom controls instead of passing behind them;
the insets are applied once here and removed for the content inside.
app/tool/capture: one Chrome DevTools capture CLI over the full-app fixture
(serve build or URL, private headless Chrome or --cdp attach, label/key/xy
clicks via Flutter semantics, type, press, scroll, screenshots, filmed
clicks with a canvas contact sheet, cleanup on exit/signal), README recipes
and an example script. The fixture entry gains ?theme=light|dark.
app/tool/memwatch: run.sh/full.sh watchdog moved from /tmp (output dir
created if missing, exit status propagated) plus install.sh for the legacy
/tmp/memwatch shims. app/AGENTS.md points tests at full.sh and UI review at
the capture kit.
On a phone the pipeline detail was pushed above the shell, so Runs switched to
the Runs tab underneath it and seemed to do nothing; the detail now shows only
while the Pipelines tab is active. Runs (list) and Run (play) are icon-only
bar actions with their accessible names. Finishes run #230; adds a phone-width
regression test.
Replaces the coloured graph with the Pipelines tab's own glyph (Material
account_tree, outlined, taken from the MaterialIcons font) in white on the
dark background, across Android, iOS and web.
A run stays in r.active after finishRunState persists its terminal status
until its goroutine finishes notifying, so a decision in that window was
refused as "already active". decide now refuses only runs whose terminal
state is not yet durable; a finished run gets ResolveDecision's
already-decided / not-waiting answer, and an executing run is still refused.
Tests overwrote runner.artifactsRoot after Handler/newRunner had started
background goroutines (sizeLoop, session export jobs) that read it. The
root is now fixed at construction through newRunnerAt, which
HandlerWithOptions uses for Options.ArtifactsRoot, and tests configure it
there instead of mutating the field afterwards.
The thread reads the session's queued prompts from the chat_subscribe reply
and chat_queue frames: a reload draws them as Queued after the transcript,
a delivered one enters the transcript as Sent, a refused one becomes Not
sent, and Remove sends chat_unqueue. A prompt the server reports queued is
dropped from the device unsent store; the any-frame queued heuristic is
used only with a server that does not report its queue.
Claude Code (stream-json stdin) and Codex (turn/steer pinned to the active
turn) receive a prompt sent while a turn runs immediately. Other harnesses
(OpenCode) get a durable chat_prompt_queue row owned by the session: it
survives the last client detaching and a server restart, is delivered in
order when the turn ends with or without a client, and is deduplicated by
operation id. chat_subscribe carries the queue, chat_queue frames report
delivered/removed/failed changes, and chat_unqueue removes a waiting prompt.
One stage forks into two parallel stages that rejoin in a finished ring, in
the app's palette on the dark background. Updates the Android adaptive,
themed and legacy launcher icons, the status-bar icon, the iOS icon set and
the web favicon and PWA icons, and adds the generator under tool/app_icon.
Tabs fade through when switching main destinations and page tabs. Each page
keeps one widget structure whatever its state, so its element (scroll,
controllers, text) survives switches; curves are computed directly instead of
building a CurvedAnimation per frame; only the active and outgoing pages are
on stage, including under reduced motion. Adds FadeThroughStack tests.
An exhausted export recovery job left its run parked forever in the
export wait, reserving the workspace and refusing later scheduled runs
(runs 221/226: OpenCode sessions above the 8 MiB export bound are
always truncated, so every retry stays partial).
A gate is now releasable when its job is exhausted: the visit keeps its
partial/unavailable evidence and diagnostic (still repairable), the run
continues to its next stage or terminal, and the workspace is freed.
Gates older than 15 minutes with a pending, lease-expired or missing job
are exhausted by a bounded wait. The worker reconciles on its first
tick after startup and every 30 seconds, so existing wedged runs recover
after a restart. Truncation diagnostics now name the size bound.
The viewer's action/pager bar added the inherited bottom clearance twice
(its SafeArea already applies it), floating far above the tab bar. On the
web an HTML preview's iframe passed behind the bars and, as a platform view,
took every click there; it now stops at the bars. Also keep floating tabs in
semantics while they fade in, which broke the badge announcements (5 failing
tests on main since the entrance animation landed).
Tapping the run detail's title expands it to the whole title and subtitle
with an icon button that opens the pipeline; tapping again, or another run,
collapses it. The expanded title is drawn in the overlay, anchored to the bar
and sized beside the actions, so its pipeline icon receives taps and the
actions stay visible. Other bars keep their title behaviour. Finishes run #224.
Opening a stage artifact paged through every visit's turn documents too,
although the list hides them; the viewer now pages through what the list
shows.
A native foreground service keeps an authenticated websocket to the
connected server (handed over by the app on every connect), subscribes with
a replay cursor, shows each notification with kind-based channels and
grouping, opens pipelines:// links on tap, and clears taps, dismissals and
cross-device clears. It starts at boot and app launch, backs off and follows
network changes. Settings gains the delivery switch, status, notification
and battery-exemption actions, and the server's optional ntfy_enabled
toggle.
Record every notification published to ntfy (run outbox, stage notify
hooks, chat question/approval/reply) in a persisted app_notifications
outbox and stream it to subscribe_notifications clients with an after
cursor; clear_notifications and ack_attention clear across devices, as do
runs leaving waiting, deleted runs and answered chat questions. Add the
notify.ntfy_enabled setting (default on) to stop only the ntfy publish.
A shared RelativeTimeLabel refreshes at the next minute/hour/day boundary,
pauses while the app is hidden and catches up on resume. It keeps the row's
time style (an unread chat's accent). Continues run #218.
Turn documents are hidden behind the Debug toggle now, so the run's own
artifact groups (the run Artifacts tab and a stage's Artifacts section) start
open instead of collapsed.
- Select mode (bar Select or long-press): per-row checkboxes, per-day
Select all/Deselect all over finished runs only, "N selected" with the
selection size, Delete and Done. Active runs get a disabled checkbox
whose semantics give the reason.
- Native destructive confirmation, then delete_runs {run_ids} (batched by
1000); the nested runs_deleted reply removes deleted rows and reports
"Deleted N runs, freed X" plus refusals verbatim. runs_removed pushes
remove rows and close an open detail; a deleted open run closes too.
Delete run in the row and detail menus.
- size_bytes shown compactly in rows (0/absent = unknown, nothing shown),
updated from run_event frames that carry it; Largest first sort (flat,
unknowns last); the sort choice persists.
- Shared AppListRow gains selectionControl and onLongPress.
- Browser probe tool/runs_delete_probe.mjs; fixture server implements
delete_runs/runs_removed.
On web the engine closes the text connection on the editing element's blur,
which the browser fires just before the window blur, so the field is already
unfocused when lifecycle inactive arrives and FocusManager's own suspend and
resume restores only the route scope. Remember whether the composer held (or
had just lost) focus when the window left, and refocus it on resume, keeping
the caret and selection, unless another control took focus or a dialog,
sheet or route covers the chat. Desktop hosts only, so phones never get an
unasked on-screen keyboard.
Every run summary carries size_bytes (artifact tree, server-created Pi
session directories and an estimate of the run's database rows), cached in
pipeline_runs.size_bytes, invalidated by triggers, measured when a run
finishes and backfilled in the background. delete_runs removes terminal
runs with every scoped row and server-owned file, refuses active ones with
a reason, and pushes runs_removed to subscribers. pipelines runs rm is the
CLI form; retention apply now shares the complete row deletion.
The room that records a server-run turn is torn down when its last client
leaves, so a page reload re-subscribed to a new room that no longer knew the
turn was running and never replayed the step-started marker. Claude Code does
not re-announce a running turn to a new stream either, so the activity row and
Stop control vanished until the next streamed delta.
chat_subscribe now also replays the marker when the room's stream announced a
turn (CLI-originated or re-announced on attach) or when the broker reports its
own turn in flight through the optional chatTurnReporter (Claude Code reads its
in-process running flag; the chat manager routes it without I/O).
Remove the 840 px Search reading cap (results column and bar pill) so both
fill the pane at Fold and wide widths. Add a width test for the stage page
at 880 and 1400 and deep-link/query flags to the search probe entry.
Claude Code emits one assistant event per content block, so a text block that
streamed at index 1 after a redacted (empty) thinking block arrives alone at
index 0 of its event. The translator aligned completed blocks by that local
index and cleared stream state after every event, found no streamed text, and
re-emitted the whole paragraph as a new text part. Claim the streamed block of
the same kind whose text prefixes the completed one, and keep stream state for
the whole message (reset on message_start or a new message id).
./install retires the pre-native standalone web agent (net.awan.pipelines.web,
kept as .disabled) and, when the public web URL is a tailnet HTTPS address,
points tailscale serve at the installed web proxy, failing the install if it
cannot.
A sent message is stored on the device until the server accepts it, so a
reload mid-request no longer loses it: on reopening, a stored intent the
history records is cleared as sent, otherwise it shows as Not sent with
Retry (same operation id) and Edit. The operator's bubble shows Sending,
Sent (newest only), Queued or Not sent. A live refusal keeps the old
contract (exact draft and chips back in the composer, unchanged re-send
reuses the id) and marks the bubble Not sent with Retry. On web, leaving
or reloading the page while a prompt is in flight asks first.
Added and removed lines take GitHub's green and red tints, with the code in
the label colour and the +/- marker and counts in GitHub's strong green and
red, in both themes and hosts.
The transcript listener read the lazily built _controller while _attach was
still building it (load() notifies synchronously), so it built another
controller, recursively, until the test process ran out of memory.
./install builds the web app and the server before replacing either, and
fails without Docker or on a failed build, leaving the old pair in place.
The supervisor and start refuse to run the server when the web app is not
installed.
Consecutive text parts of an agent turn (including folded messages) and
markdown blocks within a part are now separated by ~0.9x the scaled body
font size; a heading stays 8px from what it introduces. Adds a ?paras=1
chunked reply to the composer probe and gap tests at 1x/2x.
The floating tab bar is now sized to its icon tabs at the bottom right on
every width, the selected icon sits in a tinted circle on both hosts, and
the gap from each outer circle to the pill's sides equals the gap to its
top, bottom and neighbours.
A harness missing at server start (e.g. codex mid-reinstall) is probed
again on chat_backends and on session create/adopt, throttled to once
per 10s while unavailable. Attached clients are never replaced.
Auto runs no longer alert on failure or success; only notify_mode on does,
unless the run_finished setting (now 'Notify when any run ends', default off)
opts into every run end. Waiting still notifies auto and on runs. The setting
is stored under a new key so a value saved under the old meaning is ignored.
The linear layout used by the definition and run graphs placed each
outcome label at the middle of its widest run with no collision check,
and the run graph measured only the label text while rendering an order
badge in front of it, so taken labels ran into the next node.
Labels now try positions along their own route (horizontal runs above
and below, sliding along, then vertical runs) and take the first whose
box stays 4px clear of every node and earlier label, preferring spots
off other wires. If a label finds no spot, the layout widens its column
gaps and lanes and runs again; a last-resort shelf below the drawing
never overlaps. The run graph measures the exact badge+label widget it
renders, keyed by edge id.
On a wide split window a run's stage page (or an artifact, a file) opens
inside the detail pane's own navigator. Selecting another run kept that
page on top, so the pane still showed the old stage. ListDetailPanes now
takes the selected item's identity (run, chat or pipeline id) and the
pane navigator pops back to the item when it changes.
When canonical main is not an ancestor of the item HEAD, the gate now
merges main into the item workspace under the delivery lock, re-runs the
declared checks on the merged commit, and fast-forwards main to it. A
conflicting merge is aborted with the workspace verified unchanged and a
diagnostic naming the files. Successful catch-ups are logged.
Settings leaves the tab bar (Pipelines, Runs, Chat, Search) and opens as a
page from a gear in the Pipelines bar, keeping /settings, its keys and a Back
to Pipelines (also the system Back). Every floating tab bar shows icons only,
named for assistive technology. On wide windows the shell's tab bar stays at
the bottom right; a split detail learns its height plus a 12px gap, so its
tabs or the chat composer float above it, and pages the detail opens (the
stage page) stay in its pane through its own navigator.
Timeline outcomes: success-like words are green, failures red,
rejections orange, retries/advisories amber, skips/cancellations grey;
a second word of the same family takes the family's next shade and any
other word a distinct hue outside the families, so different outcomes
still never share a colour.
Run detail, stage page and pipeline Summary no longer cap their width
at 840: on an unfolded foldable the sections fill the pane. The unused
ReadingWidth helper is removed.
Review r2 findings P2-4, P2-5, P3-13: a shared relative-time helper for
every list row's time, formatDuration switches to days past 24h ('9d
16h'), the stage page uses one visit numbering, drops a repeated stage
heading and fixes '1 files', and search run hits read 'Run 1'.
Implemented by pipeline run #205/#207 (Terra); its UIReview blocked on a
fixture without timestamps, verified by the manager.
A completed step's outcome chip took the success colour, so 'rejected'
read green beside 'success'. Outcome chips now get one colour per
distinct outcome name in the run (assigned by first appearance, from a
well-separated hue list that continues by the golden angle), so equal
names match and different names never share a colour. No outcome word
is wired to a colour; the status glyph still shows the step's state.
Detail bodies are flat on the page on both hosts (no Cupertino inset groups,
pinned headings on the page colour). Run and pipeline Summary share a
FactsGrid that fills its width (no centred single-fact card). Missing run
graph is one muted line. Beside a list the run tabs and header share one
row; the duplicate Pipeline fact and the decision card-in-card are gone.
Pipeline Summary: facts grid, Schedules heading with Add (no inline Refresh
or paragraph), versions as AppListRow. Timeline rows are AppListRow.
Shared AppSheetHeader (title + Done) for the Runs filter/sort and Needs you
sheets; Runs filter single-choice groups as check rows and statuses in
sentence case; Cupertino decision options as a check list; run action sheet
titled with the run; usage page without the duplicate title and with honest
empty states; Settings Reconnect wording, compact notifications row and a
tinted Cupertino Save workspace; friendly artifact preview failures with
Retry.
- SegmentedBar.titleWidget (and ShellBar/ShellBarSpec titleWidget,
backgroundColor): a bar's main pill can be an input in place of the title;
Search uses it so the field fills the bar with Kind and info, capped at the
result column width so field and results share edges on wide windows.
- Templates page/frame drop the top SafeArea again (BelowTopBar gate,
TopBarNotices banners); Cupertino uses the grouped background.
- Settings on Cupertino in the shell publishes the grouped background so the
bar scrim matches the page (no white band or seam).
- TopGlassStrip: the run detail header (status, actions, decision, notices)
and the Schedules search/filter toolbar float as glass under the bar; tabs
and lists scroll behind both.
- Stage page: stage title and Visit/Run subtitle in the bar, facts lead the
Summary scroll, sections scroll behind the bar under floating tabs.
- Tests for content-behind-bar on each page and the title-widget bar mode;
notes/chrome-gaps-fixes.md.
Review findings F12, F13, F25 and F1 for viewers: the artifact viewer's
actions/pager and the Changes pager float as glass pills over content,
file facts move to the top bar, graph overlay controls are one glass pill
(duplicate fullscreen glyph removed), the image viewer is immersive, and
diff/artifact/graph views let content pass behind the bar. Implemented by
pipeline run #204 (Terra); its Review stopped after three rejections, the
last being an empty glass bar for a single unresolved artifact, which the
manager fixed here with a regression test.
AppListRow (Material + Cupertino) with avatar, bold title and trailing
time, one muted line, one overflow menu style, inset dividers, selected
and emphasised states and a compact mode. Pipelines get a legible initial
avatar, schedule rows shrink to two lines with Edit/Pause/Delete in an
overflow menu, and the shell chat list scrolls behind the bar.
- Top-bar clearance helpers (withTopBarClearance, withBarClearance,
SliverTopBarClearance, BelowTopBar, TopBarNotices); shell, DetailPane and
the runs/pipelines/templates/artifacts/stage definition/filter/usage pages
drop their top SafeArea and pad their own lists, pinned headers pin at the
inset.
- Wide windows: the shell bar narrows to the list pane (ShellPaneSplit) and
the open item's bar shares its row; item tabs float at the pane's top
(PageTabsEdge) instead of stacking on the shell's tab bar; the floating
tab pill no longer swells over leftover media padding.
- Pipeline detail is a DetailPane on wide too; Run/Runs move from FABs into
the bar's actions; name and identity live in the title pill.
- Run detail title pill shows the real title with Run N, pipeline and
version (the pill links to the pipeline); the body keeps only status,
actions and notices; standalone detail draws the same segmented bar.
- One Runs tab badge: attention outranks running.
- Tests for content-behind-bar padding and the no-stacking wide layout;
notes/app-chrome-fixes.md.
- Search: field, compact Kind menu and syntax help in the bar's actions pill;
bounds shown only when truncated; rows with bold title, kind tag and one
muted line; results run behind the bar in a start-aligned 840 column.
- AppSearchField: one search field per platform (Search, Schedules, Runs filter).
- BarIconButton: whole 44pt/48dp bar actions; Runs, bell and Pipelines icons
use the same 44pt targets on Cupertino.
- Templates and Schedules pages put Refresh in the bar and use the shared
round SegmentedBackButton; Templates shows one Back at a time.
- PipelineBackButton is the round segmented Back.
- notes/pages-fixes.md records the batch, tests and evidence.
Review finding F4: section headings were a solid surfaceContainerHighest
band with a 3px accent stripe. They are now a muted grouped-list label
on the page background; pinned headings keep a light translucent scrim.
Implemented by pipeline run #201 (Code/Review on Terra); its UIReview
blocked on a stale probe, verified by the manager instead.
Servers become rows with a selection mark, addresses as subtitles and a
Use/Edit/Remove menu plus an Add server row; the connection is a status row
with address and Reconnect/Disconnect rows; Templates and Schedules are
chevron rows in a Library group. Material groups are flat surfaceContainer
surfaces with primary titleSmall headers (no Cards); Cupertino uses
inset-grouped sections on the grouped background, switches for the ntfy
choices. The trust warning is a footer, helper copy is shortened, Save
workspace is a legible tonal/plain button, and the column starts at the
bar's inset (max 720) instead of being centred. The page pads by the top
media padding instead of a top SafeArea.
Later visits' input.md held only the previous stage's output, so the
operator's task reached only the first stage; when a Prepare stage
summarised (paths, HEAD), Code never saw the task or its acceptance
checklist and either blocked (run #202) or did part of it (#195, #197,
#198). Later inputs now carry the run prompt under '# Run task' (headings
demoted) before '# Previous turn output'.
The trailing relative time could not shrink, so a 320px row at 2x text
overflowed; it now keeps at most 40% of the title line and ellipsises.
Update the pipelines screen test for rows that no longer show the run
number or a no-runs line.
One floating frosted tab bar (host NavigationBar / CupertinoTabBar in the
shared GlassPill) replaces the NavigationRail, the Cupertino sidebar and the
run detail, stage page and pipeline detail tab strips. Below 600px it spans
the width minus 16px margins; wider it is sized to its tabs at the right edge.
Content keeps the full width, scrolls behind the bar and learns its height as
bottom media padding; lists pad their end clear of it and FABs sit above it.
The bar now sizes itself from its own constraints instead of the screen size,
which fixes the widget_test failure where a MediaQuery without a size gave it
negative width constraints.
Run #196 landed list polish that broke a 640px window: the list pane is
~127px there, so the new pipeline icon overflowed, the run row's centre
landed on its new actions menu (a tap opened the menu instead of the
run), and the new loading/empty states overflowed short panes. Narrow
pipeline rows drop the icon and chevron, run rows show their menu only
from 280px (the detail carries it), and the state blocks scroll.
Extract the chat's segmented bar into lib/ui/adaptive (SegmentedBar,
GlassPill, SegmentedBarOverlay) and use it for the shell bar, DetailPane
and every page-level bar. Pieces are frosted glass over a fading scrim;
only pills take taps. Actions keep their natural width so the title gives
way before a model name. The chat transcript scrolls behind its header.
Sent images and composer thumbnails share ChatAttachmentFrame: rounded
corners plus a faint outline in the host's outline role, so a dark
screenshot no longer melts into a dark page. Adds a web probe that
renders the streaming activity line at several text sizes.
A Bash call with run_in_background and an Agent call return at once
('Command running in background…' / 'Async agent launched…'), so the
chat's task list counted them finished immediately and showed 0 tasks.
They now stay running until Claude Code's task notification (the
<task-notification> text or the SDK's task_notification message)
reports completion, with the exit code from its summary.
The dots were period glyphs sitting on the baseline, so they read low
beside the label. They are now round dots sized from the surrounding
text, vertically centred with it and scaling with it.
The open conversation draws its own bar of separate rounded pieces: the
platform Back in a circle, a title pill with the folder that opens the
chat information, and a pill with the model and mode controls. Detail
pages drop only their app bar for it, keeping the body mounted.
Persist three global ntfy switches in server_settings: run_finished
(default on: auto-mode runs notify on success, read inside the
transition transaction; on/off modes unchanged), chat_needs_you
(default on: gates chat question/approval alerts) and
chat_reply_finished (default off: one alert per finished assistant
turn). Expose notification_settings / set_notification_settings over
the websocket protocol, add a Phone notifications section with
Material and Cupertino checkboxes in Settings, document the settings,
and keep the cli, tui, stage and pipeline test packages from
inheriting a real ntfy configuration.
Rows lead with a circular harness avatar, put the time beside the title,
collapse metadata into one muted model · folder line and trail the
actions menu. Unread chats are bold with an accent time and dot, running
chats badge their avatar, and Star moves into the menu.
Operator-attached images render as rounded thumbnails above the user
bubble and open a zoomable Material/Cupertino viewer. Inline data: URIs
decode locally; file:// attachment-store URIs load through the new
chat_attachment_image websocket request, which serves only regular image
files directly inside the private attachment store (os.Root, <= 4 MiB,
sniffed raster types). Missing files show an 'Image no longer available'
placeholder; other files keep the file row.
Run notifications now always click through to pipelines://run/<id>; a valid
PIPELINES_WEB_PUBLIC_URL adds an "Open in browser" ntfy view action instead
of replacing the click. Queued rows derive links from the run id at delivery,
so legacy rows holding a web URL still open the app.
Unresolved chat questions/forms and permission requests publish one async,
bounded notification to the system destination (pipelines://chat/<id> plus the
browser action), deduplicated per form/request id across reconnects and
replays. stage.PublishNtfy gains optional, strictly validated view actions.
Server tests now clear the operator's real ntfy environment.
The app routes pipelines://chat/<id> to that chat, alongside the
existing pipelines://run/<id>, and Android registers the chat host so a
tapped ntfy notification opens the app on it.
On Android and iOS the keyboard's Return now inserts a newline and the
Send button sends; desktop keeps Enter to send. The Material activity
line drops TextButton's inset so it starts at the answer's edge now that
replies have no bubble.
Agent replies sit on the page without a bubble and get a copy control;
the operator's turn is a neutral rounded bubble; the composer is one
filled pill with +, a borderless field and a round Send, and its
placeholder names the chat's folder. Also fixes two picker tests left
stale by the native picker.
ChatScreen keeps a bounded in-memory cache of recently left transcripts
(16 chats / 4000 messages, LRU). A reopened chat is seeded from it with no
loading state, still re-subscribes and re-reads, and the newest page replaces
the cached copy while live frames received during the read are kept. /close
removes the entry; only transcripts backed by a successful read on the
current connection are written.
Adds tool/chat_reopen_probe.mjs and an optional history delay in the loopback
fixture. Measurement shows a second cost the cache does not remove: opening at
the end of the top-anchored transcript lays out every row (notes).
The conversation now reads chat_shells on mount and after a reconnect, and
the client serializes requests, so the deep-link and reconnect fixtures
must answer that snapshot before the history page can leave the queue.
Review 139 found the selected task's output page unbounded, overflowing a
phone-height conversation. The bar now keeps half the viewport and scrolls
its own body, the output pane is capped at twelve scaled lines, row labels
elide instead of overflowing, and a reply without a page reads as
unavailable rather than empty.
The run detail now offers the web's "Schedule this run" action when the
run names a positive pipeline and pinned version. It opens the existing
create editor seeded from the run and sends nothing until Save.
The seed preserves every field the browser's scheduleDraft({ run })
copies: title (following the title_source rule), all input keys with
prompt kept editable, pinned version, workspace, notify mode, write
paths, tool access, model, stage models and output format. build() emits
the same conditional payload as serializeSchedule.
One request key is minted per editor opening so a refused save retries
without duplicating the schedule. Advanced options are seed-only for
now: the editor has no controls for them yet.
Mark the run's recorded current stage on the run graph while it executes. The
halo is a foreground painter outside the node box, so it adds no size, hit
target or semantics, and it is derived only from RunGraphState.activeStage,
which is non-null only while the run reports executing. Reduced motion keeps a
still ring instead of animating.
Widget tests cover the sole active node, a finished run with no halo or ticker,
reduced motion, toggling it at runtime and unchanged node extents.
Transcripts pin to the newest end while following, release on the operator's upward scroll, and offer a native Jump to latest control carrying the count of messages that arrived meanwhile. The chat destination keeps each conversation's saved position so reopening restores it.
The conversation reads the session's recorded chat_shells snapshot and folds
pushed shell frames, so only tasks the server still reports as running appear.
The list is capped at three visible rows and scrolls beyond, and a task that
exits leaves it.
Selecting a task opens its recorded command, identity and running status plus
one bounded chat_shell_output page (cursor 0, 64 KiB). Empty, unavailable and
refused reads are reported with native Retry/Refresh controls, and a refused
snapshot is shown with its reason instead of claiming there are no tasks.
Both reads carry the session id, linking every task to its conversation.
A retired or unknown field hit now selects the plain Summary instead of
leaving an open visit pane in place, matching the browser's searchFieldTab
and Android. The resolved target is a sealed Summary/visit value, so the
field mapping lives in one place.
An unapplied request is dropped when the shell leaves the run it names, so
Backing out of a loading detail no longer replays the selection on a later,
unrelated visit. Search/Templates/Schedules pages above the run keep it.
Collect per-visit capture states and visit numbers with Previous/Next
instead of one body snapshot, assert the pager clamps at both ends, and use
a trusted mouse event for Copy patch so the clipboard readback still works
in current headless Chrome.
The run-wide header, note, filter and matched-path counter still describe
every visit; below them Previous/Next move through the recorded visits in
run order without wrapping, and the shown visit keeps its own stage and
Visit N heading. A single recorded visit renders no pager.
A leading slash opens the recorded command palette above the composer,
filtered by name prefix and driven by Up/Down, Enter, tap and Escape.
Slash drafts never reach the prompt path: a recorded command reports
locally that its action is not implemented yet, and an unknown word takes
the web client's no-send report with an explicit Send as message offer.
Enter and the primary control share that route.
Adds the chat commands domain vocabulary, the palette widget, composer
wiring and regression tests; notes/C9-commands.md records behaviour and
the remaining command-action gap.
Follow the web chat layout on both hosts without changing request shapes or
bubble/composer behaviour.
- Session rows (Material and Cupertino): title with trailing relative
recency, muted `directory · model` line with the `New`/`Closed` word at
the trailing edge. Shared row content keeps one arrangement; native tiles
keep their own padding, separators and subtitle size. The state word keeps
its intrinsic width and the metadata ellipsises first, so it is never
clipped at 320px/2x.
- Thread header: one row of compact icon-only Back, ellipsised title,
bounded model control and Chat information. Back keeps the destination as
its accessible name and both hosts share `Key('chat-back')`.
- Share the epoch-millis parser as `chatSessionMillis`, and match the web's
relative-time words, including `Sept`.
- Cover the row content, status word at narrow widths, header layout and
Back accessibility in widget tests; update existing tests for the
separate trailing status word.
Group each Settings section under one compact title, tighten the page to the
web's 8/16 spacing and 20/16/32 page insets, and make field labels secondary so
only the section title carries emphasis. Drop the duplicate Notifications
heading now that the permission tile draws its own title.
Adds a rendered-geometry regression for the centred 720px column, the title and
section gaps, the secondary label role on both platforms, and the single
Notifications heading.
Put the page summary and the recorded capture notes on one scrolling
header, style Material section headings as muted titleSmall, and draw a
hairline between Material rows only. Share the selection-facts hierarchy
between the sheet and the viewer and order the sheet actions Close,
Copy link, Open on both hosts.
The header now rides inside the artifact list's scroll view, so many
partial visits or a large text scale scroll with the rows instead of
overflowing the page and collapsing the list.
Tests cover per-host headings, dividers, notes, sheet order, and the
constrained 2x large-text layouts.
Compact list toolbar and rows on the web's 12px inset, a title line with
the trailing version, one muted facts line plus the last-run line, and
row separators. The detail header becomes one identity line; its recorded
id/version/stage facts move to the top of Summary, where web renders
detail-subtitle.
Replace the full-width runs dropdowns and status chips with web-shaped
controls: a Material filter popup with checked statuses and triggers, a
sort menu, and removable applied-filter chips; Cupertino gets a compact
Filter/Sort row plus one action sheet with live check marks. Add
RunsController.activeFilterCount and clearFilters(), and use the shared
seven-state run vocabulary. Clarify the singular active-filter tooltip.
Native model control and chooser in the chat thread header, matching the web
chat_models/chat_model exchange. Fixes the chat_models list parsing, keeps the
accepted server echo across Back/reopen, and resolves the session row for
/chat/:id deep links.
Remove the redundant dart:typed_data import so integrated analysis is
clean, restore immediate composer focus on send, and cover operation-id
reuse for refused attachment retries plus duplicate-name removal.
A /runs/:id?action=decide route now opens the landed decision prompt once the named detail loads, and only when that detail genuinely awaits a person. A non-waiting run consumes the request without inventing a prompt, and dismissing the prompt leaves the loaded detail. The route flag is forwarded through the existing destination seam; submission, refusal wording and the bounded re-read are shared with the detail's Decide button.
The route `/pipelines/:id[/:version]/stage/:key` now opens the pipeline
detail's Graph tab with the named stage selected and its authored
definition pane for the pinned version. A key the pinned definition does
not declare opens the Graph tab with nothing selected and no pane; no key
keeps the ordinary Summary tab.
The request is scoped to the pipeline and version the URL names, consumed
once the named pin's first reply is shown, and never replayed by a re-read,
a later version switch or a different pipeline. A route change from a pin
to latest re-reads latest, matching the web's requested-version rule.
Show dismissible notices for refused history reads, refused live watches and a running compaction. A dismissal lasts only while the recorded condition is unchanged; a syncToken gap hides pre-gap notices until fresh state arrives.
Suppress the export-only repair for a legacy session.html with no recorded
evidence, narrow the identity check to the web's own, and keep the stricter
partial rule for an unverified complete status. Fix the analyzer findings,
add gating/legacy/Cupertino coverage, format, and correct the parity docs.
`/runs/:id/stage/:key?visit=N` now selects that stage's N-th recorded
visit in the run detail Timeline, matching the web client's stage-local
visit ordering. A stage key without a visit opens the latest recorded
visit, an out-of-range index clamps to the last one, and a stage with no
recorded visit selects only its Graph node instead of inventing a visit.
Route plumbing carries the query end to end: boot seeds the router from
path and query, the parser reads path plus query, and restore keeps `?`
a query separator instead of percent-encoding it. That also repairs the
existing `?action=decide` and `/runs?pipeline=` URLs.
The Graph node click and the stage route share one sequence-ordered
resolver, so both open the same latest visit.
The chat thread header gains an Info action that opens a platform sheet (Material bottom sheet, Cupertino popup) with the four harness-reported usage facts in the web order and wording: rate, tokens, context and reported cost. Unknown facts read Unavailable; reported zeros stay zero. A live usage frame replaces an open panel without adding messages or touching turn state.
Split the export model/classification from the session wording, add the
no-session, selected-repair and missing-evidence coverage, and update the
parity matrix and R4 note.
The visit probe now passes the scheme name its fixture reads, asserts the
painted theme before capture and re-captures the export states.
Build the chat_prompt attachments array in draft order with the web's
{name, mime, data} shape, trimming and 8-file/1 MiB bounds, and read a
recorded history file part back to an attachment.
Widen AppRoute to the pipeline detail, definition stage pane, runs filter,
run stage pane, decision prompt and template detail the web client already
addresses, and canonicalise the /settings/templates aliases. The URL codec
moves to app_route_codec.dart as a part file to keep the route model and the
parser under the app's 250-line aim.
The summary line now carries the host's own disclosure control and, when expanded, the recorded lifecycle, input, output, error, duration and edit diff. Each absent field keeps an exact sentence; no value is inferred from answer text.
The opened recorded-visit pane gains one native Changes action next to
Back to timeline. It reuses showRunChanges with only that visit's step,
so the pushed page shows that visit's own capture and no run-wide
summary, and a visit without a capture reaches the honest missing-capture
state. The run-level Changes action and its title are unchanged.
Lift recorded activity/compaction parts out of an assistant turn into a
single activity row before the answer. Running kinds use the web's phase
words; terminal records keep the label the server recorded.
Stage, Started, Finished, Duration, Provider/model, Target and Verdict
come from the run reply and the current stage's latest recorded visit.
An absent fact reads Unavailable; tokens and cost keep their Metrics
home.
Map every recorded search hit payload (pipeline, version, run, step,
field, artifact) to the server's own target token and accept that
token back, so a result can name the exact entity it opened. A hit
whose payload or recorded token is incomplete or disagreeing is
reported as unresolved rather than guessed.
Native Run action opens the web's prompt/workspace/notify dialog, sends the exact run_pipeline body against the pinned resolved version with one request key per confirmed attempt, keeps refusals in the dialog, reconciles a lost reply by key, and opens only the server-named run through the existing run route with one fresh Runs list read.
Adds a shared failure-reason helper so operators never see Dart runtime prefixes, and records the slice boundary in notes/P3-run.md.
An abstract NotificationBridge with a dart:js_interop web implementation and
an honest unsupported stub; a NotificationController that reports only the
platform's permission word, asks only from an explicit gesture, never
re-prompts a denied answer, and notifies once per run+kind+finished marker
under its own persisted ledger key. One reusable native
NotificationPermissionTile for Settings, an isolated browser probe, and
focused tests. No shell/settings wiring.
Port the web markdown subset to a pure Dart parser and a native
Material/Cupertino block renderer, with a caller seam for assistant text
parts and safe http(s) link activation.
- parser: entities, paragraphs, H1-H6, fenced code, quotes, lists, tables,
rules, inline code/emphasis/links; entity overflow stays literal
- renderer: host text roles, inline/fenced code fills, table header fill,
heading level and list/columnHeader semantics, horizontal code/table
scrolling, native selection
- tests cover parser safety, both hosts, the seam and real taps
- probe plus note record the web evidence and remaining limits
Conflicts: app/lib/features/runs/ui/run_detail_actions.dart.
Keep main's recorded-artifacts action and the retry branch's spaced,
render-gated Wrap: Rename, Retry, Cancel, then Recorded artifacts.
Render Retry beside Rename on a stopped failed run under both native
hosts, send only {run_id, request_key} for resume and add
retry_mode=restart for a fresh start, and open the run the accepted
reply names. Keep hidden actions out of the Wrap so native 8/4 dp
spacing is not doubled, and use a literal 2^32 entropy bound because
dart2js evaluates 1 << 32 as 0.
Adds wiring, guard and layout tests, a browser-only key regression and
the retry probe; notes/R2c-wire.md records the checks and limits.
Port the browser's Needs-you list, dismissal bookkeeping and attention
transition ledger as widget-free Dart under lib/features/attention/domain/.
Includes the local-day window, export-wait exclusion, {runId}:{kind}
identities, sorted dismissal storage and focused regressions.
Persist the exact per-session draft, send one plain prompt with a stable operation/native identity, restore a refused draft without overwriting newer typing, track the reply's queued flag and stop through chat_interrupt. No UI, transport, server or platform change; the optimistic/rejection callbacks and loadDraft are the thread integration seam.
Main's Runs detail now requires the shared gateway, but three inherited
call sites (two Changes tests and the diff wiring probe) still constructed
it without one, and the Cupertino 2x detail test tapped Output before the
reveal scroll had been pumped. Pass the existing fake gateway at each call
site and settle after scrollUntilVisible. No production behaviour changes.
Validate the template source first, then submit the typed name create-only,
matching the browser's P5 flow and wording. Refusals keep the prompt and the
typed name; the accepted detail is reported once through the callback. The
labelled field, visible feedback and native Material/Cupertino controls are
covered by focused widget tests and a loopback browser probe.
Render one transcriptRows row with native controls: role-labelled user and
agent messages, verbatim user text, client and attachment names (own name,
URI basename, else file), ordered agent parts, and collapsed reasoning, tool
and unknown-part bodies using ExpansionTile or a Cupertino disclosure.
Blank known parts draw nothing so they no longer fall through to the
unknown-part disclosure; closed bodies build lazily. Adds focused widget
tests, the fixture probe pair and the C2 evidence note.
Build a save_schedule record from server schedule records with the web
editor's field messages. The draft preserves unknown record, input, rule
and run-option fields, keeps the exact revision, writes the operator's
workspace and sends no payload while any field is invalid.
Owns one open chat session: subscribes with chat_subscribe, reads the newest
history page, folds only this session's chat_event frames, pages older history
with the opaque cursor, and replaces the held turn on resync. Failures keep the
held transcript and surface an error; disposal only cancels the local stream.
Co-authored-by: C2 pipeline <noreply@pipeline.local>
Register the landed PipelinesScreen at /pipelines through AppSession, with
an honest first-connection gate, a native reconnect banner that retains the
open list and detail, and an in-place refresh on reconnect. Move the shared
connection chrome out of RunsDestination so both destinations use one
implementation and one wording.
Add destination, registration and reconnect coverage plus an isolated
loopback Chrome probe that drives the real runPipelinesApp() composition.
Expose the existing RunTitleAction from the real run detail under both native hosts and fold the server's accepted run_detail into the open detail and the matching list row through RunsController, mirroring the web applyRunTitle path. Adds focused wiring/controller tests, a real-composition browser probe and an evidence note. Mobile remains unverified.
Read-only Pipelines screen for the Flutter client:
- list_pipelines and list_runs with a last-run join, plus get_pipeline
with an explicit version (0 = latest); no mutation requests.
- Name, run-presence, last-run-status and schedule filters; six sort
orders; clear filters; truthful loading, empty and error states.
- Detail Summary, selectable Source and version history with selection
and return to latest.
- Sequenced list/detail requests so stale replies cannot replace a newer
selection or open a cleared one; refresh keeps the selected pipeline
and version.
- Material controls on Android/desktop and Cupertino on iOS; a
per-label segmented tab row at narrow widths and scaled text, with the
native control kept wherever an equal share fits.
- Fixture probe entry and Chrome scripts for the rendered evidence;
widget tests cover filters, sorting, formatting, sequencing, layout
and the tab row.
Graph rendering remains P2: the Graph tab states that it is pending and
exposes a host hook. PipelinesScreen is not yet registered in the shell.
Evidence and limits: app/notes/P1.md.
The fixture had no darkTheme, so its Material "dark" captures were the
default light theme. Supply the stock dark theme and themeMode.system, rerun
the probe in both schemes, and correct the note's test counts, capture names
and branch state.
Render recorded artifact groups for the active host, with visit-scoped
selection and an explicit selection callback. Material uses ListTile,
Cupertino uses inset grouped sections with separate heading semantics.
Recorded names, MIME and size are shown verbatim with honest fallbacks;
nothing is resolved, fetched, previewed, downloaded or fabricated.
Adds widget, host and semantics regressions plus an isolated browser probe.
One content-sized stage node as an ordinary native control. Material uses
stock Card.outlined/Card.filled inside an InkWell; Cupertino uses
CupertinoButton.tinted/filled. onSelected reports the definition key
verbatim, one merged button semantics node carries the exact label and
selected state, recorded status is shown only when the caller supplies it,
and invisible U+200B break opportunities reproduce the web's anywhere
wrapping. Painted-boundary and painted-surface tests cover the UI-review
2x outline and Cupertino container defects.
Paint the landed orthogonal EdgeRoutes on a caller-sized canvas: one polyline
per route, a filled arrow at the target port in the route's real arrival
direction, clipping, and value-based repaint. The layer is pointer transparent
so node widgets below it keep their gestures. Includes focused geometry,
painter and hit-test regressions, an isolated web probe with rendered evidence,
and a note recording the slice and its limits.
Split the 406-line chat session browser into a controller, body, shared
adaptive primitives and separate standard Material and Cupertino lists and
dialogs. Preserve the existing server directory/backend catalogs,
instructions field, closed/starred grouping, directory headings and
empty/no-match states.
- keep refresh generations so stale replies are discarded
- open a created chat immediately and refresh the list in the background
- disable rename Save while the trimmed name is blank
- label row actions per session, with the id on duplicate titles
- wrap Cupertino empty/no-match/error messages instead of clipping, and
give them a Cupertino text style under a bare MaterialApp
- allow the Material rename helper to wrap at large text scales
- cover both native branches, lifecycle ordering, create/rename/close/star
and the Cupertino theme path with widget tests
Add the Settings destination under lib/features/settings with an editable
websocket endpoint, truthful connection states, one ping per connect/mount,
workspace validation and persistence under new feature-owned keys. Material
and Cupertino controls, wrapping copy at large text, pending ping state, and
isolated probe tools plus widget/unit coverage.
Pure Dart A1a artifact domain slice mirroring web/src/artifacts.js and
artifactNavigation.js: record parsing, capture facts, stage/visit grouping,
public attribution, kind vocabulary, summaries, viewer paging and safe
artifact url resolution. Tests mirror the domain directory; nothing is
wired into a screen or transport.
Pure-Dart P2c slice: interval-aware ports and corridors, label-aware lane spacing, measured label placement with fallback shelf, skipped diagnostics and routing bounds. 20 focused tests plus existing suite and web build pass.
Pure request/parse/row logic in lib/features/search/domain, a
gateway-backed repository, and Material plus Cupertino bodies.
The header and rows share one scroll view, and the server's
truncation, scan and cap facts stay visible even when a bounded
scan returns no matches.
Tests cover the exact search envelope, token parsing, stale replies,
retry, truncation bounds and platform layouts. A Web-only fixture
and CDP probe support rendered verification; the screen is not yet
registered in the shell.
Pure-Dart SCC ranking and column placement over the landed graph
identities. Every extent and gap is caller supplied; missing
measurements are rejected rather than defaulted.
Focused tests cover linear, diamond, cycle, self-loop, disconnected,
terminal, expanded-text and invalid-input cases.
Keep main's landed retry action and saved-schedules slices alongside the
templates data slice. Resolve app/.gitignore by keeping the single
test/**/data/ negation both sides added, with the explanatory comment.
Checks after merge: dart format clean, flutter analyze clean, 111 tests pass,
flutter build web succeeds.
Pure-Dart graph foundation mirroring the current web client:
terminal targets and labels, definition edges and nodes with web
outcome ordering, recorded run evidence (visited stages, taken
routes, current stage and live start), and sequence-ordered stage
visit selection with clamping.
No layout, widgets, screens or coordinates; fixtures cover linear,
diamond, self-loop, repeated visits, mixed outcomes, terminals and
missing/malformed evidence.
Add the nonvisual templates data/domain slice: TemplateRepository over the
shared ApiGateway for list_templates, validate and create-only submit, and
TemplateEntry preserving every server field in a deeply read-only raw map.
Re-include test/**/data/ in app/.gitignore so the mirroring tests are not
silently dropped from a fresh checkout.
Tests cover exact request shapes, source preservation, blank-name refusal,
malformed replies, server refusals and immutability.
Six computed Flutter runs stopped at the export handoff gate because the
rendered session.html cap was 2 MiB while their complete sessions (well inside
the 8 MiB source read bound) rendered between 2.25 and 4.28 MiB once html
escaping and the readable projection duplicated native text.
Raise SessionExportFileLimit to 8 MiB, the server's existing per-artifact file
bound, so a complete export is still listed and served. Normal export
verification, versioned repair and the handoff gate keep using the single
shared constant. The source read bound is unchanged, and an over-cap render is
still visibly truncated and recorded partial.
Add focused regressions for a complete export above the old cap, an over-new-cap
file rejected as partial, repair above the old cap leaving original evidence
untouched, the gate accepting the larger repair, and the constant staying inside
the artifact file bound. Update the artifact, handoff-gate and operations docs
and record the diagnosis in docs/notes/session-export-render-cap.md.
Port the web client's list/save/delete schedule request shapes and reply checks, with a typed record that preserves the whole server payload including unknown fields. Revision stays the CAS token; server refusals propagate unchanged.
Native Material/Cupertino prompt seeded from the run's stored title. Only
Save sends set_run_title {run_id, title} with the text untrimmed; typing and
Cancel send nothing, refusals stay verbatim with the draft kept, and only the
accepted run_detail is delivered once.
Port the browser's canCancel rule and cancel_run request into a native
Material/Cupertino confirmation. Opening the prompt or choosing Keep sends
nothing; a refusal stays visible with the server's words and the run is
re-read so the owner always receives server truth. Includes eligibility,
double-submit, disposal and narrow 2x-text tests plus R2b evidence.
Adds HumanDecisionAction plus its native prompt, wording constants and
tests. The action renders only while pendingDecision() reports a genuine
human wait, sends decide_run only after an option is chosen and Confirm
pressed, sends the pending stage/trimmed option/optional feedback, blocks
double submits, shows server refusals verbatim with the draft intact, and
re-reads the run so the owner always receives server truth.
Read a bounded newest-first page of eight assistants (4 MiB, no cursor traversal), selecting context and completed generation rate independently from the latest valid measurement matching Session.Info.model provider/id. Require assistant model identity; never pair an old model's measurements with the selected model's window. Context remains unknown across a newer compaction until a subsequent prompt reports usage; the last completed matching rate may survive compaction.
Unknown model metadata is cached for 15 seconds instead of five minutes, while known capacities retain their five-minute cache. Provenance remains canonical V2 Model.Ref, TokenUsage and request-created/streamed/completed fields cited in chat_usage.go. No live endpoint access, inference or service changes.
Isolated HTTP regressions cover in-flight/null/empty newest tokens with prior known metrics, post-compaction boundaries, independent prompt/rate selection, switched/missing model identity, duplicate known-zero measurements, over-limit page rejection and metadata recovery. Checked full internal/opencode suite, focused usage race suite, go vet ./internal/opencode and git diff --check.
Read V2 session accounting, latest assistant prompt/cache components and native request-to-stream boundary. Resolve capacity by location/provider/catalog id with bounded metadata caching. Coalesce active/final readbacks; retain message-less session snapshots without changing admission or compaction state.
Provenance: https://opencode.ai/v2/openapi.json and anomalyco/opencode V2 4617210822bdbb31e5749751afbfb4584ccedac8: packages/schema/src/token-usage.ts, session-event.ts; packages/core/src/session/usage.ts, projector.ts, message-updater.ts, runner/step.ts. Native output is visible output, reasoning separate. Session totals include all five non-overlapping components. Generation rate uses created-to-streamed, not tool-inclusive completion.
Limitations: metrics remain unknown for missing components, absent timing/model metadata, reads beyond bounded latest-message/catalog budgets, or context preceding compaction. No local pricing, token estimation or default capacity. V1 gets no invented cumulative metrics; older V2 events remain available when readback is unavailable. No deployment or protocol/web/docs changes.
Checks: go test ./...; focused usage/stream race tests; go vet ./internal/opencode ./internal/server; go build ./...; git diff --check.
Verify typed ThreadTokenUsage/TokenUsageBreakdown/Thread/Turn against openai/codex@6fb1c3903d. Use native totalTokens and latest-call context tokens without re-adding cached/reasoning subsets. Replay bounded per-connection snapshots and clear on room/source release.
Cost stays unavailable: no subscription USD usage is reported by this notification. Throughput stays unavailable even with native Turn.durationMs because neither last-call nor cumulative-session output is a compatible turn-specific numerator. Thread readback exposes no token usage; no extra reads, resume, or live provider calls added.
Checks: go test -race ./internal/codex; go vet ./internal/codex; go test ./internal/server ./internal/protocol; git diff --check.
Read OpenCode V2's resolved default Model.Info through its authenticated CLI API from HOME when saved profile fields are missing. Preserve valid saved models, explicit --model and unrelated settings. Record the selected stage model in the native server environment so web starters have an actual default.
Run the existing read-only model picker inside ./install when a terminal needs a choice; fail noninteractive or cancelled/incomplete setup before claiming ready or starting services. Do not parse JSONC, open login flows, create sessions or run inference. Document the one-step configuration path.
Checks: 61 mocked native installer/lifecycle tests, 8 entrypoint tests, sh -n install install.sh, git diff --check. API/schema checked against official OpenCode V2 documentation. No operator CLI/service/model calls, live install, restart, deployment or native Linux verification.
Select native installs only via explicit PIPELINES_PREFIX or the matching owned prefix/bin/pipelines executable. Route enable/status/disable to the existing native supervisor; validate registration ownership, label and command, keep preview read-only, and disable login registration before stopping. Never fall back to a standalone service for an invalid explicit prefix.
Fresh native installs explicitly enable authoring, while reinstalls preserve false or missing legacy role settings. Add explicit --allow-authoring/--no-authoring overrides and pass the server flag only for manifest true. Print a copyable native enable command and update installation help/docs. No Docker configuration changes.
Checks: 54 mocked native installer/lifecycle tests; 8 entrypoint tests; offline Go installation/CLI tests and vet; gofmt clean; shell syntax and diff checks. No live install, restart, deployment, permission/config changes, or native Linux verification.
Register the existing native supervisor with launchd/systemd, include the dependency-free authenticated web proxy, detect Node, and keep the API loopback by default. Preserve existing web credentials and configured host harness defaults. Clarify single-step setup, lifecycle selection, and optional ntfy limits.
Checks: 44 mocked native installer/lifecycle tests; 8 entrypoint tests; 42 Docker installer tests; GOPROXY=off GOTOOLCHAIN=local go test ./internal/installation ./cmd/pipelines; sh -n install install.sh; git diff --check. No live install, deployment, restart, downloads, real autostart/login verification or native Linux verification.
A stage's final session write can land just after the step settles. Retry the
read-only native export once after 200 ms when its envelope is invalid or names
another session, so the stage records session.html instead of dropping evidence.
Fall back to Homebrew and local install locations when opencode is not on the
service's minimal PATH, so a launchd/systemd restart cannot fail a run with
exec: opencode not found.
Graph and Source return before the detail footer, so their Run click set the
dialog state but never appended the overlay. Append the overlay before the tab
branches.
The Runs view is created before the attention view is destructured, so its
toolbar callback was undefined and selecting Runs threw before rendering. Attach
the function after destructuring.
Show the current model under the chat title with an OpenCode-backed picker,
put an agent mark on the right of every chat row, simplify the tool summary to
'N tools', and give the reasoning and tool controls one symmetric hover box.
New chats preload an editable behavior brief, and the activity spinner remains
the turn's single live progress indicator.
Expose the OpenCode model list and session model switch over the chat protocol,
carry a per-session model provider on chat rows, and apply a preloaded behavior
brief as a durable session instruction entry when a chat is created.
Use ~ for the server home prefix in directory bands and row meta, with the
full path still in the band's tooltip. Keeps long repository paths readable
inside the centred collapsible header.
Replace the reasoning, tool and bottom thinking rows with one stable activity
line and refresh Stop on the step frame. Make directory and Closed bands share
an elevated square surface, centred text and a collapse toggle. Read pasted
files into the composer attachment path and show sent files in user bubbles.
Carry browser files as base64 prompt attachments, write them to private
temporary files and pass file:// references to OpenCode, and map the user
turn's top-level files back into history. Replay a running step on subscribe,
forward only a caller-supplied msg_ id, and persist cancel on the run and live
step before interrupting the runner.
Remove authoring from the skill description and move the authoring commands
and examples behind an explicit-request section in help. A skill test keeps the
default description from advertising authoring again.
Use existing pipelines for run requests and put task specifics in the run
prompt. Creation, edits and publication now require an explicit user request;
the authoring skill test enforces that guidance.
Add the Run pipeline dialog with prompt, server directory and a per-run
notification choice; add --notify auto/on/off to run and retry; move the live
tool call onto the tool-count line and tick the reasoning duration; stop chat
frames from repainting a different screen.
Store a chat's harness with its operator session, expose chat_backends and a
backend choice in New chat, and route each session through a manager. The Codex
adapter uses the App Server's Unix WebSocket for threads, turns, history,
questions and interrupt; OpenCode remains the default and Claude is not
advertised until its sidecar and login are wired.
Wrap each table in its own scroll frame and let the markdown grid shrink, so a
wide table scrolls sideways instead of pushing the chat content past its div.
Every detail screen now owns one 44px chevron Back control beside its title.
Sending appends the user's message immediately and keeps Send available beside
Stop so a follow-up can be queued. Reasoning renders above the answer bubble
rather than inside it.
Raise phone body/meta type, controls and dock targets to 44/56px, make the chat
back arrow a visible 44px control, and give the star/menu 44px hit areas without
covering the chat status. Keep the shipped skill free of personal device and
project capture paths.
Enter inserts a newline and Ctrl/Cmd+Enter sends; slash commands still run on
Enter. Chat renames are stored in the server registry so every device sees the
same title, with a one-time upload of old local titles. The star no longer
covers the row status, and shell frames patch the background bar in place so the
composer stays mounted while streaming.
Preserve scroll intent for touch scrolling, coalesce live frames into one paint,
keep stable dialogs mounted across re-renders, and add a Settings refresh that
pings the server for a fresh build/time card.
Keep caret focus, value and selection across live-frame re-renders, and show a
single in-place running-tool line so tool calls no longer grow and shrink the
transcript for every call. Right-align the pipeline-list miniature.
Opening a chat now pushes /chat/:id, so Android/browser Back returns to the
chat list rather than the previous destination. The conversation header owns a
compact Back to chats control matching the create pane, replacing the
full-width Back to list row on phones.
- Persist chat stars in the operator-session registry (chat_star) so every
browser/device shows the same Starred group; migrate old local stars once.
- Add a compact pipeline graph shape to list responses and draw a lightweight
list miniature; replace the cryptic id/version line with the stage count.
- Surface OpenCode form questions as a chat card (chat_answer), replay a
pending form to late subscribers, and notify for background questions.
- Make the mobile dock's Search cell equal to every destination, keep the
tab row visible with 100svh, and let Source use the full pane height.
- Let a fresh sign-in auto-connect to its own origin; use a Lax session cookie
with Expires so Remember me survives app/link launches.
- Keep shipped starters and the skill agnostic: no repository paths, project
areas or personal device commands; add Diagnose/Fix and Research starters.
- Refresh the installed skill and document the new browser conventions.
Checked (the default) issues a 30-day persistent cookie; unchecked keeps a
browser-session cookie and a 12-hour token. The sign-in card also links the
public favicon/apple icon and uses the app mark.
- serve.mjs requires a signed session cookie for every page, artifact and the
WebSocket, with a password file, 30-day sessions, login throttling and public
brand assets for the sign-in page.
- The diff viewer is a fixed-height top-anchored panel whose toolbar (modes,
copy, previous, next, close as icons) is its first row; the artifact viewer is
likewise a fixed frame so its navigation never moves.
- The audit's selected tab uses the app's normal selected surface and bottom
accent. Sessions that were not recorded say so plainly.
- Chat code blocks are syntax-coloured; graph pinch-zoom works with two fingers
while a single pointer still pans and clicks nodes.
- Phones always keep the destination bar (pane collapse is wide-only), with the
destinations spread evenly and Search on the right; the list default width is
narrower; the theme colour matches the app.
- Code-format and layout tests, plus the full browser suite, pass.
- Panes fade in on a destination/tab/selection change only; list rows FLIP when
they move (sort, star, filter) and fade in when they appear; removals close the
gap through the same move. Reduced-motion users get none of it.
- Modal panels (audit, viewers, diff, tool calls, confirmations) arrive with a
short scale/fade.
- A collapsed list hides its filter/sort toolbars; the Refresh tooltip is stamped
as soon as a populated list first paints.
- The smoke settles after a sort before measuring a row for a click.
- Run and pipeline rows use one coloured status glyph with the word in its
tooltip; the run version sits at the right of the title line; the usage
metrics row is gone.
- Settings is an icon beside the connection status (rail and dock), not a
destination tab; the destinations keep a roving tab even while Settings is
open.
- The rail and every list pane collapse to a narrow strip from an icon at their
top-right (remembered per device). A collapsed runs list shows the status
glyph, pipelines their flow glyph, chats their status word.
- Tool calls open in a modal (rendered/expanded rows in place) instead of an
inline popover; the chip stays a quiet line beside the message.
- Refresh tooltips show the last data arrival (manual or socket) per
destination.
Replace the yellow emoji in the Runs heading with a 20px inline-SVG outline
bell that inherits currentColor. The badge, count model, accessible name,
click behaviour, in-place refresh and Escape focus return are unchanged.
Cover the glyph in ui-smoke: tag/viewBox/paths, 20px size, no emoji or glyph
class, badge text/count/label, badge position:absolute with a no-shift rect
measurement at 1440x900 and 420x900, glyph survival across a count change,
and the zero state at both widths. R15 records the new captures.
- The diff viewer is a centered panel over a dim scrim (clicking outside closes),
and the browser Back button closes the open viewer/audit/artifact viewer via a
modal history entry. Transient sheets opt out (they must never undo an
in-app navigation on close).
- The page is installable: web app manifest, 192/512/maskable icons, apple
meta, and a shell service worker that never caches the socket or artifacts.
- Chat: operator bubbles are accent-tinted, agent bubbles neutral with an accent
edge; the tool summary is a quiet line outside the message; the star and more
controls are compact 20px corner icons inside the row.
- The Refresh button's tooltip shows the last data arrival (manual or socket),
per destination.
- The audit Input/Output/Memory tabs fetch the actual input.md/output.md/
memory.md, so the outcome section is visible and each document has a
Rendered/Raw switch plus an Open raw file link. The Session tab renders the
exported HTML in place with the same link.
- The audit's selected tab uses the normal selected surface, not the accent tint.
- The run Summary no longer carries an Audit & debug section; the stage pane's
Audit & debug button is the one door.
- Search results all lead with one 56px tile: image thumbnails, artifact type
tiles, or a kind glyph (pipeline/version/run/step/field); no text kind labels.
- Chat star and more sit on the row's top-right and bottom-right corners, revealed
on hover/focus, and the row menu opens below them without losing clicks.
- The chat spinner starts at the wall-clock animation phase, so frequent
streaming re-renders no longer snap it back to the animation start.
- Turn files (input/memory/output/session) are system artifacts now: they are
never tiles in the run or stage galleries. Shared public files are attributed
to the visit that first recorded them, so a run counts 3 stage artifacts, not
one copy of each per later stage.
- Audit & debug opens a dialog with vertical Input / Output / Memory / Session /
Definition tabs, for a visit from the stage pane or the run Summary.
- Run tabs are Summary / Graph / Timeline; Input and Output are Summary sections
with Artifacts, Files changed and Audit. Each stage pane gains Files changed.
- Artifacts gain a gallery/list switch (remembered) and full-name wrapping; the
copy/share actions are hover-or-focus icon buttons.
- Status badge above the run title; no live badges on the run surfaces. The runs
list leads with the pipeline name and the stored task title beneath it.
- Chat rows: title + coloured status word only, then directory, then model; no
operator or closed chips, no dot. The more/star cluster is a hover/focus
overlay so the title uses the row's width, and an open menu stacks above rows.
Closed chats collapse behind a chevron. Sessions can be starred locally and
sort in a Starred group. The chat header no longer repeats status/dir/model.
- A visible rail divider separates Search from the destinations; the page has a
real favicon/apple-touch icon and the rail brand wears it.
- Smoke updated: no live badges, 3 detail tabs, field hits open Summary sections,
closed chats expand for checks, the fixture viewer uses shot.png/missing.txt
and the audit for markdown.
Every streamed delta re-rendered the conversation and restarted the indicator's
one-second ticker, so a busy turn cleared the timer before it fired and the chat
sat at "Thinking… · 0s" for the whole turn. The ticker is now kept while a turn
is in flight; a simulated silent turn ticks 0s→4s and clears on step end.
The one-line verdict summariser expects the old field map; given a turn's single
markdown body it treated the result as untrusted reference material and produced
a rationale unrelated to the work ("The text was treated as untrusted..."). Turn
outputs now keep the honest absent-reason state: the card still shows the option,
and no model call is spent inventing a reason.
Turn bodies were embedded verbatim, so a body's own ## headings looked like
sibling turns and could even duplicate the system's "Files added to public/"
line. Body headings are now demoted two levels (capped at H6) outside fences;
fenced code is untouched.
A probe stage read "public/" in its task, created a workspace-relative public/
folder, and also copied to the run's shared path. The prompt now states that the
absolute path is the shared folder and a relative public/ is a different,
unshared directory.
The stage pane stringified the step's single-key {markdown} map, so a turn's
output appeared under a literal "markdown:" line inside a code card. The pane now
shows that body as the document it is, with "(no output)" for an empty turn; an
ordinary value map still shows its keys.
ParseOutput returned only the text after the outcome value, so a stage that wrote
its result first and "# outcome" last handed the next stage "(no output)" — the
probe's Compose and Critique turns were both lost this way. The body is now the
whole document with just the outcome heading and value line removed, in order,
byte for byte. Tests cover a trailing and a mid-document outcome.
The indicator called a silent turn "Waiting…" after 2.5s without a delta, so a
model reasoning for a minute looked idle. A running turn is now thinking for as
long as it is silent; Waiting… is reserved for a prompt queued behind the turn in
flight.
The section strip moved to the detail's top on wide screens, but arrow-key
selection still focused the hidden rail copy, dropping focus to the body; it now
focuses whichever mount is visible. The browser suite no longer assumes the old
curated run fixtures (runs 428/430/438/440/442/449/450), discovers a failed run
and the pipeline's own stage key, and skips the removed fixture groups with a
clear note instead of timing out. The live chat transcript's inline-code check is
advisory, like its table check.
A markdown/text artifact hit now opens the artifact viewer (with its Open run
action) instead of a raw browser tab, and the run Summary's Pipeline row shows
the pipeline's name beside its id and version, all in the link to the definition.
A turn run carries one markdown body. The Output tab now renders that body
directly instead of hiding it behind a collapsed field named "markdown"; legacy
field maps keep their collapsible sections.
- The run Summary's Pipeline value is a button that opens that pipeline version.
- The artifact viewer carries an Open run button (the search viewer passes the
artifact's run id), so the evidence always leads back to the run.
- Search artifact rows show the image itself as a thumbnail; other artifacts get
a type tile (MD/TXT/JSON/CSV/GO/PDF/...), and every artifact row offers an
Open run action next to its own navigation.
Settings drew a sun because the sprite was a circle with rays; it is a cog now.
Search is a modal, so it leads the rail (and the narrow dock) instead of sitting
under the destinations, which leaves Settings last. The section strip reads as a
tab bar: flush cells on a bar, the selected tab filled with the panel surface and
underlined, no chip borders.
The successful retry in TestDefaultRetriesAndTimeoutResetEachAttempt was
racing its own 20ms deadline when the full suite ran in parallel. Keep the
two-attempt behavior and give the retry realistic headroom.
Each model visit now gets <run>/stages/<seq>-<stage>/ with input.md,
memory.md, output.md, private/ and a shared run-level public/. The model
reads the two input files, follows the stage's instructions verbatim and
returns complete markdown; only the # outcome section is parsed.
- add internal/turn layout, render and output parsing
- write input.md/memory.md before a visit and output.md from the final
message; inventory all turn files as stage artifacts
- accumulate completed turns and system-written public file additions in
memory, including across retries and resume
- remove the JSON envelope, strict field validation, line format and the
repair ladder for model stages
- republish pipeline authoring prompts and docs in the new style
Checks: go build ./..., go vet ./..., go test -count=1 ./..., gofmt -l .
Drop the resource allocation feature end to end: store tables and migration, runner scheduling and cleanup, protocol types and commands, CLI commands, TUI screens, tests and docs. Existing databases open cleanly and definitions carrying a retired resources block still validate.
- Gaps between stages are sized from the widest straight-route label, so a chip
never reaches into either box; a source's forward routes fan across its side
instead of sharing a 20px band.
- A label prefers the widest horizontal run that can hold it; when only a stub
exists the chip moves onto the edge's longest run and sits beside a vertical
one, keeping clear of both the box and the neighbouring label.
- Hovering a wire or its chip highlights the route and dims the rest.
- System-added routes (the parser's implicit error fallback) draw dotted with a
legend entry, distinct from declared routes and executed state.
- Lanes are 34px apart, so a dense definition no longer doubles the canvas height.
- The graph opens expanded by default and remembers a collapse (graphPrefs.js).
The section list lived in the destination rail, next to Pipelines/Runs/Chat, which
read as navigation rather than as the current detail's view. On a wide screen the
sections are now a tab row at the top of the detail pane and the rail keeps only
destinations; narrow keeps the thumb-zone strip at the bottom.
Every stage declares error/blocked/retry outcomes, so a run graph labelled all of
them and the chips buried the nodes. In run mode only routes that actually
happened are labelled; a pipeline definition (no run state) still labels every
route.
The turn protocol writes a markdown body; the run detail now renders a field as
markdown when it has markdown structure (heading, fence, list, table) and keeps
the honest monospace block for historical plain-text fields. Pure helper with
tests.
Palette: bg #0a0a0b, surfaces #121214/#17171a, elevated #1d1d21, neutral borders,
text #e8e8ea, muted #9a9aa2, restrained cool accent (#8fa8c8) — the green cast is
gone; the run-status palette is unchanged. Contrast is AA or better (text 16.2:1,
muted 7.1:1, border 4.3:1). Padding tightened across lists, headers, settings,
tabs, chat, stage panels and artifact tiles on the 8px grid; radii 10/8.
The suite's run-history sections assumed older failures/day groups that the
operator has since wiped; those checks now skip honestly when the fixture history
is not there.
The full-screen viewer now opens markdown/text artifacts (text/markdown,
text/plain, .md/.markdown/.txt) through the resolved artifact URL and renders
them with the page's own DOM markdown renderer, with an honest failure message
and an external fallback. ArrowLeft/ArrowRight page the shared media+document
list, and a backdrop click closes the viewer while panel clicks do not.
The run gallery and per-visit artifacts present input.md, memory.md and
output.md as ordinary Document tiles with a drawn glyph and open the viewer.
Adds isMarkdownArtifact/isViewerArtifact with unit coverage, deterministic
viewer fixtures, and ui-smoke assertions/captures for rendered markdown,
keyboard paging, the honest 404 and backdrop dismissal.
- the attention sheet is managed imperatively, so closing it now tells the
controller; without that it stayed on the stack and left the app root inert,
which silently swallowed every real click (found by the suite: the Settings
Templates card stopped working after the sheet had been used);
- the sheet returns focus to the bell after the repaint that replaces it;
- opening a chat row's menu at the bottom edge now scrolls the row into view, not
just flips the panel, so the items are actually reachable.
- Sticky sections: a run/pipeline/template keeps the section you chose when you
open another one, and the choice persists across reloads (localStorage per
destination). A stage deep link still opens the Graph.
- Search is a Spotlight: a modal overlay opened with Ctrl+/ (Cmd+/ too), arrow keys
move the selected result, Enter opens it, the query/kind/sort/selection resume on
the next open, and an artifact result opens the artifact itself (media in the
viewer, anything else in a tab) instead of the run's visit pane.
- Live sync: the server only emits a user frame for prompts sent through it, so a
message typed in the OpenCode UI appeared only after a refresh. When a frame for
an unknown turn arrives, the open conversation now reads the newest history once,
which brings the user message in live.
The layout smoke still asserted the guidance paragraph the operator asked to
remove; assert its absence and a graph viewport of at least half the window, and
keep the pipeline graph's own note check.
The a11y work made the chat row a container with its control inside, so Back
focused a non-focusable div and keyboard focus fell to the body. Focus the first
focusable descendant instead (generic for chat, runs, pipelines and templates).
Take main's newer smoke behaviour where they met: the binary capture is run 449
(opened through openRunDetail), and a running run must show no aggregate Changes
section. Keep the layout's shell-aware checks and its L2-L4 rows; L7 stays todo
with the view-level fixes recorded.
- the run Graph tab drops the guidance paragraph and the graph fills ~70vh;
- the Artifacts collapsible carries the visit's count in its title (the body keeps
the reason line only when there is nothing to show);
- the stage panel's section padding and gaps are reduced.
The layout item's work plus the two defects its review found:
- the wide grid sized the list track from its MAX, so at 600-759px the detail pane
was clipped to 40-199px; cap the list below 900px and narrow the rail there
(measured now: detail 232px at 600, 332 at 700, 340 at 900, 880 at 1440);
- the shell said 'Not connected' on a fresh page because the prefilled proxy URL
validated; the status now reflects a SAVED endpoint ('Not configured' until then)
and refreshes as the draft changes.
Includes the rail + bottom dock, connection moved into Settings, viewport-only
scrolling with panes that scroll themselves, tab semantics, skip link, h1 per
route, and the design tokens.
The merged main branch names the attention dismiss and chat actions
controls for their rows. Assert those prefixes instead of the old bare
words so the live smoke exercises the current labels.
Each visit's This run pane reports its own recorded capture: the File
changes status line (with skipped/omitted counts and diagnostic) and its
Changed files list with parseable stats. The Summary aggregate now keeps
each path's last recorded step rather than summing visits, and is only
rendered for a succeeded run; a failed run keeps its evidence in the
visit panes. This is a deliberate divergence from Android, noted in R4.
The page resolves artifact URLs against the configured server. In a proxied
deployment that is the page's own origin, and serve.mjs only proxied /connect, so
every artifact request 404'd: broken gallery thumbnails, a blank viewer and no
session.html. Forward GET/HEAD /artifacts/ to the same upstream and stream the
reply (status, headers, body). Verified: 10/10 thumbnails load on run 430 and the
viewer's image has naturalWidth > 0.
The previous section can leave the operator's thread marked running from a
replayed frame; C8 tests the composer's default state, so it settles once through
the page's own fold instead of asserting against leftover state. Found by the
post-split gate (the split itself was correct: a fresh open shows Send, no Stop).
Role-named tokens (colour, 8px spacing, radii, type scale, elevation, focus,
state tints, motion) with a styleguide built from the app's real components and a
short application guide, including what to remove from the current CSS.
Pure move, behaviour unchanged: app.js is now the shell (boot, state, client wiring, connection/banner, navigation and routes, render dispatch, header). Views live under src/views with shared DOM and format helpers. client.js stays DOM-free; no circular imports; every server-derived string still uses textContent.
Pure move, behaviour unchanged: every rule is carried verbatim into one of base, lists, run-detail, chat, graph, dialogs or settings, linked in a fixed order from index.html. No @import and no build step.
The layout prototype shows the operator's target shell: a left destination rail
(Pipelines/Runs/Chat/Settings) with the detail sections grouped in the rail, list
and detail panes, a status dot in the rail footer and no top connection chrome.
The spec's DOM sketch still mentions the old connection banner; the implementation
brief supersedes that (connection lives in Settings only).
The audit records 9 must-fix, 12 should-fix and 15 notes from real DOM and
accessibility-tree inspection, with file:line for each finding.
Add an opt-in --decide smoke mode that reuses or submits a human-only pipeline, starts two runs in throwaway workspaces, and presses the real card, sheet and Confirm for the feedback and no-feedback shapes. Record R11 as done with the live captures.
The created chat loads its history asynchronously; reading the DOM once raced the
load (worse when the OpenCode endpoint is busy), reporting a permanent 'Loading
conversation...' that the app never showed.
--compare BEFORE AFTER fails when a capture is missing or unexpected and lists
pixel drift for manual review; live durations make byte equality the wrong gate.
Describes what the client is, how to run and test it (OS-assigned smoke port,
gitignored captures), the module areas, and keeps the 403/proxy explanation that
justifies serving the page from serve.mjs.
Integration fixes found by the full suite:
- drop the dead 1 Hz run poll helpers still referencing R10-removed state (they
threw on every route apply, so the first connection never rendered a list);
- keep this tab's ephemeral verification chats across a reload (sessionStorage),
so a chat the server intentionally hides stays usable in the tab that made it;
- the smoke marks only the throwaway ephemeral, clears the marker after /new, and
tolerates a stale page banner plus a re-rendered row menu;
- the nav no longer claims a false Pipelines (0) before that list has loaded, and
the Runs destination preloads it once per connection.
Full suite: 580 unit tests green, UI SMOKE PASS.
Reconcile L6 with R10's live-run watch: onConnected waits for the connection's
watch on the first connect too, and the reconnect path uses R10's
loadCurrentView(runsFresh) call while keeping L6's detail re-hydration. The
selectRun catch keeps L6's stale-selection and server-refusal guards.
Fixes found by running the full suite after merging main, not by the route
model itself:
- start the run-alert watch on the FIRST connection too: L6's early return for a
pending deep link skipped it, so no subscribe was sent (R10 broke silently);
- an ephemeral /new chat no longer refreshes the session list (the server
intentionally omits it), which had replaced the open conversation and dropped
its local notice;
- the chat row menu flips above the row when it would fall off the window, so the
last rows' items are hit-testable (a real defect, not clipping);
- smoke robustness for drifted live data: the C2 closed-row assertion opens C13's
menu, the C13 hide step opens a conversation when none is left open, the
timeline empty-state capture is skipped when no empty run exists, and the last
row is scrolled into view.
Full suite: 551 unit tests green, UI SMOKE PASS.
Resolve the L6 routes against the newer C2/C13/L5/R10 shell: keep both sides
(single client imports, the run-alert watch inside the reconnect path, the boot
route + popstate wiring alongside loadNotifyAsked, main's L5 row and L6 done).
Resolve the C11/C12 vs C13 overlap in the chat work:
- PARITY: keep main's done C11/C12 rows and this branch's done C13 row.
- app.js/chat tests: keep both import/helper sets (notices and overrides/seen).
- ui-smoke: keep main's C11 background-task bar, C12 notice checks and the
shared composer throwaway, and C13's row-menu rename/hide/seen checks.
The composer throwaway stays a listed server session: C12 switches away
and back to it and C13 reads its row, which an ephemeral create (2fe6301)
deliberately hides from chat_sessions. The live-run graph halo check is
best effort as its own comment says, so a run with no stage in flight at
capture time skips instead of failing the whole smoke.
Every run defaulted to 8091, so two parallel pipeline items running the UI
check collided with EADDRINUSE. An explicit --port/WEB_UI_PORT still wins;
otherwise the OS assigns a free port. Verified with two simultaneous --scratch
runs (60540/60541), both PASS.
The operator's chat list showed ~99 stray "New chat" entries. The listing
was already fail-closed (registry-only); the fault was what got recorded: an
automated UI check drives the real page, so its throwaway chat was recorded as
an operator chat exactly like a manually created one and stayed in the list for
ever (each run added one).
Server: chat_create takes an optional ephemeral flag. The session is created,
bootstrapped, usable, closable and reopenable exactly like any other, but its
registry row is hidden, so chat_sessions never lists it. operator_sessions gains
an ephemeral column (idempotent migration, existing rows default to listed) and
the list query filters it; the single-row lookup does not, so close/reopen keep
working. RecordVerificationSession is the hidden recorder.
Web: the page marks a create ephemeral only when automation asks for it
(__pipelinesEphemeralChat, set by the UI smoke for its throwaway chat), so the
smoke's own runs stop polluting while a manual create is unchanged.
Tests: a hidden row is never listed yet is still looked up and closable; a
normal re-record of the same id lists it again; a pre-ephemeral database
migrates with every existing chat still listed. Live data pruned separately
(107 -> 8 registry rows, backed up).
The discovery loop already opened the session it found, and openChatSession
keeps a loaded thread, so the assertion's second click early-returned and sent
nothing once the live server listed an empty session first.
Completes the item: the Settings view, its pure helpers and the client's
socket-replacement path, plus the fix the review required (a header-side URL
correction clears the Settings field's own error) and a smoke check for it.
Resolve C10 vs C11 in the shared shell:
- keep both send hooks in the smoke's WebSocket shim (recording +
scripted replies + synthetic approval acknowledgement) instead of the
second assignment overwriting the first;
- close the .chat-approval CSS rule so the C11 background-task rules are
not swallowed by it (the list lost its 3-row cap and scrolling);
- assert the folding invariant directly (no adjacent agent bubbles)
instead of 'agent bubbles <= user prompts', which the growing operator
session now legitimately breaks;
- exercise the resource clamp by scroll overflow instead of a clone
measurement that the clamped frame makes unreliable.
Completes the item the pipeline could not land: the C10 diff its own
implementer and probe assertions already verified is committed as-is.
The resource block is a padding-free six-line clamp inside a padded frame
(the app's maxLines = 6 + ellipsis) and the primary control is filled.
Add the background-tasks bar to an open conversation: heading
"Background tasks" plus "{n} running", shown only while at least one
shell is running. Rows are capped at 3 (BACKGROUND_TASK_VISIBLE_ROWS)
and the list scrolls beyond; each row is a play glyph, "Running", a
one-line shellCommandSummary and "Details" while selected. Tapping a
row toggles its detail pane ("Command"/"Task identity"/"Status:
running" plus the bounded output: spinner, error + "Retry",
"Output unavailable for this task.", "No output yet.", or the
monospace output and "Output is bounded to 64 KiB." with "Refresh").
Fold shell frames without ever marking the turn running, merge a blank
command from the previous frame, list only running shells (an exited
shell is never a task) and drop/relearn shells on reconnect via
chat_shells. Refresh always rereads the bounded 64 KiB page from cursor
0. Update PARITY.md C11 with its captures and the replayed-vs-real note.
Checks: node --check on every touched file; cd web && node --test test/
(456 pass).
The merge put main's C5 live-stream section after the C8/C9 composer section,
but the composer section closes its throwaway session and returns to the list,
so no conversation was open for C5 to observe. The C5 section now re-opens the
operator's own session (read-only: real subscribe + history, synthetic frames
injected into the page's socket handler) and waits for its newest history page
to render before replaying, so the history load cannot replace the replayed
turn. `node test/ui-smoke.mjs` is green end to end against
ws://127.0.0.1:8080/connect.
Address the review of C8/C9: the composer's Stop control now routes to
`chat_interrupt` (`onStop`) instead of the inert submit path, and the smoke
clicks it and asserts the page's own "Stopping the running turn…" notice with
no `Action failed` dialog (captures/63b). Accepting `/close` finishes the
session locally — the running/queued bits clear and the conversation leaves
the pane for the list, mirroring Android's `finishSession` — and the smoke
asserts the select hint returns. A command notice draws the one terminal
glyph (`CHAT_COMMAND_GLYPH`, `>_`) for both states, tinted only; the growing
textarea accounts for its padding and border so six rows are six whole lines;
remove a shadowed duplicate `chatSessionById`. Wording unchanged; every pure
helper and the wire shapes remain unit-tested.
The smoke creates a throwaway session via `/new`, really prompts, really
interrupts and closes it; the operator's session is never prompted.
Add the composer at the foot of an open conversation: a growing 1–6-row
textarea (Enter sends, Shift+Enter newline), an Attach file control with
removable attachment chips (25 MiB limit, failed attachments block sending),
one send/stop control that turns to Stop while a turn runs, and the queued
notice cleared on any incoming frame. Add the five slash commands with the
palette, the pure chatCommand* helpers and the command notices. The prompt
carries native_message_id so OpenCode accepts it, and a rejected prompt
restores the draft and attachments with the server's message. Drafts persist
per chat in memory and localStorage; attachments stay memory-only.
Tests cover every pure helper and the exact chat_prompt/chat_interrupt/
chat_create wire shapes; ui-smoke captures the composer, palette, a failed
command notice, the attachment chips and the Stop control (a real prompt to a
throwaway session that is closed in cleanup).
A template detail now offers "Create pipeline from this template". Its
dialog ("Create from {name}", one required field "New pipeline name
(required)", the note that it creates a draft and does not run, Create /
Cancel with Cancel reading Close after a success) validates the
template's source first and, only when it parses, submits it create-only
with the trimmed name. Create is disabled while the name is blank or
while sending; the field locks while sending and after a success. A
refusal shows the server's own error in the still-open dialog; a success
shows `Created "{name}". It is in the Pipelines list.` and refreshes
list_pipelines so the new row is visible.
Pure helpers + both request shapes are unit-tested; the flow is captured
against a scratch server with its own throwaway database. The live
server's pipeline list is never touched: the default ui-smoke run sends
no submit and create runs only under its --scratch flag. Wording matches
android/.../TemplateDetailScreen.kt and PipelinesRepository.kt.
Both web-attention and web-chat declared 'const cleared' in the top-level
module scope of test/ui-smoke.mjs; the auto-merge kept both, which is a
SyntaxError. Rename the chat one to 'clearedQuery'.
Browser Chat destination for parity with the Android app:
- session list grouped by directory (closed grouped under "Closed"), kind
chip, activity badge, work-label meta line, "Search chats" filter (C1)
- open/close/reopen with the Android copy verbatim (C3)
- conversation history paging via the opaque next_cursor (C4)
- markdown subset renderer + code blocks (C7)
- scroll follow / "Jump to latest" / per-session saved position (C14)
Request builders in src/repository.js; pure merge/format/markdown/paging
logic in src/chat.js and src/markdown.js; view in app.js. Every server
string set with textContent, markdown built as DOM nodes.
Add the run-level operator actions to the browser run detail, matching the
Android client's wording and wire frames:
- R11 human decision: pure model in src/actions.js (pendingDecision,
lastWaitingStep, waitingPrompt/waitingOptions, humanOptions,
decisionTargetLabel, DecisionDraft) plus the decision card and sheet;
decide_run sends run_id, the chosen option and trimmed feedback.
- R12 cancel: a Cancel run action offered only while executing; the Android
confirm copy; cancel_run then a silent get_run refresh.
- R13 retry: offered only for a loaded, non-executing failed run; resume is
the default (no retry_mode, like Android) with a browser-only
Restart from start secondary that sends retry_mode:"restart".
- R14 rename: an inline set_run_title field; refreshes the run and its list row.
- One shared Action failed dialog for all of the above.
Add the protocol constants and typed builders, a hand-written dark-palette
section for the card/sheet/dialogs, focused unit tests for the helpers and
request shapes, and ui-smoke captures for the new states. Update PARITY.md:
R11 stays partial (no live waiting run), R12–R14 done with the stated
shown-not-executed and Android-divergence notes.
Also harden openRunDetail() in the UI smoke: the tabstrip already exists from
the previously opened run, so wait for the target run's identity line before
asserting on its actions (review finding).
Integrate main's run-detail Changes (R4) and Graph (R5) work with the
connection banner/reconnect/foreground-recovery/live-badge work (T3/T4/T5).
Conflicts resolved by keeping both independent additions:
- web/styles.css: the .conn-*/.live-* rules and the .change-*/.diff-* rules
are separate blocks; both retained under their own comment headers.
- web/test/ui-smoke.mjs: both capture sequences retained (T3/T4/T5 writes
28-connected-banner/29-disconnected-banner/30-reconnect-recovered; R4/R5
writes its own distinct 28-34 run-change captures), so no filename collides.
Checks after the merge: node --check on all touched JS/MJS; node --test test/
225 pass / 0 fail; node test/ui-smoke.mjs --out <worktree>/captures UI SMOKE
PASS against ws://127.0.0.1:8080/connect, including the connected banner +
build line + live badge, the disconnected retry banner, the online-event
recovery, and main's R4/R5 captures.
Resolve the web/PARITY.md conflict by keeping main's R3 (now listing the
Graph tab) and R5 rows alongside this branch's R4 row; R4's Changes viewer
merges cleanly into app.js, styles.css and ui-smoke.mjs.
Add a collapsed-by-default Changes section to the run Summary tab and a
full-screen diff viewer, ported from the Android RunChanges/ChangeDiffViewer
wording. Pure aggregation and unified-patch parsing live in src/changes.js;
app.js wires the section/viewer and sets every server string with textContent.
Unit tests cover the header variants, kind merge, stat sums and hunk parsing;
ui-smoke captures the collapsed/expanded section, rendered and raw viewer,
paging, Escape/backdrop close, binary, truncated and a running run's header.
Close T3, T4 and T5 of web/PARITY.md (the "Transport and connection"
table). T1/T2/T6 are untouched beyond wiring.
- src/connection.js (new): the pure, DOM/socket/timer-free helpers behind
every new state — `bannerState` (the persistent banner's copy and tone),
`stateBadge` (the compact header indicator, which is also where the retry
attempt is named), `foregroundAction` (the return-to-foreground policy
from ConnectionRecovery.kt), `protocolMismatch`, `serverBuildLabel` and
`liveBadgeState`. Wording and colour roles mirror ConnectionBanner.kt,
LiveBadge.kt/RunStream.kt and SettingsScreen.kt.
- src/app.js: wiring only. The banner sits in normal document flow under
the header (never overlaying content); a Reconnect control appears beside
the URL field whenever `bannerState` offers one and re-opens the same
validated endpoint through `client.connect`, resetting the backoff;
`visibilitychange`/`online` drive the foreground recovery; the ping reply
records the server build and protocol for the banner.
- src/protocol.js: `PROTOCOL_VERSION = 1`, citing internal/protocol/
identity.go and Message.kt.
- styles.css: the .conn-* banner and .live-badge rules in the app's dark
palette, on the existing :root variables.
- test/connection.test.mjs (new): 18 focused unit tests for the pure
helpers, including source-parity assertions against the Android files.
- test/ui-smoke.mjs: assert the connected banner + build line + live badge
and capture them, then point the page at a closed port to capture the
disconnected retry banner and recover via the browser's `online` event.
- PARITY.md: T3/T4/T5 done with their captures.
Checks: `node --check` on all five touched JS/MJS files; `node --test
test/` 190 pass / 0 fail (18 new); `node test/ui-smoke.mjs --out ...
/web/captures` UI SMOKE PASS against ws://127.0.0.1:8080/connect, writing
28-connected-banner.png, 29-disconnected-banner.png and
30-reconnect-recovered.png.
Add the run detail's Graph tab (between Summary and Input), reusing the
shared src/graph.js renderer (P6) rather than a second renderer. In run
mode a visited stage is executed (solid fill + border), an unvisited one
hollow with a dashed muted border; a terminal is executed only when a
visit resolved to it; a route is executed only when a recorded visit
produced that outcome (solid with an arrowhead, success first, error
last, others alphabetical, `error*` for the fallback). The Executed /
Not executed legend shows only for a run. While the run executes the
current stage carries a pulsing halo (static under prefers-reduced-motion)
and a ticking elapsed badge; a finished run shows neither. Clicking a
stage opens the existing visit pane at that stage's latest visit, and
Back/Escape return focus. The empty state is the exact
"This server did not include the run graph."
extend src/graph.js with the run-mode inputs (runState-driven executed
styling, legend, active halo/elapsed badge); keep app.js to wiring.
Extend graph.test.mjs with focused run-mode unit tests and ui-smoke.mjs
with the run 438 / run 440 / live-run captures. Mark R5 done in
web/PARITY.md.
Checks: node --check on every touched file; cd web && node --test test/
(178 pass, 0 fail); cd web && node test/ui-smoke.mjs --out captures
(UI SMOKE PASS, captures 28-31).
The browser run detail becomes a tab strip — Summary, Input, Output,
Timeline — over the selected tab's body, with the Graph tab key reserved
for the R5 item.
- Summary: run label, status chip + outcome, the run identity line, the
key/value rows (Pipeline, Stage, waiting-for-resource line, Workspace,
content hash, Started, Finished, live Duration, Retry of, Diagnostic)
and the collapsed run artifacts gallery.
- Input / Output: one collapsed section per recorded map entry, the value
as a monospace block; empty states match the app.
- Timeline: one row per visit with the stage-outcome glyph, `{stage} ·
visit {n}`, an outcome chip, a paperclip when artifacts were recorded,
the duration and the description; a row opens the per-visit stage pane.
- Stage pane: headline rows, the Verdict block with inline artifact links
and the Artifacts / Session / Output / Input / This run / Stage
definition sections, all closable with Escape.
All new logic is the pure, DOM-free src/runDetail.js ported from the
Android sources; app.js keeps only the wiring and every server string is
set with textContent.
PARITY.md: R3, R6 and R7 marked done with their captures.
Close P6 of web/PARITY.md: the pipeline detail's Graph tab now renders the
pipeline's workflow graph — stage nodes in declaration order, labelled outcome
edges, and the #failure/#success terminals on a shared lower row — plus a
definition pane opened from a node.
- src/graph.js (new): reusable `mount(container, graph, options) -> { unmount }`
plus the pure helpers it is built from (layout, edges, `error*`, lanes,
fit/clamp/zoom, hit-test, stage-definition fields). Definition view only, so
the run-detail Graph tab (R5) can reuse it. Mirrors WorkflowGraph.kt,
GraphPalette.kt, GraphSemantics.kt, StageDetailPane.kt and RunGraphTab.kt.
- src/app.js: wiring only — mount the graph in the Graph tab, drop the previous
mount on every re-render.
- styles.css: the .graph-* styles in the app's dark palette.
- test/graph.test.mjs (new): focused unit tests for the pure helpers, no DOM.
- test/ui-smoke.mjs: open "Plan and land", switch to Graph, capture the graph,
a stage pane and the expanded view, and assert the zoom/pan clamps and the
empty-pane wording against the live server.
- PARITY.md: P6 done with the 2026-10-19 captures; P3 notes the Graph tab now
renders the graph; R5 stays todo.
Checks: node --check on all five touched JS/MJS files; `node --test test/`
137 pass / 0 fail; `node test/ui-smoke.mjs --out ../captures` UI SMOKE PASS
against ws://127.0.0.1:8080/connect.
Combine the R8/R9 artifacts gallery, viewer and session link with main's
pipelines/runs/templates work. app.js: keep both import blocks. ui-smoke.mjs:
the artifacts step now navigates to Runs and selects run 430 through the
post-main run-row markup (meta[data-run-id=430]) instead of the retired
'.list button.row #430' spike row.
Checks: node --check on every touched file; node --test test/ 108 pass;
live ui-smoke against ws://127.0.0.1:8080/connect passes (run 430: 18 tiles,
viewer '1 of 10 · image/png', session link .../artifacts/430/8/session.html).
captures/ stays untracked.
Close three rows of the browser client's parity checklist, matching the Android
app's wording and behaviour:
- P1 pipeline list: name; "id {id} · v{version} · {N stages}"; "updated d MMM
HH:mm"; a last-run line joined from list_runs (status chip plus
"{ago} · {duration} · run {id}", or "no runs recorded").
- P2 filter + sort: Filter menu (name contains, Runs Any/Has runs/No runs, the
seven server run statuses, Clear filters) and Sort menu (Server order default,
Name A-Z/Z-A, Most recent run, Fewest/Most stages, Reset). Server order is
preserved.
- P3 pipeline detail: Summary/Graph/Source tabs; Summary shows the content hash
(monospace), latest version, created/updated and a collapsed-by-default
Versions section. The Graph tab carries the browser guidance note only; the
rendered graph stays P6.
New src/pipelines.js holds the pure, DOM-free helpers (timestamps, durations,
last-run join, comparators, filter, empty states); app.js is wiring only.
web/test/pipelines.test.mjs covers the helpers; web/test/ui-smoke.mjs captures
the list, controls and detail against the live server. All server strings are
set with textContent.
Day-grouped run list with sticky day headers (Today / Yesterday / d MMM
yyyy / Unknown date), a usage roll-up block, the app's row hierarchy and
a bounded filter/sort menu — mirroring RunHistoryScreen.kt, ListFilter.kt
and ListSort.kt. New pure helpers live in src/runs.js with focused unit
tests; app.js keeps the wiring and sets server strings with textContent.
R1 done, R2 partial: no per-row "needs you" mark exists in the Android
app; its wording is deferred to R15 (separate attention surface).
Port the Android artifact derivation into a pure, DOM-free src/artifacts.js
(presentedArtifacts with the retired session.md hidden everywhere, grouping by
stage/visit, the header/summary/capture-note wording, kind and size formatting,
viewer paging and sessionExportArtifact) and unit-test it.
Wire it into src/app.js: a run-level artifacts gallery with per-(stage,visit)
groups, per-visit summaries and tiles, a full-screen viewer overlay (paging,
Escape/backdrop close) and the read-only session.html link. Every server string
is set with textContent; captures/ stays untracked.
Captured live against run 430 through test/ui-smoke.mjs:
captures/04-run-430-artifacts.png, 05-artifact-viewer.png,
06-session-export-link.png. PARITY.md marks R8 and R9 done.
Adds the area map (web/AGENTS.md), the parity acceptance checklist
(web/PARITY.md, one row per Android feature), and a zero-dependency browser
verification harness: test/browser.mjs drives the installed Chrome over the
DevTools protocol, and test/ui-smoke.mjs serves the page, connects it through
its own /connect proxy, and captures the rendered pipeline list, a pipeline
detail and a run detail as PNGs.
This closes the spike's 'rendered page not verified' gap (29 pipelines rendered,
three captures) and gives review stages real UI evidence without a phone or an
npm install. Hosting is unchanged: serve.mjs stays alongside the Pipelines
server and proxies /connect.
The chat background-task bar now lists only tasks that are still running, so an
exited task no longer lingers and the bar disappears when the last one ends. The
one-line 'running now and recently observed exits' subtitle is replaced by a
compact 'Background tasks · N running' header, and the list is capped at three
touch-sized rows and scrolls beyond that instead of pushing the composer down the
screen. Unit-tested (running-only set and the row cap) and the stale note
updated.
Opening a pipeline is a detail surface that owns the foot of the Pipelines
destination, so the floating pill now stands down there exactly as it already
does for a run detail (any non-list pane depth), and returning to the pipeline
list restores it. Verified on the foldable emulator: pill drawn on the pipeline
list, hidden on the Android pipeline detail, restored on Back.
The Android UI reviewer declares the android-devices pool instead of one
hard-coded Pixel, so a second UI run can use the idle foldable emulator instead
of waiting behind the single phone. Updates the Android map's device rules to
match the pool (replacing the old single-phone / no-emulator rule) and records
the pool, its members and the delivery-only personal Fold in a note. Safety
rules are unchanged; configuration and the pipeline version are separate steps.
An empty partial capture no longer collapses to "no changes observed": the run
summary keeps partial/unavailable/missing capture evidence explicit, reports
skipped files, and preserves real earlier patches when a later commit-only stage
has a complete empty capture. Adds focused RunChanges tests and the stale-doc
note. UI-verified on the foldable emulator against a controlled fixture: an empty
partial capture shows 'Changes · partial capture' with the skipped-file note, and
a clean complete capture still shows 'Changes · no changes observed'.
Relocates the attention entry point from the floating above-pill chip into the
existing main/detail app bars (bell + count badge), removing the old floating
indicator and its reserved scroll spacing. Preserves Clear all, individual
dismiss, open-run and badge-count behavior. UI-verified on the foldable
emulator: action-bar bell with badge on Runs and run detail, sheet opens from
it, no floating chip.
Add local operator inspection and reconciliation for quarantined resource leases, including atomic audit-backed FIFO handoff and recovery protocol support.\n\nPreserve capability tokens in the authoritative store and reject non-loopback or ordinary client transport for recovery mutations.\n\nChecked packaged templates and packaged authoring skill references; none need updating. The task-owned docs note records shared README and skill reference follow-up for docs-fold.
Add executable regressions for a forged forwarded loopback claim over a real WebSocket transport and for replaying an old recovery after FIFO successor handoff.\n\nChecked packaged templates and packaged authoring skill references; neither needs updating. The existing per-item documentation note records shared documentation that the manual docs-fold process must update.
Use an explicit chat_create operation_id as the durable bootstrap key while retaining envelope IDs for reply correlation. Legacy requests receive fresh server-scoped identities, so independent cli-1/android-1 requests do not collide; clients that retry retain one operation_id.
Update Android creation state and repository calls to preserve an operation identity across retries, and cover durable reconnect retries, duplicate barriers, changed input, legacy correlation reuse, and protocol serialization.
Checked packaged templates: none describe chat_create. Checked packaged authoring-skill references: the existing description is stale, but shared references and README must not be edited by an item; docs/notes/bootstrap-create-identity.md records the required docs-fold update and rollout compatibility.
Use conditional durable phase transitions and affected-row checks so only the request that reserves each phase can create or activate a manager chat session. Record duplicate ownership conflicts without repeating external work, and cover the reservation and restart state in pipeline and server tests.
Checked packaged templates and authoring skill references: the existing task commit already packages the dedicated manager skill and installer inventory; this transition-race fix requires no further template or reference update. Shared documentation remains untouched; the task note is docs/notes/manager-skill-bootstrap.md.
Close the per-thread history loading gate before launching requests, make live/history part reconciliation linear, and reject duplicate history envelope fields.
Complete task-owned history paging work remains preserved in the preceding recovery commit. Checked packaged templates and packaged authoring skill references: neither needs an update; docs/notes/large-chat-history.md records the stale shared documentation.
Add validated OpenCode-only delivery capabilities, canonical linked-worktree access checks, isolated candidate verification, and guarded main settlement.
Wire the bounded reconnect-foreground controlled HTTP fixture through ordinary server construction so target verification obtains server-controlled provenance and rejects unknown or incompatible fixture evidence.
Checked packaged templates and packaged authoring skill references; no updates are needed because this draft-only infrastructure activates no definition. Recorded the stale reference and activation guidance in docs/notes/delivery-stabilization.md for the docs fold.
Reconcile authoritative shell snapshots with bounded lifecycle journals so concurrent exits and creates cannot be overwritten, coalesce observation setup, and retain verified ownership across reconnects. Add deterministic reconciliation and cancellation regressions plus stable limited-visibility handling.\n\nChecked packaged templates and authoring skill references: none need updating. The task-owned docs note records the stale shared chat documentation for docs-fold; shared documentation was not edited.
Add a process-lifecycle foreground reconnector and pure recovery policy, wiring repository recovery through the validated saved endpoint. Include lifecycle-process and focused unit coverage while preserving explicit Disconnect and stale socket callback guards.
Checked packaged templates and packaged authoring skill references: neither documents Android connection lifecycle behavior, so neither needs updating. Shared android README changes are recorded in docs/notes/foreground-reconnect.md for the docs-fold writer.
Add durable FIFO capacity-one resource leases for executable stages, including cleanup-confirmed release, conservative restart quarantine, queue state events, and CLI/TUI/Android waiting presentation. Add scheduler, cleanup, protocol, client, and Android coverage plus a proposed Android v3 resource draft.
Checked packaged templates and authoring skill references: neither needs updating in this item. The per-item docs note records the shared documentation that docs-fold must update; no shared README or packaged reference was edited.
Serialize socket replacement and callbacks so a superseded socket cannot clear or regress the active connection, and make reconnect backoff safe after a successful open. Add focused recovery regression coverage.\n\nChecked packaged templates and packaged authoring skill references; neither needs updating for this Android transport-only change.
Derive validated same-run visit artifact capabilities in the runner and pass them to OpenCode and Pi clients. Permit supported file tools to read completed prior visits and write only the current visit, preserving workspace, secret, database, and shell restrictions.\n\nChecked packaged templates and authoring skill references: neither needs updating in this item; docs/notes/scoped-artifact-access.md records the shared documentation staleness for the docs-fold writer.
Identify configured attempt expiry during V2 active-session idle waits and retain bounded phase, timeout and session diagnostics without claiming a lost response. Preserve genuine operation failures, error identities, redaction, cleanup and admitted-work replay protections. Add stage regressions and scratch-server CLI/websocket retention coverage.
Checked packaged templates in examples and the pipeline template generator: none needs updating because timeout configuration and contracts are unchanged. Checked packaged authoring skill references: debugging.md needs a STAGE DEADLINE playbook and clarified transport guidance. Recorded that stale shared documentation in docs/notes/stage-timeout-diagnostics.md for docs-fold; shared documentation was deliberately not edited.
Verification: go build ./...; go vet ./...; go test ./...; go test -count=1 ./internal/server ./internal/stage ./internal/pipeline ./internal/protocol; go test -count=1 -run TestStageDeadlineDiagnosticThroughCLIAndWebsocket -v ./internal/server; gofmt -l .; git diff --check. All passed. Live-provider behavior not tested; no deploy or deployed-service restart.
Merge session-html-only: a stage's session is exported as one html file and the
markdown export is retired from the wire, the store, the server evidence and
every listing (app, TUI, web spike). The packaged authoring references and a
docs note travel with it.
A stage's session was exported twice, as session.md and session.html, and both
files were presented. It is now one html file; the markdown export is retired.
- internal/stage/session_export.go: ExportSession renders and writes exactly one
file, session.html, via writeSessionFile; renderSessionMarkdown and its helpers
are gone; SessionExportResult carries HTML/HTMLBytes only. The source read, the
8 MiB source / 2 MiB rendered bounds, the truncation banner, the
never-overwrite rule and the honest empty-session handling are unchanged.
- internal/protocol/runs.go: SessionExport drops markdown/markdown_bytes (a
record written before the change still decodes; unknown fields are ignored),
and adds LegacySessionMarkdownArtifact with RunStep.PresentedArtifacts(), the
one Go rule that hides the retired session.md from every artifact listing.
- internal/server/runner.go: evidence.Markdown/MarkdownBytes are no longer copied.
- internal/tui: the artifacts panel, the recorded count and the per-visit summary
derive from PresentedArtifacts(), so the terminal never lists session.md.
- web/src/app.js: the spike's renderArtifacts applies the same filter.
- android: the Session section is the html export alone in a WebView — SessionView,
the Markdown/HTML toggle and the session markdown path are removed;
presentedArtifacts(step) filters the retired session.md out of the per-visit
gallery, the run gallery and its count, the verdict/selection lists and the
timeline indicator; data/protocol SessionExport drops the markdown fields.
- Tests pin the single html file, prove no session.md is written and that a
pre-existing one is neither overwritten nor presented, and prove a legacy
export record still loads and its session.md is hidden.
The legacy session.md of an older run stays on disk (dated evidence); it is only
no longer produced and no longer presented.
Checks (macOS, Go 1.24, Android Gradle 8.11.1, 18 Oct 2026): gofmt -l . prints
nothing; go build ./... && go vet ./... clean; go test ./internal/... ./cmd/...
-> 19 packages ok, 0 failures; node --check web/src/app.js ok and node --test
web/test -> 20/20; gradle --offline --no-daemon :app:assembleDebug
:app:testDebugUnitTest -> BUILD SUCCESSFUL.
Packaged references checked: internal/author/skill/references/delivery.md and
operations.md both described the session.md+session.html pair, so both are
updated here to describe the single session.html export and the retired, hidden
session.md. README.md and internal/author/skill/SKILL.md carry no session.md
reference and install.go's managed inventory is unchanged (no reference added or
removed). docs/notes/session-html-only.md records the remaining stale shared
documentation (docs/stage-artifacts.md, docs/app-integration-verification.md) for
the docs-fold writer; shared docs are not edited by this item.
Brings the tool-call summary chip (7fbbd95) together with main's chat in-flight
state and background-process surface (7b0dc94). Both edit ChatFormat.kt and
ChatTranscript.kt; the merge combined them cleanly (no conflict markers) — the
chip's live gating (live = streaming, toolStartedAt) now sits alongside main's
turn-phase labels and background-process bar, and both sides' pure helpers
coexist.
Re-ran the repository checks on the resolved tree: gradle --offline --no-daemon
:app:testDebugUnitTest :app:assembleDebug => BUILD SUCCESSFUL; JUnit XML
aggregate classes=70 tests=680 failures=0 errors=0 skipped=0.
The chat transcript no longer renders a chip per tool call: `ToolCalls`
(`android/.../ui/chat/ChatToolCalls.kt`) now draws a single summary chip
reading `N tools called` (`1 tool called` for one) as the turn's only
tool-call surface. While the turn streams the chip shows the call count
growing and the existing spinner while any call is in flight, plus the
existing `· long` mark for a running call past `TOOL_LONG_RUNNING_MILLIS`;
both are gated on the turn still streaming (`live = streaming` in
`AgentTurnItem`), so a settled chip never spins or fakes a long mark.
Tapping the chip opens the existing `ToolPanel` as a popup listing every
call of the turn, in the order the agent made them: one independently
collapsible row per call naming it, showing its one-line detail, its
`+N -M` edit stat and its duration, expanding in place to the
pretty-printed INPUT, the synthesised edit diff, then the ERROR block for
a failed call or the OUTPUT (`(no output)` when empty). The list is
bounded by the new `TOOL_PANEL_MAX_HEIGHT_DP` (`Dimens.kt`, purpose-named)
and scrolls inside the panel, so many calls never grow the popup past the
window nor re-flow the transcript. The chip announces the count ("N tool
calls, expand for details") through the app's accessibility treatment.
Pure logic lives in `ChatFormat.kt` (`toolCallsLabel`,
`toolCallsAnnouncement`, `toolCallCount`, `toolsRunning`, `toolCallRow`)
with unit cases added to the existing `ChatFormatTest`; no raw dimension
was introduced, so `DimensTest` is unchanged.
Checked for staleness: the packaged authoring skill references
(`internal/author/skill/references/`) and the packaged templates carry no
Android-chat content, so neither needs updating — this change is
`android/`-only. The shared docs this change makes stale
(`android/README.md`'s "Tool-call chips and the expandable panel" section
and `docs/chat-verification.md`'s tool-chip row) are recorded in
`docs/notes/chat-tool-group.md` for the single `docs-fold` writer rather
than edited here.
Brings in the turn-phase label (Thinking…/Running a tool…/Waiting…) derived
purely from the stream, and end-to-end surfacing of the agent's shell commands
as a 'shell' chat_event kind with a retained, resumable background-process
indicator in the app.
Two gaps in the chat's in-flight feedback.
The turn indicator no longer reads a bare `Working…` for every state. A new
pure derivation (TurnPhase/turnPhase/turnPhaseLabel in ui/chat/ChatFormat.kt)
labels the headline from evidence already on the wire: `Thinking…` while text
or reasoning deltas are still arriving (within TURN_THINKING_WINDOW_MILLIS),
`Running a tool…` while calls are in flight, `Waiting…` otherwise. No
percentage, ETA or invented progress.
The agent's shell commands are now surfaced end to end as their own frame kind,
so a background process (a dev server, a watching build) that outlives its tool
call is visible and clears when it exits.
Server:
- protocol/chat.go adds ChatEventShell, ChatShell (id, status, command, *int
exit — a pointer so exit 0 is not "absent") and ChatEventFrame.shell.
- opencode/chat.go maps shell.created/shell.exited through a new exported
ChatStreamState, attributing created via info.metadata.sessionID and exit via
the ids the stream already surfaced; another session's or an unattributed
shell is ignored, an id-less shell fails the stream. No cwd/file/credential is
carried.
- server/chat_hub.go retains still-running shells (chatShellLimit plus the
shared byte cap) and drops them on exit; chat_stream.go replays them on
chat_subscribe, the shell half of the resume (a shell is not a turn, so the
message snapshot cannot carry it).
App:
- data/protocol/Chat.kt adds ChatShell, ChatEventFrame.shell, EVENT_SHELL,
SHELL_RUNNING/SHELL_EXITED.
- ui/chat/ChatStore.kt stamps ChatThread.lastDeltaAt on each delta (cleared when
the turn settles) and keeps ChatThread.shells across a chat switch; a shell
never marks the thread running. streamResumed drops shells so the subscribe
replay re-syncs the still-running ones.
- ui/chat/ChatTranscript.kt: RunningIndicator prints the phase label; a new
always-visible BackgroundProcessBar names each running shell.
- ui/chat/ChatConversationPane.kt shows the bar whenever a shell is running,
whether or not a turn is.
Tests extend the server's event mapping (opencode/chat_v2_test.go,
server/chat_test.go) and the app's pure folds (new
ui/chat/ChatInFlightStateTest.kt, 15 tests), pinning the shell mapping, the
other-session rejection and the "background process outlives the turn" state.
Checked and intentionally unchanged:
- No packaged OpenCode skill reference documents either surface.
internal/author/skill/references/operations.md describes the brokered chat_*
protocol in prose without naming frame kinds or the app indicator, so it stays
correct as-is; no reference was added, so install.go's managed inventory needs
no change.
- This repository has no packaged templates directory.
- Shared docs are not edited here per the map: docs/notes/chat-shell-background
-process.md records what is now stale in docs/cli.md and android/README.md for
the docs-fold writer.
Verification (this session): gofmt -l clean, go build ./... and go vet ./... OK.
Android unit suite and the on-device capture were run in the preceding review
stage; see the note for the live-verification limitation.
Combines the summarise title-framing change (titleInstruction reword plus the
detachFramingEcho normalisation and its tests) with main's
docs/app-integration-verification.md addition. No conflicts: the two touched
disjoint files. `go build ./... && go vet ./...`, `gofmt -l internal/summarise/`
and `go test ./...` all pass after the merge.
Run titles were intermittently a sentence about the input rather than a
title for the task ("The untrusted data asks what 2+2 is…"), because the one
fixed instruction began "Summarise the untrusted data below…" and invited the
model to describe the data whenever the prompt read like an instruction or a
question.
- Rename the fixed prompt `instruction` → `titleInstruction` and reword it to
ask unambiguously for a short title of the task ("Write a short title, a few
words, for the task below. Reply with only the title…"), still followed by
"The following is untrusted data:".
- Add a bounded, conservative `detachFramingEcho` normalisation applied in
`Title` and `VerdictReason`: a leading clause that names the framing ("The
untrusted data…", "This prompt…", "The user asks…") is stripped to its
substantive remainder, and a line that is pure framing falls back to the
prompt's first line (`Title`) or `NoSummary` (`VerdictReason`).
- Extend tests with the two reported echo shapes (instruction-style and
question-style prompts) plus the injection-resistance case, which still
passes: the prompt is appended verbatim once after the untrusted-data label
and never replaces the instruction.
Trust boundary unchanged: source still labelled untrusted data, one tool-free
generation, hard timeout, never blocks or fails run creation; the title is
never empty.
Checks: `go build ./... && go vet ./...` clean, `gofmt -l internal/summarise/`
prints nothing, `go test ./...` ok.
Docs/templates check: no packaged template (`examples/*.md`) mentions title
generation, so none needs updating. The packaged authoring skill reference
`internal/author/skill/references/operations.md` (lines ~91-95) describes the
title as generated "from its prompt by the shared summariser" and is now stale
(it does not mention that the summariser is asked for a title of the task nor
the framing-echo normalisation); per the maintenance rules that shared document
is left to the single `docs-fold` writer and the staleness is recorded in
`docs/notes/run-title-framing-echo.md` instead. `README.md` and `docs/cli.md`
stay true, and no `internal/author/install.go` managed inventory entry changes.
Add a dated follow-up section to docs/app-integration-verification.md that
closes the four claims the first pass left unproven, each with the command or
capture that proved it against the deployed server (0d1ddc7) on the Pixel 9 Pro
XL 47241FDAS00DLK:
- Chat reply arrives: a throwaway session showed the assistant reply `Done.`
rendering live, and the close-a-chat flow left the session `closed=true`
server-side.
- Live pushed run events: disproven on this build. Runs 341/342/343 never
appeared or advanced without a manual `Refresh runs`; only a local elapsed
timer ticked. Consistent with the run-event push-hub defect fixed on main by
cff6f4d, absent from the deployed 0d1ddc7. Recorded as a defect with exact
reproduction, not an app defect.
- Disconnected state: the closed-port state and the restore to
ws://10.0.0.75:8080/connect were both captured and Settings verified after.
- Wide windows: the covered-pane region is a constant 553 px at depths 1-3 and
at 2000x2244 and 2076x2152; `wm size reset` left no override.
Checked for staleness from this change: it touches no source or resource file,
so no packaged template or packaged authoring skill reference
(internal/author/skill/references/) depends on it - none references this
document and none needs updating.
Report-only: the untracked scratch directory .gaps-tmp/ is deliberately left
uncommitted.
The run-event hub seeded a new subscription by sending every matching run
through the subscription's bounded 32-frame channel and only then acking. A
snapshot larger than that buffer tripped the drop-a-slow-subscriber policy on
the snapshot itself, so the remaining snapshot frames, the ack and every later
delta were lost while the websocket stayed open - the client could not tell it
had been unsubscribed. The snapshot and the ack now go straight out on the
subscribing connection, deltas emitted meanwhile are held and released in order
before the writer goroutine starts, and the drop policy now applies only to
deltas. Guarded by TestRunEventSubscribeSnapshotLargerThanBuffer.
handleRunEvents seeded a new subscription by pushing every matching run
through the subscription channel (runEventSubscriberBuffer = 32) and only
then acked. sendMessage is a non-blocking send that closes the
subscription when the channel is full, so a snapshot larger than the
buffer dropped the subscription it was seeding: the remaining snapshot
frames hit the closed-done early return, the ack was never sent, and no
later delta could arrive. The connection stayed open, so the client could
not tell it was no longer subscribed. This was the app's only
subscription - AppViewModel subscribes with a blank workspace, matching
every run - so the app's live state froze.
The subscription now starts in a snapshot phase. The subscribing
connection itself writes the snapshot frames via writeSnapshot (one
direct write per frame, outside the bounded channel, so the drop policy
cannot fire on them) and the ack, and ready then moves any deltas held
meanwhile into the channel in order and starts the writer goroutine.
sendMessage holds deltas in a bounded pending queue while snapshotting
instead of closing, so the drop-a-slow-subscriber policy still applies,
but only to deltas. Ordering is snapshot, ack, then deltas; a write
failure or a listRuns error closes the subscription instead of leaving
it registered.
Numbers reported by this run: the probe against the deployed server saw
blank-scope frames=2 ack=0 (scoped frames=1 ack=0) because the snapshot
was ~252 frames into a 32-frame buffer; the scratch-server probe with the
fix saw 40 snapshot frames, ack=1 and a delta after a run transition.
Guarded now by TestRunEventSubscribeSnapshotLargerThanBuffer (seeds 40
finished runs, asserts every snapshot frame, the ack strictly after them,
and a terminal delta for a run started after subscribing), which fails
against the previous runevents.go.
Checked for staleness: the packaged templates and the packaged authoring
skill references internal/author/skill/references/ carry no run-event
subscription contract (their "snapshot" mentions are the workspace-change
snapshots in operations.md), and README carries none either, so none of
them needs updating. No UI surface changed.
Checks run before committing: gofmt -l . prints nothing, go build ./...,
go vet ./..., go test ./... (all packages ok), go test -race
./internal/server (ok).
Rewrite the workflow documentation to describe how the system actually works:
the agent (the session) is the brain and advances the queue by hand through the
`pipelines` CLI. There is no orchestration script, no driver, no polling loop and
no lane machinery, and none may be written.
- references/work.md: rewritten end to end. The queue-driver script
(drivers/workd.sh), the claim-file ledger with atomic renames, the PAUSED
marker and the poll loop are gone. State is now the server (authoritative for
run state), the queue file (authoritative for intent) and the conversation.
The agent reads the queue, picks the item, creates its worktree/branch and
launches it with `pipelines run <pipeline> <brief> --json --yes`; progress is
event-driven via a background `pipelines wait <run-id> [...]` (never polled);
on completion the agent reconciles with `pipelines inspect <run-id> --json`,
verifies it landed and starts the next item.
- references/queue.md: the landing gate runs the command directly
(`git merge-base --is-ancestor <branch> main`, exit 0 = landed) instead of a
`land-check.sh` helper; the never-delete-branch / never-remove-worktree rules
are kept, and the waiting section states the agent advances the queue by hand.
- references/orchestration.md: intro and "Running and watching" state the
agent-driven, event-driven model; "Pipeline choice" names the current set
(Android, TUI, Server, Generic, Plan and land, UI sweep, Probe) by area and
records the retired names.
- references/debugging.md: "Duplicated work after a driver restart" became
"…after a session restart", resuming from the queue file not a cursor file.
- SKILL.md: the routing row no longer says "queue driver".
- AGENTS.md: the maintenance workflow names the current pipeline set instead of
the retired `Pipelines maintenance - plan implement review`.
- internal/tui/AGENTS.md: the restart line no longer names lanes.
- docs/notes/agent-driven-work-model.md: the docs-fold note recording that
docs/cli.md needs its "Scripted runs"/`--wait` framing aligned to the
event-driven model, and that the dated evidence docs stay as they are.
Checked before committing: no packaged template directory exists in this repo, so
none needed updating; internal/author/install.go's managed file inventory needs no
change (no packaged reference was added or removed — the 13 listed files all
match internal/author/skill/references/); no stale `queue driver`/`workd.sh`/
`claim-file` references remain anywhere under internal/author. Genuine device
tooling (android/scripts/capture_png.sh-style) and server-side polling prose were
left alone.
Checks: `go test ./internal/author -count=1` ok; `go build ./...` clean;
`go vet ./...` clean; `gofmt -l .` clean.
The phone's chat transcript rendered one agent reply as ~36 bubbles, each with
its own thinking block, and a finished tool call lost its name and its input.
- Turn fold (android): ChatFormat.kt gains the pure ChatTurn / TranscriptRow /
transcriptRows fold - each run of consecutive assistant messages between two of
the operator's messages is one agent turn - and ChatTranscript renders one
bubble per turn: the turn's single collapsible thinking block (all its
reasoning, in order, growing live while it streams), then its tool-call chips,
then one answer block of just the turn's text parts. AssistantParts/MessagePart
are replaced by AgentTurnItem/UserMessageItem; ChatConversationPane counts the
folded rows.
- Delta part ids (server + client): internal/protocol/chat.go adds
ChatDeltaPartID(messageID, kind, ordinal), mirrored as ChatProtocol.deltaPartId
in data/protocol/Chat.kt, and NormalizeChatEvent keys a text or reasoning delta
on it. OpenCode numbers a message's text and reasoning parts independently from
0, so the old "%s#%d" gave the first text delta and first reasoning part the
same id: the answer was appended into the thinking block, and the server's
retained state (chat_hub.go) re-collided on resume. ChatStore's upsert now
routes a delta through the kind-aware deltaPartId fold, so it stays robust even
against a peer that still shares one id.
- Tool fields (server + client): NormalizeChatEvent takes a call's arguments from
session.tool.input.ended's text as well as session.tool.called's input object
(toolInput), and chat_hub.go's new mergeChatToolPart folds each tool frame onto
the retained part so the progress/success frames that omit name and input never
blank them. ChatFormat.kt's mergeToolPart mirrors that on the client, so the
chip and panel header keep the real tool name and the panel shows INPUT beside
OUTPUT.
Tests: chat_v2_test.go and chat_test.go add the text/reasoning id-collision and
the tool name+input retention cases; ChatReasoningTurnTest, ChatTranscriptTest
and ChatRunningWorkTest cover the turn fold, the collision and the tool lifecycle.
Checks: Go build, vet, gofmt and the package tests pass (go build ./... &&
go vet ./...; gofmt -l . empty; go test ./internal/server ./internal/opencode
./internal/protocol ./internal/stage ./internal/pipeline; go test ./...).
Android passes offline with --no-daemon (assembleDebug and the full
testDebugUnitTest suite, 660 tests). The on-phone observation was not performed:
the device lock was held by another run and adb was not available here.
Documentation inventory checked: no packaged OpenCode skill reference in
internal/author/skill/references/ and no packaged template documents the app's
chat transcript, this delta part-id derivation or the tool-field retention, and
no internal/author/ managed file inventory entry names any touched file, so none
of them needs updating. The shared android/README.md behaviour statements are
made stale by this change and are recorded instead in
docs/notes/chat-transcript-turn-fold.md for the docs-fold writer, per the repo
rule that an item never edits a shared document itself.
docs/app-integration-verification.md: operator-facing report of the Android app
verified end-to-end against the real running server on the phone, per flow with
the real data observed and the coverage gaps that remain.
Adds docs/app-integration-verification.md, an operator-facing report of an
end-to-end verification of the Android app against the real running Pipelines
server on the phone. Report only: no app, server, installer or Docker file was
changed, and nothing was fixed.
The report records, per flow, the result, capture path and the real server data
observed: the pipelines list and its filters/sort, pipeline detail tabs, runs
list aggregate (246 total) and run detail, the stage sheet/timeline and
full-screen artifact viewer gaps, artifacts gallery, omni search, Settings
(endpoint ws://10.0.0.75:8080/connect, server build 0d1ddc73a4), the templates
gallery, chat sessions, live run updates and the disconnected state that were
not verified and why.
Revision tested: phone app at main's build (0d1ddc7, installed md5
722f6a139a8aea6d15b09c89360dbea0), server build
v0.0.0-20261018001257-0d1ddc73a444. The phone was left on main's build.
Checked for staleness: no packaged template or packaged authoring skill
reference (internal/author/skill/references/*) describes or indexes this
document, and the change adds no runtime behaviour, so none of them needed
updating. Per the maintenance convention the shared docs were not edited; the
verification findings live in this document alone.
Adds a read-only CLI command that blocks until each named run reaches a terminal
status (including through a human stage) and reports each run's id, status,
outcome, stage and duration; batches several ids in one command and exits 0 even
for an unsuccessful run. Reuses the existing run --wait polling machinery.
Includes tests and a docs/notes record of the docs the docs-fold writer should
update.
Brings main (chat-persistence pairing; skill: replace the lane model with the
work queue) up to date on this branch so it can land without conflict. The
second merge (skill/queue.md) auto-merged with no conflicts; no intent from
either side was dropped. Build, vet, gofmt and the affected package tests pass
after the merge.
The lane machinery is gone: work is a markdown queue, items run in parallel in
their own worktrees, the committer stage lands its own work, land-check.sh gates
cleanup, branches are never deleted, and pipelines wait (rather than a driver
script) is what wakes a session. references/lanes.md becomes references/queue.md;
the remaining lane references in work/orchestration/debugging/delivery/format and
SKILL.md are rewritten, and the installer now prunes a managed file it no longer
bundles when the copy is unmodified.
Brings main (chat-persistence: OpenCode pairing, protocol status, server
websocket/status changes) up to date on this branch so it can land without
conflict. Auto-merged with no conflicts; no comment or intent from either side
was dropped. Re-ran build, vet, gofmt and the full test suite after the merge -
all pass.
The harness resumes a session when a background command finishes, so "tell me
when this run is done" needs one command that blocks and exits rather than a
polling script.
- `pipelines wait <run-id> [run-id ...]` resolves every id up front (an unknown
run is a fast client error), then polls each run to a terminal status -
`succeeded`, `failed`, `canceled` or `interrupted`, blocking through a run
parked on a human decision - and prints one line per run as it finishes with
id, status and outcome, stage and duration.
- A finished-but-unsuccessful run is still a finished run: it is reported and
the command exits 0. The exit is non-zero only for a client-side failure: an
unknown id, a connection that cannot be established, or `--timeout` expiring
while a run is still active. A timeout reports the still-active runs,
changes nothing, and is never treated as a run's outcome.
- Reuses the existing `run --wait` polling machinery: the per-second `get_run`
reattachment is factored into `awaitRuns`, used by `finishRun` too. No
subscription or new protocol message. `--url`/`--timeout` follow the existing
client conventions; `--timeout` is the overall client limit (default 0).
- Read-only: sends only `get_run`, resolves no workspace, is not refused by the
workspace guard and writes nothing. `--json` prints the final run envelope
(one envelope for one id, an array for several).
- `commands.go` and `help.go` add it to the usage inventory and EXECUTE help.
Tests: `wait_test.go` (line format, batch reporting, wait-until-terminal,
unknown id, timeout leaves the run active, `--json` shape) and
`wait_command_test.go` (real CLI against the real websocket server and store).
Packaged assets checked: no packaged template changes. No authoring skill
reference file is added, so `internal/author/install.go`'s managed inventory
needs no change. `internal/author/skill/references/operations.md` (the
"inspect results first" run-operations list) and `docs/cli.md` (the scripted-runs
`--wait` paragraph and the CLI/TUI capability-map row) are now stale and are
recorded - not edited - in `docs/notes/wait-command.md` for the `docs-fold`
writer. `SKILL.md` stays a task-directed index; no shared document is edited
here.
No protocol, server, store, TUI or Android change; no new dependency; no run
started. Committed locally only, not pushed or deployed.
Brokered chat now pairs with the operator's running OpenCode V2 service
(POST /api/pair then GET /auth/connect/{code}) using the local service
credential as bootstrap, stores the resulting token owner-only beside the
pipeline database, reuses it across restarts and re-pairs once when it is
refused; an explicit PIPELINES_OPENCODE_ENDPOINT_PASSWORD_FILE still wins. An
endpoint that cannot be attached falls back to the server's own OpenCode
instance with a log line and a get_status opencode object
(health = endpoint | fallback | spawned | unavailable) instead of silently
disabling chat. See docs/notes/chat-persistence.md.
Brings main (78725e9, "bottom-strip": the Android detail and visit selectors
moved to a bottom strip, with its docs/notes/bottom-selector-strip.md) into this
branch on top of the chat-persistence commit. The two sides touch disjoint files
- main changes android/ and its own note, this branch changes
cmd/pipelines-server, internal/opencode, internal/protocol, internal/server and
docs/notes/chat-persistence.md - so the merge applied with no conflict and no
resolution was needed. Repository checks after the merge: go build ./...,
go vet ./... and gofmt -l . clean; go test ./internal/... ./cmd/... green.
Brokered chat accepted an operator-supplied endpoint (-opencode-endpoint /
PIPELINES_OPENCODE_ENDPOINT) but failed closed against the operator's running
V2 service: that API authenticates every request with HTTP Basic auth (fixed
user "opencode" plus a password), the broker had no credential, so the health
probe answered 401 and startup logged "OpenCode endpoint ... is unreachable or
is not an OpenCode service", disabling chat entirely.
Established from the installed binary (opencode v2.0.20), not from docs:
`opencode --help` advertises `api`, `pair`, `serve`, `service` and `auth`;
`GET /api/info` is unauthenticated-401 with www-authenticate Basic realm
"Secure Area"; Basic auth user `opencode` with the password from
~/.local/state/opencode/service.json answers 200; `POST /api/pair` returns a
code and `GET /auth/connect/{code}` returns a token that is then accepted as
the Basic password.
- internal/opencode/pair.go (new): PairEndpoint does the pair exchange over the
shared nativeRequest transport (same auth, bounds and JSON checks);
ReadServiceCredential reads the operator's local service password under the
private-file rule; OpenEndpointAttached resolves the credential in precedence
order - explicit password file, a paired token stored by an earlier run, then
a fresh pairing bootstrapped by the local service credential - stores the
token owner-only and re-pairs once when a stored token is refused (401).
- internal/opencode/endpoint.go: OpenEndpoint wraps probeEndpoint, which returns
the connection even on failure; Connection.unauthorized (set on HTTP 401 by
the request paths, cleared per probe) distinguishes an authentication refusal
from any other refusal.
- cmd/pipelines-server/main.go: the endpoint attach uses OpenEndpointAttached
with the paired-credential file beside the pipeline database. An endpoint that
cannot be attached logs a line naming it and falls back to the server's own
OpenCode instance instead of leaving chat refused.
- internal/protocol/status.go, internal/server/websocket.go: get_status gains an
opencode object (health = endpoint | fallback | spawned | unavailable, plus
the endpoint url), the honest status evidence for the fallback. No credential
is ever placed there.
- Tests: internal/opencode/pair_test.go, internal/protocol/status_test.go and a
TestStatusReportsOpenCodeAttachment case in internal/server/status_test.go.
Repository checks: go build ./..., go vet ./... and gofmt -l . clean;
go test ./internal/... ./cmd/... green.
Packaged templates and skill references: the repository has no template tree
that mentions the OpenCode endpoint, and no packaged reference file is added, so
internal/author/install.go's managed inventory is unchanged. The packaged
authoring reference internal/author/skill/references/operations.md (the endpoint
paragraph around line 289, the "clear refusal and no fallback" wording and the
password-file/username-only credential story, and the missing opencode status
field) is now stale; per the maintenance convention the item does not edit the
shared document and instead records the stale points, with the exact wording
they should take, in docs/notes/chat-persistence.md for the docs-fold writer.
The narrow detail and visit selectors are now the shared bottom strip in the thumb zone (content above it), while a wide window keeps the left rail and the pinned visit top row; the floating destinations pill lifts clear of the strip. android/ only, no new dependency.
The two selectors that were a horizontally scrolling Material 3 tab row at
the top of a surface become one deliberate treatment. On a narrow window the
shared detail selector (`DetailTabs`) and the visit selector are now the shared
bottom strip (`ui/components/SelectorStrip.kt`), pinned in the thumb zone above
the system gesture inset with the content filling the area above; a wide window
keeps the left rail for the detail selector and the pinned top row for visits.
- SelectorStrip: the one bottom strip plus its pure model (`SelectorEntry`,
`SelectorPlacement`, `detailSelectorPlacement`, `visitSelectorPlacement`,
`selectorStripShown`, `detailSelectorEntries`, `visitSelectorKey/Label`,
`visitMarker`, `visitSelectorEntries`). Each entry keeps at least the platform
minimum touch target, shows its whole label, and a visit shows its recorded
status/outcome as a small `RunStatusIcon` marker rather than an invented one.
Selection is carried by tab semantics and container colour, not colour alone.
A single entry (or none) draws no strip.
- `DetailTabs` narrow branch replaced by `SelectorStrip` after the panel in a
Column; the wide rail is unchanged.
- `StageDetailPane`: `StageVisitStrip` is the narrow visit selector; the bodies
put a `weight(1f)` scroll above it and keep the top row only on a wide window.
The stage definition section still shows no strip.
- `SessionExport`: `SessionExportSection` gains `visitTabs` so the narrow pane
does not render the visit selector twice.
- `PipelinesApp`: the strip publishes its measured height through the new
`LocalBottomStripInset`/`BottomStripInset`, and the floating pill's overlay
lifts by `pillBottomOffset(stripHeight) = SPACING_L + stripHeight` (pure, zero
when no strip is up), so the pill never overlaps the strip.
- Tests: new `SelectorStripTest` (placements, single-entry no strip, detail
entries keep tab keys/titles/icons, visit labels and markers, stable visit
keys) and a new `PipelinesNavTest` case pinning the pill lift.
Pill/strip clearance is the brief's "pill moves clear of the strip" option,
implemented once in `pillBottomOffset`. All geometry and motion come from the
existing named tokens and the layout; no new dependency.
Documentation checked: no packaged OpenCode skill reference (`internal/author/
skill/references/`) or packaged template (`examples/*.md`) documents the app's
detail/visit selector presentation, so neither is stale and `internal/author/
install.go`'s managed inventory needs no change. The shared `android/README.md`
is made stale by this change (the narrow tab-row wording at lines ~182-184,
~233-235 and ~487-488) and is recorded for the single `docs-fold` writer in the
new `docs/notes/bottom-selector-strip.md` rather than edited here.
The composer reads a leading slash as a command instead of a prompt: a filtered
offer list with Enter/tap and D-pad navigation, /new creating a session in the
current directory and switching to it (the old one stays listed with its
history), /rename on this device, /stop for a running turn and /help, with an
unrecognised /… offered as a message or cancelled rather than ever reaching the
agent. Commands report as their own transcript lines outside the model's context.
/close finishes the session through the server's own close (chat_close) that
landed beside this work, then returns to the list.
server-side chat close
What was combined:
- main brought the server-side close (chat_close/chat_reopen over the protocol,
PipelinesRepository.chatClose/chatReopen, ChatStore.sessionClosed/sessionReopened
and active/closed session projections, the list's Close chat… confirmation and
the Closed chip), plus the destinations-pill overlay and the omni-search and
status-label work from the lanes that landed beside this one.
- this branch brought the composer's slash commands: parsing, the filtered offer
list with Enter/tap/D-pad, the shared prompt path, /new in the current
directory, the local /rename, /stop, /help and the unknown-command offer, with
local command lines rendered outside the model's conversation.
Resolution (the one place the two sides disagreed):
The branch's /close reported that no real session close existed, because none did
when it was written. main now has one, so /close delegates to it instead:
AppViewModel.SessionChatCommandHost.finishSession calls closeChatSession, which
uses the server's own chat_close (a running turn is stopped, the session is marked
closed for every client, the history is kept), and then chatStore.close returns the
operator to the list. A failure is reported on the list, where the list's own close
reports it. The now-false "this build has no real session close yet" line and its
CHAT_CLOSE_UNAVAILABLE constant are removed, /close's offer summary says it
finishes the session for every client, and its test now drives the real store
close (sessionClosed + close) and asserts the row is closed, kept as history and
off the pane.
Checks run after resolving, on the merged tree (HEAD = this merge):
`--offline --no-daemon :app:assembleDebug` BUILD SUCCESSFUL, and
`:app:testDebugUnitTest` BUILD SUCCESSFUL with 646 tests, 0 failures (including
ChatCommandsTest.closeDelegatesToTheRealServerCloseAndReturnsToTheList). DimensTest
still holds: no raw dimension was added outside the token files. The packaged
templates and packaged authoring skill references are unaffected — this is an
Android-app-only change with no protocol, server, installer or Docker change — so
none of them needed updating.
Documentation now stale (not edited here; one writer folds shared docs):
android/README.md's chat section describes the composer and the session list
without the slash commands (vocabulary, offer list, unknown-command guard) and
without the composer's /close path to the server close.
The composer now reads a leading slash as a command instead of a prompt, so the
operator can start a session, rename it, stop a turn or ask for help without
leaving the input field — the same surface the pipeline terminal gives with
`:status`, `:logs`, …
- ChatCommands.kt: parsing (a bare `/`, an unknown word, an argument, text that
merely starts with a slash), the filtered offer list, the Enter target, the
`/help` listing, the effect routing and the host interface. Pure, so the
routing is testable without a device or server.
- ChatComposer.kt: the offer list above the field, Up/Down to move the highlight
and Enter/tap to run the highlighted row, shown only while the draft is a bare
command word. Sending, attachments, stop-while-streaming, queued state and the
field's ordinary keyboard action are unchanged.
- AppViewModel.kt: one shared prompt path (`postChatPrompt`) for the composer and
the unknown-command offer, and a host that performs the effects. `/new` creates
in the current session's directory and switches to it, leaving the old session
open, listed and with its history; `/rename` uses the device's own local rename
and says so; `/stop` interrupts a running turn; `/close` reports that this
revision has no real session close rather than dressing up the local hide.
- ChatStore.kt / ChatTranscript.kt / ChatCommandUi.kt: local command lines
(`ChatCommandNotice`) rendered as their own transcript item, visually distinct
from a message to the agent, with an error container for a failed command.
- An unrecognised `/…` is never sent to the agent: it becomes an offer to send it
as a message or cancel, and the offer is taken once so a stale tap sends
nothing. Running a command adds nothing to the model's conversation.
- Dimens.kt: one new token, CHAT_COMMAND_LIST_MAX_HEIGHT, for the capped list.
- ChatCommandsTest.kt: parsing, filtering, `/new` in the current directory and
switching, `/rename` and `/close` delegating, `/stop` only while running, and
the unknown command never reaching the prompt path.
Checks made before committing: this is an Android-app-only change with no
protocol, server, installer or Docker change, so the packaged templates and the
packaged authoring skill references (internal/author/skill/references/) are
unaffected and no managed-file inventory in internal/author/install.go changes;
none of them needed updating. No dependency was added — Icons.Default.Terminal
comes from the already-declared material-icons-extended. Verified with the
Android map's own checks for an implementation change, build plus unit tests
(`--offline --no-daemon :app:assembleDebug` and `:app:testDebugUnitTest`), and
DimensTest's geometry-token rule holds: the only new dimension is the named token
above. Device behaviour was deliberately not exercised here (this stage does not
use adb); the rendered offer list, D-pad handling and notice item belong to
visual review.
Documentation that is now stale (not edited here; a single writer folds shared
docs): android/README.md's chat section describes the composer without the slash
commands — it should gain the command vocabulary, the offer list and the
unknown-command guard.
The pill no longer takes layout space: it is drawn in the bottom overlay above the
content, centred on a narrow window and anchored bottom-right on a wide one, with
its trailing clearance moved into each scrollable's own content through
LocalPillBottomInset. Templates leaves the pill for a Templates row on the Settings
page, backed by the new SettingsDestination sliding stack. The item's documentation
change is recorded in docs/notes/pill-overlay-and-position.md for the docs-fold
writer rather than edited into android/README.md.
Brings the branch up to date with main's tip so it can be merged back without
conflict. Merged cleanly, with no conflicted path: git auto-merged
ui/PipelinesApp.kt, ui/chat/ChatListPane.kt and ui/screens/RunHistoryScreen.kt,
keeping main's changes (the omni-search panel, the one status colour, the chat
close/tool-work surfaces) alongside this item's pill overlay, its
LocalPillBottomInset clearance and the SettingsDestination templates stack.
android/README.md is main's version, not this item's: this item records its
documentation change in docs/notes/pill-overlay-and-position.md for the single
docs-fold writer instead of editing that shared document.
Checks re-run on the merged tree (macOS, JAVA_HOME=Android Studio jbr,
ANDROID_HOME=~/Library/Android/sdk, Gradle 8.11.1, --offline --no-daemon):
`gradle :app:assembleDebug :app:testDebugUnitTest` -> BUILD SUCCESSFUL, 67 result
XMLs aggregating to 627 tests, 0 failures, 0 errors, 0 skipped.
The floating destination pill no longer takes layout space: it is drawn in the
bottom overlay layer above the content, horizontally centred on a narrow window
and anchored to the bottom-right corner on a wide one. Templates leaves the pill
for a Templates row on the Settings page.
- PipelinesApp: the content Column's pill reservation is gone; contentPillPadding
(pillVisible) is the named zero and a unit test pins both states. The pill and
the attention chip stay in their own bottom-anchored overlay Column, a sibling
of the content in the Box, so nothing positions the content. The one placement
rule is destinationPillAlignment(wide) (CenterHorizontally narrow, End wide);
the corner margin is the named SPACING_L, so no new number. The attention chip
keeps its own bottom-right place at every width via Modifier.align(End).
- Trailing clearance moves into each scrollable's own content: pillScrollInset
(DESTINATION_PILL_RESERVE + ATTENTION_CHIP_RESERVE while drawn, zero while
hidden) is published through the new LocalPillBottomInset
(components/PillInset.kt) and applied with pillContentPadding /
Modifier.pillBottomPadding in every list, grid and scrolling detail, stage and
settings body. The container keeps its full height, a hidden pill leaves no
empty band, and the last row still scrolls clear of the pill.
- Templates is no longer a pill destination: TemplatesDestination.kt is deleted
and destinations is pipelines/runs/chat/settings. The new SettingsDestination
sliding stack (pane 0 SettingsScreen, 1 TemplateGalleryScreen, 2
TemplateDetailScreen) with the pure, Bundle-able SettingsSelection model gives
the gallery the shared covered-pane strip and one-level Back; SettingsScreen
gains the Templates row that opens it. This re-lands the intent of a2043f9,
which never reached main.
- Dimens: the two reserve tokens' docs now describe the scroll-content clearance
and the chip's share of it; no new token and no hardcoded geometry.
Checked where the change belongs: no packaged template (examples/*.md) and no
packaged authoring skill reference (internal/author/skill/references/*) describes
the Android pill, its destinations or the Templates gallery, so none needs
updating and internal/author/install.go's inventory is unchanged. android/README.md
does document the surfaces this item changed, so it is now stale: this item does
not edit that shared document - docs/notes/pill-overlay-and-position.md records
the two places that need it (the Templates bullet and the dated section to append)
for the single docs-fold writer.
Tests: at a297fb6 with these working changes the build and unit suite were green
(593 tests, 0 failures); no device command was run and the geometry stays
token-derived. Visual rendering of the centred/right pill needs the device and
was not verified here.
Adds chat_close/chat_reopen to the brokered chat protocol and the
operator_sessions closed state, so an operator can finish with a chat: any turn
in flight is stopped through the existing interrupt, the closed state is recorded
on the server for every client, and the session, its transcript and its history
are kept and stay reachable as history. The app gains a Close action with a
confirmation, a Closed section and chip, and Reopen; the device-local hide is
renamed Hide on this device. Nothing is deleted and no pipeline-owned run session
is touched.
The item adds chat_close/chat_reopen to the brokered chat protocol and the
operator-session registry's closed state. main replaced the per-session claim
model with shared chat rooms (chat_subscribe, a prompt queue, one broker stream
fanned out to every watcher). This merges the two.
Resolved conflicts:
- internal/protocol/chat.go, internal/protocol/message.go: kept both additions -
ChatClose/ChatReopen and main's ChatSubscribe/ChatQueued.
- internal/server/chat_sessions.go: kept the closed fields on a listed session;
dropped the `Busy` assignment, because main no longer marks a session Busy (any
number of clients may watch and write one).
- internal/server/chat_claims.go: main deleted the claim model, so the file goes;
close's "is a turn running" check is now `chatHub.turnInFlight` in
internal/server/chat_room.go, reading the room's `running` flag. That is the
same question the old claim answered, against main's model.
- internal/server/chat_close.go: calls turnInFlight instead of the removed
`active`.
- android AppViewModel.kt, ChatFormat.kt, ChatListPane.kt, Message.kt: kept both
sides - main's search state, queued-prompt handling, `Busy`-free status label
and row/menu shape, plus the item's close/reopen actions, closed chip and
section, close confirmation and "Hide on this device" rename.
Also in this merge: main's new convention (AGENTS.md) that an item does not edit
a shared document; the item's stale-document record for this change lives in
docs/notes/chat-close.md, and docs/cli.md, android/README.md and
internal/author/skill/references/operations.md are left to the docs-fold writer.
Checks after resolving: gofmt clean, go build ./... and go vet ./... clean, the
Go module passes, and the app's :app:assembleDebug and :app:testDebugUnitTest
pass (--offline --no-daemon).
Add a server-side close for operator chats, so finishing with a chat takes it out
of the active list for every client without deleting anything. The brokered
protocol gains chat_close and chat_reopen; chat_close stops a running turn by
reusing the existing broker interrupt (its result carries an interrupted flag, so
a stream is never left running into nothing) and then sets closed_at on the
session's operator_sessions row. The session, its transcript and its history
survive, and because the closed state lives in the registry chat_sessions reports
it to every client, not just the one that asked. An id that is not a recorded
operator session, including a pipeline-owned run session, is refused before
anything is written. chat_reopen clears the state again, and simply prompting a
closed session also clears it (the store clears closed_at on touch).
The registry gains closed_at for a fresh database and an idempotent migration for
one created before it existed. The app renders closed sessions under a labelled
Closed section with a Closed chip, offers a Close action with a confirmation that
says it stops a running turn, marks the chat closed on every device and deletes
nothing, and a Reopen action on each closed row. The device-local hide is renamed
Hide on this device, with a snackbar saying the chat stays on the server, so it is
never confused with the real close. No new dependency, the installer and Docker
files are untouched, and no run is started from the app.
Checked before committing: the packaged templates carry no chat surface and need
no update, and internal/author/install.go's managed inventory needs none either
(this adds no reference file). The packaged authoring skill reference
internal/author/skill/references/operations.md and the shared docs/cli.md and
android/README.md are stale because of this change, but an item no longer edits a
shared document: what is stale and what should change there is recorded in
docs/notes/chat-close.md for the docs-fold writer, which is committed here with
the change.
Checks: gofmt clean, go build ./... and go vet ./... clean, and
go test ./internal/protocol/... ./internal/pipeline/... ./internal/server/...
./internal/author/... pass. The app side is verified with :app:assembleDebug and
:app:testDebugUnitTest (--offline --no-daemon, BUILD SUCCESSFUL); the on-device
close, second-client and reopen check is deferred to visual review.
Not deployed; deploying is the operator's step.
Replaying b808158 removed ui/components/LabelChip.kt: that commit predates
e2147b0, which extracted one shared LabelChip for the chat panes, so the older
diff carried the file's deletion. Restored from the commit before the replay; the
build and the full unit suite pass again. A cherry-pick's deletions need the same
scrutiny as its conflicts.
The search results panel replaces each row's text type badge (LabelChip,
removed) with a glyph derived from the result kind and, for an artifact,
from its content type. The artifact branch reuses the gallery's own
artifactKind/artifactIcon mapping in ui/graph/ArtifactType.kt instead of
a second table, and the glyph's contentDescription carries the kind in
words so a screen reader hears what the icon cannot show.
The panel's header gains the runs list's FilterMenu and SortMenu: a kind
filter (All kinds, Pipelines, Runs, Steps, Fields, Artifacts, Versions)
that sends the server's SearchRequest.kind verbatim, and Relevance /
Newest / Name sorting. The server's search takes no sort, so Newest and
Name order the results in hand and say so ("Sort results in hand", the
collapsed summary's "(in hand)"); no Prompts option is offered because
the server's search kinds cannot produce one. The chosen kind and order
persist via SettingsRepository, surviving query changes and streaming.
Tests: OmniSearchResultsTest covers the per-kind and per-content-type
glyph (checked against the gallery mapping), the kind label, filter
narrowing, Relevance/Newest/Name ordering with ties, and the empty-state
line; ArtifactTypeTest covers artifactKindLabel.
Checked before committing:
- Packaged templates: none describes the app's search panel; unchanged.
- README/topic docs: android/README.md gains the "Search type icons, a
kind filter and sorting" section; docs/cli.md and docs/ui-ux-review.md
describe only the TUI/server search, so they stay accurate and are
unchanged.
- Packaged authoring skill references: internal/author/skill/references/
contains no Android search-panel documentation (operations.md's "omni
search" is the TUI), so none needs updating; install.go's inventory is
untouched.
Evidence: gradle :app:testDebugUnitTest --rerun 433 tests 0 failures;
:app:assembleDebug successful, APK published to the run artifacts; the
API-27 NewApi lint errors are pre-existing and unrelated.
(cherry picked from commit b808158d499912e09872c31b5259205ee6cd8838)
Every client watching a session receives every frame any client's turn produces,
a prompt from any client is accepted and serialised per session (queued behind
the in-flight turn, acknowledged as queued), user messages are attributed to the
sending device's label, and a pending approval is a shared exactly-once object:
the first answer wins, is recorded, is pushed to every watching client, and a
later answer is refused. Supersedes the per-session claim and the Busy
read-only state.
No conflicts: main's chat-surface work (the in-flight tool work in ChatFormat,
ChatStore and ChatTranscript, run notifications, the status palette) sits in
different hunks from this branch's fan-out edits, and main did not touch
docs/cli.md. Checks re-run on the merged tree: gofmt -l . (clean), go build ./...,
go vet ./..., go test -count=1 ./... (all packages pass; the focused multi-client
tests fan-out, per-session serialisation, first-answer-wins, pending replay and
resync pass), and the Android unit tests
(gradle --offline --no-daemon :app:testDebugUnitTest, BUILD SUCCESSFUL, 598 tests,
0 failures).
A session was owned by one connection: the claim map in chat_claims.go let the
first client hold it, every other client saw the session Busy and read-only, and
a second client's prompt was rejected. Replace the claim with a per-session
"room" so the operator's phone, tablet and terminal all watch and write the same
conversation, and a pending approval is a shared, exactly-once object.
Server (internal/server, internal/protocol):
- New chat_room.go: one room per session holding the session's single broker
stream, its one bounded prompt queue (8) and the fan-out to every attached
client. A chat_subscribe frame attaches a connection to a session's shared
stream and replays the still-unresolved approval requests the room holds.
- chat_stream.go: handleChatPrompt accepts a prompt from any client. It attaches
the sender, either starts a turn or queues the prompt behind the in-flight turn
and acknowledges it with chat_queued:true ("queued" is the chosen behaviour,
stated on the wire and in docs/cli.md), and echoes the user turn to every other
client attributed to the sender's label. The prompt handler no longer owns the
stream; one turn runner per room drains the queue, so two turns never
interleave. Per-connection write serialisation is unchanged (each chatSub has
its own writer goroutine and bounded buffer).
- chat_permissions.go / chat_commands.go: an approval is reserved by the first
answer and confirmed once delivered; the first answer wins, is recorded with
the answering client's label, and the resolution is pushed to every watching
client as chat_permission with resolved/decision/resolved_by so their cards
clear. A later answer is refused with an error naming the client that answered,
and never reaches the agent twice; a reservation whose reply failed is
released.
- chat_hub.go / chat_sessions.go / chat.go: the hub now owns rooms and the
user-turn id sequence; the resulting user turns are retained (role and client
carried) so a reconnect re-syncs who said what. chat_sessions no longer marks a
session Busy and its clientID parameter is gone; the protocol keeps the Busy
field for wire compatibility only. websocket.go detaches a connection's chat
subscriptions when the read loop ends.
- chat_claims.go is removed, not left vestigial: the only exclusive thing left is
a turn, and the room's queue is that.
App (android):
- PipelinesRepository carries a stable per-device client label (Build.MODEL, with
a fallback) on prompts and replies, and adds chatSubscribe; AppViewModel
subscribes on opening a chat (best-effort, an older server's error frame does
not stop history loading) and records the queued ack.
- ChatStore folds a user frame from another client into the transcript once,
attributed by the sender's label, and never receives its own prompt back, so
the sender's own message is never duplicated. ChatThread.readOnly is gone:
canSend no longer depends on another client, the composer says "Queued - it
will send when the current turn finishes." instead of disabling input, and the
status label is Running/Idle only. Scroll/follow behaviour is untouched.
- Tests: ChatProtocolTest round-trips the new wire fields, ChatFormatTest asserts
the stale Busy flag cannot produce a read-only label, MultiChatStateTest asserts
a session another client watches stays writable.
Reflected where it belongs: no packaged template changes (no bundled starter
embeds the chat protocol). Checked the packaged authoring skill references: none
of them describes the chat wire beyond operations.md, and
internal/author/skill/references/operations.md is now stale - its "Brokered
OpenCode chat" section still says chat_sessions marks "busy" when another client
holds the session and that a second client's chat_prompt is rejected, and it does
not mention chat_subscribe, the per-session prompt queue/chat_queued, the
per-client label or the shared exactly-once approval (it also still describes the
per-subscription permission poller, which the room's single poller replaced). The
supported semantics are the ones in docs/cli.md, updated in this commit; the
operations.md section needs a rewrite to match. No README or other shared
document was edited here.
Checks run on the committed tree: gofmt -l internal cmd examples (nothing), go
build ./..., go vet ./internal/... ./cmd/..., go test ./internal/server
./internal/protocol ./internal/stage ./internal/pipeline.
A session said "Running" with an empty tool chip while it worked, so a silent
wait was indistinguishable from a stuck one. Derive the in-flight work from the
stream the app already folds and show it on both surfaces.
- ChatFormat: runningToolCalls() reads the tool parts still running, in
transcript order, so the conversation and the session row share one set;
toolDetail() takes the command/description the part actually carries (the
first of description/command/filePath/file_path/path/pattern/query/url),
collapsed to one line and elided at 72 chars, and returns null rather than a
fabricated summary; runningToolElapsedMillis() uses the protocol's own
time.ran/created when present and the local per-part stamp otherwise;
runningToolStamps() keeps a stable start per part across frames;
TOOL_LONG_RUNNING_MILLIS (60s) and toolLongRunning() mark an unusually long
call; sessionWorkLabel() names what a working session is doing while a
text-streaming turn stays plain "Running" and a busy session never reads
"Idle".
- ChatStore: ChatThread gains toolStartedAt, stamped when a part turns running
and dropped when it settles, plus runningTools/toolElapsedMillis; history()
and the frame fold maintain it; setRunning/turn end clear it.
- ChatTranscript: RunningIndicator lists one line per running call (name,
detail where present, live elapsed) keyed by part id so concurrent calls
render together without flicker; no percentage, ETA or progress bar.
- ChatListPane: the session row renders sessionWorkLabel(busy, thread).
- ChatRunningWorkTest covers name/detail/elapsed, clear on completion, error
state, concurrent calls and the no-detail stream.
Only fields the harness reports are used: tool name, state.status and input;
the live brokered frame carries no timing envelope, so elapsed falls back to the
local stamp. Existing chips, INPUT/OUTPUT, reasoning blocks, stop control,
activity marks and scroll/follow behaviour are untouched.
Checked and unchanged: no packaged template or packaged authoring-skill
reference describes this app surface (the chat references in
internal/author/skill/references/ document the server's brokered chat_* protocol,
which this change does not touch), so none is stale. android/AGENTS.md already
names ui/chat/ and its files. The shared documents this change does make stale
are recorded, not edited, in docs/notes/chat-in-flight-tool-work.md: the
Running-indicator and session-status statements in android/README.md.
The recovered commit gave every status one colour, but it predates main's split of the run
view and main's own cyan 'waiting' colour. Resolution: keep main's Waiting, keep the run
view's own file (main already has RunSummaryTab), and carry the parts that were genuinely
missing - RunState.Blocked and RunState.Skipped with their words, glyphs and one colour
each - so the palette and the enum agree.
A successful stage read amber in the Timeline because a visit's chip was
coloured from the graph's outcome palette (`graphColors`/`outcomeColor`) while
every other surface used the run-status palette, so the same word meant two
colours. This makes `RunStatusPalette` the single source of truth:
- `RunState` gains the server's own `Waiting`/`Blocked`/`Skipped` words, each
with a deliberate palette entry, a distinct material glyph and a label, so a
status is never colour alone and success is green / failure red everywhere.
- `graphColors()` takes success/error from `runStateColor(Succeeded/Failed)`;
`outcomeColor()` returns the shared status colour for any word that resolves
to a `RunState` and leaves `GraphPalette` only the graph-only flow outcomes
(`rejected`/`exhausted`/`retry`/`approved`/`fast`/`missing`; `blocked`/
`skipped`/`done` removed). The Timeline's `TimelineRow` uses the same factory.
- A visit's *outcome* stays distinct from the run's *status* by the chip's own
label and the row's state glyph, never a second colour.
- The runs-list failure diagnostic uses `runStateColor(Failed)` instead of a
scheme role that could drift from the chip above it; the status filter gains
`waiting`.
Tests: new `StatusColorConsistencyTest` (timeline colour comes from the runs-list
source; every state maps to exactly one colour) and extended `GraphPaletteTest`/
`RunStatusTest`. `gradle --offline --no-daemon :app:testDebugUnitTest
--rerun-tasks` -> 516 tests, 0 failures, 0 errors, 0 skipped.
Docs check: the root README and docs/ do not describe the Android status
colours; the packaged templates and internal/author/skill/references cover the
authoring surface and are unrelated, so nothing there needed updating.
android/README.md did enumerate the run states and claimed the graph outcome
palette was unchanged, so its features bullets were updated and a new "One status
colour everywhere" section added, with the old bullet marked superseded.
APK published to the run's artifacts as pipelines-debug-wip-d13f359.apk.
(cherry picked from commit a3caa734cd4769f42883b518d877dd0132ef57ae)
Every item wrote the shared, append-only docs (android/README.md, docs/cli.md and
the packaged skill references), so every merge conflicted on prose. Keep the duty
to notice stale docs; move the writing to one deliberate place.
- Per-item note, not a shared edit. An item that makes a shared document stale
writes docs/notes/<slug>.md - unique per item, so two items never touch the same
file - and commits that note with its change. It never edits a README, topic doc
or packaged skill reference itself.
- One writer. The manual-only docs-fold pipeline, bundled as the fifth starter
examples/docs-fold.md, folds every note under docs/notes/ into the shared
document it names and deletes the consumed notes in its own commit; an empty
notes directory is a success no-op. Operator trigger:
pipelines new "Docs fold" --template docs-fold --no-open; pipelines submit
<draft.md>; pipelines run "Docs fold".
- Implemented where the convention lives: orchestration.md (brief item 5, the
hard-constraint bullet, a "Single documentation writer" section and the
"Pipeline choice" committer bullet), the canonical committer checklist in
format.md (new step 6), the committer prompts in examples/task.md and
examples/three-stage.md, the new examples/docs-fold.md with its catalog and
README entries, and the repository guideline AGENTS.md. Test-expectation counts
(examples/catalog_test.go, internal/server/templates_test.go,
scripts/smoke-first-install.py) follow the fifth starter.
Reflected where it belongs: the packaged templates (examples/task.md,
examples/three-stage.md, the new examples/docs-fold.md), the packaged skill
references (orchestration.md, format.md) and the repo guideline AGENTS.md all carry
the new convention. No new reference file was added, so install.go's managed
inventory is unchanged. The shared descriptive docs were deliberately not
rewritten: this change makes README.md:191, docs/cli.md:170 and
internal/author/skill/references/operations.md:13 name four starters where there are
now five. Those stay as they are - correcting them now is exactly the per-item
shared edit this change removes - and the stale-doc note
docs/notes/docs-fold-single-writer.md records each one for the docs-fold writer to
fold. Nothing else needed updating. No new dependency; no Android, Gradle, server,
installer, Docker or published-definition change; no definition published over the
running pipelines.
Evidence: go test -count=1 ./... passed; go build ./... and go vet on the touched
packages clean; ./internal/author/... covers embedding, reference links, the managed
inventory and install/upgrade/protection; ./examples/... validates the fifth starter
and its manual-only, committer-terminated graph; ./internal/server/... covers the
served catalog. Not run: the docs-fold writer against the shared docs (nothing to
fold yet); no install or deploy.
(cherry picked from commit f29656cf084d7eee2e033f2a37a9d231d7acaaf0)
Brings this branch up to main (73284ff) so it can be merged back without
conflict. Main's two chat commits (ChatFormat/ChatTranscript reasoning into
one collapsible block) do not touch any of the notification files, so the
merge was clean with no conflicts to resolve. The merged tree keeps both
intents unchanged.
The app already had an in-app attention surface but nothing in the system
tray. This adds the app's own Android notifications for the two events that
need a person: a run waiting for a decision (highest importance) and a run
that failed. A successful, running or cancelled run raises nothing.
- RunAlerts.kt: the pure model. Maps the attention list's kinds to run
alerts, coalesces several into one grouped summary, dedupes one
notification per run+kind via AlertLedger (never repeated while the run
stays failed or waiting), clears on resolution/dismissal/arrival, and
decides the one-time permission prompt and tap destination. Unit-tested.
- RunNotifier.kt: the Android edge. Creates the single "Runs that need you"
channel, posts/clears through NotificationManagerCompat, and reports
notificationsAllowed() from POST_NOTIFICATIONS (API 33+) / the system
notification switch. Posted from the app's own process.
- Manifest: POST_NOTIFICATIONS runtime permission; PipelinesApplication
creates the channel before anything can post.
- SettingsRepository/AppViewModel: remembers that the permission was asked
once (never nags), keeps notificationsAllowed fresh on resume, feeds the
tray from the same attention flow, and clears a run's notification when
the operator arrives at it.
- PipelinesApp/DecisionPrompt/RunDetailScreen: the one-time rationale before
the system dialog, asked at a sensible moment (first run that needs the
operator, or first open of the attention surface), degrading to the
existing in-app surface on refusal; a waiting run's tap opens its decision
sheet (pipelines://run/<id>?action=decide), a failed run's tap opens the
run; reaching a run clears its notification.
- Attention.kt: drops the Finished kind so a successful run is never
announced on any surface (the operator's rule), keeps the deep-link parser
(now carrying an optional action) and still decodes an older state's
looked-at-finished set.
- AttentionTest.kt / RunAlertsTest.kt: the mapping (waiting and failed
only), the permission paths (granted, refused, not-yet-asked), coalescing
and clearing, dedupe, and the tap destination.
Checks: `:app:assembleDebug` and `:app:testDebugUnitTest --rerun-tasks`
pass (578 tests, 0 failures). Reflected-where-it-belongs check: this is an
android/-only change and the packaged authoring skill references and the
packaged templates describe the server's ntfy notification authoring, not
the Android app's tray, so none of them needs updating. No README or other
shared documentation file was touched.
A chat turn that reasoned several times now shows a single collapsible thinking
block (with its step count and elapsed time) instead of one box per reasoning
part, and a streaming turn grows that block rather than adding another.
The chat rendered every reasoning part as its own ReasoningBlock, so a turn
that reasoned several times stacked several thinking boxes between messages.
This folds a turn's reasoning parts into a single collapsible entry, anchored
where the turn's first reasoning part sits, so a streaming turn grows the
block it has instead of gaining another.
- ChatFormat.kt: add ReasoningTurn / turnReasoning (the ordered fold of a
turn's reasoning parts), reasoningLabel (counted wording for >1 steps, plain
one-block wording otherwise) and turnElapsedMillis (elapsed from the turn's
own part timing envelopes, null when unknown). ReasoningExpansion is now
keyed by the turn's message id via reasoningTurnKey rather than a per-part
key.
- ChatTranscript.kt: AssistantParts renders exactly one ReasoningBlock per
turn (first reasoning part wins the anchor); the collapsed line reads
"Thinking · N steps"/"Reasoning · N steps" when the turn reasoned more than
once, else "Thinking…"/"Reasoning", with elapsed time appended when known.
Streaming elapsed is driven by thread.runningSince so it matches the running
indicator. The answer, tool chips, diff cards, attachments and approval
cards are untouched.
- Tests: ChatTranscriptTest exercises the turn-keyed expansion; new
ChatReasoningTurnTest covers the fold (several parts -> one entry in order),
the collapsed wording, elapsed derivation and a streaming turn appending
into the same entry.
Checked for stale packaged artefacts: none needs updating. The packaged
authoring skill references (internal/author/skill/references/) document the
protocol (reasoning deltas, cost/token budgets), not the Android transcript
rendering, so nothing there describes per-part thinking blocks. No packaged
template mentions reasoning rendering. Shared docs / the Android area map are
left to the single documentation writer; nothing here changes documented
behaviour beyond the transcript fold.
Verified with the Android toolchain (no daemon): :app:testDebugUnitTest passes
567 tests, 0 failures, 0 errors, including ChatReasoningTurnTest (5),
ChatTranscriptTest (7) and DimensTest (2). No new raw geometry literals.
Main adds only documentation (per-area agent maps for the Android app, the TUI
and the server); the sweep-ui side holds the UI/UX sweep fixes. No overlapping
files, so both intents are kept unchanged.
Addresses the survey/review findings on the sweep-ui branch, reusing the
app's existing patterns and named tokens (DetailTabBody, formatLocalTimestamp,
stageCountText, ATTENTION_CHIP_RESERVE) rather than hardcoding values.
Fixed findings:
- n:1 attention-chip reserve (OmniSearchResults, ATTENTION_CHIP_RESERVE in
Dimens, PipelinesApp bottom content reserve).
- n:2 formatted local timestamps via the shared Format.formatLocalTimestamp
(PipelinesApp lists, RunHistory, RunSummaryTab, PipelineDetail).
- n:3 decodeHtmlEntities for the session export's HTML entities (Markdown),
with regression cases for entities and a bold-only line.
- n:4 Raw/Rendered control now labels the current view and its state
(SourceView).
- n:5 filters as a Material modal bottom sheet capped at a window-derived
filterMenuMaxHeight with a scrolling body (FilterMenu), plus tests.
- n:7 stage-count wording via the shared stageCountText helper.
- n:8 labelled key row on the template detail screen.
- n:9 stage pane de-duplicates identity / folds the definition.
- n:10 wide-flag plumbing into the destination lists and ChatListPane, which
now wraps its session list in DetailTabBody(wide, ...) so wide rows keep
DETAIL_MAX_WIDTH_DP centred.
- n:13 Settings: Disconnect is the filled primary while connected and the
trust warning moved into a surfaceVariant card.
- n:15 CodeBlock bounded height plus a scroll affordance with an unbounded
option.
Deferred findings (with reason):
- n:3 (Chat transcript) residual is server-side data: chat_messages returns a
single assistant part whose text is already interleaved/doubled, so the
renderer cannot close it. The android half (entities/Markdown) is fixed.
- n:6 Runs list titles arrive truncated to 80 chars mid-word from the server.
- n:11 Two-pane top-band layering is a product/design decision.
- n:12 48dp graph-node hit targets and label dodging are product decisions.
- n:14 The session-list chip is OpenChatStrip (open chats), not a list filter;
relabelling it would misdescribe it.
Commands: :app:compileDebugKotlin + :app:testDebugUnitTest (562 tests, 0
failures) and :app:assembleDebug all succeed.
Pure move: split the three multi-feature server files into per-concern files,
with no behaviour change - same package, same exported and unexported
identifiers, same call graph, same tests.
- internal/server/chat.go -> chat.go (broker seam, client token, dispatcher),
chat_hub.go, chat_claims.go, chat_permissions.go, chat_sessions.go,
chat_stream.go, chat_commands.go
- internal/stage/model.go -> model.go, model_run.go, model_failure.go,
model_validation.go
- internal/pipeline/runs.go -> runs.go (read side), runs_schema.go,
runs_create.go, runs_mutate.go, runs_sessions.go
Checked before committing:
- Packaged templates and internal/author/skill/references: neither refers to
internal/server/chat.go, internal/stage/model.go or internal/pipeline/runs.go,
so nothing there needed updating (the change is a move with no behaviour
change).
- gofmt -l on the three packages: clean. go build ./..., go vet ./... and
go test ./... pass. go.mod/go.sum unchanged.
- No test, docs, android/, install or Docker files touched.
Known stale path pointers deliberately left to the single docs writer (shared
docs) and out of scope (android/): docs/chat-verification.md and
android/README.md name the old file paths.
Combine the chat end-to-end verification record update (revision, APK
artifact, test totals and the 3ffc126..ec27a2d chat-surface delta) into main.
Docs-only; no behaviour change.
Update docs/chat-verification.md from the earlier `3ffc126` record to the
current revision `ec27a2d`, which is both this lane's HEAD and main:
- revision, APK name/size/sha256 and LAN URL refreshed to the rebuilt
artifact `pipelines-debug-wip-ec27a2d.apk` (18,585,084 bytes,
sha256 5ee4b38c…da84);
- unit-test totals refreshed to 61 suites / 558 tests / 0 failures, and the
server-side `go build ./...` plus the chat/session/adopt Go tests recorded;
- a "Changes since the previous record" section describing the chat-relevant
delta `3ffc126..ec27a2d` (the `chat_adopt` request, the lazy
`MarkdownBlocks` renderer, the run-watch scope change) and correcting the
chat protocol file path to `data/protocol/Chat.kt`.
The change is documentation only: no app or server behaviour changes.
Checked where the change belongs: packaged templates (no template encodes
this record) and the packaged authoring skill references
(internal/author/skill/references/) — none is made stale by a
verification-record update, so none is touched. `go build ./...` passes.
The debug APK lives in the run's artifacts directory outside the repo and is
therefore not committed.
Refs: brief "Verify the chat end to end, on the phone, against the real server".
main brought pushed run events (emitRun/RunEventFrame across protocol, server
and the Android client) and this branch brought per-run usage recording. Both
touch internal/server/runner.go; git auto-merged cleanly and the result keeps
both intents — each model step is stamped with its effective provider/model and
budget-derived usage (stageUsage, overlayEffectiveModels) while run events are
emitted (emitRun) and applied to the same step loop. No conflict markers, no
side's work discarded.
Post-merge checks: gofmt -l clean, go build ./..., go vet ./... and
go test ./... all pass.
Carry the usage a model stage already measures for its budget
(stage.Budget.Snapshot()) onto the step as typed evidence and total it in
one pass, rather than a second harness read, a transcript parse or an
output-length estimate. A shared budget across stage revisits records only
the visit's increment, and a revisit that observes no new report records no
usage instead of a fabricated known zero.
- protocol: StageUsage/RunUsage/TotalUsage and UsageTotals.
- pipeline: step_usage table + migration, COALESCEd into the one step
projection, FinishStep persistence, one json_extract history aggregate,
retention removes the rows with their run.
- server: stageUsage maps the budget snapshot, stamping per-stage model and
usage for every model stage (including failures).
- cli: inspect/stats human and JSON output.
- budget/pi: retain the reported in/out split, mark a total-only (Pi) report
split-unknown, and keep an unreported cost unknown (never zero).
Evidence and docs updated in the packaged skill references and docs/cli.md;
the live database has no step_usage rows yet (all history predates this), so
per-run figures are reported as unavailable, not zero.
The Android client subscribes to run events for every workspace its runs list
displays (the blank "any workspace" scope the server already honours) instead
of only the configured workspace, so a run executing in a lane worktree - a
different workspace - now delivers frames. A pushed frame carries the run's
pipeline identity (pipeline_id, name, title, version), so the runs-list fold
inserts a never-seen run and the pipelines list, run detail, timeline and stage
cards all follow a run finishing and a new one starting without a refresh, with
no per-event fetch. Server-side workspace isolation and coalescing are unchanged.
Combines this lane's "make every view live from the pushed run events" change
(android + server run-event scope and frame identity) with main's operator
chat brokering work (opencode endpoint adoption, protocol/settings/CLI chat
support, operations reference). The two touch different files; git's ort
strategy merged them cleanly with no conflict markers and nothing to resolve.
Post-merge checks: go build/vet and go test ./... all pass; gradle
--no-daemon testDebugUnitTest assembleDebug passes (558 tests, 0 failures).
The pipelines list (and every other run-state view) kept the row it had when
the screen was last fetched. Two class-level root causes, fixed here:
- The app subscribed to run events scoped to the one workspace the operator
configured, so a run executing in another workspace (a lane worktree is its
own workspace) never delivered a frame: the rows only changed on a manual
refresh. The app now asks for the blank "any workspace" scope the server
already treats as any (ALL_WORKSPACES in AppViewModel.subscribeRuns, blank
default on PipelinesRepository.subscribeRuns). Workspace isolation on the
server is unchanged: an explicit workspace scope still matches only that
workspace (TestRunEventWorkspaceIsolation); the new
TestRunEventAllWorkspacesSubscription pins the blank "any" scope.
- foldRunEvent refused to insert a run the list had never held, returning
needsResync and leaving the list untouched, so a run started after the
screen loaded appeared only after a fetch. The pushed frame now carries the
pipeline identity a row needs (RunEventFrame.PipelineID/Name/Title/Version),
so the fold inserts the new run at the head from the frame's own identity
without a fetch and without reordering existing rows; a server that predates
those fields still falls back to the one resync. Added fields and why each
is needed: pipeline_id (row's pipeline join), name (row title), title (the
stored operator-facing title a row shows), version (the row's pinned
version) - everything a RunSummary row renders, so no per-event fetch and no
guess from stale cache. The server stamps them on every emitted frame from a
per-run identity remembered at create/decide/cancel/resume (runner.go
runIdentity/rememberRunIdentity/stampRunIdentity), first-write-wins through
the coalescer (mergeRunEventFrame) and on the subscribe snapshot, so every
transition - created/queued, running, each stage start/finish, terminal -
carries them. Reconnect still resyncs once then follows pushes; the
pull-to-refresh path is untouched.
Checks run: go build ./..., go vet ./..., go test ./... (all packages ok),
go test -race -run 'RunEvent|RunEvents|Subscribe' ./internal/protocol/
./internal/server/, and gradle --no-daemon testDebugUnitTest assembleDebug
(558 tests, 0 failures, 0 skipped; BUILD SUCCESSFUL).
Packaged templates and the packaged authoring skill references were checked:
nothing there describes the run_event field list or the client's subscription
scope, so neither needs updating (references/notifications.md only says the
attention surface is derived from the pushed run events, which is unchanged).
Docs are a shared file owned by a single writer and were not edited:
docs/cli.md's description of the pushed `run_event` frame still enumerates
only the older fields (status, outcome, current stage, completed-step count,
timestamps, optional step) and is now incomplete - it should mention the
pipeline identity fields; docs/ntfy.md remains accurate.
Broker chat from an operator-supplied OpenCode endpoint (opt-in flag/env,
validated once, no fallback) with the endpoint choice recorded across restarts,
and add chat_adopt with the pipelines chat-adopt CLI command to continue a
session that already exists on that endpoint.
Add an opt-in way to broker chat from an operator-supplied OpenCode service
instead of the instance the server spawns for itself, and a way to adopt a
session that already exists on that endpoint so it appears in chat_sessions and
can be continued from the app.
- Endpoint selection: the `-opencode-endpoint` server flag (defaulting to
`PIPELINES_OPENCODE_ENDPOINT`) opts in; precedence is explicit flag >
explicit environment > the endpoint recorded on a previous run, with the
spawned instance as the default. opencode.OpenEndpoint validates the
reference once (http(s), host, no userinfo/query/fragment/path), detects the
backend from its own /api/info (v2) or /global/health (v1) contract, and
requires a streamable text/event-stream event path. It owns no process
(Close is a no-op) and never calls startServe; every failure names the
endpoint and disables chat rather than silently falling back. An
authenticated endpoint takes an optional password only through the private
file PIPELINES_OPENCODE_ENDPOINT_PASSWORD_FILE, with
PIPELINES_OPENCODE_ENDPOINT_USERNAME overriding the detected default.
- Persistence: the validated choice is recorded in an additive single-row
server_settings table so a restart with no flag/environment reuses it; an
unreachable recorded endpoint disables chat with a clear message and no
fallback.
- chat_adopt: a new protocol request (ChatAdoptRequest) with handleChatAdopt in
internal/server/chat.go. It refuses a nil broker/registry/payload and a
blank or foreign-shaped id before any endpoint call, reads the endpoint via
the shared Chat.Session (which reuses Sessions/decodeChatSessions), records
through the existing RecordOperatorSession with the endpoint's directory and
title verbatim, and echoes the adopted session plus its registry row like
chat_create. A missing id is refused naming the id and records nothing; an
endpoint record with an empty directory is refused rather than substituting
the server's working directory or home.
- CLI: `pipelines chat-adopt <session-id> [--json]` (usage, notes, help
inventory, dispatch) with docs/cli.md updated under Chat sessions.
- Autostart preserves the endpoint variables (and the password-file reference,
never an inline secret) via serviceEnvironmentKeys.
Checks before committing:
- Package location: the change is user-facing chat behaviour, so the packaged
authoring skill reference internal/author/skill/references/operations.md is
updated in the same change (Brokered OpenCode chat section) with a dated
verification-evidence entry and the not-deployed state. No new reference file
is added, so internal/author/install.go's managed inventory is unchanged.
- Packaged templates: this repository packages no template set for this
behaviour and none references the chat endpoint, so no template needs
updating.
- Verification: `go build ./...`, `go vet` on the touched packages, `gofmt -l`
clean and `go test ./...` all pass. The unit tests cover the endpoint
validation/precedence, the adopt happy path and refusals, the recorded
endpoint round-trip, the protocol round-trip and the CLI dispatch. The live
scratch-server check against the operator's real endpoint was not run in this
change.
Nothing unrelated is staged; docs left stale (README and other shared documents)
are not edited here and are for a single folding writer.
Lands the Android reader for the per-stage session export: a Session section in
the stage detail that appears only when the visit's session_export actually wrote
a file, renders the markdown export with the app's existing markdown renderer
(lazy, off the main thread), offers the html export in a WebView via a toggle, and
reports a failed fetch as its own in-pane error without hiding other sections.
The server-side export already landed in 016c39c.
Add a Session section to the stage detail that appears only when the visit's
session export actually wrote a file, beside the artifacts it was written with,
and opens the transcript on a click like any artifact.
- Derive the section from the recorded `session_export` matched against the
step's artifact listing (`sessionExportFiles`), so a visit with no export - a
non-OpenCode harness, an export failure, or a pre-export server - lists no
empty section, mirroring internal/protocol/runs.go and the server's export.
- Default to the markdown export rendered with the app's existing markdown
renderer (new lazy `MarkdownBlocks` reusing `MarkdownBlock`), and when both
files exist offer the html export through an "HTML view" toggle in a WebView
for fidelity; html is the default only when markdown is absent.
- Behave like the artifacts around it: the same Scaffold/TopAppBar/back chrome,
the shared ArtifactBytesCache so the file is fetched once and never loaded
twice, decode/parse off the main thread so a several-hundred-kilobyte session
stays responsive in a lazy block list, and a failed fetch shown as its own
in-pane error without hiding the other sections.
- `SessionExport` protocol model and `RunStep.session_export`, with the
unit tests for section presence, fetch/render, fetch failure isolation and a
large session.
Checked the packaged templates and the packaged authoring skill references: the
session export's server-side behaviour is already documented in
references/delivery.md and references/operations.md (landed with the server
change), and no packaged reference or template describes the Android stage
pane's sections, so none of them needs updating for this client-only change.
Verified before commit (recorded by the independent code review on this tree):
compileDebugKotlin, testDebugUnitTest (forced rerun) and assembleDebug all
BUILD SUCCESSFUL, 554 tests / 0 failures across 61 classes, SessionExportTest
9/0/0.
Lands the session-export feature: a finished OpenCode-harness stage writes its
real session into its own step artifacts directory as session.md and
session.html, served by the existing artifact listing and URL path, with
bounded source and rendered output, a visible truncation banner, recorded
session_export evidence and failure isolation that never fails the stage.
Every OpenCode-harness model stage now writes its real session into its own
step artifacts directory as session.md and session.html, so the existing
bounded artifact listing, the /artifacts/<run>/<step>/<name> serving path and
the artifact scan find and serve them with no special casing, while the stage
keeps its bounded preview in the run record unchanged.
- internal/opencode/export.go adds the one shared native export invocation and
the exact session-ID/messages validation used by both Connection.Messages and
the new ExportSession, so the readback path does not diverge. The backend's
published subcommand is used (v1 `export <id>`, v2 `session export <id>`),
the source read is capped at 8 MiB, and a larger session is read as a prefix
and reported truncated instead of failing. boundedOutput.ReadFrom keeps the
cap effective so overflow and the truncation path are real.
- internal/stage/session_export.go renders markdown and html with a metadata
header, every role and every part (unknown part types as raw JSON, every
session text escaped in html), atomic temp+rename writes that never overwrite
an existing file, a visible truncation banner at both ends when the source or
the 2 MiB rendered cap cuts it, and an honest 0-message header for an empty
session rather than fabricated text.
- protocol.SessionExport and RunStep.SessionExport are stored in a new
step_session_exports table (CREATE TABLE IF NOT EXISTS, so an old database
gains an empty table with no migration) loaded through the existing main
SELECT alongside the other per-step evidence and deleted by run retention.
- internal/server/runner.go exports after the post-stage filediff capture and
before scanArtifacts, with context.WithTimeout(context.WithoutCancel(ctx),
10s); it never waits for session idleness and a failure or a Pi stage (no
native export path) records a sanitized diagnostic and continues, never
changing the stage status, outcome, target, timing or result validation.
Reflected where it belongs: the packaged skill references
(internal/author/skill/references/operations.md and delivery.md) carry the new
Session export rules and the run-artifacts bullet, and docs/stage-artifacts.md
documents the names, the <run>/<step> paths, the served URL, the caps, the
truncation labels, failure isolation and the Pi limitation. The packaged
templates (examples/*.md) only tell a stage to save its own artifacts and say
nothing about the server-written session export, so none needed updating; no
new reference file was added, so install.go's managed inventory is unchanged.
Shared documentation: README.md's per-step artifacts sentence is now stale - it
should name the exported session alongside images, screenshots, reports and
logs. It is deliberately not committed here; the shared documents are folded by
the single documentation writer.
Checks: gofmt -l on the touched packages produced no output; go vet ./...
passed; go test -race -count=1 ./... passed.
Add docs/chat-verification.md, the required record for the chat verification brief: per-flow table (flow, result, evidence path, notes), the known tree-level gaps, and the section on what could not be verified and why. Verification only; no app behaviour changed.
Checked: packaged templates (internal/author/skill/references/) do not mention this record - no template or skill reference needed updating. Shared README and topic docs are intentionally not touched (single-writer fold).
Pure move of RunDetailScreen.kt (847 -> 342) and PipelinesApp.kt (1003 -> 405)
into files by concern with no behaviour change: five run tabs plus the header,
and the destination pill and destinations separate from the shell that hosts
them. Same package, same composable names and signatures, same call graph and
rendering; only private -> internal visibility widenings. Verified with
:app:assembleDebug and the unit suite (545 tests, 0 failures).
Brings main's retention store/CLI, review-contract and notification work
(internal/pipeline, internal/cli, internal/server, internal/author/skill/
references) together with this branch's pure move of the Android run view and
app shell into files by concern. No overlapping paths, so no conflict; the
merge was clean and the run/shell split is unchanged.
Pure move of two oversized Android UI files into smaller files by concern,
with no behaviour change:
- RunDetailScreen.kt 847 -> 342: the run header and ConfirmDialog stay; the
five run tabs move out to RunSummaryTab.kt, RunGraphTab.kt,
RunFieldSectionsTab.kt, RunEvidenceTab.kt and RunTimelineTab.kt.
- PipelinesApp.kt 1003 -> 405: the shell/scaffold, NavHost and hoisted state
stay; the destination pill and the three destinations move out to
DestinationBar.kt, PipelineDestination.kt, RunsDestination.kt and
TemplatesDestination.kt.
Same package, same composable names and signatures, same call graph and
rendering. The only textual edits are eleven private -> internal visibility
widenings on declarations now called across the new file boundaries. No
strings, colours, spacing tokens, tests or entry points changed.
Verified with `gradle :app:assembleDebug --no-daemon` (BUILD SUCCESSFUL) and
`gradle :app:testDebugUnitTest --no-daemon` (545 tests, 0 failures, 0 errors,
0 skipped).
Checked packaging that could go stale with this change:
- internal/author/skill/references/ (the packaged authoring skill references):
none mention these files or any Android UI symbol, so nothing to update.
- packaged templates: not touched and none reference the split files.
- android/README.md: its historical prose still names some now-stale file
locations; left unedited because the shared documentation is folded by a
single writer and this commit's job is the move itself.
Brings the definition-level review-loop control change and its server tests into
main: the reviewer advisory -> next stage edge for non-blocking notes, the
blocked_retryable -> implementer self-edge bounded by {"max_visits":5}, and the
unchanged rejected -> implementer limit. No production Go code changed; the new
internal/server/review_contract_test.go and the shared test seams cover it.
Keeps this branch's advisory review edge, bounded blocked_retryable implementer
edge and their tests alongside main's run-attention/ntfy notification work, the
split of the Android chat conversation screen, and the retention/history changes.
No conflicts: the two sides touch disjoint files.
Cut the review loop's repeat cost and make a blocked stage actionable, at the
definition level only, with the runner's existing visit counting and caps.
The published maintenance, quick and focused pipelines gain a reviewer
`advisory -> next stage` edge for non-blocking notes, so an advisory-only review
continues the run instead of buying another implementer visit; `rejected ->
implementer` and its unchanged {"max_visits":3,"on":["rejected"]} limit keep a
must-fix finding looping and still terminate. The implementer gains
blocked_retryable -> implementer with {"max_visits":5,"on":["blocked_retryable"]}
for a transient environment/tooling/device problem a fresh attempt could
survive, while blocked -> #failure stays terminal. The cap is at least the
reviewer's rejection budget so the implementer's own pre-execution cap cannot
preempt the reviewer's rejected control.
No production Go code changed. New tests in internal/server/review_contract_test.go
cover advisory-only never revisiting the implementer, must-fix still looping to
the reviewer limit, the implementer cap not preempting the reviewer, retryable
blocks bounded then failing closed, a retry that recovers, and a terminal block
failing immediately; concurrency/control/human tests share the new submitRunner
and startRun seams.
Documentation checked: internal/author/skill/references/control.md and
docs/harnesses-and-control.md carry the new edges and the visit-cap rule;
no packaged template defines these pipelines (they are published immutable
versions), and docs/model-results.md needs no change because the {outcome,output}
result contract is unchanged. README and other shared docs deliberately untouched.
Verified: go build ./... and go test -count=1 ./... pass.
Residual limitation: the must-fix-vs-advisory split is carried by the prompt
contract, not a machine-readable marker, because the recorded findings have none;
a model that still returns rejected for advisory-only notes would still buy a
visit. All 18 recorded implementer blocked runs classify terminal, so the
blocked_retryable edge recovers 0 of them.
Move ui/chat/ChatScreen.kt (1864 lines) into ten files by concern with no
behaviour change: ChatScreen.kt keeps the destination and the shared chat
geometry tokens (84 lines); ChatListPane, ChatCreatePane, ChatOpenStrip,
ChatConversationPane, ChatTranscript, ChatComposer, ChatToolCalls,
ChatDiffCard and ChatApprovalCard take the session list, new-chat picker,
open-conversation strip, conversation header, transcript, composer, tool
chips and the cards.
Pure move: same package, same composable names and signatures, same call
graph. The only substantive edits are per-file imports and private->internal
widenings needed for the cross-file calls; review confirmed identical
declaration sets and an equal line multiset. :app:assembleDebug and the full
unit suite pass (545 tests, 0 failures, 0 skipped) and the built APK is
byte-identical (same sha256) to the published artifact.
Checked before committing:
- Packaged templates: this repository carries no packaged template tree, so
nothing to update.
- Packaged authoring skill references (internal/author/skill/references/):
none reference the chat UI internals; nothing to update.
- android/README.md still cites ChatScreen.kt inner declarations
(ChatScreen.MessagePart, rememberElapsedMillis, ChatConversationPane) that
this move relocated; left unedited for the single documentation writer.
Lands lane-app2's pill-standdown work: the floating destinations pill is hidden
while the Chat destination shows an open conversation and stays everywhere else,
with the bottom reserve tracking the drawn pill so content neither jumps nor
leaves a gap. Includes the lane's merge of main and its tests.
Brings main (c5b0de1) into the pill-standdown lane. Main added the whole-title
run view / two-line list rows (RunIdentity, RunTitlesTest) and the readable
conversation work (ChatFormat, ChatScreen, ChatStore, ChatTranscriptTest). Those
are disjoint from this lane's destination-pill change, so the Kotlin sources
auto-merged; only android/README.md conflicted, where both sides appended a new
dated section to the end of the item log.
Resolved android/README.md by keeping both intents: the lane's "Destination pill
stands down in an open conversation" section and main's "Run title readability"
section are both retained, in that order. No conflict marker remains and nothing
from either side was discarded.
Verified after resolving: gradle :app:testDebugUnitTest --offline --no-daemon ->
BUILD SUCCESSFUL, 60 suites / 545 tests / 0 failures / 0 errors / 0 skipped; and
gradle :app:assembleDebug --offline --no-daemon -> BUILD SUCCESSFUL.
The floating destinations pill was drawn over the bottom of every screen,
including an open chat, where it sat on the composer and the newest message
and competed with the send/stop controls. It now stands down while the Chat
destination shows an open conversation and stays everywhere else, unchanged.
- One rule: `destinationPillVisible(currentRoute, conversationOpen)` is false
only for `chat` with an open conversation. `conversationOpen` is the new
`AppViewModel.conversationOpen`, a distinctUntilChanged boolean derived from
the same ChatStore the chat surface renders, so a background chat never hides
the pill elsewhere and a streamed delta never recomposes the app shell.
- The space, not just the pill: `destinationPillReserve(pillVisible)` returns
the named DESTINATION_PILL_RESERVE while drawn and 0.dp while hidden, so the
content Column clears a drawn pill and leaves no empty band when it is gone,
and no frame reserves a gap behind a hidden pill or draws one over content it
does not clear. Keyboard-open and the IME padding are unchanged.
- Escapability untouched: the top-bar "Back to chats" arrow, ChatScreen's
PredictiveBackHandler and SlidingPaneStack.onPopTo remain the way out.
- No other pill behaviour changed: destinations, selection indicator,
morph-into-search and every other screen are as before.
Checked for staleness: none of the packaged templates or the packaged authoring
skill references (internal/author/skill/references) mention the destination pill,
so no template or reference needed updating for this Android-only change.
Tests: PipelinesNavTest gains thePillStandsDownOnlyWhileAConversationIsOpen and
theReserveTracksTheDrawnPillSoContentNeitherJumpsNorLeavesAGap.
Fix two honesty gaps in run-history retention that the implementer stage
left uncommitted on top of 14175eb:
- Populate RemovedRuns, RemovedRunCount, RemovedArtifactFiles/Bytes and
Applied right after the row transaction commits, before staging cleanup.
A cleanup failure must not report a successful row/artifact removal as
zero removed, and staging leftovers are excluded from SpaceReclaimedBytes.
A failed VACUUM after removal now reports the artifact bytes actually
removed while claiming no database pages.
- Stage artifacts through os.Stat instead of os.Lstat so a symlinked
artifacts root is followed: the report sized that directory, so apply
removes through it too instead of counting bytes it never deleted.
Tests cover post-commit staging-cleanup failure reporting, staging through a
symlinked artifacts root (including no staging directory left in the link
target), and an honest reclaim failure after removal.
Checked documentation surfaces:
- docs/cli.md: measured example refreshed with the current before/apply/after
output and the symlink/staging/VACUUM reporting described accurately.
- README.md: retention prose (explicit, never automatic, protected runs,
artifacts go with the run) is unchanged and still correct.
- internal/author/skill/references/operations.md: operator-only retention
summary describes the same behaviour; no user-facing surface changed, so
no reference update was needed.
- Packaged templates: retention is a CLI/store capability with no template
change, so nothing to update. internal/author/install.go inventory
unchanged (no reference added or renamed).
Verification: gofmt clean on the touched Go files, git diff --check clean,
go vet ./internal/pipeline clean, and go test ./internal/pipeline -run
'TestRetention' -count=1 passing.
Nothing told the operator that a run was waiting for a person or had failed; they
found out by going looking. A run that needs attention now reaches the ntfy they
already run, and the app answers "what needs me now" in one live, ordered surface.
Server (smallest change, reusing the existing publisher):
- internal/server/notify.go adds notifyRun, called from finishRunState (failed)
and when a run parks on a human (runner.go runLoop). It publishes to the same
already-configured `system` destination through the unchanged stage.PublishNtfy,
so there is no second publisher, topic or service and the token handling is the
stage's own. runAttentionEvent maps only waiting and failed; queued, running,
succeeded, canceled and interrupted publish nothing.
- No storms: runner.attentionSent records sequence:event per run before publishing,
so a run that stays waiting is never republished on a re-request or restart, and
a stage notify policy that already covers the same event marks it first so the
run-level default is suppressed. The set is dropped when the run is terminal. A
delivery failure is logged, never fails the run, and is not retried.
- The payload names the run and pipeline and carries a click action
pipelines://run/<id> (validated: absolute URL, no userinfo, no fragment, no
credentials). PublishNtfy gained the optional click parameter; existing callers
pass "".
App:
- AndroidManifest/MainActivity declare the pipelines://run/<id> deep link
(singleTop); runIdFromDeepLink parses it and PipelinesApp opens that run once,
clearing the link. It opens a run; it starts nothing.
- ui/Attention.kt is the pure model (status -> Decision/Failed/Finished or
nothing, ordered by kind then newest-first) and ui/components/AttentionSurface.kt
is the floating indicator plus bottom sheet. It is derived from the same run
events the server already pushes, so an entry appears with no refresh and clears
when resolved; a finished run clears once looked at, and any entry can be
dismissed, persisted in SettingsRepository. The existing destinations, pill and
bottom strip are untouched and no competing navigation surface is added.
Checked before committing:
- Packaged authoring skill references: internal/author/skill/references/
notifications.md documents the automatic run-attention notifications and the
app surface. The only packaged "template" carrying notify is that reference; no
pipeline definition template exists to update and install.go's managed file list
is unchanged (notifications.md already existed).
- Repository guidelines: docs/ntfy.md gains an "Automatic run-attention
notifications" section and no longer claims "No block means no notifications";
the top-level README phone-notifications note now says a waiting/failed run
notifies automatically; android/README.md gains the dated feature section and
supersedes the previous section's note that the attention surface was absent.
- docker.md, install docs and the CLI/TUI docs describe mechanisms this change
does not alter; left as they are.
Tests: go test ./internal/server/... ./internal/stage/... ./internal/author/...
all ok; notify_test.go covers the event mapping and the real HTTP delivery
(destination, topic, click, no duplicate). Android :app:testDebugUnitTest ->
BUILD SUCCESSFUL, 58 suites / 531 tests / 0 failures (new AttentionTest, 13 cases,
covering ordering, appearing from a push, clearing on resolution, dismissal, the
empty case, persistence and the deep link). Device screenshots and the phone's own
notification are visual review's per the brief's device policy.
Scope: android/ plus the smallest server change; no new dependency, no run started
from the app, no installer or Docker change.
Merge lane-chat4 (d13f359, "make a run's title readable: whole in the run
view, two lines in the list") into main (cd87982, "answer a run's waiting
human decision from the phone"). Both intents are kept.
Conflict resolution:
- android/README.md (the only conflicted path): kept both sections, HEAD's
"Answer a waiting human decision from the phone" first and lane-chat4's
"Run title readability" second, with nothing removed. Each heading appears
exactly once.
- StageDetailPane.kt and RunDetailScreen.kt were changed on both sides and
auto-merged: the staged tree carries the incoming title line budgets plus
the local DecisionPrompt wiring (the stage pane surfaces a decision only
for its own stage; the run detail surfaces it above the tabs).
- The remaining incoming files (RunIdentity.kt, RunHistoryScreen.kt,
RunIdentityTest.kt, RunTitlesTest.kt) and the local files are one-sided and
taken whole. The staged tree differs from HEAD by exactly the incoming
diff and from MERGE_HEAD by exactly the local diff, so no side was dropped
or duplicated.
Checks (JDK 17, ANDROID_HOME=/Users/alan/Library/Android/sdk, Gradle 9.7.1
--no-daemon --offline):
- gradle :app:testDebugUnitTest :app:assembleDebug -> BUILD SUCCESSFUL.
- 59 result XMLs aggregate to 530 tests, 0 failures, 0 errors, 0 skipped;
RunTitlesTest 4/0 and RunIdentityTest 6/0.
No conflict markers remain.
Staleness check: the incoming work is android/-only. android/README.md is
the topic doc and now carries both sections; no packaged template, the repo
README, the other topic docs, or the packaged authoring skill references
describe this run-title UI, so none needed updating (the delivery reference's
Android build/publish example is unchanged and still accurate).
A run's title is derived from its prompt, so it is often long. Give it the
room it needs where the operator reads the run, and a deliberate clamp where
it is one of many. Android only; no new dependency (the declared
material-icons-extended only), no Pipelines server/Go/installer/Docker file
touched, and no run started from the app.
- Run view shows the whole title. The run-summary title line states its
intent with RUN_VIEW_TITLE_LINES (Int.MAX_VALUE) and TextOverflow.Clip, so
it wraps over as many lines as it needs and is never ellipsised; the
fixed-height M3 app-bar copy stays a compact one-line label.
- Runs-list rows grow, then clamp. RunRow's title went from maxLines = 1 to
RUN_ROW_TITLE_LINES (2): a longer title takes a second line before it
ellipsises, with the glyph, status chip and meta line still aligned and the
selection highlight and tap target unchanged.
- Stage-pane context line. StageDetailPane's run-label line went from
maxLines = 1 to STAGE_RUN_LABEL_LINES (2); the pane is compact context, not
where the whole title lives.
- Named budgets. ui/RunIdentity.kt holds the three budgets so the choice is
deliberate at each call site. RunTitlesTest (4 cases) pins them and asserts
a clamping place is never more generous than the run view; RunIdentityTest
gained a case that runLabel/runIdentity never shorten a long title.
Checked for stale copies: android/README.md gained a dated section for this
change (its existing "Run title beside the pipeline name" section still holds,
it just did not describe line budgets). The top-level README and docs/ do not
document the app's run-title rendering, and the packaged templates and
internal/author/skill/references/ packaged skill describe Pipelines authoring
and Android APK delivery, not this UI, so none of them needed updating.
Evidence (JDK 17, Gradle 9.7.1 --offline --no-daemon): :app:testDebugUnitTest
BUILD SUCCESSFUL, 57 classes / 513 tests / 0 failures / 0 errors / 0 skipped
(RunTitlesTest 4/0, RunIdentityTest 6/0); :app:assembleDebug BUILD SUCCESSFUL,
app-debug.apk 18,486,624 bytes sha256 2b23762b54f0..., published as this run's
pipelines-debug-wip-2bc00a2.apk and served at
http://10.0.0.75:8080/artifacts/278/4/pipelines-debug-wip-2bc00a2.apk.
Combine the reviewed Android work already on main (conversation reading:
markdown, collapsed reasoning, one identity) with the incoming lane's
"answer a waiting human decision from the phone" change (the waiting
run/step sync, HumanDecision/DecisionPrompt, the decide_run envelope and
the waiting RunState) over merge base d48175a.
The only conflicted file, android/README.md, now carries both sections
exactly once ("Conversation reading: markdown, collapsed reasoning, one
identity" and "Answer a waiting human decision from the phone") with no
bullet or paragraph dropped. The auto-merged Kotlin tree carries both
features; no conflict markers, duplicated blocks or dead code remain. The
resolution also restored the blank line between the two README sections.
Verified on the merged tree (JDK 17 from Homebrew openjdk@17,
ANDROID_HOME=/Users/alan/Library/Android/sdk, offline, no daemon):
- gradle :app:testDebugUnitTest --rerun-tasks -> BUILD SUCCESSFUL; JUnit
XMLs total 58 suites / 525 tests / 0 failures / 0 errors / 0 skipped.
- gradle :app:assembleDebug -> BUILD SUCCESSFUL;
app/build/outputs/apk/debug/app-debug.apk present (18,519,392 bytes).
Docs check: android/README.md records the resolved change. No packaged
template, README/topic doc or packaged authoring skill reference describes
the Android decision surface or changed as a result, so nothing there
needed updating. Nothing was deliberately left uncommitted.
A human stage parks its run on a person, and the terminal client could answer
it while the app had no decide request at all. This adds the missing piece so a
waiting run is answerable from the phone.
Protocol/repo:
- PipelinesRepository.decideRun sends the same `decide_run` request the CLI and
TUI build: stage (optional; the server infers it), option, optional feedback,
with the exact wire names internal/protocol/message.go declares. Message gains
the stage/option/feedback fields; no second mechanism is invented.
- A waiting run/step now forces the existing push-driven full get_run
(runDetailNeedsFullSync), so the waiting step's recorded options/prompt
surface live with no refresh and no server field added.
- RunState.Waiting (label "waiting", FrontHand glyph, violet palette entry)
makes the waiting state honest in the list and summary.
UI:
- DecisionPrompt is the one shared surface: a "Waiting for your decision" card
with a deliberate Decide action, plus the sheet showing the run and waiting
stage, the author's instructions, every option as written with the label it
routes to, an optional feedback field, and a Confirm decision button that is
disabled until an option is chosen. It sits above the run detail's tabs and at
the top of the waiting stage's pane, reachable from where the operator already
is.
- Answering applies the returned run detail immediately, so the new stage shows
without a manual refresh. A refusal keeps the sheet open with the server's own
message verbatim and silently re-reads the run rather than faking success.
- Pure helpers pendingDecision, DecisionOption, DecisionDraft (the confirm gate)
and decisionRefusalMessage; Tests: HumanDecisionTest and DecisionTest (13 new)
plus waiting cases in RunEventsTest and RunStatusTest.
Scope: android/ only. No server/Go/installer/Docker change, no new dependency
(the glyph is from the already-declared material-icons-extended), no run started
from the app, no adb or device use.
Reflected where it belongs: android/README.md gained the dated feature section
for this change. Checked and needing no update: the packaged pipeline templates
(the change touches no pipeline definition), the repository's top-level README
and docs/ topic docs (none enumerates the app's operations or the decide
protocol; the TUI/CLI wording they carry is unchanged), and the packaged
authoring skill references (the decide protocol is unchanged and already
documented; no reference describes this app surface).
Combine the reviewed chat work already on main (session model in the
header, agent mirroring, chatHeaderMeta, tagged-label intent) with the
incoming lane's "make the conversation readable" change (markdown/part
rendering, collapsed reasoning, one conversation identity,
openChatsBeside, ChatTranscriptTest) over merge base 5ac196c.
Both intents survive in every conflicted file: android/README.md,
ChatFormat.kt, ChatScreen.kt (session header and conversation header),
ChatStore.kt and the new ChatTranscriptTest.kt. No conflict markers or
duplicated blocks remain.
Verified on the merged tree (JDK 17, ANDROID_HOME=/Users/alan/Library/Android/sdk,
offline, no daemon, --rerun-tasks):
- gradle :app:assembleDebug -> BUILD SUCCESSFUL
- gradle :app:testDebugUnitTest -> BUILD SUCCESSFUL; JUnit XMLs total
512 tests, 0 failures, 0 errors, 0 skipped (7 in ChatTranscriptTest).
Docs check: android/README.md already records the resolved change, and no
packaged template, README/topic doc or packaged authoring skill reference
describes the Android chat surface, so nothing there needed updating.
Fix the three reading problems in the chat conversation view. Android only;
no new dependency (the declared material-icons-extended only); no server,
Go, installer or Docker file touched and no run started from the app.
- Markdown reaches the transcript. Assistant text already went through
MarkdownText inside a private composable; name the decision as the pure
ChatFormat.partRendering(part) (MARKDOWN/REASONING/PLAIN/HIDDEN) and have
MessagePart consume it. Text outside the renderer's documented subset and
unknown part kinds still render as their own text (PLAIN); blank parts
render nothing (HIDDEN).
- Reasoning collapsed by default. ReasoningBlock is now one compact, muted
line per part (icon, label, chevron) that expands on tap to the muted
text. Expansion is hoisted to the conversation pane as the pure
ReasoningExpansion set keyed per stable part key, so a part keeps its
state across scroll/disposal and every part starts collapsed in a newly
opened chat. A running turn's streaming reasoning stays collapsed under a
live "Thinking…" label, signalling progress without competing with the
answer.
- One identity in the header. ChatFormat.conversationHeader(thread) builds
the app-bar title plus only context (labelled kind chip from the server
tag, activity, directory, model); the app bar and the context line read
the same value. openChatsBeside drops the active chat from the open-chat
strip so its title is shown once; every other open chat stays one tap
away and the session list is unchanged.
Tests: new ChatTranscriptTest (7 cases) plus the existing ChatFormatTest —
the markdown subset reaches the renderer from a ChatPart, text outside the
subset and an unknown kind still render, reasoning starts collapsed and
toggles per part, the header names the session once, and the strip offers
only the other open chats.
Checked, and none needs an update: the packaged templates carry no Android
chat surface; the repository guidelines (README, docs/) document the server
and CLI, whose behaviour is unchanged — docs/cli.md's note that Android
rendering of the tag is out of scope for the server change still holds; and
the packaged authoring skill references (internal/author/skill/references/)
describe delivery/verification generally, none of which this UI change
alters. android/README.md records the new behaviour.
Verified: `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon
--offline --rerun-tasks` → BUILD SUCCESSFUL; JUnit XMLs total 508 tests, 0
failures, 0 errors, 0 skipped. app-debug.apk sha256
0df6899429a8f5632ec568340dddb63a5617b1a04af19f52c6ebb793470a0b23.
The conversation header showed only the thread title, so inside a chat there
was nothing saying which model was answering. It now renders a second line
from server-reported values only.
- ChatFormat.kt: add chatHeaderMeta(thread), joining the reported model, the
session's kind tag and the directory with " · "; blank parts are omitted so
no model is ever claimed when the server did not report one. Refactor
sessionTagLabel to a tag-value overload so the list row and the header share
one tag mapping.
- ChatStore.kt: ChatThread gains the tag field; sessionsLoaded and open fold
the server's model/agent/tag into already-open threads, and ensureThread
seeds them, so the header never shows a stale or missing model.
- ChatScreen.kt: the conversation top bar title becomes a two-line column with
the meta line in the shared pipelinesText().meta role; the create flow states
plainly that this server has no request for choosing a chat's model.
- No model chooser is shipped. The server forwards no model/agent on
chat_prompt and exposes no model/agent catalogue, so shipping a picker would
be a control that does nothing; android/README.md records the exact server
change it would need.
- Tests: ChatFormatTest covers chatHeaderMeta (reported model/tag/directory,
and never claiming an unreported model) and the shared tag mapping;
ChatSessionManagementTest covers the open thread carrying the reported
model/agent/tag and a list refresh folding a new model in.
Checked before committing:
- Packaged templates: none exist (the author package embeds only skill/SKILL.md
and references/*.md; no *.tmpl/*.template in the tree) - nothing to update.
- Repository guidelines: android/README.md updated with the change and its
evidence; the root README and docs/ describe the server and CLI, not the
Android chat surface - no update needed.
- Packaged authoring skill references (internal/author/skill/references/): none
describes the Android chat surface - no update needed.
android/ only, no new dependency beyond the declared material-icons-extended.
Treat a failure to reach the harness before any prompt or tool call is
admitted (connecting or creating the session) as a distinct retryable
reach failure, so a transport blip at the first stage no longer ends a
mutating run; keep post-admission readback/poll/agent failures retried
only on an explicit read-only stage and never replay admitted tool work.
Preserve the true cause when the context is already done (join ctx.Err
with the typed transport error) and report a sanitized unknown provider
error name/status instead of a blanket summary.
Make the isolated format-repair deadline proportional to the stage
timeout (floored, capped and clamped to remaining minus a margin) so a
slow-but-repairable result is recovered without ever extending the stage
deadline; the bounded ladder, value guard, deny-all formatter session,
cumulative usage accounting and no-tool-replay rule are unchanged.
Update docs/model-results.md, docs/pipeline-performance-review.md and the
packaged skill references; add stage, opencode and server fixtures.
With a day's sessions the list was a flat, unsearchable wall in recency
order, so the chat the operator wanted was the one that could not be
found, and sessions of one repository were scattered through it.
Narrow the list as the operator types and keep same-repository chats
together, using the control and empty-state patterns the other lists
already use:
- ChatListFilter.kt adds the one pure derivation: sessionMatchesQuery /
filterChatSessions match a case-insensitive substring over a session's
title and directory, a blank query narrows nothing, and the survivors
keep their incoming (recency) order. groupChatSessionsByDirectory groups
the narrowed list by directory, each group keeping that order and the
groups ordered by their first (most recent) session, so the top still
leads with the newest activity.
- ChatState.sessionQuery (set through ChatStore.searchSessions /
AppViewModel.setChatSessionQuery) is a display narrowing only: the
server's list, open conversations and the activity marks are untouched.
filteredSessions is visibleSessions narrowed by the query.
- ChatListPane renders the existing FilterMenu with one OutlinedTextField
and a Clear search reset (the pipelines/runs filter pattern), shows a
directory heading per group only when more than one directory is
present, and renders the shared EmptyState ("No chats match ...") with
a Clear search action when nothing matches. The trailing New chat
action is never hidden while the list is narrowed, and every row still
shows its directory.
Tests (ChatListFilterTest, 9 cases): the match rule over title and
directory, that a narrowing preserves the recency order, grouping by
directory (order by the first session, order kept inside a group, a
single directory yields one group, a blank directory groups too), and
through the store that searching narrows filteredSessions, clearing
restores the full list, the server's list is untouched and a filtered
session still reports its activity mark.
Checked before commit: android/README.md was updated in this change with
the behaviour, tests and evidence. The packaged authoring skill references
(internal/author/skill/references/) document the Pipelines server, its
chat_* protocol surface and authoring, none of which changed - this is a
client-side narrowing over the already-listed sessions - so none needed
updating, and the internal/author/install.go managed reference inventory
is unchanged. No repository template or root/topic doc describes the
Android session list, so none was stale.
android/ only; no dependency added beyond the already-declared
material-icons-extended; no run is started from the app.
With several operator sessions the list gave no sign of where a reply
arrived: an idle chat and one streaming a reply right now looked the same,
so the operator lost the conversation they were in.
Add a per-session read state that the session list derives from data it
already receives, and render it as a three-state activity badge:
- ChatSeenState (ui/chat/ChatSeen.kt) keeps a per-session recency watermark
(the newest updated_at the operator has read) plus the ids that moved on
while the app was open. It is persisted as one opaque JSON preference
(SettingsRepository chat_seen, observed by AppViewModel.observeChatSeen),
the same way ChatSessionOverrides is, so the marks survive a restart and
not only a reconnect.
- ChatState.isUnseen marks a background session that carried a live mark
(a pushed chat_event/permission frame) or, if never opened here, is newer
than its stored watermark; first sight of a session is seeded to its
current recency so a pre-existing chat is not reported as new. Opening,
activating and closing a conversation reads it and clears the mark;
history for the active chat advances the watermark to the newest server
message. No server request is added.
- ChatFormat.sessionActivity(running, unseen) is the one pure derivation
(streaming outranks finished-unseen, which outranks idle) and
SessionActivityBadge renders it as Streaming/New/Open beside the
unchanged kind chip and directory line. Most-recently-used order is
untouched.
Tests (ChatActivityTest): unseen is marked, opening clears it including in
the persisted state, the derivation distinguishes streaming/finished-unseen/
idle, and the seen state survives an encode/decode into a fresh store.
Checked before commit: android/README.md was updated in this change with the
behaviour, tests and evidence. The packaged authoring skill references
(internal/author/skill/references/) describe the Pipelines server and its
chat_* protocol surface, neither of which changed - this is a client-side
derivation over existing frames - so none needed updating, and the
internal/author/install.go managed reference inventory is unchanged. No
repository template or root/topic doc describes the Android session list,
so none was stale.
android/ only; no dependency added; no run is started from the app.
Let the operator attach one or more files to the next chat message and send
them with it. The platform multi-document picker returns content URIs; the app
resolves only each file's name, size and MIME (confirming it can be opened) and
holds the attachments per chat, exactly like the draft. Nothing is read or
transmitted until the message is sent.
- Composer: an attach action, a strip of removable chips (image thumbnail or
file glyph, name, size, remove), and a send that is blocked while any
attachment is flagged.
- Wire: one shared builder, ChatProtocol.promptRequest(sessionId, text, files),
carries the attached URIs on the chat_prompt frame, in attachment order and
omitted for a text-only prompt so that shape is unchanged.
PipelinesRepository.chatPrompt takes the same list.
- Transcript: a sent turn carries each attachment as a ChatProtocol.PART_FILE
part, drawn through the existing UserParts -> FilePart display path rather
than a second rendering.
- Honest failures: an unreadable or over-24-MiB file is attached with its reason
and blocks the send; a server rejection takes the optimistic bubble back out
and returns the files flagged with the server's message. Attaching never
transmits on its own, and attachments clear once the message is sent.
Review follow-ups in the same slice: the composer now uses ui/Format.kt's
humanBytes instead of a duplicate formatter; optimistic user-turn ids come from a
monotonic counter so removing a rejected turn cannot re-mint a live key;
restoreAttachments keeps a file attached between send and rejection; the
thumbnail decode catches Exception rather than Throwable.
Checks made for this commit:
- The change is android/ only; the server, its Go source, the installer and the
Docker files are untouched, no run is started from the app, and no dependency
was added beyond the already-declared material-icons-extended.
- Packaged authoring skill references (internal/author/skill/references/): no
update needed. operations.md documents the brokered chat server, which this
change does not alter; the server still stores user turns as text and ignores
the prompt's files, so that reference stays accurate.
- Packaged templates (internal/tui, internal/server) and the root README/topic
docs: no update needed; none describes the Android chat composer. The
Android-facing documentation lives in android/README.md, which this change
updates with the attachment slice, its known server-side gap and its tests.
Tests: ChatAttachmentTest (5 cases), ChatAttachmentStateTest (5 cases) and a new
ChatProtocolTest case cover building the request with attachments (and omitting
them for a text-only prompt), removing one, the unreadable and oversized paths,
which files travel with the prompt, the optimistic turn's file parts, clearing
after send, and the rejected path restoring the files flagged. Verified by the
review stage with gradle --offline --no-daemon :app:testDebugUnitTest
:app:assembleDebug -> BUILD SUCCESSFUL, 487 tests / 0 failures / 0 errors /
0 skipped.
Opening a conversation used to start at the top, so the operator first had to
scroll down past everything already said to find the current turn. The
transcript now opens at its newest message, follows it while the operator reads
the newest part, and offers a jump-to-latest affordance when they have
deliberately scrolled up instead.
- Opening at the newest message. The transcript's list state is created the
moment the conversation first has content, with its first visible item set by
chatFirstScroll (ui/chat/ChatScroll.kt): a position the operator left is
restored and clamped with the app's shared rule (restoredScrollAnchor), and
every other conversation starts at its newest item. "A position of their own"
is explicit now: ChatThread.scroll is nullable, null meaning the operator has
never left a position here, so a chat left at the very top
(ChatScrollPosition(0, 0)) is restored rather than mistaken for "new", and a
list state that never held content saves nothing. Placement is unanimated, on
the list's first measure, and goes through the one scroll path below.
- One scroll path, changed deliberately. The existing follow scroll, the app
bar's approval jump and the new jump-to-latest all go through
LazyListState.scrollToEnd(itemCount, animated); when the newest item sits
entirely below the fold it is brought in first, and any part still below is
then closed by exactly that distance (closeBottomGap). An item already partly
visible is only gap-closed, so following a growing stream never bounces. The
distance is measured against the transcript's content count
(chatBottomDistancePx), not the layout's stale count, so an item appended
ahead of the measure that shows it actually arrives in view.
- Follow while reading the newest part. Only the operator's own drag changes
following (a DragInteraction.Start stops it, a settling Stop/Cancel resumes it
at or within the threshold, chatFollowsAt); while it holds, an arriving
message, a streamed delta, a tool chip, a freshly arrived approval card, a
grown composer or the appearing keyboard re-follows smoothly. The item count
is read at use time (rememberUpdatedState) so a captured count cannot go
stale. Programmatic scrolls never touch the list's interactionSource.
- Threshold. CHAT_FOLLOW_THRESHOLD_DP (ui/theme/Dimens.kt) is 32dp: about one
comfortable line of text.
- Jump to latest. A small Material 3 SmallFloatingActionButton (the
already-declared KeyboardArrowDown icon, on the shared gutter token) is offered
only while the view is not following and there is genuinely something below the
fold (chatShowJumpToLatest), hidden at the bottom or for an empty transcript;
tapping it re-engages the follow. A pending permission/approval is still
brought into view as the existing code did - it is the transcript's last item,
so the follow brings it in while the operator reads the newest part, and the
app bar's approval action still jumps straight to it.
android/ only: no dependency added beyond the already-declared
material-icons-extended, no run is started from the app, and no Pipelines
server, Go source, installer or Docker file is touched.
Checks: the packaged authoring skill references need no update - they document
the Pipelines server's own contract, not the Android client, and this change is
app-side only, so nothing in them became stale. There are no packaged templates
in this repository. The repository's topic doc for the client, android/README.md,
is updated in this change with the flow, the threshold, the one scroll path and
what remains unverified on a device.
Verified by the review stage on this tree: gradle --no-daemon
:app:testDebugUnitTest :app:assembleDebug -> BUILD SUCCESSFUL, 50 suites / 458
tests / 0 failures / 0 errors / 0 skipped (including the new ChatScrollTest, 11
cases), and the published APK matches the freshly built app-debug.apk
byte-for-byte.
Both sides are reviewed work and both are kept:
- android/app/.../ui/AppViewModel.kt: HEAD's live-run push wiring
(RunStreamState/_runStream, combine(connectionState, settings.workspace),
subscribeRuns/streamDown/resync, applyRunEvent, scheduleRunsResync/
scheduleRunDetailSync, observeRunEvents) together with lane-chat2's chat
management (ChatStore overrides, observeChatOverrides, refreshChatDirectories,
startNewChat/selectChatDirectory/cancelNewChat/createNewChat,
renameChat/removeChat/undoRemoveChat). The only textual conflict was the
import list; combine (HEAD) plus map and ui.chat.ChatSessionOverrides (lane)
are all kept and all used. No duplicated definitions.
- android/README.md: HEAD's "Live run updates from the socket" section and
lane-chat2's "Operator chat sessions: choose the directory, list only your
own" section are both present once, in file order.
- The rest of lane-chat2's chat files (ChatDirectories.kt, ChatOverrides.kt,
ChatStore.kt, ChatScreen.kt, ChatFormat.kt, protocol Chat/Message, repositories,
tests) merge cleanly on top of HEAD's work.
Documentation check: android/README.md is updated by this merge and its new
section is consistent with HEAD's. docs/cli.md and
internal/author/skill/references/operations.md already describe the server's
chat_sessions/chat_create/chat_directories surface this client builds on, and
the authoring skill (SKILL.md, references/) contains no Android-client behaviour
to stale, so nothing there needed changing and no packaged reference or
inventory entry was touched. No server, installer or template change is part of
this merge.
Checks (android/, Gradle 8.11.1, --offline):
- gradle :app:testDebugUnitTest --offline --rerun-tasks -> BUILD SUCCESSFUL;
test-results report 463 tests, 0 failures, 0 errors across 50 suites
(including ChatDirectoriesTest and ChatSessionManagementTest).
- gradle :app:assembleDebug --offline -> BUILD SUCCESSFUL (debug APK built).
Not verified here: on-device picker/rendering, which the visual-review stage owns.
Starting a chat now asks where first, and the session list is the operator's
own chats alone, told apart by the server's own tag.
- The create flow is a normal pane of the chat stack, not a modal: it loads
the server's chat_directories (home first, then the directories of previous
operator sessions, most recently used first) into the shared ListRow, each
with its full path, and starts on the operator's home
(directoryChoices/defaultDirectoryChoice). Back, the app-bar back control,
the footer Cancel and predictive back all leave it without creating
anything. chat_create is always sent the chosen directory (HOME_DIRECTORY
"~" for home, the absolute path for a recent), so a session is never
created in the server's working directory; the server resolves or rejects
it and its error is shown in the pane.
- The list renders ChatState.visibleSessions: exactly the server's
chat_sessions (operator sessions only) with the operator's own local
changes applied; the app adds no ownership guessing. Each row shows its
directory and the kind chip derived from the server's tag
(sessionTagLabel, "operator" -> "Operator"); another tag shows verbatim,
an untagged session shows no chip.
- The brokered protocol exposes no chat rename or delete (no
chat_rename/chat_delete type and no session endpoint), so both are
device-local and persisted with the other settings
(ChatSessionOverrides, KEY_CHAT_OVERRIDES): rename stores a local title
that wins on later list loads, and "Remove from list" hides the row and
closes its conversation with an Undo snackbar ("Removed from this list;
the chat stays on the server."). Nothing is deleted on the server.
- Messages, streaming replies, tool chips, diff cards, approval cards, stop
and the reconnect path are unchanged.
android/ only: no dependency added beyond the declared
material-icons-extended, no run is started from the app, and no Pipelines
server, Go source, installer or Docker file is touched.
Checks: the packaged authoring skill references need no update - the server
contract this builds on is already documented in
internal/author/skill/references/operations.md ("Brokered OpenCode chat",
committed with lane-chatsrv) and this change is app-side only, so nothing in
it became stale. There are no packaged templates in this repository. The
repository's topic doc for the client, android/README.md, is updated in this
change with the new flow, the honest local rename/removal and what remains
unverified.
Verified: gradle 8.11.1, JDK 17, --offline --no-daemon, from android/;
:app:testDebugUnitTest :app:assembleDebug -> BUILD SUCCESSFUL, 447 tests in
50 suites, 0 failures, 0 errors.
Replace the Android app's one-second run poll with the server's
workspace-scoped run_event pushes. The runs list, each pipeline row's
last-run line, the run header and the run detail (status, timeline,
stages, artifacts) now advance from the socket instead of polling or a
manual refresh.
- Wire: Message.kt mirrors internal/protocol/runevents.go (subscribe,
unsubscribe, run_event; RunEventFrame/RunStepDelta). The frames are
unsolicited and already arrive on the client's events stream;
PipelinesRepository.subscribeRuns/unsubscribeRuns add the typed
command, sent via a new PipelinesClient.sendOnly that does not hold the
send lock waiting for the running server's unreliable subscribe ack.
- One pure fold: ui/RunEvents.kt folds a frame into the list (in place,
order preserved) and the open detail with one shared status ladder and
one shared run-field merge. It is monotonic (a stale or duplicate
delta is dropped whole), reports needsResync for a run the list does
not hold instead of inventing a row, and only requests a full get_run
for a settled step or terminal run.
- Wiring: AppViewModel subscribes once per (re)connect and workspace;
every (re)subscribe re-reads the list and open detail once, because the
deployed server's subscribe snapshot is partial, then folds the pushes
on top. Re-reads are push-driven, coalesced and keyed so no push is
dropped and no timer remains. LiveBadge (RunStream.kt RunStreamState)
shows honestly live/reconnecting/not live, confirmed by the ack, a
push or a successful read and dropped when a read fails.
- ui/RunEventsTest.kt pins the delta sequence as pure cases: created run
not in the list, step started, step finished, run finished, unknown
run, duplicate/out-of-order deltas, and a reconnect resync.
- android/README.md records the change, the wire mapping and the
observed limitation of the running server (partial snapshot, no ack
within 30s), which the client tolerates without inventing a stream.
Checked where the change belongs: android/README.md gained this entry;
docs/cli.md described the Android app as still polling, which this makes
stale, so that sentence now says the app consumes the pushes while the
TUI still polls. The packaged TUI pipeline templates (internal/tui) do
not touch run-state refresh and need no change, and the packaged
authoring skill references (internal/author/skill/references) document
the authoring workflow, not the Android client's run updates, so none of
them needs updating.
Reviewed and approved by the run's review stage (build, unit tests,
Kotlin compile and lint in android/README.md); no merge/rebase/cherry-pick
was in progress and no conflict was present.
chat_sessions used to list exactly the OpenCode sessions the pipelines own,
filtered through pipeline.SessionOwner (run_steps/run_session_owners), so an
operator-created chat was an accident of the run-ownership table and the
operator's working sessions were mixed with the internals of running pipelines.
Add a first-class operator session:
- internal/pipeline/operator_sessions.go: a dedicated operator_sessions table
(session_id PK, directory, title, tag, created_at, last_used_at) with
RecordOperatorSession (upsert preserving created_at), a one-statement
TouchOperatorSession (no-op for a non-operator id), OperatorSessions bounded to
128 rows most-recently-used first, and OperatorDirectories (bounded MRU,
deduped). run_steps/run_session_owners and SessionOwner/OwnedSessions are
untouched.
- internal/server/chat.go: chat_sessions returns operator sessions only - it
reads the registry once, intersects it with one broker session-list call, fills
directory/tag/created/updated from the registry, sets busy for a session held
by another connection, keeps MRU order, and stays fail-closed (empty list, never
the endpoint's whole list). A pipeline stage session and an untagged row can
never be listed. chat_create resolves the directory (empty/'~'/'~/...' ->
operator home; relative or missing rejected before any OpenCode call), calls
broker.Create(title, resolved) and records the row with the operator tag.
chat_directories returns home first then bounded (8) deduped recents. A
successful prompt touches the operator session without affecting pipeline
prompts.
- internal/opencode, internal/protocol, internal/server/websocket.go and
message.go: unscoped session list, Create posts {"title":...,
"location":{"directory":...}} to POST /api/session, additive protocol fields
(omitempty) and the ChatDirectories request/response, plus the OperatorRegistry
option defaulting to the first store. One OpenCode transport per server is
unchanged.
Docs and references: docs/cli.md gains a "Chat sessions" section documenting the
operator-only fail-closed list, directory defaulting/rejection, chat_directories
(home first, deduped, bounded 8) and why a dedicated request was chosen.
internal/author/skill/references/operations.md's stale "Brokered OpenCode chat"
text (chat_create unbrokered, run_steps filtering, "listed the owned scratch
session" evidence) is rewritten to the operator-session registry, the fail-closed
filter, directory defaulting and the corrected live-test wording. No new
reference file, so internal/author/install.go's inventory is unchanged.
Checked for staleness elsewhere: README.md, the docs/ topic pages and the
packaged server/TUI templates carry no chat-session ownership claims, so none
needed updating.
Verified: gofmt -l clean; go vet and go build ./... clean; go test -count=1
./internal/pipeline/... ./internal/protocol/... ./internal/opencode/...
./internal/server/... and the full go test -count=1 ./... pass.
Combine the two reviewed versions of the Android artifact gallery/viewer.
- ArtifactViewer.kt: keep lane-c's gallery-wide paged full-screen viewer
(artifacts/index/configuredServerUrl/onIndexChange overload with paging
gestures, header, page buttons, share action and video-frame support) and
re-add HEAD's single-artifact overload (url/name/fetchBytes/onDismiss/video)
as a thin wrapper so StageVerdict still compiles and works.
- Artifacts.kt: keep lane-c's gallery-owned single viewer + onOpen callback and
compose HEAD's all-artifacts-as-tiles grid (media tiles open the paged viewer,
non-media open externally, selection and per-item share/copy preserved).
Checked: no conflict markers remain in any affected path. android/README.md
already carries the new "Page between artifacts in the full-screen viewer
(17 Oct 2026)" section documenting this change; the packaged templates, the
top-level README and topic docs, and the packaged authoring skill references
are not made stale by this Android-client UI change, so nothing further needs
updating.
The full-screen viewer becomes a pager instead of a single image with no
way to reach its neighbours.
- ArtifactGallery now owns the one viewer instance over pagedArtifacts(groups)
-- the grid's image artifacts in the order the grid draws them -- and each
tile opens the position it holds in that list via viewerIndexByUrl, so the
grid and the viewer derive their index from one source (previously a second,
untested per-tile counter and a per-tile viewer that had no neighbours).
- A horizontal drag or flick in ArtifactViewerBody moves to the previous/next
artifact: pagedIndex moves by one and clamps at both ends without wrapping,
a single-item gallery is inert, and canPageAtScale pages only at fit so a
zoomed image pans via the existing zoomAbout/clampImageOffset as before.
Previous/next IconButtons (disabled at each end) keep both neighbours
reachable without a swipe, and the header shows "N of M · type" while the
open artifact's own content, type icon, name and actions reload per artifact.
- Pure helpers pagedArtifacts, viewerIndexByUrl, pagedIndex, canPageAtScale and
artifactViewerPositionLabel are added to ArtifactViewer.kt; ArtifactViewerTest
covers next/previous, clamping at both ends, a single-item and an empty list,
a zoomed viewer that does not page, the paged order versus the grid's draw
order, and the per-artifact position label.
Placement check: the Android topic doc android/README.md is updated in this
commit with a section describing the pager, its gesture rule and the recorded
build/test checks. No packaged template and no packaged authoring skill
reference (internal/author/skill/references/*, internal/author/install.go's
inventory) documents the app's full-screen artifact viewer, so none needed
updating.
Only the four files this run changed are staged. The unrelated uncommitted
covered-pane statistics and list-load-phase edits (SlidingPaneStack.kt,
States.kt, Dimens.kt, LoadPhaseTest.kt) and the untracked scratch files in the
worktree belong to other changes and are deliberately left uncommitted.
Combine the two reviewed versions of docs/pipeline-performance-review.md.
- Local (main) review: the exact 201939-byte runs.json capture, the three
final_result_validation sub-shapes, and the 5-to-4 unresolved busy-wait
correction.
- Incoming (lane-t2) review: both captures (artifacts/222/2 and
artifacts/222/4), both stat snapshots (134 succeeded / 3 active and
135 succeeded / 2 active), plus the server-side rejection, deploy-wait,
device-lock and refined improvement-ranking analysis.
Checked: no conflict markers remain anywhere in the tree and the two sides are
composed without duplicated headings or dead text. This is a documentation-only
change to a dated analysis document; the packaged templates, the README and
topic docs, and the packaged authoring skill references are not made stale by
it, so nothing further needs updating.
Combines lane-go's typed omni search, launch-time model overrides, TUI
artifacts view, run-state websocket push, and the "reflect the change where
it belongs" committer rule with the Templates gallery, chat/omni-search and
other reviewed work already on main. The 12 files both sides touched keep
both intents composed rather than dropping either side: the omni search keeps
the typed search contract (CLI `pipelines search` and the TUI popup with type
badges and marked snippets) alongside the run-list quick filter; cli.md and
ui-ux-review.md document both the search rework and the artifacts view;
orchestration.md, harnesses.md and operations.md keep the model-override and
reflect-where-it-belongs guidance; and the protocol/CLI/server/TUI code keeps
the new search, run-event, override and artifacts paths alongside the existing
run, title and help surfaces.
Checks before committing:
- go build ./... -- pass
- go vet ./... -- pass
- go test -count=1 ./internal/... ./cmd/... -- all pass
Doc check before committing: nothing needs updating. The lane's own docs and
references (docs/cli.md, docs/ui-ux-review.md, and the orchestration,
harnesses and operations skill references) already carry the new features.
format.md and the packaged templates already describe the line-oriented result
format and the human decision stage from the earlier lane-go merge. The root
README already describes the omni search popup. Model overrides, the search
command, run events and the artifacts view are runtime/CLI/TUI surfaces that
cli.md documents; no template, README or topic-doc edit is required by this
merge.
The installed OpenCode 2.0.20 exposes the authenticated SSE event firehose at
/api/event and the /api HTTP surface, but Detect selects backend "v2" and Open
returned no owned process/URL, so chat stayed disabled and every chat_* request
was answered with "chat is not configured on this server".
Add opencode.OpenStream/OpenChat: for either backend they start the single owned
opencode serve process, discover the loopback URL and verify the backend health
contract (/api/info for v2, /global/health for v1). main and the live test share
OpenChat so the selection cannot drift. Chat now streams real incremental
session.text.delta/session.reasoning.delta frames via the existing
Connection.EventStream + NormalizeChatEvent, with no polling and no fake
streaming.
- Authenticate the owned endpoint with the per-backend user (opencode for v2,
pipelines for v1); the v2 server ignores OPENCODE_SERVER_USERNAME.
- Send the V2 prompt shape {"text":...}, which the v1 translation also accepts.
- Skip firehose event types the adapter does not surface before decoding their
data, so session.instructions.updated (delta is an object) no longer fails the
stream.
Unit tests cover the per-backend user, the prompt shape/auth, the captured real
V2 event shapes and the selection guards. An opt-in live test drives
chat_sessions/chat_messages/a completed chat_prompt/an interrupted chat_prompt
against the installed OpenCode. Update the packaged operations reference with the
realized capability, dated evidence and deployment state.
Checks before commit: the packaged authoring reference
internal/author/skill/references/operations.md is updated in this change; no new
reference file was added, so internal/author/install.go's managed inventory is
unchanged and the internal/author tests pass. No packaged template describes the
brokered chat surface, and neither README.md nor the topic docs under docs/ (nor
web/) document it, so none of them needed updating.
Combines lane-c's Templates gallery and detail view with the chat and omni-search work already on main (lane-t2). The three files both lanes touched keep both intents: AppViewModel.kt keeps refreshTemplates/createFromTemplate alongside the search/chat flows, PipelinesApp.kt keeps both the Templates and Chat destinations, and graph/Artifacts.kt adopts the shared galleryGrid fitting while keeping the tile-gallery refactor.
Doc check before committing: nothing needs updating. This is an android/-only merge. The app's topic doc (android/README.md) already documents the Templates destination (lane-c) and the Chat/omni-search work (lane-t2). The root README and docs/ describe the server CLI/TUI (whose :templates catalog is a separate surface) and are unchanged. The packaged authoring skill references (internal/author/skill/references/) mention the Android client only for APK-delivery mechanics, which this change does not alter, and the packaged templates are server-side and untouched.
The server's template catalog (the list_templates command) had no surface in
the app. This adds a Templates destination to the shared SlidingPaneStack: a
measured card gallery (name, short description, stage count and its own glyph;
one column narrow, a fitting grid wide) and a detail pane that reuses the
pipeline detail's Summary/Graph/Source tabs, plus a create-from-template action
that submits a create-only draft. Stage counts come from a source the server
parsed (validate); a source that does not parse is still viewable as raw
markdown.
Added: Templates.kt (TemplateEntry/TemplateCard, the grid-column and
stage-count mapping), components/GalleryGrid.kt (the shared measured-gallery
fitting, extracted from the artifact gallery), graph/SourceView.kt
(PipelineSourceView, the one rendered-definition view, extracted from
PipelineDetailScreen), screens/TemplateGalleryScreen.kt,
screens/TemplateDetailScreen.kt, TemplatesTest.kt.
Changed: PipelinesApp.kt (the Templates destination), AppViewModel.kt
(refreshTemplates/createFromTemplate), data/PipelinesRepository.kt
(listTemplates/validateSource/createPipeline), graph/Artifacts.kt (use the
shared galleryGrid), PipelineDetailScreen.kt (use the shared
PipelineSourceView), ArtifactGalleryTest.kt (exercise galleryGrid).
Doc/state check before committing:
- android/README.md (the app's topic doc): updated. Added a Features bullet for
the Templates destination and a dated "Templates: a gallery and a detail view"
section, matching the per-feature convention every prior android change uses.
- Packaged templates: not touched. The server's templates are Go-side and the
brief forbids touching the Pipelines server; this change only renders the
catalog the server already exposes.
- Packaged authoring skill references (internal/author/skill/references/): not
updated. They document the Pipelines harness, not the Android app, and this
change adds no harness runtime behaviour.
- Root README and docs/: not updated. They document the CLI/TUI/server, which
are unchanged; the Android app is documented in android/README.md.
No conflict was present: no unmerged paths and no unfinished merge, rebase or
cherry-pick, so nothing needed resolving.
Deliberately left uncommitted (other work this run did not touch, not staged):
the worktree's other WIP - components/ListScroll.kt and screens/PaneStats.kt with
their tests, and the uncommitted edits to components/SlidingPaneStack.kt,
components/States.kt, theme/Dimens.kt and components/LoadPhaseTest.kt - plus the
untracked .ui-review-*/ capture artifacts.
Bring the packaged starters and the pipelines skill up to the guidelines the
project now works to.
Templates:
- task and three-stage now end in a committer stage that stages the union of the
runner's captured input.server_changed_files and the producer's declared
changed_files, runs the repository's checks, commits locally and never pushes;
their producers no longer commit.
- Every model/agent prompt states the line-oriented result contract (outcome on the
first non-empty line, "# output" JSON map, other "# <heading>" sections kept
verbatim as evidence) and an "# evidence" section for exact commands and results,
with proportionate verification and no fabricated checks.
- Stages that can write save their reports, logs and screenshots into the runtime
artifacts directory.
- Remove the summary starter: a tool-free single-prompt text transform with no
repository interaction, artifact or commit is a format demonstration, not a
reusable workflow. No starter invents a pretend approval stage; a decision point
is a type=human stage.
Skill:
- references/format.md gains a Result format section (line form, legacy JSON
precedence, result_parse, raw-output.md, artifacts) and a Committer stages
section with the pre-commit checklist; the role-split and envelope notes mention
the line form and the committer.
- orchestration.md points at the checklist and records that a genuine gate is a
human stage; operations.md and the SKILL.md index drop the removed starter and
name the result format and committer. No new reference, so the managed inventory
is unchanged.
Docs/tests: examples/README, README, docs/cli, docs/first-version-testing, the CLI
help example and the smoke script track the four starters; catalog, tool-role,
server, tui and pipeline tests are updated, with a new test pinning the committer
ending and server-captured change set.
Commands run: go build ./...; go vet ./...; go test ./...; python3 -m unittest
discover -s scripts -p 'test_*.py'; python3 scripts/smoke-first-install.py. All
passed. Templates inspected through an isolated CLI server (pipelines templates;
pipelines template KEY --source). No server, service or device was restarted, and
nothing was pushed.
Expanding a stage section drew its rows stacked at the section's origin:
CollapsibleSectionBody passed the section's several field composables straight
into AnimatedVisibility, which lays out a single child, so the rows overlapped at
the top of the section and only the last was visible. The shared body now wraps
its content in one full-width Column, so any multi-row section stacks its rows
under its header.
Every stage section now opens as its own pane rather than growing the stage
screen inline:
- PaneState: add the Section pane level (MAX_PANE_DEPTH = 3) and a saved
sectionKey primitive, with backStep/popTo/encode/decode handling so one Back or
peek pops exactly one level and the open section survives rotation and process
death.
- StageDetailPane: the stage screen keeps a compact collapsed list of its
sections (Artifacts, Output, Input, This run, Stage definition); opening one
shows it as a full-window surface over the stage on a narrow window, or a panel
to the right of the stage pane on a wide one, with its own Scaffold/TopAppBar
title, its own scroll and its own top spacing.
- SectionHeader: a navigation mode for those rows - a static forward chevron
(mirrored for RTL) and an "Open <section>" action instead of a rotating
disclosure chevron and "Expand/Collapse", so assistive tech is not told the row
expands in place. The detail screens' disclosure rows are unchanged.
- DetailTabs: drop the rememberSectionExpansion initiallyExpanded seed, whose
last caller was the inline stage definition.
- Tests: cover the Section level's backStep, popTo, encode/decode and depth, and
the shared stageSectionSpecs order and blank-section cases.
Sections still start collapsed, the operator's choices still persist, and each
section's content is unchanged. android/ only; no dependency was added.
Also in this diff, from the covered-identity statistics work: PipelinesApp passes
compactStats = true on its two stacks (SlidingPaneStack's statistics flag).
The packaged authoring skill's orchestration reference now tells an author
to carry the check from the brief into the pipeline: before committing, the
committer verifies the change is reflected in the packaged templates, the
repository's guidelines (README and topic docs) and the packaged skill
references, updates anything stale, and states in the commit body what was
checked or that nothing needed updating.
- brief-writing section: add a "Where it belongs" item to the brief and
renumber the hard-constraints and publishing items.
- hard-constraints block: add a "Reflect the change where it belongs" bullet.
- Pipeline choice: extend the committer bullet with the same pre-commit
check, keeping the existing rule that the committer stages only the run's
changed files.
Checked before committing: the change is prose in the packaged skill
reference, so no template, README or topic-doc edit was needed; the eight
pipelines carrying a committer stage were republished with the same rule in
their committer prompt (not tracked in this repository); no other reference
is stale.
Add a server-pushed run_event frame so a client no longer has to poll
once a second to notice run changes.
- protocol: RunEventFrame/RunStepDelta compact delta (run id, workspace,
status, outcome, current stage, completed-step count, timestamps and an
optional single step delta), plus subscribe/unsubscribe/run_event types
and the optional RunEvent/RunIDs message fields. All fields optional so
older peers ignore them.
- server: runEventHub with per-connection subscriptions scoped to a
workspace (and optional explicit run ids), one bounded writer goroutine
per subscription, slow-subscriber drop, per-client subscription cap and
a ~220ms per-run coalescer that flushes pending deltas before a terminal
frame.
- runner: emit deltas on created/queued, queued->running and step start,
human waiting, step finish (outcome, target, diagnostic, artifacts and
completed count), terminal finish, cancel of a waiting run and
decide/resume; emitRun is a no-op without a hub.
- websocket: subscribe seeds current state before the ack, unsubscribe and
connection teardown drop subscriptions, and pushed frames reuse the
connection write closure.
- tests: protocol golden-JSON wire shape plus websocket coverage for the
started-run frame sequence, subscribe current-state snapshot, silent
unsubscribed/never-subscribed clients, workspace isolation and a
bounded coalescing frame count.
- docs: note subscribe/unsubscribe/run_event in docs/cli.md; TUI and
Android still poll in this release.
The Artifacts view re-clamped its scroll offset to the selected row on every
render, so the tail of the list - a trailing visit that recorded none (running
or finished) and its capture summary - could never be brought on screen, and
the image marker crowded out artifact names at narrow widths.
- Decouple the scroll offset from the selection: add PgUp/PgDn (and ctrl+u/
ctrl+d) paging, and make G/end select the last artifact and scroll to the
tail so a trailing visit stays reachable.
- Share artifactContent/clampArtifactTop/revealArtifactSelection between
selection and render so both agree on the same page.
- Show the [img] marker only while the width still leaves room for a usable
name, keeping columns aligned either way.
- Advertise the scroll keys in the artifacts footer help.
- Test the omitted-files capture wording, trailing-visit reachability via
G/end and page scroll, and narrow-width no-overflow; render both the top and
the scrolled tail in the env-gated live capture test.
- Update the packaged operations reference for the A artifacts view.
Protocol: replace the loose Query/Kind/Matches/Limit search fields with a Search request object and a SearchResults response, and have the server answer search from Store.Search over the shared run projections (runFrom/runStamps).
CLI: add the read-only 'pipelines search QUERY [--type KIND] [--limit N] [--json]' command with usage/help, and document the typed targets, ranking and bounds in docs/cli.md.
TUI: the '/' popup keeps type-to-search, up/down, Enter and Esc, renders one ranked list with kind badges and a bracketed (non-colour) match snippet, and Enter opens the matched pipeline, run, step, artifact or field; footer text updated to match.
TUI: add a dedicated run artifacts view ('A') with open/copy of recorded files, and move artifacts out of the run-detail File changes section (artifactCaptureNotes).
Tests: add Store.OpenReadOnly for read-only inspection of a live database plus pipeline/server/TUI search tests and artifacts tests, including env-gated live checks.
The committer staged only the implementer's self-declared changed_files,
so an incomplete declaration silently left part of the approved change
uncommitted. The runner already records the run's real changed paths by
comparing the working tree around each step; publish that set to the
committer.
- runState gains an unbounded, deduplicated, first-seen-ordered captured
path accumulator (capturedPaths/capturedSeen), distinct from the bounded
changedPaths sample used only by the UI-surface skip reason.
- recordChanges folds each captured FileChange path into it in the existing
single pass, so no second walk and no new I/O.
- publishServerChangedFiles writes the set into the input memory value as
input.server_changed_files, called before memoryInput so the binding
always resolves (an empty list when nothing was captured) and only stages
that select it receive it. rebuildRunState rebuilds it from persisted
completed steps, so a resumed run hands the committer the same evidence.
- Tests prove the committer receives the captured set distinct from and
additive to the implementer's declared changed_files, that an omitted
path is still present, and that the field is an empty list when nothing
was captured.
- control.md and orchestration.md document the reserved field and instruct
the committer to select input.server_changed_files alongside the declared
changed_files and stage their union.
Commands run: go build ./...; go vet ./...; go test -count=1
./internal/server/... ./internal/stage/...; go test -count=1 ./internal/author/...;
go test -count=1 -run TestCommitterReceivesServerCapturedChangedPaths ./internal/server/.
All passed. go.mod/go.sum unchanged.
A planner had no machine-readable view of the tool set later stages would
have, so it could emit acceptance checks that required tools (shell) the
implementer was not permitted, causing a blocked run.
modelPrompt now emits exactly one authoritative line naming the stage's
permitted tools, derived from the definition via the new effectiveTools
helper. effectiveTools reuses ToolNames: a present tools block, including
an explicit empty one, is returned as parsed; an absent block yields the
legacy mutating read/glob/grep/edit/shell bundle so it is never
misrepresented as empty or read-only. The bundle is declared once as
legacyTools and reused by tools.go, agent.go, pi.go and permissions.go.
The redundant client-side strings.Replace of the tools line is removed
from AgentClient.Generate and PiClient.Generate; the agent-only guidance
sentence is preserved by appending it in agent.go, and Pi appends a short
mapping line derived from piTools. Edit-scope and permitted-shell text,
routing, review, budgets and retries are unchanged.
Adds internal/stage/model_prompt_test.go covering explicit, absent and
explicit-empty blocks plus derivation edge cases, and a guard that the
agent prompt still carries the tools, edit-scope and shell-command text.
Add `pipelines run --model PROVIDER/MODEL` and repeatable
`--stage-model STAGE=PROVIDER/MODEL`, resolved with precedence
per-stage > whole-run > the model pinned in the pipeline version.
- A shared pure resolver (`pipeline.ParseModelOverride` /
`pipeline.EffectiveModels`) owns the precedence and validation: every value
must be a `provider/model` pair (`stage.ValidModel`), every stage key must
exist in the pinned graph, an unknown key fails naming the valid keys, and a
per-stage key that names a non-model stage is refused.
- The server validates against the pinned version before admission (no run row
is ever inserted for an invalid request), persists `model`/`stage_models` on
the run and `provider`/`model` on each step, applies the effective pair to a
clone of the stage definition so the stage and its repair/formatter path share
it, overlays the returned run graph with the effective pair (presentation
only), and reuses the recorded overrides on retry.
- The run record echoes the overrides it was launched with and each step records
the provider/model it actually ran with; the TUI Evidence pane renders that
effective pair. The pinned pipeline version and `show --version N` are never
modified.
- CLI help, `docs/cli.md` and the packaged authoring skill references document
the flags and the precedence. A TUI override picker remains a documented
follow-up; the CLI is the deliverable.
Tests: pure precedence/validation table tests, store round-trip and
request-key-mismatch plus migration, server admission/application/overlay/retry
with a controlled executor, CLI flag/help/malformed-value tests, and a TUI
evidence test.
A stage declaring a `skipped` outcome is short-circuited with no model call
when the run's recorded file changes and artifacts touch no UI surface
(android/, internal/tui/, a presentation extension or an image artifact).
The step is recorded completed/skipped along its declared edge with a
bounded one-line reason, so a backend-only run no longer pays for a
ui_reviewer generation that can only answer ui_applicable=false.
A covered pane's width is spent on the covered region (`identityWidth +
startInset`), and when a second level is covered `coveredEdgesDp` gives the
nearest identity that region less the thin older edge (`startInset + minTouch`;
the leading gesture inset cancels), i.e. `identityWidth - minTouch`. Flooring a
statistics-bearing identity at the full block alone (`MIN_COVERED_PANE_WIDTH_DP +
PEEK_WIDTH_DP`, 168dp) therefore left the nearest edge at 120dp, below the
`paneStatTier` Full boundary, so a pipeline's last-run/age and average lines were
filtered out at every depth a pipeline is ever covered. `coveredIdentityWidthDp`
now floors a statistics-bearing identity one touch target above the block
(`+ minTouch`), so the nearest edge is exactly 168dp and reaches Full, while the
single-covered and title-only cases are unchanged and the active pane width still
does not depend on depth.
The covered title also broke mid-word in a narrow strip ("Complete a Task" ->
"Complet"/"e a Task"). `wholeWordTitle` now packs the title greedily onto
whole-word lines and, once they are full, drops the remaining words and
ellipsizes the last line at a word boundary; a word wider than the whole strip is
the one exception, ellipsized to the width because it has no internal boundary.
It takes an injected `measure`, so the packing rule is unit-testable without a
device, and `PaneIdentity` measures with the same `cardTitle` role it draws with.
`PaneIdentityTest` adds the pure cases: the width-degradation tiers, the
statistics-bearing width floor, the nearest-edge geometry at depth 2 (which fails
without the `+ minTouch` reserve, so it pins the defect), and the whole-word
wrap/ellipsis/oversized-word/no-room cases. `android/README.md` records the
corrected geometry, the fix and the run's build/test evidence.
android/ only; no new dependency, no server field, and no server/Go/installer/
Docker change. Build and unit tests only (no device): 300 tests, 0 failures.
Back the TUI "/" popup with the server's search command and add a matching
pipelines search CLI command.
- protocol: SearchRequest/SearchResponse and per-kind SearchResult payloads,
one shared Label for the six-kind badge dispatch and RuneIndexFold for
case-insensitive matching.
- pipeline: the read-only, ranked, bounded Store.Search implementation.
- cli: search QUERY [--type KIND] [--limit N] [--json], printing the shared
label plus a text-field snippet when present.
- tui: type to search, up/down to choose, Enter to open and Esc to cancel over
one mixed ranked list, with short type badges and a bracketed non-colour
match marker; Enter navigates to the matched pipeline, run, step, field
section or artifact entry.
- tests: protocol and TUI coverage, including an env-gated live test against
the running server.
The soft-input comments in the manifest, PipelinesApp.kt and android/README.md
still described `adjustNothing`, a mode the activity no longer declares. MainActivity
uses `android:windowSoftInputMode="adjustResize"` and the app draws edge-to-edge, so
the Compose window inset (WindowInsets.safeDrawing) is the single source of the IME
geometry and is applied once by the surface that owns it.
- AndroidManifest.xml: rewrite the soft-input comment to describe adjustResize, why
the app is edge-to-edge and reads the IME from Compose window insets, and warn
against changing it without re-checking the chat composer.
- PipelinesApp.kt: correct the bottom search column comment that claimed the activity
declares adjustNothing and the window is never resized for the IME.
- android/README.md: correct the omni-search results-panel section that claimed the
IME inset was counted once because of adjustNothing; now records the declared
adjustResize mode, the edge-to-edge single source of IME geometry, and the chat
composer's imePadding.
Documentation only; no rendered surface or behaviour changes. The omni-search entry
point and pill morph already exist at this HEAD; this reconciles the stale wording
with the committed mode.
Integrates eight commits of reviewed chat work: the Chat destination with
several conversations, markdown transcripts, tool-call chips with an expandable
INPUT/OUTPUT panel, edit diff cards, the composer's stop control, and approval
cards. The automated resolver failed on this merge repeatedly (its own stages kept
dying on the malformed-result defect), so it was integrated by hand.
Integration decisions:
- Pill geometry: main's tokens win. lane-app2 carried private duplicates of
DESTINATION_ITEM_SIZE/GAP and a private DESTINATION_PILL_RESERVE, added before the
geometry-token migration; those duplicates are dropped in favour of the theme
tokens main already exports.
- IME mode: kept lane-app2's adjustResize for the window, because the chat composer
and the search field both raise the keyboard and the chat UI was reviewed with it.
- Protocol and view-model constants: both sides' independent additions are kept.
- ChatScreen now passes the compactLabel main's SlidingPaneStack gained, and the
literals lane-app2 introduced before the token discipline are converted to five
new named tokens (HAIRLINE_DP, ICON_BUTTON_SMALL_DP, TOOL_PANEL_MAX_WIDTH_DP,
CHAT_TITLE_MAX_WIDTH_DP, CHAT_BUBBLE_MAX_WIDTH_DP) rather than allow-listed.
Verified: assembleDebug plus the full Android unit suite (409 tests) pass,
including the geometry enforcement test.
Integrates nine commits of reviewed work from the lane-go branch after the
automated resolver failed on this merge five times (each attempt dying on the
malformed-result defect whose fix is contained in this same merge).
Integration decisions:
- Search: kept main's shipped design (Store.Search + SearchResponse.Results) and
dropped lane-go's parallel, older attempt (an unused Message.Matches field, an
absent runs.search, and two partial TUI plumbing blocks). lane-go itself did not
compile: protocol.SearchMatch was undefined and model.go referenced searchNav,
requestSearch and applyRunNav, which exist nowhere. Those partial TUI blocks are
removed; the queued TUI omni-search item will implement the surface properly on
main's design.
- Both sides' additions are kept where they are independent: run titles and
provenance, the human decision stage and its CLI/TUI surface, the derived stage
verdict, the stale-client guard, the line-oriented result format, and main's
search command.
- The search key's help label is now "/ omni search"; the two tests asserting the
old label are updated rather than the label reverted.
- docs/cli.md and the packaged operations reference carry both sides' text.
Verified: go build ./... , go vet ./... and the full go test ./... suite pass.
Add references/work.md: one durable ledger per project (queue, active, done,
failed), the start/pause/resume/status operations, per-item directives, a
restart-safe queue driver, sleep autonomy and a conciseness rule. Index it from
SKILL.md and add it to the installed inventory.
Add a "Omni-search results panel (16 Oct 2026)" section to android/README.md
describing the panel that sits above the omni-search field: its placement above
the input and IME, the badge/title/secondary row layout with a bold+underlined
snippet span, the debounced query with stale-response gating and no flicker to
empty, the loading/empty/error states, and result-to-target navigation for every
kind. Records the verification evidence (unit tests and assembleDebug, APK hash
and size, published APK and LAN URL) and notes what was left to the visual review.
No source behaviour changes: the panel logic already existed; this pass verified
it and filled the documentation gap.
Introduce a short, markdown-ish result format whose first non-empty line is
the declared outcome and whose "# output" section carries the routing data,
so stage output stops carrying multi-kilobyte prose inside a JSON envelope.
- New internal/stage/line_result.go: resultFormat() gates legacy JSON ('{'
first) vs the new line format; decodeLineResult() parses outcome-from-first
line, requires a JSON-object "# output" section, stores extra sections
verbatim under normalised keys, and records a reserved result_parse status
(parsed/partial/failed). Failures return a salvage Result plus
ErrInvalidModelResult, and never route an undeclared outcome.
- internal/stage/model.go: write the raw response to raw-output.md (0600,
best-effort) before parsing, and route the line format through
decodeLineResult while leaving the JSON path (stageResultText ->
decodeModelResult -> repairModelResult) unchanged.
- internal/stage/agent.go: agentResultText returns line-format text verbatim
so the "# output" body is not stripped by the JSON-object extractor.
- internal/server/runner.go: merge a non-empty salvage Result into the error
envelope under "salvage" on failure (a no-op for the legacy JSON path).
- internal/stage/line_result_test.go: raw-text fixtures covering happy path,
missing/undeclared outcome, missing "# output", best-effort extras,
adversarial prose, legacy JSON unchanged, >=64KB responses, and
raw-output.md written before parsing.
Combine lane-e's reviewed Android UI work with main's lane-c/lane-d work.
Conflicts resolved by keeping both intents:
- android/README.md: both documentation sections retained
- graph/StageDetailPane.kt: lane-e pane plus local section changes
- screens/RunDetailScreen.kt, RunHistoryScreen.kt: lane-e features and
local work both preserved
- screens/PipelineListScreen.kt: new row layout and remembered
sort/filter controls kept together
Combine the local list-scroll/covered-edge and hoisted pane wiring work with
lane-d's Section pane level, sectionKey persistence, three-way back
descriptions and single-Column CollapsibleSectionBody. Both intents survive:
conflicts in README, PipelinesApp, StageDetailPane, PaneState, Sections and
their tests were resolved by composing both sides, without conflict markers.
Build: ./gradlew :app:assembleDebug
Tests: ./gradlew :app:testDebugUnitTest (322 tests, 0 failures)
Combine lane-c's incoming work with the local branch.
- PipelinesApp.kt was the only unmerged path: resolution is purely additive over HEAD, keeping HEAD's hoisted selection/onSelectionChange and pendingNav/onPendingNavResolved while adding lane-c's listState wiring and compactLabel/compactIcon.
- graph/StageDetailPane.kt and theme/Dimens.kt auto-merged and retain both sides' changes.
- Incoming branch af68a62 preserved as second parent.
Consolidate the omni-search row type badge and the stage-type chip into a
single ui/components/LabelChip composable, so the chip's shape, colour and
type live in one place and a second copy cannot drift.
Remove the unused SearchTarget.Run.artifacts field: an artifact hit and a
step hit now resolve identically to the visit's stage pane, whose fixed
section order already leads with the artifacts. Correct the
SearchUiState.failed KDoc to describe how prior results are kept, and
update OmniSearchResultsTest to the simplified target.
The pipelines list carried its own "Search pipelines" field while the app also
has the omni search, so the list offered a second, narrower way to do the same
job. Remove that field and move name narrowing into the list's filter control,
keeping "filters narrow one list" separate from "search finds across the system".
- PipelineListScreen no longer owns a `query` state or draws the
OutlinedTextField; the list is now the first child under the app bar, so the
reclaimed space comes from layout with no compensating spacer or new dp value.
- PipelineFilters gains a free-text `name` facet beside presence/lastRunStatuses,
applied by filterPipelines through the new pure pipelineMatchesName
(case-insensitive contains, blank means any). It needs no run history, so it
applies as soon as pipelines load while the run facets still wait for runsKnown;
activeCount and isActive include it, and hasRunFacets gates just the run facets.
- PipelineFilterControl opens with a Name section holding a single-line
PipelineNameFilter labelled "Pipeline name contains"; the shared Clear filters
resets it with the run facets and the active-count badge counts it.
- SettingsRepository/AppViewModel persist the name under pipeline_filter_name.
- Empty-state messages reflect the name-only miss.
- ListFilterTest covers the new name narrowing (+4 cases) and storage parsing.
- android/README.md documents the change and the build/APK evidence.
The runs list never had an inline search field, so nothing was removed there.
Add the fourth Search destination to the floating bottom container and
morph that container into the omni-search field.
- PipelinesApp: the destination pill gains a Search icon; tapping it
animates the icons out and turns the same Surface into a focused text
field whose size and position derive from the pill's own layout and the
window insets rather than fixed pill sizes. Back, the back gesture and a
scrim tap play the reverse and restore the pill with its previous
destination still selected. The open field covers the content behind a
scrim and shows a results panel above it.
- OmniSearch: pure state model (open/focused/query) with the open, dismiss,
focus and query transitions and a Bundle-able Saver, so an open field
survives a saved-state round trip.
- OmniSearchResults / SearchResultsPanel: map the typed search reply to
rows and render the ranked results, keeping the last accepted results
while a newer query loads and reporting a failure without blanking.
- AppViewModel / PipelinesRepository: drive queries over the existing
transport with debounce and reply ordering; the server search command
arrives in a later item, so a reply is classified by envelope type and a
non-search_results reply is reported with a clear message instead of
being mis-parsed, never a crash.
- Message: SEARCH / SEARCH_RESULTS constants and the SearchRequest,
SearchResponse and per-kind result payloads.
- AndroidManifest: adjustNothing so the app reads the IME from Compose
window insets and the field is not cleared twice by a window resize.
- Dimens: spacing for the search surface.
- Unit tests for the state model (pill, opening, focused, dismissed and
restored after the Saver round trip) and for the result-row mapping.
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.
The covered panes spent a fixed 224dp (PEEK_BUDGET_DP) whatever the window
width, so a folded window lost over half its width and the active pane was
squeezed as levels were added. Derive the covered region at runtime from the
compact identity a covered edge must show - an icon plus the shortest label
that identifies the pane, measured with the app's own type role and floored at
the platform minimum touch target - plus the leading gesture inset.
coveredEdgesDp now returns edges that sum to exactly that region, so the active
pane opens at hostWidth - region and its width is identical at every depth:
opening a level only adds a thin edge inside the region. The nearest covered
level shows its identity, one older level is a thinner touch-target edge, and
older levels fold into a count rather than accumulating width; tapping an edge
still pops everything above it. Removes PEEK_BUDGET_DP, MIN_ACTIVE_PANE_WIDTH_DP
and the peekBudgetDp/peekStripsDp budget split from Dimens.kt and
SlidingPaneStack.kt. PaneIdentity gains the pane-kind icon drawn above the title
at the vector's own measured default size, and each destination passes its
compact label/icon.
The touched files also carry the in-flight covered-pane statistics and list-scroll
plumbing they depend on (PaneStat/paneStatTier/visiblePaneStats, per-destination
LazyListState); the remaining pieces of that work remain uncommitted.
Exchange a build/protocol identity so an older CLI can no longer talk to a
newer native server silently:
- protocol carries ProtocolVersion and every server frame (including the
unsolicited welcome) is stamped with the server build and protocol, so a
client that never pings still learns the server identity.
- buildinfo.Compare classifies the relationship as InSync/Warn/Refuse and
names both builds; the client Watch reports one warning per connection and
returns a hard error when the server speaks a newer, uninterpretable
protocol so the caller never acts on the frame.
- client.ReceiveNotice decodes the raw frame so an unmodeled top-level field
produces a one-time "unrecognized field(s)" notice instead of being dropped
silently (the case that hid the artifacts field).
- CLI routes warnings to stderr, keeps machine JSON stdout clean and fails
non-zero on a refused mismatch; ping/connection print the client/server
relationship. The TUI surfaces the same notices through the shared log.
- scripts/setup-native.py now warns when an older `pipelines` earlier on PATH
shadows prefix/bin/pipelines, naming both paths and versions, without
installing or modifying anything else.
- Docs, the packaged debugging skill reference and README no longer imply the
installed CLI always matches the server.
Tests cover the comparison table, unknown-field detection and caching, the
server identity stamping on pong and welcome, the CLI/TUI reporting paths and
the installer PATH shadowing warning.
Surface the operator's title for a run so two runs of the same pipeline
read as clearly different goals, with the pipeline name kept as context.
- protocol: optional nullable `title` on RunSummary and RunDetail; absent
or blank degrades to the pipeline name.
- ui/RunIdentity.kt: one shared fallback (`runLabel`) and two-line identity
(`runIdentity`) so the list, detail header and stage pane never spell a
run differently; a titled run shows the pipeline name + version as a
second line, an untitled run keeps the pipeline name as its only line.
- runs list / run detail / stage pane use the shared identity; the status
chip, duration and metadata layout are unchanged.
- no rename affordance: the server exposes no title and no `set_run_title`,
so the app does not fake renaming.
- tests: RunIdentityTest (5) plus ProtocolModelTest cases for a present and
an absent title; README documents the change and its verification.
A running run now shows how long it has taken so far instead of its start
time, kept live: the runs-list meta row, the pipeline list's last-run line
and the run detail summary's Duration row all read one shared rule,
runDurationText (ui/Format.kt), which reports the elapsed while executing and
keeps the stored total once the run has finished.
The elapsed is derived from the server's own start timestamp against a single
shared clock, rememberLiveNowMillis/hostResumed (ui/components/LiveTime.kt),
so it stays correct after a reconnect and never ticks while the app is
backgrounded or while no shown run is executing. WorkflowGraph's private
lifecycle read and once-a-second loop are replaced by that same shared pair.
A missing start omits the value and a future start (clock skew) reads as 0s.
Unit tests (FormatTest, PipelineLastRunTest) cover a run that has just
started, the minute and hour boundaries, a missing and a future start, and a
finished run keeping its stored total duration.
The run summary led with the artifacts gallery, but it was always open, so a
long run's grid pushed the run's own facts below the fold. The gallery now
sits in one collapsed-by-default section in the same place, with a header that
describes itself while collapsed.
- RunDetailScreen.kt: RunSummaryTab renders the gallery through the shared
LazyListScope.collapsibleSection, keyed "artifacts" and seeded with
rememberSectionExpansion(run.id), so a run opened fresh starts collapsed and
the operator's choice persists per run across tab switches and config
changes. Order is unchanged: the section still leads the summary and the
facts item follows it. Expanding composes the unchanged ArtifactGallery;
collapsing composes nothing.
- ArtifactGroups.kt: new pure runArtifactsHeader(steps, executing) builds the
self-describing header - singular/plural title, recorded count and
"· partial capture" when any visit excluded or omitted files; empty runs
reuse the shared artifactsEmptyMessage. Its count equals runArtifactGroups'
tile total, so the header and the expanded gallery cannot disagree.
- ArtifactGroupsTest.kt: four header tests covering count, singular vs plural,
the partial-capture notes and the empty case, plus a count-matches-gallery
assertion.
- android/README.md: records the change and its verification evidence.
Android only; no new dependency, no run started from the app, device work on
the operator's Pixel 10 Pro Fold (58281FDCG000JF). Verified: 269/0/0/0 unit
tests, clean assembleDebug and published APK LAN URL 200.
Refinements on top of the human decision stage (a6aff47):
- `pipelines decide` now reports the feedback the server actually stored for
the chosen option, so a repeated (idempotent) decision shows the recorded
evidence instead of the ignored request text. A repeated decision is covered
by a new assertion that also checks the step output does not change.
- The decision option/feedback output keys are defined once in protocol
(DecisionOptionKey/DecisionFeedbackKey) with a DecisionEvidence reader, and
the store and CLI use them instead of bare string literals.
- piEnvironment drops any inherited PIPELINES_ARTIFACTS_DIR before spawning Pi,
so the artifactsDir argument is authoritative and an ambient directory (for
example Pipelines' own when a stage runs inside another stage) never leaks
into a child that was given none. Covered by a test with an ambient value set.
Standardise the artifacts gallery so the run summary and the stage pane
render one tile per artifact instead of images as a grid and everything
else as a plain list.
- Artifacts.kt: ArtifactTile now covers both shapes - an image/video fills
the cell with a thumbnail (a video shows its poster frame with a play
badge), anything else shows its file-type icon with the name and size
beneath it; the grid, share/copy actions and multi-select are unchanged
and the capture wording is untouched.
- ArtifactType.kt (new): pure ArtifactKind classification from content
type plus name extension fallback, and artifactIcon(kind) mapping each
kind to a distinct glyph.
- ArtifactImage.kt: ArtifactVideoFrame/rememberArtifactVideoFrame extract
a poster frame via MediaMetadataRetriever over an in-memory
MediaDataSource; the shared memoized-preview scaffold is factored into
rememberArtifactPreview.
- ArtifactViewer.kt: full-screen viewer takes a video flag and shows the
poster frame.
- Format.kt: add isVideoContentType; drop the now-unused artifactMetaLine.
- Dimens.kt: ARTIFACT_TYPE_ICON_DP, ARTIFACT_PLAY_BADGE_DP,
ARTIFACT_TILE_ACTION_DP tokens.
- Tests: new ArtifactTypeTest (type-to-icon mapping, extension fallback,
distinct glyphs); FormatTest updated for the removed helper.
- android/README.md documents the pass.
android/ only; no new dependencies beyond material-icons-extended.
Expanding a stage section rendered its rows stacked at the top of the section: CollapsibleSectionBody passed the section's several field composables straight into AnimatedVisibility, which measures a single child, so all rows were placed at the section origin and only the last (Memory) was visible. Fix the shared body by laying its content out in one full-width Column, and make every stage section open as its own pane rather than growing the stage screen inline.
- PaneState: add the Section pane level (MAX_PANE_DEPTH = 3), a saved sectionKey primitive, and the matching backStep/popTo/encode/decode handling so one Back or peek pops one level and the open section survives rotation and process death.
- StageDetailPane: the stage screen now keeps a compact collapsed list of sections (Artifacts, Output, Input, This run, Stage definition); tapping one opens it as a full-window screen on a narrow window or a panel to the right of the stage pane on a wide one, with its own title, scroll and top spacing. A shared stageSectionSpecs derives the sections for both the stage screen and the section pane, and the artifacts section keeps the shared ArtifactSelectionScaffold.
- PipelinesApp: wire the Section pane into the stack, its peeks and Back. Section content (Definition, Input, Output, Artifacts) and semantics are unchanged; sections start collapsed and the operator's choice persists.
- Tests: cover the section pane level, backStep, popTo and the shared stageSectionSpecs. Build and forced unit tests pass (262 tests, 0 failures); lint shows only the pre-existing themes.xml NewApi errors.
Android only (7 files); no dependency added, no server/Go/installer/Docker change, no run started from the app. APK published to the run artifacts directory and documented in android/README.md.
Extend ChatApprovalTest so once, always and reject each go through the same
ChatProtocol.replyRequest builder plus one encode/decode round trip using the
DECISION_* constants, so no decision is asserted more weakly than another, and
add answeringAlwaysUpdatesTheCardInPlace (settled card, no actions, risk panel
retired, request still visible). Refresh the android/README.md verification
notes: 267 tests, the rebuilt APK's sha256 and byte size, the 147/3 artifact
path and LAN URL, and the emulator/device-lock notes for this pass.
A new registered stage type `human` (internal/stage/human.go) has no model,
agent, tools or configs: its required `prompt` block carries the operator
instructions and its non-error edges are the selectable options. It parses,
validates, renders, exports and imports like every other type (no parser
special-case, no config keys).
At runtime the runner parks the run instead of executing: the step and the run
persist `waiting` with self-contained {prompt, options} evidence, and the run
returns without starting later stages, capturing file diffs, scanning artifacts,
holding a goroutine/timer or applying a stage timeout. The wait is durable: a
restart leaves the waiting rows untouched (RecoverRuns excludes them) and a
rebuilt runtime over the same database still accepts the decision.
`pipelines decide <run-id> [stage] --option KEY [--feedback TEXT] [--json]` and
the TUI `c` picker resolve the decision from the pinned graph in one store
transaction, record the choice and feedback as the step's evidence and resume
along edges[KEY]. An unknown option is refused with the valid list, a stage that
is not waiting is refused, and a repeated decision for an already-decided visit
does not double-apply. Cancel and retry keep working while waiting and after a
decision; a human stage is never killed by a stage timeout or max_visits, and a
`notify` policy can fire an `on=waiting` event.
Docs: the authoring skill references (format.md, operations.md), docs/cli.md and
README describe the stage, the command and the TUI picker. Tests cover stage
validation, the parsing round-trip, the store transitions, a websocket wait/decide
integration, cancel/retry, waiting notifications and a persistence-layer rebuild
(second Open + newRunner over one database, no process restart).
While a turn was in flight the trailing composer button became the stop
control, but the text field's keyboard send action still checked only
canSend, so a prompt could be sent from the IME during a run even though
the visible control had become stop.
Add ChatFormat.composerAction(thread) -> ComposerAction.Send/Stop as the
single pure derivation and read it from both the trailing button and the
keyboard action, so the two controls can no longer disagree.
ChatFormatTest.composerControlIsStopWhileARunIsInFlightAndSendOtherwise
covers Send when idle and Stop while running. android/ only; no new
dependency.
Render a server-pushed chat_permission as an approval card in the
transcript instead of a transient bar above the composer, matching the
reference opencode/Jarvis chat: the requested action, its resources, the
amber RISK REVIEW panel, and once/always/reject actions wired to the
server's chat_reply.
- ChatFormat: a pure approvalCard()/ApprovalCard model and one
ChatProtocol.replyRequest() builder shared by the card's actions and
the repository, so the wire frame and the controls cannot drift.
- ChatStore/AppViewModel: answerPermission() settles the card in place
optimistically and survives a chat switch; a failed reply reopens the
same request rather than showing an unacknowledged decision.
- ChatPermissionFrame gains optional resolved/decision fields so a
request the server reports as already settled shows its verdict with
no stale actions; a new request replaces a settled card.
- Findability: a gold PanTool top-bar action and chat-chip marker jump
to the pending card; the running indicator stands down while waiting.
- Tests: ChatApprovalTest covers pending/answered/resolved, the reply
builder's once/reject decisions and the missing-summary fallback;
ChatProtocolTest covers the server-resolution frame. README records
the 265-test/assembleDebug evidence and the emulator-5556 captures,
and .approval_check/chat_stub_approval.py is the test double used.
android/ only; no new dependency beyond material-icons-extended; no
Pipelines server, Go, installer or Docker file touched; no run started
from the app. The live brokered server is not verified (the resolved
frame fields are an additive contract it does not emit yet).
One query now finds anything in the system over the wire and from the CLI.
- protocol: add Search/SearchResults message types and a SearchRequest
(query, optional kind filter, optional limit) / SearchResponse (typed,
ranked matches plus truncation and scan-bound counters) pair, with typed
payloads for pipeline, version, run, step/visit, field text and artifact.
- store: add Store.Search, a read-only query over pipelines,
pipeline_versions, pipeline_runs, run_steps (+step_control) and
step_artifacts. Ranks exact name (3) > name substring (2) > body text (1),
breaks ties by recency then a stable kind/target order, and reports the
matched field. Bounds work with a 50-default/200-max result cap, a 2000-row
per-kind scan limit and a 2000-step / 1 MiB field-text scan budget.
- terms: a bare status word or lone date expression (today, yesterday, this
week, YYYY-MM-DD) selects runs; anything else stays free text.
- server: dispatch protocol.Search to stores[0].Search; read-only and
unconfirmed.
- cli: add `pipelines search QUERY [--type KIND] [--limit N] [--json]`, help
text and a BROWSE line.
- store: add OpenReadOnly so the live-database check never runs DDL.
- docs: document the grammar, kinds, ranking and bounds in docs/cli.md,
scope the TUI omnisearch to pipelines in docs/ui-ux-review.md, and add a
search bullet to the packaged operations reference.
- tests: protocol round trip, store/ranking/term-parsing/limit/scan-bound
unit tests, a server end-to-end test, and an env-guarded live check.
No new dependencies; go.mod/go.sum unchanged.
Extract the single chat_interrupt frame into ChatProtocol.interruptRequest and
have PipelinesRepository.chatInterrupt send it, so production and its unit test
share the one wire shape instead of the repository building it inline.
Add chatInterruptRequestCarriesTheRunningSession, which asserts the frame the
stop control sends is chat_interrupt carrying the running session's id (and no
chat prompt/reply) and that it survives the client's JSON round-trip.
Document the slice and its emulator-5556 evidence in android/README.md.
The chat edit diff card rendered every line of an edit, so the >400-line
fallback flooded the transcript with thousands of Text nodes on a phone;
it also showed only the tool name, not the file, on the expanded panel.
- ChatFormat.toolEditDiff keeps the first MAX_RENDERED_DIFF_LINES (200)
lines and puts the remainder in the new ToolDiff.omitted, while the
+N/-M counts continue to describe the whole edit.
- DiffView prints "… N more changed lines not shown" first so the
truncation is visible without scrolling.
- The expanded panel header now shows the edited file name and the shared
green/red DiffStat, matching the collapsed chip.
- ChatFormatTest pins omitted = 0 for a small edit and the true counts,
200-line cap and omitted = 300 for an oversized one.
- android/README.md records the change and its evidence.
Move a completed stage visit's derived verdict out of the Progress summary
and into the top of the selected stage's Result section, so the chosen
option, its concise reason and the referenced artifacts are visible where
the stage is inspected.
- Add stageVerdictLines, which renders one line "Verdict: <option> · <reason>"
(still stating the option when the reason is absent) plus a following
"Referenced artifacts:" line only when artifacts exist, and returns nil
for a nil verdict so nothing extra is shown.
- Prepend those lines in runSectionLines after the stage state and before
the stage output and evidence, without adding a section or changing the
panel layout.
- Update the TUI test to render through the run-detail view, asserting the
option, reason and artifact names appear, and that a nil verdict adds
nothing; document the TUI placement in the debugging skill reference.
Omni-search work already present in the working tree (including the
runDuration→protocol.Duration refactor in run_detail.go) is unrelated to
this change and is left uncommitted.
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.
Each completed step now exposes a verdict: the chosen option (outcome -> target),
a bounded one-line reason with model/fallback/absent provenance, and the recorded
artifacts the reason refers to. The store persists only the model-generated line
in a new step_verdicts table and derives the fallback at read time (no backfill);
the server generates the line once at completion, best-effort; the TUI renders it
in the stage progress summary. The packaged debugging reference documents it.
Add a bounded, never-empty title to every run. `pipelines run --title "..."`
sets it explicitly and skips model generation; otherwise the server generates
it from the prompt through the shared summariser and falls back to the prompt's
first line, recording title_source (model/fallback/explicit) and title_model.
- protocol/store: RunSummary.Title plus Label(), a set_run_title message, title
columns with an idempotent migration, CreateRunTitled, and SetRunTitle renames.
- summarise: Title/GenerateTitle/DeriveTitle/ExplicitTitle bounded to TitleCap.
- runner: generate the title outside the admission lock and only for a request
that starts a run; a replay reuses the stored title and an explicit title
skips the model entirely.
- CLI: `--title` on run and a `title <run-id> "<title>"` rename command; human
`runs` and `inspect` show the title beside the pipeline name and version.
- TUI: the run list row, run detail header, Home run cards and last-run line,
and the pipeline Results line show the title via Label().
Tests cover storage/migration/fallback, explicit-title and rename, the
end-to-end CLI flow, and title rendering; CLI and operations docs updated.
Move the workflow-graph package (WorkflowGraph, the StageDetailPane sheet,
Artifacts, ArtifactViewer, ArtifactImage) off its remaining raw dp literals
and onto the geometry tokens, all substitutions value-equal so the visuals
are unchanged.
- ui/theme/Dimens.kt gains the off-scale component and graph-chrome sizes:
the run legend's GRAPH_LEGEND_PAD_X/PAD_Y/GAP, the collapsed
GRAPH_PANEL_MIN_HEIGHT (moved off WorkflowGraph.kt, now imported by its
test), the gallery's ARTIFACT_TILE_DP/THUMB_DP/BADGE_DP/PROGRESS_DP/
PROGRESS_STROKE_DP, and the stage-type chip's STAGE_CHIP_PAD_H.
- Artifact tile/row and thumbnail corner radii derive from the Material
shape scale (MaterialTheme.shapes.medium/.small), matching the graph's
existing node corners.
- DimensTest.kt's allow-list shrinks from 24 to 21 entries: 24.dp, 56.dp and
96.dp are gone now that their last call sites migrated. The structural
hairlines/zeros, the not-yet-migrated app shell and Settings literals, and
the sp type values owned by Typography.kt remain.
- WorkflowGraphTest.kt imports the moved GRAPH_PANEL_MIN_HEIGHT.
- android/README.md documents the change and its verification evidence.
Verified: gradle :app:assembleDebug :app:testDebugUnitTest --rerun-tasks
BUILD SUCCESSFUL, 30 XMLs / 259 tests, 0 failures/errors/skipped; the
enforcement test fails on a deliberately introduced literal and passes once
removed; before/after captures at both window widths differ only on the
status-bar clock and live relative-time text.
A model stage whose final result was malformed failed the whole run even when
the work and evidence had survived, because the only recovery was an isolated
formatter call on a fixed 30-second deadline that could time out on its own
(run 55, ui_reviewer of pipeline 9 v6).
Add an ordered, deterministic local repair pass (internal/stage/result_repair.go)
that runs before any model call: (a) append missing closing delimiters via the
existing closeJSONContainers; (b) remove one unambiguous trailing comma before a
closing } or ]; (c) insert exactly the single comma/colon the JSON parser reported
at its byte offset. Every candidate must pass losslessSyntaxRepair(original,
candidate) and decodeModelResult before it is accepted, so no field value is
invented, removed, reordered or rewritten. Ambiguous payloads (an unescaped quote
or colon inside a string value, or a stray delimiter with no single completion)
return not-ok and fall through to the bounded model re-emit rather than guessing.
stageResultText still strips surrounding prose and a single code fence first;
model_prompt.go now also strips prose around a single balanced-but-malformed
object span so the deterministic pass sees just the object.
Replace the fixed 30-second formatter deadline with repairDeadline(payloadBytes,
remaining), which grows monotonically with payload size, has a floor, and is
clamped to the attempt's remaining budget minus a safety margin, so the stage
context remains the outer bound and a large result is not guaranteed to time out.
The one-request-per-attempt, 32 KiB bound and the deny-all, retained, new-session
property of RepairFormat are unchanged for OpenCodeClient and PiClient.
Record an explicit recovery status on every terminal path: repaired, partial or
unrecoverable, plus a byte offset. A candidate that is valid JSON but still fails
envelope validation is marked partial and never returned as a completed result;
the unrecoverable path retains the bounded original payload, the precise parse
error (including its byte offset) and surfaces the status in the FINAL RESULT
VALIDATION diagnostic.
safeToReplay is intentionally unchanged. The deterministic local repair and the
fresh deny-all, no-tools, retained formatter session are independent of the
stage's tool set and never re-prompt or replay the admitted agent session, so a
shell-enabled review stage gains malformed-result recovery without any replay of
admitted work. Risk: no change to mutation safety; the only added cost is one
bounded formatter call, already budgeted. Replayability is not extended for shell
stages.
Docs and packaged skill references (docs/model-results.md,
internal/author/skill/references/{format,debugging,verification}.md) describe the
three-tier recovery, the status words and the derived deadline; the safeToReplay
decision and its risk are recorded there alongside the commit.
Tests add mocked, offline coverage for the deterministic and partial paths, a
repairDeadline monotonicity/floor/clamp table, and a shell-stage regression
proving a recoverable malformed result does not fail the run or replay tool work.
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.
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.
Replace the hardcoded paddings, spacings, sizes and offsets in the four
list/detail screens and the shared components they are built from with
references to the token file from the previous item, via WindowInsets or
layout where those derive the value. Every replacement is value-equal, so
the screens render identically at both window widths.
Name the glyph sizes that cannot derive from layout as four new ICON_*
tokens in ui/theme/Dimens.kt (14/18/20/24dp) and shrink the DimensTest
allow-list from 30 to 24 entries: 14.dp, 18.dp and 20.dp leave because
their last call site migrated, and the already-unused 32.dp, 11.sp and
13.sp entries are dropped. All adb/emulator work targeted emulator-5554
only; android/ only; no new dependency, server/Go/installer/Docker file
touched, and no run started from the app.
Verified: :app:assembleDebug + the full unit suite (30 result XMLs, 259
tests, 0 failures/0 errors/0 skipped), the shrunk allow-list still fails a
forced raw-literal probe, and before/after screenshots of every converted
screen at narrow and wide widths match near-zero.
internal/summarise called protocol.NormalizeText, which was never defined, so the tree did not compile. Add the shared normalisation helper: drop zero-width formatting runes, turn control characters into spaces and collapse whitespace runs (including the non-breaking space variants) into single spaces. Reuse it in OutputPreview instead of duplicating the mapping logic.
Cover the awkward inputs (newlines, tabs, non-breaking spaces, zero-width runes, surrounding quotes, trailing punctuation) in the protocol and summarise tests. Unrelated working-tree changes are left uncommitted.
Compose the parallel lane (lane-app2) with the work already on main,
preserving both intents rather than picking one side:
- lane-app2's modernised run graph (rounded tonal nodes, pill terminals,
chipped outcome labels, pass/fail emphasis and active-stage/edge motion)
plus its remembered list filters/sort and last-run badges, and the
app-owned run-status palette.
- main's cross-fading loading/empty/error states, animated list items and
the single geometry token file (Dimens.kt + DimensTest).
Conflicts resolved in android/README.md (kept both appended sections),
RunStatus.kt (kept the shared ColoredChip extraction and made it animate
under MotionQuick), PipelineListScreen.kt (filters/sort/badges composed with
the StateCrossfade/load-phase presentation and animateListItem rows),
RunDetailScreen.kt (kept both the artifact-selection and graph-palette
imports) and RunHistoryScreen.kt (the cross-faded load branch now passes
sort/filters through, and both empty branches keep the Clear filters action
with animated items). LoadPhase.Empty now carries an optional recovery
action so the crossfade can still offer Clear filters. The graph's new
geometry literals moved onto Dimens.kt GRAPH_* tokens so DimensTest passes
and its allow-list shrinks as intended.
Verified: :app:assembleDebug and :app:testDebugUnitTest (259 tests,
0 failures) with the offline Gradle 8.11.1 / JDK 17 toolchain.
Introduce ui/theme/Dimens.kt as the one source of truth for app geometry,
alongside Typography.kt for type. It defines the 4dp spacing scale
(SPACING_XXS/XS/S/M/L/XL/XXL) and receives the geometry constants that
already existed, each with a comment tying it to what it is: PEEK_WIDTH_DP
(the collapsed strip), PEEK_BUDGET_DP, MIN_ACTIVE_PANE_WIDTH_DP and
MIN_COVERED_PANE_WIDTH_DP from SlidingPaneStack.kt, DESTINATION_PILL_RESERVE
from PipelinesApp.kt, and WIDE_RAIL_WIDTH_DP and DETAIL_MAX_WIDTH_DP from
DetailTabs.kt. Call sites now import the tokens; every value is unchanged,
so no layout changes.
Add ui/theme/DimensTest.kt, a JVM test that scans the app's Kotlin sources
for raw dp/sp literals and fails with file:line:literal unless the literal
is a token or an explicit, reasoned allow-list entry. The allow-list records
the 34 literals that predate the token file, each with a written reason, and
is expected to shrink as call sites migrate onto the tokens.
Document the change and its verification in android/README.md.
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.
Animate selection and status changes across the Android UI using the
existing Motion tokens, leaving every resting state unchanged.
- DestinationPill draws one selection indicator and animates its offset
between the three slots (animateDpAsState, MotionStandard), with the
glyph tint cross-fading in step; geometry comes from named
DESTINATION_ITEM_SIZE/GAP tokens via the unit-tested
destinationIndicatorOffsetDp helper.
- The shared ListRow fades its tonal container and content colour under
MotionQuick instead of switching.
- New shared CollapsibleSectionBody wraps section bodies in
AnimatedVisibility (expand/shrink + fade) under MotionQuick, used by
both the lazy collapsibleSection and the stage pane's StageSection, so
body and chevron move together.
- StatusChip eases container and label colour and RunStatusIcon eases its
glyph tint, so a live run's status transition is visible rather than a
silent colour swap.
Verified: assembleDebug + testDebugUnitTest BUILD SUCCESSFUL, 186 tests
across 23 classes with 0 failures/errors/skips; frames captured on
emulator-5554 for the travelling pill, section collapse and a live status
change; APK published to the run artifact directory. README documents the
change and its evidence.
internal/summarise performs a single tool-free generation through the
configured default harness (its interactive model), reusing the exact
stage.ModelGenerator/OpenCodeClient/PiClient construction provider-check
uses. It bounds input (InputCap), output (one line, OutputCap runes) and
time (DefaultTimeout), returns the NoSummary sentinel on any error/timeout/
unusable reply, never runs tools or writes files, and records the harness,
model and failed flag in one sanitized log line plus at most one
OperationEvidence.
Reuse: stage.TruncateRunes and stage.OperationLog.Record are the exported
forms of the existing rune-safe truncation and bounded evidence recording;
protocol.NormalizeText trims replies to one line. No new dependencies.
Not wired into titles/verdicts yet: protocol.OutputPreview and the
internal/server/notify.go notification summary are the obvious future call
sites.
A data-backed pane swapped its loading spinner, empty message, error
message and content with a plain `when`, so content flashed from empty to
full and empty/error states popped.
Introduce a shared presentation model in ui/components/States.kt:
- `LoadPhase` (Loading, Error(message), Empty(message), Content), with
message-carrying phases capturing their text at classification so a
fading-out branch never recomposes against cleared error/filter state.
- `listLoadPhase(loading, error, hasData, emptyMessage)` and
`detailLoadPhase(error, hasData)` pure classifiers preserving the
existing precedence (failed load with no data, then loading, then
empty, else content; stale data keeps the pane on content).
- `StateCrossfade(phase)` wraps the branch in a `Crossfade` using the
existing `MotionStandard` token; both branches share one box so the
resting layout is unchanged and the outgoing phase fades under the
incoming one.
Apply to PipelineListScreen, RunHistoryScreen, PipelineDetailScreen and
RunDetailScreen. Detail panes render the fading-out branch from the last
non-null item. The Runs pane keeps its inline empty/error line inside the
list, now fading through animateListItem().
Add LoadPhaseTest covering the classifiers and captured messages, and
document the change and evidence in android/README.md.
Introduce ui/components/Motion.kt beside the pane dimension tokens: two
named duration+easing tokens, MotionQuick (120ms) for small in-place state
changes and MotionStandard (220ms) for content that moves or swaps, under a
300ms MAX_MOTION_MILLIS cap. Every animation call site now asks a token for
its spec instead of writing a duration: the pane slide and section
Crossfade use MotionStandard, the section chevron uses MotionQuick, and the
pane-pop stagger moves in as MOTION_STAGGER_MILLIS (the old
PANE_SLIDE_* / SECTION_SWAP_MILLIS constants are gone).
Add a single LazyItemScope.animateListItem() helper (ListRow.kt) wrapping
the supported Modifier.animateItem with the tokens: items fade in/out
(MotionQuick) and slide to new positions on refresh, filter or re-sort
(MotionStandard). Pipelines rows, run rows, version rows and evidence rows
use it. Specs are built at composition time (no per-frame allocation) and
the chevron reads its angle inside graphicsLayer so it turns without
recomposing the header; resting layout is unchanged and the standard
animator duration scale still applies, so disabled animations are instant.
Add MotionTest covering token ordering, per-token bands, the cap, monotonic
easings, self-reversal and spec timing; SlidingPaneStackTest now reads the
pane timing from the token. Document the change and its verification in
android/README.md.
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.
chat_sessions now brokers GET /api/session but filters the global list to
the sessions this server recorded in run_steps, deduped by session id, and
fails closed to an empty list when no ownership source is configured. A
session another client holds (in-server claim, released on stream end or
disconnect) or an active run is marked busy; a second client's chat_prompt
for a held session is rejected before any OpenCode call. chat_create stays
unbrokered.
Long-pressing any artifact — a gallery tile in the run summary or a row in
the stage pane's per-visit list — now enters artifact selection: the pressed
item is selected with the app's selected treatment and further taps toggle
items instead of opening them. A contextual bar replaces the surface's top
bar while selecting, showing the count plus Copy links, Share and a close;
it carries the same pane safe-area insets as the bar it replaces, uses 48dp
IconButtons and leaves selection mode on Back before the surface's own Back
runs. Selection applies only to artifacts, never the runs or pipelines lists.
The selection is one shared host: ArtifactSelectionScaffold owns the
remembered ArtifactSelection, the resolvedSelection lookup, the bulk
copy/share actions, the SnackbarHostState and the pane-scoped BackHandler,
and both RunDetailScreen (summary grid) and StageDetailPane (per-visit list)
go through it, so neither screen owns its own SnackbarHostState or
BackHandler. The immutable ArtifactSelection (enter/toggle/selectAll/clear)
treats selection mode as "one or more urls selected", so it can never
restore half-applied; rememberArtifactSelection saves it via a listSaver and
reseeds per run/visit.
Copy links resolves every selected url against the configured server through
the existing resolvedArtifactUrl (no hardcoded host), writes one absolute
link per line through the new single Clipboard.copyText path (now also used
by the code blocks, pipeline source, artifact row and viewer), and confirms
the number of lines actually produced in a Snackbar. Share fetches every
selected artifact through the existing client, reuses the single-item
writeSharedArtifact (same bounded cache, FileProvider and prune), and sends
one ACTION_SEND_MULTIPLE typed by bulkShareMimeType (the common type, else
the wildcard) with the count in the chooser title; when any fetch fails the
whole set degrades in the same action to its resolved links shared as text.
Pure helpers and tests: ArtifactSelectionTest covers enter, toggle,
deselect-last, select-all/clear, the restored state, the one-per-line link
formatting and the labels; ArtifactSharingTest gains shareTargets and
bulkShareMimeType cases. Unit tests plus assembleDebug pass (168 tests,
21 classes, 0 failures). android/README.md documents the model, action bar
and the bulk share flow, and the doc-accuracy pass records that the bulk
copy writes links in gallery (candidate) order.
No new dependency (icons come from the declared material-icons-extended).
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.
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.
Give each gallery image cell and each per-visit file row its own share
control: a 48dp IconButton with an accurate "Share <name>" content
description drawn as a sibling of the item's tap handler, so sharing
never opens the image or the item.
Sharing fetches the artifact through the existing client into a scoped
cache file (cache/shared-artifacts/), exposed via a non-exported
FileProvider declared with the new res/xml/file_paths.xml, and sends it
through ACTION_SEND. When the fetch returns nothing the action falls
back to sharing the resolved link as text. Cache files are named
deterministically per artifact so re-sharing overwrites instead of
growing without bound, and a failed or unreachable fetch cannot crash.
The artifact-to-file naming, mime/extension table and the file-vs-link
fallback decision are factored into ArtifactSharing.kt and covered by
the new ArtifactSharingTest.kt. The existing open and copy-link actions
are unchanged; the viewer's action scrim alpha is shared as
ARTIFACT_ACTION_SCRIM_ALPHA. android/README.md documents the provider
and the share flow. No new dependency is added.
The chat_interrupt path was already wired end to end (protocol type,
server dispatch through handleChatSimple to broker.Interrupt, and the
adapter POST /api/session/{id}/interrupt), but nothing exercised it
against a live stream. Add the missing coverage:
- internal/opencode/chat_test.go: pin the adapter's outbound call
exactly (POST /api/session/ses_1/interrupt, empty JSON body, one
request, nil on 200) plus a non-nil error on HTTP 500.
- internal/server/chat_test.go: drive the real opencode.Chat adapter
over an httptest SSE fixture that holds the turn open until the
interrupt arrives, then assert the run ends, the interrupt is
acknowledged, no error frame is sent, and the prompt/interrupt posts
and interrupt path match. Also cover invalid-session rejection,
the unconfigured-broker error, and broker-failure reporting, adding a
spare interruptErr hook to the scripted fakeChat.
Production code is unchanged: verification found no gap in the existing
interrupt transport. Tests use httptest loopback fixtures only and do
not touch the live OpenCode service.
Tapping an image artifact (run summary grid, per-visit list or stage pane,
all rendered through ArtifactGallery) now opens a new scrim-backed
full-screen viewer instead of the former small centred dialog, which is
removed rather than stacked.
- ArtifactViewer.kt renders a full-bleed Dialog (usePlatformDefaultWidth =
false, decorFitsSystemWindows = false) whose content re-applies
paneSafeArea() so the dark backdrop reaches the edges while respecting
status bar, cutout and navigation bar. A top-right row keeps the
open-in-new and copy-link actions and adds a close button over a
translucent scrim capsule.
- Gestures: pinch zooms about the centroid, drag pans via the existing
graph zoomAbout, double-tap toggles fit <-> 2.5x, and a downward swipe at
fit dismisses; a plain tap does nothing. Zoom clamps to [1x, 5x] and the
new pure clampImageOffset keeps pan inside the scaled image. Zoom state is
keyed on the url, so closing the viewer or opening another image resets to
fit/centred. System Back and the close button dismiss the viewer without
closing the pane behind it.
- Loading goes through the existing cached, off-main-thread
rememberArtifactBitmap/ArtifactImageState path with distinct loading and
error states, drawn in the light inverseSurface role that contrasts with
the always-black scrim.
- Pure helpers fitImageSize, clampImageOffset and toggleZoomScale are
covered by the new ArtifactViewerTest. ArtifactImage.kt widens
rememberArtifactBitmap/ArtifactImageState to internal and Artifacts.kt
replaces FullSizeArtifactDialog with ArtifactViewer (openArtifact made
internal).
- android/README.md documents the viewer, its gestures and the evidence
gathered on emulator-5554.
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.
In the run detail summary, artifacts now appear at the top of the page and as a grid rather than a list:
- RunDetailScreen emits the "run-artifacts" LazyColumn item before the "run-summary" item, so the captured screenshots are the first thing the operator sees. The rest of the summary and its collapsed-by-default sections are unchanged.
- ArtifactGallery derives its geometry from the measured width via the new pure artifactGrid(availableWidth, preferred, spacing): it fits as many preferred-shaped cells as the width allows and stretches them to fill the row, instead of the removed fixed ARTIFACT_GRID_COLUMNS count. A host narrower than one preferred cell falls back to a single narrower cell; a non-positive preferred token never divides by zero. Tiles still open the full-size image on tap; non-image artifacts keep their compact list form.
- ArtifactGalleryTest replaces the fixed-column cases with grid cases covering a narrow pane (fewer, larger cells), a wide window (more columns), a very wide window (cells near the preferred shape), the single-cell fallback and degenerate inputs, asserting the row never overflows the host.
Verified with assembleDebug (APK 17,863,337 bytes, sha256 32e9081b28f5caa85f5bfa24f7fe7149eeddb919d4e71cf497e9017b80f54ce7) and the unit tests (140 tests, 0 failures/errors/skipped); captured on emulator-5554 at both window widths.
decodeChatMessages only understood the native-serve {info,parts} envelope,
so records from the V2 HTTP API (GET /api/session/{id}/message) decoded
with an empty role and were silently dropped, leaving chat_messages with
empty history. Teach nativeChatMessage to read the V2 top-level shape
(id/type/agent/model/time, parts under "content", user prompt as a bare
string) while keeping the native {info,parts} path via role/id/model/agent/
created accessors and a contentParts fallback.
Add seeded-session evidence: a decoder table test covering both envelopes
(user + assistant with text, reasoning and a completed tool part carrying
input, content and status) plus handler tests that drive chat_messages
through the broker fallthrough and through the real adapter.
The stage detail pane covered the status bar. Introduce one shared
paneSafeArea() (WindowInsets.safeDrawing: status bar, display cutout,
navigation bar, gesture area and IME) and apply it from the live window
insets across the pane stack:
- SlidingPaneStack uses it (unioned with systemGestures) for the covered
peeks' strip geometry.
- Each pane's Scaffold reserves it once via contentWindowInsets, and its
TopAppBar reserves the top/horizontal part, so no pane sits under the
status bar, a cutout, the navigation bar or the IME. Applied to the five
stacked panes and SettingsScreen.
- The connection banner owns the top inset and the NavHost consumes it
(paneSafeArea().only(Top), was statusBars) so the inset is never doubled.
- The floating destinations pill clears the same safe area, so the keyboard
no longer hides it.
Scrollable content stays inside the remaining space rather than clipping.
android/README.md records the design and emulator-5554 verification.
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.
Give every pane one shared slide spec, a fixed 300 ms duration and a symmetric cubic-bezier easing, so a close is the open curve run backwards at the same duration; several levels that pop in one tap now stagger so each reverses in order from the top.
The stack mounts a level while it is open or still sliding out and calls the pane only then, and rememberPaneContent retains each closing pane's full parent identity (item/version/section, stage key, visit). A closing pane therefore keeps rendering the content that opened it instead of vanishing or falling back to an empty node, and a fully closed level composes nothing. Geometry, tokens and insets are unchanged.
Adds three pure unit cases for the symmetric easing and the stagger rule; documents the change and its emulator verification in android/README.md.
Add the server-side half of the brokered chat path (route B): the
opencode.Chat adapter forwards chat_prompt to POST
/api/session/{id}/prompt through the owned Connection.Call translation
and derives chat_event frames from the authenticated /api/event SSE
firehose (text and reasoning deltas, tool parts with their status
transitions, step and usage). Every pushed frame carries a stable
session and message id, with a last-message-id fallback so step/tool
events that omit the assistant message id stay attributable.
The /connect handler keeps per-session retained state (chatHub) capped at
1 MiB with least-recently-updated eviction at 128 turns, so a
reconnecting client re-syncs through chat_messages instead of replaying
deltas the OpenCode per-session log never resends. Prompt dispatch
subscribes before posting and buffers pre-ack frames to preserve order,
and cancels the stream on disconnect so no goroutine leaks. chat_sessions
and chat_create are declared but not yet brokered: they answer with an
explicit protocol error rather than the generic Pong.
Reuse the existing transport, validation and normalization; no second
OpenCode transport or credential path is introduced.
Tests: protocol golden round-trip, adapter normalization + v1/v2 Call
translation, and handler ack/stream/validation/resume/disconnect, plus a
real-adapter no-tool evidence harness.
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…).
Rewrite SKILL.md to state the stance (reconnoitre, then route all work
through Pipelines runs; manage and debug, never implement), keep the
existing authoring/operations index, and route to four new references.
Add references/orchestration.md (stance, work items, brief template,
hard constraints, pipeline choice, running and watching),
references/lanes.md (worktrees, devices, sync/merge, restart-replay
cursor fix), references/debugging.md (eight symptom/confirm/do
playbooks) and references/delivery.md (artifacts, LAN URLs, WIP naming,
install boundaries), each with a clearly labelled project example where
Android/device specifics apply.
Append orchestration verification habits to references/verification.md
and add the four new files to install.go's managed inventory.
Add the internal/protocol types the phone needs to talk to OpenCode chat
through the Pipelines server (route B): the chat_* request/response type
constants (sessions, create, prompt, messages, interrupt, reply) and the
server-pushed chat_event frame, plus the part/status/role/tool-state/decision
constant sets and payload structs modelled on the verified OpenCode shapes -
an assistant turn is a list of parts (text | reasoning | tool), and a tool
part carries name, executed, state.status (streaming | running | completed |
error), state.input, state.content, state.metadata, state.error and
epoch-millisecond timings.
Add eight optional omitempty chat fields to the shared Message envelope, so
older peers ignore them, and a golden round-trip test covering every new type,
an exact-JSON pin of a tool chat_event frame, envelope preservation and
omitempty. go test ./internal/protocol/... passes.
The pane's Scaffold already painted an opaque colour, but it was the app
background role, identical to the peeks it slides over, so it read as
"no background" and its rows ran together with the covered pane's compact
identity.
Paint the whole pane one theme container role: StageDetailPane gains
paneContainerColor() = colorScheme.surfaceContainer and applies it to the
Scaffold container, the TopAppBar and the visit PrimaryScrollableTabRow, and
StageSection passes it to the shared SectionHeader, which gains an opaque
containerColor parameter defaulting to the previous background. The pane now
fully covers the area it occupies, including under a sticky section header,
and sits a tuneful step above the app background it covers.
Move the shared cards one step up so a card stays a card on the new sheet:
CodeBlock and the artifacts ArtifactRow use surfaceContainerHigh and the
full-size artifact dialog uses surfaceContainerHighest. No geometry, inset or
dependency changes; all colours come from the existing theme.
Verified with gradle :app:assembleDebug and :app:testDebugUnitTest (137 tests,
0 failures) and by capturing the pane open over the graph and the Timeline at
both window widths on emulator-5554. android/README.md records the change and
evidence.
Add a README evidence subsection for the committed run-status colour change at 24584d8: the unit suite (143 tests, RunStatusPaletteTest 7/7 incl. contrast), assembleDebug with the published APK size and sha256, before/after pixel-sampled captures on emulator-5556, and the APK publish location and LAN URL.
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.
A stage opened from a run (Timeline, run graph or run stage list) now leads
with the run-side result instead of the stage's own definition: status,
outcome, duration, visit and target, then the visit's results in the order
Artifacts (gallery first), Output, Input, then the remaining run evidence
under This run. The stage's full definition (type, prompt, output contract,
outcomes, model, provider, configs, tools, limits, memory, notify) moves into
one collapsed "Stage definition" section at the bottom.
StageDetailPane gains a runContext flag: RunStagePane passes true and gets the
collapsed-definition default, while PipelineStagePane passes false and keeps
the definition expanded, since it is then the pane's only content.
rememberSectionExpansion gains an initiallyExpanded set (part of the save key)
so the seed respects an operator's own expand/collapse choices without
inheriting them across contexts.
Nothing visible before is removed - the previous Model/Provider headline
promotion is reverted and those facts remain reachable inside the expanded
definition. The visit tabs and the collapsed-by-default behaviour of the other
sections are unchanged. android/ only; no dependency added.
Updates android/README.md and StageDetailSheetTest.kt accordingly.
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.
Add android/scripts/capture_png.sh, which captures on-device (screencap -p -d <SurfaceFlinger id>) to /sdcard, pulls the file, and validates PNG magic bytes plus the reported type, deleting and failing on anything that is not a real image. Document the multi-display warning failure mode and the required helper in android/README.md so every UI-capturing run captures and validates instead of writing adb screencap straight to a file.
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.
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 791d3dd (the run-61 definition-only screenshots
are the Pipelines destination), the promoted facts are the real gap, and
the unit tests (132/0), assembleDebug, device verification on
emulator-5554 and the APK publish are noted with what was not verified.
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.
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.
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.
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.
Native installs left Docker-era harness profiles in harnesses.json, so every
authoring launch failed trying to reach a Docker service, and a retained draft
bound to the old Docker server was silently projected onto the configured one.
- harness: add Profile.Mode and VerifyDockerLink as the single mode/verification
helpers. `harness setup --host` configures or converts a host profile and
clears docker_directory; reconfiguring a Docker-linked profile re-verifies the
recorded directory still owns compose.yaml and fails naming it instead of
saving a link that cannot launch. Setup's summary and `harness list` (via the
new List/ListView shape) report the resulting mode and, for Docker, the
directory, without changing the stored Config schema.
- setup-native.py: after build/install-skill it writes host (no docker_directory)
profiles for the detected harnesses, defaulting to the detected OpenCode profile
rather than a stale pi default, taking models from --model or the existing valid
profile and never inventing one; it clears a stale Docker link and preserves
unrelated keys/profiles. Detection-only: no harness install, upgrade or download.
- draft: add Draft.Resolve, the shared mismatch helper, which projects a draft
onto the configured server and returns a dual-URL notice. CLI validate/submit
and the TUI draft browser use it so a foreign draft is never silently
retargeted; the TUI pre-wraps the notice to the panel width.
- Tests cover the Docker->host and host->host transitions, the missing-directory
failure, installer write/migration (Python), and the CLI/TUI notice, using the
real config file path in a temp dir.
- Update help text, README, docs and the packaged authoring skill reference to
describe host as the default and the Docker-linked case.
- 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).
Fix four stage failure-handling and observability defects (A2, A3, A6, A9).
- A2: add safeToReplay(def) as the single definition of retryable post-admission
work - only an explicit tools block that selects neither edit nor shell. The
agent/pi WorkStarted guards now break only when the stage is not safe to
replay, so read-only stages genuinely retry a post-admission timeout while
mutating and legacy-bundle stages still never replay admitted work.
- A6: re-emit a malformed final result on an explicit read-only stage up to the
retry budget, preserving format_repairs evidence; mutating stages keep the
immediate return and their session.
- A3: timed-out stages retain usable evidence. waitForSessionIdle records one
bounded sanitized OperationEvidence on deadline; the agent deferred cleanup
does a bounded best-effort latest-assistant readback and settles knowable V2
usage; RetainSession adds a retained_session pointer to failed step
transcripts so the session is visible beneath the BoundTranscript threshold.
- A9: a stage outcome routed to #failure now yields a non-empty run diagnostic
("stage <name> returned outcome <outcome>") while preferring an existing step
diagnostic.
Adds focused stage and server tests for retry safety, malformed-result
re-emission, timeout evidence retention and run-level diagnostics; updates the
packaged skill references and docs/cli.md, docs/model-results.md.
Every agent stage now writes into a per-run/step artifacts directory under
the data dir (<data>/artifacts/<run>/<step>), passed to Pi as
PIPELINES_ARTIFACTS_DIR, exposed on the OpenCode client env seam, and stated
in the agent prompt boilerplate so agents save images, screenshots, reports
and logs there.
After each step the server scans that directory with a bounded, symlink- and
traversal-safe inventory (os.OpenRoot + Lstat + O_NOFOLLOW) recording name,
size_bytes, content type (extension then 512-byte sniff fallback) and URL,
enforcing max files, per-file bytes and total bytes while counting skipped
and truncated entries. A missing, unreadable or oversized directory yields
only a best-effort diagnostic and never changes the step outcome.
The list is carried on protocol.RunStep as Artifacts []StageArtifact plus
skipped/truncated counters (omitempty, backwards compatible), persisted in a
new step_artifacts table keyed (run_id, sequence) alongside the
notifications/file-changes tables and loaded by GetRun.
GET /artifacts/{run}/{step}/{name} on the existing handler serves the bytes
with http.ServeContent, so Content-Type, Content-Length, HEAD and Range
(206/416) come from the stdlib; unknown runs/steps, absolute paths,
traversal, symlink escapes and non-regular files are refused.
The TUI lists each selected step's artifacts (name + human size) in the
retained-evidence section and adds an artifacts summary in the style of the
file-changes summary. Adds docs/stage-artifacts.md linked from README and an
artifacts subsection to the packaged operations skill reference.
Tests cover the scan records and caps, missing/oversized directories,
HTTP HEAD/Range/traversal/symlink/unknown refusals and protocol round-trips.
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
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.
- Only change source files under `app/`. The Go server, web proxy (`web/`) and installation scripts are read-only. User-requested web/server deployment and APK publication are allowed through the installer after checking quiescence and preserving a rollback. Never restart shared services merely for client tests or manipulate real operator chats/runs for testing.
- This Flutter app is the only client: it replaced the former JavaScript web client and the Kotlin Android app.
- No backend changes; report missing capabilities.
- One Material UI on every platform: standard Material controls, including buttons/menus in custom graphs/diffs/chat. No Cupertino widgets, `cupertino` flags, Cupertino tests or Cupertino captures; remove Cupertino branches you touch rather than extend them. System typography, theme colors, light/dark, content-driven layout and text scaling. No fixed row/bubble/button dimensions, bespoke palette or CSS token port. Centralize necessary layout constraints; do not ban legitimate native default spacing or graph coordinates.
- Develop and test on web by default; user-requested Android release APK builds and publication are allowed. When the user authorizes device installation or testing, perform it directly on the named device; no pipeline stage or resource lease is required. Keep source portable to all three targets. Distinguish APK build/publication from on-device verification; report mobile behavior as unverified when no device test ran.
- Small cohesive files (aim below 250 lines; split by responsibility, not arbitrary fragments). Each task owns a directory and its tests. Do not edit another lane or root pubspec/main unless assigned.
- Code quality is a delivery requirement. No minified implementations, silent capability fallbacks, fake data masking missing features, or workarounds that bypass the real defect. A pipeline success does not waive missing behavior, native controls, regression coverage or rendered evidence. Label incomplete work honestly and complete it before claiming parity.
- The manager drives authorized routine integration and recovery without repeatedly stopping for permission. Feature implementation stays in pipelines where appropriate; infrastructure blockers can be resolved directly within the user's authorized scope. Verify quiescence, preserve data and rollback, act, and report actual results. Ask only for genuinely new scope or unresolved destructive choices.
## Shared contract
-`lib/core/api_gateway.dart`: `JsonMap` alias; `ApiGateway.call(type, [fields])` yields the entire decoded reply envelope; `frames` yields unsolicited server envelopes. Gateway owns request IDs. Do not put domain interpretation in transport.
- Feature directories: `lib/features/{pipelines,runs,chat,schedules,search,artifacts,settings,templates}/`. Pure domain logic has no widget imports. Feature screens receive an `ApiGateway`; do not open their own sockets.
-`lib/ui/adaptive/` owns platform primitives; `lib/shell/` owns navigation and composition. Manager integrates feature registration. Feature lanes may supply `screen.dart` but do not edit shell/main.
- Use existing dependencies. Only the assigned foundation lane or manager edits pubspec/lock.
- Tests mirror directories under `test/`; tests use local fixtures/fake gateways, never mutate production. Put item evidence in `notes/<item>.md`, not shared queue.
## Tools and verification
Flutter: `/Users/alan/development/flutter/bin/flutter`; Dart beside it. Run pub get per worktree; never upgrade shared SDK. Run tests only through the memory watchdog, from `app/`: `tool/memwatch/full.sh test` (or a focused `tool/memwatch/full.sh test/<area>` while editing). Never run a bare `flutter test`, because a runaway test has crashed the Mac. Off a terminal it is quiet: one verdict line (counts, peak MB, duration, exit), only failing tests with bounded errors, and the full log path; read that log with grep or a line range rather than whole, or set `MEMWATCH_OUTPUT=full`. `tool/memwatch/quiet_test.sh` checks this output. `tool/memwatch/install.sh` restores the legacy `/tmp/memwatch` shims. Use `tool/analyze.sh` (bounded `flutter analyze`) and `flutter build web` for integrated acceptance. No Go/legacy client checks needed for app-only changes.
Rendered changes require real browser interaction/captures; widget tests alone are not browser evidence. Use isolated loopback servers and OS-assigned ports. Browser automation may use Chrome DevTools, with independent scripts under `app/tool/`; do not modify legacy browser drivers. Never disable authentication on exposed services.
UI capture and review: use `tool/capture/` (see its README). It is one generic Chrome DevTools kit over the full-app fixture `tool/search_selection_probe_entry.dart`. It opens any route at a given size, platform and theme, clicks by semantics label, identifier or point, types text, takes screenshots and films transitions. If a feature's legacy `tool/*_probe.mjs` driver is stale (missing labels, outdated status text), capture with this kit; a stale driver is not a reason to report blocked. Inspect every PNG you cite.
Keep commits referenced; do not discard unrelated work or delete branches. Deploy only when requested by the user; preserve existing public URLs unless a cutover is part of that request. Land candidates per selected pipeline; manager verifies actual ancestry and records source, checks, landing and deployment separately.
## Device testing
The ADB executable is `/Users/alan/Library/Android/sdk/platform-tools/adb`.
Use that absolute path (or explicitly add its directory to PATH); `adb: command
not found` alone is not evidence that the leased device is disconnected.
For populated attention review, `TestExportReadyAttentionReviewFixture` exports a
create-only scratch database when `PIPELINES_ATTENTION_REVIEW_DIR` names a new
directory. Its fixture.json identifies one failed, one finished and one waiting
run and the workspace. Build a scratch server, read back those states, and keep
the owned server alive through all UI interactions. The export itself does not
leave a server running or configure a device. Never use a dead scratch endpoint.
The manager may install, interact, capture and profile directly when authorized
by the user. Check for active shared work first, use an explicit `adb -s` serial,
preserve app data, and record and restore any device settings changed for testing.
Do not require a runner lease or a particular pipeline role.
Known test devices are:
-`phone-47241FDAS00DLK` — the operator's **Pixel 9 Pro XL**, adb serial
`47241FDAS00DLK` (metadata `kind=phone`).
-`emulator-Pipelines_Fold_A` — one managed **foldable emulator**, adb serial
`emulator-5554` (metadata `kind=emulator`, `avd=Pipelines_Fold_A`). Its unfolded
built-in display is 2076x2152; its cover display is 1080x2424.
The operator's **Pixel 10 Pro Fold** (`58281FDCG000JF`) is delivery-only: never a
test target. Do not start an ad-hoc emulator — the one managed foldable AVD above
is the only emulator in scope.
The UI reviewer records original app connection/workspace, display size and power/settings
before changing them. Before any capture: `svc power stayon usb`, `settings put global stay_on_while_plugged_in 7`,
`input keyevent KEYCODE_WAKEUP`, `wm dismiss-keyguard`. Capture with
`adb -s <serial> shell screencap -p /sdcard/shot.png` then `adb pull` — never `exec-out > file`.
Wide layout: `wm size 2000x2244`; the fold's unfolded shape is `wm size 2076x2152`; `wm size reset`
afterwards either way.
Create controlled fixtures for changed screens/states (including human-decision sheets)
on a scratch server/database and throwaway session; never depend on incidental production
state, change a real operator session, or restart a deployed service. Use the configured
authoritative endpoint, never a scratch URL as a project default. Keep all shell/ADB work
foreground and awaited: do not leave test processes running after testing.
Restore the captured original settings after testing. Leave the user-requested
build installed unless they request otherwise. Confirm every test tool has exited.
If capture, restoration or cleanup fails, report the failure explicitly; do not
Target: current `web/src/` behavior and latest entries in `web/PARITY.md`, NOT
web CSS. Native Material/Cupertino controls, typography, semantic colours and
content-driven sizing take precedence over visual-review styling suggestions.
`WORK.md` is the run/commit queue; this file tracks what remains for a full port.
## Evidence vocabulary
- **Preview**: registered in the normal app and published to8096, with fixture
browser interaction/captures. This does NOT imply live production mutations.
- **Source**: landed/tested reusable code, not a delivered screen.
- **Active**: assigned implementation, not accepted or deployed.
- **Missing**: still required; no implied fallback or scope waiver.
Live authenticated data, OS sharing/notifications and Android/iOS device behavior
remain unverified unless explicitly recorded. Test mutations use isolated fakes
or scratch servers only, never real operator sessions/runs/workflows.
## Functional inventory
| Area | Current state | Remaining acceptance |
| --- | --- | --- |
| Shared transport/settings connection | Preview: reconnect when the app returns to the foreground and the protocol-mismatch warning stays visible (8b9a298d) | native boot uses the saved endpoint (run 155); a connected foreground return re-reads the visible Pipelines/Runs list (run 157) skipped while a dialog, page or text field is in use (run 158); the list keeps its scroll on the re-read (run 160, test-only) |
| Native shell/run URLs | Preview: full route vocabulary; pipeline/version/stage, template detail and run visit/stage links open their detail/pane; `?action=decide` opens the run's decision prompt (9344e6d3) | `pipelines://run/<id>` registered on Android and iOS and routed to the run (cold start and running app); not yet exercised on a device |
| Pipeline list/filter/sort/detail/source/versions | Preview: recorded row metadata and miniature, pinned detail URLs, filter/sort | none outstanding on the list/detail read path |
| Definition graph | Preview: measured native canvas, pipeline Graph tab, pan/zoom, expanded view, stage definition pane, pipeline stage deep link | none outstanding on the definition graph read path |
| Start a pipeline | Preview: native Run action, prompt/workspace/notify dialog, pinned run request, response-loss check/retry | pending launch intent persists across a reload (run 159) keyed per server (runs 159, 161) |
| Templates | Preview: gallery/detail/source, create-only dialog via Settings → Templates, list invalidated on create | create refresh verified against a real server (the web has no run-detail template link, so none is added) |
| Runs list/filter/sort/live fold | Preview | shell live/attention state (filter menu and day groups landed) |
| Run detail/input/output/copy | Preview: Summary recorded fields with exact unknown wording, Input/Output/Copy (no usage metrics block, matching the web since be6b6239) | verify the remaining server-shape variants against fixtures |
| Rename run | Preview | verified exact accepted title fold; no live production mutation tested |
| Cancel run | Preview | exact confirm/server-accepted detail+list fold; production cancellation not tested |
| Retry/restart | Preview controls in the run detail | accepted new-run navigation, stale/refusal handling verified in the app |
| Human decisions | Preview waiting card/native prompt/exact accepted reply | attention/action URL entry; no production decision answered during tests |
| Run graph | Preview: Graph tab with legend, recorded-stage selection, canvas pan/zoom, an expanded view, and a live pulse on the recorded current stage while executing | rendered browser capture of the pulse; styling advisories tracked in `notes/graph-pulse.md` |
| Timeline/recorded visit pane | Preview: selection opens the recorded facts with Input/Output/Artifacts/Session/Definition sections and exact absence wording | — (the server's one repair command, export-only retry, is wired per visit; in-flight state survives remounts) |
| Changes/diffs | Preview via run detail: one recorded visit at a time with Previous/Next paging and capture states, probed in Chrome (9532ecdd, c0ba5d54); recorded file/diff/close/back verified | — (the run-wide aggregate shows only for a succeeded run, as the web) |
| Artifact groups | Preview: recorded groups in run detail, per-visit drill-down, turn documents (input/memory/output, session.html) in the run gallery | — (images, video, markdown, text/logs/JSON/code, CSV/TSV tables and inert HTML preview in-app; session exports stay external) |
| Artifact preview | Preview: image + markdown/text in-app through the chat renderer, paging, honest unsupported/external/HTTP states | — (video plays in-app; HTML renders sandboxed; CSV/TSV as tables) |
| Artifact actions | Preview: external Open, Copy link, download and native share carry the recorded name/MIME bytes; progress, cancel, HTTP failure and unsupported-share states | OS share/download on Android/iOS remain unverified until the final build |
| Session audit/export repair facts | Preview: recorded export state/reason, repair request with one-shot submit and refusal, session.html external-only | rendered browser evidence for the repair control |
| Chat session management | Preview list + open session; shared create/rename/star/close/reopen with server-refreshed rows and full-width row refusals; local hide/undo and this device's read watermark (open rows only; a closed row never shows `New`) | web action-failed report is a modal (Flutter keeps the refusal under its row with an `OK` dismiss), hide closing an open conversation is not reachable here (the list is offstage while one is open), web `Open` badge (the list is offstage while a conversation is open; deep-linked chats are marked read, run 162), create dialog in the shell |
| Chat history/live transport | Preview: `/chat` list and `/chat/:id` history, paging, live failure notice; composer integrated with the thread | run-detail-style reconnect verification in the real app |
| Chat activity/reasoning/tools | Preview: one activity line, expanded native overlay with lifecycle/input/output/error/duration/edit diff | compaction wording variants |
| Chat composer | Preview: field, Send/Stop, persisted draft, queued/refusal lines; attachments sent with the prompt (87bb518c); slash palette with no-send routing (63babc59); file and text paste (copied text keeps the field's caret and draft); one verified send in the real app flow | — (slash command actions landed) |
| Chat attachments | Preview: host picker, pasted files through the same bounded 1 MiB draft, composer chips, base64 wire payload, sent with the prompt (87bb518c); the sent turn shows its files until history replaces it (run 156) | — |
| Chat permissions/questions | Preview: native approval/risk and question cards in the conversation view, Chrome fixture captures under the C4 probe (`notes/C4-approvals.md`) | authenticated smoke with a real pending approval/question; live multi-client resolution; no production decision sent |
| Chat model/Info/background tasks | Preview: numeric Info sheet (unknown != 0); header model control and chooser (`notes/chat-model-picker.md`); `Background tasks` bar with `N running`, capped scrolling rows, selected-task detail and one bounded `chat_shell_output` page (cursor 0, 64 KiB) that reports empty/unavailable/refused states, re-read on reconnect; the bar keeps half the viewport and the output pane twelve scaled lines (run 139 + manager fix; widget tests, published, no rendered capture yet) | rendered browser captures of the model chooser and the task bar; authenticated smoke with a real running shell |
| Chat commands/notices/scroll | Preview: dismissible local notices with reconnect clearing; slash palette with the unknown-command report and `Send as message` / `Cancel` (63babc59, `notes/C9-commands.md`); streamed follow and restored read position (e4c196d7) | `/rename` sends the shared server rename (operator decision; the web's is device-local) |
| Saved schedule list | Preview: Settings row, /schedules route, read-only list; a row opens the owning pipeline detail (Summary by default) | authenticated smoke |
| Schedule editor | Preview: pipeline Summary creates/edits/pauses/deletes with the lossless draft and revision guard; conflict keeps the draft and shows the server words; Schedule this run seeds the editor with the recorded run's options (f2c33d2a) | authenticated smoke |
| Search | Preview: exact target model and navigation to pipeline, pinned version, run and recorded stage; field/artifact hits select the recorded Summary section/visit (artifact hits follow web S2/Android and open the recorded visit, where the current browser source opens the artifact externally); a retired field or unknown visit selects the plain Summary; unresolvable hits stay read-only | authenticated smoke; rendered capture of the field/artifact selection |
| Notifications | Preview: Settings permission tile over live platform state, transition-only dedupe, tap opens the run | permission/browser smoke only in fixtures (background question notices landed) |
| Mobile replacement build | Native build: Android release APK from clean main `67045f25` (`net.awan.pipelines.next`, label `Pipelines Next`, debug-signed, `app/build/android-testing/pipelines-next-67045f25.apk`, sha256 `084a06b8…`); iOS `Runner.app` compiles unsigned after the deployment target moved to 15.0; all six web-only modules have conditional stubs; no device install, OS share/notification or endpoint smoke yet | phone install against a reachable endpoint (the server binds loopback only; a tailnet TLS-terminated forward gives `wss://`, which avoids Android cleartext), device/OS behavior, release signing |
## Current-reference corrections
Latest behavior supersedes older parity rows: Enter inserts a newline and
Ctrl/Cmd+Enter sends; chat rename/star are server-shared; chat usage is behind
Info; graph clicks open recorded visits; image artifacts preview internally;
artifact Share carries bytes as a named file, never a URL; attachments use the
latest bounded attachment envelope. Native layout differences are intentional;
missing behavior is not a native-layout difference.
## Completion gate
Every row must have actual normal-app registration, request/state regression
coverage, and real-browser evidence for visible/interactive states. Recheck
integrated analysis/tests/build and publish the verified preview. Produce the
requested Android testing build only after development acceptance; do not use
the personal delivery device for tests. Distinguish code, landing, publication,
authenticated smoke, native build and device/OS verification in the final report.
| Server evidence | Re-saved visit keeps newest evidence | manager fac055d | runs failed on a raw duplicate key when the runner saved a visit twice; per-visit evidence now upserts under the serialized writer; Go suite green | committed main | deploy after quiescence |
| Miniature | Pipeline row preview | run116 micro | recorded preview only, external never fetched | merged main | - |
| Schedules list | (no change needed) | run109 no-op | list screen already landed; only route registration remains (manager) | - | route wiring |
| Pipeline metadata | Recorded list-row facts | run108 micro | single behaviour; pipelines tests | merged main | miniature next |
| Search target | Exact hit identity model | run105 /cbba026c | micro lane (single behaviour, no probe); 41 search tests | merged main | navigation wiring next |
`RobotoMono-Regular.ttf` and `RobotoMono-Bold.ttf` are Roboto Mono by
Christian Robertson, licensed under the Apache License, Version 2.0
(https://www.apache.org/licenses/LICENSE-2.0). The files are copied unchanged
from the Flutter SDK's DevTools assets. They give monospace text (artifact text
previews, background task output) a real fixed-width face on every platform:
Flutter web does not resolve the generic `monospace` family.
## Optional interface fonts
Chosen per device in Settings > Font (`lib/ui/theme/app_font.dart`). They are
declared as plain `assets:`, not `fonts:`, so Flutter web does not download them
at startup; the chosen family is registered on demand with a `FontLoader`. Each
directory holds the unmodified Regular (400), Medium (500), SemiBold (600) and
Bold (700) static TTFs and the family's SIL Open Font License 1.1 as `OFL.txt`,
which is also registered with `LicenseRegistry`.
| Directory | Family | Source | Licence |
| --- | --- | --- | --- |
| `inter/` | Inter 4.1 | github.com/rsms/inter release v4.1, `Inter-4.1.zip`, `extras/ttf/` | OFL 1.1, (c) The Inter Project Authors |
| `ibm-plex-sans/` | IBM Plex Sans 1.1.0 | github.com/IBM/plex release `@ibm/plex-sans@1.1.0`, `ibm-plex-sans.zip`, `fonts/complete/ttf/` | OFL 1.1, (c) IBM Corp., Reserved Font Name "Plex" |
| `source-sans-3/` | Source Sans 3.052 | github.com/adobe-fonts/source-sans release 3.052R, `TTF-source-sans-3.052R.zip`; licence text from `LICENSE.md` at that tag | OFL 1.1, (c) Adobe, Reserved Font Name "Source" |
| `atkinson-hyperlegible-next/` | Atkinson Hyperlegible Next | github.com/googlefonts/atkinson-hyperlegible-next (no releases) at commit 7925f50f, `fonts/ttf/` and `OFL.txt` | OFL 1.1, (c) The Atkinson Hyperlegible Next Project Authors |
The files are unmodified (no subsetting), so the Reserved Font Names stay
Copyright 2010-2022 Adobe (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe in the United States and/or other countries.
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>PreviewsEnabled</key>
<false/>
</dict>
</plist>
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.