Skip to content

feat(autonudge): pause, trigger, stop and save icon controls in the goal popover - #11478

Closed
pepmach wants to merge 1 commit into
mainfrom
feat/autonudge-controls
Closed

pepmach wants to merge 1 commit into
mainfrom
feat/autonudge-controls

Conversation

@pepmach

@pepmach pepmach commented Sep 17, 2026 •

Copy link
Copy Markdown
Contributor

Problem / Motivation

Goal: While a goal loop is running, its popover offers two text buttons, Stop loop and Save.

While a goal loop is running, its popover offers two text buttons, Stop loop and Save. There is no way to pause the loop and pick it up later: the only way to halt it is Stop, which removes the goal for good, and the one-off Trigger nudge sits alone as a text button on the schedule line. A stopped loop and a paused loop also look the same, so a reader cannot tell which one is safe to bring back.

Why it matters

An operator who wants a running loop to hold for a while (a meeting, a manual check, a busy host) has to throw the goal away and retype it later. When a loop stops on a spent cap, the way back is a text button that restarts it on the next interval rather than now, and editing the goal before restarting means a separate save first.

Not a goal

  • The bridge's popover key: SessionAutomationPopover.tsx keys the popover on legacyLoop?.id, so when a press creates a loop and the fire is then refused, the hand-off of the created record remounts the popover and the inline refusal does not survive in the bridge context; that is a separate change.
  • A transaction across a control's save and fire: a refused write fires nothing, and a write landing before a refused fire (409) stays, with the refusal inline.
  • An overflow menu for the loop's controls: rejected by the product owner because every control must stay visible, so max-two-buttons-per-row is knowingly exceeded on a running loop.

What changed (motivation → approach → change)

The controls by loop state (product owner, 2026-09-30: "Move trigger back to schedule line. Keep Pause and Save. Stop appears after hitting pause."):

Loop state Schedule line Action rows
running last fire · countdown — at its cap Next cycle in … stops the loop. Cycle cap reached: raise Max cycles. — then ⚡ Nudge now (Save edits and nudge now once edited) [⏸] [💾] — Pause loop, Save (Save without nudging once edited)
paused by hand (stopped_reason: manual) Paused [■] …… [▶] — Stop loop, Resume loop and nudge now (Save edits, resume loop and nudge now once edited); no Save: Play saves edits, resumes, fires
stopped by a bound or a tool Stopped · the bound (Cycle cap reached — raise Max cycles / Runtime budget spent — max_runtime_secs is set when the loop is armed (monitor_start); raise it with monitor_update), help line Start loop resumes this goal. Clear stopped goal removes it for good. (only its Clear sentence while a bound holds Play) [■] …… [▶] — Clear stopped goal, Start loop and nudge now (Save edits, start loop and nudge now once edited)
no loop — [▶] — Start loop: creates and starts it, no nudge

Every control is icon-only — its name as aria-label and hover title, no visible text (product owner, 2026-09-30 23:22Z: the dashboard's toolbars are icon buttons with hover text; the italics above are the titles); the close X gains a title too. Text stays on the confirm's two buttons; no row exceeds two controls. Stop is two steps from a running loop — Pause, then Stop, which asks first (Remove this goal for good?, Cancel / Clear) on paused and stopped records alike — no single press erases a goal. With writes disabled (crew/member session) a running loop's row holds a lone confirm-gated Stop, sending intent=stop or intent=clear.

A control that fires saves the form first only when you edited it, and writes only the fields you edited (editedFields, against what the form showed on open or the server last stored — the service clamps interval and cap), so an edit cannot write a stale cap over a raised one. Pristine, Nudge now only fires and Play (paused or stopped) sends {active: true} then POST …/fire; edited, the PATCH carries them. Save (running row only) PATCHes the edits, never active. Each leg reports only its own result: the write hands the server's record up as it lands, applied only while the parent's record has not moved since the press (no revision exists, so a moved record — a frame landed — drops the response and re-reads the slot, as bounded-monitor writes do); the fire hands up no record — the bridge arms the deadline on the record the parent holds now, measured against the pressed record, never the route's answer (armedNow; nothing for another loop, a paused one, or one fired since).

Play with no loop creates and starts it; the first nudge goes out at the interval or on Nudge now (product owner, 00:35Z).

Play is disabled while a bound is spent, read off the record (loop.max_cycles > 0 && cycle_count >= max_cycles, or the runtime_budget reason); the unsaved cap never spends a bound and, for Play alone, lifts one (written first). Pause is held only by the budget reason: at its cap a running loop keeps a live Pause, the route to Stop. A pause reaching a bound-stopped loop keeps the bound (autonudge_service/mutations.py: deactivating an inactive loop is no new stop).

The {{STOP_FILE}} help line (#11162) stays as on main except its Stop-button tail, cut (product owner, 00:35Z: a running loop no longer shows that button); likewise the blank-sentinel variant. The bridge passes stoppedReason through; the autonudge_state frame carries stopped_reason and next_due_ts (slack/gateway.py).

Catalogs (en.manual.json, eleven translations, en-XA): pause_loop, resume_loop, loop_paused, nudge_now, start_loop_and_nudge, bound_cycle_cap, bound_runtime_budget, capped_tick_in, capped_tick, stopped_help_bound, save_without_nudging, save_edits_and_resume, save_edits_and_start added; trigger_nudge, clear_goal_for_good (now Clear), bn's stop_loop reworded; start_loop as on main; stop_file_help and stop_file_help_none lose their Stop-button sentences everywhere (fr/ru per their gates); no key main ships removed; bn in তুমি, hi in तुम.

Backwards compatibility

Compatible: the PATCH body shrinks to the edited fields, and the service applies only the keys present (an absent field is unchanged; it already drops a re-submitted identical message); a reasonless active: false on a loop a bound already stopped now keeps that bound's reason instead of recording manual (the returned record says so; a pause of a running loop still records manual, and active: true still clears any bound); the websocket frame gains two fields already public on the REST list; the catalogs only gain keys, reword two labels this popover alone reads, and shorten one help sentence.

Tests

website/src/test/AutoNudgePopover.test.tsx, red first:

  • Every row assertion checks each control is icon-only: aria-label equal to its title, no text, a glyph; the confirm's Cancel / Clear are the one text row.
  • Running: the row holds exactly Pause loop, Save, Save accented — reading Save without nudging once a field differs, on the same reading as the Nudge-now label, and Save again when the edit is typed back; no Stop of either reading anywhere; the schedule line's one button is Nudge now, which reads Nudge now on a pristine form and Save edits and nudge now once a field differs (typing the edit back, or 090 for a seeded 90, restores Nudge now); disabled on an empty goal and once a cycle is due.
  • Nudge now on an edited form saves it first — PATCH {message}, no active, no untouched field — then posts the fire route with no body; the saved record goes up at the write and the fire is reported separately, with the route's response and no record; the popover stays open; a 409 on the fire shows inline with the save standing; a pristine press writes nothing and fires; a second press after a saved edit writes nothing again. Red first (Opus :596): an interval typed as 1 goes out as {idle_secs: 1} and the record comes back holding the clamped 15 — the field then reads 15, the Nudge-now name is back to Nudge now, Save reads Save, and a second press writes nothing and only fires.
  • Save, Nudge now and Play write only the edited field: with the record's cap raised by another writer while the popover sat open, an edit to the goal PATCHes {message} alone.
  • Pause sends exactly {active:false}, fires nothing, keeps the popover open, hands the paused record up; a refused pause shows inline.
  • Paused: Stop loop, Resume loop and nudge now — Stop danger-coloured left of the accented Play, no Pause, no Nudge now, status Paused, no help line and no question until the confirm; an edit adds nothing — the row stays Stop + Play, no Save of any reading on an inactive loop, Play live and accented. Red first (UX): Play's name flips with the form — Save edits, resume loop and nudge now on the edited paused record, Save edits, start loop and nudge now on the edited stopped one, the pristine name back when the edit is typed back; the edited-form Play test reaches the control by the dirty name.
  • Play on a pristine paused loop sends PATCH {active:true} alone, then the fire; the resumed record goes up at the write and the fire is reported after it, with no record; with goal, interval and cap edited, the three ride the PATCH with active:true; a 409 on the fire leaves the loop resumed with the refusal shown; a refused resume sends no fire.
  • Stopped by cycle_cap, runtime_budget, approval_stalled, autonudge_stop, an empty reason or no reason field: reads Stopped, the help line under it, row Clear stopped goal, Start loop and nudge now (Play accented), Stop opens the Cancel / Clear confirm with the question in the help line's place, Cancel restores row and help line, an edit adds no Save.
  • Bounds: a loop stopped on its cap keeps Play disabled until the cap in the form clears it (above the count or 0); the cap is the record's — max_cycles: 0, cycle_count: 5, 3 typed leaves Pause live and its press sends {active:false}; a cap raised since the stop names no bound; runtime_budget names its bound whatever the form holds — red first (UX): that line reads Runtime budget spent — max_runtime_secs is set when the loop is armed (monitor_start); raise it with monitor_update, naming the field, where it is set and what raises it, since no field here does. Red first (UX): the stopped-on-cap help keeps only Clear stopped goal removes it for good. while Play is held and regains its resume sentence the moment a typed cap lifts it; the budget-stopped help keeps only the Clear sentence; stops without a bound keep the full help. Red first (Opus :1210, then UX): a RUNNING loop at its cap (cycle_count: 3, max_cycles: 3) keeps Pause live, the schedule line reads Next cycle in … stops the loop. Cycle cap reached: raise Max cycles. — two sentences, not one run together — with no bound span and exactly one Next cycle in (a typed cap moves neither; The next cycle stops the loop. Cycle cap reached: raise Max cycles. once due), the press sends {active:false} and hands up the paused-at-cap record; a running loop under its cap or uncapped shows no bound; Pause stays disabled on the budget reason; a Pause the server answers with the bound hands that record up.
  • No loop: one accented Start loop; the press POSTs the form, fires NOTHING (every fire route asserted absent), hands the created record up once and stays open; a refused create hands nothing up and shows the refusal inline.
  • Stop: none on a running loop's row; on a paused loop it asks first, Cancel restores the pair and the question leaves, only the confirmed press sends intent=stop; the stopped record's confirmed press sends intent=clear. With writes disabled a running loop's row is Stop alone, its confirm sends intent=stop, Pause and Save are not drawn, Nudge now and Play are disabled.
  • The {{STOP_FILE}} help line: main's own six tests (Goal textarea shows the raw {{STOP_FILE}} token to the reader #10458), restored verbatim — explained under the template with the token interpolated and aria-describedby wired, absent without the token, the empty-sentinel arm, the path never rendered.

website/src/test/SessionAutomationPopover.test.tsx: crew/member mode keeps Stop reachable behind its confirm with nothing written. Red first (GPT :685, the same span as :684): a pause another tab lands between the write leg and the fire leg — its inactive frame reaches this tab's store, then the fire answers 409 loop is not active — stands: the parent receives the written record at the write and nothing after it, the trigger stops reading active, the paused row shows and the refusal sits in the notice (before: the written record went up on the refusal and showed the paused loop as running); the same pause landing before an accepted fire's answer arms nothing on the paused record. Red first (GPT :154 of the bridge): a pause another tab lands between this tab's save and its answer — the pause's frame reaches the store, then the PATCH response arrives — never reaches the parent: onChange is not called, the slot's cold read is invalidated, the paused row stands (before: the active response was handed up over the pause); and the two-leg press whose own updated frame lands before the write's response hands the parent exactly one record, the fire's, on the frame's record. Red first (GPT :170 of the bridge): the fire route arms a zero-delay timer and returns the live loop, serialized only after its audit await, so its answer can already carry the delivery — count up, last_fire_ts equal to the fired frame's — and a bridge that measured the parent's record against the answer armed "due" on the delivered record for a whole interval; now the fire leg reports the record the press was made on (the written record when a write preceded it, else the loop as held), the bridge measures against that pre-request baseline, and a post-delivery answer leaves the delivered record untouched (one hand-off, the write's); AutoNudgePopover.test.tsx pins that onFired carries the pressed record and never the answer, for the edited Nudge now and for Play on a paused loop whose answer comes back delivered. The two-leg press reaches the parent twice, each leg with its own result — the saved record on its full countdown, then the deadline armed to now on the record the parent holds; a frame that re-identifies the same loop between the legs is what the fire arms, so the deadline lands on the frame's record; a frame that already carries the DELIVERED fire (count up, last_fire_ts newer) leaves nothing to arm and the trigger keeps reading the delivered cycle. AutoNudgePopover.test.tsx pins the contract from the component's side: the write hands its record up (onChange) before the fire is reported (onFired, with the record the press was made on); a pristine Nudge now hands up no record and reports the fire with what the loop holds; a refused fire or a create reports no fire. The two refusal-mailbox tests are gone with the mailbox: no fire follows a create, so there is no refusal to carry across the create's remount.

test/test_autonudge.py, red first: after a runtime_budget or cycle_cap stop, a reasonless active=False keeps the bound; a pause of a running loop still records manual; active=True still clears. test/test_slack_gateway_coverage.py: the plain-loop frame carries stopped_reason and next_due_ts. docs/system-specs/modules/learn-cron-dashboard.md says both.

website/src/i18n/style/hiStyle.test.ts / bnStyle.test.ts (I18N_BASE_REF=origin/main): the branch's hi values carry no आप form, its bn values no আপনি form.

Manual verification

Frames below are from the built SPA of this head served with the repository's gateway-free API stub (serveDist + stubDashboardApi), driven by Playwright, 10/10 states passing their DOM assertions (row names read off aria-label, Play's dirty name on the edited paused record, every icon control's title equal to its name with no visible text, the Nudge-now name in both readings, the status word, the capped-tick line in its two sentences, the bound beside Stopped — the budget one naming max_runtime_secs, the arming call and monitor_update — Pause live at the cap, the help line in both readings, the question, Play disabled on the spent cap and on the spent budget, the lone confirm-gated Stop of a crew session); the pod refused to boot for this worktree ("FATAL: no python3.12 found (need it to build the venv)"), so no live-gateway run. The "before" frames are the same harness on origin/main's build. This head restructures how a press reports to the parent, against the previous head's model read (a refused fire handed the written record up over a pause another tab had landed): each leg now reports only its own result and no record is built for a fire; the popover's rendering is unchanged, so the frames stand, and every gate and the harness were re-run on it. This head's round closes the write leg the same way, against the model read of the head before it (a same-id guard let a PATCH answered before another tab's pause, delivered after the pause's frame, overwrite the paused record): the bridge applies a written record only while the parent's record has not moved since the press and otherwise drops it and re-reads the slot; one guard function removed, nothing rendered differently, so the frames stand and every gate was re-run. The round after it (this head) changes what the fire leg reports, against the next model read (the fire route's answer is the live loop serialized after its audit await, so it can carry the delivery, and a bridge measuring against it rolled a delivered cycle back to due): the fire leg now reports the record the press was made on and the bridge measures against that pre-request baseline; the route's answer is not consulted. This head is also rebased onto main's tip, which carries #15740 (the default goal names the autonudge_stop tool and is read from the catalog, defaultMsg()); the one conflict was that rename against this PR's additions beside it, resolved by taking main's function and following the rename in the four lines this PR adds that read the default. Every gate was re-run on the rebased tree and the harness passed 10/10; only the no-loop frame changed (main's default goal, and no {{STOP_FILE}} help line since the goal no longer carries the token), so it alone is re-shot below. The head before it changed two strings against the UX read — the capped-tick line re-punctuated into two sentences, the runtime-budget line naming where the budget is set and what raises it — in every locale, with the two frames that show them re-shot below.

Retrospective on the four f9eb25b1dcc6 prints (AutoNudgePopover.tsx :1015/:530, :630, :684, :685). Each was one instance of one class: a press reporting a RECORD -- a snapshot of the loop captured at the press -- which the parent then stored after a frame had already moved the loop on: the refusal mailbox parking the refused create's record, the fire's {…fired, next_due_ts} snapshot (first dropped by the identity guard, then passed by a same-id guard), and the refused fire's written record over another tab's pause. A12's two-report contract removed the class from the fire leg: the fire reports a fact (onFired), and the bridge arms the deadline on the record the parent holds now (armedNow). GPT's next finding (new span, the bridge's :154) showed the write leg still reported a record through a same-id guard, so A13 closes the class at the bridge itself: a record from a press is applied only while the parent's record has not moved since the press -- the record carries no revision, so "moved since the press" is the one ordering the bridge can know -- and otherwise dropped with the slot re-read, the rule the bounded monitor's writes already followed in the same component. After A13 no path hands the parent a record that can be older than the one it holds: the fire reports a fact and the write's record is applied only when nothing has moved.

Local gates on this head, all re-run after the rebase onto main's tip: AutoNudgePopover.test.tsx, SessionAutomationPopover.test.tsx and the src/i18n suite with I18N_BASE_REF=origin/main (931 tests), tsc -p tsconfig.app.json, eslint on the six .ts/.tsx files this PR changes, npm run build; a bounded full npm run test ran 28 minutes with no failure before the bound on the previous base (CI's four shards are the authority); test_autonudge.py, test_slack_gateway_coverage.py, test_autonudge_refactor_contract.py, test_autonudge_refactor_characterization.py, test_autonudge_torn_deactivation.py, test_autonudge_stop_log.py (749 tests, -n0), flake8, isort, mypy on src/kiro_crew/, the black ratchet; scripts/docs-lint.sh, the diff-scoped comment-history gate, harness parity. The five CI reds on head 1140ad78f4 (test_spawn_approval_channel_delivery_2381.py, test_sandbox_protected_name_holds.py, test_knowledge_handlers_off_loop.py, test_knowledge_upload_reuse.py, Coverage Gate downstream) were the 13-day-old base's: those files pass on the rebased head. On bc551bd060, Backend Tests (Windows) (3) failed test/test_agent_panel_crew_log.py::test_eviction_ranks_on_fold_order_not_on_a_stamp (KeyError at :282) — a first-sighting flake: not this PR's file (last touched on main by #14743/#14295), no tracking issue, the same shard green on main's last green run and on every other shard of that head; one --failed rerun, and a second sighting gets an issue. On e3a0508b8a, Backend Tests (Windows) (2) (run 36697879496) failed six test/test_session_control_revive.py tests (resume_conflict, None is not None) — inherited: #15361 tracks that file as flaky on the Windows shards, it was red on main's completed run 36685196391 (64b0a33c9d) too, and it is not this PR's file; no rerun. #14925 (aec81410e2) carries the test-only fix for that class, which is why this head sits on it. No local review lane ran on this head; the server lanes are its first model read.

Screenshots / video

Before (origin/main): text buttons, Trigger nudge on the schedule line, and a paused record indistinguishable from a stopped one.

Before, no loop: the default template, the stop-file help line, a Start loop text button

Before, running loop: Trigger nudge text button under the schedule line, Stop loop and Save text buttons in the row

Before, a manually paused record: reads Stopped with the help line, Clear stopped goal and Start loop, no way to tell it from a stop

Before, stopped by the cycle cap: Stopped, help line, Clear stopped goal and Start loop, nothing naming the cap

After (this head), the rows of the 2026-09-30 rulings — icon-only controls, each name shown as hover text:

After, no loop: main's default goal as of #15740 (names the autonudge_stop tool, so it carries no {{STOP_FILE}} token and the token's help line does not show), one accented Play glyph (hover: Start loop)

After, running loop: header cycle 1/3, the schedule line with the countdown and the Zap glyph under it (hover: Nudge now), the row holding a Pause glyph and an accented Save glyph, no Stop

After, running loop sitting at its cycle cap 3/3: the schedule line reads Next cycle in 25s stops the loop. Cycle cap reached: raise Max cycles. — the Pause glyph stays live beside Save

After, running loop on a crew session, writes disabled: the reason line above the goal, the Zap glyph dimmed, the row holding a red Stop glyph alone (hover: Stop loop), confirm-gated

After, running loop with an edited goal: the Zap glyph's hover reads Save edits and nudge now and the accented Save glyph's hover reads Save without nudging; the row still shows only the two glyphs

After, paused loop: the schedule line reads Paused, a red Stop glyph on the left (hover: Stop loop) and an accented Play glyph on the right (hover: Resume loop and nudge now), no Save

After, paused loop with an edited goal: the same two glyphs, Stop and the accented Play, and no second row — Play's hover reads Save edits, resume loop and nudge now, and the press does exactly that

After, paused loop after pressing Stop: the schedule line reads Paused and Remove this goal for good?, the row holds the text buttons Cancel and a red Clear

After, stopped by the cycle cap: Stopped · Cycle cap reached — raise Max cycles, under it only Clear stopped goal removes it for good., a red Stop glyph (hover: Clear stopped goal) and a dimmed Play glyph

After, stopped on its runtime budget: Stopped · Runtime budget spent — max_runtime_secs is set when the loop is armed (monitor_start); raise it with monitor_update, under it only Clear stopped goal removes it for good., a red Stop glyph (hover: Clear stopped goal) and a dimmed Play glyph

Related Issues

no linked issue: operator product decision delivered through the crew conductor, no tracked issue exists.

Other

Layout ruled by the product owner on 2026-09-30 (his reply to the maintainer comment on this thread restates it): Nudge now back on the schedule line; a running loop's row is Pause and Save; Stop appears after Pause and asks first; the {{STOP_FILE}} help line stays as on main. This supersedes the 2026-09-17 one-lane layout that knowingly exceeded max-two-buttons-per-row; no row on this head exceeds it, and an overflow menu stays rejected. Three further rulings, 2026-09-30 23:22Z: (1) every control in the popover is icon-only — glyph, aria-label, hover title, no visible label — because that is the dashboard's established convention (the per-message toolbar: copy, link, pin, code, refresh, more; the composer: mic, enhance, send) and a first-time user learns those the same way, so the popover must not be the one surface with text labels; icon-buttons-need-labels is satisfied by the aria-label. (2) No "Save without resuming": a paused or stopped loop's row is Stop and one accented Play that saves the edited fields if dirty, then resumes or starts, then fires — the 2026-09-17 intent. (3) The confirm's button reads Clear; its question line Remove this goal for good? stays as is for now. The PR author restated the three on this thread at 23:42Z — #11478 (comment) — as his design decision for the popover. A docs/decisions/ entry waits for a maintainer's restatement (the directory's README, rule 4, takes a statement by someone not listed in MAINTAINERS.md as a proposal until a maintainer restates it).

Base: one commit on main's fecca3ea56, the tip at push time, rebased from d8fa6a527e across eleven commits of which one, #15740 (f0e2de9284, the default goal names the autonudge_stop tool and is read from the catalog as defaultMsg()), touched this PR's popover: the one conflict was that rename against the three definitions this PR adds beside it, resolved by taking main's function and following the rename in the four added lines that read the default; every other file's added and removed lines are identical against either base, the commit message unchanged. d8fa6a527e was #15744's merge, which regenerates the fold catalogue for the subagents fold and reads lessons.py's row-token helper through text_scoring, the two causes of the seven red jobs (Backend Lint & Type Check, 3.12 and Windows shards 4, 5 and 6, the Coverage Gate) the previous head inherited from d5bdff64e0 through the merge ref (its run 36826389792 and main's own 36822696805 fail the same jobs, none in a file this PR touches); flake8 and mypy are clean on this base. The replays were mechanical: git merge-tree --write-tree against the tip reports no conflicts, the rebased tree is byte-identical to the merge, every file's added and removed lines are the same against either base, the commit message unchanged. The base carries #14925's test-only change to test/test_session_control_revive.py (its _archive helper backdates closed_at by 60 s) for the Windows flake #15361 tracks, so the Backend Tests (Windows) (2) red this PR inherited on e3a0508b8a (run 36697879496, six resume_conflict failures in a file this PR does not touch) has its fix under it instead of a citation; #15633 (746028435c), the fix for the #15651 test_native_skill_projection.py failures the same shard inherited on dd1ed0e849; and the Bundle Size Gate fix 3ecea02fec that two of main's commits went red without. Earlier rounds followed two of main's moves (the autonudge_state handler into hooks/websocket/automationSeed.ts, the service's update logic into autonudge_service/mutations.py). Main gate when this body was written: the tip's own run (fecca3ea56, 36846381399) is red on Backend Tests (3.12, 4) — test_autonudge_refactor_contract.py::TestInstanceSeamsReachEveryInternalCaller store-write lock test, the flake #15676 tracks (seen on main 4d07623c54 too), and test_posix_lock_ceiling.py::TestInProcessOverlapOffTheLoop, the same lock class — plus the Coverage Gate downstream; neither is caused by this PR (the contract file passes here with -n0), so a red on that shard of this head is inherited and cited, not rerun. The previous tip d8fa6a527e (36832900240) was fully green.

Checklist

  • At most two commits (one is the norm), with a Conventional Commits title (feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert: ...)
  • Existing tests pass and new tests added for new functionality
  • Self-review completed; code follows project style guidelines
  • Documentation updated (if applicable)
  • No secrets, credentials, or internal references in the diff

@pepmach
pepmach requested review from a team and CrysisDeu September 17, 2026 07:09
@github-actions github-actions Bot added the readiness: checking Automated validation is still running label Sep 17, 2026
@pepmach

pepmach commented Sep 17, 2026

Copy link
Copy Markdown
Contributor Author

Intent: Give the goal popover one lane of icon controls so an operator can pause a running loop and bring it back later without retyping the goal, and so every control that fires saves the form first: Stop (red) pinned left; while running, Trigger, Pause and Save on the right; while paused, stopped, or with no loop, a single accented Play that saves, resumes or creates, and fires now.
Not a goal: No overflow menu, no change to the fire or PATCH routes' server semantics, no transaction across the write-then-fire pair, no change to how a loop is erased (the existing two-step confirm stays), and no new loop kinds or monitor types.

@github-actions

github-actions Bot commented Sep 17, 2026 •

Copy link
Copy Markdown
Contributor

GPT 5.6 Review — ✅ no blocking findings

GPT 5.6 completed its review of 265b978069c9614b5d0794e37ffc76fa5b60934d and found no blocking issues.

This comment is updated in place on each push.

Review details

No findings.
[GPT-REVIEWED] 265b978

False positive or not applicable? A repository writer can comment:
/ai-review override gpt 265b978069c9614b5d0794e37ffc76fa5b60934d: <one-sentence reason>

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Sep 17, 2026
@github-actions

github-actions Bot commented Sep 17, 2026 •

Copy link
Copy Markdown
Contributor

Design Review (Fable 5) — ✅ PASS

Design-level review of 265b978069c9614b5d0794e37ffc76fa5b60934d — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

Design-Verdict: PASS

Confirm the dated product-owner rulings (icon-only, Stop-after-Pause, create-without-fire) match the actual thread — the entire control layout rests on them.

[DESIGN-REVIEWED] 265b978

Description read

[DESCRIPTION-READ] ff051d3c8a7519aea4194ffe890033895252b965cad5c5f165d50e475eb580e8

That sha256 names everything this verdict read: the PR description, plus the 1 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@github-actions

github-actions Bot commented Sep 17, 2026 •

Copy link
Copy Markdown
Contributor

First Principles Review (Fable 5) — 🟡 CONCERNS

Premise-level review of 265b978069c9614b5d0794e37ffc76fa5b60934d — why this exists and whether the shipped surface is the smallest honest version. Updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

First-Principles-Verdict: CONCERNS

Converting every control to icon-only (and "Clear goal for good" → "Clear") rests on toolbar symmetry and a PR-thread quote the repository never recorded — no named failing user.

Not justified as shipped

  • Item 3 — unjustified move: the relabel's whole ground is "the dashboard's toolbars are icon buttons with hover text" plus "product owner, 2026-09-30 23:22Z" — symmetry plus a quote; docs/decisions/ (3 entries) and the base RFC list record no such ruling, and no reader failing with the text labels is named, while every existing user pays to relearn them.
    Subtraction: keep main's visible text labels; the Pause/Play/Stop capabilities need none of the relabel.
    Clears when: a named reader who failed with text labels (report, misclick), or a maintainer override recorded for this head — Stop's relocation behind Pause rides the same unrecorded ruling, and if it is read as replacing a user-facing capability it needs that record too.

What this change ships

Inventory (10 items) — 9 justified

Intent: ADDITION — let an operator pause a running goal loop and bring it back later, instead of erasing and retyping it.

  1. A running loop can be paused and resumed in place; "Paused" reads distinctly from "Stopped" — justified
  2. One-press Stop of a running loop replaced by Pause, then confirm-gated Stop — justified
  3. Every control relabeled icon-only (aria-label + hover title); confirm button now "Clear" — unjustified move (symmetry/owner quote, no recorded decision)
  4. A firing control saves only user-edited fields first; pristine presses write nothing — justified
  5. Play creates-and-starts with no loop; resumes/starts and nudges on an inactive one — justified
  6. Spent bounds named on the schedule line; Play held while one is spent — justified
  7. Stop-button sentence cut from the {{STOP_FILE}} help in all thirteen catalogs — justified
  8. Websocket frame now carries stopped_reason and next_due_ts for every loop — justified
  9. A pause landing after a bound stop keeps the bound's reason server-side — justified
  10. Nudge now disabled on an empty goal, disabled writes, or a due cycle — justified

[FIRST-PRINCIPLES-REVIEWED] 265b978

Description read

[DESCRIPTION-READ] c1f72562aacd072349846a7995804c4fe64c782cee986539630f613a5b381a4d

That sha256 names the PR description this verdict read. Recompute it with .github/scripts/pr-description-capture.sh; if it differs, the description changed after this verdict was formed and any finding drawn from the description is unproven.

@github-actions

github-actions Bot commented Sep 17, 2026 •

Copy link
Copy Markdown
Contributor

Opus 5 Review — ✅ no blocking findings

Reviewed 265b978069c9614b5d0794e37ffc76fa5b60934d — this comment is updated in place on each push.

Review details

No findings.

[OPUS-REVIEWED] 265b978

Verdict parsed from the review's SHA-scoped output markers for commit 265b978069c9614b5d0794e37ffc76fa5b60934d.

False positive or not applicable? A repository writer can comment:
/ai-review override fable 265b978069c9614b5d0794e37ffc76fa5b60934d: <one-sentence reason>

@github-actions

github-actions Bot commented Sep 17, 2026 •

Copy link
Copy Markdown
Contributor

UX Review (Fable 5) — 🔴 BLOCK

UX-level review of 265b978069c9614b5d0794e37ffc76fa5b60934d — updated in place on each push. A BLOCK verdict blocks PR readiness; PASS/CONCERNS are advisory.

UX-Verdict: BLOCK

Red square erases the goal but reads as "stop"; the blind reader refused to click it, and the state-swapping control rows have no recording.

Blockers

  • Destructive control misread and un-dared. The Square button (title stop_loop on paused) routes to setConfirmClear → DELETE — permanent removal — yet reads as the universal stop glyph. Reader, shot-08: "a stop button (red square is the universal stop symbol) → ends the loop"; shot-10: "no, I don't know whether it stops or erases, and red warns me off"; shot-13: "no; red, unlabelled." Every paused/stopped loop × either daren't-end or delete-thinking-stop × every visit. Fix within the icon-only ruling: a delete glyph (trash) plus a title that says removal ("Delete goal"), not "Stop loop".

Evidence gaps

  • Running→paused/confirm row swaps (loop?.active ? [Pause][Save] : [Stop][Play]; the confirm "REPLACES the rows") are lens-13 hard swaps; the recordings list is empty — attach a recording of pressing Pause, then Stop.
  • The hover titles that are each control's only name ("Resume loop and nudge now", "Save edits and nudge now") appear in no screenshot — attach one hover capture.

Watch

  • Every icon rated "a guess"; reader decoded them only from the labeled before-shots ("a first-time user only 'knows' the icon version by having seen the labelled one"); Zap dare: "maybe". First-run comprehension of the whole toolbar rests on hover.
  • Paused + edited shows no save path (shot-11: "I can't find any save control") — the save ride is only Play's hover title; surface it (e.g. accent/badge on Play when dirty).
  • bound_runtime_budget ships max_runtime_secs/monitor_start/monitor_update verbatim; reader: "I would not know what to do." Plain-language reason + where to act.
  • capped_tick_in is a garden path ("Next cycle in 25s stops the loop. …"); reader "took me several reads" — reorder: "Cycle cap reached — the next cycle (in {{time}}) stops the loop; raise Max cycles."

Suggestions

  • Keep the cycle readout while paused (header gates on loop?.active; reader: "I can't tell how far along it was").
  • Strengthen disabled Play beyond opacity-50 (shots 13–14: "I cannot tell if it is disabled or just styled darker").

[UX-REVIEWED] 265b978

Description read

[DESCRIPTION-READ] 7c4c9bdaa57d79f355cfee9b38d57ce528e1af797ab4fa5ebdaaa7d22b8518d5

That sha256 names everything this verdict read: the PR description, plus the 17 evidence file(s) the workflow collected from it and handed this review. It covers that evidence because the media strip replaces every attachment URL with the same placeholder, so an edit swapping one attachment for another would leave the description's captured text identical while what this review judged changed. Recompute it with .github/scripts/pr-description-capture.sh over the same inputs; if it differs, the description or that evidence changed after this verdict was formed and any finding drawn from either is unproven.

@pepmach
pepmach force-pushed the feat/autonudge-controls branch from 920581d to a472050 Compare September 17, 2026 08:13
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 17, 2026
@pepmach
pepmach force-pushed the feat/autonudge-controls branch from a472050 to cbe09a0 Compare September 17, 2026 08:39
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Sep 17, 2026
@pepmach

pepmach commented Sep 17, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted: new Pause, Play and Trigger writes use raw fetch(...) instead of useMutation span=1bda1fe2ef82

Every write this component already makes on main — save(), stop() and the loop create — is a raw fetch with the same busy flag and inline notice; the new controls share that exact shape through runControl / writeLoop rather than introducing a second pattern in the file.
The lifecycle step the finding cares about is present: every write ends with queryClient.invalidateQueries({ queryKey: AUTONUDGE_LOOPS_QUERY_KEY }), so the shared registry cache is reconciled, and the popover's own record arrives through onChange plus the autonudge_state websocket frame.
Moving this file's writes onto useMutation is a whole-file refactor of pre-existing Save/Stop paths and their tests with no behaviour change, outside this PR's intent (pause/resume controls); it belongs to a follow-up that converts the component as a unit.

@NicholasRBowers NicholasRBowers added the needs-pr-triage PR scanner: awaiting automated triage label Sep 24, 2026
@NicholasRBowers

Copy link
Copy Markdown
Contributor

🤖 Kiro Crew [operator: NicholasRBowers#a942f9ca]: This PR has been inactive for 7+ days. I reviewed the blockers but they require your input:

  • The four-control action row against the blocking max-two-buttons-per-row rule (Opus 4.8 BLOCKING, GPT 5.6 BLOCKING, First Principles Item 6). Both lanes' in-rule remedies are an overflow menu, or moving Trigger back to the schedule line — and this PR's intent comment names "no overflow menu" as an explicit non-goal. So either you choose which control leaves the lane, or a maintainer records the 2026-09-17 ruling on this head. I will not reverse your stated design decision, and I cannot authorize an override myself.
  • The {{STOP_FILE}} help-line deletion (Design Review Watch, First Principles Item 9). It reverses fix(goal-loop): explain the {{STOP_FILE}} token under the goal textarea #11162, which merged a day before this branch, on a product-owner ruling no artifact records. Both lanes clear only when a maintainer confirms that ruling on this thread or links a decision record — or the removal is dropped from this PR.
  • UX Review 🔴 BLOCK — what the red Stop square means. A cold reader could not tell what it does on a stopped loop, and while a loop is running one unconfirmed press permanently erases the typed goal. Whether that becomes a visible text label, a confirm, or an undo is a product call about the surface this PR introduces.

One finding is purely mechanical, so for the record rather than as a decision: GPT's website/src/components/AutoNudgePopover.tsx:486 data-loss finding, where body: JSON.stringify(fields) sends every field, so a concurrent edit to one field is overwritten by a stale value — PATCHing only the fields that differ from seeded closes it. It cannot unblock the PR on its own, so nothing was pushed.

When you've addressed these, the pipeline will re-assess on its next cycle.

@NicholasRBowers NicholasRBowers added needs-author-decision PR blocked on author input and removed needs-pr-triage PR scanner: awaiting automated triage labels Sep 24, 2026
@github-actions github-actions Bot added the merge conflict Branch has merge conflicts with its base — author must resolve before merge label Sep 24, 2026
@pepmach
pepmach force-pushed the feat/autonudge-controls branch 2 times, most recently from cbe09a0 to bf2d8d3 Compare September 25, 2026 20:41
@pepmach
pepmach force-pushed the feat/autonudge-controls branch from e3a0508 to dd1ed0e Compare October 1, 2026 01:44
@github-actions github-actions Bot added readiness: checking Automated validation is still running and removed readiness: action required A blocking check or review needs attention labels Oct 1, 2026
@pepmach

pepmach commented Oct 1, 2026

Copy link
Copy Markdown
Contributor Author

ok, all of this landed on dd1ed0e, that's the head to read

  1. the 4 button row is gone. nudge now moved back onto the schedule line and the row is never more than 2 controls: running = pause + save, paused/stopped = stop + play. max-two-buttons-per-row just passes now, no override needed, still no overflow menu

  2. the {{STOP_FILE}} help line stays as on main, not deleted. only its tail about the stop button got cut ("...or press Stop loop, which replaces Start loop while the loop runs") b/c a running loop doesn't show that button anymore

  3. stop: a running loop has no stop at all, u pause first and then the red square shows up next to play. pressing it asks "Remove this goal for good?" with cancel / clear, so nothing erases a goal in one press anymore

  4. the controls are icon-only w/ hover text (aria-label + title on every one), same as the dashboard's other toolbars, see feat(autonudge): pause, trigger, stop and save icon controls in the goal popover #11478 (comment)

and the :486 thing is in too, every write only sends the fields that differ from what the form was seeded with

@github-actions github-actions Bot added readiness: action required A blocking check or review needs attention and removed readiness: checking Automated validation is still running labels Oct 1, 2026
@pepmach

pepmach commented Oct 1, 2026 •

Copy link
Copy Markdown
Contributor Author

CI on dd1ed0e849: the three red backend shards are in files this PR does not touch.

CI on 695f6b901d (that next head): the three items above cleared; one new red, again in a file this PR does not touch.

@pepmach
pepmach force-pushed the feat/autonudge-controls branch from dd1ed0e to 695f6b9 Compare October 1, 2026 04:44
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 1, 2026
@pepmach
pepmach force-pushed the feat/autonudge-controls branch from 695f6b9 to 5b284e1 Compare October 1, 2026 05:52
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 1, 2026
@pepmach
pepmach force-pushed the feat/autonudge-controls branch from 5b284e1 to 02b38a4 Compare October 1, 2026 06:44
@github-actions github-actions Bot added readiness: checking Automated validation is still running readiness: action required A blocking check or review needs attention and removed readiness: action required A blocking check or review needs attention readiness: checking Automated validation is still running labels Oct 1, 2026
@pepmach

pepmach commented Oct 1, 2026

Copy link
Copy Markdown
Contributor Author

CI note for head 02b38a4edc (ci.yml run 36826389792): the seven red jobs are main's own breakage at this PR's base, reaching this head through the merge ref. None of the failing files is in this PR's diff (website popover, its tests and catalogs only).

Red job Failing Cause on main Fix in flight
Backend Lint & Type Check (3.12) flake8 F821 src/kiro_crew/vector_memory_runtime/lessons.py:1206 (_row_stem_tokens_for_scan) the row-token helper moved behind text_scoring and lessons.py still names it bare #15737
Backend Tests (3.12, 5) and (Windows) (5) test/test_lesson_turn_injection.py, 23 tests, NameError: _row_stem_tokens_for_scan same helper at runtime #15737
Backend Tests (3.12, 6) and (Windows) (6) test/test_vector_memory_composition_contract.py, 2 tests (one binding per shared name, lessons / _stem_one) same helper read outside its owner #15737
Backend Tests (3.12, 4) and (Windows) (4) test/test_fold_catalogue.py, 3 tests (subagents fold missing from the committed catalogue) catalogue not regenerated for the new fold #15744
Coverage Gate fails closed on the shards above consequence of the above clears with them

Main's own run on this base (d5bdff64e0, run 36822696805) is red on the same jobs. No rerun from this PR: the jobs will clear on the next rebase after #15737 and #15744 merge. Build Windows Installer (x64) passed on its re-run (36826389643), so the earlier 120-second-ceiling failure on 5b284e13c7 was runner timing, not this PR.

…oal popover

The goal popover's controls, by loop state (product owner, 2026-09-30: "Move
trigger back to schedule line. Keep Pause and Save. Stop appears after hitting
pause."): a running loop's row holds Pause and Save, and Nudge now sits on the
schedule line it shortcuts; a paused loop (stopped_reason "manual", which PATCH
{active:false} records) shows Stop (red, left) and one accented Play (Resume
loop and nudge now) that saves the edited fields if the form is dirty, then
resumes, then fires -- there is no separate Save on an inactive loop; a loop
stopped by a bound or a tool shows the same shape, Stop reading Clear stopped
goal and Play Start loop and nudge now, the help line naming both exits under
Stopped; no loop shows one accented Play named Start loop, as on main. Every
control is icon-only: a glyph
with its name as aria-label and the same name as its hover title, and no
visible label text (product owner, 2026-09-30 23:22Z). That is the dashboard's
own convention -- the per-message toolbar (copy, link, pin, code, refresh,
more) and the composer (mic, enhance, send) are icon buttons with hover text, a
first-time user learns those the same way, and the popover is not the one
surface with text labels; icon-buttons-need-labels is met by the aria-label.
The state-aware wording moved into those two attributes unchanged, and Play's
name flips with the form like Nudge now's and Save's: an edited paused or
stopped form reads "Save edits, resume loop and nudge now" / "Save edits, start
loop and nudge now", since the press saves the edits first. Text stays only on
the erase confirm's two buttons. No row holds more than two controls
(max-two-buttons-per-row); an overflow menu stays rejected.

Stop is two steps from a running loop: Pause first, then Stop, and Stop asks
first (Cancel / Clear, with "Remove this goal for good?" on the schedule line)
on the paused record and on the stopped one alike, since both presses remove
the goal for good. Nothing on this surface erases a running goal in one press.
The one exception is a running loop while writes are disabled (a crew or member
session): Pause cannot be pressed there, so the row holds Stop behind the same
confirm, or a stale record could never be cleared. The confirmed press sends
intent=stop for a live loop and intent=clear for a stopped record.

A control that fires saves the form first only when the user edited it, and
writes only the fields edited (editedFields: each field against what the popover
seeded on open, or what the server STORED on its last write -- the fields a
write carried re-sync from the returned record, not from the values sent, since
the service clamps the interval into its floor and ceiling and the cap to zero
or more, and a form left showing a typed 1 over a record running at 15 would
read pristine with no edit left to show the gap). Pristine: Nudge now fires and writes
nothing; Play on a paused or stopped loop PATCHes active:true alone, then POSTs
the fire route. Edited: the PATCH carries the edited fields (plus active:true
for Play), then the fire, and Nudge now's name says so -- "Nudge now" on a
pristine form, "Save edits and nudge now" once a field differs. So pause ->
edit -> Play carries a raised cap with the revive, while a field the user never
touched is never written back over a revision that landed while the popover
sat open -- the fields seed on the open edge and never re-sync, so a
monitor_update or another tab's save is not in them, and sending an untouched
field would clobber it. Play with no loop creates and starts the loop from the
form and does NOT fire (product owner, 2026-10-01 00:35Z): the first nudge
goes out at the interval, or when the user presses Nudge now on the running
loop -- main's own Start loop -> Trigger nudge flow, kept. Save, in the running
row only, is the plain PATCH of the edited fields, never active; its name reads
"Save without nudging" once the form is dirty, beside a Nudge now that would
save and fire. Every write -- the PATCH, the create, the fire -- goes through
one React Query useMutation: a refusal is the thrown error the pressing control
renders inline, a success invalidates the shared loops query. A refused write
fires nothing; a write followed by a refused fire leaves the loop written with
the refusal shown inline. Play, Nudge now and Pause keep the popover open (the
outcome and any refusal show in place); only Save closes it, as it always did.

Play is disabled while a bound is spent, read off the RECORD: a cycle cap the
record's count has reached (a cap typed in the form lifts it for Play, which
writes that field on the way to the fire, and never spends one) or the
wall-clock budget reason, which no field of this popover can clear. Pause is
held only by the budget reason: on a running loop that sits at its cap it stays
live, because Pause is the route to Stop and the paused record still names the
cap off its numbers, with Play held until the cap is raised. The schedule line
names the bound beside the status word of an inactive loop -- the budget line
names the field that holds it, where it is set and what raises it ("Runtime
budget spent -- max_runtime_secs is set when the loop is armed (monitor_start);
raise it with monitor_update"), since no field of this popover does -- and, on a
running loop at its cap, says what the next cycle does in two sentences ("Next
cycle in 25s stops the loop. Cycle cap reached: raise Max cycles.") in place of
a countdown beside the bound. A pause reaching a loop a
bound already stopped keeps the bound: the service treats a reasonless
deactivation of an inactive loop as no new stop and answers with the record as
it stands, which the popover hands up, so a stale press ends in Stopped. Each
leg of a press reports its own result to the parent the moment it lands,
carrying only what it owns. The write leg hands the record the server returned
up, as Save and Pause do. The fire leg hands up NO record: it reports the fire
with the record the press was MADE ON -- the written record when a write
preceded the fire, else the loop the editor held, pre-request either way --
and the bridge arms the next cycle's deadline on the record the parent holds
NOW -- the one source of truth for what a fire changes on screen -- unless that
record has fired since the press. The route's answer is never consulted:
fire_now arms a zero-delay timer and returns the live loop object, which the
route serializes only after its audit await, so a delivery completing inside
that window makes the answer post-delivery, its last_fire_ts equal to the
fired frame's, and a parent measured against the answer read a delivered cycle
as the one just armed and rolled it back to due for a whole interval. A
snapshot handed up after the fire can be
older than a frame that landed in between -- the write leg's own `updated`
frame, broadcast by the gateway as autonudge_state, or another tab's pause --
and two consecutive review rounds found a stale one leaving this surface
through the fire path (a fired record dropped by an object-identity guard, then
a written record handed up under a refused fire over a pause another tab had
landed, showing the paused loop as running). Each guard on the hand-off exposed
the next interleaving; a fire that never hands a record up ends the class for
the fire leg. The write leg's record is a snapshot too, and the record carries
no revision, so the bridge applies it only while the parent still holds the
record the press was rendered against -- object identity, the rule the
bounded monitor's writes already follow in the same component: the parent
re-identifies its record on every store dispatch, so a moved record means a
frame landed, frames arrive in the server's order and the write's own `updated`
frame is among them or follows. A response arriving after one is dropped and
the slot's cold read invalidated instead; a same-id guard that passed it let a
PATCH answered before another tab's pause, but delivered after the pause's
frame, put the active record back over the paused one, where it stood until a
reconnect because frames fire on change. The
bridge arms nothing when the parent's record is not this loop (the closure
outlived it), is no longer running (another writer paused it in the gap), or
FIRED since the press (the frame's last_fire_ts is newer than the pressed
record's), so a delivered cycle is never rolled back to "due". A
refused fire reports nothing: the write already did, and the loop is wherever
its frames say it is. A CREATED record's
hand-off re-keys the popover (the bridge keys it on the loop id); with no fire
behind a create, nothing is lost across that remount, and a refused create
throws before any hand-off and lands in the pressing instance's notice.

The compatibility bridge in SessionAutomationPopover passes stoppedReason
through to the editor, and the autonudge_state websocket frame carries
stopped_reason and next_due_ts for every loop, not only a structured monitor's,
so a pause is not downgraded to a stop and a countdown is not blanked when the
frame lands. The {{STOP_FILE}} help line (#11162) stays as on main except its
tail about the Stop button, which is cut (product owner, 2026-10-01 00:35Z: a
running loop no longer shows that button) -- in every locale the sentence now
ends at "Create that file to halt the loop", and only fr and ru change a word
more, where the changed-value style gates require the tu/ty imperative and the
narrow space before the colon. The blank-sentinel variant loses its "Press Stop
loop below to halt it" sentence on the same ruling. Catalogs, in all twelve locales plus the
regenerated pseudolocale: pause_loop, resume_loop, loop_paused, nudge_now,
save_without_nudging, start_loop_and_nudge, save_edits_and_resume,
save_edits_and_start, bound_cycle_cap, bound_runtime_budget, capped_tick_in,
capped_tick and stopped_help_bound added;
trigger_nudge reworded to name the combined action and clear_goal_for_good to
the bare "Clear" the confirm now shows; start_loop keeps main's value; no key
main ships is removed. The Bangla strings on this surface use the tumi register
the style guide requires; the Hindi ones the tum register (hi.md §4).
@pepmach

pepmach commented Oct 1, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted: the Square glyph is a hover-labelled control that never acts on its own; both of its names lead to the same text-labelled confirm step span=6273862466cd

Icon-only controls with hover text are the PR author's design decision for this surface (#11478 (comment)): the dashboard's other toolbars are icon buttons with hover text, and this popover follows them. Every control carries its name twice -- aria-label for assistive technology, title for pointer users -- so "Stop loop" / "Clear stopped goal" is announced and shown on hover.
The glyph never acts alone. Its press opens the confirm step, whose two TEXT buttons name the consequence -- Cancel / Clear under "Remove this goal for good?" -- so no unlabelled destructive action can land; a reader who would not press an unlabelled red button is one press from reading, in text, exactly what it does, and one Cancel from leaving the goal untouched. The two names are one outcome: on a paused loop and on a stopped record alike, the press ends in that confirm step and the goal's removal, so one glyph stands for one act and the name only says which state it acts from. On a running loop the exit is Pause, named on hover, and the row Pause opens is where Stop appears -- the PR author's ruling, which is also why the help line's sentence about a Stop button a running loop no longer shows was cut.

@pepmach

pepmach commented Oct 1, 2026

Copy link
Copy Markdown
Contributor Author
  • rebutted: the icon-only cost is accepted by the PR author's ruling; the names ride on hover text and accessible names span=2eb01d434de3

Icon-only controls are the PR author's design decision for this surface (#11478 (comment)), with the cost the finding names accepted: a first read is a guess until the hover or the screen reader supplies the name, exactly as on the dashboard's other icon toolbars (the per-message toolbar, the composer), which a user learns the same way.
Every control carries its name as aria-label and as title, and the one destructive control opens a text-labelled confirm step before acting, so the guess is never acted on blind. The owner's acceptance the item asks a human to confirm is the linked comment.

@pepmach

pepmach commented Oct 1, 2026

Copy link
Copy Markdown
Contributor Author
  • needs-a-decision: icon-only controls with hover text are the PR author's on-thread ruling; keeping main's text labels is the subtraction the maintainers would have to choose over it span=8e30d916ba04

The 2026-09-30 23:22Z ruling is on this thread: #11478 (comment) (pepmach) -- every control in this popover is a glyph with hover text (title) and an accessible name (aria-label), as the dashboard's other toolbars already are; the description links it. The names the lane says already ship as strings are exactly the strings the hover text and accessible names carry, so nothing is lost to assistive technology or to a pointer user who hovers; the relearning cost the item names is real and is the author's accepted trade.
This record claims no clearance. The item's own clearing paths are a named reader who failed with text labels (a report or a misclick), or /ai-review override first-principles 265b978069c9614b5d0794e37ffc76fa5b60934d: <decision> recorded by a maintainer; both sit with the maintainers and the PR author, who may instead take the subtraction (main's visible labels). Stop's relocation behind Pause rides the same on-thread ruling, as the item says, and the same record would cover it. Recorded so the reader sees the decision is pending with them, not folded in either direction here.

@pepmach

pepmach commented Oct 1, 2026

Copy link
Copy Markdown
Contributor Author

Superseded by #16030. It carries the redesign discussed here: Pause and Play icons, Clear as the only way to delete a goal, resume with a fresh budget, plain "Paused · reason" lines. Closing this one so the review starts from a clean thread.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

needs-author-decision PR blocked on author input

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants