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.
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.