@geravant/sinain 1.3.0 → 1.5.0

package/cli.js

@@ -6,6 +6,7 @@ import fs from "fs";
 import path from "path";
 
 const cmd = process.argv[2];
+const IS_WINDOWS = os.platform() === "win32";
 
 switch (cmd) {
   case "start":
@@ -20,6 +21,10 @@ switch (cmd) {
     await showStatus();
     break;
 
+  case "setup":
+    await runSetupWizard();
+    break;
+
   case "setup-overlay":
     await import("./setup-overlay.js");
     break;
@@ -41,39 +46,209 @@ switch (cmd) {
     break;
 }
 
+// ── Setup wizard (standalone) ─────────────────────────────────────────────────
+
+async function runSetupWizard() {
+  // Force-run the wizard even if .env exists (re-configure)
+  const { setupWizard } = await import("./launcher.js?setup-only");
+  // The wizard is embedded in launcher.js; we import the module dynamically.
+  // Since launcher.js runs main() on import, we instead inline a lightweight version.
+
+  const readline = await import("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+
+  const HOME = os.homedir();
+  const SINAIN_DIR = path.join(HOME, ".sinain");
+  const envPath = path.join(SINAIN_DIR, ".env");
+
+  const BOLD = "\x1b[1m";
+  const DIM = "\x1b[2m";
+  const GREEN = "\x1b[32m";
+  const YELLOW = "\x1b[33m";
+  const RESET = "\x1b[0m";
+  const IS_WIN = os.platform() === "win32";
+
+  const cmdExists = (cmd) => {
+    try { import("child_process").then(cp => cp.execSync(`which ${cmd}`, { stdio: "pipe" })); return true; }
+    catch { return false; }
+  };
+  // Synchronous version
+  const { execSync } = await import("child_process");
+  const cmdExistsSync = (cmd) => {
+    try { execSync(`which ${cmd}`, { stdio: "pipe" }); return true; }
+    catch { return false; }
+  };
+
+  if (fs.existsSync(envPath)) {
+    const overwrite = await ask(`  ${envPath} already exists. Overwrite? [y/N]: `);
+    if (overwrite.trim().toLowerCase() !== "y") {
+      console.log("  Aborted.");
+      rl.close();
+      return;
+    }
+  }
+
+  console.log();
+  console.log(`${BOLD}── Sinain Setup Wizard ─────────────────${RESET}`);
+  console.log(`  Configuring ${DIM}~/.sinain/.env${RESET}`);
+  console.log();
+
+  const vars = {};
+
+  // Transcription backend
+  let transcriptionBackend = "openrouter";
+  const hasWhisper = !IS_WIN && cmdExistsSync("whisper-cli");
+
+  if (IS_WIN) {
+    console.log(`  ${DIM}(Local whisper not available on Windows — using OpenRouter)${RESET}`);
+  } else if (hasWhisper) {
+    const choice = await ask(`  Transcription backend? [${BOLD}local${RESET}/cloud]: `);
+    transcriptionBackend = choice.trim().toLowerCase() === "cloud" ? "openrouter" : "local";
+  } else {
+    const install = await ask(`  whisper-cli not found. Install via Homebrew? [Y/n]: `);
+    if (!install.trim() || install.trim().toLowerCase() === "y") {
+      try {
+        execSync("brew install whisper-cpp", { stdio: "inherit" });
+        const modelDir = path.join(HOME, "models");
+        const modelPath = path.join(modelDir, "ggml-large-v3-turbo.bin");
+        if (!fs.existsSync(modelPath)) {
+          console.log(`  ${DIM}Downloading model (~1.5 GB)...${RESET}`);
+          fs.mkdirSync(modelDir, { recursive: true });
+          execSync(`curl -L --progress-bar -o "${modelPath}" "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin"`, { stdio: "inherit" });
+        }
+        transcriptionBackend = "local";
+        vars.LOCAL_WHISPER_MODEL = modelPath;
+      } catch {
+        console.log(`  ${YELLOW}Install failed — falling back to OpenRouter${RESET}`);
+      }
+    }
+  }
+  vars.TRANSCRIPTION_BACKEND = transcriptionBackend;
+
+  // API key
+  if (transcriptionBackend === "openrouter") {
+    const key = await ask(`  OpenRouter API key (sk-or-...): `);
+    if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
+  } else {
+    const key = await ask(`  OpenRouter API key for vision/OCR (optional): `);
+    if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
+  }
+
+  // Agent
+  const agent = await ask(`  Agent? [${BOLD}claude${RESET}/codex/goose/junie/aider]: `);
+  vars.SINAIN_AGENT = agent.trim().toLowerCase() || "claude";
+
+  // Escalation
+  console.log(`\n  ${DIM}Escalation: off | selective | focus | rich${RESET}`);
+  const esc = await ask(`  Escalation mode? [${BOLD}selective${RESET}]: `);
+  vars.ESCALATION_MODE = esc.trim().toLowerCase() || "selective";
+
+  // Gateway
+  const gw = await ask(`  OpenClaw gateway? [y/N]: `);
+  if (gw.trim().toLowerCase() === "y") {
+    const url = await ask(`  Gateway WS URL [ws://localhost:18789]: `);
+    vars.OPENCLAW_WS_URL = url.trim() || "ws://localhost:18789";
+    const token = await ask(`  Auth token (48-char hex): `);
+    if (token.trim()) {
+      vars.OPENCLAW_WS_TOKEN = token.trim();
+      vars.OPENCLAW_HTTP_TOKEN = token.trim();
+    }
+    vars.OPENCLAW_HTTP_URL = vars.OPENCLAW_WS_URL.replace(/^ws/, "http") + "/hooks/agent";
+    vars.OPENCLAW_SESSION_KEY = "agent:main:sinain";
+  }
+
+  vars.SINAIN_POLL_INTERVAL = "5";
+  vars.SINAIN_HEARTBEAT_INTERVAL = "900";
+  vars.PRIVACY_MODE = "standard";
+
+  // Write — start from .env.example template, patch wizard values in
+  fs.mkdirSync(SINAIN_DIR, { recursive: true });
+
+  const PKG_DIR = path.dirname(new URL(import.meta.url).pathname);
+  const examplePath = path.join(PKG_DIR, ".env.example");
+  const siblingExample = path.join(PKG_DIR, "..", ".env.example");
+  let template = "";
+  if (fs.existsSync(examplePath)) {
+    template = fs.readFileSync(examplePath, "utf-8");
+  } else if (fs.existsSync(siblingExample)) {
+    template = fs.readFileSync(siblingExample, "utf-8");
+  }
+
+  if (template) {
+    for (const [k, v] of Object.entries(vars)) {
+      const regex = new RegExp(`^#?\\s*${k}=.*$`, "m");
+      if (regex.test(template)) {
+        template = template.replace(regex, `${k}=${v}`);
+      } else {
+        template += `\n${k}=${v}`;
+      }
+    }
+    template = `# Generated by sinain setup wizard — ${new Date().toISOString()}\n${template}`;
+    fs.writeFileSync(envPath, template);
+  } else {
+    const lines = ["# sinain configuration — generated by setup wizard", `# ${new Date().toISOString()}`, ""];
+    for (const [k, v] of Object.entries(vars)) lines.push(`${k}=${v}`);
+    lines.push("");
+    fs.writeFileSync(envPath, lines.join("\n"));
+  }
+
+  rl.close();
+  console.log(`\n  ${GREEN}✓${RESET} Config written to ${envPath}\n`);
+}
+
 // ── Stop ──────────────────────────────────────────────────────────────────────
 
 async function stopServices() {
   let killed = false;
 
-  const patterns = [
-    "tsx.*src/index.ts",
-    "tsx watch src/index.ts",
-    "python3 -m sense_client",
-    "Python -m sense_client",
-    "flutter run -d macos",
-    "sinain_hud.app/Contents/MacOS/sinain_hud",
-    "sinain-agent/run.sh",
-  ];
-
-  for (const pat of patterns) {
-    try {
-      execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
-      killed = true;
-    } catch { /* not running */ }
+  if (IS_WINDOWS) {
+    const exes = ["sinain_hud.exe", "tsx.cmd", "python3.exe", "python.exe"];
+    for (const exe of exes) {
+      try {
+        execSync(`taskkill /F /IM "${exe}" 2>NUL`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
+    }
+  } else {
+    const patterns = [
+      "tsx.*src/index.ts",
+      "tsx watch src/index.ts",
+      "python3 -m sense_client",
+      "Python -m sense_client",
+      "flutter run -d macos",
+      "sinain_hud.app/Contents/MacOS/sinain_hud",
+      "sinain-agent/run.sh",
+    ];
+
+    for (const pat of patterns) {
+      try {
+        execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
+    }
   }
 
   // Free port 9500
   try {
-    const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (pid) {
-      execSync(`kill ${pid}`, { stdio: "pipe" });
-      killed = true;
+    if (IS_WINDOWS) {
+      const out = execSync('netstat -ano | findstr ":9500" | findstr "LISTENING"', { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const pid = out.split(/\s+/).pop();
+      if (pid && pid !== "0") {
+        execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
+    } else {
+      const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      if (pid) {
+        execSync(`kill ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
     }
   } catch { /* port already free */ }
 
   // Clean PID file
-  const pidFile = "/tmp/sinain-pids.txt";
+  const pidFile = path.join(os.tmpdir(), "sinain-pids.txt");
   if (fs.existsSync(pidFile)) {
     fs.unlinkSync(pidFile);
   }
@@ -107,7 +282,7 @@ async function showStatus() {
     console.log(`  ${CYAN}core${RESET}     :9500   ${RED}✗${RESET}  stopped`);
   }
 
-  // Sense: check pgrep
+  // Sense: check process
   const senseUp = isProcessRunning("python3 -m sense_client") || isProcessRunning("Python -m sense_client");
   if (senseUp) {
     console.log(`  ${YELLOW}sense${RESET}            ${GREEN}✓${RESET}  running`);
@@ -116,7 +291,7 @@ async function showStatus() {
   }
 
   // Overlay
-  const overlayUp = isProcessRunning("sinain_hud.app") || isProcessRunning("flutter run -d macos");
+  const overlayUp = isProcessRunning("sinain_hud");
   if (overlayUp) {
     console.log(`  ${MAGENTA}overlay${RESET}          ${GREEN}✓${RESET}  running`);
   } else {
@@ -124,7 +299,7 @@ async function showStatus() {
   }
 
   // Agent
-  const agentUp = isProcessRunning("sinain-agent/run.sh");
+  const agentUp = isProcessRunning("sinain-agent");
   if (agentUp) {
     console.log(`  ${GREEN}agent${RESET}            ${GREEN}✓${RESET}  running`);
   } else {
@@ -147,8 +322,13 @@ function isPortOpen(port) {
 
 function isProcessRunning(pattern) {
   try {
-    execSync(`pgrep -f "${pattern}"`, { stdio: "pipe" });
-    return true;
+    if (IS_WINDOWS) {
+      const out = execSync(`tasklist /FI "IMAGENAME eq ${pattern}.exe" 2>NUL`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+      return out.includes(pattern);
+    } else {
+      execSync(`pgrep -f "${pattern}"`, { stdio: "pipe" });
+      return true;
+    }
   } catch {
     return false;
   }
@@ -158,12 +338,13 @@ function isProcessRunning(pattern) {
 
 function printUsage() {
   console.log(`
-sinain — AI overlay system for macOS
+sinain — AI overlay system for macOS and Windows
 
 Usage:
   sinain start [options]       Launch sinain services
   sinain stop                  Stop all sinain services
   sinain status                Check what's running
+  sinain setup                 Run interactive setup wizard (~/.sinain/.env)
   sinain setup-overlay         Download pre-built overlay app
   sinain install               Install OpenClaw plugin (server-side)
 

package/launcher.js

@@ -25,7 +25,8 @@ const RESET   = "\x1b[0m";
 const PKG_DIR = path.dirname(new URL(import.meta.url).pathname);
 const HOME = os.homedir();
 const SINAIN_DIR = path.join(HOME, ".sinain");
-const PID_FILE = "/tmp/sinain-pids.txt";
+const PID_FILE = path.join(os.tmpdir(), "sinain-pids.txt");
+const IS_WINDOWS = os.platform() === "win32";
 
 // ── Parse flags ─────────────────────────────────────────────────────────────
 
@@ -59,6 +60,12 @@ async function main() {
   await preflight();
   console.log();
 
+  // Run setup wizard on first launch (no ~/.sinain/.env)
+  const userEnvPath = path.join(SINAIN_DIR, ".env");
+  if (!fs.existsSync(userEnvPath)) {
+    await setupWizard(userEnvPath);
+  }
+
   // Load user config
   loadUserEnv();
 
@@ -141,16 +148,20 @@ async function main() {
   if (!skipOverlay) {
     const overlay = findOverlay();
     if (overlay?.type === "prebuilt") {
-      // Remove quarantine if present (ad-hoc signed app)
-      try {
-        const xattrs = execSync(`xattr "${overlay.path}"`, { encoding: "utf-8" });
-        if (xattrs.includes("com.apple.quarantine")) {
-          execSync(`xattr -dr com.apple.quarantine "${overlay.path}"`, { stdio: "pipe" });
-        }
-      } catch { /* no quarantine or xattr failed — try launching anyway */ }
+      // Remove macOS quarantine if present (ad-hoc signed app)
+      if (!IS_WINDOWS) {
+        try {
+          const xattrs = execSync(`xattr "${overlay.path}"`, { encoding: "utf-8" });
+          if (xattrs.includes("com.apple.quarantine")) {
+            execSync(`xattr -dr com.apple.quarantine "${overlay.path}"`, { stdio: "pipe" });
+          }
+        } catch { /* no quarantine or xattr failed — try launching anyway */ }
+      }
 
       log("Starting overlay (pre-built)...");
-      const binary = path.join(overlay.path, "Contents/MacOS/sinain_hud");
+      const binary = IS_WINDOWS
+        ? overlay.path  // sinain_hud.exe
+        : path.join(overlay.path, "Contents/MacOS/sinain_hud");
       startProcess("overlay", binary, [], { color: MAGENTA });
       await sleep(2000);
       const overlayChild = children.find(c => c.name === "overlay");
@@ -165,7 +176,8 @@ async function main() {
       const hasFlutter = commandExists("flutter");
       if (hasFlutter) {
         log("Starting overlay (flutter run)...");
-        startProcess("overlay", "flutter", ["run", "-d", "macos"], {
+        const device = IS_WINDOWS ? "windows" : "macos";
+        startProcess("overlay", "flutter", ["run", "-d", device], {
           cwd: overlay.path,
           color: MAGENTA,
         });
@@ -259,7 +271,8 @@ async function preflight() {
       ok("flutter (version unknown)");
     }
   } else {
-    const prebuiltApp = path.join(SINAIN_DIR, "overlay-app", "sinain_hud.app");
+    const prebuiltName = IS_WINDOWS ? "sinain_hud.exe" : "sinain_hud.app";
+    const prebuiltApp = path.join(SINAIN_DIR, "overlay-app", prebuiltName);
     if (fs.existsSync(prebuiltApp)) {
       ok("overlay: pre-built app");
     } else {
@@ -278,12 +291,179 @@ async function preflight() {
   }
 }
 
+// ── Setup wizard ─────────────────────────────────────────────────────────────
+
+async function setupWizard(envPath) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+
+  console.log();
+  console.log(`${BOLD}── First-time setup ────────────────────${RESET}`);
+  console.log(`  Configuring ${DIM}~/.sinain/.env${RESET}`);
+  console.log();
+
+  const vars = {};
+
+  // 1. Transcription backend — auto-detect whisper-cli
+  let transcriptionBackend = "openrouter";
+  const hasWhisper = !IS_WINDOWS && commandExists("whisper-cli");
+
+  if (IS_WINDOWS) {
+    console.log(`  ${DIM}(Local whisper not available on Windows — using OpenRouter)${RESET}`);
+  } else if (hasWhisper) {
+    const choice = await ask(`  Transcription backend? [${BOLD}local${RESET}/cloud] (local = whisper-cli, no API key): `);
+    if (choice.trim().toLowerCase() === "cloud") {
+      transcriptionBackend = "openrouter";
+    } else {
+      transcriptionBackend = "local";
+    }
+  } else {
+    const installWhisper = await ask(`  whisper-cli not found. Install via Homebrew? [Y/n]: `);
+    if (!installWhisper.trim() || installWhisper.trim().toLowerCase() === "y") {
+      try {
+        console.log(`  ${DIM}Installing whisper-cpp...${RESET}`);
+        execSync("brew install whisper-cpp", { stdio: "inherit" });
+
+        // Download model
+        const modelDir = path.join(HOME, "models");
+        const modelPath = path.join(modelDir, "ggml-large-v3-turbo.bin");
+        if (!fs.existsSync(modelPath)) {
+          console.log(`  ${DIM}Downloading ggml-large-v3-turbo (~1.5 GB)...${RESET}`);
+          fs.mkdirSync(modelDir, { recursive: true });
+          execSync(
+            `curl -L --progress-bar -o "${modelPath}" "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin"`,
+            { stdio: "inherit" }
+          );
+        }
+
+        transcriptionBackend = "local";
+        vars.LOCAL_WHISPER_MODEL = modelPath;
+        ok("whisper-cpp installed");
+      } catch {
+        warn("whisper-cpp install failed — falling back to OpenRouter");
+        transcriptionBackend = "openrouter";
+      }
+    } else {
+      transcriptionBackend = "openrouter";
+    }
+  }
+  vars.TRANSCRIPTION_BACKEND = transcriptionBackend;
+
+  // 2. OpenRouter API key (if cloud backend or for vision/OCR)
+  if (transcriptionBackend === "openrouter") {
+    let key = "";
+    while (!key) {
+      key = await ask(`  OpenRouter API key (sk-or-...): `);
+      key = key.trim();
+      if (key && !key.startsWith("sk-or-")) {
+        console.log(`  ${YELLOW}⚠${RESET} Key should start with sk-or-. Try again or press Enter to skip.`);
+        const retry = await ask(`  Use this key anyway? [y/N]: `);
+        if (retry.trim().toLowerCase() !== "y") { key = ""; continue; }
+      }
+      if (!key) {
+        console.log(`  ${DIM}You can set OPENROUTER_API_KEY later in ~/.sinain/.env${RESET}`);
+        break;
+      }
+    }
+    if (key) vars.OPENROUTER_API_KEY = key;
+  } else {
+    // Still ask for OpenRouter key (needed for vision/OCR)
+    const key = await ask(`  OpenRouter API key for vision/OCR (optional, Enter to skip): `);
+    if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
+  }
+
+  // 3. Agent selection
+  const agentChoice = await ask(`  Agent? [${BOLD}claude${RESET}/codex/goose/junie/aider]: `);
+  vars.SINAIN_AGENT = agentChoice.trim().toLowerCase() || "claude";
+
+  // 4. Escalation mode
+  console.log();
+  console.log(`  ${DIM}Escalation modes:${RESET}`);
+  console.log(`    off       — no escalation to gateway`);
+  console.log(`    selective — score-based (errors, questions trigger it)`);
+  console.log(`    focus     — always escalate every tick`);
+  console.log(`    rich      — always escalate with maximum context`);
+  const escMode = await ask(`  Escalation mode? [off/${BOLD}selective${RESET}/focus/rich]: `);
+  vars.ESCALATION_MODE = escMode.trim().toLowerCase() || "selective";
+
+  // 5. OpenClaw gateway
+  const hasGateway = await ask(`  Do you have an OpenClaw gateway? [y/N]: `);
+  if (hasGateway.trim().toLowerCase() === "y") {
+    const wsUrl = await ask(`  Gateway WebSocket URL [ws://localhost:18789]: `);
+    vars.OPENCLAW_WS_URL = wsUrl.trim() || "ws://localhost:18789";
+
+    const wsToken = await ask(`  Gateway auth token (48-char hex): `);
+    if (wsToken.trim()) {
+      vars.OPENCLAW_WS_TOKEN = wsToken.trim();
+      vars.OPENCLAW_HTTP_TOKEN = wsToken.trim();
+    }
+
+    // Derive HTTP URL from WS URL
+    const httpBase = vars.OPENCLAW_WS_URL.replace(/^ws/, "http");
+    vars.OPENCLAW_HTTP_URL = `${httpBase}/hooks/agent`;
+    vars.OPENCLAW_SESSION_KEY = "agent:main:sinain";
+  }
+
+  // 6. Agent-specific defaults
+  vars.SINAIN_POLL_INTERVAL = "5";
+  vars.SINAIN_HEARTBEAT_INTERVAL = "900";
+  vars.PRIVACY_MODE = "standard";
+
+  // Write .env — start from .env.example template, patch wizard values in
+  fs.mkdirSync(path.dirname(envPath), { recursive: true });
+
+  const examplePath = path.join(PKG_DIR, ".env.example");
+  let template = "";
+  if (fs.existsSync(examplePath)) {
+    template = fs.readFileSync(examplePath, "utf-8");
+  } else {
+    // Fallback: try sibling (running from cloned repo)
+    const siblingExample = path.join(PKG_DIR, "..", ".env.example");
+    if (fs.existsSync(siblingExample)) {
+      template = fs.readFileSync(siblingExample, "utf-8");
+    }
+  }
+
+  if (template) {
+    // Patch each wizard var into the template by replacing the KEY=... line
+    for (const [key, val] of Object.entries(vars)) {
+      // Match KEY=anything (possibly commented out with #)
+      const regex = new RegExp(`^#?\\s*${key}=.*$`, "m");
+      if (regex.test(template)) {
+        template = template.replace(regex, `${key}=${val}`);
+      } else {
+        // Key not in template — append it
+        template += `\n${key}=${val}`;
+      }
+    }
+    // Add wizard timestamp header
+    template = `# Generated by sinain setup wizard — ${new Date().toISOString()}\n${template}`;
+    fs.writeFileSync(envPath, template);
+  } else {
+    // No template found — write bare vars (fallback)
+    const lines = [];
+    lines.push("# sinain configuration — generated by setup wizard");
+    lines.push(`# ${new Date().toISOString()}`);
+    lines.push("");
+    for (const [key, val] of Object.entries(vars)) {
+      lines.push(`${key}=${val}`);
+    }
+    lines.push("");
+    fs.writeFileSync(envPath, lines.join("\n"));
+  }
+
+  rl.close();
+
+  console.log();
+  ok(`Config written to ${envPath}`);
+  console.log();
+}
+
 // ── User environment ────────────────────────────────────────────────────────
 
 function loadUserEnv() {
   const envPaths = [
     path.join(SINAIN_DIR, ".env"),
-    path.join(PKG_DIR, "sinain-core/.env"),
   ];
 
   for (const envPath of envPaths) {
@@ -373,31 +553,51 @@ async function installDeps() {
 
 function killStale() {
   let killed = false;
-  const patterns = [
-    "sinain_hud.app/Contents/MacOS/sinain_hud",
-    "flutter run -d macos",
-    "python3 -m sense_client",
-    "Python -m sense_client",
-    "tsx.*src/index.ts",
-    "tsx watch src/index.ts",
-    "sinain-agent/run.sh",
-  ];
 
-  for (const pat of patterns) {
+  if (IS_WINDOWS) {
+    const exes = ["sinain_hud.exe", "tsx.cmd"];
+    for (const exe of exes) {
+      try {
+        execSync(`taskkill /F /IM "${exe}" 2>NUL`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
+    }
+    // Free port 9500
     try {
-      execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
-      killed = true;
-    } catch { /* not running */ }
-  }
-
-  // Free port 9500
-  try {
-    const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    if (pid) {
-      execSync(`kill ${pid}`, { stdio: "pipe" });
-      killed = true;
+      const out = execSync('netstat -ano | findstr ":9500" | findstr "LISTENING"', { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const pid = out.split(/\s+/).pop();
+      if (pid && pid !== "0") {
+        execSync(`taskkill /F /PID ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
+    } catch { /* already free */ }
+  } else {
+    const patterns = [
+      "sinain_hud.app/Contents/MacOS/sinain_hud",
+      "flutter run -d macos",
+      "python3 -m sense_client",
+      "Python -m sense_client",
+      "tsx.*src/index.ts",
+      "tsx watch src/index.ts",
+      "sinain-agent/run.sh",
+    ];
+
+    for (const pat of patterns) {
+      try {
+        execSync(`pkill -f "${pat}"`, { stdio: "pipe" });
+        killed = true;
+      } catch { /* not running */ }
     }
-  } catch { /* already free */ }
+
+    // Free port 9500
+    try {
+      const pid = execSync("lsof -i :9500 -sTCP:LISTEN -t", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      if (pid) {
+        execSync(`kill ${pid}`, { stdio: "pipe" });
+        killed = true;
+      }
+    } catch { /* already free */ }
+  }
 
   // Clean old PID file
   if (fs.existsSync(PID_FILE)) {
@@ -496,8 +696,9 @@ function findOverlay() {
     return { type: "source", path: siblingOverlay };
   }
 
-  // 2. Pre-built .app bundle (downloaded by setup-overlay)
-  const prebuiltApp = path.join(SINAIN_DIR, "overlay-app", "sinain_hud.app");
+  // 2. Pre-built app (downloaded by setup-overlay)
+  const prebuiltName = IS_WINDOWS ? "sinain_hud.exe" : "sinain_hud.app";
+  const prebuiltApp = path.join(SINAIN_DIR, "overlay-app", prebuiltName);
   if (fs.existsSync(prebuiltApp)) {
     return { type: "prebuilt", path: prebuiltApp };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Ambient AI overlay invisible to screen capture — real-time insights from audio + screen context",
   "type": "module",
   "bin": {
@@ -26,7 +26,7 @@
     "sinain-core/package.json",
     "sinain-core/package-lock.json",
     "sinain-core/tsconfig.json",
-    "sinain-core/.env.example",
+    ".env.example",
     "sinain-mcp-server/index.ts",
     "sinain-mcp-server/package.json",
     "sinain-mcp-server/tsconfig.json",

package/setup-overlay.js

@@ -9,8 +9,14 @@ import os from "os";
 const HOME = os.homedir();
 const SINAIN_DIR = path.join(HOME, ".sinain");
 const APP_DIR = path.join(SINAIN_DIR, "overlay-app");
-const APP_PATH = path.join(APP_DIR, "sinain_hud.app");
 const VERSION_FILE = path.join(APP_DIR, "version.json");
+const IS_WINDOWS = os.platform() === "win32";
+
+// Platform-specific asset and app path
+const ASSET_NAME = IS_WINDOWS ? "sinain_hud_windows.zip" : "sinain_hud.app.zip";
+const APP_PATH = IS_WINDOWS
+  ? path.join(APP_DIR, "sinain_hud.exe")
+  : path.join(APP_DIR, "sinain_hud.app");
 
 const REPO = "anthillnet/sinain-hud";
 const RELEASES_API = `https://api.github.com/repos/${REPO}/releases`;
@@ -79,15 +85,15 @@ async function downloadPrebuilt() {
     } catch { /* corrupt version file — re-download */ }
   }
 
-  // Find the .zip asset
-  const zipAsset = release.assets?.find(a => a.name === "sinain_hud.app.zip");
+  // Find the .zip asset for this platform
+  const zipAsset = release.assets?.find(a => a.name === ASSET_NAME);
   if (!zipAsset) {
-    fail(`Release ${tag} has no sinain_hud.app.zip asset.\n  Try: sinain setup-overlay --from-source`);
+    fail(`Release ${tag} has no ${ASSET_NAME} asset.\n  Try: sinain setup-overlay --from-source`);
   }
 
   // Download with progress
-  log(`Downloading overlay ${version} (${formatBytes(zipAsset.size)})...`);
-  const zipPath = path.join(APP_DIR, "sinain_hud.app.zip");
+  log(`Downloading overlay ${version} for ${IS_WINDOWS ? "Windows" : "macOS"} (${formatBytes(zipAsset.size)})...`);
+  const zipPath = path.join(APP_DIR, ASSET_NAME);
 
   try {
     const res = await fetch(zipAsset.browser_download_url, {
@@ -125,23 +131,34 @@ async function downloadPrebuilt() {
     fs.rmSync(APP_PATH, { recursive: true, force: true });
   }
 
-  // Extract — ditto preserves macOS extended attributes (critical for code signing)
+  // Extract
   log("Extracting...");
-  try {
-    execSync(`ditto -x -k "${zipPath}" "${APP_DIR}"`, { stdio: "pipe" });
-  } catch {
-    // Fallback to unzip
+  if (IS_WINDOWS) {
     try {
-      execSync(`unzip -o -q "${zipPath}" -d "${APP_DIR}"`, { stdio: "pipe" });
+      execSync(
+        `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${APP_DIR}' -Force"`,
+        { stdio: "pipe" }
+      );
     } catch (e) {
       fail(`Extraction failed: ${e.message}`);
     }
-  }
+  } else {
+    // ditto preserves macOS extended attributes (critical for code signing)
+    try {
+      execSync(`ditto -x -k "${zipPath}" "${APP_DIR}"`, { stdio: "pipe" });
+    } catch {
+      try {
+        execSync(`unzip -o -q "${zipPath}" -d "${APP_DIR}"`, { stdio: "pipe" });
+      } catch (e) {
+        fail(`Extraction failed: ${e.message}`);
+      }
+    }
 
-  // Remove quarantine attribute (ad-hoc signed app downloaded from internet)
-  try {
-    execSync(`xattr -cr "${APP_PATH}"`, { stdio: "pipe" });
-  } catch { /* xattr may not be needed */ }
+    // Remove quarantine attribute (ad-hoc signed app downloaded from internet)
+    try {
+      execSync(`xattr -cr "${APP_PATH}"`, { stdio: "pipe" });
+    } catch { /* xattr may not be needed */ }
+  }
 
   // Write version marker
   fs.writeFileSync(VERSION_FILE, JSON.stringify({
@@ -203,8 +220,9 @@ async function buildFromSource() {
   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" });
+  const buildTarget = IS_WINDOWS ? "windows" : "macos";
+  log(`Building overlay for ${buildTarget} (this may take a few minutes)...`);
+  execSync(`flutter build ${buildTarget}`, { cwd: overlayDir, stdio: "inherit" });
   ok("Overlay built successfully");
 
   // Symlink ~/.sinain/overlay → the overlay source dir
@@ -221,7 +239,7 @@ async function buildFromSource() {
   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
+  Or run manually: cd ${overlayDir} && flutter run -d ${IS_WINDOWS ? "windows" : "macos"}
 `);
 }
 

package/sinain-agent/CLAUDE.md

@@ -82,6 +82,6 @@ Your working memory lives at `~/.openclaw/workspace/memory/`:
 
 ## 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.
+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 invisible 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/run.sh

@@ -3,12 +3,19 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
-# Load .env if present (does not override existing env vars)
+# Load .env as fallback — does NOT override vars already in the environment
+# (e.g. vars set by the launcher from ~/.sinain/.env)
 if [ -f "$SCRIPT_DIR/.env" ]; then
-  set -a
-  # shellcheck source=/dev/null
-  . "$SCRIPT_DIR/.env"
-  set +a
+  while IFS='=' read -r key val; do
+    # Skip comments and blank lines
+    [[ -z "$key" || "$key" =~ ^[[:space:]]*# ]] && continue
+    key=$(echo "$key" | xargs)  # trim whitespace
+    val=$(echo "$val" | xargs)
+    # Only set if not already in environment
+    if [ -z "${!key+x}" ]; then
+      export "$key=$val"
+    fi
+  done < "$SCRIPT_DIR/.env"
 fi
 
 MCP_CONFIG="${MCP_CONFIG:-$SCRIPT_DIR/mcp-config.json}"
@@ -217,6 +224,37 @@ while true; do
     echo ""
   fi
 
+  # Poll for pending spawn task (queued via HUD Shift+Enter or POST /spawn)
+  SPAWN=$(curl -sf "$CORE_URL/spawn/pending" 2>/dev/null || echo '{"ok":false}')
+  SPAWN_ID=$(echo "$SPAWN" | python3 -c "import sys,json; d=json.load(sys.stdin); t=d.get('task'); print(t['id'] if t else '')" 2>/dev/null || true)
+
+  if [ -n "$SPAWN_ID" ]; then
+    SPAWN_TASK=$(echo "$SPAWN" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['task']['task'])" 2>/dev/null)
+    SPAWN_LABEL=$(echo "$SPAWN" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['task'].get('label','task'))" 2>/dev/null)
+
+    echo "[$(date +%H:%M:%S)] Spawn task $SPAWN_ID ($SPAWN_LABEL)"
+
+    if agent_has_mcp; then
+      # MCP path: agent runs task with sinain tools available
+      SPAWN_PROMPT="You have a background task to complete. Task: $SPAWN_TASK
+
+Complete this task thoroughly. Use sinain_get_knowledge and sinain_knowledge_query if you need context from past sessions. Summarize your findings concisely."
+      SPAWN_RESULT=$(invoke_agent "$SPAWN_PROMPT" || echo "ERROR: agent invocation failed")
+    else
+      # Pipe path: agent gets task text directly
+      SPAWN_RESULT=$(invoke_pipe "Background task: $SPAWN_TASK" || echo "No output")
+    fi
+
+    # Post result back
+    if [ -n "$SPAWN_RESULT" ]; then
+      curl -sf -X POST "$CORE_URL/spawn/respond" \
+        -H 'Content-Type: application/json' \
+        -d "{\"id\":\"$SPAWN_ID\",\"result\":$(echo "$SPAWN_RESULT" | json_encode)}" >/dev/null 2>&1 || true
+      echo "[$(date +%H:%M:%S)] Spawn $SPAWN_ID completed: ${SPAWN_RESULT:0:120}..."
+    fi
+    echo ""
+  fi
+
   # Heartbeat check
   NOW=$(date +%s)
   ELAPSED=$((NOW - LAST_HEARTBEAT))

package/sinain-core/src/escalation/escalator.ts

@@ -78,6 +78,9 @@ export class Escalator {
   private pendingUserCommand: UserCommand | null = null;
   private static readonly USER_COMMAND_EXPIRY_MS = 120_000; // 2 minutes
 
+  // HTTP spawn queue — for bare agents that poll (mirrors httpPending for escalation)
+  private spawnHttpPending: { id: string; task: string; label: string; ts: number } | null = null;
+
   private stats = {
     totalEscalations: 0,
     totalResponses: 0,
@@ -397,6 +400,37 @@ ${recentLines.join("\n")}`;
     return { ok: true };
   }
 
+  /** Return the current HTTP pending spawn task (or null). */
+  getSpawnPending(): { id: string; task: string; label: string; ts: number } | null {
+    return this.spawnHttpPending;
+  }
+
+  /** Respond to a pending spawn task from a bare agent. */
+  respondSpawn(id: string, result: string): { ok: boolean; error?: string } {
+    if (!this.spawnHttpPending) {
+      return { ok: false, error: "no pending spawn task" };
+    }
+    if (this.spawnHttpPending.id !== id) {
+      return { ok: false, error: `id mismatch: expected ${this.spawnHttpPending.id}` };
+    }
+
+    const label = this.spawnHttpPending.label;
+    const startedAt = this.spawnHttpPending.ts;
+
+    // Push result to HUD feed
+    const maxLen = 3000;
+    const text = `[🔧 ${label}] ${result.trim().slice(0, maxLen)}`;
+    this.deps.feedBuffer.push(text, "high", "openclaw", "agent");
+    this.deps.wsHandler.broadcast(text, "high", "agent");
+
+    // Broadcast completion
+    this.broadcastTaskEvent(id, "completed", label, startedAt, result.slice(0, 200));
+
+    log(TAG, `spawn ${id} responded (${result.length} chars)`);
+    this.spawnHttpPending = null;
+    return { ok: true };
+  }
+
   /** Whether the gateway WS client is currently connected. */
   get isGatewayConnected(): boolean {
     return this.wsClient.isConnected;
@@ -468,8 +502,12 @@ ${recentLines.join("\n")}`;
     this.broadcastTaskEvent(taskId, "spawned", label, startedAt);
 
     if (!this.wsClient.isConnected) {
-      warn(TAG, `spawn-task ${taskId}: WS disconnected — cannot dispatch`);
-      this.broadcastTaskEvent(taskId, "failed", label, startedAt);
+      // No OpenClaw gateway — queue for bare agent HTTP polling
+      this.spawnHttpPending = { id: taskId, task, label: label || "background-task", ts: startedAt };
+      const preview = task.length > 60 ? task.slice(0, 60) + "…" : task;
+      this.deps.feedBuffer.push(`🔧 Task queued for agent: ${preview}`, "normal", "system", "stream");
+      this.deps.wsHandler.broadcast(`🔧 Task queued for agent: ${preview}`, "normal");
+      log(TAG, `spawn-task ${taskId}: WS disconnected — queued for bare agent polling`);
       return;
     }
 

package/sinain-core/src/index.ts

@@ -416,6 +416,15 @@ async function main() {
         return execFileSync("python3", args, { timeout: 5000, encoding: "utf-8" });
       } catch { return ""; }
     },
+
+    // Spawn background agent task (from HUD Shift+Enter or bare agent POST /spawn)
+    onSpawnCommand: (text: string) => {
+      escalator.dispatchSpawnTask(text, "user-command").catch((err) => {
+        log("srv", `spawn via HTTP failed: ${err}`);
+      });
+    },
+    getSpawnPending: () => escalator.getSpawnPending(),
+    respondSpawn: (id: string, result: string) => escalator.respondSpawn(id, result),
   });
 
   // ── Wire overlay profiling ──
@@ -435,6 +444,12 @@ async function main() {
     onUserCommand: (text) => {
       escalator.setUserCommand(text);
     },
+    onSpawnCommand: (text) => {
+      escalator.dispatchSpawnTask(text, "user-command").catch((err) => {
+        log("cmd", `spawn command failed: ${err}`);
+        wsHandler.broadcast(`\u26a0 Spawn failed: ${String(err).slice(0, 100)}`, "normal");
+      });
+    },
     onToggleScreen: () => {
       screenActive = !screenActive;
       if (!screenActive) {

package/sinain-core/src/overlay/commands.ts

@@ -15,6 +15,8 @@ export interface CommandDeps {
   onUserMessage: (text: string) => Promise<void>;
   /** Queue a user command to augment the next escalation */
   onUserCommand: (text: string) => void;
+  /** Spawn a background agent task */
+  onSpawnCommand?: (text: string) => void;
   /** Toggle screen capture — returns new state */
   onToggleScreen: () => boolean;
   /** Toggle trait voices — returns new enabled state */
@@ -44,6 +46,17 @@ export function setupCommands(deps: CommandDeps): void {
         deps.onUserCommand(msg.text);
         break;
       }
+      case "spawn_command": {
+        const preview = msg.text.length > 60 ? msg.text.slice(0, 60) + "…" : msg.text;
+        log(TAG, `spawn command received: "${preview}"`);
+        if (deps.onSpawnCommand) {
+          deps.onSpawnCommand(msg.text);
+        } else {
+          log(TAG, `spawn command ignored — no handler configured`);
+          wsHandler.broadcast(`⚠ Spawn not available (no agent gateway connected)`, "normal");
+        }
+        break;
+      }
       case "command": {
         handleCommand(msg.action, deps);
         log(TAG, `command processed: ${msg.action}`);

package/sinain-core/src/server.ts

@@ -39,6 +39,9 @@ export interface ServerDeps {
   respondEscalation?: (id: string, response: string) => any;
   getKnowledgeDocPath?: () => string | null;
   queryKnowledgeFacts?: (entities: string[], maxFacts: number) => Promise<string>;
+  onSpawnCommand?: (text: string) => void;
+  getSpawnPending?: () => { id: string; task: string; label: string; ts: number } | null;
+  respondSpawn?: (id: string, result: string) => { ok: boolean; error?: string };
 }
 
 function readBody(req: IncomingMessage, maxBytes: number): Promise<string> {
@@ -341,6 +344,45 @@ export function createAppServer(deps: ServerDeps) {
         return;
       }
 
+      // ── /spawn ──
+      if (req.method === "POST" && url.pathname === "/spawn") {
+        const body = await readBody(req, 65536);
+        const { text, label } = JSON.parse(body);
+        if (!text) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "missing text" }));
+          return;
+        }
+        if (deps.onSpawnCommand) {
+          deps.onSpawnCommand(text);
+          res.end(JSON.stringify({ ok: true, spawned: true }));
+        } else {
+          res.end(JSON.stringify({ ok: false, error: "spawn not configured" }));
+        }
+        return;
+      }
+
+      // ── /spawn/pending (bare agent polls for queued tasks) ──
+      if (req.method === "GET" && url.pathname === "/spawn/pending") {
+        const task = deps.getSpawnPending?.() ?? null;
+        res.end(JSON.stringify({ ok: true, task }));
+        return;
+      }
+
+      // ── /spawn/respond (bare agent returns task result) ──
+      if (req.method === "POST" && url.pathname === "/spawn/respond") {
+        const body = await readBody(req, 65536);
+        const { id, result } = JSON.parse(body);
+        if (!id || !result) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "missing id or result" }));
+          return;
+        }
+        const resp = deps.respondSpawn?.(id, result) ?? { ok: false, error: "spawn not configured" };
+        res.end(JSON.stringify(resp));
+        return;
+      }
+
       res.writeHead(404);
       res.end(JSON.stringify({ error: "not found" }));
     } catch (err: any) {

package/sinain-core/src/types.ts

@@ -72,8 +72,14 @@ export interface UserCommandMessage {
   text: string;
 }
 
+/** Overlay → sinain-core: spawn a background agent task */
+export interface SpawnCommandMessage {
+  type: "spawn_command";
+  text: string;
+}
+
 export type OutboundMessage = FeedMessage | StatusMessage | PingMessage | SpawnTaskMessage;
-export type InboundMessage = UserMessage | CommandMessage | PongMessage | ProfilingMessage | UserCommandMessage;
+export type InboundMessage = UserMessage | CommandMessage | PongMessage | ProfilingMessage | UserCommandMessage | SpawnCommandMessage;
 
 /** Abstraction for user commands (text now, voice later). */
 export interface UserCommand {

package/sinain-mcp-server/index.ts

@@ -152,6 +152,24 @@ server.tool(
 );
 
 // 6. sinain_post_feed
+// 6b. sinain_spawn
+server.tool(
+  "sinain_spawn",
+  "Spawn a background agent task via sinain-core",
+  {
+    task: z.string(),
+    label: z.string().optional().default("background-task"),
+  },
+  async ({ task, label }) => {
+    try {
+      const data = await coreRequest("POST", "/spawn", { text: task, label });
+      return textResult(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      return textResult(`Error spawning task: ${err.message}`);
+    }
+  },
+);
+
 server.tool(
   "sinain_post_feed",
   "Post a message to the sinain-core HUD feed",

package/sinain-core/.env.example

@@ -1,92 +0,0 @@
-# sinain-core configuration
-# Copy to .env and fill in your values:  cp .env.example .env
-
-# ── Server ──
-PORT=9500
-
-# ── System Audio ──
-# Default: ScreenCaptureKit (zero-setup, macOS 13+). Fallback: ffmpeg + BlackHole.
-AUDIO_CAPTURE_CMD=screencapturekit # screencapturekit | sox | ffmpeg
-AUDIO_DEVICE=BlackHole 2ch        # macOS audio device (only used by sox/ffmpeg)
-AUDIO_SAMPLE_RATE=16000
-AUDIO_CHUNK_MS=5000
-AUDIO_VAD_ENABLED=true
-AUDIO_VAD_THRESHOLD=0.003
-AUDIO_AUTO_START=true
-AUDIO_GAIN_DB=20
-
-# ── Microphone (opt-in for privacy) ──
-MIC_ENABLED=false                  # set true to capture user's microphone
-MIC_DEVICE=default                 # "default" = system mic. For specific device: use exact CoreAudio name
-MIC_CAPTURE_CMD=sox                # sox or ffmpeg (mic uses sox by default)
-MIC_SAMPLE_RATE=16000
-MIC_CHUNK_MS=5000
-MIC_VAD_ENABLED=true
-MIC_VAD_THRESHOLD=0.008            # higher threshold (ambient noise)
-MIC_AUTO_START=false
-MIC_GAIN_DB=0
-
-# ── Transcription ──
-OPENROUTER_API_KEY=                # required (unless TRANSCRIPTION_BACKEND=local)
-TRANSCRIPTION_BACKEND=openrouter   # openrouter | local (local = whisper.cpp on-device)
-TRANSCRIPTION_MODEL=google/gemini-2.5-flash
-TRANSCRIPTION_LANGUAGE=en-US
-
-# ── Local Transcription (only when TRANSCRIPTION_BACKEND=local) ──
-# Install: brew install whisper-cpp
-# Models:  https://huggingface.co/ggerganov/whisper.cpp/tree/main
-# LOCAL_WHISPER_BIN=whisper-cli
-# LOCAL_WHISPER_MODEL=~/models/ggml-large-v3-turbo.bin
-# LOCAL_WHISPER_TIMEOUT_MS=15000
-
-# ── Agent ──
-AGENT_ENABLED=true
-AGENT_MODEL=google/gemini-2.5-flash-lite
-# AGENT_FALLBACK_MODELS=google/gemini-2.5-flash,anthropic/claude-3.5-haiku
-AGENT_MAX_TOKENS=300
-AGENT_TEMPERATURE=0.3
-AGENT_PUSH_TO_FEED=true
-AGENT_DEBOUNCE_MS=3000
-AGENT_MAX_INTERVAL_MS=30000
-AGENT_COOLDOWN_MS=10000
-AGENT_MAX_AGE_MS=120000            # context window lookback (2 min)
-
-# ── Escalation ──
-ESCALATION_MODE=selective          # off | selective | focus | rich
-ESCALATION_COOLDOWN_MS=30000
-# ESCALATION_TRANSPORT=auto        # ws | http | auto — use http for bare agent (no gateway)
-                                   # auto = WS when gateway connected, HTTP fallback
-                                   # http = skip gateway entirely, poll via GET /escalation/pending
-                                   # See docs/INSTALL-BARE-AGENT.md for bare agent setup
-
-# ── OpenClaw / NemoClaw Gateway ─────────────────────────────────────────────
-# Run ./setup-nemoclaw.sh to fill these in interactively (recommended).
-#
-# NemoClaw (NVIDIA Brev) quick-start:
-#   1. In Brev dashboard: Expose Port(s) → enter 18789 → TCP → note the IP
-#   2. In Code-Server terminal: npx sinain   (installs plugin, prints token)
-#   3. On Mac: ./setup-nemoclaw.sh           (interactive wizard)
-#
-# URL:   ws://YOUR-IP:18789   (use the IP shown after exposing port 18789)
-# Token: printed by `npx sinain` / visible in Brev dashboard → Gateway Token
-OPENCLAW_WS_URL=ws://localhost:18789
-OPENCLAW_WS_TOKEN=                 # 48-char hex — from gateway config or `npx sinain` output
-OPENCLAW_HTTP_URL=http://localhost:18789/hooks/agent
-OPENCLAW_HTTP_TOKEN=               # same token as WS_TOKEN
-OPENCLAW_SESSION_KEY=agent:main:sinain  # MUST be agent:main:sinain — see README § Session Key
-# OPENCLAW_PHASE1_TIMEOUT_MS=10000    # Phase 1 (delivery) timeout — circuit trips on failure
-# OPENCLAW_PHASE2_TIMEOUT_MS=120000   # Phase 2 (agent response) timeout — no circuit trip
-# OPENCLAW_QUEUE_TTL_MS=300000        # Outbound queue message TTL (5 min)
-# OPENCLAW_QUEUE_MAX_SIZE=10          # Max queued escalations (oldest dropped on overflow)
-# OPENCLAW_PING_INTERVAL_MS=30000     # WS ping keepalive interval
-
-# ── SITUATION.md ──
-SITUATION_MD_PATH=~/.openclaw/workspace/SITUATION.md
-# OPENCLAW_WORKSPACE_DIR=~/.openclaw/workspace
-
-# ── Debug ──
-# DEBUG=true                       # verbose logging (every tick, every chunk)
-
-# ── Tracing ──
-TRACE_ENABLED=true
-TRACE_DIR=~/.sinain-core/traces