From 526c19fc21af796fd37092010b3dd884fe2c2ab8 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Tue, 20 Oct 2026 03:11:37 +0100 Subject: [PATCH] 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. --- examples/README.md | 45 +- examples/catalog.go | 4 +- examples/catalog_test.go | 10 +- examples/debug.md | 117 ++++++ examples/docs-fold.md | 71 ---- examples/research.md | 26 +- examples/review.md | 23 +- examples/task.md | 51 +-- examples/three-stage.md | 102 +---- internal/author/install.go | 2 +- internal/author/skill/SKILL.md | 79 ++-- internal/author/skill/references/access.md | 55 +++ .../author/skill/references/orchestration.md | 30 +- internal/author/skill_reference_test.go | 2 +- internal/opencode/chat.go | 139 +++++++ internal/opencode/chat_test.go | 38 ++ internal/pipeline/operator_sessions.go | 32 +- .../pipeline/operator_sessions_star_test.go | 53 +++ internal/pipeline/store.go | 24 +- internal/protocol/chat.go | 68 ++- internal/protocol/message.go | 7 + internal/server/chat.go | 14 + internal/server/chat_answer.go | 48 +++ internal/server/chat_close.go | 4 + internal/server/chat_hub.go | 19 + internal/server/chat_room.go | 17 +- internal/server/chat_sessions.go | 2 + internal/server/chat_star.go | 59 +++ internal/server/chat_stream.go | 10 + web/AGENTS.md | 9 +- web/PARITY.md | 11 + web/chat.css | 52 +++ web/lists.css | 26 +- web/serve.mjs | 11 +- web/shell.css | 31 +- web/src/app.js | 70 +++- web/src/attention.js | 18 +- web/src/chat.js | 31 ++ web/src/protocol.js | 3 + web/src/repository.js | 24 ++ web/src/views/attention.js | 7 +- web/src/views/chat.js | 211 +++++++++- web/src/views/pipelines.js | 75 +++- web/test/attention.test.mjs | 22 + web/test/chat.test.mjs | 19 + web/test/ui-smoke.mjs | 387 +++++++----------- 46 files changed, 1547 insertions(+), 611 deletions(-) create mode 100644 examples/debug.md delete mode 100644 examples/docs-fold.md create mode 100644 internal/author/skill/references/access.md create mode 100644 internal/pipeline/operator_sessions_star_test.go create mode 100644 internal/server/chat_answer.go create mode 100644 internal/server/chat_star.go diff --git a/examples/README.md b/examples/README.md index cd95fd6b..f424ae1d 100644 --- a/examples/README.md +++ b/examples/README.md @@ -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/.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; diff --git a/examples/catalog.go b/examples/catalog.go index 150c9f97..044440bd 100644 --- a/examples/catalog.go +++ b/examples/catalog.go @@ -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 { diff --git a/examples/catalog_test.go b/examples/catalog_test.go index fb6acb26..4bbdc506 100644 --- a/examples/catalog_test.go +++ b/examples/catalog_test.go @@ -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] diff --git a/examples/debug.md b/examples/debug.md new file mode 100644 index 00000000..7097146e --- /dev/null +++ b/examples/debug.md @@ -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 +``` diff --git a/examples/docs-fold.md b/examples/docs-fold.md deleted file mode 100644 index f38bdfb4..00000000 --- a/examples/docs-fold.md +++ /dev/null @@ -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 -``` diff --git a/examples/research.md b/examples/research.md index 57ed3483..5616ce68 100644 --- a/examples/research.md +++ b/examples/research.md @@ -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 diff --git a/examples/review.md b/examples/review.md index ffa73d03..8b6681f7 100644 --- a/examples/review.md +++ b/examples/review.md @@ -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 diff --git a/examples/task.md b/examples/task.md index b663c907..ae2b8c78 100644 --- a/examples/task.md +++ b/examples/task.md @@ -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/.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 diff --git a/examples/three-stage.md b/examples/three-stage.md index ecbe2898..55cc303b 100644 --- a/examples/three-stage.md +++ b/examples/three-stage.md @@ -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/.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 diff --git a/internal/author/install.go b/internal/author/install.go index 1b3aa42c..f1d8ef91 100644 --- a/internal/author/install.go +++ b/internal/author/install.go @@ -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") diff --git a/internal/author/skill/SKILL.md b/internal/author/skill/SKILL.md index e8f61744..640e4c64 100644 --- a/internal/author/skill/SKILL.md +++ b/internal/author/skill/SKILL.md @@ -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 ""`, and inspect it with +`pipelines inspect `. `pipelines wait ` blocks until it finishes. -## Definitions +A failed run keeps its worktree and commits. Read `pipelines inspect --json` +before deciding: resume the failed stage (`pipelines retry `), 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 ` 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 ` 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. diff --git a/internal/author/skill/references/access.md b/internal/author/skill/references/access.md new file mode 100644 index 00000000..7197e2d9 --- /dev/null +++ b/internal/author/skill/references/access.md @@ -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://..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. diff --git a/internal/author/skill/references/orchestration.md b/internal/author/skill/references/orchestration.md index ffd8835f..26a9c01d 100644 --- a/internal/author/skill/references/orchestration.md +++ b/internal/author/skill/references/orchestration.md @@ -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 diff --git a/internal/author/skill_reference_test.go b/internal/author/skill_reference_test.go index 94eff84b..2cb34562 100644 --- a/internal/author/skill_reference_test.go +++ b/internal/author/skill_reference_test.go @@ -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) } diff --git a/internal/opencode/chat.go b/internal/opencode/chat.go index 0f38d5df..63f3ade2 100644 --- a/internal/opencode/chat.go +++ b/internal/opencode/chat.go @@ -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 diff --git a/internal/opencode/chat_test.go b/internal/opencode/chat_test.go index c9acff88..09ab0284 100644 --- a/internal/opencode/chat_test.go +++ b/internal/opencode/chat_test.go @@ -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) + } +} diff --git a/internal/pipeline/operator_sessions.go b/internal/pipeline/operator_sessions.go index fedb4736..982ff9a6 100644 --- a/internal/pipeline/operator_sessions.go +++ b/internal/pipeline/operator_sessions.go @@ -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) diff --git a/internal/pipeline/operator_sessions_star_test.go b/internal/pipeline/operator_sessions_star_test.go new file mode 100644 index 00000000..b79ce14f --- /dev/null +++ b/internal/pipeline/operator_sessions_star_test.go @@ -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) + } +} diff --git a/internal/pipeline/store.go b/internal/pipeline/store.go index 46466d51..c2c8f4f4 100644 --- a/internal/pipeline/store.go +++ b/internal/pipeline/store.go @@ -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() diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index cd6b87da..cc1974af 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -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"` diff --git a/internal/protocol/message.go b/internal/protocol/message.go index bce8e613..f759933d 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -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 diff --git a/internal/server/chat.go b/internal/server/chat.go index 8ae8bd3f..d987c806 100644 --- a/internal/server/chat.go +++ b/internal/server/chat.go @@ -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 diff --git a/internal/server/chat_answer.go b/internal/server/chat_answer.go new file mode 100644 index 00000000..afb45cbc --- /dev/null +++ b/internal/server/chat_answer.go @@ -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}) +} diff --git a/internal/server/chat_close.go b/internal/server/chat_close.go index 822615bb..036e8a63 100644 --- a/internal/server/chat_close.go +++ b/internal/server/chat_close.go @@ -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 } diff --git a/internal/server/chat_hub.go b/internal/server/chat_hub.go index f761decc..40ced392 100644 --- a/internal/server/chat_hub.go +++ b/internal/server/chat_hub.go @@ -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 diff --git a/internal/server/chat_room.go b/internal/server/chat_room.go index 0fbb54d6..e21d1366 100644 --- a/internal/server/chat_room.go +++ b/internal/server/chat_room.go @@ -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() diff --git a/internal/server/chat_sessions.go b/internal/server/chat_sessions.go index 5b22851f..2e8e61e3 100644 --- a/internal/server/chat_sessions.go +++ b/internal/server/chat_sessions.go @@ -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) diff --git a/internal/server/chat_star.go b/internal/server/chat_star.go new file mode 100644 index 00000000..79e742ab --- /dev/null +++ b/internal/server/chat_star.go @@ -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}, + }) +} diff --git a/internal/server/chat_stream.go b/internal/server/chat_stream.go index 91370f56..415df982 100644 --- a/internal/server/chat_stream.go +++ b/internal/server/chat_stream.go @@ -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 diff --git a/web/AGENTS.md b/web/AGENTS.md index 9c5e1a4f..21d48b78 100644 --- a/web/AGENTS.md +++ b/web/AGENTS.md @@ -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 diff --git a/web/PARITY.md b/web/PARITY.md index c7d5347e..2068dcee 100644 --- a/web/PARITY.md +++ b/web/PARITY.md @@ -157,6 +157,17 @@ to it, but the server never lists it and a reload drops it. | L6 | Deep links to a run (`pipelines://run/…` analogue → URL route) | — | done — the page's destinations are real URLs through a pure, total route model in `src/routes.js`: `/pipelines`, `/runs`, `/chat`, `/settings` and `/templates`; `/pipelines/:id` and `/pipelines/:id/:version` (version 0 or absent = latest); `/pipelines/:id[/:version]/stage/:key`; `/runs/:id` with `?action=decide`; `/runs/:id/stage/:key[?visit=N]`; `/settings/templates` and `/settings/templates/:key` parse as aliases of `/templates` and `/templates/:key`. `visit` is a zero-based index into that stage's visits, dropped when invalid while the stage route stays; a malformed or unknown path (a bad percent escape, a zero/negative run id, a non-numeric version or path, or a trailing extra segment on either stage branch, e.g. `/runs/440/stage/planner/extra`) resolves to the Pipelines list and never throws, and search/query state is never a route. The serialiser percent-encodes path segments, omits version 0 and an absent visit, and round-trips under `parse(serialize(…))`; an id, version or key the parser would reject is never emitted — it falls back to the nearest canonical route (an invalid id to the list, an invalid version to latest) so the address bar can never carry a path the parser would discard. `serve.mjs` serves `index.html` for any page route (a first segment naming a destination, so a stage key that ends in an extension — `plan.js`, `plan.v2` — still deep-links) or any non-asset GET, with a root `` so the shell's relative asset URLs resolve under a deep path, while an asset-looking path outside a page prefix such as `/nope.js` stays 404. Navigation moves the URL with `pushState` only on a real change (top-level tabs, pipeline/run/template selection, Settings' Browse templates, opening/closing either stage pane; a user click on a pipeline graph node pushes `/pipelines/:id/:version/stage/:key` through the shared graph's `onSelectionChange` (a synthetic click is never used); a deep-linked stage instead opens at mount through the graph's `selectedKey` option without notifying), and one `popstate` listener parses and applies Back/Forward without a reload; in-detail tabs (Summary/Graph/Source, run tabs) and search stay in-place. A deep link is parsed at boot, kept pending until the first successful connection, and then loaded list-first (later reconnects never replay it; any move made while still disconnected replaces the pending boot link, so the URL and the first connected view agree). An unknown or malformed boot path renders the Pipelines list and `replaceState`s the address bar to the canonical `/pipelines` so the URL and the view agree. A later reconnect refreshes the lists and re-applies the route: the URL and a detail already in hand survive the drop, while a detail that is not in hand (never loaded, or cleared while disconnected) is fetched again. Only a genuine server refusal — never a timeout or a socket drop — discards the deep link. A run link's `?action=decide` opens the existing decision sheet once, only when the run is genuinely waiting, then `replaceState`s to the action-free `/runs/:id`. A valid but out-of-range `?visit=N` is clamped to the stage's last visit and the entry is corrected, so the address bar and the pane agree; a pipeline-stage path naming a key the loaded graph does not declare falls back to `/pipelines/:id[/:version]` rather than leaving a pane-less stage URL, while a key the mounted graph can select — including its `#success`/`#failure` terminals — re-opens the same definition pane (the graph writes those URLs itself, so the loader accepts them). A run-stage path naming a stage that is neither visited nor a node of the run graph falls back to the plain run detail. A deep link to an executing run installs its 1 Hz refresh; leaving Runs for any other destination stops it, and a reply discarded for a view that no longer shows Runs stops it too, so no get_run loop survives the move (asserted in the smoke when an executing run is live). A deep-linked stage pane is revealed clear of the sticky top bar (its head and the Close control stay visible), which the smoke asserts. A run the server does not have falls back honestly to `/runs` — the real list, the server's own refusal in the banner and no stale pane or throw (the same for a missing pipeline → `/pipelines`). A run or run-stage route also loads the pipeline list when it has not been seen, so the nav badge stays honest (`Pipelines (29)` at capture time, never a false `Pipelines (0)`) — asserted in the smoke. Captured 2026-10-19: `captures/L6-deeplink-run-440.png` (a hard navigation to `/runs/440` opening run 440's detail), `captures/L6-deeplink-pipeline-24.png` (a hard navigation to `/pipelines/24` opening `Plan and land`), `captures/L6-deeplink-pipeline-24-stage.png` (a hard navigation to `/pipelines/24/stage/planner` opening the Graph tab and the stage's definition pane in view), `captures/L6-deeplink-pipeline-24-terminal.png` (a hard navigation to `/pipelines/24/stage/%23failure` re-opening the Failure terminal pane — the live graph's first terminal at capture time — with its URL unchanged), `captures/L6-history-back.png` (an in-page Pipelines→Runs→run-detail sequence, then `history.back()` restoring the Runs list, with a window marker proving no reload), `captures/L6-missing-run.png` (`/runs/900000000` landing on `/runs` with the real list — 407 rows at capture time — and the banner `run not found`) and `captures/L6-missing-pipeline.png` (`/pipelines/900000000` landing on `/pipelines` with the real pipeline rows and the server's refusal banner). Parsing, serialisation, version/visit semantics and round-tripping are unit-tested in `test/routes.test.mjs`. **The live server had no waiting run, so the `?action=decide` path was not exercised live**; `test/ui-smoke.mjs` captures the sheet automatically the moment a waiting run exists | | L7 | Accessibility: focus order, labels, keyboard operation | — | done — every must-fix finding in `web/docs/a11y-audit.md` is addressed. **M1/M2 are this change:** one shared DOM-only controller (`web/src/modal.js`) now owns every listed `role="dialog"` surface (attention sheet, stage pane, changes viewer, artifact viewer, decision sheet, cancel/retry/restart confirm, Action-failed, chat Rename/Close, template create): it records the opener, re-parents the panel into `#modalLayer` outside `.app-root`, focuses the first control (or the panel with `tabindex=-1`), traps Tab/Shift+Tab, sets native `inert` on `.app-root` (exact-prior restoration; the no-inert fallback uses `aria-hidden` plus saved `tabindex` and a `focusin` guard), routes Escape/backdrop/the close control through the same view callback, and restores focus to the re-resolved trigger or a sensible heading. Same-id re-renders replace the panel without recapturing the trigger, a second overlay inerts the first and gives it back on close, and the one document keydown/focusin listener is removed when the stack empties. **M3/M4/M8** were built into the shell (tablist/tab/tabpanel with roving `tabindex` and arrow keys, the `Skip to detail` link plus list→detail focus handoff, and one `h1` per route with list `h2`s). **M5/M6/M7/M9** previously landed (named keyboard artifact tiles; sibling Chat actions with unique names; named attention Dismiss controls; timeline focus ring). No markup copy, roles or CSS was changed by this item. Focused proof: `node --test test/modal.test.mjs` (focusable discovery, both wrap directions, empty-panel fallback, idempotent open/listener cleanup, stack inertness, exact inert/aria-hidden/tabindex restore) and `node test/modal-probe.mjs --out ../captures` passed against the live server for the attention sheet, run 440 Retry confirm, run 438 changes viewer and the artifact-viewer-over-stage-pane stack, with `captures/86-modal-focus-attention.png` as the keyboard-opened focus-visible capture. `node --test test/` is green (603 tests). The **S1–S12** should-fix items remain notes and are not claimed fixed here; the full `ui-smoke` run reached the unchanged live-chat markdown-table assertion, which the current operator session does not satisfy (no table anywhere in its history), so it is recorded as an environmental live-data limitation rather than a modal regression. | +## Beyond parity (browser-only) + +| # | Feature | Protocol | Status | +| --- | --- | --- | --- | +| B1 | Shared chat stars | `chat_star` | done — the star is stored in the server's operator-session registry (`starred_at`), not in a browser's `localStorage`, so every browser and device lists the same `Starred` group. The request is `{type:"chat_star",chat_query:{session_id,starred}}`; the reply echoes the updated session. A one-time migration uploads the old local star set, then the server wins. Verified with a real browser against a scratch server: starring a session created the group, a second page with no local star storage showed the same group, and the unit suite covers the registry round-trip. | +| B2 | Pipeline list mini graph | `list_pipelines` (`shape`) | done — each summary now carries the current version's parsed graph as `shape`; the browser draws a label-free miniature from the real `layoutGraph` with terminal-free stage routes. The row shows the name, the shape and only `{N stages}`; the cryptic `id {n} · v{n} · …` line is gone. Verified at 390×844 against the live server: 9 rows, 9 miniatures, and the detail still owns the full Graph tab. Additive field; older clients ignore it. | +| B3 | Equal phone dock cells | — | done — the narrow dock is a four-cell grid (one cell per destination plus Search) with a subgrid for the tablist, so every control has the same width and height. At 390×844 the measured widths are 92/92/92/92 and the row is 48px high. The phone shell uses `100svh` so a browser toolbar cannot hide the tab row while leaving only the Connected/Settings status row visible. | +| B4 | Full-height pipeline Source | — | done — the Source block no longer caps itself at `60vh`; it is as tall as its content and the detail pane owns the scroll. Verified at 390×844: a 4386px definition sits in the full pane (656px viewport) and scrolls. | +| B6 | Agent questions are answerable in the browser | `chat_event` (`form`), `chat_answer` | done — OpenCode's question tool pauses inside a `form.created` event; the broker now maps `form.created` / `form.replied` / `form.cancelled` to a `form` chat_event, the browser renders a question card with the form's options and free-text fields, and `chat_answer` posts the field-keyed answer to `/api/session/{id}/form/{id}/reply`. A question for a backgrounded chat also raises the existing browser notification. Verified end to end with a real model turn: the card appeared with a `Demo colour` field, selecting Red and pressing `Send answer` cleared it and the same turn completed with "You chose Red for the demo."; the OpenCode form normalizer is unit-tested. | +| B5 | Sign-in reaches the app, and stays signed in | — | done — a successful `POST /login` redirects to the requested path; a fresh browser with no saved endpoint now connects to its own origin instead of stopping on Settings/"Not configured". The session cookie is `SameSite=Lax` (a Strict cookie was withheld when the installed app or another app opened the page) and carries both `Max-Age` and `Expires` for Remember me. Verified in headless Chrome: login with `next=/pipelines` reached the connected list, and a closed/reopened page stayed signed in with no local endpoint. **iOS Safari/PWA itself was not directly exercised**, so the toolbar/cookie fixes are targeted at that report rather than claimed as device-verified. | + ## Deliberately out of scope - **Operator-only transport** — `inspect_resource`, `reconcile_resource`, `inspect_resource_pool`, `configure_resource_pool` are loopback-only and must diff --git a/web/chat.css b/web/chat.css index bdced4e2..e5cea4fe 100644 --- a/web/chat.css +++ b/web/chat.css @@ -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; } diff --git a/web/lists.css b/web/lists.css index 3cbd08ce..cdd898b2 100644 --- a/web/lists.css +++ b/web/lists.css @@ -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; } +} diff --git a/web/serve.mjs b/web/serve.mjs index a53c70cb..b650a92d 100644 --- a/web/serve.mjs +++ b/web/serve.mjs @@ -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(); diff --git a/web/shell.css b/web/shell.css index 5b7a4503..91eba848 100644 --- a/web/shell.css +++ b/web/shell.css @@ -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; } } diff --git a/web/src/app.js b/web/src/app.js index 3481cf1c..5083efa6 100644 --- a/web/src/app.js +++ b/web/src/app.js @@ -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 }); \ No newline at end of file +// 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 }); + } +} \ No newline at end of file diff --git a/web/src/attention.js b/web/src/attention.js index 6a786c15..3a075c7e 100644 --- a/web/src/attention.js +++ b/web/src/attention.js @@ -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 diff --git a/web/src/chat.js b/web/src/chat.js index 34dc4389..a22499ef 100644 --- a/web/src/chat.js +++ b/web/src/chat.js @@ -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: diff --git a/web/src/protocol.js b/web/src/protocol.js index c18a286c..d1842bac 100644 --- a/web/src/protocol.js +++ b/web/src/protocol.js @@ -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 diff --git a/web/src/repository.js b/web/src/repository.js index 914bd32e..6f150aea 100644 --- a/web/src/repository.js +++ b/web/src/repository.js @@ -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({ diff --git a/web/src/views/attention.js b/web/src/views/attention.js index 8f0c7aa3..9560f822 100644 --- a/web/src/views/attention.js +++ b/web/src/views/attention.js @@ -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(); } diff --git a/web/src/views/chat.js b/web/src/views/chat.js index 046cd1a8..10bf9c77 100644 --- a/web/src/views/chat.js +++ b/web/src/views/chat.js @@ -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 diff --git a/web/src/views/pipelines.js b/web/src/views/pipelines.js index cc4f9651..ca2eaad2 100644 --- a/web/src/views/pipelines.js +++ b/web/src/views/pipelines.js @@ -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) { diff --git a/web/test/attention.test.mjs b/web/test/attention.test.mjs index cb7a7e9d..21b0127f 100644 --- a/web/test/attention.test.mjs +++ b/web/test/attention.test.mjs @@ -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"); diff --git a/web/test/chat.test.mjs b/web/test/chat.test.mjs index 47608931..f967568e 100644 --- a/web/test/chat.test.mjs +++ b/web/test/chat.test.mjs @@ -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); +}); diff --git a/web/test/ui-smoke.mjs b/web/test/ui-smoke.mjs index d6187325..cc11bc41 100644 --- a/web/test/ui-smoke.mjs +++ b/web/test/ui-smoke.mjs @@ -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");