@geravant/sinain 1.6.6 → 1.6.7

package/cli.js

@@ -7,6 +7,9 @@ import path from "path";
 
 const cmd = process.argv[2];
 const IS_WINDOWS = os.platform() === "win32";
+const HOME = os.homedir();
+const SINAIN_DIR = path.join(HOME, ".sinain");
+const PKG_DIR = path.dirname(new URL(import.meta.url).pathname);
 
 switch (cmd) {
   case "start":
@@ -52,6 +55,14 @@ switch (cmd) {
     await import("./install.js");
     break;
 
+  case "export-knowledge":
+    await exportKnowledge();
+    break;
+
+  case "import-knowledge":
+    await importKnowledge();
+    break;
+
   default:
     printUsage();
     break;
@@ -349,6 +360,152 @@ function isProcessRunning(pattern) {
   }
 }
 
+// ── Knowledge export/import ──────────────────────────────────────────────────
+
+function findWorkspace() {
+  const candidates = [
+    process.env.SINAIN_WORKSPACE,
+    path.join(HOME, ".openclaw/workspace"),
+    path.join(HOME, ".sinain/workspace"),
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    const resolved = dir.replace(/^~/, HOME);
+    if (fs.existsSync(resolved)) return resolved;
+  }
+  return null;
+}
+
+async function exportKnowledge() {
+  const BOLD = "\x1b[1m", GREEN = "\x1b[32m", RED = "\x1b[31m", DIM = "\x1b[2m", RESET = "\x1b[0m";
+
+  const workspace = findWorkspace();
+  if (!workspace) {
+    console.error(`${RED}✗${RESET} No knowledge workspace found.`);
+    console.error(`  Checked: SINAIN_WORKSPACE env, ~/.openclaw/workspace, ~/.sinain/workspace`);
+    process.exit(1);
+  }
+
+  const outputIdx = process.argv.indexOf("--output");
+  const outputPath = outputIdx !== -1 && process.argv[outputIdx + 1]
+    ? path.resolve(process.argv[outputIdx + 1])
+    : path.join(HOME, "sinain-knowledge-export.tar.gz");
+
+  // Collect files that exist
+  const includes = [];
+  const check = (rel) => {
+    const full = path.join(workspace, rel);
+    if (fs.existsSync(full)) { includes.push(rel); return true; }
+    return false;
+  };
+
+  check("modules");
+  check("memory/sinain-playbook.md");
+  check("memory/knowledge-graph.db");
+  check("memory/playbook-base.md");
+  check("memory/playbook.md");
+  check("memory/sinain-knowledge.md");
+
+  if (includes.length === 0) {
+    console.error(`${RED}✗${RESET} No knowledge files found in ${workspace}`);
+    process.exit(1);
+  }
+
+  console.log(`${BOLD}[export]${RESET} Exporting from ${DIM}${workspace}${RESET}`);
+  for (const inc of includes) {
+    console.log(`  ${GREEN}+${RESET} ${inc}`);
+  }
+
+  try {
+    execSync(
+      `tar czf "${outputPath}" --exclude="memory/triplestore.db" ${includes.map(i => `"${i}"`).join(" ")}`,
+      { cwd: workspace, stdio: "pipe" }
+    );
+  } catch (e) {
+    console.error(`${RED}✗${RESET} tar failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  const size = fs.statSync(outputPath).size;
+  const sizeStr = size < 1024 * 1024
+    ? `${(size / 1024).toFixed(1)} KB`
+    : `${(size / (1024 * 1024)).toFixed(1)} MB`;
+
+  console.log(`\n${GREEN}✓${RESET} Exported to ${BOLD}${outputPath}${RESET} (${sizeStr})`);
+  console.log(`  Transfer to another machine and run: ${BOLD}sinain import-knowledge ${path.basename(outputPath)}${RESET}`);
+}
+
+async function importKnowledge() {
+  const BOLD = "\x1b[1m", GREEN = "\x1b[32m", RED = "\x1b[31m", YELLOW = "\x1b[33m", DIM = "\x1b[2m", RESET = "\x1b[0m";
+
+  const filePath = process.argv[3];
+  if (!filePath) {
+    console.error(`${RED}✗${RESET} Usage: sinain import-knowledge <file.tar.gz>`);
+    process.exit(1);
+  }
+
+  const resolved = path.resolve(filePath.replace(/^~/, HOME));
+  if (!fs.existsSync(resolved)) {
+    console.error(`${RED}✗${RESET} File not found: ${resolved}`);
+    process.exit(1);
+  }
+
+  const targetWorkspace = path.join(HOME, ".sinain/workspace");
+  fs.mkdirSync(targetWorkspace, { recursive: true });
+
+  console.log(`${BOLD}[import]${RESET} Importing to ${DIM}${targetWorkspace}${RESET}`);
+
+  // Extract
+  try {
+    execSync(`tar xzf "${resolved}" -C "${targetWorkspace}"`, { stdio: "inherit" });
+  } catch (e) {
+    console.error(`${RED}✗${RESET} Extraction failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  // Symlink sinain-memory scripts from npm package
+  const srcMemory = path.join(PKG_DIR, "sinain-memory");
+  const dstMemory = path.join(targetWorkspace, "sinain-memory");
+  if (fs.existsSync(srcMemory)) {
+    try { fs.rmSync(dstMemory, { recursive: true, force: true }); } catch {}
+    fs.symlinkSync(srcMemory, dstMemory, IS_WINDOWS ? "junction" : undefined);
+    console.log(`  ${GREEN}✓${RESET} sinain-memory scripts linked`);
+  }
+
+  // Update ~/.sinain/.env
+  const envPath = path.join(SINAIN_DIR, ".env");
+  const envVars = {
+    SINAIN_WORKSPACE: targetWorkspace,
+    OPENCLAW_WORKSPACE_DIR: targetWorkspace,
+  };
+
+  if (fs.existsSync(envPath)) {
+    let content = fs.readFileSync(envPath, "utf-8");
+    for (const [key, val] of Object.entries(envVars)) {
+      const regex = new RegExp(`^#?\\s*${key}=.*$`, "m");
+      if (regex.test(content)) {
+        content = content.replace(regex, `${key}=${val}`);
+      } else {
+        content += `\n${key}=${val}`;
+      }
+    }
+    fs.writeFileSync(envPath, content);
+  } else {
+    fs.mkdirSync(SINAIN_DIR, { recursive: true });
+    const lines = Object.entries(envVars).map(([k, v]) => `${k}=${v}`);
+    fs.writeFileSync(envPath, lines.join("\n") + "\n");
+  }
+  console.log(`  ${GREEN}✓${RESET} SINAIN_WORKSPACE set in ${DIM}~/.sinain/.env${RESET}`);
+
+  // Summary
+  const items = [];
+  if (fs.existsSync(path.join(targetWorkspace, "modules"))) items.push("modules");
+  if (fs.existsSync(path.join(targetWorkspace, "memory/sinain-playbook.md"))) items.push("playbook");
+  if (fs.existsSync(path.join(targetWorkspace, "memory/knowledge-graph.db"))) items.push("knowledge graph");
+
+  console.log(`\n${GREEN}✓${RESET} Knowledge imported: ${items.join(", ")}`);
+  console.log(`  Workspace: ${BOLD}${targetWorkspace}${RESET}`);
+}
+
 // ── Usage ─────────────────────────────────────────────────────────────────────
 
 function printUsage() {
@@ -362,6 +519,8 @@ Usage:
   sinain setup                 Run interactive setup wizard (~/.sinain/.env)
   sinain setup-overlay         Download pre-built overlay app
   sinain setup-sck-capture     Download sck-capture audio binary (macOS)
+  sinain export-knowledge      Export knowledge for transfer to another machine
+  sinain import-knowledge <file>  Import knowledge from export file
   sinain install               Install OpenClaw plugin (server-side)
 
 Start options:

package/launcher.js

@@ -35,13 +35,11 @@ let skipSense = false;
 let skipOverlay = false;
 let skipAgent = false;
 let agentName = null;
-let forceSetup = false;
 
 for (const arg of args) {
   if (arg === "--no-sense")   { skipSense = true; continue; }
   if (arg === "--no-overlay") { skipOverlay = true; continue; }
   if (arg === "--no-agent")   { skipAgent = true; continue; }
-  if (arg === "--setup")      { forceSetup = true; continue; }
   if (arg.startsWith("--agent=")) { agentName = arg.split("=")[1]; continue; }
   console.error(`Unknown flag: ${arg}`);
   process.exit(1);
@@ -62,20 +60,15 @@ async function main() {
   await preflight();
   console.log();
 
-  // Run setup wizard on first launch (no ~/.sinain/.env) or when --setup flag is passed
+  // Run setup wizard on first launch (no ~/.sinain/.env)
   const userEnvPath = path.join(SINAIN_DIR, ".env");
-  if (forceSetup || !fs.existsSync(userEnvPath)) {
+  if (!fs.existsSync(userEnvPath)) {
     await setupWizard(userEnvPath);
   }
 
   // Load user config
   loadUserEnv();
 
-  // Ensure Ollama is running (if local vision enabled)
-  if (process.env.LOCAL_VISION_ENABLED === "true") {
-    await ensureOllama();
-  }
-
   // Auto-detect transcription backend
   detectTranscription();
 
@@ -134,10 +127,7 @@ async function main() {
         const scDir = path.join(PKG_DIR, "sense_client");
         // Check if key package is importable to skip pip
         try {
-          const depCheck = IS_WINDOWS
-            ? 'python3 -c "import PIL; import skimage"'
-            : 'python3 -c "import PIL; import skimage; import Quartz; import Vision"';
-          execSync(depCheck, { stdio: "pipe" });
+          execSync('python3 -c "import PIL; import skimage"', { stdio: "pipe" });
         } catch {
           log("Installing sense_client Python dependencies...");
           try {
@@ -223,41 +213,7 @@ async function main() {
         warn("flutter not found — overlay source found but can't build");
       }
     } else {
-      // Auto-download overlay if not found
-      log("overlay not found — downloading from GitHub Releases...");
-      try {
-        const { downloadOverlay } = await import("./setup-overlay.js");
-        const success = await downloadOverlay({ silent: false });
-        if (success) {
-          // Re-find and launch the freshly downloaded overlay
-          const freshOverlay = findOverlay();
-          if (freshOverlay?.type === "prebuilt") {
-            if (!IS_WINDOWS) {
-              try {
-                execSync(`xattr -cr "${freshOverlay.path}"`, { stdio: "pipe" });
-              } catch { /* no quarantine */ }
-            }
-            log("Starting overlay (pre-built)...");
-            const binary = IS_WINDOWS
-              ? freshOverlay.path
-              : path.join(freshOverlay.path, "Contents/MacOS/sinain_hud");
-            startProcess("overlay", binary, [], { color: MAGENTA });
-            await sleep(2000);
-            const overlayChild = children.find(c => c.name === "overlay");
-            if (overlayChild && !overlayChild.proc.killed && overlayChild.proc.exitCode === null) {
-              ok(`overlay running (pid:${overlayChild.pid})`);
-              overlayStatus = "running";
-            } else {
-              warn("overlay exited early — check logs above");
-              overlayStatus = "failed";
-            }
-          }
-        } else {
-          warn("overlay auto-download failed — run: sinain setup-overlay");
-        }
-      } catch (e) {
-        warn(`overlay auto-download failed: ${e.message}`);
-      }
+      warn("overlay not found — run: sinain setup-overlay");
     }
   }
 
@@ -353,38 +309,25 @@ async function preflight() {
     ok("port 9500 free");
   }
 
-}
-
-async function ensureOllama() {
-  try {
-    const resp = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(2000) });
-    if (resp.ok) {
-      ok("ollama server running");
-      return true;
-    }
-  } catch { /* not running */ }
-
-  // Try to start Ollama in background
-  log("Starting ollama server...");
-  try {
-    const { spawn: spawnProc } = await import("child_process");
-    spawnProc("ollama", ["serve"], { detached: true, stdio: "ignore" }).unref();
-    // Wait for it to become ready
-    for (let i = 0; i < 10; i++) {
-      await sleep(500);
+  // Ollama (if local vision enabled)
+  if (process.env.LOCAL_VISION_ENABLED === "true") {
+    try {
+      const resp = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(2000) });
+      if (resp.ok) {
+        ok("ollama server running");
+      } else {
+        warn("ollama server not responding — local vision will be unavailable");
+      }
+    } catch {
+      // Try to start Ollama in background
       try {
-        const resp = await fetch("http://localhost:11434/api/tags", { signal: AbortSignal.timeout(1000) });
-        if (resp.ok) {
-          ok("ollama server started");
-          return true;
-        }
-      } catch { /* not ready yet */ }
+        const { spawn: spawnProc } = await import("child_process");
+        spawnProc("ollama", ["serve"], { detached: true, stdio: "ignore" }).unref();
+        ok("ollama server started in background");
+      } catch {
+        warn("ollama not running and could not auto-start — local vision disabled");
+      }
     }
-    warn("ollama started but not responding — local vision may not work");
-    return false;
-  } catch {
-    warn("ollama not found — local vision disabled. Install: brew install ollama");
-    return false;
   }
 }
 
@@ -394,20 +337,9 @@ async function setupWizard(envPath) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
 
-  // Load existing .env values as defaults (for re-configuration)
-  const existing = {};
-  if (fs.existsSync(envPath)) {
-    for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
-      const m = line.match(/^([A-Z_]+)=(.*)$/);
-      if (m) existing[m[1]] = m[2];
-    }
-  }
-  const hasExisting = Object.keys(existing).length > 0;
-
   console.log();
-  console.log(`${BOLD}── ${hasExisting ? "Re-configure" : "First-time setup"} ────────────────────${RESET}`);
+  console.log(`${BOLD}── First-time setup ────────────────────${RESET}`);
   console.log(`  Configuring ${DIM}~/.sinain/.env${RESET}`);
-  if (hasExisting) console.log(`  ${DIM}Press Enter to keep current values shown in [brackets]${RESET}`);
   console.log();
 
   const vars = {};
@@ -459,13 +391,10 @@ async function setupWizard(envPath) {
 
   // 2. OpenRouter API key (if cloud backend or for vision/OCR)
   if (transcriptionBackend === "openrouter") {
-    const existingKey = existing.OPENROUTER_API_KEY;
-    const keyHint = existingKey ? ` [${existingKey.slice(0, 8)}...${existingKey.slice(-4)}]` : "";
     let key = "";
     while (!key) {
-      key = await ask(`  OpenRouter API key (sk-or-...)${keyHint}: `);
+      key = await ask(`  OpenRouter API key (sk-or-...): `);
       key = key.trim();
-      if (!key && existingKey) { key = existingKey; break; }
       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]: `);
@@ -479,17 +408,13 @@ async function setupWizard(envPath) {
     if (key) vars.OPENROUTER_API_KEY = key;
   } else {
     // Still ask for OpenRouter key (needed for vision/OCR)
-    const existingKey = existing.OPENROUTER_API_KEY;
-    const keyHint = existingKey ? ` [${existingKey.slice(0, 8)}...${existingKey.slice(-4)}]` : "";
-    const key = await ask(`  OpenRouter API key for vision/OCR (optional, Enter to skip)${keyHint}: `);
+    const key = await ask(`  OpenRouter API key for vision/OCR (optional, Enter to skip): `);
     if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
-    else if (existingKey) vars.OPENROUTER_API_KEY = existingKey;
   }
 
   // 3. Agent selection
-  const defaultAgent = existing.SINAIN_AGENT || "claude";
-  const agentChoice = await ask(`  Agent? [${BOLD}${defaultAgent}${RESET}/claude/codex/goose/junie/aider]: `);
-  vars.SINAIN_AGENT = agentChoice.trim().toLowerCase() || defaultAgent;
+  const agentChoice = await ask(`  Agent? [${BOLD}claude${RESET}/codex/goose/junie/aider]: `);
+  vars.SINAIN_AGENT = agentChoice.trim().toLowerCase() || "claude";
 
   // 3b. Local vision (Ollama)
   const IS_MACOS = os.platform() === "darwin";
@@ -498,24 +423,20 @@ async function setupWizard(envPath) {
     const useVision = await ask(`  Enable local vision AI? [Y/n] (Ollama — screen understanding without cloud API): `);
     if (!useVision.trim() || useVision.trim().toLowerCase() === "y") {
       vars.LOCAL_VISION_ENABLED = "true";
-      // Ensure ollama serve is running before list/pull
-      const ollamaReady = await ensureOllama();
-      if (ollamaReady) {
-        try {
-          const models = execSync("ollama list 2>/dev/null", { encoding: "utf-8" });
-          if (!models.includes("llava")) {
-            const pull = await ask(`  Pull llava vision model (~4GB)? [Y/n]: `);
-            if (!pull.trim() || pull.trim().toLowerCase() === "y") {
-              console.log(`  ${DIM}Pulling llava...${RESET}`);
-              execSync("ollama pull llava", { stdio: "inherit" });
-              ok("llava model pulled");
-            }
-          } else {
-            ok("llava model already available");
+      try {
+        const models = execSync("ollama list 2>/dev/null", { encoding: "utf-8" });
+        if (!models.includes("llava")) {
+          const pull = await ask(`  Pull llava vision model (~4GB)? [Y/n]: `);
+          if (!pull.trim() || pull.trim().toLowerCase() === "y") {
+            console.log(`  ${DIM}Pulling llava...${RESET}`);
+            execSync("ollama pull llava", { stdio: "inherit" });
+            ok("llava model pulled");
           }
-        } catch {
-          warn("Could not check Ollama models");
+        } else {
+          ok("llava model already available");
         }
+      } catch {
+        warn("Could not check Ollama models");
       }
       vars.LOCAL_VISION_MODEL = "llava";
     }
@@ -530,8 +451,6 @@ async function setupWizard(envPath) {
           console.log(`  ${DIM}Installing Ollama...${RESET}`);
           execSync("curl -fsSL https://ollama.com/install.sh | sh", { stdio: "inherit" });
         }
-        // Start ollama serve before pulling
-        await ensureOllama();
         console.log(`  ${DIM}Pulling llava vision model...${RESET}`);
         execSync("ollama pull llava", { stdio: "inherit" });
         vars.LOCAL_VISION_ENABLED = "true";
@@ -550,44 +469,59 @@ async function setupWizard(envPath) {
   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 defaultEsc = existing.ESCALATION_MODE || "selective";
-  const escMode = await ask(`  Escalation mode? [off/${BOLD}${defaultEsc}${RESET}/selective/focus/rich]: `);
-  vars.ESCALATION_MODE = escMode.trim().toLowerCase() || defaultEsc;
+  const escMode = await ask(`  Escalation mode? [off/${BOLD}selective${RESET}/focus/rich]: `);
+  vars.ESCALATION_MODE = escMode.trim().toLowerCase() || "selective";
 
   // 5. OpenClaw gateway
-  const hadGateway = !!(existing.OPENCLAW_WS_URL);
-  const gatewayDefault = hadGateway ? "Y" : "N";
-  const hasGateway = await ask(`  Do you have an OpenClaw gateway? [${gatewayDefault === "Y" ? "Y/n" : "y/N"}]: `);
-  const wantsGateway = hasGateway.trim()
-    ? hasGateway.trim().toLowerCase() === "y"
-    : hadGateway;
-  if (wantsGateway) {
-    const defaultWs = existing.OPENCLAW_WS_URL || "ws://localhost:18789";
-    const wsUrl = await ask(`  Gateway WebSocket URL [${defaultWs}]: `);
-    vars.OPENCLAW_WS_URL = wsUrl.trim() || defaultWs;
-
-    const existingToken = existing.OPENCLAW_WS_TOKEN;
-    const tokenHint = existingToken ? ` [${existingToken.slice(0, 6)}...${existingToken.slice(-4)}]` : "";
-    const wsToken = await ask(`  Gateway auth token (48-char hex)${tokenHint}: `);
+  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();
-    } else if (existingToken) {
-      vars.OPENCLAW_WS_TOKEN = existingToken;
-      vars.OPENCLAW_HTTP_TOKEN = existing.OPENCLAW_HTTP_TOKEN || existingToken;
     }
 
     // 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 = existing.OPENCLAW_SESSION_KEY || "agent:main:sinain";
+    vars.OPENCLAW_SESSION_KEY = "agent:main:sinain";
   } else {
     // No gateway — disable WS connection attempts
     vars.OPENCLAW_WS_URL = "";
     vars.OPENCLAW_HTTP_URL = "";
   }
 
-  // 6. Agent-specific defaults
+  // 6. Knowledge import (for standalone machines)
+  console.log();
+  const wantImport = await ask(`  Import knowledge from another machine? [y/N]: `);
+  if (wantImport.trim().toLowerCase() === "y") {
+    const filePath = await ask(`  Path to knowledge export (.tar.gz): `);
+    const resolved = filePath.trim().replace(/^~/, HOME);
+    if (resolved && fs.existsSync(resolved)) {
+      const targetWorkspace = path.join(HOME, ".sinain/workspace");
+      fs.mkdirSync(targetWorkspace, { recursive: true });
+      try {
+        execSync(`tar xzf "${resolved}" -C "${targetWorkspace}"`, { stdio: "inherit" });
+        // Symlink sinain-memory scripts from npm package
+        const srcMemory = path.join(PKG_DIR, "sinain-memory");
+        const dstMemory = path.join(targetWorkspace, "sinain-memory");
+        try { fs.rmSync(dstMemory, { recursive: true }); } catch {}
+        fs.symlinkSync(srcMemory, dstMemory);
+        vars.SINAIN_WORKSPACE = targetWorkspace;
+        vars.OPENCLAW_WORKSPACE_DIR = targetWorkspace;
+        ok(`Knowledge imported to ${targetWorkspace}`);
+      } catch (e) {
+        warn(`Import failed: ${e.message}`);
+      }
+    } else if (resolved) {
+      warn(`File not found: ${resolved}`);
+    }
+  }
+
+  // 7. Agent-specific defaults
   vars.SINAIN_POLL_INTERVAL = "5";
   vars.SINAIN_HEARTBEAT_INTERVAL = "900";
   vars.PRIVACY_MODE = "standard";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "description": "Ambient AI overlay invisible to screen capture — real-time insights from audio + screen context",
   "type": "module",
   "bin": {

package/sense_client/__main__.py

@@ -12,7 +12,6 @@ if sys.platform == "win32":
 
 import argparse
 import concurrent.futures
-import copy
 import json
 import os
 import time
@@ -29,7 +28,7 @@ from .capture import ScreenCapture, create_capture
 from .change_detector import ChangeDetector
 from .roi_extractor import ROIExtractor
 from .ocr import OCRResult, create_ocr
-from .gate import DecisionGate, SenseEvent, SenseObservation, SenseMeta
+from .gate import DecisionGate, SenseObservation
 from .sender import SenseSender, package_full_frame, package_roi
 from .app_detector import AppDetector
 from .config import load_config
@@ -129,7 +128,6 @@ def main():
     )
     app_detector = AppDetector()
     ocr_pool = concurrent.futures.ThreadPoolExecutor(max_workers=4)
-    vision_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1, thread_name_prefix="vision")
 
     # Vision provider — routes to Ollama (local) or OpenRouter (cloud) based on config/privacy
     vision_cfg = config.get("vision", {})
@@ -357,28 +355,18 @@ def main():
             title=title, subtitle=subtitle, facts=facts,
         )
 
-        # Vision scene analysis — async: send text event immediately, vision follows
+        # Vision scene analysis (throttled, non-blocking on failure)
         if vision_provider and time.time() - last_vision_time >= vision_throttle_s:
-            last_vision_time = time.time()  # claim slot immediately to prevent concurrent calls
-            _v_frame = use_frame.copy() if isinstance(use_frame, np.ndarray) else use_frame.copy()
-            _v_meta = copy.copy(event.meta)
-            _v_ts = event.ts
-            _v_prompt = vision_prompt
-            def _do_vision(frame, meta, ts, prompt):
-                try:
-                    from PIL import Image as PILImage
-                    pil = PILImage.fromarray(frame) if isinstance(frame, np.ndarray) else frame
-                    scene = vision_provider.describe(pil, prompt=prompt or None)
-                    if scene:
-                        log(f"vision: {scene[:80]}...")
-                        ctx_ev = SenseEvent(type="context", ts=ts)
-                        ctx_ev.observation = SenseObservation(scene=scene)
-                        ctx_ev.meta = meta
-                        ctx_ev.roi = package_full_frame(frame)
-                        sender.send(ctx_ev)
-                except Exception as e:
-                    log(f"vision error: {e}")
-            vision_pool.submit(_do_vision, _v_frame, _v_meta, _v_ts, _v_prompt)
+            try:
+                from PIL import Image as PILImage
+                pil_frame = PILImage.fromarray(use_frame) if isinstance(use_frame, np.ndarray) else use_frame
+                scene = vision_provider.describe(pil_frame, prompt=vision_prompt or None)
+                if scene:
+                    event.observation.scene = scene
+                    last_vision_time = time.time()
+                    log(f"vision: {scene[:80]}...")
+            except Exception as e:
+                log(f"vision error: {e}")
 
         # Send small thumbnail for ALL event types (agent uses vision)
         # Privacy matrix: gate image sending based on PRIVACY_IMAGES_OPENROUTER

package/sense_client/requirements.txt

@@ -4,7 +4,6 @@ numpy>=1.24
 pytesseract>=0.3
 requests>=2.31
 pyobjc-framework-Quartz>=10.0; sys_platform == "darwin"
-pyobjc-framework-Vision>=10.0; sys_platform == "darwin"
 mss>=9.0; sys_platform == "win32"
 psutil>=5.9; sys_platform == "win32"
 winrt-Windows.Media.Ocr>=2.0; sys_platform == "win32"

package/setup-overlay.js

@@ -37,36 +37,25 @@ function ok(msg)   { console.log(`${BOLD}[setup-overlay]${RESET} ${GREEN}✓${RE
 function warn(msg) { console.log(`${BOLD}[setup-overlay]${RESET} ${YELLOW}⚠${RESET} ${msg}`); }
 function fail(msg) { console.error(`${BOLD}[setup-overlay]${RESET} ${RED}✗${RESET} ${msg}`); process.exit(1); }
 
-// ── Entry point (only when run directly, not when imported) ──────────────────
+// ── Parse flags ──────────────────────────────────────────────────────────────
 
-const isMain = process.argv[1] && (
-  import.meta.url === `file://${process.argv[1]}` ||
-  import.meta.url === new URL(process.argv[1], "file://").href
-);
+const args = process.argv.slice(2);
+const fromSource = args.includes("--from-source");
+const forceUpdate = args.includes("--update");
 
-if (isMain) {
-  const args = process.argv.slice(2);
-  const fromSource = args.includes("--from-source");
-  const forceUpdate = args.includes("--update");
-
-  if (fromSource) {
-    await buildFromSource();
-  } else {
-    await downloadOverlay({ forceUpdate });
-  }
+if (fromSource) {
+  await buildFromSource();
+} else {
+  await downloadPrebuilt();
 }
 
 // ── Download pre-built .app ──────────────────────────────────────────────────
 
-export async function downloadOverlay({ silent = false, forceUpdate = false } = {}) {
-  const _log = silent ? () => {} : log;
-  const _ok = silent ? () => {} : ok;
-  const _warn = silent ? () => {} : warn;
-
+async function downloadPrebuilt() {
   fs.mkdirSync(APP_DIR, { recursive: true });
 
   // Find latest overlay release
-  _log("Checking for latest overlay release...");
+  log("Checking for latest overlay release...");
   let release;
   try {
     const res = await fetch(`${RELEASES_API}?per_page=20`, {
@@ -78,7 +67,6 @@ export async function downloadOverlay({ silent = false, forceUpdate = false } =
     release = releases.find(r => r.tag_name?.startsWith("overlay-v"));
     if (!release) throw new Error("No overlay release found");
   } catch (e) {
-    if (silent) return false;
     fail(`Failed to fetch releases: ${e.message}\n  Try: sinain setup-overlay --from-source`);
   }
 
@@ -90,22 +78,21 @@ export async function downloadOverlay({ silent = false, forceUpdate = false } =
     try {
       const local = JSON.parse(fs.readFileSync(VERSION_FILE, "utf-8"));
       if (local.tag === tag) {
-        _ok(`Overlay already up-to-date (${version})`);
-        return true;
+        ok(`Overlay already up-to-date (${version})`);
+        return;
       }
-      _log(`Updating: ${local.tag} → ${tag}`);
+      log(`Updating: ${local.tag} → ${tag}`);
     } catch { /* corrupt version file — re-download */ }
   }
 
   // Find the .zip asset for this platform
   const zipAsset = release.assets?.find(a => a.name === ASSET_NAME);
   if (!zipAsset) {
-    if (silent) return false;
     fail(`Release ${tag} has no ${ASSET_NAME} asset.\n  Try: sinain setup-overlay --from-source`);
   }
 
   // Download with progress
-  _log(`Downloading overlay ${version} for ${IS_WINDOWS ? "Windows" : "macOS"} (${formatBytes(zipAsset.size)})...`);
+  log(`Downloading overlay ${version} for ${IS_WINDOWS ? "Windows" : "macOS"} (${formatBytes(zipAsset.size)})...`);
   const zipPath = path.join(APP_DIR, ASSET_NAME);
 
   try {
@@ -125,18 +112,17 @@ export async function downloadOverlay({ silent = false, forceUpdate = false } =
       if (done) break;
       chunks.push(value);
       downloaded += value.length;
-      if (total > 0 && !silent) {
+      if (total > 0) {
         const pct = Math.round((downloaded / total) * 100);
         process.stdout.write(`\r${BOLD}[setup-overlay]${RESET} ${DIM}${pct}% (${formatBytes(downloaded)} / ${formatBytes(total)})${RESET}`);
       }
     }
-    if (!silent) process.stdout.write("\n");
+    process.stdout.write("\n");
 
     const buffer = Buffer.concat(chunks);
     fs.writeFileSync(zipPath, buffer);
-    _ok(`Downloaded ${formatBytes(buffer.length)}`);
+    ok(`Downloaded ${formatBytes(buffer.length)}`);
   } catch (e) {
-    if (silent) return false;
     fail(`Download failed: ${e.message}`);
   }
 
@@ -146,7 +132,7 @@ export async function downloadOverlay({ silent = false, forceUpdate = false } =
   }
 
   // Extract
-  _log("Extracting...");
+  log("Extracting...");
   if (IS_WINDOWS) {
     try {
       execSync(
@@ -154,7 +140,6 @@ export async function downloadOverlay({ silent = false, forceUpdate = false } =
         { stdio: "pipe" }
       );
     } catch (e) {
-      if (silent) return false;
       fail(`Extraction failed: ${e.message}`);
     }
   } else {
@@ -165,7 +150,6 @@ export async function downloadOverlay({ silent = false, forceUpdate = false } =
       try {
         execSync(`unzip -o -q "${zipPath}" -d "${APP_DIR}"`, { stdio: "pipe" });
       } catch (e) {
-        if (silent) return false;
         fail(`Extraction failed: ${e.message}`);
       }
     }
@@ -186,15 +170,12 @@ export async function downloadOverlay({ silent = false, forceUpdate = false } =
   // Clean up zip
   fs.unlinkSync(zipPath);
 
-  _ok(`Overlay ${version} installed`);
-  if (!silent) {
-    console.log(`
+  ok(`Overlay ${version} installed`);
+  console.log(`
 ${GREEN}✓${RESET} Overlay ready!
   Location: ${APP_PATH}
   The overlay will auto-start with: ${BOLD}sinain start${RESET}
 `);
-  }
-  return true;
 }
 
 // ── Build from source (legacy) ───────────────────────────────────────────────

package/sinain-core/src/agent/loop.ts

@@ -1,10 +1,9 @@
 import { EventEmitter } from "node:events";
-import fs from "node:fs";
 import type { FeedBuffer } from "../buffers/feed-buffer.js";
 import type { SenseBuffer } from "../buffers/sense-buffer.js";
-import type { AgentConfig, AgentEntry, ContextWindow, EscalationMode, ContextRichness, RecorderStatus, SenseEvent, FeedbackRecord } from "../types.js";
+import type { AgentConfig, AgentEntry, ContextWindow, EscalationMode, ContextRichness, RecorderStatus } from "../types.js";
 import type { Profiler } from "../profiler.js";
-import { buildContextWindow, RICHNESS_PRESETS } from "./context-window.js";
+import { buildContextWindow } from "./context-window.js";
 import { analyzeContext } from "./analyzer.js";
 import { writeSituationMd } from "./situation-writer.js";
 import { calculateEscalationScore } from "../escalation/scorer.js";
@@ -36,10 +35,6 @@ export interface AgentLoopDeps {
   traitEngine?: TraitEngine;
   /** Directory to write per-day trait log JSONL files. */
   traitLogDir?: string;
-  /** Optional: path to sinain-knowledge.md for startup recap. */
-  getKnowledgeDocPath?: () => string | null;
-  /** Optional: feedback store for startup recap context. */
-  feedbackStore?: { queryRecent(n: number): FeedbackRecord[] };
 }
 
 export interface TraceContext {
@@ -74,7 +69,6 @@ export class AgentLoop extends EventEmitter {
   private lastRunTs = 0;
   private running = false;
   private started = false;
-  private firstTick = true;
 
   private lastPushedHud = "";
   private agentNextId = 1;
@@ -118,9 +112,6 @@ export class AgentLoop extends EventEmitter {
     }, this.deps.agentConfig.maxIntervalMs);
 
     log(TAG, `loop started (debounce=${this.deps.agentConfig.debounceMs}ms, max=${this.deps.agentConfig.maxIntervalMs}ms, cooldown=${this.deps.agentConfig.cooldownMs}ms, model=${this.deps.agentConfig.model})`);
-
-    // Fire recap tick: immediate HUD from persistent knowledge (no sense data needed)
-    this.fireRecapTick().catch(e => debug(TAG, "recap skipped:", String(e)));
   }
 
   /** Stop the agent loop. */
@@ -140,13 +131,12 @@ export class AgentLoop extends EventEmitter {
   onNewContext(): void {
     if (!this.started) return;
 
-    // Fast first tick: 500ms debounce on startup, normal debounce after
-    const delay = this.firstTick ? 500 : this.deps.agentConfig.debounceMs;
+    // Debounce: wait N ms after last event before running
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
     this.debounceTimer = setTimeout(() => {
       this.debounceTimer = null;
       this.run().catch(err => error(TAG, "debounce tick error:", err.message));
-    }, delay);
+    }, this.deps.agentConfig.debounceMs);
   }
 
   /** Get agent results history (newest first). */
@@ -408,80 +398,7 @@ export class AgentLoop extends EventEmitter {
       traceCtx?.finish({ totalLatencyMs: Date.now() - Date.now(), llmLatencyMs: 0, llmInputTokens: 0, llmOutputTokens: 0, llmCost: 0, escalated: false, escalationScore: 0, contextScreenEvents: 0, contextAudioEntries: 0, contextRichness: richness, digestLength: 0, hudChanged: false });
     } finally {
       this.running = false;
-      this.firstTick = false;
       this.lastRunTs = Date.now();
     }
   }
-
-  // ── Private: startup recap tick from persistent knowledge ──
-
-  private async fireRecapTick(): Promise<void> {
-    if (this.running) return;
-    this.running = true;
-
-    try {
-      const sections: string[] = [];
-      const startTs = Date.now();
-
-      // 1. sinain-knowledge.md (established patterns, user preferences)
-      const knowledgePath = this.deps.getKnowledgeDocPath?.();
-      if (knowledgePath) {
-        const content = await fs.promises.readFile(knowledgePath, "utf-8").catch(() => "");
-        if (content.length > 50) sections.push(content.slice(0, 2000));
-      }
-
-      // 2. SITUATION.md digest (if fresh — less than 5 minutes old)
-      try {
-        const stat = await fs.promises.stat(this.deps.situationMdPath);
-        if (Date.now() - stat.mtimeMs < 5 * 60_000) {
-          const sit = await fs.promises.readFile(this.deps.situationMdPath, "utf-8");
-          const digestMatch = sit.match(/## Digest\n([\s\S]*?)(?=\n##|$)/);
-          if (digestMatch?.[1]?.trim()) {
-            sections.push(`Last session digest:\n${digestMatch[1].trim()}`);
-          }
-        }
-      } catch { /* SITUATION.md missing — fine */ }
-
-      // 3. Recent feedback records (last 5 escalation summaries)
-      const records = this.deps.feedbackStore?.queryRecent(5) ?? [];
-      if (records.length > 0) {
-        const recaps = records.slice(0, 5).map(r => `- ${r.currentApp}: ${r.hud}`).join("\n");
-        sections.push(`Recent activity:\n${recaps}`);
-      }
-
-      if (sections.length === 0) { return; }
-
-      const recapContext = sections.join("\n\n");
-
-      // Build synthetic ContextWindow with knowledge as screen entry
-      const recapWindow: ContextWindow = {
-        audio: [],
-        screen: [{
-          ts: Date.now(),
-          ocr: recapContext,
-          meta: { app: "sinain-recap", windowTitle: "startup" },
-          type: "context",
-        } as unknown as SenseEvent],
-        images: [],
-        currentApp: "sinain-recap",
-        appHistory: [],
-        audioCount: 0,
-        screenCount: 1,
-        windowMs: 0,
-        newestEventTs: Date.now(),
-        preset: RICHNESS_PRESETS.lean,
-      };
-
-      const result = await analyzeContext(recapWindow, this.deps.agentConfig, null);
-      if (result?.hud && result.hud !== "—" && result.hud !== "Idle") {
-        this.deps.onHudUpdate(result.hud);
-        log(TAG, `recap tick (${Date.now() - startTs}ms, ${result.tokensIn}in+${result.tokensOut}out tok) hud="${result.hud}"`);
-      }
-    } catch (err: any) {
-      debug(TAG, "recap tick error:", err.message || err);
-    } finally {
-      this.running = false;
-      // Do NOT update lastRunTs — normal cooldown should not be affected by recap
-    }
-  }
 }

package/sinain-core/src/index.ts

@@ -25,12 +25,6 @@ import { initPrivacy, levelFor, applyLevel } from "./privacy/index.js";
 
 const TAG = "core";
 
-/** Resolve workspace path, expanding leading ~ to HOME. */
-function resolveWorkspace(): string {
-  const raw = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
-  return raw.startsWith("~") ? raw.replace("~", process.env.HOME || "") : raw;
-}
-
 async function main() {
   log(TAG, "sinain-core starting...");
 
@@ -86,7 +80,7 @@ async function main() {
     profiler,
     feedbackStore: feedbackStore ?? undefined,
     queryKnowledgeFacts: async (entities: string[], maxFacts: number) => {
-      const workspace = resolveWorkspace();
+      const workspace = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
       const dbPath = `${workspace}/memory/knowledge-graph.db`;
       const scriptPath = `${workspace}/sinain-memory/graph_query.py`;
       try {
@@ -162,13 +156,6 @@ async function main() {
     } : undefined,
     traitEngine,
     traitLogDir: config.traitConfig.logDir,
-    getKnowledgeDocPath: () => {
-      const workspace = resolveWorkspace();
-      const p = `${workspace}/memory/sinain-knowledge.md`;
-      try { if (existsSync(p)) return p; } catch {}
-      return null;
-    },
-    feedbackStore: feedbackStore ?? undefined,
   });
 
   // ── Wire learning signal collector (needs agentLoop) ──
@@ -413,13 +400,13 @@ async function main() {
 
     // Knowledge graph integration
     getKnowledgeDocPath: () => {
-      const workspace = resolveWorkspace();
+      const workspace = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
       const p = `${workspace}/memory/sinain-knowledge.md`;
       try { if (existsSync(p)) return p; } catch {}
       return null;
     },
     queryKnowledgeFacts: async (entities: string[], maxFacts: number) => {
-      const workspace = resolveWorkspace();
+      const workspace = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
       const dbPath = `${workspace}/memory/knowledge-graph.db`;
       const scriptPath = `${workspace}/sinain-memory/graph_query.py`;
       try {