@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.84c56d87

package/packages/gsd-agent-modes/dist/modes/interactive/controllers/chat-controller.js

@@ -98,6 +98,39 @@ export function textInvitesUserReply(text) {
     return /\b(?:what do you want|what's on your mind|let me know|tell me what|help me understand)\b/i.test(trimmed);
 }
 const DISCUSS_RESTATE_RE = /\b(?:what do you want|what should we|before i can write|context file|placeholder name|need to understand what|what(?:'s| is) (?:on your mind|the next)|help me understand what you want)\b/i;
+/** Second sub-turn that only says it is waiting after questions were already asked. */
+const HANDOFF_WAIT_RESTATE_RE = /\b(?:holding\s+(?:here|for)|waiting\s+(?:here|for)|no\s+need\s+for\s+anything\s+else|until\s+you\s+(?:point|tell|let\s+me\s+know|answer|reply)|i(?:'ve| have)\s+asked)\b/i;
+function isWaitOnlyQuestionFragment(fragment) {
+    return /^(?:i(?:'ve| have)\s+asked\b|(?:i'?m|i am)\s+(?:holding|waiting)\b|no\s+need\s+for\s+anything\s+else\b)/i.test(fragment)
+        && !/\b(?:should|do you|would you|can we|could we|what|which|how|where|when|who|also|add|include)\b/i.test(fragment);
+}
+/** True when text adds a question beyond wait/hold boilerplate. */
+function containsNewSubstantiveQuestion(text) {
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] !== "?")
+            continue;
+        const previousBreak = Math.max(text.lastIndexOf("\n", i), text.lastIndexOf(".", i), text.lastIndexOf("!", i), text.lastIndexOf("?", i - 1), -1);
+        const fragment = text.slice(previousBreak + 1, i + 1).trim();
+        if (fragment.length < 8)
+            continue;
+        if (isWaitOnlyQuestionFragment(fragment))
+            continue;
+        return true;
+    }
+    return false;
+}
+function isHandoffWaitRestatement(next) {
+    if (!HANDOFF_WAIT_RESTATE_RE.test(next))
+        return false;
+    // Keep follow-ups that add a real question even when they also say holding/waiting.
+    if (containsNewSubstantiveQuestion(next))
+        return false;
+    // Only classify as a pure wait ack when the text is short; long text likely
+    // contains substantive content alongside incidental wait language.
+    if (next.length > 400)
+        return false;
+    return true;
+}
 /**
  * Claude Code can emit a second text sub-turn that restates the same milestone
  * discuss ask. Drop it when the prior sub-turn already invited a user reply.
@@ -109,12 +142,33 @@ export function isRedundantDiscussRestatement(priorText, newText) {
         return false;
     if (!textInvitesUserReply(prior))
         return false;
-    if (!DISCUSS_RESTATE_RE.test(next))
+    const isDiscussRestate = DISCUSS_RESTATE_RE.test(next);
+    const isWaitRestate = isHandoffWaitRestatement(next);
+    if (!isDiscussRestate && !isWaitRestate)
         return false;
+    // Wait acks are gated on length and no-? inside isHandoffWaitRestatement.
+    if (isWaitRestate)
+        return true;
     if (next.length > prior.length * 1.1)
         return false;
     return next.length <= prior.length || next.length < 900;
 }
+function isSubTurnTextReplacement(blocks, rendered) {
+    for (const seg of rendered) {
+        if (seg.kind !== "text-run")
+            continue;
+        const oldText = (seg.cachedText ?? "").trim();
+        if (!oldText)
+            continue;
+        const newText = getTextFromContentBlocks(blocks, seg.startIndex, seg.endIndex).trim();
+        if (!newText || newText === oldText)
+            continue;
+        // Streaming growth extends prior text; a new sub-turn replaces it wholesale.
+        if (!newText.startsWith(oldText) && !oldText.startsWith(newText))
+            return seg.startIndex;
+    }
+    return null;
+}
 function getTextFromContentBlocks(blocks, startIndex, endIndex) {
     const parts = [];
     for (let i = startIndex; i <= endIndex && i < blocks.length; i++) {
@@ -193,6 +247,12 @@ export function priorAssistantTextFromSession(messages, opts) {
     }
     return undefined;
 }
+function shouldSuppressEntireAssistantMessage(message, sessionMessages, orphaned) {
+    const textBlocks = (message.content ?? []).filter((block) => block?.type === "text" && typeof block.text === "string" && block.text.trim());
+    if (textBlocks.length !== 1)
+        return false;
+    return shouldSuppressRedundantHandoffText(sessionMessages, textBlocks[0].text, orphaned, []);
+}
 function shouldSuppressRedundantHandoffText(sessionMessages, currentText, orphaned, rendered) {
     const next = currentText.trim();
     if (!next)
@@ -374,6 +434,22 @@ let hasToolsInTurn = false;
 let pinnedBorder;
 // Reference to the pinned markdown component below the border
 let pinnedTextComponent;
+// Set when the pinned zone was shown this turn; used to realign viewport after teardown.
+let pinnedZoneNeedsViewportRealign = false;
+function tearDownPinnedZone(host, options) {
+    const needsRealign = pinnedZoneNeedsViewportRealign;
+    if (pinnedBorder)
+        pinnedBorder.stopSpinner();
+    pinnedBorder = undefined;
+    pinnedTextComponent = undefined;
+    host.pinnedMessageContainer.clear();
+    lastPinnedText = "";
+    hasToolsInTurn = false;
+    pinnedZoneNeedsViewportRealign = false;
+    if (options?.realignViewport && needsRealign) {
+        host.ui.requestRender(true);
+    }
+}
 function mergeToolPhases(phases) {
     const merged = [];
     for (const phase of phases) {
@@ -462,15 +538,9 @@ export async function handleAgentEvent(host, event) {
     if (event.type === "message_start" && event.message.role === "assistant") {
         lastProcessedContentIndex = 0;
         lastContentLength = 0;
-        lastPinnedText = "";
-        hasToolsInTurn = false;
         renderedSegments = [];
         orphanedSegments = [];
-        if (pinnedBorder)
-            pinnedBorder.stopSpinner();
-        pinnedBorder = undefined;
-        pinnedTextComponent = undefined;
-        host.pinnedMessageContainer.clear();
+        tearDownPinnedZone(host);
     }
     switch (event.type) {
         case "session_state_changed":
@@ -482,16 +552,10 @@ export async function handleAgentEvent(host, event) {
                     host.streamingMessage = undefined;
                     host.pendingTools.clear();
                     host.pendingMessagesContainer.clear();
-                    host.pinnedMessageContainer.clear();
-                    lastPinnedText = "";
-                    hasToolsInTurn = false;
+                    tearDownPinnedZone(host);
                     renderedSegments = [];
                     orphanedSegments = [];
                     lastContentLength = 0;
-                    if (pinnedBorder)
-                        pinnedBorder.stopSpinner();
-                    pinnedBorder = undefined;
-                    pinnedTextComponent = undefined;
                     host.compactionQueuedMessages = [];
                     host.rebuildChatFromMessages();
                     host.updatePendingMessagesDisplay();
@@ -564,7 +628,10 @@ export async function handleAgentEvent(host, event) {
                         externalToolResult = {
                             toolCallId: tc.id,
                             content: ext.content ?? [{ type: "text", text: "" }],
-                            details: ext.details ?? {},
+                            // Preserve undefined when MCP omits structuredContent — an empty
+                            // object is truthy and makes ask_user_questions renderResult show
+                            // "Cancelled" despite a successful text payload (#cc-elicitation).
+                            details: ext.details,
                             isError: ext.isError ?? false,
                         };
                     }
@@ -577,7 +644,7 @@ export async function handleAgentEvent(host, event) {
                         externalToolResult = {
                             toolCallId: block.id,
                             content: ext.content ?? [{ type: "text", text: "" }],
-                            details: ext.details ?? {},
+                            details: ext.details,
                             isError: ext.isError ?? false,
                         };
                     }
@@ -591,6 +658,9 @@ export async function handleAgentEvent(host, event) {
                 // components don't get overwritten in place with new sub-turn
                 // content (#4144 regression). Prior sub-turn children stay in
                 // chatContainer as frozen history; new segments append after them.
+                const replacedAt = contentBlocks.length <= lastContentLength
+                    ? isSubTurnTextReplacement(contentBlocks, renderedSegments)
+                    : null;
                 if (contentBlocks.length < lastContentLength) {
                     // Accumulate across successive shrinks — overwriting would drop
                     // segments displaced by an earlier shrink, leaving them stranded
@@ -600,6 +670,19 @@ export async function handleAgentEvent(host, event) {
                     lastPinnedText = "";
                     lastProcessedContentIndex = 0;
                 }
+                else if (replacedAt !== null) {
+                    // Same-index wholesale replacement: orphan only the replaced
+                    // text-run and any text-runs after it. Earlier unchanged text
+                    // and tool segments stay in renderedSegments so they are not
+                    // re-rendered and duplicated in chatContainer.
+                    orphanedSegments = [
+                        ...orphanedSegments,
+                        ...renderedSegments.filter((seg) => seg.kind === "text-run" && seg.startIndex >= replacedAt),
+                    ];
+                    renderedSegments = renderedSegments.filter((seg) => !(seg.kind === "text-run" && seg.startIndex >= replacedAt));
+                    lastPinnedText = "";
+                    lastProcessedContentIndex = replacedAt;
+                }
                 else if (lastProcessedContentIndex >= contentBlocks.length) {
                     lastProcessedContentIndex = 0;
                 }
@@ -807,6 +890,7 @@ export async function handleAgentEvent(host, event) {
                                 // doesn't exceed the viewport and cause render flashing.
                                 pinnedTextComponent.maxLines = pinnedMax;
                                 host.pinnedMessageContainer.addChild(pinnedTextComponent);
+                                pinnedZoneNeedsViewportRealign = true;
                                 // Hide the separate status loader — the pinned zone replaces it
                                 if (host.loadingAnimation) {
                                     host.loadingAnimation.stop();
@@ -827,11 +911,7 @@ export async function handleAgentEvent(host, event) {
                     else if (pinnedBorder) {
                         // Every candidate is still visible in the chat scrollback —
                         // tear down the pinned zone so we don't duplicate on-screen text.
-                        pinnedBorder.stopSpinner();
-                        pinnedBorder = undefined;
-                        pinnedTextComponent = undefined;
-                        host.pinnedMessageContainer.clear();
-                        lastPinnedText = "";
+                        tearDownPinnedZone(host);
                         if (!host.loadingAnimation) {
                             host.statusContainer.clear();
                             startLoadingAnimation(host);
@@ -857,7 +937,7 @@ export async function handleAgentEvent(host, event) {
                 const shouldRenderAssistant = hasVisibleAssistantContent(host.streamingMessage, host.hideThinkingBlock) ||
                     ((host.streamingMessage.stopReason === "aborted" || host.streamingMessage.stopReason === "error") &&
                         !hasAssistantToolBlocks(host.streamingMessage));
-                const suppressRedundantHandoff = shouldSuppressRedundantHandoffText(host.session.messages, extractAssistantText(host.streamingMessage), orphanedSegments, []);
+                const suppressRedundantHandoff = shouldSuppressEntireAssistantMessage(host.streamingMessage, host.session.messages, orphanedSegments);
                 // The final message_end payload can contain additional text/thinking
                 // blocks that never arrived via message_update (e.g. SDK result
                 // aggregation). Rebuild this in-flight turn from final content so
@@ -913,8 +993,7 @@ export async function handleAgentEvent(host, event) {
                         const comp = new AssistantMessageComponent(undefined, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), timestampFormat, { startIndex: seg.startIndex, endIndex: seg.endIndex }, connectedToUser);
                         comp.updateContent(host.streamingMessage);
                         const segmentText = getTextFromContentBlocks(finalBlocks, seg.startIndex, seg.endIndex);
-                        if (suppressRedundantHandoff ||
-                            shouldSuppressRedundantHandoffText(host.session.messages, segmentText, orphanedSegments, renderedSegments)) {
+                        if (shouldSuppressRedundantHandoffText(host.session.messages, segmentText, orphanedSegments, renderedSegments)) {
                             continue;
                         }
                         host.chatContainer.addChild(comp);
@@ -973,13 +1052,7 @@ export async function handleAgentEvent(host, event) {
                 // Clear pinned output once the message is finalized in the chat
                 // container — prevents duplicate display when the agent continues
                 // (e.g. form elicitation) after the assistant message ends.
-                if (pinnedBorder)
-                    pinnedBorder.stopSpinner();
-                host.pinnedMessageContainer.clear();
-                lastPinnedText = "";
-                hasToolsInTurn = false;
-                pinnedBorder = undefined;
-                pinnedTextComponent = undefined;
+                tearDownPinnedZone(host, { realignViewport: true });
                 host.footer.invalidate();
             }
             host.ui.requestRender();
@@ -1031,14 +1104,7 @@ export async function handleAgentEvent(host, event) {
             host.pendingTools.clear();
             // Pinned output is only useful while work is actively streaming.
             // Keep chat history as the single source after completion.
-            if (pinnedBorder) {
-                pinnedBorder.stopSpinner();
-            }
-            host.pinnedMessageContainer.clear();
-            lastPinnedText = "";
-            hasToolsInTurn = false;
-            pinnedBorder = undefined;
-            pinnedTextComponent = undefined;
+            tearDownPinnedZone(host, { realignViewport: true });
             await host.checkShutdownRequested();
             host.ui.requestRender();
             break;