Commit Graph

308 Commits

Author SHA1 Message Date
alan 88595ebd55 Land scoped stage artifact access 2026-10-18 12:03:02 +01:00
alan 31aec05f99 Scope stage artifact access by run visit
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.
2026-10-18 12:02:37 +01:00
alan dbff7f9a47 Merge stage deadline diagnostics distinguishing active overruns from transport failures 2026-10-18 11:17:09 +01:00
alan 31d8f4a6d5 Distinguish active stage deadlines from harness transport failures
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.
2026-10-18 11:17:01 +01:00
alan b93eee234c session export: write only session.html, retire the markdown export
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.
2026-10-18 10:08:02 +01:00
alan 70529926cc Merge main into session-html-only: combine the html-only session export with chat-tool-group and chat-activity 2026-10-18 10:06:54 +01:00
alan 95362134aa session export: write only session.html, retire the markdown export
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.
2026-10-18 10:06:49 +01:00
alan 51a2ba43c4 Merge chat-tool-group: one tool-call summary chip per turn, opening the call list 2026-10-18 09:59:25 +01:00
alan 194540b768 Merge main into chat-tool-group: combine the tool-call summary chip with the chat-activity feature
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.
2026-10-18 09:59:13 +01:00
alan 7fbbd95374 chat: one tool-call summary chip per turn, opening the call list
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.
2026-10-18 09:58:28 +01:00
alan 7b0dc94d37 Merge chat-activity: name the chat's in-flight state and surface background processes
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.
2026-10-18 09:46:13 +01:00
alan 7d9490bba1 chat: name the in-flight state, and surface background processes
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.
2026-10-18 09:45:28 +01:00
alan 5a4cfc2e9c Merge run-title-framing: title the task, not the framing 2026-10-18 02:52:32 +01:00
alan 9565adc5f5 Merge main into run-title-framing: bring the run-title framing fix onto current main
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.
2026-10-18 02:52:27 +01:00
alan c88bb27775 summarise: title the task, not the framing
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.
2026-10-18 02:52:15 +01:00
alan e270dca077 Merge verify-gaps: record the four end-to-end verification gap checks against the deployed server 2026-10-18 02:47:20 +01:00
alan f43115ef0a Merge branch 'main' into verify-gaps 2026-10-18 02:46:48 +01:00
alan db313336b2 docs: record the four end-to-end verification gap checks (run 340)
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.
2026-10-18 02:46:46 +01:00
alan 7b8ba6745d Merge runevent-snapshot: write a subscribe snapshot in full before its ack
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.
2026-10-18 02:24:38 +01:00
alan cff6f4dfac server: write a subscribe snapshot in full before its ack
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).
2026-10-18 02:23:58 +01:00
alan 0d9430e4ad Merge docs-event-driven: rewrite the workflow docs for the agent-driven model (no driver, no poll loop, no lanes) 2026-10-18 01:51:09 +01:00
alan 93dc0103c3 Merge main into docs-event-driven: bring the agent-driven workflow docs onto current main 2026-10-18 01:50:59 +01:00
alan 01d5dad9b9 docs: describe the agent-driven workflow, drop the scripted driver model
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.
2026-10-18 01:50:55 +01:00
alan 2c8115b6f9 Merge chat-turn-render: the chat transcript now folds one agent reply into one bubble, keeps reasoning and answer in separate parts and retains a tool call's name and input for its whole lifecycle 2026-10-18 01:48:49 +01:00
alan d26db8f830 Merge main into chat-turn-render: pick up the end-to-end app verification report alongside the chat turn fold 2026-10-18 01:47:55 +01:00
alan 798e958cb7 chat: fold an agent turn into one reply, split reasoning from answer, keep tool name/input
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.
2026-10-18 01:47:52 +01:00
alan d0c12e3b75 Merge e2e-verify2: add end-to-end app verification report against the real server
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.
2026-10-18 01:36:38 +01:00
alan 8c3efa4143 docs: add end-to-end app verification report against the real server
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.
2026-10-18 01:36:22 +01:00
alan 0d1ddc73a4 Merge wait-cmd: add pipelines wait <run-id> to block until runs finish, then report them
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.
2026-10-18 01:12:57 +01:00
alan fdaa930bc9 Merge main into wait-cmd: combine the wait command with the work-queue skill and chat pairing
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.
2026-10-18 01:12:53 +01:00
alan 8f3ebf74ad skill: replace the lane model with the work queue
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.
2026-10-18 01:12:21 +01:00
alan 1e7607c502 Merge main into wait-cmd: combine the wait command with chat-persistence pairing
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.
2026-10-18 01:11:54 +01:00
alan b7c2ba7d56 cli: add wait <run-id> to block until runs finish, then report them
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.
2026-10-18 01:11:26 +01:00
alan 2da583c946 Merge chat-persist: attach chat to the operator's own OpenCode by pairing, and fall back honestly
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.
2026-10-18 00:56:29 +01:00
alan 648c9c33d8 Merge main into chat-persist: combine OpenCode pairing chat persistence with main's bottom selector strip
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.
2026-10-18 00:55:48 +01:00
alan 0ba1204895 chat: attach to the operator's own OpenCode by pairing, fall back honestly
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.
2026-10-18 00:55:26 +01:00
alan 78725e92f0 Merge bottom-strip: move the detail and visit selectors to a bottom strip on narrow windows
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.
2026-10-18 00:50:29 +01:00
alan 49f40bfe45 android: move the detail and visit selectors to a bottom strip on narrow windows
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.
2026-10-18 00:50:15 +01:00
alan d9619ea568 Merge slash-commands: run /new, /close, /rename, /stop and /help from the chat composer
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.
2026-10-18 00:25:18 +01:00
alan dc75791992 Merge main into slash-commands: combine the composer's slash commands with the
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.
2026-10-18 00:24:41 +01:00
alan fa6106ea46 android: add slash commands to the chat composer, starting with /new
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.
2026-10-18 00:22:33 +01:00
alan 643073d602 Merge lane-pill: make the destinations pill a true overlay, centred narrow and right when wide
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.
2026-10-18 00:21:34 +01:00
alan d6cb1931d0 Merge main into lane-pill: combine the pill overlay with main's chat-close, omni-search and status work
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.
2026-10-18 00:21:20 +01:00
alan 5a44ff1568 android: make the destinations pill a true overlay, centred narrow and right when wide
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.
2026-10-18 00:20:37 +01:00
alan d3dd5ab868 Merge chat-close: finish a chat on the server and keep its history
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.
2026-10-18 00:19:40 +01:00
alan f85c172dc2 Merge main into chat-close: combine the shared chat room with the server-side close
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).
2026-10-18 00:19:23 +01:00
alan 971e555ceb chat: close and reopen an operator session on the server, keeping its history
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.
2026-10-18 00:16:24 +01:00
alan 2c1dfe9a35 android: restore the shared LabelChip the search-icon replay deleted
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.
2026-10-18 00:13:17 +01:00
alan 986a62b09f android: add omni-search type icons with a kind filter and sorting
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)
2026-10-18 00:12:07 +01:00
alan 36977d7353 Merge multiclient: fan a chat session out to every client and answer approvals exactly once
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.
2026-10-18 00:10:23 +01:00