@geravant/sinain 1.0.18 → 1.1.0

package/sense_client/sender.py

@@ -0,0 +1,173 @@
+"""POST sense events to the relay server."""
+
+import base64
+import io
+import time
+
+import requests
+from PIL import Image
+
+from .gate import SenseEvent
+
+# Retry config for /sense POST
+_MAX_RETRIES = 3
+_RETRY_BASE_DELAY_S = 1.0  # 1s, 2s, 4s (exponential)
+
+
+class SenseSender:
+    """POSTs sense events to the relay server with retry and backoff."""
+
+    def __init__(self, url: str = "http://localhost:9500",
+                 max_image_kb: int = 500, send_thumbnails: bool = True):
+        self.url = url.rstrip("/")
+        self.max_image_kb = max_image_kb
+        self.send_thumbnails = send_thumbnails
+        self._latencies: list[float] = []
+        self._last_stats_ts: float = time.time()
+        self._consecutive_failures: int = 0
+
+    def send(self, event: SenseEvent) -> bool:
+        """POST /sense with JSON payload. Returns True on success."""
+        payload = {
+            "type": event.type,
+            "ts": event.ts,
+            "ocr": event.ocr,
+            "meta": {
+                "ssim": event.meta.ssim,
+                "app": event.meta.app,
+                "windowTitle": event.meta.window_title,
+                "screen": event.meta.screen,
+            },
+        }
+        if event.roi:
+            payload["roi"] = event.roi
+        if event.diff:
+            payload["diff"] = event.diff
+        if event.observation and event.observation.title:
+            payload["observation"] = {
+                "title": event.observation.title,
+                "subtitle": event.observation.subtitle,
+                "facts": event.observation.facts,
+                "narrative": event.observation.narrative,
+                "concepts": event.observation.concepts,
+            }
+
+        for attempt in range(_MAX_RETRIES):
+            try:
+                start = time.time()
+                resp = requests.post(
+                    f"{self.url}/sense",
+                    json=payload,
+                    timeout=5,
+                )
+                elapsed_ms = (time.time() - start) * 1000
+                self._latencies.append(elapsed_ms)
+                self._maybe_log_stats()
+
+                if resp.status_code == 200:
+                    if self._consecutive_failures > 0:
+                        print(f"[sender] reconnected after {self._consecutive_failures} failure(s)", flush=True)
+                    self._consecutive_failures = 0
+                    return True
+
+                # Non-200 but not an exception — log and retry
+                print(f"[sender] HTTP {resp.status_code} on attempt {attempt + 1}/{_MAX_RETRIES}", flush=True)
+
+            except requests.exceptions.ConnectionError as e:
+                print(f"[sender] connection error (attempt {attempt + 1}/{_MAX_RETRIES}): {e}", flush=True)
+            except requests.exceptions.Timeout:
+                print(f"[sender] timeout (attempt {attempt + 1}/{_MAX_RETRIES})", flush=True)
+            except Exception as e:
+                print(f"[sender] unexpected error (attempt {attempt + 1}/{_MAX_RETRIES}): {e}", flush=True)
+
+            # Don't sleep after the last attempt
+            if attempt < _MAX_RETRIES - 1:
+                delay = _RETRY_BASE_DELAY_S * (2 ** attempt)
+                print(f"[sender] retrying in {delay:.1f}s...", flush=True)
+                time.sleep(delay)
+
+        self._consecutive_failures += 1
+        if self._consecutive_failures == 1 or self._consecutive_failures % 10 == 0:
+            print(f"[sender] all {_MAX_RETRIES} attempts failed (consecutive failures: {self._consecutive_failures})", flush=True)
+        return False
+
+    def _maybe_log_stats(self):
+        """Log P50/P95 send latencies every 60s."""
+        now = time.time()
+        if now - self._last_stats_ts < 60:
+            return
+        if not self._latencies:
+            return
+        sorted_lat = sorted(self._latencies)
+        p50 = sorted_lat[len(sorted_lat) // 2]
+        p95 = sorted_lat[int(len(sorted_lat) * 0.95)]
+        print(f"[sender] relay latency: p50={p50:.0f}ms p95={p95:.0f}ms (n={len(sorted_lat)})", flush=True)
+        self._latencies.clear()
+        self._last_stats_ts = now
+
+
+def encode_image(img: Image.Image, max_kb: int, max_px: int = 0) -> str:
+    """Encode PIL Image to base64 JPEG, reducing quality until under max_kb."""
+    if max_px:
+        ratio = max_px / max(img.size)
+        if ratio < 1:
+            img = img.resize(
+                (int(img.width * ratio), int(img.height * ratio)),
+                Image.LANCZOS,
+            )
+
+    if img.mode == "RGBA":
+        img = img.convert("RGB")
+
+    # Try high quality first — often fits
+    max_bytes = max_kb * 1024
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=85)
+    if buf.tell() <= max_bytes:
+        return base64.b64encode(buf.getvalue()).decode()
+
+    # Binary search for the highest quality that fits
+    lo, hi = 20, 80
+    best_buf = None
+    while lo <= hi:
+        mid = (lo + hi) // 2
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=mid)
+        if buf.tell() <= max_bytes:
+            best_buf = buf
+            lo = mid + 1
+        else:
+            hi = mid - 1
+
+    if best_buf is not None:
+        return base64.b64encode(best_buf.getvalue()).decode()
+
+    # Last resort: return at lowest quality
+    buf = io.BytesIO()
+    img.save(buf, format="JPEG", quality=20)
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def package_full_frame(frame: Image.Image, max_px: int = 384) -> dict:
+    """Package a full frame as a small thumbnail for context events."""
+    return {
+        "data": encode_image(frame, max_kb=200, max_px=max_px),
+        "bbox": [0, 0, frame.width, frame.height],
+        "thumb": True,
+    }
+
+
+def package_roi(roi, thumb: bool = True) -> dict:
+    """Package an ROI as a small thumbnail for text/visual events."""
+    return {
+        "data": encode_image(roi.image, max_kb=60, max_px=384),
+        "bbox": list(roi.bbox),
+        "thumb": True,
+    }
+
+
+def package_diff(diff_image: Image.Image) -> dict:
+    """Package a diff image."""
+    return {
+        "data": encode_image(diff_image, max_kb=200),
+    }

package/sense_client/tests/test_stream1_optimizations.py

@@ -0,0 +1,234 @@
+"""Tests for Stream 1 optimizations: adaptive cooldown, adaptive SSIM,
+parallel OCR, skip image for text events, latency instrumentation."""
+
+import time
+import unittest
+from unittest.mock import MagicMock, patch
+
+from sense_client.change_detector import ChangeDetector, ChangeResult
+from sense_client.config import load_config, DEFAULTS
+from sense_client.gate import DecisionGate, SenseEvent, SenseMeta
+from sense_client.ocr import OCRResult
+from sense_client.sender import SenseSender
+
+
+class TestConfig(unittest.TestCase):
+    """Test that adaptiveCooldownMs is present in defaults."""
+
+    def test_defaults_has_adaptive_cooldown(self):
+        config = load_config(None)
+        self.assertIn("adaptiveCooldownMs", config["gate"])
+        self.assertEqual(config["gate"]["adaptiveCooldownMs"], 2000)
+
+    def test_defaults_cooldown_unchanged(self):
+        config = load_config(None)
+        self.assertEqual(config["gate"]["cooldownMs"], 5000)
+
+
+class TestChangeDetectorSetThreshold(unittest.TestCase):
+    """Test dynamic SSIM threshold adjustment."""
+
+    def test_set_threshold(self):
+        det = ChangeDetector(threshold=0.92)
+        self.assertEqual(det.threshold, 0.92)
+        det.set_threshold(0.85)
+        self.assertEqual(det.threshold, 0.85)
+        det.set_threshold(0.95)
+        self.assertEqual(det.threshold, 0.95)
+
+
+class TestAdaptiveCooldown(unittest.TestCase):
+    """Test that DecisionGate uses shorter cooldown after app switch."""
+
+    def _make_change(self, ssim=0.80):
+        return ChangeResult(
+            ssim_score=ssim,
+            diff_image=MagicMock(),
+            contours=[],
+            bbox=(0, 0, 100, 100),
+        )
+
+    def _make_ocr(self, text=""):
+        return OCRResult(text=text, confidence=90, word_count=len(text.split()))
+
+    def test_init_has_adaptive_params(self):
+        gate = DecisionGate(adaptive_cooldown_ms=2000)
+        self.assertEqual(gate.adaptive_cooldown_ms, 2000)
+        self.assertEqual(gate.last_app_change_ts, 0)
+
+    def test_app_change_sets_timestamp(self):
+        gate = DecisionGate(cooldown_ms=5000, adaptive_cooldown_ms=2000,
+                            context_cooldown_ms=0)
+        change = self._make_change()
+        ocr = self._make_ocr()
+
+        # First call with app_changed — should set last_app_change_ts
+        event = gate.classify(change, ocr, app_changed=True)
+        self.assertIsNotNone(event)
+        self.assertEqual(event.type, "context")
+        self.assertGreater(gate.last_app_change_ts, 0)
+
+    def test_adaptive_cooldown_shorter_after_app_switch(self):
+        gate = DecisionGate(cooldown_ms=5000, adaptive_cooldown_ms=2000,
+                            context_cooldown_ms=0)
+        long_text = "This is a sufficiently long OCR text for testing purposes here"
+        change = self._make_change(ssim=0.80)
+        ocr = self._make_ocr(long_text)
+
+        # Trigger app change to set last_app_change_ts
+        gate.classify(change, ocr, app_changed=True)
+
+        # Immediately after: should use 2s adaptive cooldown
+        # Within 2s window, should be gated
+        event = gate.classify(change, ocr, app_changed=False)
+        self.assertIsNone(event)  # within 2s cooldown
+
+        # Simulate 2.1s passing by adjusting timestamps
+        gate.last_send_ts -= 2100  # pretend 2.1s have passed
+        gate.last_app_change_ts = time.time() * 1000 - 1000  # app change 1s ago (within 10s)
+
+        event = gate.classify(change, self._make_ocr(long_text + " extra"), app_changed=False)
+        self.assertIsNotNone(event)
+        self.assertEqual(event.type, "text")
+
+    def test_normal_cooldown_when_no_recent_app_change(self):
+        gate = DecisionGate(cooldown_ms=5000, adaptive_cooldown_ms=2000,
+                            context_cooldown_ms=10000)
+        long_text = "This is a sufficiently long OCR text for testing purposes here"
+        change = self._make_change(ssim=0.80)
+        ocr = self._make_ocr(long_text)
+
+        # No app change ever — last_app_change_ts is 0
+        # Send an initial event
+        event = gate.classify(change, ocr, app_changed=False)
+        self.assertIsNotNone(event)
+
+        # Try again after 3s (> adaptive but < normal cooldown)
+        gate.last_send_ts -= 3000
+        event = gate.classify(change, self._make_ocr(long_text + " more"), app_changed=False)
+        # Should be gated because no recent app change → uses 5s cooldown
+        self.assertIsNone(event)
+
+
+class TestSkipImageForTextEvents(unittest.TestCase):
+    """Verify that text events don't get image data packaged."""
+
+    def test_text_event_has_no_roi(self):
+        """Simulate what __main__.py does: text events skip package_roi."""
+        event = SenseEvent(type="text", ts=time.time() * 1000, ocr="some text")
+        # The logic in __main__.py:
+        # if event.type == "context": package_full_frame
+        # elif event.type == "visual" and rois: package_roi
+        # text events: nothing
+        if event.type == "context":
+            event.roi = {"data": "base64..."}
+        elif event.type == "visual":
+            event.roi = {"data": "base64..."}
+        # text: no roi set
+        self.assertIsNone(event.roi)
+
+    def test_visual_event_gets_roi(self):
+        event = SenseEvent(type="visual", ts=time.time() * 1000, ocr="")
+        rois = [MagicMock()]
+        if event.type == "visual" and rois:
+            event.roi = {"data": "base64...", "bbox": [0, 0, 100, 100]}
+        self.assertIsNotNone(event.roi)
+
+
+class TestSenderLatencyTracking(unittest.TestCase):
+    """Test that SenseSender tracks send latencies."""
+
+    def test_init_has_latency_fields(self):
+        sender = SenseSender()
+        self.assertIsInstance(sender._latencies, list)
+        self.assertEqual(len(sender._latencies), 0)
+        self.assertIsInstance(sender._last_stats_ts, float)
+
+    @patch("sense_client.sender.requests.post")
+    def test_send_tracks_latency(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_post.return_value = mock_resp
+
+        sender = SenseSender(url="http://localhost:18791")
+        event = SenseEvent(type="text", ts=time.time() * 1000, ocr="test",
+                           meta=SenseMeta(ssim=0.9, app="test"))
+
+        ok = sender.send(event)
+        self.assertTrue(ok)
+        self.assertEqual(len(sender._latencies), 1)
+        self.assertGreater(sender._latencies[0], 0)
+
+    @patch("sense_client.sender.requests.post")
+    def test_stats_logged_after_interval(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_post.return_value = mock_resp
+
+        sender = SenseSender(url="http://localhost:18791")
+        sender._last_stats_ts = time.time() - 61  # pretend 61s ago
+
+        event = SenseEvent(type="text", ts=time.time() * 1000, ocr="test",
+                           meta=SenseMeta(ssim=0.9, app="test"))
+
+        with patch("builtins.print") as mock_print:
+            sender.send(event)
+            # Should have logged stats
+            calls = [str(c) for c in mock_print.call_args_list]
+            stats_logged = any("[sender] relay latency" in c for c in calls)
+            self.assertTrue(stats_logged, f"Expected latency stats log, got: {calls}")
+
+    @patch("sense_client.sender.requests.post")
+    def test_stats_not_logged_before_interval(self, mock_post):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_post.return_value = mock_resp
+
+        sender = SenseSender(url="http://localhost:18791")
+        # _last_stats_ts defaults to now, so interval not elapsed
+
+        event = SenseEvent(type="text", ts=time.time() * 1000, ocr="test",
+                           meta=SenseMeta(ssim=0.9, app="test"))
+
+        with patch("builtins.print") as mock_print:
+            sender.send(event)
+            calls = [str(c) for c in mock_print.call_args_list]
+            stats_logged = any("[sender] relay latency" in c for c in calls)
+            self.assertFalse(stats_logged)
+
+
+class TestParallelOCR(unittest.TestCase):
+    """Test parallel OCR logic from __main__.py."""
+
+    def test_single_roi_no_threadpool(self):
+        """With 1 ROI, OCR is called directly (no ThreadPoolExecutor)."""
+        mock_ocr = MagicMock()
+        mock_ocr.extract.return_value = OCRResult(text="hello world test text here", confidence=90, word_count=5)
+
+        roi = MagicMock()
+        rois = [roi]
+
+        # Simulate single-ROI path
+        if len(rois) == 1:
+            result = mock_ocr.extract(rois[0].image)
+        else:
+            result = None
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result.text, "hello world test text here")
+        mock_ocr.extract.assert_called_once()
+
+    def test_multiple_rois_picks_best(self):
+        """With multiple ROIs, pick the result with most text."""
+        results = [
+            OCRResult(text="short", confidence=90, word_count=1),
+            OCRResult(text="this is the longest text result here", confidence=85, word_count=7),
+            OCRResult(text="medium text", confidence=88, word_count=2),
+        ]
+
+        best = max(results, key=lambda r: len(r.text))
+        self.assertEqual(best.text, "this is the longest text result here")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/setup-overlay.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// sinain setup-overlay — clone and build the Flutter overlay app
+
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const HOME = os.homedir();
+const SINAIN_DIR = path.join(HOME, ".sinain");
+const REPO_DIR = path.join(SINAIN_DIR, "overlay-repo");
+const OVERLAY_LINK = path.join(SINAIN_DIR, "overlay");
+
+const BOLD  = "\x1b[1m";
+const GREEN = "\x1b[32m";
+const RED   = "\x1b[31m";
+const RESET = "\x1b[0m";
+
+function log(msg) { console.log(`${BOLD}[setup-overlay]${RESET} ${msg}`); }
+function ok(msg)  { console.log(`${BOLD}[setup-overlay]${RESET} ${GREEN}✓${RESET} ${msg}`); }
+function fail(msg) { console.error(`${BOLD}[setup-overlay]${RESET} ${RED}✗${RESET} ${msg}`); process.exit(1); }
+
+// Check flutter
+try {
+  execSync("which flutter", { stdio: "pipe" });
+} catch {
+  fail("flutter not found. Install it: https://docs.flutter.dev/get-started/install");
+}
+
+const flutterVer = execSync("flutter --version 2>&1", { encoding: "utf-8" }).split("\n")[0];
+ok(`flutter: ${flutterVer}`);
+
+fs.mkdirSync(SINAIN_DIR, { recursive: true });
+
+// Clone or update
+if (fs.existsSync(path.join(REPO_DIR, ".git"))) {
+  log("Updating existing overlay repo...");
+  execSync("git pull --ff-only", { cwd: REPO_DIR, stdio: "inherit" });
+  ok("Repository updated");
+} else {
+  log("Cloning overlay (sparse checkout — only overlay/ directory)...");
+  if (fs.existsSync(REPO_DIR)) {
+    fs.rmSync(REPO_DIR, { recursive: true, force: true });
+  }
+  execSync(
+    `git clone --depth 1 --filter=blob:none --sparse https://github.com/anthillnet/sinain-hud.git "${REPO_DIR}"`,
+    { stdio: "inherit" }
+  );
+  execSync("git sparse-checkout set overlay", { cwd: REPO_DIR, stdio: "inherit" });
+  ok("Repository cloned");
+}
+
+// Build
+const overlayDir = path.join(REPO_DIR, "overlay");
+if (!fs.existsSync(path.join(overlayDir, "pubspec.yaml"))) {
+  fail("overlay/pubspec.yaml not found — sparse checkout may have failed");
+}
+
+log("Installing Flutter dependencies...");
+execSync("flutter pub get", { cwd: overlayDir, stdio: "inherit" });
+
+log("Building overlay (this may take a few minutes)...");
+execSync("flutter build macos", { cwd: overlayDir, stdio: "inherit" });
+ok("Overlay built successfully");
+
+// Symlink ~/.sinain/overlay → the overlay source dir
+try {
+  if (fs.existsSync(OVERLAY_LINK)) {
+    fs.unlinkSync(OVERLAY_LINK);
+  }
+  fs.symlinkSync(overlayDir, OVERLAY_LINK);
+  ok(`Symlinked: ${OVERLAY_LINK} → ${overlayDir}`);
+} catch (e) {
+  // Symlink may fail on some systems — fall back to just noting the path
+  log(`Overlay built at: ${overlayDir}`);
+}
+
+console.log(`
+${GREEN}✓${RESET} Overlay setup complete!
+  The overlay will auto-start with: ${BOLD}sinain start${RESET}
+  Or run manually: cd ${overlayDir} && flutter run -d macos
+`);

package/sinain-agent/.env.example

@@ -0,0 +1,17 @@
+# sinain-agent configuration
+# Copy to .env and customize:  cp .env.example .env
+
+# ── Agent ──
+SINAIN_AGENT=claude                # claude | codex | junie | goose | aider | <custom command>
+                                   # MCP agents (claude, codex, junie, goose) call sinain tools directly
+                                   # Pipe agents (aider, custom) receive escalation text on stdin
+
+# ── Core connection ──
+SINAIN_CORE_URL=http://localhost:9500
+
+# ── Timing ──
+SINAIN_POLL_INTERVAL=5             # seconds between escalation polls
+SINAIN_HEARTBEAT_INTERVAL=900      # seconds between heartbeat ticks (15 min)
+
+# ── Workspace ──
+SINAIN_WORKSPACE=~/.openclaw/workspace  # knowledge files, curation scripts, playbook

package/sinain-agent/CLAUDE.md

@@ -0,0 +1,80 @@
+# Sinain HUD Agent
+
+You are a coding assistant connected to sinain-hud, a privacy-first AI overlay for macOS. You observe the user's screen and audio context via the HUD system and provide real-time advice displayed on an invisible overlay.
+
+## Your Tools
+
+You have MCP tools from `sinain-mcp-server`:
+- `sinain_get_escalation` — poll for pending escalation (call every 3-5 seconds in your main loop)
+- `sinain_respond` — submit your response to an escalation (appears on user's HUD)
+- `sinain_get_context` — get the full context window (screen OCR, audio transcripts, app history)
+- `sinain_get_digest` — get the current agent analysis summary
+- `sinain_get_feedback` — get feedback signals from recent escalations
+- `sinain_post_feed` — push an arbitrary message to the HUD
+- `sinain_health` — check system health
+- `sinain_knowledge_query` — query the knowledge graph for relevant context
+- `sinain_heartbeat_tick` — run the full curation pipeline (git backup, signals, insights, playbook)
+- `sinain_module_guidance` — get active module guidance
+
+## Main Loop
+
+Your primary job is an escalation response loop:
+
+1. Call `sinain_get_escalation` to check for pending escalations
+2. If an escalation is present:
+   a. Read the escalation message carefully — it contains screen OCR, audio transcripts, app context, and the local agent's digest
+   b. Optionally call `sinain_knowledge_query` with key context from the escalation to enrich your response
+   c. Optionally call `sinain_module_guidance` to get active module instructions
+   d. Craft a response and call `sinain_respond` with the escalation ID and your response
+3. If no escalation is pending, wait a few seconds and poll again
+4. Every 15 minutes, run `sinain_heartbeat_tick` for curation maintenance
+
+## Response Guidelines
+
+When responding to escalations:
+
+- **5-10 sentences** — concise but substantive
+- **Address errors first** — if the context shows errors, stack traces, or failures, diagnose and suggest fixes
+- **Reference specific context** — quote screen text or audio when relevant ("I see you have a TypeError on line 42...")
+- **Coding context** — if the user is in an IDE or coding platform, focus on code-level help (fixes, patterns, suggestions). Max 4000 chars.
+- **Non-coding context** — share insights, connections, tips relevant to what's on screen. Max 3000 chars.
+- **Never NO_REPLY** — always provide value. If context is minimal, share a relevant insight or tech joke.
+- **Never describe what the user is doing** — they can see their own screen. Add value, don't narrate.
+
+## Heartbeat Cycle (every 15 minutes)
+
+1. Call `sinain_heartbeat_tick` with a brief session summary
+2. The tool runs the full pipeline automatically:
+   - Git backup of memory directory
+   - Signal analysis (detects opportunities from session patterns)
+   - Insight synthesis (generates suggestions from accumulated patterns)
+   - Playbook curation (updates effective playbook based on feedback)
+3. If the result contains a suggestion or insight, post it to the HUD via `sinain_post_feed`
+4. Optionally call `sinain_get_feedback` to review recent escalation scores
+
+## Spawning Background Tasks
+
+When an escalation suggests deeper research would help:
+
+1. **Respond first** — the user sees your immediate HUD response
+2. Spawn a background research task (use your native subprocess/agent capabilities)
+3. On next escalation or heartbeat, check for completed task results
+4. Integrate findings into your response or playbook
+
+Rules:
+- Max 2 spawns per hour
+- Never duplicate a recent task
+- Keep spawned tasks focused and time-bounded
+
+## Files You Manage
+
+Your working memory lives at `~/.openclaw/workspace/memory/`:
+- `playbook.md` — your effective playbook (updated by curation pipeline)
+- `triplestore.db` — knowledge graph (SQLite, managed by Python scripts)
+- `playbook-logs/YYYY-MM-DD.jsonl` — decision logs
+
+## Privacy
+
+The HUD overlay is invisible to screen capture. All content you receive has already been privacy-stripped by sinain-core. Your responses appear only on the ghost overlay — they are never captured in screenshots or recordings.
+
+Never include `<private>` tagged content in your responses — it will be stripped automatically, but avoid echoing it.

package/sinain-agent/mcp-config.json

@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "sinain": {
+      "command": "../sinain-core/node_modules/.bin/tsx",
+      "args": ["../sinain-mcp-server/index.ts"],
+      "env": {
+        "SINAIN_CORE_URL": "http://localhost:9500",
+        "SINAIN_WORKSPACE": "~/.openclaw/workspace"
+      }
+    }
+  }
+}