Merge pull request #226 from SoftwareSavants/undefined-leftpad-684

feat(claude): /btw side questions for ephemeral mid-stream Q&A

Author: iabdousd

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Side question (`/btw`) for Claude sessions: ask an ephemeral question without polluting the transcript. Type `/btw <question>` in the composer (auto-completes from the slash-command palette), or - while the agent is streaming and you've scrolled to the bottom of the chat - click the small "Ask sideways /btw" pill that takes the place of the scroll-to-bottom button (same screen real estate, swapped by context). Q/A are not persisted to `output_lines` and never re-enter conversation history on resume; `synthetic` fallbacks are badged distinctly. Wires through a new `ask_side_question` Tauri command on top of the existing control-request plumbing.
 - Cmd+Alt+Left/Right now cycles between sessions in the current task when viewing a session (wraps at edges). The shortcut still cycles editor tabs when a file is open, mirroring Ctrl+Tab's view-aware behavior
 - File edits detected by the worktree watcher now trigger a debounced local git refresh, so status/commits/branch state update automatically as you change code without hitting GitHub
 - Local git refresh now uses non-locking read-only git commands, so viewing status no longer rewrites `.git/index` and self-triggers endless `git-local-changed` watcher loops

README.md

@@ -17,6 +17,7 @@ Pluggable agent backend with first-class support for Claude Code and Codex (plan
 ## Stay in control without babysitting
 
 - **Steps** - queue follow-up prompts while an agent is working; arm them to auto-send on idle, or fire manually
+- **Side question (`/btw`)** - type `/btw <question>` mid-stream (or click the "Ask sideways" button that appears in the corner of the chat while Claude is working) to ask an ephemeral question - the answer shows in a floating panel and never enters conversation history
 - **Fork from any message** - hover any past reply to rewind the conversation in place, or branch into a new task with the worktree restored to the code as it was at that exact turn. Verun takes a git snapshot at every turn, so you can undo an entire direction - not just a line of code
 - **Tool approval** - configurable trust levels per task: supervised, normal, or full auto
 - **UI / Terminal toggle for Claude** - flip any Claude session into a real PTY running `claude --resume` to use the unmodified TUI, while history, fork, and search keep working because Verun tails the on-disk transcript. The mode is sticky per session with an app-wide default in Settings

src-tauri/src/ipc.rs

@@ -935,6 +935,20 @@ pub async fn get_session_context_usage(
     task::get_session_context_usage(active.inner(), pending_ctrl.inner(), &session_id).await
 }
 
+/// Ask Claude an ephemeral side question (`/btw`) while a turn is mid-stream.
+/// Q/A are not persisted and never enter the conversation transcript.
+/// Returns `Ok(None)` when the CLI couldn't answer (e.g. before the first
+/// turn completes on a resumed session).
+#[tauri::command]
+pub async fn ask_side_question(
+    active: State<'_, ActiveMap>,
+    pending_ctrl: State<'_, PendingControlResponses>,
+    session_id: String,
+    question: String,
+) -> Result<Option<task::SideQuestionResponse>, String> {
+    task::send_side_question(active.inner(), pending_ctrl.inner(), &session_id, &question).await
+}
+
 /// Return session IDs that currently have an active process
 #[tauri::command]
 pub async fn get_active_sessions(active: State<'_, ActiveMap>) -> Result<Vec<String>, String> {

src-tauri/src/lib.rs

@@ -285,6 +285,7 @@ pub fn run() {
             ipc::abort_message,
             ipc::interrupt_session,
             ipc::get_session_context_usage,
+            ipc::ask_side_question,
             ipc::get_active_sessions,
             ipc::respond_to_approval,
             ipc::get_pending_approvals,

src-tauri/src/task.rs

@@ -2955,6 +2955,91 @@ pub async fn get_session_context_usage(
     }
 }
 
+/// Response shape for an ephemeral `/btw` side question. `synthetic = true`
+/// signals a fallback canned reply (e.g. when the turn isn't far enough along
+/// to answer meaningfully).
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SideQuestionResponse {
+    pub response: String,
+    pub synthetic: bool,
+}
+
+/// Build the inner `request` body for a `side_question` control_request.
+/// Pure (no I/O) so the wire shape can be asserted in unit tests.
+fn build_side_question_request(question: &str) -> serde_json::Value {
+    serde_json::json!({
+        "subtype": "side_question",
+        "question": question,
+    })
+}
+
+/// Parse the CLI's `control_response` payload for a `side_question` request.
+/// The Anthropic SDK envelope is `{"response": {"subtype": "success",
+/// "request_id": ..., "response": {"response": "...", "synthetic": false}}}`,
+/// but `stream.rs` already unwraps one `response` layer before resolving the
+/// oneshot, so what arrives here is the inner `{"response": ..., "synthetic": ...}`.
+/// `null` at `response` means the CLI couldn't answer (e.g. before the first
+/// turn completes on a resumed session): returns `Ok(None)`.
+fn parse_side_question_response(
+    value: &serde_json::Value,
+) -> Result<Option<SideQuestionResponse>, String> {
+    let response_field = value
+        .get("response")
+        .ok_or_else(|| "side_question reply missing `response` field".to_string())?;
+    if response_field.is_null() {
+        return Ok(None);
+    }
+    let response = response_field
+        .as_str()
+        .ok_or_else(|| "side_question reply `response` is not a string".to_string())?
+        .to_string();
+    let synthetic = value
+        .get("synthetic")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);
+    Ok(Some(SideQuestionResponse {
+        response,
+        synthetic,
+    }))
+}
+
+/// Ask Claude an ephemeral side question while a turn is mid-stream. The Q/A
+/// is not added to conversation history and never persisted to `output_lines`.
+/// Returns `Ok(None)` when the CLI returned a null response (e.g. nothing to
+/// answer about yet on a freshly resumed session).
+pub async fn send_side_question(
+    active: &ActiveMap,
+    pending: &PendingControlResponses,
+    session_id: &str,
+    question: &str,
+) -> Result<Option<SideQuestionResponse>, String> {
+    let stdin = active
+        .get(session_id)
+        .map(|proc| proc.stdin.clone())
+        .ok_or_else(|| "No active session".to_string())?;
+
+    let (request_id, rx) = send_control_request(
+        &stdin,
+        Some(pending),
+        build_side_question_request(question),
+    )
+    .await?;
+    let rx = rx.expect("pending map provided");
+
+    let result = tokio::time::timeout(Duration::from_secs(60), rx).await;
+
+    if result.is_err() {
+        pending.remove(&request_id);
+    }
+
+    match result {
+        Ok(Ok(Ok(v))) => parse_side_question_response(&v),
+        Ok(Ok(Err(e))) => Err(e),
+        Ok(Err(_)) => Err("Session closed before responding".to_string()),
+        Err(_) => Err("Timed out waiting for CLI response".to_string()),
+    }
+}
+
 fn title_generation_args(prompt: &str) -> Vec<String> {
     vec![
         "-p".into(),
@@ -3661,4 +3746,76 @@ mod tests {
         assert!(args.iter().any(|a| a == "--no-session-persistence"));
         assert!(args.iter().any(|a| a == "haiku"));
     }
+
+    #[test]
+    fn side_question_request_has_correct_wire_shape() {
+        let body = build_side_question_request("what was that var name?");
+        assert_eq!(body["subtype"], "side_question");
+        assert_eq!(body["question"], "what was that var name?");
+        // No extra top-level fields.
+        let obj = body.as_object().expect("object");
+        assert_eq!(obj.len(), 2);
+    }
+
+    // Note on shape: stream.rs unwraps one `response` layer before resolving
+    // the oneshot, so what `parse_side_question_response` sees is the inner
+    // `{"response": "...", "synthetic": ...}` object - not the SDK's outer
+    // `{"response": {"response": ..., "synthetic": ...}}` envelope.
+
+    #[test]
+    fn side_question_response_parses_full_payload() {
+        let v = serde_json::json!({ "response": "it was foo", "synthetic": false });
+        let parsed = parse_side_question_response(&v).unwrap();
+        assert_eq!(
+            parsed,
+            Some(SideQuestionResponse {
+                response: "it was foo".to_string(),
+                synthetic: false
+            })
+        );
+    }
+
+    #[test]
+    fn side_question_response_parses_synthetic_true() {
+        let v = serde_json::json!({ "response": "fallback", "synthetic": true });
+        let parsed = parse_side_question_response(&v).unwrap().unwrap();
+        assert!(parsed.synthetic);
+        assert_eq!(parsed.response, "fallback");
+    }
+
+    #[test]
+    fn side_question_response_defaults_synthetic_to_false_when_missing() {
+        let v = serde_json::json!({ "response": "ok" });
+        let parsed = parse_side_question_response(&v).unwrap().unwrap();
+        assert!(!parsed.synthetic);
+    }
+
+    #[test]
+    fn side_question_response_null_response_returns_none() {
+        let v = serde_json::json!({ "response": null, "synthetic": false });
+        let parsed = parse_side_question_response(&v).unwrap();
+        assert_eq!(parsed, None);
+    }
+
+    #[test]
+    fn side_question_response_missing_response_field_errors() {
+        let v = serde_json::json!({ "synthetic": true });
+        assert!(parse_side_question_response(&v).is_err());
+    }
+
+    #[test]
+    fn side_question_response_non_string_response_errors() {
+        let v = serde_json::json!({ "response": 42 });
+        assert!(parse_side_question_response(&v).is_err());
+    }
+
+    #[tokio::test]
+    async fn send_side_question_errors_when_session_not_active() {
+        let active = new_active_map();
+        let pending = new_pending_control_responses();
+        let err = send_side_question(&active, &pending, "no-such-session", "hi")
+            .await
+            .unwrap_err();
+        assert!(err.contains("No active session"), "got: {err}");
+    }
 }

src/components/ChatView.tsx

@@ -3,13 +3,14 @@ import { createStore, produce, reconcile } from 'solid-js/store'
 import { clsx } from 'clsx'
 import { renderMarkdown, handleMarkdownLinkClick, getWorktreePath } from '../lib/markdown'
 import type { OutputItem, SessionStatus, AttachmentRef } from '../types'
-import { ChevronDown, ChevronRight, AlertTriangle, Copy, Check, ArrowUp, ArrowDown, X, GitBranch, RotateCw, Plus, ChevronUp } from 'lucide-solid'
+import { ChevronDown, ChevronRight, AlertTriangle, Copy, Check, ArrowUp, ArrowDown, X, GitBranch, RotateCw, Plus, ChevronUp, MessageCircleQuestion } from 'lucide-solid'
 import { FileMentionBadge } from './FileMentionBadge'
 import { ImageViewer } from './ImageViewer'
 import { BlobImage } from './BlobImage'
 import { Popover } from './Popover'
 import { parseMentions } from '../lib/mentions'
 import * as ipc from '../lib/ipc'
+import { openSideQuestion, sideQuestionPanel } from '../store/sideQuestion'
 import { addToast, setSelectedTaskId, setSelectedSessionIdForTask } from '../store/ui'
 import { setSessions, loadOutputLines, loadOlderOutputLines, hasMoreOutputLines, sendMessage, createSession } from '../store/sessions'
 import { planModeForSession, thinkingModeForSession, fastModeForSession } from '../store/sessionContext'
@@ -1286,15 +1287,64 @@ export const ChatView: Component<Props> = (props) => {
         </Show>
       </div>
       </div>
-      <Show when={!isAtBottom()}>
-        <button
-          class="absolute bottom-4 right-4 z-10 w-7 h-7 flex items-center justify-center rounded-full bg-surface-2 ring-1 ring-outline/10 shadow-lg text-text-dim hover:text-text-secondary hover:ring-outline/20 transition-colors"
-          onClick={scrollToBottom}
-          title="Scroll to bottom"
-        >
-          <ChevronDown size={15} />
-        </button>
-      </Show>
+      {(() => {
+        const hasAiTurn = () => props.output.some((i) => i.kind !== 'userMessage')
+        const showBtw = () =>
+          isAtBottom()
+          && props.agentType === 'claude'
+          && !!props.sessionId
+          && hasAiTurn()
+          && sideQuestionPanel()?.sessionId !== props.sessionId
+        const showScroll = () => !isAtBottom()
+        // Both buttons share the same bottom-right pivot so they appear to
+        // morph out of/into the same anchor point instead of cross-fading
+        // as two competing rectangles.
+        const morph =
+          'absolute bottom-0 right-0 origin-bottom-right will-change-[transform,opacity] '
+          + 'transition-[opacity,transform] duration-[260ms] '
+          + 'ease-[cubic-bezier(0.22,1,0.36,1)] motion-reduce:transition-none'
+        return (
+          <div class="absolute bottom-4 right-4 z-10 pointer-events-none">
+            <button
+              class={clsx(
+                morph,
+                'w-7 h-7 flex items-center justify-center rounded-full bg-surface-2 ring-1 ring-outline/10 shadow-lg text-text-dim hover:text-text-secondary hover:ring-outline/20',
+                showScroll()
+                  ? 'opacity-100 scale-100 pointer-events-auto'
+                  : 'opacity-0 scale-75 pointer-events-none',
+              )}
+              onClick={scrollToBottom}
+              title="Scroll to bottom"
+              aria-hidden={!showScroll()}
+              tabindex={showScroll() ? 0 : -1}
+            >
+              <ChevronDown size={15} />
+            </button>
+            <button
+              class={clsx(
+                morph,
+                'h-7 px-2.5 flex items-center gap-1.5 whitespace-nowrap rounded-full bg-surface-2 ring-1 ring-outline/10 shadow-lg text-text-dim hover:text-text-secondary hover:ring-outline/20 text-[11px]',
+                showBtw()
+                  ? 'opacity-100 scale-100 pointer-events-auto'
+                  : 'opacity-0 scale-75 pointer-events-none',
+              )}
+              onClick={() => {
+                const sid = props.sessionId
+                if (sid) openSideQuestion(sid)
+              }}
+              title="Ask Claude an ephemeral side question (does not enter conversation history)"
+              aria-hidden={!showBtw()}
+              tabindex={showBtw() ? 0 : -1}
+            >
+              <MessageCircleQuestion size={12} />
+              <span>
+                Ask sideways{' '}
+                <code class="ml-0.5 px-1 py-0.5 rounded bg-surface-3 text-text-dim text-[9px]">/btw</code>
+              </span>
+            </button>
+          </div>
+        )
+      })()}
       <Show when={viewerImage()}>
         {(img) => (
           <ImageViewer

src/components/MessageInput.tsx

@@ -21,6 +21,7 @@ import * as ipc from '../lib/ipc'
 import { Popover } from './Popover'
 import { ImageViewer } from './ImageViewer'
 import { BlobImage } from './BlobImage'
+import { openSideQuestion } from '../store/sideQuestion'
 import { serializeAttachments, deserializeAttachments, uploadAttachments } from '../lib/binary'
 import { formatCost as fmtCost, formatTokens as fmtTokens, formatDurationShort } from '../lib/format'
 
@@ -1001,18 +1002,33 @@ export const MessageInput: Component<Props> = (props) => {
         setPlanMode(!planMode())
         break
       }
+      case 'btw': {
+        const sid = props.sessionId
+        if (!sid) break
+        // Strip the `/btw ` prefix; whatever's left becomes the side question.
+        // Empty rest means "open the panel" - pass undefined so the panel
+        // restores the remembered Q/A instead of blanking it.
+        const rest = message().trim().replace(/^\/btw\s*/i, '')
+        openSideQuestion(sid, rest.length > 0 ? rest : undefined, rest.length > 0)
+        break
+      }
     }
     setMessage('')
     setShowPalette(false)
   }
 
   const handleCommandSelect = (cmd: Command) => {
-    if (cmd.category === 'app') {
+    // /btw is an app command but takes a free-form question, so insert the
+    // prefix and let the user type the question instead of firing immediately
+    // with empty text.
+    if (cmd.category === 'app' && cmd.name !== 'btw') {
       handleAppCommand(cmd)
     } else {
       setMessage(`/${cmd.name} `)
+      setInputContent(`/${cmd.name} `)
       setShowPalette(false)
       inputRef?.focus()
+      setCursorToEnd()
     }
   }
 
@@ -1308,7 +1324,7 @@ export const MessageInput: Component<Props> = (props) => {
       const msg = message().trim()
       if (msg.startsWith('/')) {
         const cmdName = msg.slice(1).split(/\s+/)[0]
-        const appCmds = ['new-session', 'clear', 'plan']
+        const appCmds = ['new-session', 'clear', 'plan', 'btw']
         if (appCmds.includes(cmdName)) {
           handleAppCommand({ name: cmdName, description: '', category: 'app' })
           return