chore: sync with upstream pingdotgg/t3code main

apps/mobile/src/features/settings/SettingsRouteScreen.tsx

@@ -19,7 +19,6 @@ import { Platform, View } from "react-native";
 import { useWorkspaceSurface } from "../workspace/useWorkspaceSurface";
 import { useDeviceType } from "../../native/native-layout-metrics";
 import { useCompactWorkspaceTabs } from "../workspace/useSystemWorkspaceTabBar";
-import { NativeStackScreenOptions } from "../../native/StackHeader";
 import { deriveProjectGroupLabel } from "@t3tools/client-runtime/state/project-grouping";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 
@@ -47,15 +46,6 @@ export function SettingsRouteScreen() {
 
   return (
     <View className={`flex-1 ${surface.className}`}>
-      {Platform.OS === "ios" ? (
-        <NativeStackScreenOptions
-          options={{
-            headerTransparent: false,
-            headerStyle: { backgroundColor: surface.backgroundColor },
-            contentStyle: { backgroundColor: surface.backgroundColor },
-          }}
-        />
-      ) : null}
       <SettingsEnvironmentFilterHeader />
       <ScreenScrollViewBottomInset value={deviceType === "pad" || compactTabs ? 80 : 0}>
         {Platform.OS === "android" ? (

apps/mobile/src/features/settings/components/SettingsScreen.tsx

@@ -8,7 +8,6 @@ import { ScreenContent as SettingsScreenContent } from "../../../components/ui/S
 import { useWorkspaceTabs } from "../../workspace/WorkspaceTabsContext";
 import { useWorkspaceSurface } from "../../workspace/useWorkspaceSurface";
 import { useDeviceType } from "../../../native/native-layout-metrics";
-import { NativeStackScreenOptions } from "../../../native/StackHeader";
 import { useCompactWorkspaceTabs } from "../../workspace/useSystemWorkspaceTabBar";
 import { ScreenScrollViewBottomInset } from "../../../components/ui/ScreenScrollView";
 
@@ -47,15 +46,6 @@ export function SettingsScreen(
         onBack={workspaceRoot ? undefined : () => navigation.goBack()}
         hideBottomBorder={!props.formSheet}
       />
-      {Platform.OS === "ios" && (workspaceRoot || cover) ? (
-        <NativeStackScreenOptions
-          options={{
-            headerTransparent: false,
-            headerStyle: { backgroundColor: surface.backgroundColor },
-            contentStyle: { backgroundColor: surface.backgroundColor },
-          }}
-        />
-      ) : null}
       <ScreenScrollViewBottomInset value={deviceType === "pad" || compactTabs ? 80 : 0}>
         {props.formSheet ? (
           props.children

apps/mobile/src/features/usage/UsageRouteScreen.tsx

@@ -56,6 +56,7 @@ import { UsageLimitsSection } from "./UsageLimitsPooled";
 import { Menu } from "../../components/ui/Menu";
 import { SymbolView } from "../../components/ui/AppSymbol";
 import { NativeStackScreenOptions } from "../../native/StackHeader";
+import { withNativeGlassHeaderItem } from "../layout/native-glass-header-items";
 import type { UsageChartMetric } from "./usageChartData";
 import { PROVIDER_LABEL, useProviderColors, useUsageMixColors } from "./usageProviders";
 
@@ -245,8 +246,31 @@ function UsageScreen(props: {
     <SettingsScreen title="Usage" trailing={environmentFilter} workspaceRoot={props.workspace}>
       {Platform.OS === "ios" ? (
         <NativeStackScreenOptions
-          optionsVersion={environmentFilter}
-          options={{ headerRight: () => environmentFilter }}
+          optionsVersion={JSON.stringify({ showEnvironmentFilter, filterIcon, environmentActions })}
+          options={{
+            // A native menu item, unlike a custom view, moves into the Duo's vertical bar.
+            unstable_headerRightItems: () =>
+              showEnvironmentFilter
+                ? [
+                    withNativeGlassHeaderItem({
+                      accessibilityLabel: "Filter usage environments",
+                      icon: { name: filterIcon, type: "sfSymbol" },
+                      label: "",
+                      type: "menu",
+                      menu: {
+                        title: "Environments",
+                        items: environmentActions.map((action) => ({
+                          type: "action" as const,
+                          label: action.title,
+                          description: action.subtitle,
+                          state: action.state === "on" ? ("on" as const) : undefined,
+                          onPress: () => selectEnvironment(action.id),
+                        })),
+                      },
+                    }),
+                  ]
+                : [],
+          }}
         />
       ) : null}
       <ScrollView

apps/mobile/src/features/workspace/WorkspaceExtraTab.tsx

@@ -7,9 +7,7 @@ export function WorkspaceExtraTab(_props: {
 }) {
   return (
     <>
-      <NativeStackScreenOptions
-        options={{ headerSearchBarOptions: undefined, unstable_headerRightItems: undefined }}
-      />
+      <NativeStackScreenOptions options={{ headerSearchBarOptions: undefined }} />
       <UsageRouteScreen workspace />
     </>
   );

apps/mobile/src/features/workspace/WorkspaceRootScreen.tsx

@@ -93,7 +93,6 @@ function WorkspaceRootContent() {
   const keyboardHeight = useKeyboardState((keyboard) => keyboard.height);
   const workspace = useWorkspaceTabs()!;
   const { state } = workspace;
-  const solidHeader = deviceType === "duo-folded" || state.selectedTab === "usage";
   const renderHeaderTitle = useCallback(
     () => (
       <WorkspaceRootTitle
@@ -150,16 +149,11 @@ function WorkspaceRootContent() {
             options={{
               title: enabled.length ? TAB_TITLES[state.selectedTab] : "Navigation",
               headerShown: true,
-              headerTransparent: solidHeader ? false : NATIVE_LIQUID_GLASS_SUPPORTED,
-              headerStyle: solidHeader
-                ? { backgroundColor: surface.backgroundColor }
-                : NATIVE_LIQUID_GLASS_SUPPORTED
-                  ? { backgroundColor: "transparent" }
-                  : undefined,
-              contentStyle: solidHeader ? { backgroundColor: surface.backgroundColor } : undefined,
-              ...(state.selectedTab !== "usage" || enabled.length === 0
-                ? { headerRight: undefined }
-                : {}),
+              headerTransparent: NATIVE_LIQUID_GLASS_SUPPORTED,
+              headerStyle: NATIVE_LIQUID_GLASS_SUPPORTED
+                ? { backgroundColor: "transparent" }
+                : undefined,
+              contentStyle: undefined,
               ...(enabled.length === 0
                 ? { headerSearchBarOptions: undefined, unstable_headerRightItems: () => [] }
                 : {}),

apps/server/src/mcp/McpHttpServer.ts

@@ -816,9 +816,10 @@ const handoffTargetIds = (
 };
 
 /**
- * Runs a tool registration against a server that records one anonymous
- * `mcp.tool.invoked` event per call: the tool, the calling agent's provider,
- * the outcome with its failure code, and the duration. A handoff tool also
+ * Runs a tool registration against a server that records an anonymous
+ * `mcp.tool.invoked` event for every handoff call and every failed call of
+ * other tools: the tool, the calling agent's provider, the outcome with its
+ * failure code, and the duration. A handoff tool also
  * reports the caller's model, origin, and delegation depth, the settings the
  * agent chose, and the provider, model, and modes of each thread that received
  * the work. Ids, prompts, and free text are never recorded.
@@ -882,14 +883,18 @@ const withToolAnalytics =
           result: McpSchema.CallToolResult | undefined,
           durationMs: number,
         ) {
+          const handoff = HANDOFF_TOOLS.has(tool);
+          const outcome = toolOutcome(result);
+          // Agents call status, read, and preview tools in tight loops, so an
+          // event per successful call floods analytics. Only failures count there.
+          if (!handoff && outcome.outcome === "ok") return;
           // Client credentials (no calling thread) report an unknown caller.
           const invocation = Option.getOrUndefined(
             yield* Effect.serviceOption(McpInvocationContext.McpInvocationContext),
           )?.thread;
           const providers = Option.isSome(registry) ? yield* registry.value.getProviders : [];
           // Only handoff tools pay for thread lookups; the rest report the
           // caller's provider from the credential.
-          const handoff = HANDOFF_TOOLS.has(tool);
           const caller =
             handoff && invocation !== undefined
               ? ((yield* shellOf(invocation.threadId)) ?? undefined)
@@ -917,7 +922,7 @@ const withToolAnalytics =
                   ),
                 }),
             targets: targets.filter((thread) => thread !== null),
-            outcome: toolOutcome(result),
+            outcome,
             ...(handoff
               ? { settings: handoffSettings(tool, args, result?.structuredContent) }
               : {}),

apps/server/src/mcp/toolkits/core.test.ts

@@ -18,6 +18,7 @@ import {
   type OrchestrationV2ThreadShell,
 } from "@t3tools/contracts";
 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as TestClock from "effect/testing/TestClock";
 import * as Layer from "effect/Layer";
@@ -48,6 +49,7 @@ import * as ServerSettings from "../../serverSettings.ts";
 import * as McpHttpServer from "../McpHttpServer.ts";
 import * as McpInvocationContext from "../McpInvocationContext.ts";
 import * as McpToolAccessTestkit from "../McpToolAccess.testkit.ts";
+import * as AnalyticsService from "../../telemetry/AnalyticsService.ts";
 import { dispatchFailure } from "../threadAccess.ts";
 import * as EnvironmentHandlers from "./environment/handlers.ts";
 import * as AttachmentHandlers from "./attachment/handlers.ts";
@@ -287,6 +289,61 @@ it.effect("returns an HTML render reference that Codex and Claude tool rows both
   ),
 );
 
+it.effect("records only failed calls of tools that hand off no work", () => {
+  // Recording runs detached from the tool response, so the first event is awaited.
+  const recorded = Deferred.makeUnsafe<{ event: string; properties: object }>();
+  return Effect.gen(function* () {
+    const server = yield* McpServer.McpServer;
+    const organize = (capabilities: McpInvocationContext.McpInvocationScope["capabilities"]) =>
+      server.callTool({ name: "t3_thread_organize", arguments: { action: "pin" } }).pipe(
+        Effect.provideService(McpInvocationContext.McpInvocationContext, {
+          ...scope,
+          capabilities,
+        }),
+        Effect.provideService(McpSchema.McpServerClient, client),
+      );
+    expect((yield* organize(scope.capabilities)).isError).not.toBe(true);
+    expect(declaredFailure(yield* organize(new Set<never>()))).toMatchObject({
+      code: "capability_denied",
+    });
+    // The successful call ran first, so it would be the first event if it were recorded.
+    expect(yield* Deferred.await(recorded)).toMatchObject({
+      event: "mcp.tool.invoked",
+      properties: { tool: "t3_thread_organize", outcome: "error" },
+    });
+  }).pipe(
+    Effect.provide(
+      layerThreadToolkit.pipe(
+        Layer.provideMerge(McpServer.McpServer.layer),
+        Layer.provide(NodeCrypto.layer),
+        Layer.provide(
+          Layer.mock(ThreadManagement.ThreadManagementService)({
+            getThreadShell: (id) => Effect.succeed(McpToolAccessTestkit.liveThreadShell(id)),
+            getProjectThreadRecords: ({ threadId: id }) =>
+              Effect.succeed(
+                McpToolAccessTestkit.idleThreadProjection(McpToolAccessTestkit.liveThreadShell(id)),
+              ),
+            dispatch: () => Effect.succeed({ sequence: 1 } as never),
+          }),
+        ),
+        Layer.provide(
+          Layer.succeed(
+            AnalyticsService.AnalyticsService,
+            AnalyticsService.AnalyticsService.of({
+              record: (event, properties) =>
+                Deferred.succeed(recorded, { event, properties: properties ?? {} }).pipe(
+                  Effect.asVoid,
+                ),
+              flush: Effect.void,
+              recordOwners: () => Effect.void,
+            }),
+          ),
+        ),
+      ),
+    ),
+  );
+});
+
 it.effect("keeps unexpected handler defects private through the production registration", () =>
   Effect.gen(function* () {
     const server = yield* McpServer.McpServer;