fix(wizard-ros): use executeSSH for animations to bypass studyId requirement

- Add startTime parameter to executeRobotActionInternal for proper duration tracking
- SSH actions (animations, posture commands) now work without ROS bridge connection
- Refactor executeAction to handle SSH and ROS paths separately

.env.example

@@ -16,11 +16,19 @@
 AUTH_SECRET=""
 
 # Drizzle
-DATABASE_URL="postgresql://postgres:password@localhost:5433/hristudio"
+DATABASE_URL="postgresql://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@localhost:${POSTGRES_PORT:-5432}/${POSTGRES_DB:-hristudio}"
+
+# PostgreSQL (used by docker-compose)
+POSTGRES_USER="postgres"
+POSTGRES_PASSWORD="postgres"
+POSTGRES_DB="hristudio"
+POSTGRES_PORT="5432"
 
 # MinIO/S3 Configuration
-MINIO_ENDPOINT="http://localhost:9000"
+MINIO_ENDPOINT="http://localhost:${MINIO_PORT_API:-9000}"
 MINIO_REGION="us-east-1"
 MINIO_ACCESS_KEY="minioadmin"
 MINIO_SECRET_KEY="minioadmin"
 MINIO_BUCKET_NAME="hristudio-data"
+MINIO_PORT_API="9000"
+MINIO_PORT_CONSOLE="9001"

docker-compose.yml

@@ -2,13 +2,13 @@ services:
   db:
     image: postgres:15
     environment:
-      POSTGRES_USER: postgres
+      POSTGRES_USER: ${POSTGRES_USER:-postgres}
-      POSTGRES_PASSWORD: postgres
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
-      POSTGRES_DB: hristudio
+      POSTGRES_DB: ${POSTGRES_DB:-hristudio}
       PGSSLMODE: disable
     command: -c ssl=off
     ports:
-      - "5140:5432"
+      - "${POSTGRES_PORT:-5432}:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
     healthcheck:
@@ -20,11 +20,11 @@ services:
   minio:
     image: minio/minio
     ports:
-      - "9000:9000" # API
+      - "${MINIO_PORT_API:-9000}:9000" # API
-      - "9001:9001" # Console
+      - "${MINIO_PORT_CONSOLE:-9001}:9001" # Console
     environment:
-      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_USER: ${MINIO_ACCESS_KEY:-minioadmin}
-      MINIO_ROOT_PASSWORD: minioadmin
+      MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY:-minioadmin}
     volumes:
       - minio_data:/data
     command: server --console-address ":9001" /data
@@ -35,9 +35,9 @@ services:
       - minio
     entrypoint: >
       /bin/sh -c "
-      /usr/bin/mc alias set myminio http://minio:9000 minioadmin minioadmin;
+      /usr/bin/mc alias set myminio http://minio:9000 ${MINIO_ACCESS_KEY:-minioadmin} ${MINIO_SECRET_KEY:-minioadmin};
-      /usr/bin/mc mb myminio/hristudio-data;
+      /usr/bin/mc mb myminio/${MINIO_BUCKET_NAME:-hristudio-data};
-      /usr/bin/mc anonymous set public myminio/hristudio-data;
+      /usr/bin/mc anonymous set public myminio/${MINIO_BUCKET_NAME:-hristudio-data};
       exit 0;
       "
 

package.json

@@ -5,22 +5,26 @@
   "type": "module",
   "scripts": {
     "build": "next build",
-    "check": "next lint && tsc --noEmit",
+    "check": "eslint . && tsc --noEmit",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "db:push": "drizzle-kit push",
     "db:studio": "drizzle-kit studio",
     "db:seed": "bun db:push && bun scripts/seed-dev.ts",
-    "dev": "bun run ws-server.ts & next dev --turbo",
+    "db:reset": "docker compose rm -s -f -v db && docker compose up -d db && sleep 2 && bun db:seed",
+    "db:restart": "docker compose restart db",
+    "dev": "bun run dev:ws & next dev",
     "dev:ws": "bun run ws-server.ts",
     "docker:up": "if [ \"$(uname)\" = \"Darwin\" ]; then colima start; fi && docker compose up -d",
     "docker:down": "docker compose down && if [ \"$(uname)\" = \"Darwin\" ]; then colima stop; fi",
     "format:check": "prettier --check \"**/*.{ts,tsx,js,jsx,mdx}\" --cache",
     "format:write": "prettier --write \"**/*.{ts,tsx,js,jsx,mdx}\" --cache",
-    "lint": "next lint",
+    "lint": "eslint .",
-    "lint:fix": "next lint --fix",
+    "lint:fix": "eslint . --fix",
     "preview": "next build && next start",
-    "start": "next start",
+    "start": "bun run start:ws & next start",
+    "start:ws": "bun run ws-server.ts",
+    "start:web": "next start",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {

src/app/api/robots/command/route.ts

@@ -89,6 +89,50 @@ export async function POST(request: NextRequest) {
             command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "python2 -c \\"import sys; sys.path.append('/opt/aldebaran/lib/python2.7/site-packages'); import naoqi; m = naoqi.ALProxy('ALMotion', '127.0.0.1', 9559); m.rest()\\""`;
             break;
 
+          case "play_animation_bow":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALAnimationPlayer.run 'animations/Stand/Gestures/BowShort_1'"`;
+            break;
+
+          case "play_animation_hey":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALAnimationPlayer.run 'animations/Stand/Gestures/Hey_1'"`;
+            break;
+
+          case "play_animation_show_floor":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALAnimationPlayer.run 'animations/Stand/Gestures/ShowFloor_1'"`;
+            break;
+
+          case "play_animation_enthusiastic":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALAnimationPlayer.run 'animations/Stand/Gestures/Enthusiastic_4'"`;
+            break;
+
+          case "play_animation_yes":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALAnimationPlayer.run 'animations/Stand/Gestures/Yes_1'"`;
+            break;
+
+          case "play_animation_no":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALAnimationPlayer.run 'animations/Stand/Gestures/No_3'"`;
+            break;
+
+          case "play_animation_idontknow":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALAnimationPlayer.run 'animations/Stand/Gestures/IDontKnow_1'"`;
+            break;
+
+          case "stand":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALRobotPosture.goToPosture Stand 0.5"`;
+            break;
+
+          case "stand_init":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALRobotPosture.goToPosture StandInit 0.5"`;
+            break;
+
+          case "sit":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALRobotPosture.goToPosture Sit 0.5"`;
+            break;
+
+          case "crouch":
+            command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no "nao@${robotIp}" "qicli call ALRobotPosture.goToPosture Crouch 0.5"`;
+            break;
+
           default:
             return NextResponse.json(
               { error: `System action ${id} not implemented` },
@@ -100,6 +144,35 @@ export async function POST(request: NextRequest) {
         return NextResponse.json({ success: true });
       }
 
+      case "executeSSH": {
+        const { command } = parameters ?? {};
+        if (!command) {
+          return NextResponse.json(
+            { error: "Missing command parameter" },
+            { status: 400 },
+          );
+        }
+
+        console.log(`[Robots API] Executing SSH command: ${command}`);
+
+        const sshCmd = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no -o ConnectTimeout=10 "nao@${robotIp}" "${command}"`;
+
+        try {
+          const { stdout, stderr } = await execAsync(sshCmd);
+          if (stderr && !stderr.includes("null") && stderr.trim()) {
+            console.warn(`[Robots API] SSH stderr: ${stderr}`);
+          }
+          console.log(`[Robots API] SSH result: ${stdout}`);
+          return NextResponse.json({ success: true, stdout, stderr });
+        } catch (error) {
+          console.error(`[Robots API] SSH command failed:`, error);
+          return NextResponse.json(
+            { error: error instanceof Error ? error.message : "SSH command failed" },
+            { status: 500 },
+          );
+        }
+      }
+
       default:
         return NextResponse.json(
           { error: `Unknown action: ${action}` },

src/components/experiments/ExperimentForm.tsx

@@ -34,8 +34,8 @@ const experimentSchema = z.object({
     .max(100, "Name too long"),
   description: z
     .string()
-    .min(10, "Description must be at least 10 characters")
+    .max(1000, "Description too long")
-    .max(1000, "Description too long"),
+    .optional(),
   studyId: z.string().uuid("Please select a study"),
   estimatedDuration: z
     .number()
@@ -123,7 +123,7 @@ export function ExperimentForm({ mode, experimentId }: ExperimentFormProps) {
     if (mode === "edit" && experiment) {
       form.reset({
         name: experiment.name,
-        description: experiment.description ?? "",
+        description: experiment.description ?? undefined,
         studyId: experiment.studyId,
         estimatedDuration: experiment.estimatedDuration ?? undefined,
         status: experiment.status,

src/components/experiments/designer/DesignerRoot.tsx

@@ -1079,14 +1079,18 @@ export function DesignerRoot({
           }
         }
 
+        const defExec = actionDef.execution as any;
         const execution: ExperimentAction["execution"] =
-          actionDef.execution &&
+          defExec &&
-          (actionDef.execution.transport === "internal" ||
+          (defExec.transport === "internal" ||
-            actionDef.execution.transport === "rest" ||
+            defExec.transport === "rest" ||
-            actionDef.execution.transport === "ros2")
+            defExec.transport === "ros2")
             ? {
-                transport: actionDef.execution.transport,
+                transport: defExec.transport,
-                retryable: actionDef.execution.retryable ?? false,
+                retryable: defExec.retryable ?? false,
+                timeoutMs: defExec.timeoutMs,
+                ros2: defExec.ros2,
+                rest: defExec.rest,
               }
             : undefined;
 

src/components/experiments/designer/PropertiesPanel.tsx

@@ -43,7 +43,14 @@ import {
   Plus,
   GitBranch,
   Trash2,
+  PlayCircle,
+  Square,
+  Loader2,
+  CheckCircle2,
+  XCircle,
 } from "lucide-react";
+import { toast } from "sonner";
+import { getWizardRosService, initWizardRosService, resetWizardRosService } from "~/lib/ros/wizard-ros-service";
 
 /**
  * PropertiesPanel
@@ -90,6 +97,10 @@ export function PropertiesPanelBase({
   const [localStepDescription, setLocalStepDescription] = useState("");
   const [localParams, setLocalParams] = useState<Record<string, unknown>>({});
 
+  // Test action state
+  const [isTesting, setIsTesting] = useState(false);
+  const [testStatus, setTestStatus] = useState<"idle" | "running" | "success" | "error">("idle");
+
   // Debounce timers
   const actionUpdateTimer = useRef<NodeJS.Timeout | undefined>(undefined);
   const stepUpdateTimer = useRef<NodeJS.Timeout | undefined>(undefined);
@@ -168,6 +179,74 @@ export function PropertiesPanelBase({
     selectedAction &&
     design.steps.find((s) => s.actions.some((a) => a.id === selectedAction.id));
 
+  // Test action handler
+  const handleTestAction = useCallback(async () => {
+    if (!selectedAction || !containingStep) return;
+
+    setIsTesting(true);
+    setTestStatus("running");
+
+    try {
+      console.log("[Test Action] Starting test for action:", selectedAction.name, selectedAction.type);
+      console.log("[Test Action] Execution config:", JSON.stringify(selectedAction.execution, null, 2));
+      console.log("[Test Action] Parameters:", selectedAction.parameters);
+
+      // Reset service to ensure clean state for testing
+      resetWizardRosService();
+      
+      // Initialize with actual robot connection (not simulation)
+      const rosService = await initWizardRosService(false);
+      console.log("[Test Action] ROS service initialized, connected:", rosService.getConnectionStatus());
+
+      // Build action config from execution descriptor
+      const execution = selectedAction.execution;
+      let actionConfig: {
+        topic: string;
+        messageType: string;
+        payloadMapping: {
+          type: string;
+          payload?: Record<string, unknown>;
+          transformFn?: string;
+        };
+      } | undefined;
+
+      if (execution?.transport === "ros2" && execution.ros2) {
+        const ros2 = execution.ros2 as any;
+        actionConfig = {
+          topic: ros2.topic || "/speech",
+          messageType: ros2.messageType || "std_msgs/msg/String",
+          payloadMapping: {
+            type: ros2.payloadMapping?.type || "static",
+            payload: ros2.payloadMapping?.payload,
+            transformFn: ros2.payloadMapping?.transformFn,
+          },
+        };
+        console.log("[Test Action] Action config built:", JSON.stringify(actionConfig, null, 2));
+      }
+
+      // Execute the action on the real robot
+      const result = await rosService.executeRobotAction(
+        selectedAction.source?.kind === "plugin" ? (selectedAction.source?.pluginId || "core") : "core",
+        selectedAction.type,
+        selectedAction.parameters,
+        actionConfig,
+      );
+      console.log("[Test Action] Execution result:", result);
+
+      setTestStatus("success");
+      toast.success(`Action "${selectedAction.name}" executed on robot`);
+    } catch (error) {
+      setTestStatus("error");
+      const message = error instanceof Error ? error.message : "Action execution failed";
+      toast.error(message);
+      console.error("Test action error:", error);
+    } finally {
+      setIsTesting(false);
+      // Reset status after a delay
+      setTimeout(() => setTestStatus("idle"), 2000);
+    }
+  }, [selectedAction, containingStep]);
+
   /* -------------------------- Action Properties View -------------------------- */
   if (selectedAction && containingStep) {
     let def = registry.getAction(selectedAction.type);
@@ -277,6 +356,41 @@ export function PropertiesPanelBase({
           )}
         </div>
 
+        {/* Test Action Button */}
+        {selectedAction.execution?.transport !== "internal" && (
+          <div className="flex items-center gap-2">
+            <Button
+              variant="outline"
+              size="sm"
+              className="w-full gap-1.5"
+              onClick={handleTestAction}
+              disabled={isTesting}
+            >
+              {testStatus === "running" ? (
+                <>
+                  <Loader2 className="h-4 w-4 animate-spin" />
+                  Running...
+                </>
+              ) : testStatus === "success" ? (
+                <>
+                  <CheckCircle2 className="h-4 w-4 text-green-500" />
+                  Success!
+                </>
+              ) : testStatus === "error" ? (
+                <>
+                  <XCircle className="h-4 w-4 text-red-500" />
+                  Failed
+                </>
+              ) : (
+                <>
+                  <PlayCircle className="h-4 w-4" />
+                  Test Action
+                </>
+              )}
+            </Button>
+          </div>
+        )}
+
         {/* General */}
         <div className="space-y-2">
           <div className="text-muted-foreground text-[10px] tracking-wide uppercase">
@@ -803,12 +917,13 @@ const ParameterEditor = React.memo(function ParameterEditor({
 
   if (param.type === "text") {
     control = (
-      <Input
+      <textarea
         value={(localValue as string) ?? ""}
         placeholder={param.placeholder}
         onChange={(e) => handleUpdate(e.target.value)}
         onBlur={handleCommit}
-        className="mt-1 h-7 w-full text-xs"
+        rows={3}
+        className="mt-1 w-full rounded-md border border-input bg-transparent px-3 py-2 text-xs shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50"
       />
     );
   } else if (param.type === "select") {
@@ -868,14 +983,24 @@ const ParameterEditor = React.memo(function ParameterEditor({
               max={max}
               step={step}
               value={[Number(numericVal)]}
-              onValueChange={(vals) => setLocalValue(vals[0])} // Update only local visual
+              onValueChange={(vals) => setLocalValue(vals[0])}
-              onPointerUp={() => handleUpdate(localValue)} // Commit on release
+              onPointerUp={() => handleUpdate(localValue)}
+            />
+            <Input
+              type="number"
+              value={Number(numericVal)}
+              min={min}
+              max={max}
+              step={step}
+              onChange={(e) => {
+                const v = parseFloat(e.target.value);
+                if (!isNaN(v)) {
+                  setLocalValue(Math.max(min, Math.min(max, v)));
+                }
+              }}
+              onBlur={handleCommit}
+              className="h-7 w-16 text-xs tabular-nums"
             />
-            <span className="text-muted-foreground min-w-[2.5rem] text-right text-[10px] tabular-nums">
-              {step < 1
-                ? Number(numericVal).toFixed(2)
-                : Number(numericVal).toString()}
-            </span>
           </div>
           <div className="text-muted-foreground mt-1 flex justify-between text-[10px]">
             <span>{min}</span>

src/components/trials/TrialForm.tsx

@@ -11,6 +11,7 @@ import {
   EntityForm,
   FormField,
   FormSection,
+  NextSteps,
   Tips,
 } from "~/components/ui/entity-form";
 import { Input } from "~/components/ui/input";
@@ -26,7 +27,7 @@ import { Textarea } from "~/components/ui/textarea";
 import { useStudyContext } from "~/lib/study-context";
 import { api } from "~/trpc/react";
 
-import { Calendar as CalendarIcon, Clock } from "lucide-react";
+import { Calendar as CalendarIcon, Clock, Clock2 } from "lucide-react";
 import { format } from "date-fns";
 import { cn } from "~/lib/utils";
 import { Button } from "~/components/ui/button";
@@ -84,60 +85,61 @@ function DateTimePicker({
 
   return (
     <div className="flex items-end gap-2">
-      <div className="grid gap-1.5">
+      <Popover open={open} onOpenChange={setOpen}>
-        <Label htmlFor="date-picker" className="text-xs">
+        <PopoverTrigger asChild>
-          Date
+          <Button
-        </Label>
+            variant={"outline"}
-        <Popover open={open} onOpenChange={setOpen}>
+            id="date-picker"
-          <PopoverTrigger asChild>
+            className={cn(
-            <Button
+              "w-[200px] justify-start text-left font-normal",
-              variant={"outline"}
+              !value && "text-muted-foreground",
-              id="date-picker"
+            )}
-              className={cn(
+          >
-                "w-[240px] justify-start text-left font-normal",
+            <CalendarIcon className="mr-2 h-4 w-4" />
-                !value && "text-muted-foreground",
+            {value ? format(value, "MMM d, yyyy") : <span>Pick a date</span>}
-              )}
+          </Button>
-            >
+        </PopoverTrigger>
-              <CalendarIcon className="mr-2 h-4 w-4" />
+        <PopoverContent className="w-auto p-0" align="start">
-              {value ? format(value, "PPP") : <span>Pick a date</span>}
+          <Calendar
-            </Button>
+            mode="single"
-          </PopoverTrigger>
+            selected={value}
-          <PopoverContent className="w-auto p-0" align="start">
+            onSelect={onDateSelect}
-            <Calendar
+            initialFocus
-              mode="single"
+          />
-              selected={value}
+        </PopoverContent>
-              onSelect={onDateSelect}
+      </Popover>
-              initialFocus
+
-            />
+      <div className="relative">
-          </PopoverContent>
+        <Input
-        </Popover>
+          id="time-picker"
+          type="time"
+          value={timeValue}
+          onChange={onTimeChange}
+          disabled={!value}
+          className="w-[110px]"
+        />
+        <Clock className="text-muted-foreground pointer-events-none absolute top-2.5 right-3 h-4 w-4" />
       </div>
 
-      <div className="grid gap-1.5">
+      <Button
-        <Label htmlFor="time-picker" className="text-xs">
+        type="button"
-          Time
+        variant="outline"
-        </Label>
+        size="sm"
-        <div className="relative">
+        onClick={() => onChange(new Date())}
-          <Input
+        className="h-10 gap-1.5"
-            id="time-picker"
+      >
-            type="time"
+        <Clock2 className="h-4 w-4" />
-            value={timeValue}
+        Now
-            onChange={onTimeChange}
+      </Button>
-            disabled={!value}
-            className="w-[120px]"
-          />
-          <Clock className="text-muted-foreground pointer-events-none absolute top-2.5 right-3 h-4 w-4" />
-        </div>
-      </div>
     </div>
   );
 }
 
 const trialSchema = z.object({
-  experimentId: z.string().uuid("Please select an experiment"),
+  experimentId: z.string().min(1, "Please select an experiment *"),
-  participantId: z.string().uuid("Please select a participant"),
+  participantId: z.string().min(1, "Please select a participant *"),
-  scheduledAt: z.date(),
+  scheduledAt: z.date({ message: "Scheduled date and time is required *" }),
-  wizardId: z.string().uuid().optional().or(z.literal("")),
+  wizardId: z.string().optional().or(z.literal("")),
   notes: z.string().max(1000, "Notes cannot exceed 1000 characters").optional(),
   sessionNumber: z
     .number()
@@ -165,7 +167,7 @@ export function TrialForm({ mode, trialId, studyId }: TrialFormProps) {
     defaultValues: {
       experimentId: "" as any,
       participantId: "" as any,
-      scheduledAt: new Date(),
+      scheduledAt: undefined,
       wizardId: undefined,
       notes: "",
       sessionNumber: 1,
@@ -329,6 +331,249 @@ export function TrialForm({ mode, trialId, studyId }: TrialFormProps) {
     return <div>Error loading trial: {fetchError.message}</div>;
   }
 
+  // Sidebar content
+  const sidebar = (
+    <>
+      <NextSteps
+        steps={[
+          {
+            title: "Configure Experiment",
+            description: "Ensure the experiment protocol is designed and ready",
+            completed: !!form.watch("experimentId"),
+          },
+          {
+            title: "Select Participant",
+            description: "Choose a participant for this trial",
+            completed: !!form.watch("participantId"),
+          },
+          {
+            title: "Assign Wizard",
+            description: "Assign a wizard to operate the robot",
+          },
+          {
+            title: "Run Trial",
+            description: "Execute the trial and collect data",
+          },
+        ]}
+      />
+      <Tips
+        tips={[
+          "Verify experiment status: Only 'Ready' experiments can be used in trials.",
+          "Check participant availability: Ensure participants are available at the scheduled time.",
+          "Assign wizards early: Give wizards time to prepare before the trial.",
+          "Prepare notes: Add any special instructions for the wizard.",
+        ]}
+      />
+    </>
+  );
+
+  // Form fields
+  const formFields = (
+    <>
+      <FormSection
+        title="Trial Configuration"
+        description="Select the experiment and participant for this trial."
+      >
+        <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
+          <FormField>
+            <Label htmlFor="experimentId">
+              Experiment <span className="text-red-500">*</span>
+            </Label>
+            <Select
+              value={form.watch("experimentId") ?? ""}
+              onValueChange={(value) => form.setValue("experimentId", value)}
+              disabled={experimentsLoading || mode === "edit"}
+            >
+              <SelectTrigger
+                className={
+                  form.formState.errors.experimentId ? "border-red-500 ring-1 ring-red-500" : ""
+                }
+              >
+                <SelectValue
+                  placeholder={
+                    experimentsLoading
+                      ? "Loading experiments..."
+                      : "Select an experiment"
+                  }
+                />
+              </SelectTrigger>
+              <SelectContent>
+                {experimentsData?.map((experiment) => (
+                  <SelectItem key={experiment.id} value={experiment.id}>
+                    {experiment.name} ({experiment.status})
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+            {form.formState.errors.experimentId && (
+              <p className="mt-1 text-sm text-red-500 font-medium">
+                {form.formState.errors.experimentId.message}
+              </p>
+            )}
+            {mode === "edit" && (
+              <p className="text-muted-foreground mt-1 text-xs">
+                Experiment cannot be changed after creation
+              </p>
+            )}
+          </FormField>
+
+          <FormField>
+            <Label htmlFor="participantId">
+              Participant <span className="text-red-500">*</span>
+            </Label>
+            <Select
+              value={form.watch("participantId") ?? ""}
+              onValueChange={(value) => form.setValue("participantId", value)}
+              disabled={participantsLoading || mode === "edit"}
+            >
+              <SelectTrigger
+                className={
+                  form.formState.errors.participantId ? "border-red-500 ring-1 ring-red-500" : ""
+                }
+              >
+                <SelectValue
+                  placeholder={
+                    participantsLoading
+                      ? "Loading participants..."
+                      : "Select a participant"
+                  }
+                />
+              </SelectTrigger>
+              <SelectContent>
+                {participantsData?.participants?.map((participant) => (
+                  <SelectItem key={participant.id} value={participant.id}>
+                    {participant.name ?? participant.participantCode}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+            {form.formState.errors.participantId && (
+              <p className="mt-1 text-sm text-red-500 font-medium">
+                {form.formState.errors.participantId.message}
+              </p>
+            )}
+            {mode === "edit" && (
+              <p className="text-muted-foreground mt-1 text-xs">
+                Participant cannot be changed after creation
+              </p>
+            )}
+          </FormField>
+        </div>
+      </FormSection>
+
+      <FormSection
+        title="Scheduling"
+        description="Set when this trial should be conducted."
+      >
+        <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
+          <FormField>
+            <Label htmlFor="scheduledAt">
+              Scheduled Date & Time <span className="text-red-500">*</span>
+            </Label>
+            <Controller
+              control={form.control}
+              name="scheduledAt"
+              render={({ field }) => (
+                <DateTimePicker
+                  value={field.value}
+                  onChange={field.onChange}
+                />
+              )}
+            />
+            {form.formState.errors.scheduledAt && (
+              <p className="mt-1 text-sm text-red-500 font-medium">
+                {form.formState.errors.scheduledAt.message}
+              </p>
+            )}
+            <p className="text-muted-foreground mt-1 text-xs">
+              When should this trial be conducted?
+            </p>
+          </FormField>
+
+          <FormField>
+            <Label htmlFor="sessionNumber">Session Number</Label>
+            <Input
+              id="sessionNumber"
+              type="number"
+              min="1"
+              {...form.register("sessionNumber", { valueAsNumber: true })}
+              placeholder="1"
+              className={
+                form.formState.errors.sessionNumber ? "border-red-500 ring-1 ring-red-500" : ""
+              }
+            />
+            {form.formState.errors.sessionNumber && (
+              <p className="mt-1 text-sm text-red-500 font-medium">
+                {form.formState.errors.sessionNumber.message}
+              </p>
+            )}
+            <p className="text-muted-foreground mt-1 text-xs">
+              Auto-incremented based on participant history
+            </p>
+          </FormField>
+        </div>
+      </FormSection>
+
+      <FormSection
+        title="Assignment & Notes"
+        description="Assign a wizard and add any special instructions."
+      >
+        <FormField>
+          <Label htmlFor="wizardId">Assigned Wizard</Label>
+          <Select
+            value={form.watch("wizardId") ?? "none"}
+            onValueChange={(value) =>
+              form.setValue("wizardId", value === "none" ? undefined : value)
+            }
+            disabled={usersLoading}
+          >
+            <SelectTrigger>
+              <SelectValue
+                placeholder={
+                  usersLoading
+                    ? "Loading wizards..."
+                    : "Select a wizard (optional)"
+                }
+              />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="none">No wizard assigned</SelectItem>
+              {usersData?.map(
+                (user: { id: string; name: string; email: string }) => (
+                  <SelectItem key={user.id} value={user.id}>
+                    {user.name} ({user.email})
+                  </SelectItem>
+                ),
+              )}
+            </SelectContent>
+          </Select>
+          <p className="text-muted-foreground mt-1 text-xs">
+            Who will operate the robot during this trial?
+          </p>
+        </FormField>
+
+        <FormField>
+          <Label htmlFor="notes">Notes</Label>
+          <Textarea
+            id="notes"
+            {...form.register("notes")}
+            placeholder="Special instructions for the wizard, environmental setup notes, or other relevant information..."
+            rows={4}
+            className={form.formState.errors.notes ? "border-red-500 ring-1 ring-red-500" : ""}
+          />
+          {form.formState.errors.notes && (
+            <p className="mt-1 text-sm text-red-500 font-medium">
+              {form.formState.errors.notes.message}
+            </p>
+          )}
+          <p className="text-muted-foreground mt-1 text-xs">
+            Optional: Add any special instructions for this trial
+          </p>
+        </FormField>
+      </FormSection>
+    </>
+  );
+
   return (
     <EntityForm
       mode={mode}
@@ -351,196 +596,10 @@ export function TrialForm({ mode, trialId, studyId }: TrialFormProps) {
       onSubmit={onSubmit}
       isSubmitting={isSubmitting}
       error={error}
-      sidebar={undefined}
+      sidebar={sidebar}
       submitText={mode === "create" ? "Schedule Trial" : "Save Changes"}
-      layout="full-width"
     >
-      <div className="grid grid-cols-1 gap-6 md:grid-cols-3">
+      {formFields}
-        {/* Left Column: Main Info (Spans 2) */}
-        <div className="space-y-6 md:col-span-2">
-          <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
-            <FormField>
-              <Label htmlFor="experimentId">Experiment *</Label>
-              <Select
-                value={form.watch("experimentId") ?? ""}
-                onValueChange={(value) => form.setValue("experimentId", value)}
-                disabled={experimentsLoading || mode === "edit"}
-              >
-                <SelectTrigger
-                  className={
-                    form.formState.errors.experimentId ? "border-red-500" : ""
-                  }
-                >
-                  <SelectValue
-                    placeholder={
-                      experimentsLoading
-                        ? "Loading experiments..."
-                        : "Select an experiment"
-                    }
-                  />
-                </SelectTrigger>
-                <SelectContent>
-                  {experimentsData?.map((experiment) => (
-                    <SelectItem key={experiment.id} value={experiment.id}>
-                      {experiment.name}
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
-              {form.formState.errors.experimentId && (
-                <p className="text-sm text-red-600">
-                  {form.formState.errors.experimentId.message}
-                </p>
-              )}
-              {mode === "edit" && (
-                <p className="text-muted-foreground text-xs">
-                  Experiment cannot be changed after creation
-                </p>
-              )}
-            </FormField>
-
-            <FormField>
-              <Label htmlFor="participantId">Participant *</Label>
-              <Select
-                value={form.watch("participantId") ?? ""}
-                onValueChange={(value) => form.setValue("participantId", value)}
-                disabled={participantsLoading || mode === "edit"}
-              >
-                <SelectTrigger
-                  className={
-                    form.formState.errors.participantId ? "border-red-500" : ""
-                  }
-                >
-                  <SelectValue
-                    placeholder={
-                      participantsLoading
-                        ? "Loading participants..."
-                        : "Select a participant"
-                    }
-                  />
-                </SelectTrigger>
-                <SelectContent>
-                  {participantsData?.participants?.map((participant) => (
-                    <SelectItem key={participant.id} value={participant.id}>
-                      {participant.name ?? participant.participantCode} (
-                      {participant.participantCode})
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
-              {form.formState.errors.participantId && (
-                <p className="text-sm text-red-600">
-                  {form.formState.errors.participantId.message}
-                </p>
-              )}
-              {mode === "edit" && (
-                <p className="text-muted-foreground text-xs">
-                  Participant cannot be changed after creation
-                </p>
-              )}
-            </FormField>
-          </div>
-
-          <div className="grid grid-cols-1 gap-6 md:grid-cols-2">
-            <FormField>
-              <Label htmlFor="scheduledAt">Scheduled Date & Time *</Label>
-              <Controller
-                control={form.control}
-                name="scheduledAt"
-                render={({ field }) => (
-                  <DateTimePicker
-                    value={field.value}
-                    onChange={field.onChange}
-                  />
-                )}
-              />
-              {form.formState.errors.scheduledAt && (
-                <p className="text-sm text-red-600">
-                  {form.formState.errors.scheduledAt.message}
-                </p>
-              )}
-              <p className="text-muted-foreground text-xs">
-                When should this trial be conducted?
-              </p>
-            </FormField>
-
-            <FormField>
-              <Label htmlFor="sessionNumber">Session Number</Label>
-              <Input
-                id="sessionNumber"
-                type="number"
-                min="1"
-                {...form.register("sessionNumber", { valueAsNumber: true })}
-                placeholder="1"
-                className={
-                  form.formState.errors.sessionNumber ? "border-red-500" : ""
-                }
-              />
-              {form.formState.errors.sessionNumber && (
-                <p className="text-sm text-red-600">
-                  {form.formState.errors.sessionNumber.message}
-                </p>
-              )}
-              <p className="text-muted-foreground text-xs">
-                Auto-incremented based on participant history
-              </p>
-            </FormField>
-          </div>
-        </div>
-
-        {/* Right Column: Assignment & Notes (Spans 1) */}
-        <div className="space-y-6">
-          <FormField>
-            <Label htmlFor="wizardId">Assigned Wizard</Label>
-            <Select
-              value={form.watch("wizardId") ?? "none"}
-              onValueChange={(value) =>
-                form.setValue("wizardId", value === "none" ? undefined : value)
-              }
-              disabled={usersLoading}
-            >
-              <SelectTrigger>
-                <SelectValue
-                  placeholder={
-                    usersLoading
-                      ? "Loading wizards..."
-                      : "Select a wizard (optional)"
-                  }
-                />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="none">No wizard assigned</SelectItem>
-                {usersData?.map(
-                  (user: { id: string; name: string; email: string }) => (
-                    <SelectItem key={user.id} value={user.id}>
-                      {user.name} ({user.email})
-                    </SelectItem>
-                  ),
-                )}
-              </SelectContent>
-            </Select>
-            <p className="text-muted-foreground text-xs">
-              Who will operate the robot?
-            </p>
-          </FormField>
-
-          <FormField>
-            <Label htmlFor="notes">Notes</Label>
-            <Textarea
-              id="notes"
-              {...form.register("notes")}
-              placeholder="Special instructions..."
-              rows={5}
-              className={form.formState.errors.notes ? "border-red-500" : ""}
-            />
-            {form.formState.errors.notes && (
-              <p className="text-sm text-red-600">
-                {form.formState.errors.notes.message}
-              </p>
-            )}
-          </FormField>
-        </div>
-      </div>
     </EntityForm>
   );
 }

src/lib/experiment-designer/visual-design-guard.ts

@@ -55,7 +55,7 @@ const actionSourceSchema = z
 const executionDescriptorSchema = z
   .object({
     transport: z.enum(["ros2", "rest", "internal"]),
-    timeoutMs: z.number().int().positive().optional(),
+    timeoutMs: z.number().int().min(0).optional(),
     retryable: z.boolean().optional(),
     ros2: z
       .object({

src/lib/ros/wizard-ros-service.ts

@@ -45,6 +45,21 @@ export interface RobotActionExecution {
   error?: string;
 }
 
+/**
+ * A single frame in a multi-step joint animation.
+ * @param joint_names  - NAO joint names to move (e.g. "LShoulderPitch")
+ * @param joint_angles - Target angles in radians, one per joint_name
+ * @param speed        - Movement speed as a fraction of max (0.0–1.0)
+ * @param delay_after  - Milliseconds to wait after publishing this frame
+ *                       before sending the next one. Defaults to 800 ms.
+ */
+export interface AnimationMovement {
+  joint_names: string[];
+  joint_angles: number[];
+  speed?: number;
+  delay_after?: number;
+}
+
 /**
  * Unified ROS WebSocket service for wizard interface
  * Manages connection to rosbridge and handles robot action execution
@@ -329,6 +344,19 @@ export class WizardRosService extends EventEmitter {
 
       console.log(`[WizardROS] SIMULATION MODE - Executing ${actionId}:`, parameters);
 
+      // If the action config carries a gesture_sequence payload, run the sim animation handler
+      if (actionConfig?.payloadMapping?.payload) {
+        const payload = actionConfig.payloadMapping.payload as { type?: string; movements?: AnimationMovement[] };
+        if (payload.type === "gesture_sequence" && payload.movements?.length) {
+          await this.executeSimulationAnimationSequence(payload.movements);
+          execution.status = "completed";
+          execution.endTime = new Date();
+          this.emit("action_completed", execution);
+          this.activeActions.set(executionId, execution);
+          return execution;
+        }
+      }
+
       // Simulate action execution based on action type
       let duration = 500;
 
@@ -336,9 +364,8 @@ export class WizardRosService extends EventEmitter {
         const text = String(parameters.text || parameters.data || "Hello");
         const wordCount = text.split(/\s+/).filter(Boolean).length;
         duration = 1500 + Math.max(1000, wordCount * 300);
-      } else if (actionId.includes("walk") || actionId.includes("turn") || actionConfig?.topic === "/cmd_vel") {
+      } else if (actionId.includes("walk") || actionId === "stop_walking" || actionConfig?.topic === "/cmd_vel") {
         duration = 500;
-        // Simulate position change
         const speed = Number(parameters.speed) || 0.1;
         if (actionId === "walk_forward") {
           this.robotStatus.position.x += speed * 0.5;
@@ -349,8 +376,10 @@ export class WizardRosService extends EventEmitter {
         } else if (actionId === "turn_right") {
           this.robotStatus.position.theta += 0.5;
         }
-      } else if (actionId.includes("head") || actionId.includes("move") || actionConfig?.topic === "/joint_angles") {
+      } else if (actionConfig?.topic === "/joint_angles") {
         duration = 1000;
+      } else if (actionId === "wake_up" || actionId === "rest" || actionId === "set_posture") {
+        duration = 2000;
       }
 
       // Simulate async execution
@@ -434,7 +463,7 @@ export class WizardRosService extends EventEmitter {
 
       // Execute based on action configuration or built-in mappings
       if (actionConfig) {
-        await this.executeWithConfig(actionConfig, parameters);
+        await this.executeWithConfig(actionConfig, parameters, actionId);
       } else {
         await this.executeBuiltinAction(actionId, parameters);
       }
@@ -460,6 +489,60 @@ export class WizardRosService extends EventEmitter {
     return Array.from(this.activeActions.values());
   }
 
+  /**
+   * Execute a multi-frame joint animation by sending each movement in sequence.
+   * Each frame is published to /joint_angles then held for delay_after ms
+   * (default 800 ms) before the next frame is sent.
+   */
+  async executeAnimationSequence(movements: AnimationMovement[]): Promise<void> {
+    if (!movements.length) {
+      console.warn("[WizardROS] executeAnimationSequence called with empty movements");
+      return;
+    }
+
+    for (let i = 0; i < movements.length; i++) {
+      const movement = movements[i]!;
+      console.log(
+        `[WizardROS] Animation frame ${i + 1}/${movements.length}:`,
+        movement.joint_names,
+        "→",
+        movement.joint_angles,
+      );
+
+      this.publish(
+        "/joint_angles",
+        "naoqi_bridge_msgs/msg/JointAnglesWithSpeed",
+        {
+          joint_names: movement.joint_names,
+          joint_angles: movement.joint_angles,
+          speed: movement.speed ?? 0.3,
+        },
+      );
+
+      // Always wait after each frame (including the last) so the caller
+      // can await this method and know the animation has finished.
+      const delayMs = movement.delay_after ?? 800;
+      await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+
+  /**
+   * Execute a multi-frame joint animation in simulation mode (logs only).
+   */
+  private async executeSimulationAnimationSequence(
+    movements: AnimationMovement[],
+  ): Promise<void> {
+    for (let i = 0; i < movements.length; i++) {
+      const movement = movements[i]!;
+      console.log(
+        `[WizardROS] SIMULATION animation frame ${i + 1}/${movements.length}:`,
+        movement.joint_names,
+      );
+      const delayMs = movement.delay_after ?? 800;
+      await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+
   /**
    * Subscribe to robot sensor topics
    */
@@ -480,6 +563,7 @@ export class WizardRosService extends EventEmitter {
 
     this.advertise("/speech", "std_msgs/String");
     this.advertise("/cmd_vel", "geometry_msgs/Twist");
+    this.advertise("/joint_angles", "naoqi_bridge_msgs/msg/JointAnglesWithSpeed");
     this.advertise("/robot_pose", "geometry_msgs/Pose");
     this.advertise("/animation", "std_msgs/String");
   }
@@ -632,10 +716,30 @@ export class WizardRosService extends EventEmitter {
         type: string;
         payload?: Record<string, unknown>;
         transformFn?: string;
+        service?: string;
+        args?: Record<string, unknown>;
+        sshCommand?: string;
       };
     },
     parameters: Record<string, unknown>,
+    actionId?: string,
   ): Promise<void> {
+    // SSH command actions
+    if (config.payloadMapping.type === "ssh" && config.payloadMapping.sshCommand) {
+      await this.executeSSHCommand(config.payloadMapping.sshCommand);
+      return;
+    }
+
+    // Service-call actions — no topic publish involved
+    if (config.payloadMapping.type === "service") {
+      const service = config.payloadMapping.service ?? config.topic;
+      const args = config.payloadMapping.args
+        ? this.buildTemplatePayload(config.payloadMapping.args, parameters)
+        : parameters;
+      await this.callService(service, args);
+      return;
+    }
+
     let msg: Record<string, unknown>;
 
     if (
@@ -643,22 +747,31 @@ export class WizardRosService extends EventEmitter {
         config.payloadMapping.type === "static") &&
       config.payloadMapping.payload
     ) {
-      // Template-based payload construction
+      msg = this.buildTemplatePayload(config.payloadMapping.payload, parameters);
-      msg = this.buildTemplatePayload(
-        config.payloadMapping.payload,
-        parameters,
-      );
     } else if (config.payloadMapping.transformFn) {
-      // Custom transform function
+      msg = this.applyTransformFunction(config.payloadMapping.transformFn, parameters);
-      msg = this.applyTransformFunction(
-        config.payloadMapping.transformFn,
-        parameters,
-      );
     } else {
-      // Direct parameter mapping
       msg = parameters;
     }
 
+    // Delegate gesture_sequence payloads to the animation handler
+    if ((msg as { type?: string }).type === "gesture_sequence") {
+      const movements = (msg as { movements?: AnimationMovement[] }).movements;
+      if (!movements?.length) {
+        console.warn("[WizardROS] gesture_sequence payload has no movements");
+        return;
+      }
+      console.log(`[WizardROS] Delegating to animation handler (${movements.length} frames)`);
+      await this.executeAnimationSequence(movements);
+      return;
+    }
+
+    // Route /animation topic through SSH instead of ROS to avoid crashes
+    if (config.topic === "/animation" && actionId?.startsWith("play_animation_")) {
+      await this.executeAnimationSSH(actionId);
+      return;
+    }
+
     this.publish(config.topic, config.messageType, msg);
 
     // Wait for action completion based on topic type
@@ -747,7 +860,7 @@ export class WizardRosService extends EventEmitter {
       case "turn_head":
         this.publish(
           "/joint_angles",
-          "naoqi_bridge_msgs/JointAnglesWithSpeed",
+          "naoqi_bridge_msgs/msg/JointAnglesWithSpeed",
           {
             joint_names: ["HeadYaw", "HeadPitch"],
             joint_angles: [
@@ -760,12 +873,12 @@ export class WizardRosService extends EventEmitter {
         await new Promise((resolve) => setTimeout(resolve, 1000));
         break;
 
-      case "move_arm":
+      case "move_arm": {
         const arm = String(parameters.arm || "right");
         const prefix = arm.toLowerCase() === "left" ? "L" : "R";
         this.publish(
           "/joint_angles",
-          "naoqi_bridge_msgs/JointAnglesWithSpeed",
+          "naoqi_bridge_msgs/msg/JointAnglesWithSpeed",
           {
             joint_names: [
               `${prefix}ShoulderPitch`,
@@ -784,6 +897,40 @@ export class WizardRosService extends EventEmitter {
         );
         await new Promise((resolve) => setTimeout(resolve, 1000));
         break;
+      }
+
+      case "wake_up":
+        // Try known naoqi_driver2 service names in order
+        for (const svc of [
+          "/naoqi_driver/ALMotion/wakeUp",
+          "/naoqi_driver/motion/wake_up",
+          "/motion/wake_up",
+        ]) {
+          try {
+            await this.callService(svc, {});
+            console.log(`[WizardROS] wake_up succeeded via ${svc}`);
+            break;
+          } catch {
+            // try next
+          }
+        }
+        break;
+
+      case "rest":
+        for (const svc of [
+          "/naoqi_driver/ALMotion/rest",
+          "/naoqi_driver/motion/rest",
+          "/motion/rest",
+        ]) {
+          try {
+            await this.callService(svc, {});
+            console.log(`[WizardROS] rest succeeded via ${svc}`);
+            break;
+          } catch {
+            // try next
+          }
+        }
+        break;
 
       case "emergency_stop":
         this.publish("/cmd_vel", "geometry_msgs/Twist", {
@@ -792,6 +939,16 @@ export class WizardRosService extends EventEmitter {
         });
         break;
 
+      case "play_animation_bow":
+      case "play_animation_hey":
+      case "play_animation_show_floor":
+      case "play_animation_enthusiastic":
+      case "play_animation_yes":
+      case "play_animation_no":
+      case "play_animation_idontknow":
+        await this.executeAnimationSSH(actionId);
+        break;
+
       default:
         throw new Error(
           `Unknown action: ${actionId}. Define this action in your robot plugin.`,
@@ -879,6 +1036,56 @@ export class WizardRosService extends EventEmitter {
     });
   }
 
+  /**
+   * Execute animation via API route (SSH to robot)
+   */
+  private async executeAnimationSSH(actionId: string): Promise<void> {
+    const animationMap: Record<string, string> = {
+      "play_animation_bow": "animations/Stand/Gestures/BowShort_1",
+      "play_animation_hey": "animations/Stand/Gestures/Hey_1",
+      "play_animation_show_floor": "animations/Stand/Gestures/ShowFloor_1",
+      "play_animation_enthusiastic": "animations/Stand/Gestures/Enthusiastic_4",
+      "play_animation_yes": "animations/Stand/Gestures/Yes_1",
+      "play_animation_no": "animations/Stand/Gestures/No_3",
+      "play_animation_idontknow": "animations/Stand/Gestures/IDontKnow_1",
+    };
+
+    const animation = animationMap[actionId];
+    if (!animation) {
+      throw new Error(`Unknown animation: ${actionId}`);
+    }
+
+    console.log(`[WizardROS] Executing animation via API: ${animation}`);
+
+    // Use executeSSH to run animation via qicli (bypasses studyId requirement)
+    await this.executeSSHCommand(`qicli call ALAnimationPlayer.run '${animation}'`);
+
+    console.log(`[WizardROS] Animation completed: ${animation}`);
+  }
+
+  /**
+   * Execute an arbitrary SSH command via the API
+   */
+  private async executeSSHCommand(command: string): Promise<void> {
+    console.log(`[WizardROS] Executing SSH command: ${command}`);
+
+    const response = await fetch("/api/robots/command", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        action: "executeSSH",
+        command,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`SSH command failed: ${error}`);
+    }
+
+    console.log(`[WizardROS] SSH command completed: ${command}`);
+  }
+
   /**
    * Set Autonomous Life state with fallbacks
    */
@@ -1042,6 +1249,21 @@ export class WizardRosService extends EventEmitter {
       case "transformToEmotionalSpeech":
         return this.transformToEmotionalSpeech(parameters);
 
+      case "transformToEmotionSpeech":
+        return this.transformToEmotionalSpeech(parameters);
+
+      case "transformToWaveGoodbye":
+        return this.transformToWaveGoodbye(parameters);
+
+      case "transformToAnimation":
+        return this.transformToAnimation(parameters);
+
+      case "transformToGestureSequence":
+        return this.transformToGestureSequence(parameters);
+
+      case "transformToWaveGoodbye":
+        return this.transformToWaveGoodbye(parameters);
+
       default:
         console.warn(`Unknown transform function: ${transformFn}`);
         return parameters;
@@ -1051,34 +1273,26 @@ export class WizardRosService extends EventEmitter {
   /**
    * Transform parameters for emotional speech
    * NAOqi markup: \rspd=<speed>\<text>
-   * For animated speech: ^start(animations/Stand/Gestures/...)
+   * Using pure speech modifiers without animations to avoid sound effects
    */
   private transformToEmotionalSpeech(parameters: Record<string, unknown>): {
     data: string;
   } {
     const text = String(parameters.text || "Hello");
     const emotion = String(parameters.emotion || "neutral");
-    const speed = Number(parameters.speed || 1.0);
-    const speedPercent = Math.round(speed * 100);
 
     let markedText = text;
 
     switch (emotion) {
       case "happy":
-        markedText = `\\rspd=120\\^start(animations/Stand/Gestures/Happy_4) ${text}`;
+        markedText = `\\rspd=120\\ ${text}`;
-        break;
-      case "excited":
-        markedText = `\\rspd=140\\^start(animations/Stand/Gestures/Enthusiastic_1) ${text}`;
         break;
       case "sad":
-        markedText = `\\rspd=80\\vct=80\\${text}`;
+        markedText = `\\rspd=80\\ ${text}`;
-        break;
-      case "calm":
-        markedText = `\\rspd=90\\${text}`;
         break;
       case "neutral":
       default:
-        markedText = `\\rspd=${speedPercent}\\${text}`;
+        markedText = text;
         break;
     }
 
@@ -1086,14 +1300,13 @@ export class WizardRosService extends EventEmitter {
   }
 
   /**
-   * Transform for wave goodbye - animated speech with waving
+   * Transform for wave goodbye - speech without animation sound
    */
   private transformToWaveGoodbye(parameters: Record<string, unknown>): {
     data: string;
   } {
     const text = String(parameters.text || "Goodbye!");
-    const markedText = `\\rspd=110\\^start(animations/Stand/Gestures/Hey_1) ${text} ^start(animations/Stand/Gestures/Hey_1)`;
+    return { data: text };
-    return { data: markedText };
   }
 
   /**
@@ -1107,6 +1320,38 @@ export class WizardRosService extends EventEmitter {
     return { data: markedText };
   }
 
+  /**
+   * Transform for gesture sequences - sends multiple joint angle movements
+   * Parameters: movements = [{joints: string[], angles: number[], duration: number}, ...]
+   */
+  private transformToGestureSequence(parameters: Record<string, unknown>): {
+    type: string;
+    movements: Array<{
+      joint_names: string[];
+      joint_angles: number[];
+      speed: number;
+    }>;
+  } {
+    const movements = parameters.movements as Array<{
+      joints?: string[];
+      angles?: number[];
+      duration?: number;
+      speed?: number;
+    }>;
+
+    if (!Array.isArray(movements)) {
+      return { type: "gesture_sequence", movements: [] };
+    }
+
+    const parsedMovements = movements.map((m, index) => ({
+      joint_names: m.joints || [],
+      joint_angles: m.angles || [],
+      speed: m.speed || (m.duration ? 1 / (m.duration / 1000) : 0.3),
+    }));
+
+    return { type: "gesture_sequence", movements: parsedMovements };
+  }
+
   /**
    * Schedule reconnection attempt
    */

src/server/services/robot-communication.ts

@@ -6,6 +6,10 @@
 
 import WebSocket from "ws";
 import { EventEmitter } from "events";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
 
 export interface RobotCommunicationConfig {
   rosBridgeUrl: string;
@@ -22,6 +26,22 @@ export interface RobotAction {
     topic: string;
     messageType: string;
     messageTemplate: Record<string, unknown>;
+    payloadMapping?: {
+      type?: string;
+      transformFn?: string;
+      payload?: Record<string, unknown>;
+    };
+    ros2?: {
+      topic?: string;
+      messageType?: string;
+      service?: string;
+      action?: string;
+      payloadMapping?: {
+        type?: string;
+        transformFn?: string;
+        payload?: Record<string, unknown>;
+      };
+    };
   };
 }
 
@@ -161,41 +181,71 @@ export class RobotCommunicationService extends EventEmitter {
    * Execute a robot action
    */
   async executeAction(action: RobotAction): Promise<RobotActionResult> {
+    const actionId = `action_${this.messageId++}`;
+    const startTime = Date.now();
+
+    // Check if this is an SSH-only action (animations, posture, arbitrary SSH commands)
+    const { implementation, actionId: actionType } = action;
+    const baseActionId = actionType.includes(".")
+      ? actionType.split(".").pop()
+      : actionType;
+
+    const isAnimationAction = baseActionId?.startsWith("play_animation_");
+    const sshCommand = implementation.payloadMapping?.sshCommand
+      || implementation.ros2?.payloadMapping?.sshCommand;
+
+    // SSH actions don't require ROS connection
+    if (isAnimationAction || sshCommand) {
+      const timeout = setTimeout(() => {
+        throw new Error(`SSH action timeout: ${action.actionId}`);
+      }, 30000);
+
+      try {
+        console.log(`[RobotComm] Executing SSH action: ${action.actionId}`);
+        const result = await this.executeRobotActionInternal(action, actionId, startTime);
+        clearTimeout(timeout);
+        return result;
+      } catch (error) {
+        clearTimeout(timeout);
+        throw error;
+      }
+    }
+
+    // Non-SSH actions require ROS connection
     if (!this.isConnected) {
       throw new Error("Not connected to ROS bridge");
     }
 
-    const startTime = Date.now();
+    // Store pending action
-    const actionId = `action_${this.messageId++}`;
+    const pending = {
-
+      resolve: (() => {}) as (result: RobotActionResult) => void,
-    return new Promise((resolve, reject) => {
+      reject: (() => {}) as (error: Error) => void,
-      // Set up timeout
+      timeout: setTimeout(() => {
-      const timeout = setTimeout(() => {
         this.pendingActions.delete(actionId);
-        reject(new Error(`Action timeout: ${action.actionId}`));
+        pending.reject(new Error(`Action timeout: ${action.actionId}`));
-      }, 30000); // 30 second timeout
+      }, 30000),
+      startTime,
+    };
 
-      // Store pending action
+    this.pendingActions.set(actionId, pending);
-      this.pendingActions.set(actionId, {
-        resolve,
-        reject,
-        timeout,
-        startTime,
-      });
 
-      try {
+    // Wrap the pending resolve/reject in a way that works with async method
-        // Log the action we're about to execute
+    return new Promise<RobotActionResult>((resolve, reject) => {
-        console.log(`[RobotComm] Executing robot action: ${action.actionId}`);
+      pending.resolve = resolve;
-        console.log(`[RobotComm] Topic: ${action.implementation.topic}`);
+      pending.reject = reject;
-        console.log(`[RobotComm] Parameters:`, action.parameters);
 
-        // Execute action based on type and platform
+      // Execute action
-        this.executeRobotActionInternal(action, actionId);
+      this.executeRobotActionInternal(action, actionId, startTime)
-      } catch (error) {
+        .then((result) => {
-        clearTimeout(timeout);
+          clearTimeout(pending.timeout);
-        this.pendingActions.delete(actionId);
+          this.pendingActions.delete(actionId);
-        reject(error);
+          resolve(result);
-      }
+        })
+        .catch((error) => {
+          clearTimeout(pending.timeout);
+          this.pendingActions.delete(actionId);
+          reject(error);
+        });
     });
   }
 
@@ -208,17 +258,54 @@ export class RobotCommunicationService extends EventEmitter {
 
   // Private methods
 
-  private executeRobotActionInternal(
+  private async executeRobotActionInternal(
     action: RobotAction,
     actionId: string,
-  ): void {
+    startTime: number,
-    const { implementation, parameters } = action;
+  ): Promise<RobotActionResult> {
+    const { implementation, parameters, actionId: actionType } = action;
 
-    // Build ROS message from template
+    // Use SSH for play_animation actions (check both namespaced and non-namespaced)
-    const message = this.buildRosMessage(
+    const baseActionId = actionType.includes(".")
-      implementation.messageTemplate,
+      ? actionType.split(".").pop()
-      parameters,
+      : actionType;
-    );
+    
+    if (baseActionId?.startsWith("play_animation_")) {
+      await this.executeAnimationViaSSH(baseActionId);
+      return {
+        success: true,
+        duration: Date.now() - startTime,
+        data: { method: "ssh", action: baseActionId },
+      };
+    }
+
+    // Check for SSH command type
+    const sshCommand = implementation.payloadMapping?.sshCommand 
+      || implementation.ros2?.payloadMapping?.sshCommand;
+    
+    if (sshCommand) {
+      await this.executeSSHCommand(sshCommand);
+      return {
+        success: true,
+        duration: Date.now() - startTime,
+        data: { method: "ssh", command: sshCommand },
+      };
+    }
+
+    // Apply transform if specified
+    let message: Record<string, unknown>;
+    const transformFn = implementation.payloadMapping?.transformFn 
+      || implementation.ros2?.payloadMapping?.transformFn;
+    
+    if (transformFn) {
+      message = this.applyTransform(transformFn, parameters);
+    } else {
+      // Build ROS message from template
+      message = this.buildRosMessage(
+        implementation.messageTemplate,
+        parameters,
+      );
+    }
 
     // Publish to ROS topic
     this.publishToTopic(
@@ -229,19 +316,94 @@ export class RobotCommunicationService extends EventEmitter {
 
     // For actions that complete immediately (like movement commands),
     // we simulate completion after a short delay
-    setTimeout(() => {
+    return new Promise((resolve) => {
-      this.completeAction(actionId, {
+      setTimeout(() => {
-        success: true,
+        resolve({
-        duration:
+          success: true,
-          Date.now() -
+          duration: Date.now() - startTime,
-          (this.pendingActions.get(actionId)?.startTime || Date.now()),
+          data: {
-        data: {
+            topic: implementation.topic,
-          topic: implementation.topic,
+            messageType: implementation.messageType,
-          messageType: implementation.messageType,
+            message,
-          message,
+          },
-        },
+        });
-      });
+      }, 100);
-    }, 100);
+    });
+  }
+
+  private async executeSSHCommand(command: string): Promise<void> {
+    const robotIp = process.env.NAO_IP || "134.82.159.168";
+    const password = process.env.NAO_PASSWORD || "robolab";
+
+    console.log(`[RobotComm] Executing SSH command: ${command}`);
+
+    const sshCommand = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no -o ConnectTimeout=10 "nao@${robotIp}" "${command}"`;
+
+    const { stdout, stderr } = await execAsync(sshCommand);
+
+    if (stderr && !stderr.includes("null") && stderr.trim()) {
+      console.warn(`[RobotComm] SSH stderr: ${stderr}`);
+    }
+
+    console.log(`[RobotComm] SSH result: ${stdout}`);
+  }
+
+  private async executeAnimationViaSSH(actionType: string): Promise<void> {
+    const animationMap: Record<string, string> = {
+      "play_animation_bow": "animations/Stand/Gestures/BowShort_1",
+      "play_animation_hey": "animations/Stand/Gestures/Hey_1",
+      "play_animation_show_floor": "animations/Stand/Gestures/ShowFloor_1",
+      "play_animation_enthusiastic": "animations/Stand/Gestures/Enthusiastic_4",
+      "play_animation_yes": "animations/Stand/Gestures/Yes_1",
+      "play_animation_no": "animations/Stand/Gestures/No_3",
+      "play_animation_idontknow": "animations/Stand/Gestures/IDontKnow_1",
+    };
+
+    const animation = animationMap[actionType];
+    if (!animation) {
+      throw new Error(`Unknown animation: ${actionType}`);
+    }
+
+    const robotIp = process.env.NAO_IP || "134.82.159.168";
+    const password = process.env.NAO_PASSWORD || "robolab";
+
+    console.log(`[RobotComm] Executing animation via SSH: ${animation}`);
+
+    const command = `sshpass -p "${password}" ssh -o StrictHostKeyChecking=no -o ConnectTimeout=5 "nao@${robotIp}" "qicli call ALAnimationPlayer.run '${animation}'"`;
+
+    const { stdout, stderr } = await execAsync(command);
+
+    if (stderr && !stderr.includes("null")) {
+      console.warn(`[RobotComm] SSH stderr: ${stderr}`);
+    }
+
+    console.log(`[RobotComm] Animation result: ${stdout}`);
+  }
+
+  private transformToEmotionalSpeech(parameters: Record<string, unknown>): { data: string } {
+    const text = String(parameters.text || "Hello");
+    const emotion = String(parameters.emotion || "neutral");
+
+    switch (emotion) {
+      case "happy":
+        return { data: `\\rspd=120\\ ${text}` };
+      case "sad":
+        return { data: `\\rspd=80\\ ${text}` };
+      case "neutral":
+      default:
+        return { data: text };
+    }
+  }
+
+  private applyTransform(transformFn: string, parameters: Record<string, unknown>): Record<string, unknown> {
+    switch (transformFn) {
+      case "transformToEmotionalSpeech":
+      case "transformToEmotionSpeech":
+        return this.transformToEmotionalSpeech(parameters);
+      default:
+        console.warn(`[RobotComm] Unknown transform: ${transformFn}`);
+        return parameters;
+    }
   }
 
   private buildRosMessage(

src/server/services/trial-execution.ts

@@ -810,10 +810,10 @@ export class TrialExecutionEngine {
       }
     }
 
-    // Prepare robot action
+    // Prepare robot action - use action.type which contains the namespaced format (plugin.actionId)
     const robotAction: RobotAction = {
       pluginName: plugin.name,
-      actionId: actionDefinition.id,
+      actionId: action.type, // e.g., "nao6-ros2.play_animation_bow"
       parameters,
       implementation: actionDefinition.implementation,
     };