agentgui 1.0.1008 → 1.0.1009

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.1008",
+  "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.