omnius 1.0.434 → 1.0.435

package/dist/index.js

@@ -9286,6 +9286,74 @@ function uniqueStrings(values) {
   }
   return out;
 }
+function optionalPositiveInteger(value2) {
+  if (value2 === void 0 || value2 === null || value2 === "")
+    return void 0;
+  const parsed = typeof value2 === "number" ? value2 : Number(String(value2).trim());
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return void 0;
+  return Math.round(parsed);
+}
+function normalizeCameraPresetFps(value2) {
+  const parsed = optionalPositiveInteger(typeof value2 === "string" ? value2.replace(/\s*fps$/i, "") : value2);
+  return parsed === void 0 ? void 0 : Math.max(1, Math.min(30, parsed));
+}
+function parseCameraPresetResolution(value2) {
+  const raw = String(value2 ?? "").trim().toLowerCase();
+  if (!raw || raw === "native" || raw === "auto")
+    return null;
+  const alias = {
+    "480": "640x480",
+    "480p": "640x480",
+    "720": "1280x720",
+    "720p": "1280x720",
+    "1080": "1920x1080",
+    "1080p": "1920x1080",
+    "1440": "2560x1440",
+    "1440p": "2560x1440",
+    "2k": "2560x1440",
+    "2160": "3840x2160",
+    "2160p": "3840x2160",
+    "4k": "3840x2160",
+    "uhd": "3840x2160"
+  };
+  const normalized = alias[raw] ?? raw;
+  const match = normalized.match(/^(\d{3,5})x(\d{3,5})$/);
+  if (!match)
+    return null;
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+    return null;
+  return { width, height, label: `${width}x${height}` };
+}
+function loadLiveCameraPreset(requestedDevice) {
+  const repoRoot = process.env["OMNIUS_REPO_ROOT"] || process.cwd();
+  const configPath2 = join13(repoRoot, ".omnius", "live", "config.json");
+  try {
+    const parsed = JSON.parse(readFileSync13(configPath2, "utf8"));
+    const streams = parsed["cameraStreams"] && typeof parsed["cameraStreams"] === "object" ? parsed["cameraStreams"] : {};
+    const orientations = parsed["cameraOrientation"] && typeof parsed["cameraOrientation"] === "object" ? parsed["cameraOrientation"] : {};
+    const selected = typeof parsed["selectedCamera"] === "string" ? parsed["selectedCamera"] : void 0;
+    const device = requestedDevice || selected;
+    if (!device)
+      return {};
+    const stream = streams[device] ?? {};
+    const orientation = orientations[device] ?? {};
+    const resolution = parseCameraPresetResolution(stream["resolution"]);
+    const rotation = orientation["rotation"] !== void 0 ? normalizeCameraRotationDegrees(orientation["rotation"]) : void 0;
+    return {
+      device,
+      width: resolution?.width,
+      height: resolution?.height,
+      resolution: resolution?.label ?? String(stream["resolution"] ?? "native"),
+      rotation,
+      fps: normalizeCameraPresetFps(stream["fps"] ?? stream["framerate"])
+    };
+  } catch {
+    return {};
+  }
+}
 function buildV4l2CaptureAttempts(width, height, formats) {
   const requested = width > 0 && height > 0 ? `${width}x${height}` : void 0;
   const sizeArea = (size) => {
@@ -9465,6 +9533,14 @@ var init_camera_capture = __esm({
             type: "number",
             description: "Capture height in pixels (default: camera native format)"
           },
+          fps: {
+            type: "number",
+            description: "Requested capture frame rate for v4l2 devices. Defaults to the shared /live or /camera preset when available."
+          },
+          framerate: {
+            type: "number",
+            description: "Alias for fps."
+          },
           rotate_degrees: {
             type: "number",
             enum: [0, 90, 180, 270],
@@ -9564,20 +9640,33 @@ ${formatRouterPlan(plan)}`,
       // Capture frame — auto-selects v4l2 or QooCam
       // =========================================================================
       async captureFrame(args, start2) {
-        const device = args["device"] || "";
+        const requestedDevice = args["device"] || "";
+        const preset = loadLiveCameraPreset(requestedDevice);
+        const device = requestedDevice || preset.device || "";
+        const effectiveArgs = { ...args, device };
+        if (effectiveArgs["width"] === void 0 && preset.width !== void 0)
+          effectiveArgs["width"] = preset.width;
+        if (effectiveArgs["height"] === void 0 && preset.height !== void 0)
+          effectiveArgs["height"] = preset.height;
+        if (effectiveArgs["rotate_degrees"] === void 0 && effectiveArgs["rotation_degrees"] === void 0 && effectiveArgs["rotate"] === void 0 && preset.rotation !== void 0) {
+          effectiveArgs["rotate_degrees"] = preset.rotation;
+        }
+        if (effectiveArgs["fps"] === void 0 && effectiveArgs["framerate"] === void 0 && preset.fps !== void 0) {
+          effectiveArgs["framerate"] = preset.fps;
+        }
         const outputPath3 = args["output_path"];
         if (device === "qoocam" || device.startsWith("qoocam")) {
-          return this.captureQooCam(args, start2);
+          return this.captureQooCam(effectiveArgs, start2);
         }
         const v4l2Device = await this.resolveV4l2Device(device);
         if (!v4l2Device) {
           const qoocam = await this.discoverQooCam();
           if (qoocam.found) {
-            return this.captureQooCam(args, start2);
+            return this.captureQooCam(effectiveArgs, start2);
           }
           return { success: false, output: "", error: "No camera found. Connect a USB camera or enable QooCam WiFi hotspot.", durationMs: performance.now() - start2 };
         }
-        return this.captureV4l2(v4l2Device, args, start2);
+        return this.captureV4l2(v4l2Device, effectiveArgs, start2);
       }
       // =========================================================================
       // Camera info
@@ -9687,10 +9776,11 @@ ${formatRouterPlan(plan)}`,
         return rawDevice;
       }
       async captureV4l2(device, args, start2) {
-        const width = args["width"] || 0;
-        const height = args["height"] || 0;
+        const width = optionalPositiveInteger(args["width"]) ?? 0;
+        const height = optionalPositiveInteger(args["height"]) ?? 0;
         const outputPath3 = args["output_path"];
         const rotation = normalizeCameraRotationDegrees(args["rotate_degrees"] ?? args["rotation_degrees"] ?? args["rotate"]);
+        const fps = normalizeCameraPresetFps(args["framerate"] ?? args["fps"]);
         const captureDir = join13(tmpdir2(), "omnius-camera");
         if (!existsSync15(captureDir))
           mkdirSync9(captureDir, { recursive: true });
@@ -9722,7 +9812,7 @@ ${formatRouterPlan(plan)}`,
                 unlinkSync2(tempFile);
             } catch {
             }
-            const argv = this.ffmpegCaptureArgs(device, tempFile, attempt);
+            const argv = this.ffmpegCaptureArgs(device, tempFile, attempt, fps);
             try {
               await runProcessBuffer(ffmpegBin(), argv, { timeout: 15e3 });
               if (existsSync15(tempFile) && readFileSync13(tempFile).length > 0) {
@@ -9765,8 +9855,10 @@ ${formatRouterPlan(plan)}`,
 Recovered with capture profile: ${captureState.successfulAttempt?.label ?? "unknown"}. Last failed attempt: ${errors[errors.length - 1].slice(0, 260)}` : "";
           const rotationNote = rotation !== 0 ? `
 Applied camera rotation correction: ${rotation} degrees clockwise.` : "";
+          const fpsNote = fps ? `
+Applied camera capture FPS preset: ${fps} fps.` : "";
           const result = this.returnCapturedFile(tempFile, captureState.successfulAttempt?.videoSize ?? (width && height ? `${width}x${height}` : "native"), device, outputPath3, start2);
-          const notes = `${firstSuccess}${rotationNote}`;
+          const notes = `${firstSuccess}${rotationNote}${fpsNote}`;
           return result.success && notes ? { ...result, output: result.output + notes, llmContent: result.llmContent ? result.llmContent + notes : result.llmContent } : result;
         }
         const allErrors = errors.join("\n\n");
@@ -9841,8 +9933,10 @@ ${allErrors.slice(0, 900)}`, durationMs: performance.now() - start2 };
           return [];
         }
       }
-      ffmpegCaptureArgs(device, outputPath3, attempt) {
+      ffmpegCaptureArgs(device, outputPath3, attempt, fps) {
         const argv = ["-hide_banner", "-loglevel", "error", "-f", "v4l2", "-thread_queue_size", "4"];
+        if (fps)
+          argv.push("-framerate", String(fps));
         if (attempt.inputFormat)
           argv.push("-input_format", attempt.inputFormat);
         if (attempt.videoSize)
@@ -604669,8 +604763,8 @@ transcribe-cli error: ${transcribeCliError}` : "";
 import { spawn as spawn30 } from "node:child_process";
 import { existsSync as existsSync112, mkdirSync as mkdirSync69, statSync as statSync43, unlinkSync as unlinkSync20 } from "node:fs";
 import { join as join127 } from "node:path";
-function streamFps() {
-  const raw = Number(process.env["OMNIUS_LIVE_STREAM_FPS"] ?? "");
+function streamFps(configured) {
+  const raw = configured ?? Number(process.env["OMNIUS_LIVE_STREAM_FPS"] ?? "");
   if (Number.isFinite(raw) && raw > 0) return Math.max(1, Math.min(30, Math.round(raw)));
   return 8;
 }
@@ -604751,7 +604845,7 @@ var init_camera_streamer = __esm({
        * Only v4l2 device paths are streamable; other backends (OSC/WiFi cams)
        * keep the one-shot capture path.
        */
-      sync(sources, rotationFor, resolutionFor) {
+      sync(sources, rotationFor, resolutionFor, fpsFor) {
         const wanted = new Set(sources.filter((source) => source.startsWith("/dev/video")));
         for (const [source, stream] of this.streams) {
           if (!wanted.has(source)) {
@@ -604762,20 +604856,21 @@ var init_camera_streamer = __esm({
         for (const source of wanted) {
           const rotation = rotationFor(source);
           const resolution = resolutionFor(source);
+          const fps = streamFps(fpsFor(source));
           const existing = this.streams.get(source);
-          if (existing && existing.rotation === rotation && existing.resolution === resolution && !existing.stopped) continue;
+          if (existing && existing.rotation === rotation && existing.resolution === resolution && existing.fps === fps && !existing.stopped) continue;
           if (existing) {
             this.stopStream(existing);
             this.streams.delete(source);
           }
-          this.startStream(source, rotation, resolution);
+          this.startStream(source, rotation, resolution, fps);
         }
       }
       stopAll() {
         for (const stream of this.streams.values()) this.stopStream(stream);
         this.streams.clear();
       }
-      startStream(source, rotation, resolution) {
+      startStream(source, rotation, resolution, fps) {
         try {
           mkdirSync69(this.streamDir, { recursive: true });
         } catch {
@@ -604785,6 +604880,7 @@ var init_camera_streamer = __esm({
           framePath: join127(this.streamDir, `${slugForSource(source)}.jpg`),
           rotation,
           resolution,
+          fps,
           process: null,
           attempt: 0,
           consecutiveFailures: 0,
@@ -604798,7 +604894,7 @@ var init_camera_streamer = __esm({
       }
       spawnStream(stream) {
         if (stream.stopped) return;
-        const fps = streamFps();
+        const fps = streamFps(stream.fps);
         const resolution = parseResolution(stream.resolution);
         const filters = [`fps=${fps}`];
         const scale = scaleFilter(resolution);
@@ -605482,6 +605578,17 @@ function formatLiveCameraResolution(value2) {
   if (res === "3840x2160") return "4K (3840x2160)";
   return res;
 }
+function normalizeLiveCameraFps(value2) {
+  if (value2 === void 0 || value2 === null || value2 === "") return DEFAULT_CAMERA_FPS;
+  const parsed = typeof value2 === "number" ? value2 : Number(String(value2).trim().toLowerCase().replace(/\s*fps$/, ""));
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Unsupported live camera FPS: ${String(value2)}. Use a number from 1 to 30.`);
+  }
+  return Math.max(1, Math.min(30, Math.round(parsed)));
+}
+function formatLiveCameraFps(value2) {
+  return `${normalizeLiveCameraFps(value2)} fps`;
+}
 function liveCameraResolutionSize(value2) {
   const res = value2 ?? DEFAULT_CAMERA_RESOLUTION;
   if (res === "native") return null;
@@ -605499,10 +605606,11 @@ function sanitizeCameraStreams(value2) {
     try {
       out[device] = {
         enabled: entry["enabled"] !== false,
-        resolution: normalizeLiveCameraResolution(entry["resolution"] ?? DEFAULT_CAMERA_RESOLUTION)
+        resolution: normalizeLiveCameraResolution(entry["resolution"] ?? DEFAULT_CAMERA_RESOLUTION),
+        fps: normalizeLiveCameraFps(entry["fps"] ?? entry["framerate"] ?? DEFAULT_CAMERA_FPS)
       };
     } catch {
-      out[device] = { enabled: entry["enabled"] !== false, resolution: DEFAULT_CAMERA_RESOLUTION };
+      out[device] = { enabled: entry["enabled"] !== false, resolution: DEFAULT_CAMERA_RESOLUTION, fps: DEFAULT_CAMERA_FPS };
     }
   }
   return out;
@@ -606641,7 +606749,7 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
     const orientation = snapshot.config.cameraOrientation?.[snapshot.config.selectedCamera];
     const stream = snapshot.config.cameraStreams?.[snapshot.config.selectedCamera];
     lines.push(`Selected camera: ${snapshot.config.selectedCamera}`);
-    lines.push(`Selected camera stream: ${stream?.enabled !== false ? "enabled" : "disabled"} ${formatLiveCameraResolution(stream?.resolution)}`);
+    lines.push(`Selected camera stream: ${stream?.enabled !== false ? "enabled" : "disabled"} ${formatLiveCameraResolution(stream?.resolution)} ${formatLiveCameraFps(stream?.fps)}`);
     lines.push(`Camera orientation correction: ${describeCameraOrientation(orientation)}`);
   }
   const cameraSnapshots = Object.values(snapshot.cameras ?? (snapshot.video ? { [snapshot.video.source]: snapshot.video } : {})).sort((a2, b) => {
@@ -607098,7 +607206,7 @@ function formatLiveStatus(snapshot) {
   const lines = [
     `Live streams: video=${cfg.videoEnabled ? "on" : "off"} infer=${cfg.inferEnabled ? "on" : "off"} clip=${cfg.clipEnabled ? "on" : "off"} audio=${cfg.audioEnabled ? "on" : "off"} asr=${cfg.asrEnabled ? "on" : "off"} sounds=${cfg.audioAnalysisEnabled ? "on" : "off"} output=${cfg.audioOutputEnabled ? "on" : "off"}`,
     `Camera: ${cfg.selectedCamera || "none"}`,
-    `Camera stream: ${cfg.selectedCamera ? `${cfg.cameraStreams?.[cfg.selectedCamera]?.enabled !== false ? "enabled" : "disabled"} ${formatLiveCameraResolution(cfg.cameraStreams?.[cfg.selectedCamera]?.resolution)}` : "none"}`,
+    `Camera stream: ${cfg.selectedCamera ? `${cfg.cameraStreams?.[cfg.selectedCamera]?.enabled !== false ? "enabled" : "disabled"} ${formatLiveCameraResolution(cfg.cameraStreams?.[cfg.selectedCamera]?.resolution)} ${formatLiveCameraFps(cfg.cameraStreams?.[cfg.selectedCamera]?.fps)}` : "none"}`,
     `Camera orientation: ${cfg.selectedCamera ? describeCameraOrientation(cfg.cameraOrientation?.[cfg.selectedCamera]) : "none"}`,
     `Audio input: ${cfg.selectedAudioInput || "none"}`,
     `Audio output: ${cfg.selectedAudioOutput || "none"}`,
@@ -607112,7 +607220,7 @@ function formatLiveStatus(snapshot) {
   }
   return lines.join("\n");
 }
-var MIN_VIDEO_INTERVAL_MS, LOW_LATENCY_VIDEO_INTERVAL_MS, MIN_AUDIO_INTERVAL_MS, LOW_LATENCY_AUDIO_INTERVAL_MS, AUDIO_ACTIVITY_INTERVAL_MS, AUDIO_ACTIVITY_SAMPLE_SEC, DEFAULT_CAMERA_RESOLUTION, DEFAULT_CONFIG7, managers, DASHBOARD_ANSI_STICKY_PATTERN, _liveDashboardMaximizedCamera, LiveSensorManager;
+var MIN_VIDEO_INTERVAL_MS, LOW_LATENCY_VIDEO_INTERVAL_MS, MIN_AUDIO_INTERVAL_MS, LOW_LATENCY_AUDIO_INTERVAL_MS, AUDIO_ACTIVITY_INTERVAL_MS, AUDIO_ACTIVITY_SAMPLE_SEC, DEFAULT_CAMERA_RESOLUTION, DEFAULT_CAMERA_FPS, DEFAULT_CONFIG7, managers, DASHBOARD_ANSI_STICKY_PATTERN, _liveDashboardMaximizedCamera, LiveSensorManager;
 var init_live_sensors = __esm({
   "packages/cli/src/tui/live-sensors.ts"() {
     "use strict";
@@ -607130,6 +607238,7 @@ var init_live_sensors = __esm({
     AUDIO_ACTIVITY_INTERVAL_MS = 200;
     AUDIO_ACTIVITY_SAMPLE_SEC = 0.2;
     DEFAULT_CAMERA_RESOLUTION = "1920x1080";
+    DEFAULT_CAMERA_FPS = 8;
     DEFAULT_CONFIG7 = {
       videoEnabled: false,
       audioEnabled: false,
@@ -607339,7 +607448,8 @@ var init_live_sensors = __esm({
                 ...this.config.cameraStreams ?? {},
                 [fallback]: {
                   enabled: true,
-                  resolution: this.config.cameraStreams?.[fallback]?.resolution ?? DEFAULT_CAMERA_RESOLUTION
+                  resolution: this.config.cameraStreams?.[fallback]?.resolution ?? DEFAULT_CAMERA_RESOLUTION,
+                  fps: this.config.cameraStreams?.[fallback]?.fps ?? DEFAULT_CAMERA_FPS
                 }
               }
             };
@@ -607360,13 +607470,18 @@ var init_live_sensors = __esm({
         const target = device || this.config.selectedCamera;
         return target ? this.config.cameraStreams?.[target]?.resolution ?? DEFAULT_CAMERA_RESOLUTION : DEFAULT_CAMERA_RESOLUTION;
       }
+      getCameraStreamFps(device = this.config.selectedCamera) {
+        const target = device || this.config.selectedCamera;
+        return target ? normalizeLiveCameraFps(this.config.cameraStreams?.[target]?.fps ?? DEFAULT_CAMERA_FPS) : DEFAULT_CAMERA_FPS;
+      }
       setCameraStreamEnabled(device, enabled2) {
         const target = device || this.config.selectedCamera;
         if (!target) return null;
         const current = this.config.cameraStreams?.[target];
         const next = {
           enabled: enabled2,
-          resolution: current?.resolution ?? DEFAULT_CAMERA_RESOLUTION
+          resolution: current?.resolution ?? DEFAULT_CAMERA_RESOLUTION,
+          fps: current?.fps ?? DEFAULT_CAMERA_FPS
         };
         this.config = {
           ...this.config,
@@ -607388,7 +607503,30 @@ var init_live_sensors = __esm({
         const current = this.config.cameraStreams?.[target];
         const next = {
           enabled: current?.enabled ?? target === this.config.selectedCamera,
-          resolution: normalizeLiveCameraResolution(resolution)
+          resolution: normalizeLiveCameraResolution(resolution),
+          fps: current?.fps ?? DEFAULT_CAMERA_FPS
+        };
+        this.config = {
+          ...this.config,
+          cameraStreams: {
+            ...this.config.cameraStreams ?? {},
+            [target]: next
+          }
+        };
+        this.videoGeneration++;
+        this.lastStreamFrameMtime.delete(target);
+        this.persist();
+        this.ensureLoops();
+        return next;
+      }
+      setCameraStreamFps(device, fps) {
+        const target = device || this.config.selectedCamera;
+        if (!target) return null;
+        const current = this.config.cameraStreams?.[target];
+        const next = {
+          enabled: current?.enabled ?? target === this.config.selectedCamera,
+          resolution: current?.resolution ?? DEFAULT_CAMERA_RESOLUTION,
+          fps: normalizeLiveCameraFps(fps)
         };
         this.config = {
           ...this.config,
@@ -607642,7 +607780,8 @@ var init_live_sensors = __esm({
           if (!device.id || /metadata\/non-capture/i.test(device.detail ?? "")) continue;
           next[device.id] = {
             enabled: current[device.id]?.enabled ?? device.id === selected,
-            resolution: current[device.id]?.resolution ?? DEFAULT_CAMERA_RESOLUTION
+            resolution: current[device.id]?.resolution ?? DEFAULT_CAMERA_RESOLUTION,
+            fps: current[device.id]?.fps ?? DEFAULT_CAMERA_FPS
           };
         }
         return next;
@@ -607662,7 +607801,8 @@ var init_live_sensors = __esm({
             ...this.config.cameraStreams ?? {},
             [selected]: {
               enabled: true,
-              resolution: this.config.cameraStreams?.[selected]?.resolution ?? DEFAULT_CAMERA_RESOLUTION
+              resolution: this.config.cameraStreams?.[selected]?.resolution ?? DEFAULT_CAMERA_RESOLUTION,
+              fps: this.config.cameraStreams?.[selected]?.fps ?? DEFAULT_CAMERA_FPS
             }
           };
         }
@@ -607882,7 +608022,8 @@ var init_live_sensors = __esm({
           action: "capture",
           device: source,
           rotate_degrees: rotation,
-          ...captureSize ? { width: captureSize.width, height: captureSize.height } : {}
+          ...captureSize ? { width: captureSize.width, height: captureSize.height } : {},
+          framerate: this.getCameraStreamFps(source)
         });
         if (!this.isVideoWorkCurrent(generation)) return { ok: false, message: "Video context is disabled." };
         if (!result.success) {
@@ -608502,7 +608643,8 @@ ${analysis}` : ""
         this.cameraStreamers.sync(
           this.activeVideoSources(),
           (source) => this.getCameraOrientation(source)?.rotation ?? 0,
-          (source) => this.getCameraStreamResolution(source)
+          (source) => this.getCameraStreamResolution(source),
+          (source) => this.getCameraStreamFps(source)
         );
       }
       previewTickIntervalMs() {
@@ -613305,12 +613447,16 @@ var init_command_registry = __esm({
       ["/livechat", "Alias for /live chat, used by the top live button"],
       ["/live camera <device>", "Select a camera and render an ASCII preview"],
       ["/live resolution [camera] 720p|1080p|1440p|4k|native", "Set per-camera live stream resolution (default 1080p)"],
+      ["/live fps [camera] 1|2|4|8|12|15|24|30", "Set per-camera live stream FPS (default 8)"],
       ["/live camera-on|camera-off [camera]", "Enable or disable an individual live camera stream"],
       ["/live rotate auto|cw|ccw|180|none [camera]", "Detect or set persistent camera orientation correction"],
       ["/live infer [now|on|off]", "Toggle or run camera object/location inference"],
       ["/live clip [on|off]", "Toggle CLIP visual-memory recognition on live frames"],
       ["/live audio|asr|sounds on|off", "Toggle live audio context streams"],
       ["/live stop", "Disable all live sensor streams"],
+      ["/camera", "Open compact camera preset menu shared with /live"],
+      ["/camera status", "Show selected camera and per-device presets"],
+      ["/camera select|preview|resolution|fps|rotate", "Manage camera source, preview, resolution, FPS, and orientation"],
       ["/paste", "Attach clipboard image content to the current or next prompt"],
       ["/image", "Open image-generation model/setup menu"],
       [
@@ -653830,6 +653976,10 @@ sleep 1
       await handleLiveCommand(ctx3, arg);
       return "handled";
     }
+    case "camera": {
+      await handleCameraCommand(ctx3, arg);
+      return "handled";
+    }
     case "livechat": {
       await handleLiveCommand(ctx3, "chat");
       return "handled";
@@ -659588,7 +659738,7 @@ async function chooseLiveDevice(ctx3, title, devices, activeKey) {
   return devices.find((device) => device.id === result.key) ?? null;
 }
 function liveCameraStreamSummary(manager, deviceId) {
-  return `${manager.isCameraStreamEnabled(deviceId) ? liveEnabled(true) : liveEnabled(false)} · ${formatLiveCameraResolution(manager.getCameraStreamResolution(deviceId))} · ${formatCameraRotation(manager.getCameraRotation(deviceId))}`;
+  return `${manager.isCameraStreamEnabled(deviceId) ? liveEnabled(true) : liveEnabled(false)} · ${formatLiveCameraResolution(manager.getCameraStreamResolution(deviceId))} · ${formatLiveCameraFps(manager.getCameraStreamFps(deviceId))} · ${formatCameraRotation(manager.getCameraRotation(deviceId))}`;
 }
 async function chooseLiveCameraResolution(ctx3, manager, deviceId) {
   const current = manager.getCameraStreamResolution(deviceId);
@@ -659607,11 +659757,29 @@ async function chooseLiveCameraResolution(ctx3, manager, deviceId) {
   if (!result.confirmed || !result.key) return null;
   return normalizeLiveCameraResolution(result.key);
 }
+async function chooseLiveCameraFps(ctx3, manager, deviceId) {
+  const current = manager.getCameraStreamFps(deviceId);
+  const choices = [1, 2, 4, 8, 12, 15, 24, 30];
+  const result = await tuiSelect({
+    items: choices.map((fps) => ({
+      key: String(fps),
+      label: formatLiveCameraFps(fps),
+      detail: fps <= 4 ? "lowest hardware burden" : fps === 8 ? "default balanced live stream rate" : "smoother preview, higher camera/CPU burden"
+    })),
+    title: `Camera FPS — ${deviceId}`,
+    activeKey: String(current),
+    rl: ctx3.rl,
+    availableRows: ctx3.availableContentRows?.()
+  });
+  if (!result.confirmed || !result.key) return null;
+  return normalizeLiveCameraFps(result.key);
+}
 async function showLiveCameraMenu(ctx3, manager, device) {
   while (true) {
     const selected = manager.getConfig().selectedCamera === device.id;
     const enabled2 = manager.isCameraStreamEnabled(device.id);
     const resolution = manager.getCameraStreamResolution(device.id);
+    const fps = manager.getCameraStreamFps(device.id);
     const items = [
       { key: "hdr:camera", label: selectColors.dim(`─── Camera ${device.id} ───`) },
       {
@@ -659633,6 +659801,11 @@ async function showLiveCameraMenu(ctx3, manager, device) {
         label: "Set Stream Resolution",
         detail: formatLiveCameraResolution(resolution)
       },
+      {
+        key: "fps",
+        label: "Set Stream FPS",
+        detail: formatLiveCameraFps(fps)
+      },
       {
         key: "preview",
         label: "Preview Camera",
@@ -659685,6 +659858,14 @@ async function showLiveCameraMenu(ctx3, manager, device) {
         }
         continue;
       }
+      case "fps": {
+        const next = await chooseLiveCameraFps(ctx3, manager, device.id);
+        if (next) {
+          manager.setCameraStreamFps(device.id, next);
+          renderInfo(`Camera ${device.id} stream FPS set to ${formatLiveCameraFps(next)}.`);
+        }
+        continue;
+      }
       case "preview":
         renderLivePreview(await manager.previewCamera(device.id));
         continue;
@@ -659808,6 +659989,28 @@ async function handleLiveCommand(ctx3, arg) {
     }
     return;
   }
+  if (sub2 === "fps" || sub2 === "framerate" || sub2 === "rate") {
+    await ensureLiveInventory(manager);
+    const tokens = parts.slice(1);
+    const rawFps = tokens.pop();
+    if (!rawFps) {
+      renderWarning("Usage: /live fps [camera] 1|2|4|8|12|15|24|30");
+      return;
+    }
+    const device = tokens.join(" ") || manager.getConfig().selectedCamera;
+    if (!device) {
+      renderWarning("No camera selected. Use /live camera <device> first.");
+      return;
+    }
+    try {
+      const fps = normalizeLiveCameraFps(rawFps);
+      manager.setCameraStreamFps(device, fps);
+      renderInfo(`Camera ${device} stream FPS set to ${formatLiveCameraFps(fps)}.`);
+    } catch (err) {
+      renderWarning(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
   if (sub2 === "camera-on" || sub2 === "camera-off" || sub2 === "camera-enable" || sub2 === "camera-disable") {
     await ensureLiveInventory(manager);
     const device = value2 || manager.getConfig().selectedCamera;
@@ -659906,6 +660109,222 @@ async function handleLiveCommand(ctx3, arg) {
   }
   await showLiveMenu(ctx3, manager);
 }
+function formatCameraStatus(manager) {
+  const snapshot = manager.getSnapshot();
+  const cfg = manager.getConfig();
+  const lines = [
+    `Selected camera: ${cfg.selectedCamera || "none"}`,
+    `Video context: ${cfg.videoEnabled ? "enabled" : "disabled"}`,
+    `Camera devices: ${snapshot.devices.video.length}`
+  ];
+  for (const device of snapshot.devices.video) {
+    lines.push(`- ${device.id}: ${liveCameraStreamSummary(manager, device.id)} — ${device.label}${device.detail ? ` — ${device.detail}` : ""}`);
+  }
+  return lines.join("\n");
+}
+async function showCameraMenu(ctx3, manager) {
+  await ensureLiveInventory(manager);
+  while (true) {
+    const snapshot = manager.getSnapshot();
+    const cfg = manager.getConfig();
+    const devices = snapshot.devices.video;
+    const items = [
+      { key: "hdr:camera", label: selectColors.dim("─── Camera Presets ───") },
+      {
+        key: "info:camera",
+        label: selectColors.dim(`  selected ${cfg.selectedCamera || "none"} · video ${liveEnabled(cfg.videoEnabled)} · ${devices.length} device(s)`)
+      },
+      {
+        key: "select",
+        label: "Select Primary Camera",
+        detail: liveDeviceSummary(devices, cfg.selectedCamera)
+      },
+      {
+        key: "preview",
+        label: "Preview Selected Camera",
+        detail: "uses selected resolution, fps, and orientation preset"
+      },
+      {
+        key: "toggle-video",
+        label: cfg.videoEnabled ? "Disable Video Context" : "Enable Video Context",
+        detail: "does not delete camera presets"
+      },
+      ...devices.map((device, index) => ({
+        key: `camera-device:${index}`,
+        label: `Camera: ${device.id}`,
+        detail: `${liveCameraStreamSummary(manager, device.id)} — ${device.label}${device.detail ? ` — ${device.detail}` : ""}`
+      })),
+      { key: "refresh", label: "Refresh Devices", detail: "rescan /dev/video* and audio/video inventory" },
+      { key: "status", label: "Show Camera Status", detail: "selected camera and per-device presets" }
+    ];
+    const result = await tuiSelect({
+      items,
+      title: "Camera Presets",
+      activeKey: cfg.selectedCamera ? "preview" : "select",
+      rl: ctx3.rl,
+      availableRows: ctx3.availableContentRows?.(),
+      skipKeys: liveSkipKeys(items),
+      customKeyHint: "  r refresh",
+      onCustomKey(_item, key, helpers) {
+        if (key === "r" || key === "R") {
+          void manager.refreshDevices().then(() => helpers.done()).catch(() => helpers.done());
+          return true;
+        }
+        return false;
+      }
+    });
+    if (!result.confirmed || !result.key) return;
+    if (result.key.startsWith("camera-device:")) {
+      const index = Number(result.key.slice("camera-device:".length));
+      const device = devices[index];
+      if (device) await showLiveCameraMenu(ctx3, manager, device);
+      continue;
+    }
+    switch (result.key) {
+      case "select": {
+        const device = await chooseLiveDevice(ctx3, "Select Camera", devices, cfg.selectedCamera);
+        if (device) {
+          manager.configure({ selectedCamera: device.id, videoEnabled: true });
+          manager.setCameraStreamEnabled(device.id, true);
+          renderInfo(`Selected camera ${device.id}.`);
+        }
+        continue;
+      }
+      case "preview":
+        renderLivePreview(await manager.previewCamera(cfg.selectedCamera));
+        continue;
+      case "toggle-video":
+        manager.configure({ videoEnabled: !cfg.videoEnabled });
+        continue;
+      case "refresh":
+        renderInfo(formatLiveInventory(await manager.refreshDevices()));
+        continue;
+      case "status":
+        renderInfo(formatCameraStatus(manager));
+        continue;
+      default:
+        return;
+    }
+  }
+}
+async function handleCameraCommand(ctx3, arg) {
+  const manager = getLiveSensorManager(ctx3.repoRoot);
+  attachLiveSinks(ctx3, manager);
+  const parts = arg.trim().split(/\s+/).filter(Boolean);
+  const sub2 = (parts[0] || "").toLowerCase();
+  const value2 = parts.slice(1).join(" ");
+  if (sub2 === "status") {
+    await ensureLiveInventory(manager);
+    renderInfo(formatCameraStatus(manager));
+    return;
+  }
+  if (sub2 === "refresh" || sub2 === "devices" || sub2 === "list") {
+    renderInfo(formatLiveInventory(await manager.refreshDevices()));
+    return;
+  }
+  if (sub2 === "preview" || sub2 === "view" || sub2 === "capture") {
+    await ensureLiveInventory(manager);
+    renderLivePreview(await manager.previewCamera(value2 || manager.getConfig().selectedCamera));
+    return;
+  }
+  if (sub2 === "select" || sub2 === "use") {
+    await ensureLiveInventory(manager);
+    const device = value2;
+    if (!device) {
+      const selected = await chooseLiveDevice(ctx3, "Select Camera", manager.getSnapshot().devices.video, manager.getConfig().selectedCamera);
+      if (selected) {
+        manager.configure({ selectedCamera: selected.id, videoEnabled: true });
+        manager.setCameraStreamEnabled(selected.id, true);
+        renderInfo(`Selected camera ${selected.id}.`);
+      }
+      return;
+    }
+    manager.configure({ selectedCamera: device, videoEnabled: true });
+    manager.setCameraStreamEnabled(device, true);
+    renderInfo(`Selected camera ${device}.`);
+    return;
+  }
+  if (sub2 === "on" || sub2 === "enable" || sub2 === "off" || sub2 === "disable") {
+    await ensureLiveInventory(manager);
+    const device = value2 || manager.getConfig().selectedCamera;
+    if (!device) {
+      renderWarning("No camera selected. Use /camera select <device> first.");
+      return;
+    }
+    const enabled2 = sub2 === "on" || sub2 === "enable";
+    manager.setCameraStreamEnabled(device, enabled2);
+    renderInfo(`${enabled2 ? "Enabled" : "Disabled"} camera stream ${device}.`);
+    return;
+  }
+  if (sub2 === "resolution" || sub2 === "res" || sub2 === "size") {
+    await ensureLiveInventory(manager);
+    const tokens = parts.slice(1);
+    const rawResolution = tokens.pop();
+    if (!rawResolution) {
+      renderWarning("Usage: /camera resolution [camera] 720p|1080p|1440p|4k|native");
+      return;
+    }
+    const device = tokens.join(" ") || manager.getConfig().selectedCamera;
+    if (!device) {
+      renderWarning("No camera selected. Use /camera select <device> first.");
+      return;
+    }
+    try {
+      const resolution = normalizeLiveCameraResolution(rawResolution);
+      manager.setCameraStreamResolution(device, resolution);
+      renderInfo(`Camera ${device} stream resolution set to ${formatLiveCameraResolution(resolution)}.`);
+    } catch (err) {
+      renderWarning(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
+  if (sub2 === "fps" || sub2 === "framerate" || sub2 === "rate") {
+    await ensureLiveInventory(manager);
+    const tokens = parts.slice(1);
+    const rawFps = tokens.pop();
+    if (!rawFps) {
+      renderWarning("Usage: /camera fps [camera] 1|2|4|8|12|15|24|30");
+      return;
+    }
+    const device = tokens.join(" ") || manager.getConfig().selectedCamera;
+    if (!device) {
+      renderWarning("No camera selected. Use /camera select <device> first.");
+      return;
+    }
+    try {
+      const fps = normalizeLiveCameraFps(rawFps);
+      manager.setCameraStreamFps(device, fps);
+      renderInfo(`Camera ${device} stream FPS set to ${formatLiveCameraFps(fps)}.`);
+    } catch (err) {
+      renderWarning(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
+  if (sub2 === "rotate" || sub2 === "rotation" || sub2 === "orient" || sub2 === "orientation") {
+    await ensureLiveInventory(manager);
+    const mode = (parts[1] || "cycle").toLowerCase();
+    const deviceArg = parts.slice(2).join(" ") || manager.getConfig().selectedCamera;
+    if (mode === "auto" || mode === "detect") {
+      renderInfo("Detecting camera orientation...");
+      renderInfo(await manager.autoOrientCamera(deviceArg));
+      return;
+    }
+    if (mode === "cycle") {
+      const orientation = manager.cycleCameraRotation(deviceArg);
+      renderInfo(orientation ? `Camera rotation set to ${formatCameraRotation(orientation.rotation)} for ${deviceArg || manager.getConfig().selectedCamera || "selected camera"}.` : "No camera selected. Use /camera select <device> first.");
+      return;
+    }
+    try {
+      const rotation = normalizeLiveCameraRotation(mode);
+      const orientation = manager.setCameraRotation(deviceArg, rotation, "manual", `/camera rotate ${mode}`);
+      renderInfo(orientation ? `Camera rotation set to ${formatCameraRotation(orientation.rotation)} for ${deviceArg || manager.getConfig().selectedCamera || "selected camera"}.` : "No camera selected. Use /camera select <device> first.");
+    } catch (err) {
+      renderWarning(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
+  await showCameraMenu(ctx3, manager);
+}
 async function showLiveMenu(ctx3, manager) {
   await ensureLiveInventory(manager);
   while (true) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.434",
+  "version": "1.0.435",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.434",
+      "version": "1.0.435",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.434",
+  "version": "1.0.435",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",