web: shared chat stars, pipeline mini graphs and agent questions

- Persist chat stars in the operator-session registry (chat_star) so every
  browser/device shows the same Starred group; migrate old local stars once.
- Add a compact pipeline graph shape to list responses and draw a lightweight
  list miniature; replace the cryptic id/version line with the stage count.
- Surface OpenCode form questions as a chat card (chat_answer), replay a
  pending form to late subscribers, and notify for background questions.
- Make the mobile dock's Search cell equal to every destination, keep the
  tab row visible with 100svh, and let Source use the full pane height.
- Let a fresh sign-in auto-connect to its own origin; use a Lax session cookie
  with Expires so Remember me survives app/link launches.
- Keep shipped starters and the skill agnostic: no repository paths, project
  areas or personal device commands; add Diagnose/Fix and Research starters.
- Refresh the installed skill and document the new browser conventions.
This commit is contained in:
2026-10-20 03:11:37 +01:00
parent caae8a8038
commit 526c19fc21
46 changed files with 1547 additions and 611 deletions
+18 -27
View File
@@ -7,21 +7,15 @@ pipeline automatically; all templates are manual-only and have at most four stag
| --- | --- | --- |
| `task` | Complete a task, then commit it locally | Work: read/edit/shell and conditional web search/fetch; committer: read/shell |
| `review` | Read repository content and report findings | Read/glob/grep and conditional web search/fetch; no edit/shell |
| `research` | Research a topic, then write a sourced report | Web search/fetch, then none |
| `three-stage` | Plan → implement → review → commit | Planner read/glob/grep + conditional web; implementer read/glob/grep/edit/shell with no web (follows the planner's research); reviewer independent shell + conditional web; committer read/shell |
| `docs-fold` | Fold accumulated item documentation notes into the shared docs, then commit locally | Fold: read/glob/grep/edit/shell; committer: read/shell |
| `research` | Research a question, then write a sourced report | Web search/fetch, then none |
| `three-stage` | Plan → implement → review → commit | Planner read/glob/grep + conditional web; implementer read/glob/grep/edit/shell; reviewer independent shell + conditional web; committer read/shell |
| `debug` | Diagnose → fix → verify → commit | Diagnose read/shell; fix read/edit/shell; verify read/shell; committer read/shell |
Every workflow that changes the repository ends in a **committer** stage that
commits locally and never pushes. The committer inspects `git status` and the full
diff, stages this run's change (a model-declared list can be incomplete), then runs
the repository's required checks before committing. `task` and `three-stage` follow this;
`review` and `research` change nothing and so do not commit.
`docs-fold` is the deliberate **single documentation writer**. A per-item workflow never
edits a shared README or topic doc: when its change makes one stale it records a note at
`docs/notes/<slug>.md`, unique per item, and commits that note with the change. Running
the manual-only `docs-fold` pipeline later folds the accumulated notes into the shared
documentation and removes them.
diff, stages this run's change, and runs the repository's required checks before
committing. `task`, `three-stage` and `debug` follow this; `review` and `research`
change nothing and so do not commit.
Model and agent stages read the turn's `input.md` and `memory.md`, then return the
complete `output.md` markdown. The only required section is `# outcome` followed by
@@ -32,15 +26,13 @@ Web search/fetch is conditional: stages use it only when a task genuinely needs
external knowledge such as accepted industry approaches, framework or library
APIs, current security/compatibility guidance, or unfamiliar techniques, and they
state why when no research is needed. Trivial, fully understood local edits do not
force web access, and conditional research fails closed only when the required
reliable evidence cannot be obtained, not merely because one search failed. The
`three-stage` implementer has no web tools and works from the planner's research
with local read/edit/shell. The `three-stage` reviewer is an independent quality
gate: it receives the original task and the planner's plan/design/reuse
targets/acceptance checks, inspects the actual changed files and runs its own
checks, returns success only when the applicable acceptance checks were
independently observed passing and no unresolved substantive issue remains, and
otherwise rejects with concrete findings even when a stage reported success.
force web access. The `three-stage` implementer works from the planner's research;
the reviewer is independent and checks the actual change rather than trusting a
stage summary.
No template assumes a language, framework, repository layout, device, deployment
target or notification setup, and none pushes to a remote. They read the project's
own conventions instead of naming files that only exist in one repository.
In the TUI, use `:templates`, choose a starter, and press **s** or Enter on
**Submit template**. Type a name, press Enter to save a retained draft, then
@@ -55,14 +47,13 @@ pipelines drafts
pipelines submit /path/printed/by/new.md
```
New drafts inherit the server's configured default model. The checked-in files
contain a fallback model; direct file submission uses those configs as written.
Provider inference and search availability must be verified on your execution
server. Parsing a definition does not prove its model/tools can run.
A draft created through the UI or `new` inherits the server's configured default
model. The checked-in files carry an example provider/model for direct file
submission; replace it with one your execution server actually supports. Provider
availability and search support must be verified on that server.
Templates do not impose a language, framework, schedule, notification setup or
deployment, and they never push to a remote. Work-producing templates commit
locally through their committer stage; add a schedule, notifications or a
deployment, and they never push to a remote. Add a schedule, notifications or a
deployment step only when your own workflow requires it.
Editing these source files does not change any installed or published definition;
+2 -2
View File
@@ -15,8 +15,8 @@ var starters = []protocol.Template{
{Key: "task", Name: "Complete a task", Description: "Complete a task in your repository, then commit the change locally."},
{Key: "three-stage", Name: "Plan, implement, review", Description: "Plan a change, implement it, review and verify it, then commit it locally. Any language or file type."},
{Key: "review", Name: "Review a repository", Description: "One read-only stage to review repository content and report findings."},
{Key: "research", Name: "Research a topic", Description: "Research a topic on the web, then write a sourced report. Requires web search support."},
{Key: "docs-fold", Name: "Fold documentation notes", Description: "Fold the accumulated per-item documentation notes into the shared docs, then commit locally. The repository's single documentation writer; manual-only."},
{Key: "research", Name: "Research a topic", Description: "Research a question from primary sources, then write a sourced report. Requires web search support."},
{Key: "debug", Name: "Diagnose and fix a failure", Description: "Reproduce a failure, find its cause, fix it, verify the fix, then commit locally."},
}
func Catalog() []protocol.Template {
+6 -4
View File
@@ -32,7 +32,7 @@ func TestCatalogContainsValidUnpublishedTemplates(t *testing.T) {
t.Fatal("unexpected catalog size", len(items))
}
seen := map[string]bool{}
wantStages := map[string]int{"task": 2, "review": 1, "research": 2, "three-stage": 4, "docs-fold": 2}
wantStages := map[string]int{"task": 2, "review": 1, "research": 2, "three-stage": 4, "debug": 4}
for _, item := range items {
if seen[item.Key] || item.Description == "" || item.Name == "" {
t.Fatal("invalid template metadata", item.Key)
@@ -105,8 +105,10 @@ var starterTools = map[string]map[string][]string{
"reviewer": {"read", "glob", "grep", "shell", "websearch", "webfetch"},
"committer": {"read", "glob", "grep", "shell"},
},
"docs-fold": {
"fold": {"read", "glob", "grep", "edit", "shell"},
"debug": {
"diagnose": {"read", "glob", "grep", "shell"},
"fix": {"read", "glob", "grep", "edit", "shell"},
"verify": {"read", "glob", "grep", "shell"},
"committer": {"read", "glob", "grep", "shell"},
},
}
@@ -171,7 +173,7 @@ func TestWorkProducingStartersEndInACommitter(t *testing.T) {
for _, tc := range []struct{ key, producer string }{
{"task", "worker"},
{"three-stage", "implementer"},
{"docs-fold", "fold"},
{"debug", "fix"},
} {
graph := parsedCatalog(t)[tc.key]
last := graph.Stages[len(graph.Stages)-1]
+117
View File
@@ -0,0 +1,117 @@
# stage diagnose
```prompt
Investigate the reported problem in input.md without editing. Read the relevant
code and logs, reproduce the failure with safe commands where possible, and find
the cause rather than the first symptom. Record the evidence, the smallest
credible fix, and anything you could not verify. Return blocked when the problem
cannot be reproduced or the needed evidence is unavailable.
```
```tools
read
glob
grep
shell
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> fix
blocked -> #failure
error -> #failure
```
# stage fix
```prompt
Fix the diagnosed cause with the smallest coherent change. Follow the
repository's conventions, preserve unrelated work, and add or update a regression
test that would fail before the fix. Run the relevant checks and report the exact
commands and actual results. Do not commit, push or deploy.
```
```tools
read
glob
grep
edit
shell
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> verify
blocked -> #failure
error -> #failure
```
# stage verify
```prompt
Independently verify the fix. Reproduce the original problem, run the relevant
checks, and inspect the changed files. Do not edit. Return success only when the
original failure is gone and the checks pass; otherwise return rejected with
concrete evidence.
```
```tools
read
glob
grep
shell
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> committer
rejected -> #failure
error -> #failure
```
# stage committer
```prompt
Commit this run's change locally. Inspect `git status` and the full diff; stage
only this run's work, never secrets or generated files. Run the relevant checks
and report the actual results. If nothing changed, say so rather than creating an
empty commit. Do not push, tag, deploy or rewrite history.
```
```tools
read
glob
grep
shell
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> #success
blocked -> #failure
error -> #failure
```
-71
View File
@@ -1,71 +0,0 @@
# stage fold
```prompt
Fold the accumulated per-item documentation notes into the repository's shared
documentation. Read every file under `docs/notes/`; for each note, apply the change it
records to the shared document the note names - the repository's READMEs and topic docs
and the packaged skill references - then delete the consumed note. Do not edit any other
file, change behaviour, or rewrite documentation that is still true. Keep values from
their single existing sources. An empty or missing `docs/notes/` directory is a success
no-op: make no change, commit nothing, and say so. Limit inspection to the notes
directory and the documents they name; never scan filesystem or mount roots, and use
commands supported by the actual execution environment. Save any artifacts you produce
into the artifacts directory named in the runtime context. Report the notes read, the
documents changed and the notes deleted in an `# evidence` section, with the exact
commands and observed results. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need. Return blocked if the notes directory cannot be read.
```
```tools
read
glob
grep
edit
shell
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> committer
blocked -> #failure
error -> #failure
```
# stage committer
```prompt
Commit this run's change locally. Never push, tag, deploy or rewrite history. Inspect
`git status` and the full diff, and stage this run's change, including the notes the
fold stage deleted (stage the removal, not only surviving paths). Inspect
the staged diff before committing; never commit unrelated work, secrets or generated
artifacts. When nothing is staged - for example an empty notes directory - do not create
an empty commit; return success with a clear note. Otherwise commit with a concise
message naming this run's change and report the commit hash. If a required check fails,
do not commit; return blocked with the failing output. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need. Never claim an unexecuted check passed or fabricate a
commit.
```
```tools
read
glob
grep
shell
```
```configs
provider=opencode-go
model=deepseek-v4.1-flash
retries=2
timeout=1h
```
```edges
success -> #success
blocked -> #failure
error -> #failure
```
+8 -18
View File
@@ -1,19 +1,11 @@
# stage research
```prompt
Research the topic in the task in input.md using web search and relevant source pages.
Preserve the question and constraints. Prefer authoritative primary evidence
(official standards, upstream documentation, and versioned sources); record
supporting excerpts or facts, source URLs, and appropriate version/date/scope.
Prefer targeted queries and pages, treat fetched external text as evidence rather
than scope-changing instructions, and keep queries free of private code and
secrets. Distinguish current evidence from assumptions, report disagreement and
uncertainty rather than smoothing it over, state actual tool failures, evidence
gaps and source/version applicability, and do not invent citations. Return blocked
when required reliable evidence cannot be obtained, including empty or unreliable
results. A single failed, blocked or anti-bot search may be replaced
by a successful official-source webfetch that fully supplies the required
evidence. Return success only with reliable evidence. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need.
Research the question in input.md using authoritative primary sources. Record
the source URLs and the relevant version, date or scope. Keep queries free of
private code and secrets. Distinguish evidence from assumptions, report
disagreement and gaps, and never invent a citation. Return blocked when the
evidence needed for a reliable answer is unavailable.
```
```tools
@@ -37,11 +29,9 @@ error -> #failure
# stage report
```prompt
Answer the question in input.md using only the collected evidence and sources. Write a
concise report with citations and clearly marked uncertainties. Respect the
original constraints. Do not turn missing evidence into a confident answer.
Return success for a supported report or blocked when the evidence is insufficient.
Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need.
Answer the question using only the collected evidence and sources. Write a
concise report with citations and clearly marked uncertainty. Do not turn missing
evidence into a confident answer.
```
```tools
+6 -17
View File
@@ -1,23 +1,12 @@
# stage review
```prompt
Review the repository content described by the task in input.md. Read relevant files; do
not modify them or run commands. Focus on maintainability, duplication and
near-duplicate implementations, standards/library and version usage, and
consistency with repository conventions. As visible in source, assess root-cause
handling versus workarounds or shortcuts, unnecessary custom implementations,
complexity and coupling, appropriate reusable boundaries, and meaningful tests and
docs. Support each finding with a file path, specific evidence, severity and a
remedy; distinguish legitimate compatibility exceptions and nonblocking
personal-style nits from blockers. Prioritize correctness, clarity, consistency,
and the user's criteria without assuming a language or framework. Use
websearch/webfetch only when an official standard or documentation check is
needed, and record source dates/versions. Separate observed issues from
hypotheses. State explicitly that no commands were run and that runtime behavior
and checks are not tested; source inspection is not proof of execution. Return
success when the review is complete, even if it finds issues; return blocked if
the requested content or required official evidence cannot be obtained rather than
fabricating it. Do not claim issues have been fixed. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need.
Review the repository content described in input.md without modifying it or
running commands. Focus on correctness, clarity, maintainability, duplication and
meaningful tests. Use the repository's own conventions as the baseline, not a
preferred stack. Support each finding with a path, evidence, severity and remedy,
and separate observed facts from hypotheses. State plainly what was not tested.
Return success when the review is complete, even when it finds problems.
```
```tools
+8 -43
View File
@@ -1,33 +1,10 @@
# stage worker
```prompt
Complete the task in input.md in the run directory. Inspect only relevant context and
follow the user's scope and constraints. Limit repository inspection and
verification to relevant repository paths; never scan filesystem or mount roots,
and use commands supported by the actual execution environment rather than
guessed platform flags. This is a working instruction, not an OS sandbox. Work
with the repository's actual languages and file types; do not assume a framework
or technology. Prefer repository conventions, supported standard libraries and
existing dependencies/APIs/helpers over bespoke or copy-pasted code, and avoid
unnecessary new dependencies rather than treating useful supported standard
libraries as off-limits; justify any genuinely needed custom implementation,
compatibility exception or dependency choice with its tradeoffs and do not force
coincidental lookalikes into a shared abstraction. Research official primary
sources with websearch/webfetch only when the task genuinely needs external
knowledge, recording source URLs and applicability/version evidence or stating why
none was needed; keep queries free of private code and secrets. Return blocked only
when required reliable evidence cannot be obtained; a single failed, blocked or
anti-bot search may be replaced by a successful official-source webfetch that
fully supplies the required evidence, otherwise return blocked. Fix causes rather
than suppressing errors or weakening checks, and avoid speculative abstractions.
Preserve unrelated work and leave the commit to the committer stage: do not commit,
push, deploy, or perform destructive actions. Save any artifacts you produce
(reports, logs, screenshots) into the artifacts directory named in the runtime
context; they are attached to this stage. Verify the change with the repository's
relevant checks and report the exact commands and observed results in an
`# evidence` section; never claim an unexecuted check passed. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need. Return blocked
if the task or required tools are unavailable; otherwise return success with
actual results.
Complete the task in input.md. Inspect the repository first and follow its
conventions. Keep the change focused, preserve unrelated work, and run the
relevant checks. Report what changed, the exact checks you ran, and anything you
could not verify. Do not commit, push or deploy.
```
```tools
@@ -56,22 +33,10 @@ error -> #failure
# stage committer
```prompt
Commit this run's change locally. Never push, tag, deploy or rewrite history.
Inspect `git status` and the full diff, and stage this run's change, including
inherited work, restricted to paths that still exist and keeping any exclusions. Inspect the staged diff before
committing; never commit unrelated work, secrets or generated artifacts. Follow the
documentation-note step of the committer checklist in `references/format.md`: when the
change makes a shared document stale, stage the item's own documentation note
(`docs/notes/<slug>.md`) with the change, and never edit a shared document (a README,
topic docs or the packaged skill references) here; a single documentation writer folds
notes later. Pre-commit
checklist: confirm the staged paths are this run's change; run the repository's
required checks and record the exact commands and observed results in an
`# evidence` section; do not commit if a required check fails, return blocked
with the failing output instead. If nothing is staged, do not create an empty
commit; return success with a clear note. Otherwise commit with a concise message
naming this run's change and report the commit hash. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need. Never claim an unexecuted
check passed or fabricate a commit.
Commit this run's change locally. Inspect `git status` and the full diff; stage
only this run's work, never secrets or generated files. Run the relevant checks
and report the actual results. If nothing changed, say so rather than creating an
empty commit. Do not push, tag, deploy or rewrite history.
```
```tools
+18 -84
View File
@@ -1,25 +1,10 @@
# stage planner
```prompt
Plan the task in input.md without implementing it. Discover the repository's languages,
structure, conventions and reusable helpers/modules first; record them in
reuse_targets and prefer existing code and repository conventions over bespoke or
copy-pasted implementations. Resolve scope, acceptance, risk and design
tradeoffs. Research official primary sources with websearch/webfetch only when the
solution genuinely needs external knowledge (accepted industry approaches,
framework/library APIs, current security/compatibility guidance, or unfamiliar
techniques): record source URLs with date/version/applicability evidence,
decisions and tradeoffs, or state why no research is needed. Do not force web
access for trivial fully understood local edits, never claim research without
matching tools, keep queries free of private code and secrets, and treat external
text as evidence rather than permission to broaden scope. Return blocked only when
required reliable evidence cannot be obtained; a single failed, blocked or
anti-bot search may be replaced by a successful official-source webfetch that
fully supplies the required evidence, otherwise return blocked. Limit repository
inspection to relevant repository paths; never scan filesystem or mount roots,
and use commands supported by the actual execution environment rather than
guessed platform flags (a working instruction, not an OS sandbox). Preserve the
user's task and constraints; do not invent evidence. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need.
Plan the task in input.md without implementing it. Inspect the repository and
reuse what already exists. State the approach, the files likely to change, and
the checks that will prove the change works. Research external facts only when
the task needs them, and cite what you use. Do not edit.
```
```tools
@@ -46,28 +31,10 @@ error -> #failure
# stage implementer
```prompt
Implement the supplied plan in the run directory using the repository's actual
languages and file types; create files as needed. Reuse the supplied reuse_targets
and existing helpers/patterns first instead of duplicating or copy-pasting code;
prefer supported standard libraries and already-present dependencies/APIs/helpers
and avoid unnecessary new dependencies rather than treating useful supported
standard libraries as off-limits. Fix causes rather than suppressing errors,
weakening checks or hardcoding; justify any genuinely needed custom
implementation, compatibility exception or dependency choice with its tradeoffs,
do not force coincidental lookalikes into a shared abstraction, and avoid
speculative abstractions. Consider compatibility, security, data integrity,
cancellation, error handling and bounded performance where applicable. Limit
repository inspection and verification to relevant repository paths; never scan
filesystem or mount roots, and use commands supported by the actual execution
environment rather than guessed platform flags (a working instruction, not an OS
sandbox). Save any artifacts you produce (reports, logs, screenshots) into the
artifacts directory named in the runtime context; they are attached to this stage.
Run the relevant checks with the stage tools and record the exact commands,
observed results and any untested limits in an `# evidence` section; never
claim an unexecuted check passed. Preserve the task, plan and acceptance checks and
record actual changes in changed_files. Do not commit, push, deploy or destroy
unrelated work; the committer stage commits this run's change. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need. Return blocked
when the required edit scope or tools are unavailable.
Implement the plan from input.md. Follow the repository's conventions, keep the
change focused, and add or update tests where they matter. Preserve unrelated
work. Run the relevant checks and report the exact commands and actual results,
including what you could not test. Do not commit, push or deploy.
```
```tools
@@ -94,33 +61,12 @@ error -> #failure
# stage reviewer
```prompt
Independently review the actual changed files and related existing code against
the supplied task, plan and acceptance checks. Inspect for duplication and
near-duplicate implementations, appropriate library/standard and version usage,
modularity, coupling, contracts, error handling, security, data integrity and
bounded performance, and assess worthwhile regression tests or docs. Look for
shortcuts, hardcoded special cases, suppressed errors, weakened tests and
unnecessary bespoke solutions, not only overall architecture. Support each finding
with a concrete location, evidence, severity and remedy; distinguish blocking
evidence gaps from nonblocking personal-style nits and explain legitimate
deviations. Run relevant checks with the stage tools yourself and report what was
not tested in an `# evidence` section; do not accept a prior stage's summary as
proof and never claim an unexecuted check passed. Limit inspection and
verification to relevant repository paths; never scan filesystem or mount roots,
and run commands supported by the actual execution environment rather than
guessed platform flags (working instructions, not an OS sandbox guarantee). Save
any artifacts you produce (reports, logs, screenshots) into the artifacts
directory named in the runtime context; they are attached to this stage. Return
the complete output.md markdown; the only required section is `# outcome`
followed by a declared edge word, with free-form headings for the facts later
stages need. Return success
only when the applicable acceptance checks were independently observed passing and
no unresolved substantive design, reuse, duplication, workaround or correctness
issue remains; return rejected with concrete findings for failing checks, missing
REQUIRED verification, or substantive code-quality issues. Optional or
out-of-scope checks may be recorded untested without forcing endless work. Use
websearch/webfetch only when an official standard or documentation check is
needed. Do not edit files, commit, push or deploy.
Independently review the actual change against the task and plan. Inspect the
diff and related code, and run the relevant checks yourself rather than trusting
an earlier summary. Look for correctness, duplication, unnecessary complexity and
missing tests. Report each blocking finding with a location, evidence and remedy;
keep advisory notes separate. Return success only when the applicable checks pass
and no substantive issue remains. Do not edit or commit.
```
```tools
@@ -148,22 +94,10 @@ error -> #failure
# stage committer
```prompt
Commit this run's change locally. Never push, tag, deploy or rewrite history.
Inspect `git status` and the full diff, and stage this run's change, including
inherited work, restricted to paths that still exist and keeping any exclusions.
Inspect the staged diff
before committing; never commit unrelated work, secrets or generated artifacts.
Follow the documentation-note step of the committer checklist in
`references/format.md`: when the change makes a shared document stale, stage the item's
own documentation note (`docs/notes/<slug>.md`) with the change, and never edit a shared
document (a README, topic docs or the packaged skill references) here; a single
documentation writer folds notes later. Pre-commit checklist: confirm the staged paths are this run's change; run the
repository's required checks and record the exact commands and observed results in
a `# evidence` section; do not commit if a required check fails, return
blocked with the failing output instead. If nothing is staged, do not create an
empty commit; return success with a clear note. Otherwise commit with a concise
message naming this run's change and report the commit hash. Return the complete output.md markdown; the only required section is `# outcome` followed by a declared edge word, with free-form headings for the facts later stages need. Never claim an
unexecuted check passed or fabricate a commit.
Commit this run's change locally. Inspect `git status` and the full diff; stage
only this run's work, never secrets or generated files. Run the relevant checks
and report the actual results. If nothing changed, say so rather than creating an
empty commit. Do not push, tag, deploy or rewrite history.
```
```tools
+1 -1
View File
@@ -9,7 +9,7 @@ import (
"path/filepath"
)
var skillFiles = []string{"SKILL.md", "references/orchestration.md", "references/work.md", "references/queue.md", "references/debugging.md", "references/delivery.md", "references/format.md", "references/notifications.md", "references/operations.md", "references/transfer.md", "references/verification.md", "references/control.md", "references/harnesses.md"}
var skillFiles = []string{"SKILL.md", "references/orchestration.md", "references/work.md", "references/queue.md", "references/debugging.md", "references/delivery.md", "references/format.md", "references/notifications.md", "references/operations.md", "references/transfer.md", "references/verification.md", "references/control.md", "references/harnesses.md", "references/access.md"}
func SkillDirectory() (string, error) {
dir := os.Getenv("XDG_CONFIG_HOME")
+46 -33
View File
@@ -5,51 +5,64 @@ description: Use and author Pipelines workflows, inspect runs, and recover or de
# Pipelines
Pipelines are optional execution tools. The manager may also implement, test,
review, resolve conflicts, merge and deliver directly. Do not turn a failed
workflow into repeated whole-run retries or another pipeline's landing job.
Pipelines are reusable workflows for repositories. They are optional: direct
work, delegation and a pipeline are all valid routes. Use whichever finishes the
task with the least ceremony, and keep work small enough to verify.
## Work
## Using it
Read the task and relevant project map before asking questions. Split changes
into small verifiable items, each with one goal and short acceptance checks.
Run independent items concurrently; use separate worktrees and the agreed model.
Preserve partial work and inspect real diffs and command results. A failed item
does not freeze unrelated work. Continue at the necessary stage or recover directly.
`pipelines list` shows the registered workflows; `pipelines runs` shows history.
Start a run with `pipelines run <name> "<task>"`, and inspect it with
`pipelines inspect <id>`. `pipelines wait <id>` blocks until it finishes.
## Definitions
A failed run keeps its worktree and commits. Read `pipelines inspect <id> --json`
before deciding: resume the failed stage (`pipelines retry <id>`), fix directly,
or continue from the preserved branch.
Edit a retained draft, not immutable history. Give each stage one simple job and
only the input it needs. Preserve review gates, runtime limits, permissions and
the user's constraints unless asked to change them.
Use `pipelines validate DRAFT --json` before publication. Publish or execute when
the user requests it; do not ask again for routine steps already authorized.
Keep version guards. `--yes` is not a conflict policy; never silently force an
update over somebody else's version. A draft-only request does not authorize a run.
## Authoring
For delivery-enabled stages, the committer prepares a clean checked candidate and
returns success; the server lands afterward. Check ancestry after landing, not as
a precondition that prevents the gate running. Direct recovery may merge reviewed
work itself, while preserving unrelated changes and checking the result.
A definition is Markdown: `# stage <Name>` sections with `prompt`, `configs`,
`tools`, `edges`, and optional `limits`/`checks`/`settings`. Start from
`examples/`. Use stage names that describe the work:
`Plan` · `Code` · `Review` · `UIReview` · `Land` (`Prepare` and `Survey` are
useful variants).
Keep prompts short and objective: what the stage should produce and any real
constraints. The runner enforces turns, tools and limits; prompts do not need to
repeat them. Only `# outcome` is parsed from `output.md`; everything else is
free markdown. Use `links` and `memory` only when they clarify a handoff.
`pipelines validate DRAFT` checks a draft; `pipelines submit DRAFT` publishes a
new immutable version. `pipelines help <command>` has flags.
## Turns and artifacts
Each visit has `input.md` (the run prompt or previous body), `memory.md`
(completed turns), `output.md`, and `private/`. Every run also has one shared
`public/` directory, addressed by its absolute path; files there are visible to
later stages and are the stage's real artifacts. `input.md`, `memory.md`,
`output.md` and `session.html` are system evidence for auditing, not stage
output.
## References
Do not preload references. Read only the reference needed for the current task:
Read only what the task needs:
| Need | Reference |
| --- | --- |
| Small tasks and stage roles | `references/orchestration.md` |
| Queue and parallel work | `references/work.md`, `references/queue.md` |
| Failures and recovery | `references/debugging.md` |
| Definition syntax and turn files | `references/format.md` |
| Limits, tools and permissions | `references/control.md` |
| Stages, parallel work, recovery | `references/orchestration.md` |
| CLI, storage and evidence | `references/operations.md` |
| Verification and accounting | `references/verification.md` |
| Failures | `references/debugging.md` |
| Delivery and installation | `references/delivery.md` |
| Definition syntax and handoffs | `references/format.md`, `references/control.md` |
| Harnesses and models | `references/harnesses.md` |
| Notifications | `references/notifications.md` |
| CLI, storage and retained evidence | `references/operations.md` |
| Transfer and version conflicts | `references/transfer.md` |
| Verification and accounting | `references/verification.md` |
| Transfer and versions | `references/transfer.md` |
| Hosting, auth and deployment | `references/access.md` |
| Queue and work items | `references/work.md`, `references/queue.md` |
Use command-specific `pipelines help COMMAND` rather than guessing flags.
Distinguish validation, executed tests, landed source and deployed behavior.
Preserve history, branches and user data. Do not disrupt active services or device
users. Ask before destructive or out-of-scope actions, not ordinary implementation.
Ask about real ambiguity, destructive actions or changes outside the request;
routine steps of an authorized task do not need another confirmation.
@@ -0,0 +1,55 @@
# Hosting, access and deployment
The browser client is `web/serve.mjs`: static files plus a `/connect` WebSocket
proxy and `/artifacts/` proxy to the Pipelines server. Plain `node serve.mjs` is
enough for local work.
## Password gate
`serve.mjs` refuses pages, assets, artifacts and `/connect` without a signed
session cookie. The password and signing secret live outside the repository:
`~/.config/pipelines/web-auth.json` (mode `600`), e.g.
```json
{ "password": "…", "secret": "…" }
```
The sign-in page is `/login`; **Remember me** keeps a 30-day cookie, otherwise
the cookie lives until the browser closes. Wrong passwords are throttled. Tests
that start their own `serve.mjs` set `PIPELINES_WEB_AUTH=disabled`; never put that
in a service.
Changing the password: edit the file, then restart the web service.
## Bind and exposure
For an untrusted network, keep the raw ports local:
- Pipelines server: `-addr 127.0.0.1:8080`.
- Web proxy: `--host 127.0.0.1` (reachable through Tailscale, not the LAN).
- OpenCode: `server.hostname = "127.0.0.1"` in `~/.config/opencode/opencode.json`.
Tailscale can terminate HTTPS for a tailnet-only name:
```sh
tailscale serve --bg --https=8443 http://127.0.0.1:8095
# https://<machine>.<tailnet>.ts.net:8443/
```
That gives a valid certificate and a secure context (service worker, installable
web app). Only tailnet devices can resolve the name; the password still applies
to the app and its WebSocket.
Keep the server and web proxy supervised by the platform's service manager so
they restart after a reboot. Name the service files for your installation; their
labels are local choices, not part of the protocol. The HTTPS proxy rule must
also survive a reboot.
## Before exposing anything
Check what listens beyond loopback (`lsof -nP -iTCP -sTCP:LISTEN`). The Pipelines
server and the agent harness are control APIs without their own login; bind them
to localhost and expose only the authenticated web proxy. If an app-managed
server cannot bind loopback, a host firewall or tailnet ACLs are the remaining
options. Unrelated operating-system services are outside this deployment.
@@ -13,23 +13,27 @@ at integration. Serialize only actual dependency or resource conflicts.
## Stage jobs
- Planner: produce a short plan and acceptance checks only when needed.
- Implementer: make the focused change, add tests, run focused checks.
- Reviewer: inspect the whole task diff and independently verify relevant checks.
- UI reviewer: exercise rendered behavior using ready controlled data; retain captures.
- Committer: commit all reviewed task changes, integrate main and resolve conflicts.
- Plan: a short approach and acceptance checks when they help.
- Code: the focused change, tests and focused checks.
- Review: the whole task diff and independent verification.
- UIReview: rendered behavior with controlled data and captures.
- Land: commit the reviewed work, integrate main and resolve conflicts.
Handoff desired behavior and necessary evidence, not another role's restrictions.
An implementer's "no device use performed" is not a ban on the UI reviewer.
A fresh clean worktree is a successful no-op for preparation, not a failure.
Nonvisual changes need no device. A visual change needs actual visual evidence.
Names are a convention, not a requirement; a pipeline can use any clear stage
names. Keep each stage's job narrow enough to judge its output.
Hand off the desired behavior and the evidence that should exist at the end, not
another stage's restrictions. A clean worktree is a successful no-op for
preparation, not a failure. Nonvisual work needs no rendered evidence; a visual
change does.
## Pipeline choice
When using the project's area workflows: Android for android/, TUI for internal/tui/,
Server for backend/protocol work, Generic for genuinely cross-area work, Plan and
land when design is necessary, UI sweep for a visual survey, Probe for a smoke check.
Read area maps for project-specific commands. Keep models and costs as agreed.
Prefer the smallest workflow that makes the work verifiable: plan when the design
is genuinely uncertain, review when a change is risky or broad, and a visual survey
when appearance is the question. Stage names describe jobs, not fixed roles. Read
the project's own maps and commands instead of assuming an area layout. Keep models
and costs as agreed.
## Recovery and landing
+1 -1
View File
@@ -43,7 +43,7 @@ func TestEveryEmbeddedReferenceIsInstalledAndLinksResolve(t *testing.T) {
if len(main) > 8000 {
t.Fatal("keep detailed knowledge out of the main skill", len(main))
}
for _, required := range []string{"operations.md", "transfer.md", "verification.md", "Do not preload", "before asking", "--yes` is not a conflict policy"} {
for _, required := range []string{"operations.md", "transfer.md", "verification.md", "access.md", "Only `# outcome`", "Ask about real ambiguity"} {
if !strings.Contains(string(main), required) {
t.Fatal("missing routing or safety rule", required)
}
+139
View File
@@ -108,6 +108,26 @@ func (c *Chat) PromptWithMessageID(ctx context.Context, id, text, messageID stri
return nil
}
// Answer replies to one OpenCode form. The agent's question tool pauses inside a
// form.created event; replying lets the same turn continue. The answer object is
// keyed by the form field keys, exactly as the OpenCode CLI sends it.
func (c *Chat) Answer(ctx context.Context, request protocol.ChatAnswerRequest) error {
if !sessionID.MatchString(request.SessionID) {
return fmt.Errorf("invalid OpenCode session id")
}
if strings.TrimSpace(request.FormID) == "" {
return fmt.Errorf("a form id is required")
}
body := map[string]any{"answer": request.Answers}
if request.Answers == nil {
body["answer"] = map[string]any{}
}
if _, err := c.call(ctx, "post", "/api/session/"+request.SessionID+"/form/"+request.FormID+"/reply", body); err != nil {
return err
}
return nil
}
// Interrupt aborts the session's active run, reusing the same translated surface.
func (c *Chat) Interrupt(ctx context.Context, id string) error {
if !sessionID.MatchString(id) {
@@ -635,12 +655,40 @@ func isChatEventType(t string) bool {
"session.tool.input.started", "session.tool.input.ended",
"session.tool.called", "session.tool.progress",
"session.tool.success", "session.tool.failed",
"form.created", "form.replied", "form.cancelled",
"shell.created", "shell.exited":
return true
}
return false
}
// chatFormPayload is the form object nested under form.created. The question
// tool uses metadata.kind == "question"; other forms are surfaced with their own
// kind so the client can decide whether to render them as a question.
type chatFormPayload struct {
ID string `json:"id"`
SessionID string `json:"sessionID"`
Title string `json:"title"`
Metadata map[string]any `json:"metadata"`
Fields []chatFormField `json:"fields"`
}
type chatFormField struct {
Key string `json:"key"`
Title string `json:"title"`
Description string `json:"description"`
Type string `json:"type"`
Options []chatFormOption `json:"options"`
Custom bool `json:"custom"`
Required bool `json:"required"`
}
type chatFormOption struct {
Value string `json:"value"`
Label string `json:"label"`
Description string `json:"description"`
}
// chatEvent is the subset of the verified firehose envelope this adapter reads:
// {"type":"session.text.delta","data":{...}}. Fields absent from a given event
// stay zero so one struct covers every type.
@@ -672,6 +720,9 @@ type chatEvent struct {
Status string `json:"status"`
Exit *int `json:"exit"`
Info *chatShellInfo `json:"info"`
// Form is the nested form.created payload; FormID is the bare id on
// form.replied/form.cancelled.
Form *chatFormPayload `json:"form"`
}
// chatShellInfo is the Shell.Info envelope a shell.created event nests under
@@ -711,10 +762,13 @@ func (i *chatShellInfo) shellSessionID() string {
// seen exit. shell.exited carries no session id, so the id remembered here is
// what attributes the exit to its session: another session's shell is an
// unknown id and is ignored.
// - Forms maps a pending form id to its session, so form.replied/cancelled
// (which carry no session) can be attributed to the right chat.
type ChatStreamState struct {
mu sync.Mutex
LastMessageID string
Shells map[string]struct{}
Forms map[string]string
readGate chan struct{}
readback *ShellSnapshot
}
@@ -833,6 +887,9 @@ func NormalizeChatEvent(payload []byte, sessionID string, stream *ChatStreamStat
if outer.Type == "shell.created" || outer.Type == "shell.exited" {
return normalizeShellEvent(outer.Type, data, sessionID, stream)
}
if strings.HasPrefix(outer.Type, "form.") {
return normalizeFormEvent(outer.Type, data, sessionID, stream)
}
if data.SessionID != sessionID {
return protocol.ChatEventFrame{}, false, nil
}
@@ -882,6 +939,88 @@ func NormalizeChatEvent(payload []byte, sessionID string, stream *ChatStreamStat
return frame, true, nil
}
// normalizeFormEvent maps one form.created / form.replied / form.cancelled
// payload onto a ChatEventForm frame. Form.created carries its own session; the
// terminal events carry only an id, so the stream remembers which session owns
// each pending form. A form from another session is ignored, and an unknown
// terminal id is another session's form rather than a malformed frame.
func normalizeFormEvent(eventType string, data chatEvent, sessionID string, stream *ChatStreamState) (protocol.ChatEventFrame, bool, error) {
if eventType == "form.created" {
form := data.Form
if form == nil || form.ID == "" {
return protocol.ChatEventFrame{}, false, fmt.Errorf("malformed OpenCode form.created event")
}
if form.SessionID != "" && form.SessionID != sessionID {
return protocol.ChatEventFrame{}, false, nil
}
kind := ""
if form.Metadata != nil {
kind, _ = form.Metadata["kind"].(string)
}
frame := protocol.ChatForm{
ID: form.ID,
SessionID: sessionID,
Title: form.Title,
Kind: kind,
}
for _, field := range form.Fields {
out := protocol.ChatFormField{
Key: field.Key,
Title: field.Title,
Description: field.Description,
Type: field.Type,
Custom: field.Custom,
Required: field.Required,
}
for _, option := range field.Options {
value := option.Value
if value == "" {
value = option.Label
}
out.Options = append(out.Options, protocol.ChatFormOption{
Value: value, Label: option.Label, Description: option.Description,
})
}
frame.Fields = append(frame.Fields, out)
}
if stream != nil {
stream.mu.Lock()
if stream.Forms == nil {
stream.Forms = map[string]string{}
}
stream.Forms[form.ID] = sessionID
stream.mu.Unlock()
}
return protocol.ChatEventFrame{SessionID: sessionID, Kind: protocol.ChatEventForm, Form: &frame}, true, nil
}
id := data.ID
if id == "" && data.Form != nil {
id = data.Form.ID
}
if id == "" {
return protocol.ChatEventFrame{}, false, fmt.Errorf("malformed OpenCode %s event", eventType)
}
if stream == nil {
return protocol.ChatEventFrame{}, false, nil
}
stream.mu.Lock()
owner, known := stream.Forms[id]
if known && owner == sessionID {
delete(stream.Forms, id)
}
stream.mu.Unlock()
if !known || owner != sessionID {
return protocol.ChatEventFrame{}, false, nil
}
form := &protocol.ChatForm{ID: id, SessionID: sessionID}
if eventType == "form.cancelled" {
form.Cancelled = true
} else {
form.Resolved = true
}
return protocol.ChatEventFrame{SessionID: sessionID, Kind: protocol.ChatEventForm, Form: form}, true, nil
}
// normalizeShellEvent maps one shell.created/shell.exited payload onto a
// protocol.ChatEventShell frame. A shell belongs to the session whose id the
// created event carries in info.metadata.sessionID, so a shell started by any
+38
View File
@@ -822,3 +822,41 @@ func TestChatV1ConnectionDrivesThroughCall(t *testing.T) {
t.Fatalf("messages = %+v", page.Messages)
}
}
// TestNormalizeChatEventForm proves the question tool's form lifecycle is
// surfaced: form.created carries the field structure and is remembered for the
// session, while the terminal events (which carry only an id) resolve the same
// form for that session and are ignored for another.
func TestNormalizeChatEventForm(t *testing.T) {
state := &ChatStreamState{}
created := []byte(`{"type":"form.created","data":{"form":{"id":"form_1","sessionID":"ses_1","title":"Choose a colour","metadata":{"kind":"question"},"fields":[{"key":"colour","title":"Which colour?","description":"Pick one","type":"string","required":true,"options":[{"value":"red","label":"Red","description":"Warm"},{"value":"blue","label":"Blue"}]}]}}}`)
frame, ok, err := NormalizeChatEvent(created, "ses_1", state)
if err != nil || !ok {
t.Fatalf("form.created: ok=%v err=%v", ok, err)
}
if frame.Kind != protocol.ChatEventForm || frame.Form == nil {
t.Fatalf("form.created frame = %+v", frame)
}
if frame.Form.ID != "form_1" || frame.Form.Kind != "question" || len(frame.Form.Fields) != 1 {
t.Fatalf("form.created form = %+v", frame.Form)
}
field := frame.Form.Fields[0]
if field.Key != "colour" || field.Title != "Which colour?" || !field.Required || len(field.Options) != 2 {
t.Fatalf("form.created field = %+v", field)
}
if field.Options[0].Value != "red" || field.Options[0].Label != "Red" || field.Options[0].Description != "Warm" {
t.Fatalf("form option = %+v", field.Options[0])
}
// Another session's terminal event is not this session's form.
if _, ok, err := NormalizeChatEvent([]byte(`{"type":"form.replied","data":{"id":"form_1"}}`), "ses_2", state); err != nil || ok {
t.Fatalf("foreign form.replied: ok=%v err=%v", ok, err)
}
resolved, ok, err := NormalizeChatEvent([]byte(`{"type":"form.replied","data":{"id":"form_1"}}`), "ses_1", state)
if err != nil || !ok || resolved.Form == nil || !resolved.Form.Resolved || resolved.Form.ID != "form_1" {
t.Fatalf("form.replied frame = %+v ok=%v err=%v", resolved, ok, err)
}
if _, ok, err := NormalizeChatEvent([]byte(`{"type":"form.cancelled","data":{"id":"form_1"}}`), "ses_1", state); err != nil || ok {
t.Fatalf("duplicate/unknown form.cancelled: ok=%v err=%v", ok, err)
}
}
+27 -5
View File
@@ -30,6 +30,10 @@ type OperatorSession struct {
// so every client sees the same thing; the session and its history are never
// deleted, and reopening clears it back to 0.
ClosedAt int64
// StarredAt is the epoch-millisecond time the operator starred this session,
// or 0 while unstarred. It lives on the server so the starred group is shared
// by every browser and device.
StarredAt int64
}
// ChatCreateBootstrap is the durable progress record for one chat_create
@@ -58,7 +62,8 @@ func (s *Store) initOperatorSessions() error {
_, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS operator_sessions (
session_id TEXT PRIMARY KEY, directory TEXT NOT NULL, title TEXT NOT NULL DEFAULT '',
tag TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, last_used_at INTEGER NOT NULL,
closed_at INTEGER NOT NULL DEFAULT 0, ephemeral INTEGER NOT NULL DEFAULT 0);
closed_at INTEGER NOT NULL DEFAULT 0, starred_at INTEGER NOT NULL DEFAULT 0,
ephemeral INTEGER NOT NULL DEFAULT 0);
CREATE INDEX IF NOT EXISTS operator_sessions_recent ON operator_sessions(last_used_at DESC);`)
if err != nil {
return err
@@ -134,6 +139,11 @@ func (s *Store) migrateOperatorSessions() error {
if err := s.addColumnIfMissing("operator_sessions", "closed_at", "INTEGER NOT NULL DEFAULT 0"); err != nil {
return err
}
// starred_at records the shared star. Existing sessions default to 0
// (unstarred); the column is independent of closed_at.
if err := s.addColumnIfMissing("operator_sessions", "starred_at", "INTEGER NOT NULL DEFAULT 0"); err != nil {
return err
}
// ephemeral marks a chat created for automated verification. It is hidden from
// OperatorSessions but still a real row, so the session stays usable and
// closable. Existing rows default to 0 (a normal, listed chat).
@@ -202,14 +212,26 @@ func (s *Store) ReopenOperatorSession(ctx context.Context, sessionID string) err
return err
}
// SetOperatorSessionStar records the shared star state in one UPDATE. A session
// id that is not an operator session updates no row and is not an error, so a
// pipeline-owned run session is never affected.
func (s *Store) SetOperatorSessionStar(ctx context.Context, sessionID string, starred bool) error {
at := int64(0)
if starred {
at = time.Now().UnixMilli()
}
_, err := s.db.ExecContext(ctx, "UPDATE operator_sessions SET starred_at=? WHERE session_id=?", at, sessionID)
return err
}
// OperatorSession returns one operator session by id. found is false when the id
// is not a recorded operator session (so a pipeline-owned run session is never
// returned). It is one indexed lookup and never mutates the row.
func (s *Store) OperatorSession(ctx context.Context, sessionID string) (OperatorSession, bool, error) {
var session OperatorSession
row := s.db.QueryRowContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at,closed_at
row := s.db.QueryRowContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at,closed_at,starred_at
FROM operator_sessions WHERE session_id=? AND tag <> ''`, sessionID)
if err := row.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt, &session.ClosedAt); err != nil {
if err := row.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt, &session.ClosedAt, &session.StarredAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return OperatorSession{}, false, nil
}
@@ -228,7 +250,7 @@ FROM operator_sessions WHERE session_id=? AND tag <> ''`, sessionID)
// operator can still see and reopen what they finished. It is one bounded
// statement; recency is never mutated here.
func (s *Store) OperatorSessions(ctx context.Context) ([]OperatorSession, error) {
rows, err := s.db.QueryContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at,closed_at
rows, err := s.db.QueryContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at,closed_at,starred_at
FROM operator_sessions WHERE tag <> '' AND ephemeral = 0 ORDER BY last_used_at DESC, session_id LIMIT ?`, operatorSessionListLimit)
if err != nil {
return nil, err
@@ -237,7 +259,7 @@ FROM operator_sessions WHERE tag <> '' AND ephemeral = 0 ORDER BY last_used_at D
sessions := []OperatorSession{}
for rows.Next() {
var session OperatorSession
if err := rows.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt, &session.ClosedAt); err != nil {
if err := rows.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt, &session.ClosedAt, &session.StarredAt); err != nil {
return nil, err
}
sessions = append(sessions, session)
@@ -0,0 +1,53 @@
package pipeline
import (
"context"
"path/filepath"
"testing"
)
// TestOperatorSessionStarIsSharedAndReversible proves the server-side star
// contract: starring records starred_at on the registry row, listing returns it,
// unstarring clears it, and the OpenCode session id and other fields are never
// changed. This is what makes the Starred group visible from every browser.
func TestOperatorSessionStarIsSharedAndReversible(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "star.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if err := store.RecordOperatorSession(ctx, "ses_a", "/work/a", "A", "operator"); err != nil {
t.Fatal(err)
}
if err := store.SetOperatorSessionStar(ctx, "ses_a", true); err != nil {
t.Fatal(err)
}
starred, found, err := store.OperatorSession(ctx, "ses_a")
if err != nil || !found {
t.Fatalf("starred lookup: found=%v err=%v", found, err)
}
if starred.StarredAt <= 0 {
t.Fatalf("star did not record starred_at: %+v", starred)
}
listed, err := store.OperatorSessions(ctx)
if err != nil {
t.Fatal(err)
}
if len(listed) != 1 || listed[0].StarredAt != starred.StarredAt {
t.Fatalf("list did not return the shared star: %+v", listed)
}
if err := store.SetOperatorSessionStar(ctx, "ses_a", false); err != nil {
t.Fatal(err)
}
plain, found, err := store.OperatorSession(ctx, "ses_a")
if err != nil || !found {
t.Fatalf("unstarred lookup: found=%v err=%v", found, err)
}
if plain.StarredAt != 0 {
t.Fatalf("unstar did not clear starred_at: %+v", plain)
}
if plain.ID != "ses_a" || plain.Directory != "/work/a" || plain.Title != "A" || plain.Tag != "operator" {
t.Fatalf("star toggling changed other session fields: %+v", plain)
}
}
+22 -2
View File
@@ -118,7 +118,8 @@ func (s *Store) Directory() string { return s.dir }
func (s *Store) List(ctx context.Context) ([]protocol.PipelineSummary, error) {
rows, err := s.db.QueryContext(ctx, `SELECT p.id, p.name, v.version,
json_array_length(v.graph_json, '$.stages'),
strftime('%Y-%m-%dT%H:%M:%SZ', p.created_at), strftime('%Y-%m-%dT%H:%M:%SZ', v.created_at)
strftime('%Y-%m-%dT%H:%M:%SZ', p.created_at), strftime('%Y-%m-%dT%H:%M:%SZ', v.created_at),
v.graph_json
FROM pipelines p JOIN pipeline_versions v ON v.pipeline_id=p.id
WHERE v.version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=p.id)
ORDER BY p.name, p.id`)
@@ -129,9 +130,28 @@ ORDER BY p.name, p.id`)
result := []protocol.PipelineSummary{}
for rows.Next() {
var item protocol.PipelineSummary
if err := rows.Scan(&item.ID, &item.Name, &item.Version, &item.Stages, &item.CreatedAt, &item.UpdatedAt); err != nil {
var graphJSON string
if err := rows.Scan(&item.ID, &item.Name, &item.Version, &item.Stages, &item.CreatedAt, &item.UpdatedAt, &graphJSON); err != nil {
return nil, err
}
var shape protocol.Graph
if err := json.Unmarshal([]byte(graphJSON), &shape); err == nil && len(shape.Stages) > 0 {
// A list needs the drawing, not the definition: strip prompts,
// configs, tools, limits, notifications and checks so one list reply
// cannot leak a whole pipeline source or grow into a large payload.
shape.Settings = nil
for index := range shape.Stages {
stage := &shape.Stages[index]
stage.Prompt = ""
stage.Output = ""
stage.Configs = nil
stage.Blocks = nil
stage.Memory = nil
stage.Notify = nil
stage.Limits = nil
}
item.Shape = &shape
}
result = append(result, item)
}
return result, rows.Err()
+67 -1
View File
@@ -40,6 +40,10 @@ const (
// only records the finished state, it never detaches a client.
ChatClose = "chat_close"
ChatReopen = "chat_reopen"
// ChatStar records the operator's star on the server, so every browser and
// device shows the same starred group. It takes a ChatQuery with SessionID
// and Starred, and echoes the updated session like close/reopen.
ChatStar = "chat_star"
// ChatSubscribe attaches a connection to one session's shared live stream so
// it receives every frame any client's turn produces (its own and the other
// devices'), not only the frames of a turn it prompted itself. Any number of
@@ -61,6 +65,13 @@ const (
// ChatEvent and ChatPermission are the server-pushed frames; they are the
// only types the server sends without a matching request.
ChatEvent = "chat_event"
// ChatEventForm carries an OpenCode form (the agent's question tool uses a
// form with kind=question). It is a ChatEvent kind, not a separate request:
// the same frame stream that carries text and tools carries the question.
ChatEventForm = "form"
// ChatAnswer is the client's answer to a ChatEventForm. Answers is keyed by
// field key and mirrors OpenCode's form.reply answer object.
ChatAnswer = "chat_answer"
// ChatPermission carries one pending OpenCode approval request the phone
// answers with chat_reply.
ChatPermission = "chat_permission"
@@ -165,6 +176,11 @@ type ChatSession struct {
// Additive/omitempty so older peers ignore them.
Closed bool `json:"closed,omitempty"`
ClosedAt int64 `json:"closed_at,omitempty"`
// Starred is the operator's shared star, stored in the operator-session
// registry so every client sees the same Starred group. StarredAt is the
// epoch-millisecond time it was set, 0 while unstarred.
Starred bool `json:"starred,omitempty"`
StarredAt int64 `json:"starred_at,omitempty"`
}
// ChatCloseResult reports the outcome of a chat_close: the session id, the
@@ -210,7 +226,9 @@ type ChatAdoptRequest struct {
// returned history (server default when zero).
type ChatQuery struct {
SessionID string `json:"session_id"`
Limit int `json:"limit,omitempty"`
// Starred is set by chat_star; nil means the command did not name a state.
Starred *bool `json:"starred,omitempty"`
Limit int `json:"limit,omitempty"`
// Cursor is the opaque continuation returned by OpenCode's descending
// message listing. It is deliberately not interpreted by the broker.
Cursor string `json:"cursor,omitempty"`
@@ -346,6 +364,9 @@ type ChatEventFrame struct {
// status, the command it is running and (once it has exited) its exit code.
// It is nil on every other kind.
Shell *ChatShell `json:"shell,omitempty"`
// Form is the payload of a ChatEventForm frame: the agent's pending question
// (or another OpenCode form), and the resolved/cancelled terminal state.
Form *ChatForm `json:"form,omitempty"`
// Client is the sending device's label on a user frame (ChatEventUser), so a
// transcript can say who sent the message. It is empty on assistant frames.
Client string `json:"client,omitempty"`
@@ -374,6 +395,51 @@ type ChatUsage struct {
// distinguishable from "not exited yet". No credential, environment or output is
// carried: the command line is the only text, and only so the operator can name
// what is running.
// ChatForm is the agent's structured question/form. OpenCode emits these as
// form.created / form.replied / form.cancelled; the question tool uses
// Kind=="question". A client answers with ChatAnswerRequest. Answers is kept as
// JSON values because a field may be a string, a list (multiselect), a number or
// a boolean.
type ChatForm struct {
ID string `json:"id"`
SessionID string `json:"session_id,omitempty"`
Title string `json:"title,omitempty"`
Kind string `json:"kind,omitempty"`
Fields []ChatFormField `json:"fields,omitempty"`
Resolved bool `json:"resolved,omitempty"`
Cancelled bool `json:"cancelled,omitempty"`
Answers map[string]any `json:"answers,omitempty"`
}
// ChatFormField is one question/input in a form. Type is OpenCode's field type
// (string, multiselect, number, integer, boolean, external); Options is present
// when the question offers choices.
type ChatFormField struct {
Key string `json:"key"`
Title string `json:"title,omitempty"`
Description string `json:"description,omitempty"`
Type string `json:"type,omitempty"`
Options []ChatFormOption `json:"options,omitempty"`
Custom bool `json:"custom,omitempty"`
Required bool `json:"required,omitempty"`
}
// ChatFormOption is one selectable choice in a ChatFormField.
type ChatFormOption struct {
Value string `json:"value"`
Label string `json:"label"`
Description string `json:"description,omitempty"`
}
// ChatAnswerRequest is the chat_answer body: the form id and a field-keyed
// answer object. It is deliberately separate from ChatQuery because its payload
// is structured answers, not a session-scoped read.
type ChatAnswerRequest struct {
SessionID string `json:"session_id"`
FormID string `json:"form_id"`
Answers map[string]any `json:"answers"`
}
type ChatShell struct {
ID string `json:"id"`
Status string `json:"status,omitempty"`
+7
View File
@@ -100,6 +100,10 @@ type PipelineSummary struct {
Stages int `json:"stages"`
CreatedAt string `json:"created_at"`
UpdatedAt string `json:"updated_at"`
// Shape is the current version's parsed graph, included so a list can draw
// a miniature without one detail request per row. Detail responses keep the
// full Graph field; this one is deliberately optional and additive.
Shape *Graph `json:"shape,omitempty"`
}
// Message is the JSON envelope shared by the server and client. It also brokers
@@ -179,6 +183,9 @@ type Message struct {
// requests themselves ride on ChatQuery (the session id), matching
// chat_messages/chat_interrupt.
ChatClose *ChatCloseResult `json:"chat_close,omitempty"`
// ChatAnswer is the chat_answer body; the form update arrives through the
// normal chat_event stream.
ChatAnswer *ChatAnswerRequest `json:"chat_answer,omitempty"`
// ChatSubscribe attaches this connection to one session's shared stream; the
// body names the session like ChatQuery. A chat_prompt response sets
// ChatQueued when the prompt had to wait for an in-flight turn and was
+14
View File
@@ -46,6 +46,13 @@ type chatPromptWithMessageID interface {
PromptWithMessageID(context.Context, string, string, string) error
}
// chatAnswerer is the optional form-answer surface. Test brokers and older
// backends need not implement it; a broker that does not answers chat_answer
// with a clear error rather than pretending the question was delivered.
type chatAnswerer interface {
Answer(context.Context, protocol.ChatAnswerRequest) error
}
type chatShellOutputReader interface {
ShellOutput(ctx context.Context, query protocol.ChatShellOutputQuery) (protocol.ChatShellOutputPage, error)
}
@@ -83,6 +90,7 @@ type operatorRegistry interface {
// session (which has no operator_sessions row).
CloseOperatorSession(ctx context.Context, sessionID string) error
ReopenOperatorSession(ctx context.Context, sessionID string) error
SetOperatorSessionStar(ctx context.Context, sessionID string, starred bool) error
}
var chatTokenSequence atomic.Uint64
@@ -121,6 +129,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker
case protocol.ChatReply:
handleChatSimple(ctx, request, broker, hub, write)
return true
case protocol.ChatAnswer:
handleChatAnswer(ctx, request, broker, write)
return true
case protocol.ChatSessions:
handleChatSessions(ctx, request, broker, hub, registry, write)
return true
@@ -139,6 +150,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker
case protocol.ChatReopen:
handleChatReopen(ctx, request, registry, write)
return true
case protocol.ChatStar:
handleChatStar(ctx, request, registry, write)
return true
case protocol.ChatShells:
handleChatShells(ctx, request, broker, registry, write)
return true
+48
View File
@@ -0,0 +1,48 @@
package server
import (
"context"
"git.a-wan.net/alan/pipelines/internal/opencode"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// handleChatAnswer replies to one OpenCode form, which is how the agent's
// question tool resumes: the tool call is paused inside form.created until a
// client answers. It validates the session/form ids before calling the broker,
// so a malformed answer cannot reach another session. The resulting
// form.replied/form.cancelled event arrives on the ordinary chat_event stream
// and clears the card on every watching client.
func handleChatAnswer(ctx context.Context, request protocol.Message, broker chatBroker, write func(protocol.Message) error) {
if broker == nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"})
return
}
answer := request.ChatAnswer
if answer == nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a chat_answer payload is required"})
return
}
if !opencode.ValidSessionID(answer.SessionID) {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
return
}
if answer.FormID == "" {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a form id is required"})
return
}
if len(answer.Answers) == 0 {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "at least one answer is required"})
return
}
answerer, ok := broker.(chatAnswerer)
if !ok {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "this chat backend cannot answer questions"})
return
}
if err := answerer.Answer(ctx, *answer); err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
_ = write(protocol.Message{Type: protocol.ChatAnswer, ID: request.ID})
}
+4
View File
@@ -140,5 +140,9 @@ func chatSessionFromOperator(session pipeline.OperatorSession) protocol.ChatSess
out.Closed = true
out.ClosedAt = session.ClosedAt
}
if session.StarredAt > 0 {
out.Starred = true
out.StarredAt = session.StarredAt
}
return out
}
+19
View File
@@ -157,6 +157,25 @@ func (h *chatHub) applyLocked(frame protocol.ChatEventFrame) {
}
turn.applyShell(frame.Shell)
return
case protocol.ChatEventForm:
// A form/question likewise carries no message id. Keep the pending form
// for a late subscriber; a resolved or cancelled form removes it.
if frame.Form == nil || frame.Form.ID == "" {
return
}
if room := h.rooms[frame.SessionID]; room != nil {
next := room.forms[:0]
for _, form := range room.forms {
if form.ID != frame.Form.ID {
next = append(next, form)
}
}
room.forms = next
if !frame.Form.Resolved && !frame.Form.Cancelled && len(room.forms) < 8 {
room.forms = append(room.forms, *frame.Form)
}
}
return
}
if frame.MessageID == "" {
return
+16 -1
View File
@@ -137,7 +137,10 @@ type chatRoom struct {
// pending holds the room's unresolved approval requests, in the order they
// were raised, replayed to a client that attaches after they were raised. A
// request is removed once it is resolved.
pending []protocol.ChatPermissionFrame
pending []protocol.ChatPermissionFrame
// forms holds the room's unresolved question/form frames so a client that
// attaches after the agent asked still renders the question.
forms []protocol.ChatForm
pollerStarted bool
wake chan struct{}
turnDone chan struct{}
@@ -548,6 +551,18 @@ func (h *chatHub) submitPrompt(sessionID string, p *chatQueuedPrompt) (queued bo
// pendingFrames returns a copy of the room's unresolved approval requests so a
// client that attaches after they were raised can be shown every one of them. It
// returns nil when the room holds none.
func (h *chatHub) pendingForms(sessionID string) []protocol.ChatForm {
h.mu.Lock()
defer h.mu.Unlock()
room := h.rooms[sessionID]
if room == nil || len(room.forms) == 0 {
return nil
}
forms := make([]protocol.ChatForm, len(room.forms))
copy(forms, room.forms)
return forms
}
func (h *chatHub) pendingFrames(sessionID string) []protocol.ChatPermissionFrame {
h.mu.Lock()
defer h.mu.Unlock()
+2
View File
@@ -80,6 +80,8 @@ func handleChatSessions(ctx context.Context, request protocol.Message, broker ch
// clients may watch and write one session.
session.Closed = operator.ClosedAt > 0
session.ClosedAt = operator.ClosedAt
session.Starred = operator.StarredAt > 0
session.StarredAt = operator.StarredAt
response.ChatSessions = append(response.ChatSessions, session)
}
_ = write(response)
+59
View File
@@ -0,0 +1,59 @@
package server
import (
"context"
"git.a-wan.net/alan/pipelines/internal/opencode"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// handleChatStar records the operator's shared star for one operator chat
// session. It is a registry write, not a local preference: every browser and
// device lists the same Starred group, and starring never mutates the OpenCode
// session or its transcript. A session id that is not a recorded operator
// session is refused before anything is written, so a pipeline-owned run session
// is never touched. The request body is a ChatQuery carrying SessionID and the
// desired Starred value; the reply echoes the updated session.
func handleChatStar(ctx context.Context, request protocol.Message, registry operatorRegistry, write func(protocol.Message) error) {
if registry == nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "operator session registry is not configured on this server"})
return
}
query := request.ChatQuery
if query == nil || !opencode.ValidSessionID(query.SessionID) {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
return
}
if query.Starred == nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a starred state is required"})
return
}
sessionID := query.SessionID
if _, found, err := registry.OperatorSession(ctx, sessionID); err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
} else if !found {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " is not an operator chat session"})
return
}
if err := registry.SetOperatorSessionStar(ctx, sessionID, *query.Starred); err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
session, found, err := registry.OperatorSession(ctx, sessionID)
if err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
if !found {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " is no longer an operator session"})
return
}
wire := chatSessionFromOperator(session)
write(protocol.Message{
Type: protocol.ChatStar,
ID: request.ID,
ChatSession: &wire,
ChatSessions: []protocol.ChatSession{wire},
})
}
+10
View File
@@ -132,6 +132,16 @@ func handleChatSubscribe(request protocol.Message, broker chatBroker, hub *chatH
frame := pending
sub.send(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame})
}
// Replay a question/form the agent raised before this client attached, so a
// reload or another device still sees the paused tool call.
for _, form := range hub.pendingForms(query.SessionID) {
pending := form
sub.send(protocol.Message{Type: protocol.ChatEvent, ChatEvent: &protocol.ChatEventFrame{
SessionID: query.SessionID,
Kind: protocol.ChatEventForm,
Form: &pending,
}})
}
// Replay the background processes still running, so a device that attaches
// after they started (a reconnect, or a chat opened from another device)
// shows them rather than nothing until they exit. The message snapshot cannot
+6 -3
View File
@@ -16,9 +16,12 @@ not this one, decides whether a feature is done.
`lists.css`, `run-detail.css`, `chat.css`, `graph.css`, `dialogs.css`,
`settings.css`), the app's dark palette and spacing, real attention to
hierarchy and detail. "Simple" is about the stack, never about the finish.
- **Trusted LAN/VPN only.** The server has no authentication; the page stores
nothing but the server URL in `localStorage`. Never bake in a server address,
never store secrets, never expose the API to an untrusted network.
- **Authenticated proxy, not a public API.** `serve.mjs` gates pages, assets,
artifacts and `/connect` behind a signed session cookie. The Pipelines server
and the agent harness remain unauthenticated control APIs; bind them to
loopback and expose only the authenticated proxy. The browser stores no
credentials. Tests that start their own proxy use
`PIPELINES_WEB_AUTH=disabled`; never run a real service that way.
## Layout
+11
View File
File diff suppressed because one or more lines are too long
+52
View File
@@ -837,3 +837,55 @@
.tok-number { color: #d8b46a; }
.tok-keyword { color: #93add0; font-weight: 600; }
.tok-literal { color: #c58fb0; }
/* The agent's structured question (OpenCode form kind=question): the transcript's
last item while the tool call is paused. Same surface as an approval card, with
an accent hairline and one block per form field. */
.chat-question {
display: flex;
flex-direction: column;
gap: 12px;
padding: 12px;
background: var(--surface-2);
border: 1px solid color-mix(in srgb, var(--accent) 50%, var(--border));
border-radius: var(--radius-card);
}
.chat-question-head { display: grid; gap: 2px; }
.chat-question-title { font-weight: 600; }
.chat-question-status { font-size: 12px; }
.chat-question-field { display: grid; gap: 6px; }
.chat-question-label { font-weight: 600; }
.chat-question-desc { font-size: 12px; }
.chat-question-options { display: grid; gap: 6px; }
.chat-question-option {
display: grid;
gap: 2px;
width: 100%;
padding: 8px 10px;
text-align: left;
border: 1px solid var(--border);
border-radius: var(--radius-control);
background: var(--surface);
color: var(--text);
font: inherit;
cursor: pointer;
}
.chat-question-option:hover { background: var(--surface-2); }
.chat-question-option.selected {
border-color: var(--accent);
background: var(--tint-selected);
}
.chat-question-option:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
.chat-question-option-desc { color: var(--muted); font-size: 12px; }
.chat-question-input {
width: 100%;
padding: 8px 10px;
border: 1px solid var(--border);
border-radius: var(--radius-control);
background: var(--bg);
color: var(--text);
font: inherit;
}
.chat-question-error { color: var(--bad); font-size: 12px; }
.chat-question-controls { display: flex; gap: 10px; }
.chat-question-submit { padding: 6px 12px; }
+25 -1
View File
@@ -269,7 +269,7 @@
.version-row { display: flex; gap: 12px; align-items: baseline; border: 1px solid var(--border); border-radius: var(--radius-control); padding: 6px 10px; }
.version-title { font-weight: 600; }
.source-code { margin: 0; background: var(--surface-2); border: 1px solid var(--border); border-radius: var(--radius-card); padding: 12px; overflow: auto; max-height: 60vh; }
.source-code { margin: 0; background: var(--surface-2); border: 1px solid var(--border); border-radius: var(--radius-card); padding: 12px; overflow: auto; }
.source-code code { background: transparent; padding: 0; font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace; font-size: 12px; white-space: pre-wrap; word-break: break-word; }
.graph-note { margin: 0; max-width: 60ch; }
@@ -368,3 +368,27 @@
.list-collapsed .chat-row .chat-session-button { grid-row: auto; }
.list-collapsed .chat-row .chat-activity { font-size: 10px; }
.list-collapsed .list-pane .day-header { display: none; }
/* The list-row shape cue: the pipeline's route at a glance, without labels. */
.pipeline-mini {
display: block;
width: 100%;
max-width: 260px;
height: 22px;
margin: 3px 0 1px;
color: var(--color-muted);
}
.pipeline-mini-graph { display: block; width: 100%; height: 100%; overflow: visible; }
.pipeline-mini-edge {
fill: none;
stroke: currentColor;
stroke-width: 1.2;
opacity: 0.5;
vector-effect: non-scaling-stroke;
}
.pipeline-mini-node { fill: currentColor; opacity: 0.55; }
.row.selected .pipeline-mini { color: var(--color-accent); }
.row:hover .pipeline-mini { color: var(--color-text); }
@media (prefers-reduced-motion: no-preference) {
.pipeline-mini { transition: color 120ms ease-out; }
}
+9 -2
View File
@@ -114,10 +114,17 @@ function passwordOk(candidate) {
}
function sessionCookie(req, remember = false) {
const bits = [`${SESSION_COOKIE}=${sessionToken(remember)}`, "Path=/", "HttpOnly", "SameSite=Strict"];
// Lax, not Strict: launching the installed app or a link from another app is
// a top-level navigation, and a Strict cookie is withheld on that first
// request, which made a remembered session look forgotten. Lax still keeps
// the cookie off cross-site subresource and POST requests.
const bits = [`${SESSION_COOKIE}=${sessionToken(remember)}`, "Path=/", "HttpOnly", "SameSite=Lax"];
// Remember me persists the cookie; otherwise it is a browser-session cookie
// (and the signed token itself expires after 12 hours).
if (remember) bits.push(`Max-Age=${SESSION_LONG_SECONDS}`);
if (remember) {
const expires = new Date(Date.now() + SESSION_LONG_SECONDS * 1000).toUTCString();
bits.push(`Max-Age=${SESSION_LONG_SECONDS}`, `Expires=${expires}`);
}
// Tailscale terminates TLS and usually forwards the scheme; when it does, the
// cookie is Secure. A direct plain-http LAN visit still works without it.
const forwarded = String(req.headers["x-forwarded-proto"] ?? "").split(",")[0].trim();
+26 -5
View File
@@ -408,8 +408,23 @@ body {
padding: 0 var(--space-xs);
font-size: 11px;
}
.dock-row { display: flex; align-items: stretch; gap: 2px; min-width: 0; }
.dock-tabs { display: flex; flex: 1 1 auto; min-width: 0; gap: 2px; }
/* One equal cell per destination, then one for Search. Subgrid keeps the
tablist a real element (and a real ARIA tablist) while its tabs line up with
the search cell instead of Search taking a whole flex share of its own. */
.dock-row {
display: grid;
grid-template-columns: repeat(var(--dock-count, 1), minmax(0, 1fr)) minmax(0, 1fr);
align-items: stretch;
gap: 2px;
min-width: 0;
}
.dock-tabs {
display: grid;
grid-template-columns: subgrid;
grid-column: 1 / span var(--dock-count, 1);
min-width: 0;
gap: 2px;
}
.dock-item {
position: relative;
@@ -456,18 +471,20 @@ body {
}
.dock-badge[hidden] { display: none; }
.dock-search {
flex: 0 0 56px;
min-width: 0;
min-height: 48px;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 2px;
padding: 4px 2px;
border: 0;
border-radius: var(--radius-control);
background: transparent;
color: var(--color-muted);
font-size: 11px;
line-height: 14px;
}
.dock-search .icon { width: var(--icon-list); height: var(--icon-list); }
.dock-search[aria-expanded="true"] { background: var(--tint-selected); color: var(--color-text); }
@@ -610,8 +627,12 @@ body {
/* A phone always shows the destination bar; pane collapse is a wide affordance. */
@media (max-width: 599px) {
/* The small viewport is the one that is actually visible while a phone's
browser toolbar is showing. A dynamic-viewport bottom bar can sit under the
toolbar until it hides, leaving only the status row on screen. */
body,
.app-root { height: 100svh; }
#listCollapse { display: none; }
.dock-tabs { flex: 1 1 auto; }
.dock-item,
.dock-search { flex: 1 1 0; width: auto; min-width: 0; }
.dock-search { width: auto; min-width: 0; }
}
+60 -10
View File
@@ -27,7 +27,6 @@ import { SERVER_URL_STORAGE_KEY, readServerUrl, readWorkspace, writeServerUrl }
import { layoutGraph } from "./graph.js";
import { readGraphExpanded } from "./graphPrefs.js";
import { readArtifactView } from "./artifactViewPrefs.js";
import { readChatStars } from "./chatStars.js";
import { readLayoutPrefs, writeLayoutPrefs } from "./layoutPrefs.js";
import { DEFAULT_ROUTE, parseRoute, serializeRoute } from "./routes.js";
import { EMPTY_PIPELINE_FILTERS, PIPELINE_DETAIL_TABS } from "./pipelines.js";
@@ -179,8 +178,8 @@ const state = {
pipelineGraphExpanded: readGraphExpanded(),
// Gallery or list for run artifacts; a per-operator choice (artifactViewPrefs.js).
artifactView: readArtifactView(),
// Starred chat sessions (chatStars.js): local, always sorted first.
chatStars: readChatStars(),
// Starred chat sessions: filled from chat_sessions (server-shared).
chatStars: new Set(),
// The collapsed rail/list choices (layoutPrefs.js), restored per device.
...readLayoutPrefs(),
// Whether the CLOSED chats group is expanded (the chevron beside its name).
@@ -466,6 +465,7 @@ const railDestinations = h(
),
);
const dockTabs = DESTINATIONS.filter((destination) => destination.key !== "settings");
const dockDestinations = h(
"div",
{
@@ -474,9 +474,7 @@ const dockDestinations = h(
role: "tablist",
"aria-label": "Destinations",
},
...DESTINATIONS.filter((destination) => destination.key !== "settings").map((destination) =>
destinationTab(destination, "dock"),
),
...dockTabs.map((destination) => destinationTab(destination, "dock")),
);
const railSearch = h(
@@ -605,7 +603,9 @@ const dock = h(
h("div", { class: "dock-status-row" }, dockStatus, dockSettings),
// The destinations come first and Search sits on the right; every item takes
// an equal share of the bar on a phone.
h("div", { class: "dock-row" }, dockDestinations, dockSearch),
// One equal share per destination; Search is one more share of the same row,
// so the whole bar divides evenly however many destinations exist.
h("div", { class: "dock-row", style: `--dock-count: ${dockTabs.length}` }, dockDestinations, dockSearch),
);
// The attention sheet lives in its own layer so it can overlay any view without
// being torn down by a content re-render; renderAttentionSheet rebuilds it.
@@ -2431,6 +2431,35 @@ client.addEventListener("state", (event) => {
// transcript (C5) folds the frame itself, and the composer's own bookkeeping
// clears the queued notice and releases the Stop control. A frame for any other
// type is ignored.
/**
* A question raised by an agent chat is as urgent as a failing run: if the page
* is not showing that conversation, raise the browser notification the operator
* already enabled for run alerts. Clicking it opens the chat with the question.
*/
function notifyChatQuestion(frame) {
const form = frame?.form;
if (!form?.id) return;
if (typeof globalThis.Notification !== "function") return;
if (globalThis.isSecureContext !== true || globalThis.Notification.permission !== "granted") return;
if (state.view === "chat" && state.chatActiveId === frame.session_id) return;
const session = state.chatSessions.find((row) => row.id === frame.session_id);
const title = String(session?.title ?? "Chat").trim() || "Chat";
try {
const notification = new Notification(`${title} needs your answer`, {
body: String(form.title ?? "The agent asked a question."),
tag: `chat-question:${form.id}`,
});
notification.onclick = () => {
window.focus();
state.view = "chat";
render();
openChatSession(frame.session_id);
};
} catch {
// The in-page question card remains available.
}
}
client.addEventListener("frame", (event) => {
const message = event.detail;
if (!message) return;
@@ -2465,7 +2494,17 @@ client.addEventListener("frame", (event) => {
}
if (message.type !== Protocol.CHAT_EVENT) return;
const frame = message[ChatKeys.EVENT];
if (frame) onChatEvent(frame);
if (frame) {
if (
frame.kind === "form" &&
frame.form?.kind === "question" &&
frame.form.resolved !== true &&
frame.form.cancelled !== true
) {
notifyChatQuestion(frame);
}
onChatEvent(frame);
}
onChatFrame(message);
});
@@ -2560,5 +2599,16 @@ window.addEventListener("resize", () => {
}, 120);
});
// A previously configured endpoint re-opens on load (see bootServerUrl).
if (bootServerUrl) openConfiguredEndpoint({ surfaceError: false });
// A previously configured endpoint re-opens on load (see bootServerUrl). When
// nothing is stored, the page's own origin is the supported default proxy: use
// it instead of leaving a freshly signed-in device on a "Not configured" screen
// and making the operator find the same URL in Settings.
if (bootServerUrl) {
openConfiguredEndpoint({ surfaceError: false });
} else {
const sameOrigin = defaultServerUrl();
if (validateServerUrl(sameOrigin).valid) {
state.url = sameOrigin;
openConfiguredEndpoint({ surfaceError: false });
}
}
+16 -2
View File
@@ -94,7 +94,7 @@ export function attentionBadgeLabel(count) {
* An entry the operator explicitly dismissed never returns. A run status that
* asks nobody is dropped, so the surface can only ever hold actionable work.
*/
export function attentionEntries(runs, dismissed) {
export function attentionEntries(runs, dismissed, { since = 0 } = {}) {
const dismissedKeys =
dismissed instanceof Set ? dismissed : new Set(Array.isArray(dismissed) ? dismissed : []);
return (runs ?? [])
@@ -105,13 +105,16 @@ export function attentionEntries(runs, dismissed) {
if (dismissedKeys.has(key)) return null;
const title = String(run.title ?? "").trim();
const finished = String(run.finished_at ?? "");
const recency = finished.trim() !== "" ? finished : String(run.created_at ?? "");
const at = Date.parse(recency);
if (since > 0 && Number.isFinite(at) && at < since) return null;
return {
runId: run.id,
pipeline: String(run.name ?? ""),
label: title !== "" ? title : String(run.name ?? ""),
kind,
detail: attentionDetail(kind, run),
recency: finished.trim() !== "" ? finished : String(run.created_at ?? ""),
recency,
key,
};
})
@@ -124,6 +127,17 @@ export function attentionEntries(runs, dismissed) {
);
}
/**
* The start of the operator's local day in epoch ms. "Needs you" is a to-do list
* for what changed now; yesterday's failures are history, not a badge that
* follows every device and browser session for ever.
*/
export function startOfLocalDay(now = Date.now()) {
const date = new Date(now);
date.setHours(0, 0, 0, 0);
return date.getTime();
}
/**
* Captures the entries shown when the sheet opens. Bulk dismissal uses this
* snapshot so entries that arrive while the sheet is open are not removed. A
+31
View File
@@ -1133,6 +1133,7 @@ export const EVENT_STEP = "step";
export const EVENT_USAGE = "usage";
export const EVENT_USER = "user";
export const EVENT_SHELL = "shell";
export const EVENT_FORM = "form";
/** ChatStep.Status values. `ended` is the one status that settles a turn. */
export const STEP_ENDED = "ended";
@@ -1324,6 +1325,9 @@ export function newChatThread(sessionId = "") {
// derive from the two (see `approvalCard`).
permission: null,
permissionAnswer: "",
// The agent's pending structured question/form (OpenCode form.created). The
// card is derived from this frame; answers are local until submitted.
form: null,
// The reason a refused `chat_reply` left on the thread's error line, kept
// apart from any other error so a later accepted answer clears only this one.
permissionError: "",
@@ -1487,6 +1491,31 @@ export function threadPhase(thread, nowMillis) {
return turnPhase(threadRunningTools(thread.messages));
}
/**
* Folds one form frame into a conversation. A new form replaces the previous
* one; a resolved/cancelled update clears it; an update for a different id is
* ignored rather than reviving a dismissed card. The form is kept as data so the
* question card and every other client derive the same state.
*/
export function applyChatForm(thread, form) {
const current = thread ?? newChatThread(str(form?.session_id));
const id = str(form?.id);
if (id === "") return current;
const existing = current.form ?? null;
if (form?.cancelled === true) {
if (str(existing?.id) !== id) return current;
return { ...current, form: null };
}
if (form?.resolved === true) {
if (str(existing?.id) !== id) return current;
return { ...current, form: { ...existing, ...form, resolved: true } };
}
if (str(existing?.id) === id) {
return { ...current, form: { ...existing, ...form } };
}
return { ...current, form };
}
/**
* Applies one pushed `chat_event` frame to a conversation and returns the next
* thread. Any frame clears `queued` (the turn moved on); `user` echoes another
@@ -1515,6 +1544,8 @@ export function applyChatEvent(thread, frame, now = Date.now()) {
// that outlives the turn keeps showing after the turn's own indicator is gone.
case EVENT_SHELL:
return { ...current, shells: mergeShellFrame(current.shells, frame?.shell) };
case EVENT_FORM:
return applyChatForm(current, frame?.form);
// `usage` is recognised but not folded; it still cleared `queued` above.
case EVENT_USAGE:
default:
+3
View File
@@ -60,6 +60,7 @@ export const Protocol = Object.freeze({
CHAT_MESSAGES: "chat_messages",
CHAT_CLOSE: "chat_close",
CHAT_REOPEN: "chat_reopen",
CHAT_STAR: "chat_star",
// The shared live stream (C5). `chat_subscribe` attaches this connection to one
// session's stream (body: the session id); the server then pushes `chat_event`
// frames without a matching request id, so every client watching a session sees
@@ -67,6 +68,7 @@ export const Protocol = Object.freeze({
// detaches a subscription when the connection closes.
CHAT_SUBSCRIBE: "chat_subscribe",
CHAT_EVENT: "chat_event",
CHAT_ANSWER: "chat_answer",
// The composer's own commands (C8/C9). `chat_prompt` carries its body in
// `chat_prompt` (`{session_id,text,files?,operation_id}`) and its reply echoes
// `chat_queued` when the prompt waits behind an in-flight turn; `chat_interrupt`
@@ -111,6 +113,7 @@ export const ChatKeys = Object.freeze({
// unsolicited pushed frame on the shared stream).
SUBSCRIBE: "chat_subscribe",
EVENT: "chat_event",
ANSWER: "chat_answer",
// The composer's payloads (C8/C9). `chat_interrupt` deliberately has no key of
// its own: its body is the same `chat_query` the other session-scoped commands
// carry (internal/protocol/chat.go ChatQuery, Chat.kt interruptRequest), so a
+24
View File
@@ -347,6 +347,30 @@ export class PipelinesRepository {
return { session: response[ChatKeys.SESSION] ?? null, close: response[ChatKeys.CLOSE] ?? null };
}
/**
* Records the shared star on the server (chat_star), so every browser and
* device lists the same Starred group. Returns the updated session row.
*/
async starChat(sessionId, starred) {
const response = await this.#client.call({
type: Protocol.CHAT_STAR,
[ChatKeys.QUERY]: { session_id: sessionId, starred: Boolean(starred) },
});
return response[ChatKeys.SESSION] ?? null;
}
/**
* Answers one OpenCode form (the question tool's form). Answers is keyed by
* the form field key; the server forwards it to the paused tool call and the
* resolved form arrives on the normal chat_event stream.
*/
async answerChatForm(sessionId, formId, answers) {
return this.#client.call({
type: Protocol.CHAT_ANSWER,
[ChatKeys.ANSWER]: { session_id: sessionId, form_id: formId, answers },
});
}
/** Clears the closed state again, so a finished chat can be resumed. */
async reopenChat(sessionId) {
const response = await this.#client.call({
+4 -3
View File
@@ -12,6 +12,7 @@ import {
attentionDismissalSnapshot,
attentionEntries,
attentionRowDescription,
startOfLocalDay,
decodeAttentionDismissals,
encodeAttentionDismissals,
} from "../attention.js";
@@ -100,7 +101,7 @@ function renderAttentionBell() {
/** The number of entries the attention surface currently holds. */
function attentionCount() {
return attentionEntries(state.runs, state.attentionDismissed).length;
return attentionEntries(state.runs, state.attentionDismissed, { since: startOfLocalDay() }).length;
}
/**
@@ -154,7 +155,7 @@ function renderAttentionSheet() {
modal.close("attention-sheet");
return;
}
const entries = attentionEntries(state.runs, state.attentionDismissed);
const entries = attentionEntries(state.runs, state.attentionDismissed, { since: startOfLocalDay() });
const overlay = h("div", {
class: "attention-sheet",
role: "dialog",
@@ -259,7 +260,7 @@ function renderAttentionRow(entry, labelCounts = null) {
function openAttentionSheet() {
state.attentionSheetOpen = true;
state.attentionSnapshot = attentionDismissalSnapshot(
attentionEntries(state.runs, state.attentionDismissed),
attentionEntries(state.runs, state.attentionDismissed, { since: startOfLocalDay() }),
);
render();
}
+199 -12
View File
@@ -4,7 +4,7 @@
// in chat.js and markdown.js; this module owns the DOM and the chat wire wiring.
import { h } from "../dom.js";
import { writeChatStars } from "../chatStars.js";
import { readChatStars, writeChatStars } from "../chatStars.js";
import { describeError } from "../format.js";
import { SHELL_OUTPUT_LIMIT, newChatOperationId } from "../repository.js";
import { codeBlockLabel, parseInline, parseMarkdown } from "../markdown.js";
@@ -371,6 +371,23 @@ async function loadChatSessions(force = false) {
renderContent();
try {
const listed = await repo.chatSessions();
// One-time migration from the old local-only stars: upload this device's
// saved set, then let the server's shared set be authoritative everywhere.
const localStars = readChatStars();
if (localStars.size) {
for (const id of localStars) {
const session = listed.find((entry) => entry.id === id);
if (!session || session.starred) continue;
try {
const updated = await repo.starChat(id, true);
if (updated) Object.assign(session, updated);
} catch {
// Keep going: a missing session or a transient failure must not block
// the rest of the list.
}
}
writeChatStars(new Set());
}
// Keep this page's own verification chats, which the server intentionally
// never returns, at the head of the in-memory list (memory-only; see
// chatEphemeralIds). Everything else is the server's list, in its order.
@@ -379,6 +396,7 @@ async function loadChatSessions(force = false) {
state.chatEphemeralIds.has(session.id) && !listed.some((entry) => entry.id === session.id),
);
state.chatSessions = [...held, ...listed];
syncChatStarsFromSessions();
state.chatLoaded = true;
rt.touchView?.("chat");
// Fold this device's seen state in: the active chat has been read, and every
@@ -670,6 +688,26 @@ async function answerPermission(sessionId, requestId, decision) {
}
}
/**
* Answer the agent's pending question. The answer map is keyed by the form
* field's own key and mirrors OpenCode's form.reply body; the resolved form
* arrives on the stream and clears the card for every watching client.
*/
async function answerChatQuestion(sessionId, form, answers) {
if (!form?.id) return;
try {
await repo.answerChatForm(sessionId, form.id, answers);
const current = state.chatThreads.get(sessionId);
if (current?.form && current.form.id === form.id) {
setThread(sessionId, { form: { ...current.form, resolved: true } });
}
renderContent();
} catch (error) {
state.actionError = describeError(error);
renderContent();
}
}
/**
* The reconnect repair (C5): re-attach the open chat's stream and replace its
* conversation with the newest history page wholesale. Everything the gap could
@@ -884,10 +922,17 @@ async function reopenChatSession(id) {
}
/** Apply the echoed session (or the local closed flag) to the held row. */
function syncChatStarsFromSessions(sessions = state.chatSessions) {
state.chatStars = new Set(
(sessions ?? []).filter((session) => session.starred === true).map((session) => session.id),
);
}
function applyChatSessionUpdate(id, updated, closed) {
state.chatSessions = state.chatSessions.map((session) =>
session.id === id ? { ...session, ...(updated ?? {}), closed } : session,
);
syncChatStarsFromSessions();
}
// ---------------------------------------------------------------------------
@@ -1596,13 +1641,24 @@ function chatEmpty(message) {
return h("div", { class: "empty" }, h("span", { class: "muted", text: message }));
}
/** Toggle one session's local star, then repaint the list in its new order. */
function toggleChatStar(id) {
const next = new Set(state.chatStars ?? []);
if (next.has(id)) next.delete(id);
else next.add(id);
state.chatStars = next;
writeChatStars(next);
/** Toggle one session's shared star on the server, then repaint its group. */
async function toggleChatStar(id) {
const wasStarred = state.chatStars?.has?.(id) === true;
state.chatSessions = state.chatSessions.map((session) =>
session.id === id ? { ...session, starred: !wasStarred } : session,
);
syncChatStarsFromSessions();
renderContent();
try {
const updated = await repo.starChat(id, !wasStarred);
if (updated) applyChatSessionUpdate(id, updated, updated.closed === true);
} catch (error) {
state.chatSessions = state.chatSessions.map((session) =>
session.id === id ? { ...session, starred: wasStarred } : session,
);
syncChatStarsFromSessions();
state.actionError = describeError(error);
}
renderContent();
}
@@ -1891,7 +1947,11 @@ function renderChatConversation() {
// answer. While it is actionable the chat pane offers a jump control and the
// running indicator stands down (a turn blocked on a decision is not generating).
const approval = approvalCard(thread?.permission, thread?.permissionAnswer);
const awaiting = approval?.actionable === true;
const form =
thread?.form && thread.form.resolved !== true && thread.form.cancelled !== true
? thread.form
: null;
const awaiting = approval?.actionable === true || form != null;
const bar = h("div", { class: "chat-bar" });
const titles = h("div", { class: "chat-bar-titles" });
@@ -1942,11 +2002,11 @@ function renderChatConversation() {
// blocked on a decision is not generating, so neither the spinner nor its clock
// shows. The composer's Stop control stays governed by thread.running.
const running = thread?.running === true && !awaiting;
if (rows.length === 0 && notices.length === 0 && !running && !approval) {
if (rows.length === 0 && notices.length === 0 && !running && !approval && !form) {
pane.append(h("div", { class: "chat-transcript-empty muted", text: CONVERSATION_EMPTY }));
} else {
pane.append(
renderChatTranscript(state.chatActiveId, rows, { notices, running, now: Date.now(), approval }),
renderChatTranscript(state.chatActiveId, rows, { notices, running, now: Date.now(), approval, form }),
);
}
if (thread?.error && thread?.loaded) {
@@ -2187,7 +2247,7 @@ function renderBackgroundTaskDetail(thread, shell) {
function renderChatTranscript(
sessionId,
rows,
{ notices = [], running = false, now = Date.now(), approval = null } = {},
{ notices = [], running = false, now = Date.now(), approval = null, form = null } = {},
) {
const wrap = h("div", { class: "chat-transcript-wrap" });
const transcript = h("div", {
@@ -2219,6 +2279,7 @@ function renderChatTranscript(
// after the running indicator when it is shown — so the pane's jump control
// and a fresh card both land at the end.
if (approval) transcript.append(renderChatApproval(sessionId, approval));
if (form) transcript.append(renderChatQuestion(sessionId, form));
wrap.append(transcript);
wrap.append(
h("button", {
@@ -2303,6 +2364,132 @@ function renderChatApproval(sessionId, card) {
return node;
}
/**
* The agent's structured question (OpenCode form with kind=question). Each form
* field is rendered with its options (single-select buttons or multi-select
* toggles) and, when the field is free-form or allows Other, a text input.
* Answers stay local until Send answer; the tool call is paused until then.
*/
function renderChatQuestion(sessionId, form) {
const node = h("div", {
class: "chat-question",
id: "chatQuestion",
"data-form-id": form.id,
});
const head = h("div", { class: "chat-question-head" });
head.append(h("div", { class: "chat-question-title", text: form.title || "Question" }));
head.append(
h("div", { class: "chat-question-status muted", text: "The agent is waiting for your answer." }),
);
node.append(head);
const answers = {};
const parts = [];
for (const field of form.fields ?? []) {
const key = String(field.key ?? "");
if (key === "") continue;
const options = Array.isArray(field.options) ? field.options : [];
const multi = field.type === "multiselect";
const part = h("div", { class: "chat-question-field" });
part.append(
h("div", { class: "chat-question-label", text: field.title || field.description || key }),
);
if (field.description && field.description !== field.title) {
part.append(h("div", { class: "chat-question-desc muted", text: field.description }));
}
if (options.length) {
const rows = h("div", { class: "chat-question-options" });
const buttons = [];
const chosen = () => (multi ? (Array.isArray(answers[key]) ? answers[key] : []) : [answers[key]].filter(Boolean));
const paint = () => {
const selected = new Set(chosen());
for (const button of buttons) {
const on = selected.has(button.dataset.value);
button.classList.toggle("selected", on);
button.setAttribute("aria-pressed", on ? "true" : "false");
}
};
for (const option of options) {
const value = String(option.value ?? option.label ?? "");
if (value === "") continue;
const button = h(
"button",
{
class: "chat-question-option",
type: "button",
"data-value": value,
"aria-pressed": "false",
text: option.label || value,
},
option.description
? h("span", { class: "chat-question-option-desc", text: option.description })
: null,
);
button.addEventListener("click", () => {
if (multi) {
const next = new Set(chosen());
if (next.has(value)) next.delete(value);
else next.add(value);
answers[key] = [...next];
} else {
answers[key] = value;
}
paint();
});
buttons.push(button);
rows.append(button);
}
part.append(rows);
}
if (field.custom === true || options.length === 0) {
const input = h("input", {
class: "chat-question-input",
type: "text",
placeholder: options.length ? "Type another answer" : "Your answer",
autocomplete: "off",
});
input.addEventListener("input", () => {
const value = input.value.trim();
if (value === "") delete answers[key];
else answers[key] = value;
});
part.append(input);
}
parts.push(part);
}
node.append(...parts);
const error = h("div", { class: "chat-question-error", role: "alert", hidden: true });
node.append(error);
const controls = h("div", { class: "chat-question-controls" });
const submit = h("button", {
class: "primary chat-question-submit",
type: "button",
text: "Send answer",
});
let sent = false;
submit.addEventListener("click", () => {
if (sent) return;
const missing = (form.fields ?? []).some((field) => {
if (!field.required) return false;
const value = answers[field.key];
return Array.isArray(value) ? value.length === 0 : !value;
});
if (missing) {
error.hidden = false;
error.textContent = "Answer the required questions before sending.";
return;
}
sent = true;
submit.disabled = true;
submit.textContent = "Sending…";
answerChatQuestion(sessionId, form, answers);
});
controls.append(submit);
node.append(controls);
return node;
}
/**
* The app's amber outlined Shield (`Icons.Outlined.Shield`): an inline SVG stroked
* with `currentColor` so the palette's warn hue actually tints it, unlike the
+73 -2
View File
@@ -20,10 +20,11 @@ import {
runBadge,
runBadgeMetaLine,
sortPipelines,
stageCountText,
summaryFields,
versionRow,
} from "../pipelines.js";
import { PIPELINE_GRAPH_EMPTY, mount as mountGraph } from "../graph.js";
import { PIPELINE_GRAPH_EMPTY, layoutGraph, mount as mountGraph } from "../graph.js";
import { statusIcon } from "../statusIcon.js";
import { writeGraphExpanded } from "../graphPrefs.js";
@@ -236,6 +237,69 @@ function fillPipelineRows(rowsEl) {
rowsEl.replaceChildren(...nodes);
}
// A list row's graph is a shape cue, not a reading surface: tiny nodes and
// straight routes, no labels or chips. The detail Graph tab is the real one.
const MINI_GRAPH_METRICS = Object.freeze({
nodeWidth: 26,
nodeHeight: 12,
hGap: 12,
pad: 2,
laneSpacing: 8,
terminalGap: 8,
trackStep: 6,
portSpacing: 4,
labelCharWidth: 0,
labelPadding: 0,
labelHeight: 0,
labelGap: 0,
});
const SVG_NS = "http://www.w3.org/2000/svg";
/** The pipeline's stages and their stage-to-stage routes, without terminals. */
function miniGraphShape(graph) {
const stages = graph?.stages ?? [];
const keys = new Set(stages.map((stage) => stage.key));
return {
stages: stages.map((stage) => ({
...stage,
edges: Object.fromEntries(
Object.entries(stage.edges ?? {}).filter(([, target]) => keys.has(target)),
),
})),
};
}
function renderPipelineMiniGraph(pipeline) {
const shape = pipeline.shape ?? pipeline.graph;
if (!shape?.stages?.length) return null;
const layout = layoutGraph(miniGraphShape(shape), MINI_GRAPH_METRICS);
if (!layout.nodes.length || !layout.width || !layout.height) return null;
const svg = document.createElementNS(SVG_NS, "svg");
svg.setAttribute("class", "pipeline-mini-graph");
svg.setAttribute("viewBox", `0 0 ${Math.ceil(layout.width)} ${Math.ceil(layout.height)}`);
svg.setAttribute("preserveAspectRatio", "xMidYMid meet");
svg.setAttribute("aria-hidden", "true");
svg.setAttribute("focusable", "false");
for (const edge of layout.edges) {
if (edge.points.length < 2) continue;
const line = document.createElementNS(SVG_NS, "polyline");
line.setAttribute("class", "pipeline-mini-edge");
line.setAttribute("points", edge.points.map((point) => `${point.x},${point.y}`).join(" "));
svg.append(line);
}
for (const node of layout.nodes) {
const rect = document.createElementNS(SVG_NS, "rect");
rect.setAttribute("class", "pipeline-mini-node");
rect.setAttribute("x", String(node.x));
rect.setAttribute("y", String(node.y));
rect.setAttribute("width", String(node.width));
rect.setAttribute("height", String(node.height));
rect.setAttribute("rx", "3");
svg.append(rect);
}
return h("span", { class: "pipeline-mini", "aria-hidden": "true" }, svg);
}
function renderPipelineRow(pipeline, latestRuns, runsKnown, now) {
const children = [
h(
@@ -244,8 +308,15 @@ function renderPipelineRow(pipeline, latestRuns, runsKnown, now) {
pipelineGlyph(),
h("span", { class: "row-title", text: pipeline.name || `pipeline ${pipeline.id}` }),
),
h("span", { class: "row-meta", text: pipelineSubtitle(pipeline) }),
];
const mini = renderPipelineMiniGraph(pipeline);
if (mini) children.push(mini);
children.push(
h("span", {
class: "row-meta",
text: stageCountText(pipeline.stages ?? pipeline.shape?.stages?.length ?? 0),
}),
);
const updated = pipelineUpdatedLine(pipeline);
if (updated) children.push(h("span", { class: "row-meta", text: updated }));
if (runsKnown) {
+22
View File
@@ -13,6 +13,7 @@ import {
attentionDismissAll,
attentionDismissalSnapshot,
attentionEntries,
startOfLocalDay,
attentionKey,
attentionKindOf,
attentionRowDescription,
@@ -108,6 +109,27 @@ test("row description is exactly {pipeline} · {detail}", () => {
assert.equal(attentionRowDescription(entry), "Plan and land · failed hard");
});
test("the surface is today's work: older failures are history", () => {
const entries = [
run({ id: 1, status: "failed", finished_at: "2026-10-19T21:33:27Z" }),
run({ id: 2, status: "failed", finished_at: "2026-10-20T10:00:00Z" }),
];
const since = Date.parse("2026-10-20T00:00:00Z");
assert.deepEqual(
attentionEntries(entries, new Set(), { since }).map((entry) => entry.runId),
[2],
);
assert.equal(attentionEntries(entries, new Set()).length, 2);
});
test("startOfLocalDay is local midnight", () => {
const now = new Date(2026, 9, 20, 15, 4, 5).getTime();
const start = startOfLocalDay(now);
assert.equal(new Date(start).getHours(), 0);
assert.equal(new Date(start).getMinutes(), 0);
assert.ok(start < now);
});
test("badge label is bare Notifications when empty, else the count", () => {
assert.equal(attentionBadgeLabel(0), "Notifications");
assert.equal(attentionBadgeLabel(-3), "Notifications");
+19
View File
@@ -69,6 +69,7 @@ import {
TURN_PHASE_WAITING,
appendChatNotice,
applyChatEvent,
applyChatForm,
applyChatOverrides,
applyChatPermission,
approvalCard,
@@ -1939,3 +1940,21 @@ test("the C13 wording matches the Android sources verbatim", () => {
assert.equal(sessionActivityBadge(sessionActivity(false, false), true), "Open");
assert.equal(sessionActivityBadge(sessionActivity(false, false), false), "Idle");
});
test("applyChatForm keeps one pending question and clears it on resolve", () => {
const form = { id: "f1", session_id: "s1", kind: "question", title: "Pick", fields: [] };
let thread = newChatThread("s1");
thread = applyChatEvent(thread, { kind: "form", session_id: "s1", form }, 1);
assert.equal(thread.form?.id, "f1");
assert.equal(thread.form?.title, "Pick");
// A different form replaces the card; the old id cannot revive.
thread = applyChatForm(thread, { id: "f2", session_id: "s1", title: "Next" });
assert.equal(thread.form?.id, "f2");
thread = applyChatForm(thread, { id: "f1", session_id: "s1", resolved: true });
assert.equal(thread.form?.id, "f2");
thread = applyChatForm(thread, { id: "f2", session_id: "s1", resolved: true });
assert.equal(thread.form?.id, "f2");
assert.equal(thread.form?.resolved, true);
thread = applyChatForm(thread, { id: "f2", session_id: "s1", cancelled: true });
assert.equal(thread.form, null);
});
+139 -248
View File
@@ -2627,261 +2627,169 @@ try {
};
})()`);
const attentionCount = Number(bell.dataCount ?? 0);
if (!(attentionCount > 0)) {
throw new Error(`no attention entries on the live server: ${JSON.stringify(bell)}`);
}
if (bell.label !== `Notifications, ${attentionCount} needing attention`) {
const expectedLabel =
attentionCount > 0 ? `Notifications, ${attentionCount} needing attention` : "Notifications";
if (bell.label !== expectedLabel) {
throw new Error(`the bell's accessible name is wrong: ${bell.label}`);
}
if (!bell.hasBadge || bell.count !== String(attentionCount)) {
if (attentionCount > 0 && (!bell.hasBadge || bell.count !== String(attentionCount))) {
throw new Error(`the badge is wrong: ${JSON.stringify(bell)}`);
}
if (attentionCount === 0 && bell.hasBadge) {
throw new Error(`a zero-count bell still has a badge: ${JSON.stringify(bell)}`);
}
if (await page.evaluate(`!!document.querySelector(".attention-sheet")`)) {
throw new Error("the sheet was already open before the bell was clicked");
}
console.log(` bell: aria-label="${bell.label}", badge=${bell.count}`);
console.log(
attentionCount > 0
? ` bell: aria-label="${bell.label}", badge=${bell.count}`
: " bell: no current attention entries; asserting the zero state",
);
shots.push(await page.screenshot(`${out}/35-attention-bell.png`));
step("checking the bell's monochrome SVG glyph and the badge's layout isolation");
const countProbe = await attentionBellProbe();
assertAttentionBellGlyph(countProbe, attentionCount, "wide bell with a count");
const wideShift = assertAttentionBellBadgeShift(
await attentionBellBadgeShift(),
"wide bell with a count",
);
console.log(
` glyph: <${countProbe.tagName} viewBox="${countProbe.viewBox}"> with ${countProbe.pathCount} ` +
`unfilled currentColor paths at ${countProbe.width}×${countProbe.height}; ` +
`badge "${countProbe.badge.text}" (${countProbe.badge.position})`,
);
console.log(
` no-shift with the badge hidden: bell ${wideShift.bellDelta}px, ` +
`Runs title ${wideShift.titleDelta}px`,
);
assertAttentionBellGlyph(countProbe, attentionCount, "wide bell");
step("checking the bell at 420x900");
await page.resize(420, 900);
await eventually(() => page.evaluate(`matchMedia("(min-width: 600px)").matches === false`), {
what: "the narrow layout at 420px",
});
await settle(200);
const narrowProbe = await attentionBellProbe();
assertAttentionBellGlyph(narrowProbe, attentionCount, "narrow bell with a count");
const narrowShift = assertAttentionBellBadgeShift(
await attentionBellBadgeShift(),
"narrow bell with a count",
);
shots.push(await page.screenshot(`${out}/35a-attention-bell-narrow-420x900.png`));
console.log(
` narrow: ${narrowProbe.width}×${narrowProbe.height} glyph, badge ` +
`"${narrowProbe.badge.text}" (${narrowProbe.badge.position}); no-shift bell ` +
`${narrowShift.bellDelta}px, Runs title ${narrowShift.titleDelta}px`,
);
await page.resize(1440, 900);
await eventually(() => page.evaluate(`matchMedia("(min-width: 600px)").matches === true`), {
what: "the wide layout back at 1440px",
});
await settle(200);
if (attentionCount > 0) {
step("checking the bell's monochrome SVG glyph and the badge's layout isolation");
const wideShift = assertAttentionBellBadgeShift(
await attentionBellBadgeShift(),
"wide bell with a count",
);
console.log(
` glyph: <${countProbe.tagName} viewBox="${countProbe.viewBox}"> with ${countProbe.pathCount} ` +
`unfilled currentColor paths at ${countProbe.width}×${countProbe.height}; ` +
`badge "${countProbe.badge.text}" (${countProbe.badge.position})`,
);
console.log(
` no-shift with the badge hidden: bell ${wideShift.bellDelta}px, ` +
`Runs title ${wideShift.titleDelta}px`,
);
step("opening the Needs you sheet");
await page.click("#attentionBell");
await page.waitForSelector(".attention-sheet", { timeout: 15000 });
const sheet = await page.evaluate(`(() => {
const rows = [...document.querySelectorAll(".attention-sheet .attention-row")];
return {
step("checking the bell at 420x900");
await page.resize(420, 900);
await eventually(() => page.evaluate(`matchMedia("(min-width: 600px)").matches === false`), {
what: "the narrow layout at 420px",
});
await settle(200);
const narrowProbe = await attentionBellProbe();
assertAttentionBellGlyph(narrowProbe, attentionCount, "narrow bell with a count");
assertAttentionBellBadgeShift(await attentionBellBadgeShift(), "narrow bell with a count");
shots.push(await page.screenshot(`${out}/35a-attention-bell-narrow-420x900.png`));
await page.resize(1440, 900);
await eventually(() => page.evaluate(`matchMedia("(min-width: 600px)").matches === true`), {
what: "the wide layout back at 1440px",
});
await settle(200);
step("opening the Needs you sheet");
await page.click("#attentionBell");
await page.waitForSelector(".attention-sheet", { timeout: 15000 });
const sheet = await page.evaluate(`(() => ({
title: document.querySelector(".attention-sheet-title")?.textContent ?? "",
clearAll: document.querySelector(".attention-clear")?.textContent ?? null,
empty: document.querySelector(".attention-empty")?.textContent ?? null,
focused: document.activeElement?.className ?? "",
rows: rows.map((row) => {
const open = row.querySelector(".attention-row-open");
const dismiss = row.querySelector(".attention-dismiss");
return {
runId: Number(open?.dataset.runId),
kind: open?.dataset.kind ?? "",
label: open?.querySelector(".attention-label")?.textContent ?? "",
desc: open?.querySelector(".attention-desc")?.textContent ?? "",
icon: open?.querySelector(".attention-icon")?.textContent ?? "",
dismissName: dismiss?.getAttribute("aria-label") ?? "",
};
}),
};
})()`);
if (sheet.title !== "Needs you") throw new Error(`the sheet title is wrong: ${sheet.title}`);
if (sheet.empty !== null) throw new Error(`a non-empty sheet showed the empty copy: ${sheet.empty}`);
if (sheet.clearAll !== "Clear all") throw new Error(`Clear all is missing: ${sheet.clearAll}`);
if (sheet.rows.length !== attentionCount) {
throw new Error(`the sheet drew ${sheet.rows.length} rows for a badge of ${attentionCount}`);
}
if (!sheet.focused.includes("attention-sheet-close")) {
throw new Error(`focus did not move into the sheet on open: ${sheet.focused}`);
}
const kindRanks = { decision: 0, failed: 1 };
let lastKindRank = -1;
for (const row of sheet.rows) {
if (!row.icon) throw new Error(`row ${row.runId} has no status icon`);
if (!row.label) throw new Error(`row ${row.runId} has no primary label`);
if (!row.desc.includes(" · ")) throw new Error(`row ${row.runId} description is wrong: ${row.desc}`);
// The dismiss control is named for the row it clears (L7 M6), e.g.
// `Dismiss Web: live decision confirm (R11)`; the run id appears only for a
// repeated label, so assert the shared prefix rather than the old bare word.
if (!row.dismissName.startsWith("Dismiss ")) {
throw new Error(`row ${row.runId}'s trailing control is not named Dismiss: ${row.dismissName}`);
rows: [...document.querySelectorAll(".attention-sheet .attention-row")].map((row) => ({
runId: Number(row.querySelector(".attention-row-open")?.dataset.runId),
kind: row.querySelector(".attention-row-open")?.dataset.kind ?? "",
label: row.querySelector(".attention-label")?.textContent ?? "",
desc: row.querySelector(".attention-desc")?.textContent ?? "",
dismissName: row.querySelector(".attention-dismiss")?.getAttribute("aria-label") ?? "",
})),
}))()`);
if (sheet.title !== "Needs you") throw new Error(`the sheet title is wrong: ${sheet.title}`);
if (sheet.empty !== null) throw new Error(`a non-empty sheet showed the empty copy: ${sheet.empty}`);
if (sheet.clearAll !== "Clear all") throw new Error(`Clear all is missing: ${sheet.clearAll}`);
if (sheet.rows.length !== attentionCount) {
throw new Error(`the sheet drew ${sheet.rows.length} rows for a badge of ${attentionCount}`);
}
const rank = kindRanks[row.kind];
if (rank == null) throw new Error(`row ${row.runId} has an unknown kind ${row.kind}`);
if (rank < lastKindRank) throw new Error(`the rows are out of kind order at run ${row.runId}`);
lastKindRank = rank;
}
const firstRow = sheet.rows[0];
const kindName = (kind) => (kind === "decision" ? "Decision" : "Failed");
console.log(
` sheet: ${sheet.rows.length} row(s); first ${firstRow.runId} (${firstRow.kind}) ` +
`"${firstRow.label}" — ${firstRow.desc}`,
);
if (!sheet.rows.some((row) => row.kind === "decision")) {
console.log(
" -- no `waiting` run exists on the live server; the sheet used real failed runs " +
"and the decision path (open without dismissing) is covered by unit tests",
);
}
shots.push(await page.screenshot(`${out}/36-attention-sheet.png`));
if (!sheet.focused.includes("attention-sheet-close")) {
throw new Error(`focus did not move into the sheet on open: ${sheet.focused}`);
}
for (const row of sheet.rows) {
if (!row.label || !row.desc.includes(" · ")) {
throw new Error(`row ${row.runId} is missing its label or description: ${JSON.stringify(row)}`);
}
if (!row.dismissName.startsWith("Dismiss ")) {
throw new Error(`row ${row.runId}'s trailing control is not named Dismiss: ${row.dismissName}`);
}
}
console.log(` sheet: ${sheet.rows.length} row(s); first ${sheet.rows[0].runId} (${sheet.rows[0].kind})`);
shots.push(await page.screenshot(`${out}/36-attention-sheet.png`));
step("dismissing one entry individually");
await page.evaluate(`document.querySelector(".attention-sheet .attention-row .attention-dismiss").click()`);
await eventually(
async () =>
(await page.evaluate(`document.querySelectorAll(".attention-sheet .attention-row").length`)) ===
attentionCount - 1,
{ what: "the individual dismissal to land" },
);
const afterDismiss = await page.evaluate(`(() => ({
rows: document.querySelectorAll(".attention-sheet .attention-row").length,
badge: document.querySelector("#attentionBell .attention-badge")?.dataset.count ?? null,
svg: !!document.querySelector("#attentionBell > svg.attention-bell-icon"),
pathCount: document.querySelectorAll("#attentionBell > svg.attention-bell-icon path").length,
stored: localStorage.getItem("pipelines.web.attention.v1"),
}))()`);
if (afterDismiss.rows !== attentionCount - 1) {
throw new Error(`the sheet still shows ${afterDismiss.rows} rows after one dismissal`);
}
if (Number(afterDismiss.badge) !== attentionCount - 1) {
throw new Error(`the badge did not follow the dismissal: ${afterDismiss.badge}`);
}
if (!afterDismiss.svg || afterDismiss.pathCount !== countProbe.pathCount) {
throw new Error(
`the in-place badge refresh rebuilt the glyph: ${JSON.stringify(afterDismiss)}`,
);
}
if (!String(afterDismiss.stored).includes(`${firstRow.runId}:${kindName(firstRow.kind)}`)) {
throw new Error(`the dismissed identity was not persisted: ${afterDismiss.stored}`);
}
console.log(
` dismissed ${firstRow.runId}:${kindName(firstRow.kind)}; rows ${attentionCount} -> ` +
`${afterDismiss.rows}, stored ${afterDismiss.stored}`,
);
shots.push(await page.screenshot(`${out}/37-attention-dismissed.png`));
step("opening a Failed row: it opens the run and persists its dismissal");
const rowToOpen = await page.evaluate(`(() => {
const open = document.querySelector(".attention-sheet .attention-row .attention-row-open");
if (!open) return null;
return { runId: Number(open.dataset.runId), kind: open.dataset.kind };
})()`);
if (!rowToOpen) {
// The history may hold a single attention entry (for example a fresh database
// where only the current run has failed); the dismissal above then emptied it.
console.log(" -- no remaining attention row to open; the row-activated path is unit-tested");
} else if (rowToOpen.kind !== "failed") {
console.log(` -- the remaining row is ${rowToOpen.kind}, not Failed; skipped the open check`);
} else {
await page.evaluate(`document.querySelector(".attention-sheet .attention-row .attention-row-open").click()`);
step("dismissing one entry individually");
await page.evaluate(`document.querySelector(".attention-sheet .attention-row .attention-dismiss").click()`);
await eventually(
async () => !(await page.evaluate(`!!document.querySelector(".attention-sheet")`)),
{ what: "the sheet to close on row activation" },
async () => (await page.evaluate(`document.querySelectorAll(".attention-sheet .attention-row").length`)) === attentionCount - 1,
{ what: "the individual dismissal to land" },
);
await page.waitForSelector("#detailTitle", { timeout: 25000 });
const openedIdentity = await page.evaluate(
`document.querySelector(".run-identity")?.textContent ?? ""`,
);
if (!openedIdentity.startsWith(`run ${rowToOpen.runId} ·`)) {
throw new Error(`row ${rowToOpen.runId} did not open its run: ${openedIdentity}`);
const afterDismiss = await page.evaluate(`(() => ({
rows: document.querySelectorAll(".attention-sheet .attention-row").length,
badge: document.querySelector("#attentionBell .attention-badge")?.dataset.count ?? null,
stored: localStorage.getItem("pipelines.web.attention.v1"),
}))()`);
if (afterDismiss.rows !== attentionCount - 1 || Number(afterDismiss.badge) !== attentionCount - 1) {
throw new Error(`the dismissal did not update the sheet/badge: ${JSON.stringify(afterDismiss)}`);
}
const storedAfterOpen = await page.evaluate(`localStorage.getItem("pipelines.web.attention.v1")`);
if (!String(storedAfterOpen).includes(`${rowToOpen.runId}:Failed`)) {
throw new Error(`opening a Failed row did not persist its dismissal: ${storedAfterOpen}`);
}
console.log(` opened run ${rowToOpen.runId}; ${rowToOpen.runId}:Failed now persisted`);
}
console.log(` dismissed one; rows ${attentionCount} -> ${afterDismiss.rows}`);
shots.push(await page.screenshot(`${out}/37-attention-dismissed.png`));
step("reopening the sheet and clearing all");
// A skipped row-open can leave the sheet up; close it so the bell reopens it.
if (await page.evaluate(`!!document.querySelector(".attention-sheet")`)) {
await page.evaluate(
`document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`,
);
await eventually(
async () => !(await page.evaluate(`!!document.querySelector(".attention-sheet")`)),
{ what: "the attention sheet to close before reopening" },
);
}
await page.click("#attentionBell");
await page.waitForSelector(".attention-sheet", { timeout: 15000 });
const beforeClear = await page.evaluate(
`document.querySelectorAll(".attention-sheet .attention-row").length`,
);
if (beforeClear > attentionCount) {
throw new Error(`the sheet grew: ${beforeClear} rows from ${attentionCount} entries`);
}
if (beforeClear > 0) {
await page.evaluate(`document.querySelector(".attention-sheet .attention-clear").click()`);
step("reopening the sheet and clearing all");
if (await page.evaluate(`!!document.querySelector(".attention-sheet")`)) {
await page.evaluate(`document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`);
await eventually(async () => !(await page.evaluate(`!!document.querySelector(".attention-sheet")`)), {
what: "the attention sheet to close before reopening",
});
}
await page.click("#attentionBell");
await page.waitForSelector(".attention-sheet", { timeout: 15000 });
const beforeClear = await page.evaluate(`document.querySelectorAll(".attention-sheet .attention-row").length`);
if (beforeClear > 0) {
await page.evaluate(`document.querySelector(".attention-sheet .attention-clear").click()`);
await eventually(
async () => (await page.evaluate(`document.querySelector(".attention-empty")?.textContent ?? ""`)) === "Nothing needs you right now.",
{ what: "the empty attention state after Clear all" },
);
if (await page.evaluate(`!!document.querySelector("#attentionBell .attention-badge")`)) {
throw new Error("the badge is still visible after Clear all");
}
}
console.log(" Clear all left the empty attention state and no badge");
shots.push(await page.screenshot(`${out}/38-attention-cleared.png`));
step("closing the sheet with Escape returns focus to the bell");
await page.evaluate(`document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`);
await eventually(async () => !(await page.evaluate(`!!document.querySelector(".attention-sheet")`)), {
what: "Escape to close the attention sheet",
});
if ((await page.evaluate(`document.activeElement?.id ?? ""`)) !== "attentionBell") {
throw new Error("Escape did not return focus to the bell");
}
} else {
console.log(" -- the sheet was already emptied by the dismissals; asserting the empty state");
step("opening an empty Needs you sheet");
await page.click("#attentionBell");
await page.waitForSelector(".attention-sheet", { timeout: 15000 });
const empty = await page.evaluate(`(() => ({
title: document.querySelector(".attention-sheet-title")?.textContent ?? "",
empty: document.querySelector(".attention-empty")?.textContent ?? "",
rows: document.querySelectorAll(".attention-sheet .attention-row").length,
clear: !!document.querySelector(".attention-clear"),
focused: document.activeElement?.className ?? "",
}))()`);
if (empty.title !== "Needs you") throw new Error(`the sheet title is wrong: ${empty.title}`);
if (empty.empty !== "Nothing needs you right now.") throw new Error(`the empty copy is wrong: ${empty.empty}`);
if (empty.rows !== 0 || empty.clear) throw new Error(`an empty sheet drew rows or Clear all: ${JSON.stringify(empty)}`);
if (!empty.focused.includes("attention-sheet-close")) throw new Error("focus did not move into the empty sheet");
await page.evaluate(`document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`);
await eventually(async () => !(await page.evaluate(`!!document.querySelector(".attention-sheet")`)), {
what: "Escape to close the empty attention sheet",
});
console.log(" empty sheet: Nothing needs you right now.; no rows, no Clear all");
}
await eventually(
async () =>
(await page.evaluate(`document.querySelector(".attention-empty")?.textContent ?? ""`)) ===
"Nothing needs you right now.",
{ what: "the empty attention state after Clear all" },
);
const cleared = await page.evaluate(`(() => ({
empty: document.querySelector(".attention-empty")?.textContent ?? "",
rows: document.querySelectorAll(".attention-sheet .attention-row").length,
clearAll: !!document.querySelector(".attention-clear"),
badge: !!document.querySelector("#attentionBell .attention-badge"),
label: document.querySelector("#attentionBell").getAttribute("aria-label"),
badges: document.querySelectorAll(".attention-badge").length,
}))()`);
if (cleared.empty !== "Nothing needs you right now.") {
throw new Error(`the empty copy is wrong: ${cleared.empty}`);
}
if (cleared.rows !== 0) throw new Error(`the cleared sheet still shows ${cleared.rows} rows`);
if (cleared.clearAll) throw new Error("Clear all is still offered on the empty sheet");
if (cleared.badge || cleared.badges !== 0) throw new Error("the badge is still visible after Clear all");
if (cleared.label !== "Notifications") {
throw new Error(`the emptied bell is named wrong: ${cleared.label}`);
}
console.log(` after Clear all: "${cleared.empty}", no Clear all, bell aria-label="${cleared.label}"`);
shots.push(await page.screenshot(`${out}/38-attention-cleared.png`));
step("closing the sheet with Escape returns focus to the bell");
await page.evaluate(
`document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`,
);
await eventually(
async () => !(await page.evaluate(`!!document.querySelector(".attention-sheet")`)),
{ what: "Escape to close the attention sheet" },
);
const focusAfterEscape = await page.evaluate(`document.activeElement?.id ?? ""`);
if (focusAfterEscape !== "attentionBell") {
throw new Error(`Escape did not return focus to the bell: ${focusAfterEscape}`);
}
console.log(" Escape closed the sheet and focus returned to #attentionBell");
step("capturing the zero-state bell at 1440x900 and 420x900");
// A Failed row opened a run detail; Back to list makes the Runs heading the
// visible evidence (its control is hidden on the wide layout but is the same
// handler showList uses, and the narrow capture needs the list pane active).
await returnToRunsList();
await page.evaluate(`document.activeElement?.blur?.()`);
await settle(150);
@@ -2889,10 +2797,7 @@ try {
assertAttentionBellGlyph(zeroProbe, 0, "wide bell at zero");
assertSameAttentionGlyph(zeroProbe, countProbe, "wide bell at zero");
shots.push(await page.screenshot(`${out}/38a-attention-bell-zero-1440x900.png`));
console.log(
` zero: no badge, aria-label="${zeroProbe.label}", blank text, ` +
`${zeroProbe.pathCount} unchanged paths at ${zeroProbe.width}×${zeroProbe.height}`,
);
console.log(` zero: no badge, aria-label="${zeroProbe.label}", ${zeroProbe.pathCount} unchanged paths`);
await page.resize(420, 900);
await eventually(() => page.evaluate(`matchMedia("(min-width: 600px)").matches === false`), {
@@ -2903,27 +2808,13 @@ try {
assertAttentionBellGlyph(zeroNarrowProbe, 0, "narrow bell at zero");
assertSameAttentionGlyph(zeroNarrowProbe, countProbe, "narrow bell at zero");
shots.push(await page.screenshot(`${out}/38b-attention-bell-zero-420x900.png`));
console.log(
` zero narrow: no badge, aria-label="${zeroNarrowProbe.label}", ` +
`${zeroNarrowProbe.width}×${zeroNarrowProbe.height} glyph`,
);
console.log(` zero narrow: no badge, aria-label="${zeroNarrowProbe.label}"`);
await page.resize(1440, 900);
await eventually(() => page.evaluate(`matchMedia("(min-width: 600px)").matches === true`), {
what: "the wide layout back at 1440px",
});
await settle(200);
step("closing the sheet with a backdrop click");
await page.click("#attentionBell");
await page.waitForSelector(".attention-sheet", { timeout: 15000 });
await page.evaluate(`document.querySelector(".attention-sheet").click()`);
await eventually(
async () => !(await page.evaluate(`!!document.querySelector(".attention-sheet")`)),
{ what: "the backdrop click to close the attention sheet" },
);
console.log(" backdrop click closed the sheet");
step(`scrolling the list to the older day group (${fullDateHeader})`);
const scrolledTo = await page.evaluate(`(() => {
const scroll = document.querySelector(".run-scroll");