agentgui 1.0.1007 → 1.0.1009

package/AGENTS.md

@@ -1,5 +1,9 @@
 # AgentGUI — Agent Notes
 
+## GUI completion sweep (2026-07-02) — twenty-fourth run
+
+`gui-completion` workflow wf_4a731841-832 (33 agents, 17 confirmed). Landed 5 of the smaller-scope findings: Live-tab dashboard state (sort/filter/errors-only) now round-trips through the URL hash (`lsort=`/`lfilter=`/`lerr=1`) and localStorage — previously `lv.filter` wasn't persisted anywhere and the whole dashboard view reverted to defaults on reload. Shortcuts overlay (`?`) now wraps its content in the kit's existing `FocusTrap` component instead of a bare `role=dialog` div — Tab could previously escape into the page behind the overlay. History event rows expose copy even when collapsed (was expanded-only). Settings agents panel gives a not-installed direct-runner agent (claude-code/agy) a "re-check" button, matching the ACP rows' "restart" affordance. **Caught and fixed a real CSRF-guard test gap**: adding the regression test for the upload-PUT route (`scripts/validate-mutations.mjs`), the first draft accidentally included the `Authorization` header — matching every other case in the file but testing the wrong scenario (a stolen-token request, not real cross-site CSRF) — and passed trivially at 200. Corrected to omit auth (the path a real cross-site attacker is actually limited to); the server's existing guard correctly rejects it. **Rule for any CSRF/auth regression test: match the real attacker's capability set exactly — copying a nearby test's header pattern can silently test the wrong threat model.** 12 findings deferred to their own re-scoped PRD row (mid-thread retry/fork, file-management move UX with folder-tree picker, event-level permalinks, rolling context-size indicator — each needs a larger architecture change than a targeted fix). No kit changes this run. Pushed `d3e2d1e`. 28/28 tests, 17/17 validate-mutations, 0 console errors.
+
 ## GUI perceived-performance sweep (2026-07-02) — twenty-third run
 
 Small, targeted run landing the 22nd-run's deferred perceived-perf findings. `index.html` now `modulepreload`s the marked/dompurify ESM CDN modules (was preconnect-only) so the fetch starts in parallel with the kit/app module graph instead of waiting for `markdown.js`'s dynamic import on the first chat response's escaped-text-to-rendered-markdown swap. Settings server panel shows "checking…" instead of "unknown" for version/uptime/clients/projects-folder during the very first health probe (new `state.healthChecking` flag around `recheckHealth`'s await — "unknown" reads as a permanent broken-server fact, not in-flight loading). Settings agents panel title shows "agents · loading…" instead of the literal "agents · 0/0 installed" while the initial fetch is in flight. Still deferred (its own PRD row, re-scoped not dropped): first-render network-gating — the shell paints nothing between the boot-splash and health-probe completion, needing a render-architecture change (skeleton/optimistic shell) bigger than this run's slice. No kit changes this run. agentgui pushed `6a045ba`, 28/28 tests, 0 console errors.
@@ -75,19 +79,7 @@ Fluid-column + drag-resize density layer (workflow `gui-screen-realestate.js`, 5
 Visual/layout/motion parity vs claude.ai/code (workflow `gui-claude-code-parity.js`, 66 agents -> 37 gaps). Flat full-width chat turns (`.chat-msg-flat` at `--measure`), single bordered composer rounded-rect, `.chat-tool` status-toned cards, `WorkspaceShell mainFlush`, command-center `SessionDashboard`, reduced-motion-guarded transitions. **Load-bearing webjsx rule: never pass a conditional `x?h():null` positionally — build the array and `.filter(Boolean)` it; ANY null among VElement siblings crashes `applyDiff` (reading 'key'); `Btn` spreads array children.** Full detail in rs-learn (recall "agentgui 10th run parity").
 ## GUI logic+predictability sweep (2026-06-10) — ninth maximum-effort run
 
-Audits whether everything OPERATES logically and predictably (not coverage, not cohesion). New workflow `.claude/workflows/gui-logic-predictability.js` (6 lenses: interaction-lifecycle, cross-surface-consistency, information-architecture, realtime-truth, input-ergonomics, scale-robustness; hunt -> adversarial verify (kept-typography guard) -> plan). 78 agents -> 67 confirmed findings (`PUNCHLIST-LOGIC.md`). ALL implemented across kit/app/server.
-
-**Interaction lifecycles.** Kit `ConfirmDialog`/`PromptDialog` gain `error` (inside `.ds-modal-body`, role=alert) + `busy`/`busyLabel` (disables actions AND Escape/backdrop close via `data-busy`); Backdrop's Escape listener is **document-level** (focus can sit outside the dialog) and focus-restore fires only on genuine close (queueMicrotask remount guard) - the app's global Escape ladder ALSO closes `state.files.dialog` as belt-and-braces (a witness caught Escape dead with focus on H1). Per-session stop: `state.live.stopping` Set + kit `session.stopping` ('stopping...', disabled); bulk stops await `Promise.allSettled`, announce 'stopped N of M', partial failures keep their selection. Upload: one drain loop, concurrent drops append, 409 rows get `replace` (overwrite=1) + dismiss (kit `UploadProgress {actions,onDismiss}`). new-chat/backend-change/stop confirms are arm-only with bound values + 4s reset; chips never clobber a typed draft.
-
-**Realtime truth.** Dashboard joins on `realSid = claudeSessionId || sessionId` - server `chat.active` rows now carry `claudeSessionId`; `streaming_cancelled` is broadcast (an aborted turn never also completes; backend maps it to `{type:'cancelled'}`, app marks the turn 'stopped'); a 60s per-session terminal-frame buffer replays on re-subscribe (`replayedTerminal`) so a turn finishing during a ws drop cannot hang busy; `chat_active_changed` hints (started/ended/cancelled) trigger immediate refreshActive. Error status derives from recency (not cumulative count - a session is not 'error' forever); stale derivation honors any session's running tool (per-sid `toolRunning` off SSE); SSE counter increments dedup by `ev.i` maxI; counters take max(index,tally) and never move backwards; clock-skew clamps to 'just now'; external (non-owned) sessions render as read-only dashboard cards; sorts compare real timestamps with sid tiebreaker; tally pruned 24h/200-LRU. persistChat: 500ms debounce, 100-msg cap, >4KB tool payloads trimmed (`truncatedForStorage`), quota failure banners once, cross-tab `storage` listener with ts guard ('updated in another tab' banner instead of clobber).
-
-**Input ergonomics.** IME guards (composer, PromptDialog, SearchInput - `isComposing || keyCode===229` never sends). Escape ladder: shortcuts overlay > file dialog > confirmingEdit > new-chat arm > stop-arms > stop generation (and Esc in composer cancels while busy). Window-level dragover/drop preventDefault outside `.ds-dropzone` (a dropped file never navigates the page). Composer: `onPasteFiles`/`onDropFiles` kit props (image paste with no handler -> polite transient note), `.chat-composer-hint` 'Enter to send · Shift+Enter for a new line', context `bits` may carry per-bit `onClick` (cwd is its own target; agent/model inert). `Mod+Shift+L` focuses composer from anywhere (the one chord BEFORE the modifier early-return). cwd validates on blur (debounced `/api/stat` -> kit `cwdError`/`cwdChecking`). Streaming re-render pauses while a selection is held inside the thread (kit `hasSelectionInside` + autoscroll pause).
-
-**Scale.** `AgentChat {shownMessages,onShowEarlier}` windowed thread (`MESSAGE_CAP=100`, keyed 'show N earlier turns' row); >20k streaming part renders a 4k tail window ('streaming · N KB so far'); history events sliced to last 5000 in-app (server adds a `?limit=N[&before=]` slicing shim in server.js - ccsniff itself has no limit support, do NOT edit node_modules); markdown loader failure no longer latches degraded (30s retry, cache never stores escaped fallback).
-
-**Consistency/IA.** ONE `fmtDuration` (kit sessions.js) + ONE `fmtBytes` (= fmtFileSize, `0 B` not em-dash) kit-wide with app fallbacks; SessionCard `title` shares the rails' title expression; `session.external` + `session.elapsedMs`; STREAM_WORD `offline`; coarse-pointer always-visible file row actions; idle status never reads 'resuming...' (plain 'continues session <sid8>' in composer context); `/` focuses the files/live filter; running panel links 'open in live'; settings reordered backend -> server -> agents -> appearance -> keyboard -> data; crumb says 'settings' and Files crumb carries the parent trail.
-
-**Witness.** localhost:3000/gm/ 0 console/page errors across chat/files/live/history/settings; composer hint renders; rename dialog opens + Escape closes + focus restores; 64-row files grid + crumb trail; 420px chat+live no h-scroll; decorative-glyph count 0 (kept middot/ellipsis/dash). Joint risk to re-check after parallel agent runs: prop-name contracts (this run caught app `onPasteImage` vs kit `onPasteFiles`, and backend missing the new `streaming_cancelled` type).
+78-agent workflow, 67 confirmed findings, all implemented (interaction lifecycles, realtime truth, input ergonomics, scale, consistency). **Escape ladder order: shortcuts overlay > file dialog > confirmingEdit > new-chat arm > stop-arms > stop generation** (still binding - later runs extend the ladder, never reorder it). Full detail in rs-learn (recall "agentgui 9th run logic predictability sweep").
 
 ## GUI completion sweep (2026-06-10) — eighth maximum-effort run
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.1007",
+  "version": "1.0.1009",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/site/app/js/app.js

@@ -1945,11 +1945,12 @@ function chatMain() {
       children: [Spinner({ key: 'trspin', size: 'sm' })] }));
   }
   if (state.chat.confirmingEdit) {
-    banners.push(Alert({ key: 'confedit', kind: 'warn', title: 'Edit this message?',
+    const isRetry = state.chat.confirmingEdit.kind === 'retry';
+    banners.push(Alert({ key: 'confedit', kind: 'warn', title: isRetry ? 'Retry this turn?' : 'Edit this message?',
       children: [
-        h('span', { key: 'cetext' }, 'Editing will remove the later turns - continue? '),
+        h('span', { key: 'cetext' }, (isRetry ? 'Retrying' : 'Editing') + ' will remove the later turns - continue? '),
         Btn({ key: 'ceno', onClick: cancelEditAndResend, children: 'cancel' }),
-        Btn({ key: 'ceyes', danger: true, onClick: confirmEditAndResend, children: 'continue' })] }));
+        Btn({ key: 'ceyes', danger: true, onClick: confirmEditAndResend, children: isRetry ? 'retry' : 'continue' })] }));
   }
   const lastMsg = state.chat.messages.length ? state.chat.messages[state.chat.messages.length - 1] : null;
   const lastErr = lastMsg ? lastMsg.error : null;
@@ -2041,7 +2042,10 @@ function chatMain() {
       // edit-and-resend a user message (two-step: arm a confirm banner first,
       // since the truncation destroys the later turns).
       onCopyMessage: (m) => copyMessageText(m),
-      onRetryMessage: () => retryLastTurn(),
+      // Mid-thread retry (gui-completion #7): the kit now offers retry on
+      // EVERY assistant turn, not just the last - pass the specific message
+      // through so retryTurn truncates from the right position.
+      onRetryMessage: (m) => retryTurn(m),
       confirmEdit: true,
       onArmEdit: (m) => armEditAndResend(m),
       onEditMessage: (m) => armEditAndResend(m),
@@ -2334,28 +2338,56 @@ function chatFollowups() {
   return result;
 }
 // Retry the last assistant turn: drop it and re-send the preceding user message.
-function retryLastTurn() {
-  if (!canSend() && !state.chat.busy) { /* allow when idle */ }
+// Retry a turn: truncates the transcript back to (and resends) the user
+// message that preceded the given assistant message, discarding it and
+// everything after - the same truncate+resend mechanism edit-and-resend
+// uses. `m` is optional (falls back to the trailing assistant turn) so this
+// also serves as "retry last turn" for onRetryMessage on a dangling user
+// message with no reply yet. Mid-thread retry (any assistant turn, not just
+// the last) was a gui-completion #7 finding - the kit's per-message retry
+// action is no longer gated to the last message index for assistant turns.
+function retryTurn(m) {
   if (state.chat.busy) return;
-  // The armed edit confirm refers to indices this retry is about to shift.
-  state.chat.confirmingEdit = null;
   const msgs = state.chat.messages;
-  // Find the trailing assistant turn and the user message before it.
-  let ai = msgs.length - 1;
-  while (ai >= 0 && msgs[ai].role !== 'assistant') ai--;
+  let ai = m ? msgs.indexOf(m) : -1;
+  if (ai < 0) {
+    // Fall back to the trailing assistant turn (no specific message given,
+    // or the given message somehow isn't in the current transcript).
+    ai = msgs.length - 1;
+    while (ai >= 0 && msgs[ai].role !== 'assistant') ai--;
+  }
   if (ai < 0) return;
   let ui = ai - 1;
   while (ui >= 0 && msgs[ui].role !== 'user') ui--;
   if (ui < 0) return;
+  // Retrying anything before the trailing turn silently discards every LATER
+  // turn too - the same destructive-truncation risk edit-and-resend already
+  // confirms for, so mid-thread retry gets the identical arm-then-confirm
+  // banner instead of firing immediately.
+  const discardsLaterTurns = ai < msgs.length - 1;
+  if (discardsLaterTurns) {
+    state.chat.confirmingEdit = { idx: ui, text: msgs[ui].content || '', kind: 'retry' };
+    render();
+    return;
+  }
+  state.chat.confirmingEdit = null;
+  executeTruncateAndResend(ui);
+}
+function executeTruncateAndResend(ui) {
+  const msgs = state.chat.messages;
   const userText = msgs[ui].content || '';
-  // Drop the user+assistant pair (and anything after) and resend the user text.
   state.chat.messages = msgs.slice(0, ui);
   state.chat.totalCost = computeTotalCost();   // discarded turns leave the spend
+  // Never --resume a session whose tail diverged from what the server saw -
+  // a mid-thread retry/edit truncates history the resumed session still has.
+  state.chat.resumeSid = null;
+  state.chat.resumeNote = null;
   state.chat.draft = userText;
   persistChat();
   if (canSend()) sendChat();
   else render();
 }
+function retryLastTurn() { retryTurn(); }
 // Edit-and-resend a user message: two-step. The edit click ARMS a confirmation
 // (truncating destroys the later turns), the banner's continue executes it.
 function armEditAndResend(m) {
@@ -2369,6 +2401,9 @@ function confirmEditAndResend() {
   const ce = state.chat.confirmingEdit;
   if (!ce || state.chat.busy) return;
   state.chat.confirmingEdit = null;
+  // Retry resends the SAME text immediately (no edit step); edit-and-resend
+  // populates the draft so the user can change it before sending.
+  if (ce.kind === 'retry') { executeTruncateAndResend(ce.idx); return; }
   state.chat.messages = state.chat.messages.slice(0, ce.idx);
   state.chat.totalCost = computeTotalCost();   // discarded turns leave the spend
   // Never --resume a session whose tail diverged from what the server saw.