omnius 1.0.406 → 1.0.407

package/dist/index.js

@@ -542978,9 +542978,45 @@ var init_process_health = __esm({
 });
 
 // packages/execution/dist/tools/camera-capture.js
-import { accessSync, constants, readFileSync as readFileSync44, writeFileSync as writeFileSync28, unlinkSync as unlinkSync11, existsSync as existsSync60, mkdirSync as mkdirSync34, readdirSync as readdirSync21 } from "node:fs";
+import { accessSync, constants, readFileSync as readFileSync44, writeFileSync as writeFileSync28, unlinkSync as unlinkSync11, existsSync as existsSync60, mkdirSync as mkdirSync34, readdirSync as readdirSync21, renameSync as renameSync7 } from "node:fs";
 import { join as join75 } from "node:path";
 import { tmpdir as tmpdir10 } from "node:os";
+function normalizeCameraRotationDegrees(value2) {
+  if (value2 === void 0 || value2 === null || value2 === "")
+    return 0;
+  if (typeof value2 === "number" && Number.isFinite(value2)) {
+    const n2 = (Math.round(value2) % 360 + 360) % 360;
+    if (n2 === 0 || n2 === 90 || n2 === 180 || n2 === 270)
+      return n2;
+  }
+  const raw = String(value2).trim().toLowerCase();
+  if (!raw)
+    return 0;
+  const numeric = Number(raw.replace(/deg(?:rees)?$/i, ""));
+  if (Number.isFinite(numeric))
+    return normalizeCameraRotationDegrees(numeric);
+  if (["none", "off", "upright", "normal", "0"].includes(raw))
+    return 0;
+  if (["cw", "clockwise", "right", "rotate-cw", "rotate_cw", "90"].includes(raw))
+    return 90;
+  if (["180", "upside-down", "upside_down", "flip", "inverted"].includes(raw))
+    return 180;
+  if (["ccw", "counterclockwise", "counter-clockwise", "anticlockwise", "left", "rotate-ccw", "rotate_ccw", "270"].includes(raw))
+    return 270;
+  throw new Error(`Unsupported camera rotation: ${String(value2)}. Use 0, 90, 180, 270, cw, ccw, or none.`);
+}
+function ffmpegRotateFilterForDegrees(rotation) {
+  switch (rotation) {
+    case 0:
+      return null;
+    case 90:
+      return "transpose=1";
+    case 180:
+      return "hflip,vflip";
+    case 270:
+      return "transpose=2";
+  }
+}
 function sleep3(ms) {
   return new Promise((resolve76) => setTimeout(resolve76, ms));
 }
@@ -543216,6 +543252,21 @@ var init_camera_capture = __esm({
             type: "number",
             description: "Capture height in pixels (default: 720 for USB, native for QooCam)"
           },
+          rotate_degrees: {
+            type: "number",
+            enum: [0, 90, 180, 270],
+            description: "Optional clockwise correction applied to the captured frame before saving/returning. Use 90 for clockwise, 270 for counter-clockwise."
+          },
+          rotation_degrees: {
+            type: "number",
+            enum: [0, 90, 180, 270],
+            description: "Alias for rotate_degrees."
+          },
+          rotate: {
+            type: "string",
+            enum: ["none", "cw", "ccw", "180", "clockwise", "counterclockwise"],
+            description: "Optional human-readable rotation alias. Equivalent to rotate_degrees."
+          },
           output_path: {
             type: "string",
             description: "Save captured image to this path instead of returning base64"
@@ -543426,6 +543477,7 @@ ${formatRouterPlan(plan)}`,
         const width = args["width"] || 1280;
         const height = args["height"] || 720;
         const outputPath3 = args["output_path"];
+        const rotation = normalizeCameraRotationDegrees(args["rotate_degrees"] ?? args["rotation_degrees"] ?? args["rotate"]);
         const captureDir = join75(tmpdir10(), "omnius-camera");
         if (!existsSync60(captureDir))
           mkdirSync34(captureDir, { recursive: true });
@@ -543484,10 +543536,25 @@ ${formatRouterPlan(plan)}`,
           return false;
         };
         if (await runAttempts()) {
+          if (rotation !== 0) {
+            try {
+              await this.rotateCapturedImage(tempFile, rotation);
+            } catch (err) {
+              return {
+                success: false,
+                output: "",
+                error: `Captured from ${device}, but failed to apply ${rotation} degree rotation: ${err instanceof Error ? err.message : String(err)}`,
+                durationMs: performance.now() - start2
+              };
+            }
+          }
           const firstSuccess = errors.length > 0 ? `
 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 result = this.returnCapturedFile(tempFile, captureState.successfulAttempt?.videoSize ?? `${width}x${height}`, device, outputPath3, start2);
-          return result.success && firstSuccess ? { ...result, output: result.output + firstSuccess, llmContent: result.llmContent ? result.llmContent + firstSuccess : result.llmContent } : result;
+          const notes = `${firstSuccess}${rotationNote}`;
+          return result.success && notes ? { ...result, output: result.output + notes, llmContent: result.llmContent ? result.llmContent + notes : result.llmContent } : result;
         }
         const allErrors = errors.join("\n\n");
         if (permissionBlocked || cameraFfmpegErrorIsPermissionDenied(allErrors)) {
@@ -543576,6 +543643,37 @@ ${allErrors.slice(0, 900)}`, durationMs: performance.now() - start2 };
         argv.push("-y", outputPath3);
         return argv;
       }
+      async rotateCapturedImage(filePath, rotation) {
+        const vf = ffmpegRotateFilterForDegrees(rotation);
+        if (!vf)
+          return;
+        const rotatedPath = `${filePath}.rotated-${Date.now()}.jpg`;
+        try {
+          await runProcessBuffer(ffmpegBin2(), [
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-y",
+            "-i",
+            filePath,
+            "-vf",
+            vf,
+            "-q:v",
+            "2",
+            rotatedPath
+          ], { timeout: 15e3 });
+          if (!existsSync60(rotatedPath) || readFileSync44(rotatedPath).length === 0) {
+            throw new Error("ffmpeg produced no rotated image bytes");
+          }
+          renameSync7(rotatedPath, filePath);
+        } finally {
+          try {
+            if (existsSync60(rotatedPath))
+              unlinkSync11(rotatedPath);
+          } catch {
+          }
+        }
+      }
       async v4l2Info(device, start2) {
         let info = `Camera: ${device} [v4l2]
 `;
@@ -543726,6 +543824,7 @@ Auto-installed camera dependencies: ${[
       /** Capture a frame from QooCam via OSC API */
       async captureQooCam(args, start2) {
         const outputPath3 = args["output_path"];
+        const rotation = normalizeCameraRotationDegrees(args["rotate_degrees"] ?? args["rotation_degrees"] ?? args["rotate"]);
         const conn = await this.connectQooCamWiFi();
         if (!conn.connected) {
           return { success: false, output: "", error: conn.error || "Could not connect to QooCam", durationMs: performance.now() - start2 };
@@ -543745,13 +543844,13 @@ Auto-installed camera dependencies: ${[
         let width = 0;
         let height = 0;
         try {
-          const result = await this.oscFetch("POST", "/osc/commands/execute", {
+          const result2 = await this.oscFetch("POST", "/osc/commands/execute", {
             name: "camera.takePicture"
           });
-          if (result?.state === "error") {
-            return { success: false, output: "", error: `QooCam capture failed: ${result.error?.message || JSON.stringify(result.error)}`, durationMs: performance.now() - start2 };
+          if (result2?.state === "error") {
+            return { success: false, output: "", error: `QooCam capture failed: ${result2.error?.message || JSON.stringify(result2.error)}`, durationMs: performance.now() - start2 };
           }
-          const entry = result?.results?.entries?.[0];
+          const entry = result2?.results?.entries?.[0];
           if (!entry?.fileUrl) {
             return { success: false, output: "", error: "QooCam took a picture but returned no file URL", durationMs: performance.now() - start2 };
           }
@@ -543775,8 +543874,27 @@ Auto-installed camera dependencies: ${[
         } catch (err) {
           return { success: false, output: "", error: `Failed to download frame from QooCam: ${err instanceof Error ? err.message : String(err)}`, durationMs: performance.now() - start2 };
         }
+        if (rotation !== 0) {
+          try {
+            await this.rotateCapturedImage(tempFile, rotation);
+          } catch (err) {
+            return {
+              success: false,
+              output: "",
+              error: `Downloaded QooCam frame, but failed to apply ${rotation} degree rotation: ${err instanceof Error ? err.message : String(err)}`,
+              durationMs: performance.now() - start2
+            };
+          }
+        }
         const res = width && height ? `${width}x${height}` : "native";
-        return this.returnCapturedFile(tempFile, res, "QooCam 8K (OSC/WiFi)", outputPath3, start2);
+        const result = this.returnCapturedFile(tempFile, res, "QooCam 8K (OSC/WiFi)", outputPath3, start2);
+        return result.success && rotation !== 0 ? {
+          ...result,
+          output: `${result.output}
+Applied camera rotation correction: ${rotation} degrees clockwise.`,
+          llmContent: result.llmContent ? `${result.llmContent}
+Applied camera rotation correction: ${rotation} degrees clockwise.` : result.llmContent
+        } : result;
       }
       /** Get QooCam info via OSC */
       async qoocamInfo(start2) {
@@ -553723,7 +553841,7 @@ var init_plugin_system = __esm({
 });
 
 // packages/execution/dist/tools/notebook-edit.js
-import { readFileSync as readFileSync54, writeFileSync as writeFileSync37, existsSync as existsSync74, renameSync as renameSync7, unlinkSync as unlinkSync15 } from "node:fs";
+import { readFileSync as readFileSync54, writeFileSync as writeFileSync37, existsSync as existsSync74, renameSync as renameSync8, unlinkSync as unlinkSync15 } from "node:fs";
 import { resolve as resolve43 } from "node:path";
 function readNotebook(path12) {
   if (!existsSync74(path12))
@@ -553744,7 +553862,7 @@ function writeNotebook(path12, nb) {
   const tempPath = `${path12}.tmp-${process.pid}-${Date.now()}`;
   writeFileSync37(tempPath, JSON.stringify(nb, null, 1) + "\n", "utf8");
   try {
-    renameSync7(tempPath, path12);
+    renameSync8(tempPath, path12);
   } catch (err) {
     try {
       unlinkSync15(tempPath);
@@ -555483,6 +555601,15 @@ function makePythonScript() {
   return String.raw`
 import json, os, sys, time
 
+def apply_rotation(frame, rotate_degrees, cv2):
+    if rotate_degrees == 90:
+        return cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
+    if rotate_degrees == 180:
+        return cv2.rotate(frame, cv2.ROTATE_180)
+    if rotate_degrees == 270:
+        return cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
+    return frame
+
 def main():
     cfg_path = sys.argv[1]
     with open(cfg_path, "r", encoding="utf-8") as f:
@@ -555494,6 +555621,7 @@ def main():
     source_kind = cfg["source_kind"]
     source = cfg["source"]
     media_path = None
+    rotate_degrees = int(cfg.get("rotate_degrees") or 0)
 
     try:
         import cv2
@@ -555567,6 +555695,7 @@ def main():
         ret, frame = cap.read()
         if not ret:
             break
+        frame = apply_rotation(frame, rotate_degrees, cv2)
         ts = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
         if not ts or ts < 0:
             ts = time.time() - start_wall
@@ -555649,6 +555778,7 @@ def main():
         "output_dir": out_dir,
         "yolo_model": yolo_model,
         "yolo_live": True,
+        "rotate_degrees": rotate_degrees,
         "frames_sampled": frame_index,
         "duration_observed_sec": round(float(duration if source_kind != "camera" else time.time() - start_wall), 3),
         "objects": objects,
@@ -555662,6 +555792,7 @@ if __name__ == "__main__":
 }
 function mockResult(args, workingDir) {
   const kind = sourceKind(args);
+  const rotation = normalizeCameraRotationDegrees(args["rotate_degrees"] ?? args["rotation_degrees"] ?? args["rotate"]);
   const outDir = join92(workingDir, ".omnius", "live-media", `mock-${Date.now().toString(36)}`);
   mkdirSync47(join92(outDir, "crops"), { recursive: true });
   const facePath = join92(outDir, "crops", "face_f0000_00.jpg");
@@ -555673,6 +555804,7 @@ function mockResult(args, workingDir) {
     output_dir: outDir,
     yolo_model: String(args["yolo_model"] ?? DEFAULT_YOLO26_MODEL),
     yolo_live: false,
+    rotate_degrees: rotation,
     frames_sampled: 3,
     duration_observed_sec: Number(args["duration_sec"] ?? 3),
     objects: [
@@ -555694,6 +555826,7 @@ var init_live_media_loop = __esm({
     init_process_async();
     init_venv_paths();
     init_audio_analyze();
+    init_camera_capture();
     init_transcribe_tool();
     init_visual_memory();
     init_visual_trigger();
@@ -555713,6 +555846,9 @@ var init_live_media_loop = __esm({
           path: { type: "string", description: "Local media path" },
           file: { type: "string", description: "Alias for path" },
           camera: { type: ["string", "number"], description: "Camera device index/path" },
+          rotate_degrees: { type: "number", enum: [0, 90, 180, 270], description: "Clockwise correction applied to sampled frames before object tracking and face crops." },
+          rotation_degrees: { type: "number", enum: [0, 90, 180, 270], description: "Alias for rotate_degrees." },
+          rotate: { type: "string", enum: ["none", "cw", "ccw", "180", "clockwise", "counterclockwise"], description: "Optional human-readable rotation alias." },
           duration_sec: { type: "number", description: "Bounded watch duration, default 8" },
           sample_interval_sec: { type: "number", description: "Seconds between sampled frames, default 1" },
           max_frames: { type: "number", description: "Max sampled frames, default 8" },
@@ -555736,6 +555872,7 @@ var init_live_media_loop = __esm({
         const start2 = performance.now();
         const action = String(args["action"] ?? "watch").toLowerCase();
         const yoloModel = String(args["yolo_model"] ?? DEFAULT_YOLO26_MODEL);
+        const rotation = normalizeCameraRotationDegrees(args["rotate_degrees"] ?? args["rotation_degrees"] ?? args["rotate"]);
         const plan = buildYolo26BootstrapPlan(yoloModel);
         if (action === "status" || action === "ensure") {
           const runtime = action === "ensure" ? await ensureRuntime(args["auto_bootstrap"] !== false) : await ensureRuntime(false);
@@ -555780,6 +555917,7 @@ var init_live_media_loop = __esm({
             duration_sec: Number(args["duration_sec"] ?? 8),
             sample_interval_sec: Number(args["sample_interval_sec"] ?? 1),
             max_frames: Number(args["max_frames"] ?? 8),
+            rotate_degrees: rotation,
             detect_objects: args["detect_objects"] !== false,
             track_objects: args["track_objects"] !== false,
             crop_faces: args["crop_faces"] !== false,
@@ -555872,6 +556010,8 @@ var init_live_media_loop = __esm({
         if (result.media_path)
           lines.push(`media: ${result.media_path}`);
         lines.push(`YOLO model: ${result.yolo_model} (${result.yolo_live ? "live" : "mock/harness"})`);
+        if (result.rotate_degrees)
+          lines.push(`frame rotation correction: ${result.rotate_degrees} degrees clockwise`);
         lines.push(`sampled: ${result.frames_sampled} frame(s) over ${result.duration_observed_sec.toFixed(1)}s`);
         lines.push(`objects: ${result.objects.length} detection(s), tracks: ${result.tracks.length}, face crops: ${result.faces.length}`);
         const objectSummary = summarizeObjects(result.objects);
@@ -555918,6 +556058,7 @@ var init_live_media_loop = __esm({
             media_path: result.media_path,
             yolo_model: result.yolo_model,
             yolo_live: result.yolo_live,
+            rotate_degrees: result.rotate_degrees ?? 0,
             frames_sampled: result.frames_sampled,
             objects: result.objects.slice(0, 80),
             tracks: result.tracks.slice(0, 40),
@@ -569468,7 +569609,7 @@ var init_memory_consolidation = __esm({
 });
 
 // packages/orchestrator/dist/consolidation-runtime.js
-import { existsSync as existsSync97, mkdirSync as mkdirSync56, readFileSync as readFileSync74, writeFileSync as writeFileSync46, renameSync as renameSync8 } from "node:fs";
+import { existsSync as existsSync97, mkdirSync as mkdirSync56, readFileSync as readFileSync74, writeFileSync as writeFileSync46, renameSync as renameSync9 } from "node:fs";
 import { homedir as homedir33 } from "node:os";
 import { join as join108, dirname as dirname35 } from "node:path";
 function storePath2() {
@@ -569490,7 +569631,7 @@ function save2(s2) {
     mkdirSync56(dirname35(p2), { recursive: true });
     const tmp = `${p2}.tmp`;
     writeFileSync46(tmp, JSON.stringify(s2), "utf8");
-    renameSync8(tmp, p2);
+    renameSync9(tmp, p2);
   } catch {
   }
 }
@@ -597786,7 +597927,7 @@ var init_agent_task = __esm({
 });
 
 // packages/orchestrator/dist/task-recovery.js
-import { existsSync as existsSync105, readFileSync as readFileSync81, writeFileSync as writeFileSync51, mkdirSync as mkdirSync61, readdirSync as readdirSync33, renameSync as renameSync9, unlinkSync as unlinkSync19 } from "node:fs";
+import { existsSync as existsSync105, readFileSync as readFileSync81, writeFileSync as writeFileSync51, mkdirSync as mkdirSync61, readdirSync as readdirSync33, renameSync as renameSync10, unlinkSync as unlinkSync19 } from "node:fs";
 import { join as join117 } from "node:path";
 import { homedir as homedir36 } from "node:os";
 function sidecarDir() {
@@ -597803,7 +597944,7 @@ function persistAgentTaskSidecar(task) {
     const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
     const { abortController: _ignore, ...serializable } = task;
     writeFileSync51(tmpPath, JSON.stringify(serializable, null, 2), "utf-8");
-    renameSync9(tmpPath, finalPath);
+    renameSync10(tmpPath, finalPath);
   } catch {
   }
 }
@@ -601956,6 +602097,75 @@ function parseJsonObject3(value2) {
     return null;
   }
 }
+function parseJsonObjectFromText(value2) {
+  const direct = parseJsonObject3(value2);
+  if (direct) return direct;
+  const text2 = String(value2 ?? "");
+  const start2 = text2.indexOf("{");
+  const end = text2.lastIndexOf("}");
+  if (start2 < 0 || end <= start2) return null;
+  return parseJsonObject3(text2.slice(start2, end + 1));
+}
+function normalizeLiveCameraRotation(value2) {
+  if (value2 === void 0 || value2 === null || value2 === "") return 0;
+  if (typeof value2 === "number" && Number.isFinite(value2)) {
+    const n2 = (Math.round(value2) % 360 + 360) % 360;
+    if (n2 === 0 || n2 === 90 || n2 === 180 || n2 === 270) return n2;
+  }
+  const raw = String(value2).trim().toLowerCase();
+  const numeric = Number(raw.replace(/deg(?:rees)?$/i, ""));
+  if (Number.isFinite(numeric)) return normalizeLiveCameraRotation(numeric);
+  if (["none", "off", "upright", "normal", "0"].includes(raw)) return 0;
+  if (["cw", "clockwise", "right", "rotate-cw", "rotate_cw", "90"].includes(raw)) return 90;
+  if (["180", "upside-down", "upside_down", "flip", "inverted"].includes(raw)) return 180;
+  if (["ccw", "counterclockwise", "counter-clockwise", "counter_clockwise", "anticlockwise", "left", "rotate-ccw", "rotate_ccw", "270"].includes(raw)) return 270;
+  throw new Error(`Unsupported camera rotation: ${String(value2)}. Use 0, 90, 180, 270, cw, ccw, or none.`);
+}
+function parseCameraOrientationDecision(value2) {
+  const parsed = parseJsonObjectFromText(value2);
+  if (!parsed) return null;
+  const rawRotation = parsed["rotation_degrees"] ?? parsed["correction_degrees"] ?? parsed["rotate_degrees"] ?? parsed["rotation"] ?? parsed["correction"];
+  if (rawRotation === void 0 || rawRotation === null || rawRotation === "") return null;
+  let rotation;
+  try {
+    rotation = normalizeLiveCameraRotation(rawRotation);
+  } catch {
+    return null;
+  }
+  const confidenceNumber = Number(parsed["confidence"]);
+  const confidence2 = Number.isFinite(confidenceNumber) ? Math.max(0, Math.min(1, confidenceNumber)) : void 0;
+  const reason = typeof parsed["reason"] === "string" ? boundedText(parsed["reason"], 240) : typeof parsed["evidence"] === "string" ? boundedText(parsed["evidence"], 240) : void 0;
+  return { rotation, confidence: confidence2, reason };
+}
+function formatCameraRotation(rotation) {
+  if (rotation === 0) return "upright/no correction";
+  if (rotation === 90) return "90 degrees clockwise";
+  if (rotation === 180) return "180 degrees";
+  return "90 degrees counter-clockwise";
+}
+function sanitizeCameraOrientation(value2) {
+  if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) return {};
+  const out = {};
+  for (const [device, raw] of Object.entries(value2)) {
+    if (!device || typeof raw !== "object" || raw === null || Array.isArray(raw)) continue;
+    const entry = raw;
+    try {
+      out[device] = {
+        rotation: normalizeLiveCameraRotation(entry["rotation"]),
+        source: entry["source"] === "manual" ? "manual" : "auto",
+        updatedAt: Math.max(0, Number(entry["updatedAt"] ?? Date.now())),
+        confidence: typeof entry["confidence"] === "number" ? Math.max(0, Math.min(1, entry["confidence"])) : void 0,
+        evidence: typeof entry["evidence"] === "string" ? boundedText(entry["evidence"], 800) : void 0
+      };
+    } catch {
+    }
+  }
+  return out;
+}
+function describeCameraOrientation(orientation) {
+  if (!orientation) return "upright/no correction (default)";
+  return `${formatCameraRotation(orientation.rotation)} (${orientation.source}${orientation.confidence !== void 0 ? ` confidence=${orientation.confidence.toFixed(2)}` : ""}, updated=${nowIso3(orientation.updatedAt)})`;
+}
 function parseLiveMediaPayload(value2) {
   const parsed = parseJsonObject3(value2);
   if (!parsed) return null;
@@ -602180,6 +602390,7 @@ function loadLiveSensorConfig(repoRoot) {
     return {
       ...DEFAULT_CONFIG7,
       ...parsed,
+      cameraOrientation: sanitizeCameraOrientation(parsed.cameraOrientation),
       videoIntervalMs: Math.max(1500, Number(parsed.videoIntervalMs ?? DEFAULT_CONFIG7.videoIntervalMs)),
       audioIntervalMs: Math.max(3e3, Number(parsed.audioIntervalMs ?? DEFAULT_CONFIG7.audioIntervalMs))
     };
@@ -602208,11 +602419,15 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
   lines.push("Live sensor context is operator-enabled ambient input. Treat it as current perceptual evidence for this turn; if it is stale, missing, or insufficient, use camera/audio tools to refresh before answering what you see or hear.");
   lines.push("Identity rule: never invent names for observed people. If a person is unknown and identity matters, ask the user or the person for their name, then store the association with visual_memory(action='enroll', image='<face crop>', name='<name>') when a face crop is available, or multimodal_memory(action='meet', person_name='<name>') when live voice/name context is available.");
   lines.push(`Snapshot file: ${liveSnapshotPath(snapshot.repoRoot)}`);
-  lines.push(`Streams: video=${snapshot.config.videoEnabled ? "on" : "off"} infer=${snapshot.config.inferEnabled ? "on" : "off"} audio=${snapshot.config.audioEnabled ? "on" : "off"} asr=${snapshot.config.asrEnabled ? "on" : "off"} sounds=${snapshot.config.audioAnalysisEnabled ? "on" : "off"} output-monitor=${snapshot.config.audioOutputEnabled ? "on" : "off"}`);
-  if (snapshot.config.selectedCamera) lines.push(`Selected camera: ${snapshot.config.selectedCamera}`);
+  lines.push(`Streams: video=${snapshot.config.videoEnabled ? "on" : "off"} infer=${snapshot.config.inferEnabled ? "on" : "off"} clip=${snapshot.config.clipEnabled ? "on" : "off"} audio=${snapshot.config.audioEnabled ? "on" : "off"} asr=${snapshot.config.asrEnabled ? "on" : "off"} sounds=${snapshot.config.audioAnalysisEnabled ? "on" : "off"} output-monitor=${snapshot.config.audioOutputEnabled ? "on" : "off"}`);
+  if (snapshot.config.selectedCamera) {
+    const orientation = snapshot.config.cameraOrientation?.[snapshot.config.selectedCamera];
+    lines.push(`Selected camera: ${snapshot.config.selectedCamera}`);
+    lines.push(`Camera orientation correction: ${describeCameraOrientation(orientation)}`);
+  }
   if (snapshot.config.selectedAudioInput) lines.push(`Selected audio input: ${snapshot.config.selectedAudioInput}`);
   if (snapshot.config.selectedAudioOutput) lines.push(`Selected audio output: ${snapshot.config.selectedAudioOutput}`);
-  const cameraEvents = (snapshot.events ?? []).filter((event) => event.kind.startsWith("camera_") || event.kind === "visual_trigger").sort((a2, b) => b.observedAt - a2.observedAt).slice(0, 18);
+  const cameraEvents = (snapshot.events ?? []).filter((event) => event.kind.startsWith("camera_") || event.kind === "clip_recognition" || event.kind === "visual_trigger").sort((a2, b) => b.observedAt - a2.observedAt).slice(0, 18);
   if (activeVideo) {
     lines.push("");
     lines.push("## LIVE CAMERA EVENTS");
@@ -602257,7 +602472,7 @@ function formatLiveSensorContextFromSnapshot(snapshot, opts = {}) {
     const age = now2 - snapshot.video.updatedAt;
     lines.push("");
     lines.push("## LIVE CAMERA LATEST FRAME");
-    lines.push(`timestamp: ${nowIso3(snapshot.video.updatedAt)} age=${Math.max(0, Math.round(age / 1e3))}s source=${snapshot.video.source}${age > maxAgeMs ? " STALE" : ""}`);
+    lines.push(`timestamp: ${nowIso3(snapshot.video.updatedAt)} age=${Math.max(0, Math.round(age / 1e3))}s source=${snapshot.video.source}${snapshot.video.orientation ? ` rotation=${formatCameraRotation(snapshot.video.orientation.rotation)}` : ""}${age > maxAgeMs ? " STALE" : ""}`);
     if (snapshot.video.error) lines.push(`error: ${snapshot.video.error}`);
     if (snapshot.video.framePath) lines.push(`frame: ${snapshot.video.framePath}`);
     if (snapshot.video.asciiContext) lines.push(snapshot.video.asciiContext);
@@ -602401,8 +602616,9 @@ function formatLiveInventory(inventory) {
 function formatLiveStatus(snapshot) {
   const cfg = snapshot.config;
   const lines = [
-    `Live streams: video=${cfg.videoEnabled ? "on" : "off"} infer=${cfg.inferEnabled ? "on" : "off"} audio=${cfg.audioEnabled ? "on" : "off"} asr=${cfg.asrEnabled ? "on" : "off"} sounds=${cfg.audioAnalysisEnabled ? "on" : "off"} output=${cfg.audioOutputEnabled ? "on" : "off"}`,
+    `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 orientation: ${cfg.selectedCamera ? describeCameraOrientation(cfg.cameraOrientation?.[cfg.selectedCamera]) : "none"}`,
     `Audio input: ${cfg.selectedAudioInput || "none"}`,
     `Audio output: ${cfg.selectedAudioOutput || "none"}`,
     `Snapshot: ${liveSnapshotPath(snapshot.repoRoot)}`
@@ -602427,8 +602643,10 @@ var init_live_sensors = __esm({
       audioEnabled: false,
       audioOutputEnabled: false,
       inferEnabled: false,
+      clipEnabled: false,
       asrEnabled: false,
       audioAnalysisEnabled: false,
+      cameraOrientation: {},
       videoIntervalMs: 5e3,
       audioIntervalMs: 9e3
     };
@@ -602454,16 +602672,124 @@ var init_live_sensors = __esm({
       videoInFlight = false;
       audioInFlight = false;
       statusSink = null;
+      feedbackSink = null;
+      agentActionSink = null;
+      agentActionEnabled = false;
+      lastAgentReviewAt = 0;
+      autoOrientationInFlight = /* @__PURE__ */ new Set();
       setStatusSink(sink) {
         this.statusSink = sink ?? null;
         this.emitStatus();
       }
+      setFeedbackSink(sink) {
+        this.feedbackSink = sink ?? null;
+      }
+      setAgentActionSink(sink) {
+        this.agentActionSink = sink ?? null;
+      }
       getConfig() {
         return { ...this.config };
       }
       getSnapshot() {
         return this.snapshot;
       }
+      getCameraOrientation(device = this.config.selectedCamera) {
+        return device ? this.config.cameraOrientation?.[device] : void 0;
+      }
+      getCameraRotation(device = this.config.selectedCamera) {
+        return this.getCameraOrientation(device)?.rotation ?? 0;
+      }
+      setCameraRotation(device, rotation, source, evidence, confidence2) {
+        const target = device || this.config.selectedCamera || firstDeviceId(this.devices.video);
+        if (!target) return null;
+        const orientation = {
+          rotation,
+          source,
+          updatedAt: Date.now(),
+          confidence: confidence2,
+          evidence: evidence ? boundedText(evidence, 800) : void 0
+        };
+        this.config = {
+          ...this.config,
+          selectedCamera: target,
+          cameraOrientation: {
+            ...this.config.cameraOrientation ?? {},
+            [target]: orientation
+          }
+        };
+        this.snapshot.events = mergeRecentById(this.snapshot.events, [{
+          id: stableEventId("camera_orientation", target, orientation.updatedAt, `${source}:${rotation}`),
+          kind: "camera_orientation",
+          observedAt: orientation.updatedAt,
+          source: target,
+          title: "Camera orientation correction updated",
+          summary: `${target}: ${formatCameraRotation(rotation)} via ${source}${confidence2 !== void 0 ? ` confidence=${confidence2.toFixed(2)}` : ""}${evidence ? ` evidence=${boundedText(evidence, 300)}` : ""}`,
+          confidence: confidence2
+        }], 50);
+        this.persist();
+        this.emitFeedback({
+          kind: "orientation",
+          title: "Camera orientation correction updated",
+          observedAt: orientation.updatedAt,
+          message: `${target}: ${describeCameraOrientation(orientation)}`
+        });
+        return orientation;
+      }
+      cycleCameraRotation(device = this.config.selectedCamera) {
+        const current = this.getCameraRotation(device);
+        const next = current === 0 ? 90 : current === 90 ? 180 : current === 180 ? 270 : 0;
+        return this.setCameraRotation(device, next, "manual", "manual cycle from /live menu");
+      }
+      async autoOrientCamera(device = this.config.selectedCamera, options2 = {}) {
+        const target = device || this.config.selectedCamera || firstDeviceId(this.devices.video);
+        if (!target) return "No camera selected. Use /live camera <device> or select a camera in /live.";
+        if (options2.onlyIfUnset && this.getCameraOrientation(target)) {
+          return `Camera orientation already set for ${target}: ${describeCameraOrientation(this.getCameraOrientation(target))}`;
+        }
+        if (this.autoOrientationInFlight.has(target)) {
+          return `Camera orientation detection is already running for ${target}.`;
+        }
+        this.autoOrientationInFlight.add(target);
+        try {
+          const captured = await new CameraCaptureTool().execute({
+            action: "capture",
+            device: target,
+            width: 640,
+            height: 480,
+            rotate_degrees: 0
+          });
+          if (!captured.success) {
+            return `Camera orientation detection could not capture ${target}: ${captured.error || captured.output || "unknown error"}`;
+          }
+          const framePath = extractSavedImagePath(captured.output, this.repoRoot);
+          if (!framePath) return `Camera orientation detection captured ${target}, but no frame path was returned.`;
+          const prompt = [
+            "Determine whether this camera frame is upright for a human viewer.",
+            "Return only JSON with this schema:",
+            '{"rotation_degrees":0|90|180|270,"confidence":0.0-1.0,"reason":"brief visual evidence"}',
+            "rotation_degrees is the clockwise correction to apply to future frames so they are upright.",
+            "Use 90 if the image must rotate clockwise; use 270 if it must rotate counter-clockwise; use 180 if upside down; use 0 if already upright or inconclusive."
+          ].join("\n");
+          const vision = await new VisionTool(this.repoRoot).execute({
+            action: "query",
+            image: framePath,
+            prompt,
+            model: "moondream3-preview"
+          });
+          if (!vision.success) {
+            return `Camera orientation detection captured ${target}, but vision inference was unavailable: ${vision.error || vision.output || "unknown error"}`;
+          }
+          const decision2 = parseCameraOrientationDecision(vision.llmContent || vision.output);
+          if (!decision2) {
+            return `Camera orientation detection for ${target} was inconclusive. Vision output did not contain a structured rotation decision.`;
+          }
+          const evidence = decision2.reason || boundedText(vision.llmContent || vision.output, 400);
+          const orientation = this.setCameraRotation(target, decision2.rotation, "auto", evidence, decision2.confidence);
+          return orientation ? `Auto orientation for ${target}: ${describeCameraOrientation(orientation)}` : `Auto orientation for ${target} could not be persisted.`;
+        } finally {
+          this.autoOrientationInFlight.delete(target);
+        }
+      }
       async refreshDevices() {
         const errors = [];
         let video = [];
@@ -602504,23 +602830,82 @@ var init_live_sensors = __esm({
         return this.getConfig();
       }
       stopAll() {
+        this.agentActionEnabled = false;
         this.configure({
           videoEnabled: false,
           audioEnabled: false,
           audioOutputEnabled: false,
           inferEnabled: false,
+          clipEnabled: false,
           asrEnabled: false,
           audioAnalysisEnabled: false
         });
       }
+      startRunMode(options2 = {}) {
+        this.agentActionEnabled = Boolean(options2.agent);
+        this.configure({
+          videoEnabled: true,
+          inferEnabled: true,
+          clipEnabled: true,
+          audioEnabled: true,
+          asrEnabled: true,
+          audioAnalysisEnabled: true,
+          videoIntervalMs: options2.lowLatency === false ? this.config.videoIntervalMs : Math.min(this.config.videoIntervalMs, 1500),
+          audioIntervalMs: options2.lowLatency === false ? this.config.audioIntervalMs : Math.min(this.config.audioIntervalMs, 3e3)
+        });
+        const source = this.config.selectedCamera || firstDeviceId(this.devices.video);
+        if (source && !this.getCameraOrientation(source)) {
+          void this.autoOrientCamera(source, { onlyIfUnset: true }).then((message2) => {
+            this.emitFeedback({
+              kind: "orientation",
+              title: "Camera auto-orientation",
+              observedAt: Date.now(),
+              message: message2
+            });
+          }).catch((err) => {
+            this.emitFeedback({
+              kind: "error",
+              title: "Camera auto-orientation failed",
+              observedAt: Date.now(),
+              message: err instanceof Error ? err.message : String(err)
+            });
+          });
+        }
+        void this.sampleVideoNow(true).catch((err) => {
+          this.emitFeedback({
+            kind: "error",
+            title: "Live video sample failed",
+            observedAt: Date.now(),
+            message: err instanceof Error ? err.message : String(err)
+          });
+        });
+        void this.sampleAudioNow().catch((err) => {
+          this.emitFeedback({
+            kind: "error",
+            title: "Live audio sample failed",
+            observedAt: Date.now(),
+            message: err instanceof Error ? err.message : String(err)
+          });
+        });
+        this.emitFeedback({
+          kind: "status",
+          title: options2.agent ? "Live PFC run started" : "Live run started",
+          observedAt: Date.now(),
+          message: "Low-latency video, face, CLIP, ASR, and sound loops are active. Latest observations are injected into each agent turn."
+        });
+        return options2.agent ? "Live PFC run enabled: visual/audio feedback is active and significant events can launch background agent review." : "Live run enabled: visual/audio feedback is active and live context will update each turn.";
+      }
       async previewCamera(device = this.config.selectedCamera) {
         const source = device || firstDeviceId(this.devices.video);
         if (!source) return { ok: false, message: "No camera selected. Use /live to select a camera after device discovery." };
+        const orientation = this.getCameraOrientation(source);
+        const rotation = orientation?.rotation ?? 0;
         const result = await new CameraCaptureTool().execute({
           action: "capture",
           device: source,
           width: 640,
-          height: 480
+          height: 480,
+          rotate_degrees: rotation
         });
         if (!result.success) {
           const error = result.error || result.output || "camera capture failed";
@@ -602539,6 +602924,12 @@ var init_live_sensors = __esm({
             summary: error
           }], 50);
           this.persist();
+          this.emitFeedback({
+            kind: "error",
+            title: "Camera capture failed",
+            observedAt: observedAt2,
+            message: error
+          });
           return { ok: false, message: error };
         }
         const framePath = extractSavedImagePath(result.output, this.repoRoot);
@@ -602552,7 +602943,9 @@ var init_live_sensors = __esm({
           source,
           framePath,
           displayPath,
-          asciiContext
+          asciiContext,
+          rotation,
+          orientation
         };
         this.snapshot.events = mergeRecentById(this.snapshot.events, [{
           id: stableEventId("camera_frame", source, observedAt, framePath),
@@ -602560,10 +602953,20 @@ var init_live_sensors = __esm({
           observedAt,
           source,
           title: "Captured camera frame",
-          summary: `frame=${framePath}${displayPath ? ` display=${displayPath}` : ""}`,
+          summary: `frame=${framePath}${displayPath ? ` display=${displayPath}` : ""}${orientation ? ` rotation=${formatCameraRotation(orientation.rotation)}` : ""}`,
           evidencePath: framePath
         }], 50);
         this.persist();
+        this.emitFeedback({
+          kind: "camera-frame",
+          title: "Live camera frame",
+          observedAt,
+          message: `Captured from ${source}${orientation ? ` (${formatCameraRotation(orientation.rotation)})` : ""}: ${framePath}`,
+          imagePath: framePath,
+          displayPath,
+          ascii: preview?.ascii,
+          renderer: preview?.renderer
+        });
         return {
           ok: true,
           message: `Camera frame captured from ${source}: ${framePath}`,
@@ -602573,13 +602976,54 @@ var init_live_sensors = __esm({
           renderer: preview?.renderer
         };
       }
+      async recognizeFrameObjects(framePath, source, observedAt = Date.now()) {
+        try {
+          const result = await new VisualMemoryTool().execute({
+            action: "recognize",
+            image: framePath,
+            format: "json",
+            auto_setup: true,
+            timeout_ms: 45e3
+          });
+          const summary = result.success ? boundedText(result.llmContent || result.output || "No visual-memory object matches returned.", 1400) : `CLIP/visual-memory unavailable: ${result.error || result.output || "unknown error"}`;
+          this.snapshot.events = mergeRecentById(this.snapshot.events, [{
+            id: stableEventId("clip_recognition", source, observedAt, framePath),
+            kind: "clip_recognition",
+            observedAt,
+            source,
+            title: result.success ? "CLIP visual-memory recognition" : "CLIP visual-memory unavailable",
+            summary,
+            evidencePath: framePath
+          }], 50);
+          this.persist();
+          this.emitFeedback({
+            kind: "clip",
+            title: result.success ? "CLIP visual-memory recognition" : "CLIP visual-memory unavailable",
+            observedAt,
+            message: summary
+          });
+          return summary;
+        } catch (err) {
+          const message2 = `CLIP/visual-memory failed: ${err instanceof Error ? err.message : String(err)}`;
+          this.emitFeedback({
+            kind: "error",
+            title: "CLIP visual-memory failed",
+            observedAt,
+            message: message2
+          });
+          return message2;
+        }
+      }
       async sampleVideoNow(forceInfer = this.config.inferEnabled) {
         if (this.videoInFlight) return "Video sampler is already running.";
         this.videoInFlight = true;
         try {
           const preview = await this.previewCamera(this.config.selectedCamera);
           let inference = "";
+          let clipSummary = "";
           const source = this.config.selectedCamera || firstDeviceId(this.devices.video);
+          const orientation = source ? this.getCameraOrientation(source) : void 0;
+          const sampledAt = Date.now();
           if (forceInfer && source) {
             const loop = new LiveMediaLoopTool(this.repoRoot);
             const result = await loop.execute({
@@ -602589,6 +603033,7 @@ var init_live_sensors = __esm({
               duration_sec: 4,
               sample_interval_sec: 1,
               max_frames: 4,
+              rotate_degrees: orientation?.rotation ?? 0,
               auto_bootstrap: true,
               audio_mode: "none",
               detect_objects: true,
@@ -602596,7 +603041,6 @@ var init_live_sensors = __esm({
               crop_faces: true,
               recognize_faces: true
             });
-            const sampledAt = Date.now();
             inference = result.success ? String(result.output || result.llmContent || "") : `Video inference failed: ${result.error || result.output || "unknown error"}`;
             const livePayload = result.success ? parseLiveMediaPayload(result.llmContent || result.output) : null;
             const observations = observationsFromLiveMediaPayload(livePayload, sampledAt, source);
@@ -602607,12 +603051,54 @@ var init_live_sensors = __esm({
               updatedAt: sampledAt,
               source,
               inference,
+              rotation: orientation?.rotation ?? 0,
+              orientation,
               ...preview.ok ? {} : { error: preview.message }
             };
             this.persist();
+            this.emitFeedback({
+              kind: result.success ? "video-inference" : "error",
+              title: result.success ? "Live video inference" : "Live video inference failed",
+              observedAt: sampledAt,
+              message: boundedText(inference, 1800)
+            });
+            for (const person of observations.people.filter((entry) => entry.cropPath).slice(0, 4)) {
+              const cropPath = person.cropPath;
+              const displayPath = relative11(this.repoRoot, cropPath).startsWith("..") ? cropPath : relative11(this.repoRoot, cropPath);
+              const facePreview = await buildImageAsciiPreview(cropPath, { width: 38, height: 14 });
+              this.emitFeedback({
+                kind: "face-crop",
+                title: person.status === "known" && person.name ? `Known face: ${person.name}` : "Unknown face awaiting identification",
+                observedAt: person.observedAt,
+                message: person.status === "known" && person.name ? `Identified ${person.name}${person.confidence !== void 0 ? ` confidence=${person.confidence.toFixed(2)}` : ""}` : `Face crop saved and awaiting identification${person.confidence !== void 0 ? ` confidence=${person.confidence.toFixed(2)}` : ""}`,
+                imagePath: cropPath,
+                displayPath,
+                ascii: facePreview?.ascii,
+                renderer: facePreview?.renderer
+              });
+            }
+            const unknownPeople = observations.people.filter((entry) => entry.status === "unknown");
+            if (unknownPeople.length > 0) {
+              this.maybeRequestAgentReview(
+                `${unknownPeople.length} unknown individual(s) observed on live camera`,
+                unknownPeople.map((entry) => `${entry.cropPath || entry.trackId || entry.source} ${entry.evidence || ""}`).join("; ")
+              );
+            }
+            const triggerEvents = observations.events.filter((entry) => entry.kind === "visual_trigger");
+            if (triggerEvents.length > 0) {
+              this.maybeRequestAgentReview(
+                "Visual trigger hit in live camera stream",
+                triggerEvents.map((entry) => entry.summary).join("; ")
+              );
+            }
+          }
+          if (this.config.clipEnabled && preview.ok && preview.framePath && source) {
+            clipSummary = await this.recognizeFrameObjects(preview.framePath, source, sampledAt);
           }
           return [preview.message, inference ? `
-${inference}` : ""].filter(Boolean).join("\n");
+${inference}` : "", clipSummary ? `
+CLIP visual memory:
+${clipSummary}` : ""].filter(Boolean).join("\n");
         } finally {
           this.videoInFlight = false;
         }
@@ -602638,6 +603124,12 @@ ${inference}` : ""].filter(Boolean).join("\n");
               error: message2
             };
             this.persist();
+            this.emitFeedback({
+              kind: "error",
+              title: "Live audio capture failed",
+              observedAt: this.snapshot.audio.updatedAt,
+              message: message2
+            });
             return message2;
           }
           if (this.config.asrEnabled) {
@@ -602698,6 +603190,19 @@ ${inference}` : ""].filter(Boolean).join("\n");
           }
           this.snapshot.events = mergeRecentById(this.snapshot.events, audioEvents, 50);
           this.persist();
+          if (transcript || analysis) {
+            this.emitFeedback({
+              kind: "audio",
+              title: "Live audio sample",
+              observedAt: this.snapshot.audio.updatedAt,
+              message: [
+                transcript ? `ASR:
+${boundedText(transcript, 700)}` : "",
+                analysis ? `Sounds:
+${boundedText(analysis, 900)}` : ""
+              ].filter(Boolean).join("\n\n")
+            });
+          }
           return [
             `Audio sample captured from ${input}: ${recordingPath}`,
             transcript ? `
@@ -602713,10 +603218,10 @@ ${analysis}` : ""
       }
       ensureLoops() {
         if (this.config.videoEnabled && !this.videoTimer) {
-          void this.sampleVideoNow(false).catch(() => {
+          void this.sampleVideoNow(this.config.inferEnabled || this.config.clipEnabled).catch(() => {
           });
           this.videoTimer = setInterval(() => {
-            void this.sampleVideoNow(this.config.inferEnabled).catch(() => {
+            void this.sampleVideoNow(this.config.inferEnabled || this.config.clipEnabled).catch(() => {
             });
           }, this.config.videoIntervalMs);
           this.videoTimer.unref?.();
@@ -602745,6 +603250,38 @@ ${analysis}` : ""
           label: "live"
         });
       }
+      emitFeedback(feedback) {
+        try {
+          this.feedbackSink?.(feedback);
+        } catch {
+        }
+      }
+      maybeRequestAgentReview(reason, evidence) {
+        if (!this.agentActionEnabled || !this.agentActionSink) return;
+        const now2 = Date.now();
+        if (now2 - this.lastAgentReviewAt < 2e4) return;
+        this.lastAgentReviewAt = now2;
+        const prompt = [
+          "Live environment PFC review.",
+          "Inspect the current live sensor evidence and decide whether any immediate action is needed.",
+          "Do not invent person names. If a person is unknown and identity matters, ask the user or person for their name and then store the association with visual_memory or multimodal_memory.",
+          "Prefer minimal, reversible actions. If no action is needed, summarize the observation and stand by.",
+          "",
+          `Reason: ${reason}`,
+          `Evidence: ${evidence}`,
+          `Live snapshot: ${liveSnapshotPath(this.repoRoot)}`
+        ].join("\n");
+        this.emitFeedback({
+          kind: "agent-review",
+          title: "Live PFC review queued",
+          observedAt: now2,
+          message: reason
+        });
+        try {
+          this.agentActionSink(prompt);
+        } catch {
+        }
+      }
       persist() {
         ensureLiveDir(this.repoRoot);
         writeFileSync56(liveConfigPath(this.repoRoot), JSON.stringify(this.config, null, 2), "utf8");
@@ -608474,8 +609011,13 @@ var init_command_registry = __esm({
       ["/listen stop", "Stop listening"],
       ["/live", "Open live sensor stream menu for video/audio context"],
       ["/live status", "Show live sensor devices, selected streams, and latest snapshot"],
+      ["/live run [agent]", "Start low-latency video/audio feedback; agent enables background PFC review"],
+      ["/live chat", "Start low-latency voicechat with live audio/video context and async agent review"],
+      ["/livechat", "Alias for /live chat, used by the top live button"],
       ["/live camera <device>", "Select a camera and render an ASCII preview"],
+      ["/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"],
       ["/paste", "Attach clipboard image content to the current or next prompt"],
@@ -618863,7 +619405,7 @@ __export(omnius_directory_exports, {
   writeIndexMeta: () => writeIndexMeta,
   writeTaskHandoff: () => writeTaskHandoff2
 });
-import { appendFileSync as appendFileSync13, cpSync as cpSync2, existsSync as existsSync117, mkdirSync as mkdirSync74, readFileSync as readFileSync95, writeFileSync as writeFileSync63, readdirSync as readdirSync40, statSync as statSync44, unlinkSync as unlinkSync22, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync10, watch as fsWatch2 } from "node:fs";
+import { appendFileSync as appendFileSync13, cpSync as cpSync2, existsSync as existsSync117, mkdirSync as mkdirSync74, readFileSync as readFileSync95, writeFileSync as writeFileSync63, readdirSync as readdirSync40, statSync as statSync44, unlinkSync as unlinkSync22, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync11, watch as fsWatch2 } from "node:fs";
 import { join as join133, relative as relative13, basename as basename25, dirname as dirname40, resolve as resolve57 } from "node:path";
 import { homedir as homedir41 } from "node:os";
 import { createHash as createHash37 } from "node:crypto";
@@ -619269,7 +619811,7 @@ function writeTaskHandoff2(repoRoot, handoff) {
   const tempPath = filePath + ".tmp";
   writeFileSync63(tempPath, JSON.stringify(handoff, null, 2) + "\n", "utf-8");
   try {
-    renameSync10(tempPath, filePath);
+    renameSync11(tempPath, filePath);
   } catch {
     writeFileSync63(filePath, JSON.stringify(handoff, null, 2) + "\n", "utf-8");
     try {
@@ -619579,7 +620121,7 @@ function saveSessionContext(repoRoot, entry) {
     const tempFilePath = filePath + ".tmp";
     writeFileSync63(tempFilePath, JSON.stringify(ctx3, null, 2) + "\n", "utf-8");
     try {
-      renameSync10(tempFilePath, filePath);
+      renameSync11(tempFilePath, filePath);
     } catch {
       writeFileSync63(filePath, JSON.stringify(ctx3, null, 2) + "\n", "utf-8");
       try {
@@ -622522,7 +623064,7 @@ function setTerminalTitle(task, version5) {
     process.stdout.write(data);
   }
 }
-var EXPERT_TOOL_BASELINES, CONTEXT_SWITCH_OVERHEAD, TURN_PLANNING_OVERHEAD, DEFAULT_TOOL_BASELINE, CODE_READ_CHARS_PER_SEC, PROSE_READ_CHARS_PER_SEC, MIN_CONTENT_FOR_READING, CODE_CONTENT_TOOLS, PROSE_CONTENT_TOOLS, HumanSpeedTracker, PANEL_BG_SEQ, CONTENT_BG_SEQ, BOX_FG, TEXT_PRIMARY, TEXT_DIM, NO_SUB_AGENTS_HEADER_LABEL, HEADER_BUTTON_GLYPH_FG, HEADER_BUTTON_BG, HEADER_BUTTON_FG, HEADER_ACCENT_BOLD_FG, HEADER_TELEGRAM_FG, BOX_TL3, BOX_TR3, BOX_BL3, BOX_BR3, BOX_H3, BOX_V3, BOX_BJ, _globalFooterLock, RESET4, CURSOR_BLINK_BLOCK, _isWindows, SPONSOR_HEADER_LABEL_MAX, _termTitleWriter, StatusBar;
+var EXPERT_TOOL_BASELINES, CONTEXT_SWITCH_OVERHEAD, TURN_PLANNING_OVERHEAD, DEFAULT_TOOL_BASELINE, CODE_READ_CHARS_PER_SEC, PROSE_READ_CHARS_PER_SEC, MIN_CONTENT_FOR_READING, CODE_CONTENT_TOOLS, PROSE_CONTENT_TOOLS, HumanSpeedTracker, PANEL_BG_SEQ, CONTENT_BG_SEQ, BOX_FG, TEXT_PRIMARY, TEXT_DIM, NO_SUB_AGENTS_HEADER_LABEL, HEADER_BUTTON_GLYPH_FG, HEADER_BUTTON_BG, HEADER_BUTTON_FG, HEADER_ACCENT_BOLD_FG, HEADER_TELEGRAM_FG, BOX_TL3, BOX_TR3, BOX_BL3, BOX_BR3, BOX_H3, BOX_V3, BOX_BJ, _globalFooterLock, RESET4, CURSOR_BLINK_BLOCK, _isWindows, HEADER_BUTTON_LEFT, HEADER_BUTTON_RIGHT, SPONSOR_HEADER_LABEL_MAX, _termTitleWriter, StatusBar;
 var init_status_bar = __esm({
   "packages/cli/src/tui/status-bar.ts"() {
     "use strict";
@@ -622719,6 +623261,8 @@ var init_status_bar = __esm({
     RESET4 = "\x1B[0m";
     CURSOR_BLINK_BLOCK = "\x1B[1 q";
     _isWindows = process.platform === "win32";
+    HEADER_BUTTON_LEFT = _isWindows ? "[" : "🭁";
+    HEADER_BUTTON_RIGHT = _isWindows ? "]" : "🭝";
     SPONSOR_HEADER_LABEL_MAX = 48;
     _termTitleWriter = null;
     StatusBar = class _StatusBar {
@@ -623267,27 +623811,30 @@ var init_status_bar = __esm({
         const buttonFg = (cmd) => {
           let fg2 = TEXT_DIM;
           if (cmd === "voice" && this._voiceActive) fg2 = 82;
-          if (cmd === "live" && (this._liveMediaStatus.audio || this._liveMediaStatus.video)) fg2 = 82;
+          if (cmd.startsWith("live") && (this._liveMediaStatus.audio || this._liveMediaStatus.video)) fg2 = 82;
           if (cmd === "nexus") {
             fg2 = this._nexusStatus === "connected" ? 82 : this._nexusStatus === "connecting" ? 208 : 196;
           }
           return fg2;
         };
         const decorateMenuButton = (cmd, label) => {
-          return `${HEADER_BUTTON_GLYPH_FG}[\x1B[0m${HEADER_BUTTON_BG}${HEADER_BUTTON_FG}${label}\x1B[0m${PANEL_BG_SEQ}${HEADER_BUTTON_GLYPH_FG}]\x1B[0m${PANEL_BG_SEQ}`;
+          return `${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_LEFT}\x1B[0m${HEADER_BUTTON_BG}${HEADER_BUTTON_FG}${label}\x1B[0m${PANEL_BG_SEQ}${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_RIGHT}\x1B[0m${PANEL_BG_SEQ}`;
         };
         const decorateAgentButton = (content, color, active) => {
           const bg = `\x1B[48;5;${color}m`;
           const fg2 = `\x1B[38;5;${contrastTextColor(color)}m`;
           const weight = active ? "\x1B[1m" : "";
-          return `\x1B[38;5;${color}m[\x1B[0m${weight}${fg2}${bg}${content}\x1B[0m${PANEL_BG_SEQ}\x1B[38;5;${color}m]\x1B[0m${PANEL_BG_SEQ}`;
+          return `\x1B[38;5;${color}m${HEADER_BUTTON_LEFT}\x1B[0m${weight}${fg2}${bg}${content}\x1B[0m${PANEL_BG_SEQ}\x1B[38;5;${color}m${HEADER_BUTTON_RIGHT}\x1B[0m${PANEL_BG_SEQ}`;
         };
         const renderBtn = (cmd, label) => {
           const fg2 = buttonFg(cmd);
-          const btnW = label.length;
+          const btnW = label.length + 2;
           const availW2 = getTermWidth() - identity3.width - 1;
           if (btnW > availW2) return linkify(cmd, `\x1B[38;5;${fg2}m${label}`);
-          return linkify(cmd, `${PANEL_BG_SEQ}\x1B[38;5;${fg2}m${label}\x1B[0m${PANEL_BG_SEQ}`);
+          return linkify(
+            cmd,
+            `${PANEL_BG_SEQ}${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_LEFT}\x1B[0m${PANEL_BG_SEQ}\x1B[38;5;${fg2}m${label}\x1B[0m${PANEL_BG_SEQ}${HEADER_BUTTON_GLYPH_FG}${HEADER_BUTTON_RIGHT}\x1B[0m${PANEL_BG_SEQ}`
+          );
         };
         const identity3 = this.buildHeaderIdentityRender();
         const modelLabel = this.summarizeHeaderModelName() || "model";
@@ -623301,6 +623848,8 @@ var init_status_bar = __esm({
             w: (this._voiceActive ? this._voiceModelId || "voice" : "voice").length + 2
           },
           // +2 for spaces
+          { cmd: "livechat", label: "live", w: "live".length + 2 },
+          // +2 for spaces
           { cmd: "model", label: modelLabel, w: modelLabel.length + 2 },
           // +2 for spaces
           { cmd: "endpoint", label: endpointLabel, w: endpointLabel.length + 2 }
@@ -648807,6 +649356,10 @@ sleep 1
       await handleLiveCommand(ctx3, arg);
       return "handled";
     }
+    case "livechat": {
+      await handleLiveCommand(ctx3, "chat");
+      return "handled";
+    }
     case "call": {
       if (!ctx3.callStart) {
         renderWarning("Call mode not available in this context.");
@@ -654417,6 +654970,59 @@ function renderLivePreview(preview) {
     renderWarning("Camera preview was captured, but ASCII rendering was unavailable.");
   }
 }
+function renderLiveFeedback(feedback) {
+  const stamp = new Date(feedback.observedAt).toISOString();
+  if (feedback.kind === "error") {
+    renderWarning(`[live ${stamp}] ${feedback.title}
+${feedback.message}`);
+    return;
+  }
+  if ((feedback.kind === "camera-frame" || feedback.kind === "face-crop") && feedback.ascii && feedback.displayPath && feedback.renderer) {
+    renderInfo(`[live ${stamp}] ${feedback.message}`);
+    renderImageAsciiPreview(feedback.title, feedback.displayPath, feedback.ascii, feedback.renderer);
+    return;
+  }
+  renderInfo(`[live ${stamp}] ${feedback.title}
+${feedback.message}`);
+}
+function attachLiveSinks(ctx3, manager, agentEnabled = false) {
+  manager.setStatusSink(ctx3.setLiveMediaStatus);
+  manager.setFeedbackSink((feedback) => renderLiveFeedback(feedback));
+  if (agentEnabled && ctx3.startBackgroundPrompt) {
+    manager.setAgentActionSink((prompt) => {
+      const id2 = ctx3.startBackgroundPrompt?.(prompt);
+      if (id2) renderInfo(`Live PFC background review started: ${id2}`);
+    });
+  } else {
+    manager.setAgentActionSink(void 0);
+  }
+}
+async function startLiveVoicechat(ctx3, manager) {
+  const agentEnabled = Boolean(ctx3.startBackgroundPrompt);
+  attachLiveSinks(ctx3, manager, agentEnabled);
+  await ensureLiveInventory(manager);
+  renderInfo(manager.startRunMode({ agent: agentEnabled, lowLatency: true }));
+  if (!ctx3.voiceChatStart) {
+    renderWarning("Voice chat is not available in this context; live audio/video feedback remains active.");
+    return;
+  }
+  ctx3.voiceSetMode?.("voicechat");
+  if (ctx3.isVoiceChatActive?.()) {
+    renderInfo("Voice chat is already active. Live audio/video feedback remains attached.");
+    return;
+  }
+  try {
+    await ensureVoiceDeps(ctx3);
+  } catch {
+  }
+  try {
+    renderInfo("Starting live voicechat with audio/video context...");
+    await ctx3.voiceChatStart();
+    renderInfo("Live voicechat active: low-latency audio/video context is updating while voice conversation continues.");
+  } catch (err) {
+    renderError(`Live voicechat failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 async function chooseLiveDevice(ctx3, title, devices, activeKey) {
   if (devices.length === 0) {
     renderWarning("No devices found. Run /live refresh after connecting hardware.");
@@ -654439,7 +655045,7 @@ async function chooseLiveDevice(ctx3, title, devices, activeKey) {
 }
 async function handleLiveCommand(ctx3, arg) {
   const manager = getLiveSensorManager(ctx3.repoRoot);
-  manager.setStatusSink(ctx3.setLiveMediaStatus);
+  attachLiveSinks(ctx3, manager);
   const parts = arg.trim().split(/\s+/).filter(Boolean);
   const sub2 = (parts[0] || "").toLowerCase();
   const value2 = parts.slice(1).join(" ");
@@ -654460,9 +655066,48 @@ async function handleLiveCommand(ctx3, arg) {
   }
   if (sub2 === "stop" || sub2 === "off" || sub2 === "disable") {
     manager.stopAll();
+    manager.setAgentActionSink(void 0);
     renderInfo("Live sensor streams disabled.");
     return;
   }
+  if (sub2 === "run" || sub2 === "start" || sub2 === "pfc") {
+    const agentEnabled = sub2 === "pfc" || /\bagent|pfc|action\b/i.test(value2);
+    const effectiveAgent = agentEnabled && Boolean(ctx3.startBackgroundPrompt);
+    attachLiveSinks(ctx3, manager, effectiveAgent);
+    if (agentEnabled && !ctx3.startBackgroundPrompt) {
+      renderWarning("Live PFC agent review is unavailable in this context; starting visual/audio feedback only.");
+    }
+    await ensureLiveInventory(manager);
+    renderInfo(manager.startRunMode({ agent: effectiveAgent, lowLatency: true }));
+    return;
+  }
+  if (sub2 === "chat" || sub2 === "voicechat" || sub2 === "voice") {
+    await startLiveVoicechat(ctx3, manager);
+    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 /live camera <device> first.");
+      return;
+    }
+    try {
+      const rotation = normalizeLiveCameraRotation(mode);
+      const orientation = manager.setCameraRotation(deviceArg, rotation, "manual", `/live rotate ${mode}`);
+      renderInfo(orientation ? `Camera rotation set to ${formatCameraRotation(orientation.rotation)} for ${deviceArg || manager.getConfig().selectedCamera || "selected camera"}.` : "No camera selected. Use /live camera <device> first.");
+    } catch (err) {
+      renderWarning(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
   if (sub2 === "video") {
     const cfg = manager.getConfig();
     manager.configure({ videoEnabled: setBool(value2, !cfg.videoEnabled) });
@@ -654508,6 +655153,15 @@ async function handleLiveCommand(ctx3, arg) {
     }
     return;
   }
+  if (sub2 === "clip") {
+    const cfg = manager.getConfig();
+    manager.configure({
+      videoEnabled: true,
+      clipEnabled: setBool(value2, !cfg.clipEnabled)
+    });
+    renderInfo(formatLiveStatus(manager.getSnapshot()));
+    return;
+  }
   if (sub2 === "camera") {
     await ensureLiveInventory(manager);
     const selected = value2 || manager.getConfig().selectedCamera;
@@ -654551,9 +655205,24 @@ async function showLiveMenu(ctx3, manager) {
       {
         key: "info:status",
         label: selectColors.dim(
-          `  video ${liveEnabled(cfg.videoEnabled)} · infer ${liveEnabled(cfg.inferEnabled)} · audio ${liveEnabled(cfg.audioEnabled)} · asr ${liveEnabled(cfg.asrEnabled)} · sounds ${liveEnabled(cfg.audioAnalysisEnabled)}`
+          `  video ${liveEnabled(cfg.videoEnabled)} · infer ${liveEnabled(cfg.inferEnabled)} · clip ${liveEnabled(cfg.clipEnabled)} · audio ${liveEnabled(cfg.audioEnabled)} · asr ${liveEnabled(cfg.asrEnabled)} · sounds ${liveEnabled(cfg.audioAnalysisEnabled)}`
         )
       },
+      {
+        key: "run-live",
+        label: "Start Live Run",
+        detail: "low-latency visual/audio feedback + context injection"
+      },
+      {
+        key: "run-agent",
+        label: "Start Live PFC Run",
+        detail: "live feedback + background agent review for significant events"
+      },
+      {
+        key: "run-chat",
+        label: "Start Live Voicechat",
+        detail: "low-latency voice conversation with live audio/video context"
+      },
       {
         key: "toggle-video",
         label: cfg.videoEnabled ? "Disable Video Context" : "Enable Video Context",
@@ -654569,11 +655238,26 @@ async function showLiveMenu(ctx3, manager) {
         label: "View Selected Camera",
         detail: "capture frame + image-to-ascii preview"
       },
+      {
+        key: "auto-orient-camera",
+        label: "Auto-Orient Camera",
+        detail: `current: ${cfg.selectedCamera ? formatCameraRotation(manager.getCameraRotation(cfg.selectedCamera)) : "no camera selected"}`
+      },
+      {
+        key: "cycle-rotation",
+        label: "Cycle Camera Rotation",
+        detail: "manual override: upright -> clockwise -> 180 -> counter-clockwise"
+      },
       {
         key: "toggle-infer",
         label: cfg.inferEnabled ? "Disable Frame Inference" : "Enable Frame Inference",
         detail: "YOLO object/location stream into context"
       },
+      {
+        key: "toggle-clip",
+        label: cfg.clipEnabled ? "Disable CLIP Visual Memory" : "Enable CLIP Visual Memory",
+        detail: "recognize taught objects from camera frames"
+      },
       {
         key: "infer-now",
         label: "Infer Current Camera Frame",
@@ -654647,6 +655331,20 @@ async function showLiveMenu(ctx3, manager) {
       case "toggle-video":
         manager.configure({ videoEnabled: !cfg.videoEnabled });
         continue;
+      case "run-live":
+        attachLiveSinks(ctx3, manager, false);
+        renderInfo(manager.startRunMode({ agent: false, lowLatency: true }));
+        continue;
+      case "run-agent":
+        attachLiveSinks(ctx3, manager, true);
+        if (!ctx3.startBackgroundPrompt) {
+          renderWarning("Live PFC agent review is unavailable in this context; starting visual/audio feedback only.");
+        }
+        renderInfo(manager.startRunMode({ agent: Boolean(ctx3.startBackgroundPrompt), lowLatency: true }));
+        continue;
+      case "run-chat":
+        await startLiveVoicechat(ctx3, manager);
+        continue;
       case "toggle-audio":
         manager.configure({ audioEnabled: !cfg.audioEnabled });
         continue;
@@ -654656,6 +655354,9 @@ async function showLiveMenu(ctx3, manager) {
       case "toggle-infer":
         manager.configure({ videoEnabled: true, inferEnabled: !cfg.inferEnabled });
         continue;
+      case "toggle-clip":
+        manager.configure({ videoEnabled: true, clipEnabled: !cfg.clipEnabled });
+        continue;
       case "toggle-asr":
         manager.configure({ audioEnabled: true, asrEnabled: !cfg.asrEnabled });
         continue;
@@ -654683,6 +655384,15 @@ async function showLiveMenu(ctx3, manager) {
       case "preview-camera":
         renderLivePreview(await manager.previewCamera());
         continue;
+      case "auto-orient-camera":
+        renderInfo("Detecting camera orientation...");
+        renderInfo(await manager.autoOrientCamera(cfg.selectedCamera));
+        continue;
+      case "cycle-rotation": {
+        const orientation = manager.cycleCameraRotation(cfg.selectedCamera);
+        renderInfo(orientation ? `Camera rotation set to ${formatCameraRotation(orientation.rotation)} for ${cfg.selectedCamera || manager.getConfig().selectedCamera || "selected camera"}.` : "No camera selected. Use Select Camera first.");
+        continue;
+      }
       case "infer-now":
         manager.configure({ videoEnabled: true, inferEnabled: true });
         renderInfo("Sampling camera inference...");
@@ -661333,7 +662043,7 @@ import {
   readFileSync as readFileSync113,
   readdirSync as readdirSync49,
   writeFileSync as writeFileSync74,
-  renameSync as renameSync12,
+  renameSync as renameSync13,
   mkdirSync as mkdirSync85,
   unlinkSync as unlinkSync29,
   appendFileSync as appendFileSync16
@@ -661357,7 +662067,7 @@ function persistSession(s2) {
     const final2 = sessionPath(s2.id);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
     writeFileSync74(tmp, JSON.stringify(s2, null, 2), "utf-8");
-    renameSync12(tmp, final2);
+    renameSync13(tmp, final2);
   } catch {
   }
 }
@@ -661367,7 +662077,7 @@ function persistInFlight(j) {
     const final2 = inFlightPath(j.sessionId);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
     writeFileSync74(tmp, JSON.stringify(j, null, 2), "utf-8");
-    renameSync12(tmp, final2);
+    renameSync13(tmp, final2);
   } catch {
   }
 }
@@ -694197,7 +694907,7 @@ __export(projects_exports, {
   setCurrentProject: () => setCurrentProject,
   unregisterProject: () => unregisterProject
 });
-import { readFileSync as readFileSync124, writeFileSync as writeFileSync83, mkdirSync as mkdirSync95, existsSync as existsSync152, statSync as statSync55, renameSync as renameSync13 } from "node:fs";
+import { readFileSync as readFileSync124, writeFileSync as writeFileSync83, mkdirSync as mkdirSync95, existsSync as existsSync152, statSync as statSync55, renameSync as renameSync14 } from "node:fs";
 import { homedir as homedir55 } from "node:os";
 import { basename as basename40, join as join166, resolve as resolve68 } from "node:path";
 import { randomUUID as randomUUID19 } from "node:crypto";
@@ -694216,7 +694926,7 @@ function writeAll(file) {
   mkdirSync95(OMNIUS_DIR3, { recursive: true });
   const tmp = `${PROJECTS_FILE}.${randomUUID19().slice(0, 8)}.tmp`;
   writeFileSync83(tmp, JSON.stringify(file, null, 2), "utf8");
-  renameSync13(tmp, PROJECTS_FILE);
+  renameSync14(tmp, PROJECTS_FILE);
 }
 function listProjects() {
   const { projects } = readAll2();
@@ -695195,7 +695905,7 @@ var init_access_policy = __esm({
 
 // packages/cli/src/api/project-preferences.ts
 import { createHash as createHash43 } from "node:crypto";
-import { existsSync as existsSync153, mkdirSync as mkdirSync96, readFileSync as readFileSync125, renameSync as renameSync14, writeFileSync as writeFileSync84, unlinkSync as unlinkSync35 } from "node:fs";
+import { existsSync as existsSync153, mkdirSync as mkdirSync96, readFileSync as readFileSync125, renameSync as renameSync15, writeFileSync as writeFileSync84, unlinkSync as unlinkSync35 } from "node:fs";
 import { homedir as homedir56 } from "node:os";
 import { join as join167, resolve as resolve69 } from "node:path";
 import { randomUUID as randomUUID20 } from "node:crypto";
@@ -695249,7 +695959,7 @@ function writeProjectPreferences(root, partial) {
   const tmp = `${file}.${randomUUID20().slice(0, 8)}.tmp`;
   writeFileSync84(tmp, JSON.stringify(merged, null, 2), "utf8");
   try {
-    renameSync14(tmp, file);
+    renameSync15(tmp, file);
   } catch (err) {
     try {
       writeFileSync84(file, JSON.stringify(merged, null, 2), "utf8");
@@ -696305,7 +697015,7 @@ var init_direct_tool_registry = __esm({
 });
 
 // packages/cli/src/api/external-tool-registry.ts
-import { existsSync as existsSync157, mkdirSync as mkdirSync100, readFileSync as readFileSync127, writeFileSync as writeFileSync85, renameSync as renameSync15 } from "node:fs";
+import { existsSync as existsSync157, mkdirSync as mkdirSync100, readFileSync as readFileSync127, writeFileSync as writeFileSync85, renameSync as renameSync16 } from "node:fs";
 import { join as join170 } from "node:path";
 function externalToolStorePath(workingDir) {
   return join170(workingDir, ".omnius", "external-tools.json");
@@ -696329,7 +697039,7 @@ function persist3(workingDir, tools) {
   const file = { version: STORE_VERSION, tools };
   const tmp = `${path12}.tmp`;
   writeFileSync85(tmp, JSON.stringify(file, null, 2), { mode: 384 });
-  renameSync15(tmp, path12);
+  renameSync16(tmp, path12);
 }
 function validateManifest2(input, existing) {
   if (!input || typeof input !== "object") {
@@ -714217,7 +714927,7 @@ import {
   readdirSync as readdirSync58,
   existsSync as existsSync165,
   watch as fsWatch4,
-  renameSync as renameSync16,
+  renameSync as renameSync17,
   unlinkSync as unlinkSync36,
   statSync as statSync60,
   openSync as openSync6,
@@ -715874,7 +716584,7 @@ function atomicJobWrite(dir, id2, job) {
   const tmpPath = `${finalPath}.tmp.${process.pid}.${Date.now()}`;
   try {
     writeFileSync90(tmpPath, JSON.stringify(job, null, 2), "utf-8");
-    renameSync16(tmpPath, finalPath);
+    renameSync17(tmpPath, finalPath);
   } catch {
     try {
       writeFileSync90(finalPath, JSON.stringify(job, null, 2), "utf-8");
@@ -717712,7 +718422,7 @@ function writeUpdateState(state) {
     const finalPath = updateStateFile();
     const tmpPath = `${finalPath}.tmp.${process.pid}`;
     writeFileSync90(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-    renameSync16(tmpPath, finalPath);
+    renameSync17(tmpPath, finalPath);
   } catch {
   }
 }