chore(sync): merge pingdotgg/t3code main

apps/mobile/src/features/home/ThreadUndoNotice.android.tsx

@@ -0,0 +1,128 @@
+import { useLayoutEffect, useState } from "react";
+import { StyleSheet, View } from "react-native";
+import { GestureDetector, usePanGesture } from "react-native-gesture-handler";
+import Animated, {
+  cancelAnimation,
+  Easing,
+  FadeOut,
+  ReduceMotion,
+  runOnJS,
+  useAnimatedStyle,
+  useSharedValue,
+  withTiming,
+  type EntryAnimationsValues,
+} from "react-native-reanimated";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { Toast } from "../../components/ui/Toast";
+import { MOBILE_MOTION } from "../../lib/designTokens";
+import {
+  dismissThreadUndoNotice,
+  readThreadUndoNotice,
+  useThreadUndoNotice,
+} from "./thread-undo-notice";
+
+const SWIPE_TIMING = { duration: 160, reduceMotion: ReduceMotion.System };
+const ENTER_TIMING = {
+  duration: MOBILE_MOTION.enter,
+  easing: Easing.out(Easing.cubic),
+  reduceMotion: ReduceMotion.System,
+};
+const NOTICE_EXITING = FadeOut.duration(MOBILE_MOTION.exit).reduceMotion(ReduceMotion.System);
+const noticeEntering = (values: EntryAnimationsValues) => {
+  "worklet";
+  return {
+    initialValues: { originY: values.targetOriginY + values.targetHeight + 12 },
+    animations: { originY: withTiming(values.targetOriginY, ENTER_TIMING) },
+  };
+};
+
+export function ThreadUndoNotice(props: { readonly visible: boolean }) {
+  const notice = useThreadUndoNotice();
+  // Replacing a notice must also cancel the native gesture tracking the old one.
+  const [instance, setInstance] = useState({ notice, key: 0 });
+  if (instance.notice !== notice) setInstance({ notice, key: instance.key + 1 });
+  if (!props.visible || notice === null) return null;
+  return <SwipeableUndoNotice key={instance.key} notice={notice} />;
+}
+
+function SwipeableUndoNotice(props: {
+  readonly notice: NonNullable<ReturnType<typeof useThreadUndoNotice>>;
+}) {
+  const { notice } = props;
+  const insets = useSafeAreaInsets();
+  const translation = useSharedValue(0);
+  const width = useSharedValue(0);
+
+  useLayoutEffect(
+    () => () => {
+      cancelAnimation(translation);
+    },
+    [translation],
+  );
+
+  const dismiss = () => {
+    // A newer action can replace the notice while the swipe is animating out.
+    if (readThreadUndoNotice() === notice) dismissThreadUndoNotice();
+  };
+  const gesture = usePanGesture({
+    activeOffsetX: [-10, 10],
+    failOffsetY: [-12, 12],
+    onUpdate: (event) => {
+      translation.set(event.translationX);
+    },
+    onDeactivate: (event) => {
+      if (
+        !event.canceled &&
+        (Math.abs(event.translationX) > width.value * 0.25 ||
+          (Math.abs(event.velocityX) > 800 && event.translationX * event.velocityX > 0))
+      ) {
+        const direction = Math.sign(event.translationX || event.velocityX);
+        translation.set(
+          withTiming(direction * (width.value + 24), SWIPE_TIMING, (finished) => {
+            if (finished) runOnJS(dismiss)();
+          }),
+        );
+      } else {
+        translation.set(withTiming(0, SWIPE_TIMING));
+      }
+    },
+  });
+  const animatedStyle = useAnimatedStyle(() => ({
+    transform: [{ translateX: translation.value }],
+  }));
+
+  // Clip the entrance above navigation; the notice intentionally covers the anchored FAB.
+  return (
+    <Animated.View
+      className="absolute inset-x-3 z-[100] overflow-hidden"
+      style={{ bottom: insets.bottom + 12 }}
+      pointerEvents="box-none"
+      exiting={NOTICE_EXITING}
+      onLayout={(event) => {
+        width.set(event.nativeEvent.layout.width);
+      }}
+    >
+      <GestureDetector gesture={gesture}>
+        <Animated.View collapsable={false} entering={noticeEntering} style={animatedStyle}>
+          {/* Keep the dismiss target separate so TalkBack can also focus Undo. */}
+          <View
+            accessible
+            accessibilityRole="alert"
+            accessibilityLiveRegion="assertive"
+            accessibilityLabel={`${notice.action} thread`}
+            accessibilityActions={[{ name: "dismiss", label: "Dismiss message" }]}
+            onAccessibilityAction={({ nativeEvent }) => {
+              if (nativeEvent.actionName === "dismiss") dismiss();
+            }}
+            pointerEvents="none"
+            style={StyleSheet.absoluteFill}
+          />
+          <Toast
+            message={`${notice.action} thread`}
+            action={{ label: "Undo", onPress: () => void notice.undo() }}
+          />
+        </Animated.View>
+      </GestureDetector>
+    </Animated.View>
+  );
+}

apps/mobile/src/features/threads/ThreadDetailScreen.tsx

@@ -55,6 +55,7 @@ import {
 } from "@t3tools/shared/codexArtifactTemplates";
 import {
   declinePendingApprovals,
+  sendApprovalFeedback,
   type ApprovalResponder,
   type ThreadUserInputQuestion,
 } from "@t3tools/client-runtime/state/thread-requests";
@@ -264,7 +265,10 @@ export interface ThreadDetailScreenProps {
   readonly onResumeQueue: (() => Promise<void>) | null;
   readonly onSendMessage: (
     followUp?: ActiveTurnComposerAction,
-    beforeDispatch?: () => Promise<boolean>,
+    beforeDispatch?: (
+      text: string,
+      hasAttachmentsOrContext: boolean,
+    ) => Promise<boolean | "responded">,
   ) => Promise<MessageId | null>;
   readonly onReconnectEnvironment: () => void;
   readonly canSwitchThreadProvider: boolean;
@@ -1213,18 +1217,40 @@ export const ThreadDetailScreen = function ThreadDetailScreen(props: ThreadDetai
     const approvalsToDecline = props.activePendingApprovals;
     const declineBeforeDispatch =
       approvalsToDecline.length > 0 && props.activePendingUserInput === null
-        ? async () =>
-            props.respondingApprovalId === null &&
-            (await declinePendingApprovals(approvalsToDecline, props.onRespondToApproval)) &&
-            selectedThreadKeyRef.current === targetThreadKey &&
-            // A draft edited or pasted into during the decline isn't what the user sent.
-            stillSendable?.() !== false &&
-            // An approval that arrived during the decline would block the redirect; the draft
-            // stays so the next send declines it too.
-            !activePendingApprovalsRef.current.some(
-              (approval) =>
-                !approvalsToDecline.some((declined) => declined.requestId === approval.requestId),
+        ? async (text: string, hasAttachmentsOrContext: boolean) => {
+            if (
+              selectedThreadKeyRef.current !== targetThreadKey ||
+              stillSendable?.() === false ||
+              props.respondingApprovalId !== null
             )
+              return false;
+            const feedbackTarget = approvalsToDecline[0];
+            if (feedbackTarget?.supportsFeedback) {
+              if (hasAttachmentsOrContext) {
+                Dialog.alert(
+                  "Approval feedback",
+                  "Send approval feedback without attachments or added context.",
+                );
+                return false;
+              }
+              return (await sendApprovalFeedback(feedbackTarget, text, props.onRespondToApproval))
+                ? ("responded" as const)
+                : false;
+            }
+            return (
+              props.respondingApprovalId === null &&
+              (await declinePendingApprovals(approvalsToDecline, props.onRespondToApproval)) &&
+              selectedThreadKeyRef.current === targetThreadKey &&
+              // A draft edited or pasted into during the decline isn't what the user sent.
+              stillSendable?.() !== false &&
+              // An approval that arrived during the decline would block the redirect; the draft
+              // stays so the next send declines it too.
+              !activePendingApprovalsRef.current.some(
+                (approval) =>
+                  !approvalsToDecline.some((declined) => declined.requestId === approval.requestId),
+              )
+            );
+          }
         : undefined;
     const messageId = await props.onSendMessage(followUp, declineBeforeDispatch);
     if (messageId === null || selectedThreadKeyRef.current !== targetThreadKey) {
@@ -1659,7 +1685,9 @@ export const ThreadDetailScreen = function ThreadDetailScreen(props: ThreadDetai
                         editorRef={composerEditorRef}
                         placeholder={
                           props.activePendingApproval
-                            ? "Send a message to decline and redirect the agent"
+                            ? props.activePendingApproval.supportsFeedback
+                              ? "Send feedback to decline this request"
+                              : "Send a message to decline and redirect the agent"
                             : "Ask the repo agent, or run a command…"
                         }
                         contentMaxWidth={contentMaxWidth}

apps/mobile/src/state/thread-task-permissions.test.ts

@@ -18,6 +18,7 @@ import {
 } from "../../../../packages/client-runtime/src/state/orchestrationV2TestFixtures";
 import type { DraftComposerImageAttachment } from "../lib/composerImages";
 import type { PendingThreadRequests } from "@t3tools/client-runtime/state/thread-requests";
+import { sendApprovalFeedback } from "@t3tools/client-runtime/state/thread-requests";
 import { AsyncResult, type Atom } from "effect/reactivity";
 import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
 
@@ -202,6 +203,43 @@ beforeEach(() => {
 });
 
 describe("mobile task permissions", () => {
+  it("consumes an approval reply without queueing a parent message", async () => {
+    state.grantedEnvironments.add("secondary");
+    const composer = useThreadComposerState();
+    const requests = useSelectedThreadRequests();
+    const approval = { ...state.pendingRequests.approvals[0]!, supportsFeedback: true };
+    const messageId = await composer.onSendMessage(undefined, async (text) =>
+      (await sendApprovalFeedback(approval, text, requests.onRespondToApproval))
+        ? "responded"
+        : false,
+    );
+    expect(messageId).toBeNull();
+    expect(state.approve).toHaveBeenCalledWith({
+      environmentId: "secondary",
+      input: {
+        threadId: "thread",
+        requestId: "approval",
+        decision: "decline",
+        feedback: "Keep my draft",
+      },
+    });
+    expect(state.enqueue).not.toHaveBeenCalled();
+    expect(state.clearDraft).toHaveBeenCalledOnce();
+  });
+
+  it("preserves a draft changed during an approval reply and never sends it to the parent", async () => {
+    state.grantedEnvironments.add("secondary");
+    const composer = useThreadComposerState();
+    const beforeDispatch = async () => {
+      state.draft = { ...state.draft, text: "New feedback" };
+      return "responded" as const;
+    };
+    expect(await composer.onSendMessage(undefined, beforeDispatch)).toBeNull();
+    expect(state.enqueue).not.toHaveBeenCalled();
+    expect(state.clearDraft).not.toHaveBeenCalled();
+    expect(state.draft.text).toBe("New feedback");
+  });
+
   it("keeps a connected read-only task's draft instead of queueing it with another environment's grant", async () => {
     const composer = useThreadComposerState();
     expect(await composer.onSendMessage()).toBeNull();

apps/mobile/src/state/use-selected-thread-requests.ts

@@ -236,7 +236,7 @@ export function useSelectedThreadRequests() {
   );
 
   const onRespondToApproval = useCallback(
-    async (requestId: RuntimeRequestId, decision: ProviderApprovalDecision) => {
+    async (requestId: RuntimeRequestId, decision: ProviderApprovalDecision, feedback?: string) => {
       if (
         !selectedThreadShell ||
         !readEnvironmentScope(selectedThreadShell.environmentId, AuthOrchestrationOperateScope)
@@ -257,6 +257,7 @@ export function useSelectedThreadRequests() {
           threadId: selectedThreadShell.id,
           requestId,
           decision,
+          ...(feedback === undefined ? {} : { feedback }),
         },
       });
       setRespondingApprovalId((current) => (current === requestId ? null : current));

apps/mobile/src/state/use-thread-composer-state.ts

@@ -527,7 +527,10 @@ export function useThreadComposerState() {
 
   const onSendMessage = async (
     followUpOverride?: ActiveTurnComposerAction,
-    beforeDispatch?: () => Promise<boolean>,
+    beforeDispatch?: (
+      text: string,
+      hasAttachmentsOrContext: boolean,
+    ) => Promise<boolean | "responded">,
   ) => {
     if (
       selectedThreadShell &&
@@ -646,7 +649,11 @@ export function useThreadComposerState() {
     }
 
     if (beforeDispatch !== undefined) {
-      if (!(await beforeDispatch())) return null;
+      const response = await beforeDispatch(
+        text,
+        attachments.length > 0 || draft.context !== undefined,
+      );
+      if (!response) return null;
       // A context paste still landing, or any draft or settings change while approvals were
       // declined, means this snapshot is no longer what the user sent.
       if (appAtomRegistry.get(composerContextImportsAtom)[threadKey]) return null;
@@ -661,6 +668,10 @@ export function useThreadComposerState() {
         current.attachments.some((attachment, index) => attachment.id !== attachments[index]?.id)
       )
         return null;
+      if (response === "responded") {
+        clearComposerDraftContent(threadKey);
+        return null;
+      }
     }
 
     // Resolved here rather than at drain time: the outbox can deliver minutes

apps/server/integration/transferBudgetV2.integration.test.ts

@@ -89,6 +89,8 @@ const layerManagement = Layer.unwrap(
         projections.getThreadSnapshotWindow(id, options).pipe(Effect.orDie),
       getThreadShell: (id) => projections.getThreadShell(id).pipe(Effect.orDie),
       getShellSnapshot: (options) => projections.getShellSnapshot(options).pipe(Effect.orDie),
+      listActiveSubagentThreadIds: () =>
+        projections.listActiveSubagentThreadIds().pipe(Effect.orDie),
       readShellSnapshot: (options) =>
         projections.readShellSnapshot(options).pipe(Effect.map(Effect.orDie), Effect.orDie),
       streamStoredEventsFrom: (input) =>

apps/server/src/mcp/AcpMcpStdioBridge.test.ts

@@ -2,10 +2,11 @@
 import * as NodeStream from "node:stream";
 
 import { describe, expect, it } from "@effect/vitest";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
 
-import { runAcpMcpStdioBridge } from "./AcpMcpStdioBridge.ts";
+import { mcpToolSession, runAcpMcpStdioBridge } from "./AcpMcpStdioBridge.ts";
 
 function makeHarness(responder: (request: Request) => Promise<Response> | Response) {
   const input = new NodeStream.PassThrough();
@@ -29,6 +30,13 @@ function makeHarness(responder: (request: Request) => Promise<Response> | Respon
   return { input, written, requests, bridge };
 }
 
+function pendingFetch(started: Deferred.Deferred<AbortSignal | undefined>) {
+  return (_url: string, init?: RequestInit): Promise<Response> => {
+    Deferred.doneUnsafe(started, Effect.succeed(init?.signal ?? undefined));
+    return new Promise(() => {});
+  };
+}
+
 describe("AcpMcpStdioBridge", () => {
   it.effect("forwards requests and replays the session id and protocol version", () =>
     Effect.gen(function* () {
@@ -282,4 +290,43 @@ describe("AcpMcpStdioBridge", () => {
       expect(JSON.parse(written[0]!)).toMatchObject({ id: 7, result: {} });
     }),
   );
+
+  it.effect("aborts the pending fetch when a tool call is interrupted", () =>
+    Effect.gen(function* () {
+      const started = yield* Deferred.make<AbortSignal | undefined>();
+      const fiber = yield* mcpToolSession({
+        endpoint: "http://127.0.0.1:1/mcp",
+        authorization: "Bearer bridge-test",
+        clientName: "t3-code-acp-cli",
+        fetchImplementation: pendingFetch(started),
+      }).pipe(
+        Effect.flatMap((session) => session.call("orchestrator_capabilities", {})),
+        Effect.scoped,
+        Effect.forkChild,
+      );
+
+      const signal = yield* Deferred.await(started);
+      yield* Fiber.interrupt(fiber);
+      expect(signal?.aborted).toBe(true);
+    }),
+  );
+
+  it.effect("aborts the pending fetch when the stdio bridge is interrupted", () =>
+    Effect.gen(function* () {
+      const started = yield* Deferred.make<AbortSignal | undefined>();
+      const input = new NodeStream.PassThrough();
+      const fiber = yield* runAcpMcpStdioBridge({
+        endpoint: "http://127.0.0.1:1/mcp",
+        authorization: "Bearer bridge-test",
+        input,
+        output: { write: () => undefined },
+        fetchImplementation: pendingFetch(started),
+      }).pipe(Effect.forkChild);
+
+      input.write(`${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" })}\n`);
+      const signal = yield* Deferred.await(started);
+      yield* Fiber.interrupt(fiber);
+      expect(signal?.aborted).toBe(true);
+    }),
+  );
 });