@geravant/sinain 1.9.0 → 1.10.0

package/.env.example

@@ -3,8 +3,18 @@
 # The launcher reads this file on every start. sinain-core and sinain-agent
 # inherit all vars via the launcher's process environment.
 
-# ── Required ─────────────────────────────────────────────────────────────────
+# ── Context Analysis (HUD summarizer) ────────────────────────────────────────
+# Provider: openrouter (cloud, needs API key) or ollama (local, free)
+ANALYSIS_PROVIDER=openrouter
+ANALYSIS_MODEL=google/gemini-2.5-flash-lite
+# ANALYSIS_VISION_MODEL=google/gemini-2.5-flash  # auto-upgrade for image ticks
+# ANALYSIS_ENDPOINT=                             # default per provider; override for custom
+# ANALYSIS_API_KEY=                              # uses OPENROUTER_API_KEY if not set
+# ANALYSIS_FALLBACK_MODELS=google/gemini-2.5-flash,anthropic/claude-3.5-haiku
+
+# ── API Keys ─────────────────────────────────────────────────────────────────
 OPENROUTER_API_KEY=                # get one free at https://openrouter.ai
+                                   # used by context analysis + transcription
 
 # ── Privacy ──────────────────────────────────────────────────────────────────
 PRIVACY_MODE=standard              # off | standard | strict | paranoid
@@ -20,6 +30,11 @@ SINAIN_CORE_URL=http://localhost:9500
 SINAIN_POLL_INTERVAL=5             # seconds between escalation polls
 SINAIN_HEARTBEAT_INTERVAL=900      # seconds between heartbeat ticks (15 min)
 SINAIN_WORKSPACE=~/.openclaw/workspace  # knowledge files, curation scripts, playbook
+# SINAIN_ALLOWED_TOOLS=mcp__sinain     # MCP tools auto-approved for bare agent
+SINAIN_AGENT_MAX_TURNS=5               # max tool-use turns for escalation responses
+SINAIN_SPAWN_MAX_TURNS=25              # max tool-use turns for spawn tasks (Shift+Enter)
+                                       # auto-derived from mcp-config.json if unset
+                                       # format: mcp__<server> (all) | mcp__<server>__<tool> (specific)
 
 # ── Escalation ───────────────────────────────────────────────────────────────
 ESCALATION_MODE=rich               # off | selective | focus | rich
@@ -27,7 +42,7 @@ ESCALATION_MODE=rich               # off | selective | focus | rich
                                    # selective: score-based (errors, questions trigger it)
                                    # focus: always escalate every tick
                                    # rich: always escalate with maximum context
-ESCALATION_COOLDOWN_MS=30000
+# ESCALATION_COOLDOWN_MS=10000
 # ESCALATION_TRANSPORT=auto        # ws | http | auto
                                    # auto = WS when gateway connected, HTTP fallback
                                    # http = bare agent only (no gateway)
@@ -70,18 +85,6 @@ TRANSCRIPTION_LANGUAGE=en-US
 # LOCAL_WHISPER_MODEL=~/models/ggml-large-v3-turbo.bin
 # LOCAL_WHISPER_TIMEOUT_MS=15000
 
-# ── Local Agent Loop ─────────────────────────────────────────────────────────
-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)
-
 # ── OpenClaw / NemoClaw Gateway ──────────────────────────────────────────────
 # Leave blank to run without a gateway (bare agent mode).
 # The setup wizard fills these in if you have an OpenClaw gateway.

package/HEARTBEAT.md

@@ -59,4 +59,4 @@ SINAIN_BACKUP_REPO=<git-url> npx sinain
 - Token printed at end (or visible in Brev dashboard → Gateway Token)
 - Mac side: `./setup-nemoclaw.sh` → 5 prompts → overlay starts
 
-Memory is git-backed via `git_backup.sh` on every heartbeat tick. New instances restore instantly via `SINAIN_BACKUP_REPO`.
+Memory is backed up via knowledge snapshots to `~/.sinain/knowledge-snapshots/`. New instances restore instantly via `SINAIN_BACKUP_REPO`.

package/README.md

@@ -29,13 +29,12 @@ Five lifecycle hooks, one tool, four commands, and a background service:
 
 | Tool | Purpose |
 |---|---|
-| `sinain_heartbeat_tick` | Executes all heartbeat mechanical work (git backup, signal analysis, insight synthesis, log writing). Returns structured JSON with results, recommended actions, and Telegram output. |
+| `sinain_heartbeat_tick` | Executes all heartbeat mechanical work (signal analysis, insight synthesis, log writing). Returns structured JSON with results, recommended actions, and Telegram output. |
 
 The heartbeat tool accepts `{ sessionSummary: string, idle: boolean }` and runs:
-1. `bash sinain-memory/git_backup.sh` (30s timeout)
-2. `uv run python3 sinain-memory/signal_analyzer.py` (60s timeout)
-3. `uv run python3 sinain-memory/insight_synthesizer.py` (60s timeout)
-4. Writes log entry to `memory/playbook-logs/YYYY-MM-DD.jsonl`
+1. `uv run python3 sinain-memory/signal_analyzer.py` (60s timeout)
+2. `uv run python3 sinain-memory/insight_synthesizer.py` (60s timeout)
+3. Writes log entry to `memory/playbook-logs/YYYY-MM-DD.jsonl`
 
 ### Commands
 
@@ -114,8 +113,6 @@ Also ensures these directories exist:
 - `memory/`, `memory/playbook-archive/`, `memory/playbook-logs/`
 - `memory/eval-logs/`, `memory/eval-reports/`
 
-The `git_backup.sh` script is automatically made executable (chmod 755) after sync.
-
 After syncing modules, the plugin generates `memory/sinain-playbook-effective.md` — a merged view of active module patterns (sorted by priority) plus the base playbook.
 
 ## Heartbeat Compliance Validation

package/index.ts

@@ -8,7 +8,7 @@
  * - Strips <private> tags from tool results before persistence
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync, chmodSync, copyFileSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync, copyFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 
@@ -358,8 +358,6 @@ export default function sinainHudPlugin(api: OpenClawPluginApi): void {
       const memorySource = cfg.memoryPath ? api.resolvePath(cfg.memoryPath) : undefined;
       if (memorySource) {
         store.deployDir(memorySource, "sinain-memory");
-        const gbPath = join(workspaceDir, "sinain-memory", "git_backup.sh");
-        if (existsSync(gbPath)) try { chmodSync(gbPath, 0o755); } catch {}
       }
 
       const modulesSource = cfg.modulesPath ? api.resolvePath(cfg.modulesPath) : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Ambient intelligence that sees what you see, hears what you hear, and acts on your behalf",
   "type": "module",
   "bin": {

package/sense_client/ocr.py

@@ -158,8 +158,10 @@ class VisionOCR:
 
         # Execute
         handler = VNImageRequestHandler.alloc().initWithCGImage_options_(cg_image, None)
-        success = handler.performRequests_error_([request], objc.nil)
-        if not success[0]:
+        result = handler.performRequests_error_([request], objc.nil)
+        # PyObjC may return (bool, error) tuple or just bool depending on version
+        success = result[0] if isinstance(result, tuple) else result
+        if not success:
             return OCRResult(text="", confidence=0, word_count=0)
 
         results = request.results()
@@ -172,7 +174,8 @@ class VisionOCR:
 
         for observation in results:
             candidate = observation.topCandidates_(1)
-            if not candidate:
+            # PyObjC may return bool instead of list depending on version
+            if not candidate or isinstance(candidate, bool):
                 continue
             text = candidate[0].string()
             conf = candidate[0].confidence()

package/sinain-agent/CLAUDE.md

@@ -47,7 +47,6 @@ When responding to escalations:
 
 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)
    - **Session distillation** — fetches new feed items from sinain-core, distills patterns/learnings
    - **Knowledge integration** — updates playbook (working memory) and knowledge graph (long-term memory)

package/sinain-agent/run.sh

@@ -5,7 +5,9 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # 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
+# Load project root .env (single config for all subsystems)
+ENV_FILE="$SCRIPT_DIR/../.env"
+if [ -f "$ENV_FILE" ]; then
   while IFS='=' read -r key val; do
     # Skip comments and blank lines
     [[ -z "$key" || "$key" =~ ^[[:space:]]*# ]] && continue
@@ -19,7 +21,7 @@ if [ -f "$SCRIPT_DIR/.env" ]; then
     if [ -z "${!key+x}" ]; then
       export "$key=$val"
     fi
-  done < "$SCRIPT_DIR/.env"
+  done < "$ENV_FILE"
 fi
 
 MCP_CONFIG="${MCP_CONFIG:-$SCRIPT_DIR/mcp-config.json}"
@@ -28,6 +30,8 @@ POLL_INTERVAL="${SINAIN_POLL_INTERVAL:-2}"
 HEARTBEAT_INTERVAL="${SINAIN_HEARTBEAT_INTERVAL:-900}" # 15 minutes
 AGENT="${SINAIN_AGENT:-claude}"
 WORKSPACE="${SINAIN_WORKSPACE:-$HOME/.openclaw/workspace}"
+AGENT_MAX_TURNS="${SINAIN_AGENT_MAX_TURNS:-5}"
+SPAWN_MAX_TURNS="${SINAIN_SPAWN_MAX_TURNS:-25}"
 
 # Build allowed tools list for Claude's --allowedTools flag.
 # SINAIN_ALLOWED_TOOLS in .env overrides; otherwise auto-derive from MCP config.
@@ -64,10 +68,11 @@ invoke_agent() {
   local prompt="$1"
   case "$AGENT" in
     claude)
+      local turns="${2:-$AGENT_MAX_TURNS}"
       claude --enable-auto-mode \
         --mcp-config "$MCP_CONFIG" \
         ${ALLOWED_TOOLS:+--allowedTools $ALLOWED_TOOLS} \
-        --max-turns 5 --output-format text \
+        --max-turns "$turns" --output-format text \
         -p "$prompt"
       ;;
     codex)
@@ -89,9 +94,10 @@ invoke_agent() {
       fi
       ;;
     goose)
+      local turns="${2:-$AGENT_MAX_TURNS}"
       GOOSE_MODE=auto goose run --text "$prompt" \
         --output-format text \
-        --max-turns 10
+        --max-turns "$turns"
       ;;
     aider)
       # No MCP support — signal pipe mode
@@ -267,7 +273,7 @@ while true; do
       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")
+      SPAWN_RESULT=$(invoke_agent "$SPAWN_PROMPT" "$SPAWN_MAX_TURNS" || echo "ERROR: agent invocation failed")
     else
       # Pipe path: agent gets task text directly
       SPAWN_RESULT=$(invoke_pipe "Background task: $SPAWN_TASK" || echo "No output")

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

@@ -1,13 +1,10 @@
-import type { AgentConfig, AgentResult, ContextWindow, RecorderStatus, RecordCommand } from "../types.js";
+import type { AnalysisConfig, AgentResult, ContextWindow, RecorderStatus, RecordCommand } from "../types.js";
 import { normalizeAppName } from "./context-window.js";
 import { log, error } from "../log.js";
 import { levelFor, applyLevel } from "../privacy/index.js";
 
 const TAG = "agent";
 
-/** Guard: only one Ollama vision call at a time (latest-wins, skip if busy). */
-let ollamaInFlight = false;
-
 /**
  * Model-specific timeouts in milliseconds.
  * Only increases timeouts for slow models to avoid false timeouts.
@@ -211,75 +208,54 @@ function parseTask(parsed: any): string | undefined {
  */
 export async function analyzeContext(
   contextWindow: ContextWindow,
-  config: AgentConfig,
+  config: AnalysisConfig,
   recorderStatus: RecorderStatus | null = null,
   traitSystemPrompt?: string,
 ): Promise<AgentResult> {
   const userPrompt = buildUserPrompt(contextWindow, recorderStatus);
-  // Apply privacy gating for images sent to OpenRouter
+
+  // Apply privacy gating for images based on provider
   let images = contextWindow.images || [];
+  const privacyDest = config.provider === "ollama" ? "local_llm" : "openrouter";
   try {
-    const imgLevel = levelFor("screen_images", "openrouter");
-    if (imgLevel === "none") {
-      images = [];
-    }
+    if (levelFor("screen_images", privacyDest) === "none") images = [];
   } catch { /* privacy not initialized, keep images */ }
+
   const systemPrompt = traitSystemPrompt ?? SYSTEM_PROMPT;
 
-  // Try local Ollama first when enabled (handles both vision and text-only ticks)
-  // Guard: skip if a previous Ollama call is still in-flight (avoids "no slots available")
-  if (config.localVisionEnabled && !ollamaInFlight) {
-    ollamaInFlight = true;
-    try {
-      const result = await callOllamaVision(systemPrompt, userPrompt, images, config);
-      const mode = images.length > 0 ? "vision" : "text";
-      log(TAG, `local ollama (${config.localVisionModel}, ${mode}): success`);
-      return result;
-    } catch (err: any) {
-      log(TAG, `local ollama failed: ${err.message || err}, falling back to OpenRouter`);
-    } finally {
-      ollamaInFlight = false;
-    }
+  if (config.provider === "ollama") {
+    return await callOllama(systemPrompt, userPrompt, images, config);
   }
 
-  // Skip OpenRouter entirely if no API key (local-only mode)
-  if (!config.openrouterApiKey) {
-    if (config.localVisionEnabled) {
-      throw new Error("local ollama failed and no OpenRouter API key — cannot analyze");
-    }
-    throw new Error("no OpenRouter API key configured");
+  // OpenRouter path: model chain with fallbacks
+  if (!config.apiKey) {
+    throw new Error("ANALYSIS_API_KEY / OPENROUTER_API_KEY not set");
   }
 
   const models = [config.model, ...config.fallbackModels];
-
-  // Auto-upgrade: use vision model when images are present
-  if (images.length > 0 && config.visionModel) {
-    // Insert vision model at the front if not already there
-    if (!models.includes(config.visionModel)) {
-      models.unshift(config.visionModel);
-    }
+  // Auto-upgrade to vision model when images are present
+  if (images.length > 0 && config.visionModel && !models.includes(config.visionModel)) {
+    models.unshift(config.visionModel);
   }
 
   let lastError: Error | null = null;
-
   for (const model of models) {
     try {
-      return await callModel(systemPrompt, userPrompt, images, model, config);
+      return await callOpenRouter(systemPrompt, userPrompt, images, model, config);
     } catch (err: any) {
       lastError = err;
       log(TAG, `model ${model} failed: ${err.message || err}, trying next...`);
     }
   }
-
   throw lastError || new Error("all models failed");
 }
 
-async function callModel(
+async function callOpenRouter(
   systemPrompt: string,
   userPrompt: string,
   images: ContextWindow["images"],
   model: string,
-  config: AgentConfig,
+  config: AnalysisConfig,
 ): Promise<AgentResult> {
   const start = Date.now();
   const controller = new AbortController();
@@ -307,10 +283,10 @@ async function callModel(
 
     const imageCount = images?.length || 0;
 
-    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    const response = await fetch(config.endpoint, {
       method: "POST",
       headers: {
-        "Authorization": `Bearer ${config.openrouterApiKey}`,
+        "Authorization": `Bearer ${config.apiKey}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
@@ -398,28 +374,27 @@ async function callModel(
 }
 
 /**
- * Call Ollama local vision model for image analysis.
- * Uses the /api/chat endpoint with base64 images.
- * Falls back to OpenRouter on any failure.
+ * Call Ollama local model for context analysis.
+ * Uses the /api/chat endpoint with optional base64 images.
  */
-async function callOllamaVision(
+async function callOllama(
   systemPrompt: string,
   userPrompt: string,
   images: ContextWindow["images"],
-  config: AgentConfig,
+  config: AnalysisConfig,
 ): Promise<AgentResult> {
   const start = Date.now();
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), config.localVisionTimeout);
+  const timeout = setTimeout(() => controller.abort(), config.timeout);
 
   try {
     const imageB64List = (images || []).map((img) => img.data);
 
-    const response = await fetch(`${config.localVisionUrl}/api/chat`, {
+    const response = await fetch(`${config.endpoint}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        model: config.localVisionModel,
+        model: config.model,
         messages: [
           { role: "system", content: systemPrompt },
           { role: "user", content: userPrompt, images: imageB64List },
@@ -445,7 +420,7 @@ async function callOllamaVision(
     const tokensIn = data.prompt_eval_count || 0;
     const tokensOut = data.eval_count || 0;
 
-    log(TAG, `ollama vision: model=${config.localVisionModel} latency=${latencyMs}ms tokens=${tokensIn}+${tokensOut}`);
+    log(TAG, `ollama vision: model=${config.model} latency=${latencyMs}ms tokens=${tokensIn}+${tokensOut}`);
 
     // Parse the response (same format as OpenRouter)
     // Parse JSON response (same logic as callModel)
@@ -459,7 +434,7 @@ async function callOllamaVision(
         task: parseTask(parsed),
         latencyMs,
         tokensIn, tokensOut,
-        model: config.localVisionModel,
+        model: config.model,
         parsedOk: true,
       };
     } catch {
@@ -475,7 +450,7 @@ async function callOllamaVision(
               task: parseTask(parsed),
               latencyMs,
               tokensIn, tokensOut,
-              model: config.localVisionModel,
+              model: config.model,
               parsedOk: true,
             };
           }
@@ -486,7 +461,7 @@ async function callOllamaVision(
         digest: content || "\u2014",
         latencyMs,
         tokensIn, tokensOut,
-        model: config.localVisionModel,
+        model: config.model,
         parsedOk: false,
       };
     }

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

@@ -2,7 +2,7 @@ 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 { AnalysisConfig, AgentEntry, ContextWindow, EscalationMode, ContextRichness, RecorderStatus, SenseEvent, FeedbackRecord } from "../types.js";
 import type { Profiler } from "../profiler.js";
 import type { CostTracker } from "../cost/tracker.js";
 import { buildContextWindow, RICHNESS_PRESETS } from "./context-window.js";
@@ -18,7 +18,7 @@ const TAG = "agent";
 export interface AgentLoopDeps {
   feedBuffer: FeedBuffer;
   senseBuffer: SenseBuffer;
-  agentConfig: AgentConfig;
+  agentConfig: AnalysisConfig;
   escalationMode: EscalationMode;
   situationMdPath: string;
   /** Called after analysis with digest + context for escalation check. */
@@ -106,9 +106,10 @@ export class AgentLoop extends EventEmitter {
   /** Start the agent loop. */
   start(): void {
     if (this.started) return;
-    if (!this.deps.agentConfig.enabled || !this.deps.agentConfig.openrouterApiKey) {
-      if (this.deps.agentConfig.enabled) {
-        warn(TAG, "AGENT_ENABLED=true but OPENROUTER_API_KEY not set \u2014 agent disabled");
+    const ac = this.deps.agentConfig;
+    if (!ac.enabled || (ac.provider !== "ollama" && !ac.apiKey)) {
+      if (ac.enabled) {
+        warn(TAG, "AGENT_ENABLED=true but no API key and provider is not ollama \u2014 analysis disabled");
       }
       return;
     }
@@ -177,8 +178,8 @@ export class AgentLoop extends EventEmitter {
 
   /** Get config (safe — no API key). */
   getConfig(): Record<string, unknown> {
-    const { openrouterApiKey, ...safe } = this.deps.agentConfig;
-    return { ...safe, hasApiKey: !!openrouterApiKey, escalationMode: this.deps.escalationMode };
+    const { apiKey, ...safe } = this.deps.agentConfig;
+    return { ...safe, hasApiKey: !!apiKey, escalationMode: this.deps.escalationMode };
   }
 
   /** Get stats for /health. */
@@ -219,10 +220,10 @@ export class AgentLoop extends EventEmitter {
     if (updates.maxIntervalMs !== undefined) c.maxIntervalMs = Math.max(5000, parseInt(String(updates.maxIntervalMs)));
     if (updates.cooldownMs !== undefined) c.cooldownMs = Math.max(3000, parseInt(String(updates.cooldownMs)));
     if (updates.fallbackModels !== undefined) c.fallbackModels = Array.isArray(updates.fallbackModels) ? updates.fallbackModels : [];
-    if (updates.openrouterApiKey !== undefined) c.openrouterApiKey = String(updates.openrouterApiKey);
+    if (updates.apiKey !== undefined) c.apiKey = String(updates.apiKey);
 
     // Restart loop if needed
-    if (c.enabled && c.openrouterApiKey) {
+    if (c.enabled && (c.provider === "ollama" || c.apiKey)) {
       if (!this.started) this.start();
       else {
         // Reset max interval timer with new config
@@ -238,7 +239,7 @@ export class AgentLoop extends EventEmitter {
 
   private async run(): Promise<void> {
     if (this.running) return;
-    if (!this.deps.agentConfig.openrouterApiKey) return;
+    if (this.deps.agentConfig.provider !== "ollama" && !this.deps.agentConfig.apiKey) return;
 
     // Cooldown: don't re-analyze within cooldownMs of last run (unless urgent)
     const isUrgent = this.urgentPending;

package/sinain-core/src/config.ts

@@ -2,7 +2,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import os from "node:os";
-import type { CoreConfig, AudioPipelineConfig, TranscriptionConfig, AgentConfig, EscalationConfig, OpenClawConfig, EscalationMode, EscalationTransport, LearningConfig, TraitConfig, PrivacyConfig, PrivacyMatrix, PrivacyLevel, PrivacyRow } from "./types.js";
+import type { CoreConfig, AudioPipelineConfig, TranscriptionConfig, AnalysisConfig, EscalationConfig, OpenClawConfig, EscalationMode, EscalationTransport, LearningConfig, TraitConfig, PrivacyConfig, PrivacyMatrix, PrivacyLevel, PrivacyRow } from "./types.js";
 import { PRESETS } from "./privacy/presets.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -178,25 +178,28 @@ export function loadConfig(): CoreConfig {
     },
   };
 
-  const agentConfig: AgentConfig = {
+  const analysisProvider = env("ANALYSIS_PROVIDER", "openrouter") as import("./types.js").AnalysisProvider;
+  const defaultEndpoint = analysisProvider === "ollama"
+    ? "http://localhost:11434"
+    : "https://openrouter.ai/api/v1/chat/completions";
+
+  const agentConfig: import("./types.js").AnalysisConfig = {
     enabled: boolEnv("AGENT_ENABLED", true),
-    model: env("AGENT_MODEL", "google/gemini-2.5-flash-lite"),
-    visionModel: env("AGENT_VISION_MODEL", "google/gemini-2.5-flash"),
-    visionEnabled: boolEnv("AGENT_VISION_ENABLED", true),
-    localVisionEnabled: boolEnv("LOCAL_VISION_ENABLED", false),
-    localVisionModel: env("LOCAL_VISION_MODEL", "llava"),
-    localVisionUrl: env("LOCAL_VISION_URL", "http://localhost:11434"),
-    localVisionTimeout: intEnv("LOCAL_VISION_TIMEOUT", 10000),
-    openrouterApiKey: env("OPENROUTER_API_KEY", ""),
-    maxTokens: intEnv("AGENT_MAX_TOKENS", 800),
-    temperature: floatEnv("AGENT_TEMPERATURE", 0.3),
+    provider: analysisProvider,
+    model: env("ANALYSIS_MODEL", "google/gemini-2.5-flash-lite"),
+    visionModel: env("ANALYSIS_VISION_MODEL", "google/gemini-2.5-flash"),
+    endpoint: env("ANALYSIS_ENDPOINT", defaultEndpoint),
+    apiKey: env("ANALYSIS_API_KEY", env("OPENROUTER_API_KEY", "")),
+    maxTokens: intEnv("ANALYSIS_MAX_TOKENS", 800),
+    temperature: floatEnv("ANALYSIS_TEMPERATURE", 0.3),
+    fallbackModels: env("ANALYSIS_FALLBACK_MODELS", "google/gemini-2.5-flash,anthropic/claude-3.5-haiku")
+      .split(",").map(s => s.trim()).filter(Boolean),
+    timeout: intEnv("ANALYSIS_TIMEOUT", 15000),
     pushToFeed: boolEnv("AGENT_PUSH_TO_FEED", true),
     debounceMs: intEnv("AGENT_DEBOUNCE_MS", 3000),
     maxIntervalMs: intEnv("AGENT_MAX_INTERVAL_MS", 30000),
     cooldownMs: intEnv("AGENT_COOLDOWN_MS", 10000),
     maxAgeMs: intEnv("AGENT_MAX_AGE_MS", 120000),
-    fallbackModels: env("AGENT_FALLBACK_MODELS", "google/gemini-2.5-flash,anthropic/claude-3.5-haiku")
-      .split(",").map(s => s.trim()).filter(Boolean),
     historyLimit: intEnv("AGENT_HISTORY_LIMIT", 50),
   };
 

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

@@ -62,6 +62,15 @@ export function setupCommands(deps: CommandDeps): void {
       case "spawn_command": {
         const preview = msg.text.length > 60 ? msg.text.slice(0, 60) + "…" : msg.text;
         log(TAG, `spawn command received: "${preview}"`);
+        // Echo spawn command to all overlay clients as a feed item (green in UI)
+        wsHandler.broadcastRaw({
+          type: "feed",
+          text: `⚡ ${msg.text}`,
+          priority: "normal",
+          ts: Date.now(),
+          channel: "agent",
+          sender: "spawn",
+        } as any);
         if (deps.onSpawnCommand) {
           deps.onSpawnCommand(msg.text);
         } else {

package/sinain-core/src/overlay/ws-handler.ts

@@ -226,6 +226,9 @@ export class WsHandler {
       case "user_command":
         log(TAG, `\u2190 user command: ${msg.text.slice(0, 100)}`);
         break;
+      case "spawn_command":
+        log(TAG, `\u2190 spawn command: ${msg.text.slice(0, 100)}`);
+        break;
       case "profiling":
         if (this.onProfilingCb) this.onProfilingCb(msg);
         return;

package/sinain-core/src/types.ts

@@ -247,28 +247,31 @@ export interface StopResult {
 export type EscalationMode = "off" | "selective" | "focus" | "rich";
 export type ContextRichness = "lean" | "standard" | "rich";
 
-export interface AgentConfig {
+export type AnalysisProvider = "openrouter" | "ollama";
+
+export interface AnalysisConfig {
   enabled: boolean;
+  provider: AnalysisProvider;
   model: string;
   visionModel: string;
-  visionEnabled: boolean;
-  localVisionEnabled: boolean;
-  localVisionModel: string;
-  localVisionUrl: string;
-  localVisionTimeout: number;
-  openrouterApiKey: string;
+  endpoint: string;
+  apiKey: string;
   maxTokens: number;
   temperature: number;
+  fallbackModels: string[];
+  timeout: number;
+  // Loop timing
   pushToFeed: boolean;
   debounceMs: number;
   maxIntervalMs: number;
   cooldownMs: number;
   maxAgeMs: number;
-  fallbackModels: string[];
-  /** Maximum entries to keep in agent history buffer (default: 50) */
   historyLimit: number;
 }
 
+/** @deprecated Use AnalysisConfig */
+export type AgentConfig = AnalysisConfig;
+
 export interface AgentResult {
   hud: string;
   digest: string;
@@ -468,7 +471,7 @@ export interface CoreConfig {
   micConfig: AudioPipelineConfig;
   micEnabled: boolean;
   transcriptionConfig: TranscriptionConfig;
-  agentConfig: AgentConfig;
+  agentConfig: AnalysisConfig;
   escalationConfig: EscalationConfig;
   openclawConfig: OpenClawConfig;
   situationMdPath: string;

package/sinain-knowledge/curation/engine.ts

@@ -43,7 +43,6 @@ function writeDistillState(workspaceDir: string, state: DistillState): void {
 
 export type HeartbeatResult = {
   status: string;
-  gitBackup: string | null;
   signals: unknown[];
   recommendedAction: { action: string; task: string | null; confidence: number };
   output: unknown | null;
@@ -95,7 +94,6 @@ export class CurationEngine {
     const workspaceDir = this.store.getWorkspaceDir();
     const result: HeartbeatResult = {
       status: "ok",
-      gitBackup: null,
       signals: [],
       recommendedAction: { action: "skip", task: null, confidence: 0 },
       output: null,
@@ -131,20 +129,6 @@ export class CurationEngine {
     const latencyMs: Record<string, number> = {};
     const heartbeatStart = Date.now();
 
-    // 1. Git backup (30s timeout)
-    try {
-      const t0 = Date.now();
-      const gitOut = await this.runScript(
-        ["bash", "sinain-memory/git_backup.sh"],
-        { timeoutMs: 30_000, cwd: workspaceDir },
-      );
-      latencyMs.gitBackup = Date.now() - t0;
-      result.gitBackup = gitOut.stdout.trim() || "nothing to commit";
-    } catch (err) {
-      this.logger.warn(`sinain-hud: git backup error: ${String(err)}`);
-      result.gitBackup = `error: ${String(err)}`;
-    }
-
     // Current time string for memory scripts
     const hbTz = this.config.userTimezone;
     const currentTimeStr = new Date().toLocaleString("en-GB", {
@@ -291,7 +275,6 @@ export class CurationEngine {
         output: result.output,
         skipped: result.skipped,
         skipReason: result.skipReason,
-        gitBackup: result.gitBackup,
         latencyMs,
         totalLatencyMs,
       };

package/sinain-knowledge/protocol/heartbeat.md

@@ -59,4 +59,4 @@ SINAIN_BACKUP_REPO=<git-url> npx sinain
 - Token printed at end (or visible in Brev dashboard → Gateway Token)
 - Mac side: `./setup-nemoclaw.sh` → 5 prompts → overlay starts
 
-Memory is git-backed via `git_backup.sh` on every heartbeat tick. New instances restore instantly via `SINAIN_BACKUP_REPO`.
+Memory is backed up via knowledge snapshots to `~/.sinain/knowledge-snapshots/`. New instances restore instantly via `SINAIN_BACKUP_REPO`.

package/sinain-mcp-server/index.ts

@@ -317,23 +317,7 @@ server.tool(
     const results: string[] = [];
     const now = new Date().toISOString();
 
-    // Step 1: git_backup.sh
-    const gitBackupPath = resolve(SCRIPTS_DIR, "git_backup.sh");
-    if (existsSync(gitBackupPath)) {
-      try {
-        const out = await new Promise<string>((res, rej) => {
-          execFile("bash", [gitBackupPath, MEMORY_DIR], { timeout: 30_000 }, (err, stdout, stderr) => {
-            if (err) rej(new Error(`git_backup failed: ${err.message}\n${stderr}`));
-            else res(stdout);
-          });
-        });
-        results.push(`[git_backup] ${out.trim() || "OK"}`);
-      } catch (err: any) {
-        results.push(`[git_backup] FAILED: ${err.message}`);
-      }
-    }
-
-    // Step 2: signal_analyzer.py
+    // Step 1: signal_analyzer.py
     try {
       const out = await runScript([
         resolve(SCRIPTS_DIR, "signal_analyzer.py"),
@@ -346,7 +330,7 @@ server.tool(
       results.push(`[signal_analyzer] FAILED: ${err.message}`);
     }
 
-    // Step 3: insight_synthesizer.py
+    // Step 2: insight_synthesizer.py
     try {
       const out = await runScript([
         resolve(SCRIPTS_DIR, "insight_synthesizer.py"),
@@ -358,7 +342,7 @@ server.tool(
       results.push(`[insight_synthesizer] FAILED: ${err.message}`);
     }
 
-    // Step 4: memory_miner.py
+    // Step 3: memory_miner.py
     try {
       const out = await runScript([
         resolve(SCRIPTS_DIR, "memory_miner.py"),
@@ -369,7 +353,7 @@ server.tool(
       results.push(`[memory_miner] FAILED: ${err.message}`);
     }
 
-    // Step 5: playbook_curator.py
+    // Step 4: playbook_curator.py
     try {
       const out = await runScript([
         resolve(SCRIPTS_DIR, "playbook_curator.py"),

package/sinain-agent/.env.example

@@ -1,23 +0,0 @@
-# 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
-
-# ── Tool permissions (Claude only) ──
-# Tools auto-approved without prompting (space-separated).
-# Default: auto-derived from MCP config server names (e.g. mcp__sinain).
-# Format: mcp__<server> (all tools) | mcp__<server>__<tool> (specific) | Bash(pattern)
-# SINAIN_ALLOWED_TOOLS=mcp__sinain mcp__github Bash(git *)

package/sinain-memory/git_backup.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-# Phase 1: Git backup — commit and push any uncommitted changes in the workspace.
-# Runs from the workspace root. Exits 0 on success or nothing to commit, 1 on push failure.
-
-set -euo pipefail
-
-changes=$(git status --porcelain 2>/dev/null || true)
-
-if [ -z "$changes" ]; then
-    echo "nothing to commit"
-    exit 0
-fi
-
-git add -A
-git commit -m "auto: heartbeat $(date -u +%Y-%m-%dT%H:%M:%SZ)"
-git push origin main
-
-# Output the commit hash
-git rev-parse --short HEAD