@geravant/sinain 1.8.0 → 1.10.0

package/sinain-core/src/index.ts

@@ -10,7 +10,7 @@ import { TranscriptionService } from "./audio/transcription.js";
 import { AgentLoop } from "./agent/loop.js";
 import { TraitEngine, loadTraitRoster } from "./agent/traits.js";
 import { shortAppName } from "./agent/context-window.js";
-import { Escalator, type SpawnContext } from "./escalation/escalator.js";
+import { Escalator } from "./escalation/escalator.js";
 import { Recorder } from "./recorder.js";
 import { Tracer } from "./trace/tracer.js";
 import { TraceStore } from "./trace/trace-store.js";
@@ -18,6 +18,7 @@ import { FeedbackStore } from "./learning/feedback-store.js";
 import { SignalCollector } from "./learning/signal-collector.js";
 import { createAppServer } from "./server.js";
 import { Profiler } from "./profiler.js";
+import { CostTracker } from "./cost/tracker.js";
 import type { SenseEvent, EscalationMode, FeedItem } from "./types.js";
 import { isDuplicateTranscript, bigramSimilarity } from "./util/dedup.js";
 import { log, warn, error } from "./log.js";
@@ -25,41 +26,6 @@ import { initPrivacy, levelFor, applyLevel } from "./privacy/index.js";
 
 const TAG = "core";
 
-/** Build context snapshot for user-initiated spawn tasks. */
-function buildSpawnContext(
-  entry: { digest: string; context: { currentApp: string } },
-  feedBuffer: FeedBuffer,
-  senseBuffer: SenseBuffer,
-): SpawnContext {
-  const cutoff = Date.now() - 60_000;
-
-  // Recent audio: last ~60s of transcripts
-  const recentAudio = feedBuffer.queryByTime(cutoff)
-    .filter(m => m.channel === "stream" && (m.text.startsWith("[🔊]") || m.text.startsWith("[🎙]")))
-    .map(m => m.text)
-    .join("\n")
-    .slice(0, 2000);
-
-  // Recent screen: last ~60s of deduped OCR text
-  const screenEvents = senseBuffer.queryByTime(cutoff);
-  const seenOcr = new Set<string>();
-  const screenLines: string[] = [];
-  for (const e of screenEvents) {
-    if (e.ocr && !seenOcr.has(e.ocr)) {
-      seenOcr.add(e.ocr);
-      screenLines.push(`[${e.meta.app}] ${e.ocr}`);
-    }
-  }
-  const recentScreen = screenLines.join("\n").slice(0, 3000);
-
-  return {
-    currentApp: entry.context.currentApp,
-    digest: entry.digest,
-    recentAudio: recentAudio || undefined,
-    recentScreen: recentScreen || undefined,
-  };
-}
-
 /** Resolve workspace path, expanding leading ~ to HOME. */
 function resolveWorkspace(): string {
   const raw = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
@@ -93,6 +59,10 @@ async function main() {
   // ── Initialize overlay WS handler ──
   const wsHandler = new WsHandler();
 
+  // ── Initialize cost tracker ──
+  const costTracker = new CostTracker((snapshot) => wsHandler.broadcastCost(snapshot, config.costDisplayEnabled));
+  costTracker.startPeriodicLog(60_000);
+
   // ── Initialize tracing ──
   const tracer = config.traceEnabled ? new Tracer() : null;
   const traceStore = config.traceEnabled ? new TraceStore(config.traceDir) : null;
@@ -100,9 +70,6 @@ async function main() {
   // ── Initialize recorder ──
   const recorder = new Recorder();
 
-  // ── Spawn context cache — updated every agent tick for user-initiated spawns ──
-  let lastSpawnContext: SpawnContext | null = null;
-
   // ── Initialize profiler ──
   const profiler = new Profiler();
 
@@ -146,11 +113,35 @@ async function main() {
     getRecorderStatus: () => recorder.getStatus(),
     profiler,
     onAnalysis: (entry, contextWindow) => {
-      // Handle recorder commands (recording start/stop still works)
-      recorder.handleCommand(entry.record);
+      // Handle recorder commands
+      const stopResult = recorder.handleCommand(entry.record);
+
+      // Dispatch task via subagent spawn
+      if (entry.task || stopResult) {
+        let task: string;
+        let label: string | undefined;
+
+        if (stopResult && stopResult.segments > 0 && entry.task) {
+          // Recording stopped with explicit task instruction
+          task = `${entry.task}\n\n[Recording: "${stopResult.title}", ${stopResult.durationS}s]\n${stopResult.transcript}`;
+          label = stopResult.title;
+        } else if (stopResult && stopResult.segments > 0) {
+          // Recording stopped without explicit task — default to cleanup/summarize
+          task = `Clean up and summarize this recording transcript:\n\n[Recording: "${stopResult.title}", ${stopResult.durationS}s]\n${stopResult.transcript}`;
+          label = stopResult.title;
+        } else if (entry.task) {
+          // Standalone task without recording
+          task = entry.task;
+        } else {
+          task = "";
+        }
 
-      // Cache context for user-initiated spawn commands (Shift+Enter)
-      lastSpawnContext = buildSpawnContext(entry, feedBuffer, senseBuffer);
+        if (task) {
+          escalator.dispatchSpawnTask(task, label).catch(err => {
+            error(TAG, "spawn task dispatch error:", err);
+          });
+        }
+      }
 
       // Escalation continues as normal
       escalator.onAgentAnalysis(entry, contextWindow);
@@ -184,6 +175,7 @@ async function main() {
       return null;
     },
     feedbackStore: feedbackStore ?? undefined,
+    costTracker,
   });
 
   // ── Wire learning signal collector (needs agentLoop) ──
@@ -211,6 +203,7 @@ async function main() {
   systemAudioPipeline.setProfiler(profiler);
   if (micPipeline) micPipeline.setProfiler(profiler);
   transcription.setProfiler(profiler);
+  transcription.setCostTracker(costTracker);
 
   // Wire: audio chunks → transcription (both pipelines share the same transcription service)
   systemAudioPipeline.on("chunk", (chunk) => {
@@ -322,6 +315,7 @@ async function main() {
     senseBuffer,
     wsHandler,
     profiler,
+    costTracker,
     feedbackStore: feedbackStore ?? undefined,
     isScreenActive: () => screenActive,
 
@@ -447,7 +441,7 @@ async function main() {
 
     // Spawn background agent task (from HUD Shift+Enter or bare agent POST /spawn)
     onSpawnCommand: (text: string) => {
-      escalator.dispatchSpawnTask(text, text.slice(0, 64), lastSpawnContext ?? undefined).catch((err) => {
+      escalator.dispatchSpawnTask(text, "user-command").catch((err) => {
         log("srv", `spawn via HTTP failed: ${err}`);
       });
     },
@@ -475,7 +469,7 @@ async function main() {
       agentLoop.onNewContext(true);
     },
     onSpawnCommand: (text) => {
-      escalator.dispatchSpawnTask(text, text.slice(0, 64), lastSpawnContext ?? undefined).catch((err) => {
+      escalator.dispatchSpawnTask(text, "user-command").catch((err) => {
         log("cmd", `spawn command failed: ${err}`);
         wsHandler.broadcast(`\u26a0 Spawn failed: ${String(err).slice(0, 100)}`, "normal");
       });
@@ -551,12 +545,14 @@ async function main() {
   log(TAG, `  agent:   ${config.agentConfig.enabled ? "enabled" : "disabled"}`);
   log(TAG, `  escal:   ${config.escalationConfig.mode}`);
   log(TAG, `  traits:  ${config.traitConfig.enabled ? "enabled" : "disabled"} (${traitRoster.length} traits)`);
+  log(TAG, `  cost:    display=${config.costDisplayEnabled ? "on" : "off"} (always logged)`);
 
   // ── Graceful shutdown ──
   const shutdown = async (signal: string) => {
     log(TAG, `${signal} received, shutting down...`);
     clearInterval(bufferGaugeTimer);
     if (feedbackSummaryTimer) clearInterval(feedbackSummaryTimer);
+    costTracker.stop();
     profiler.stop();
     recorder.forceStop(); // Stop any active recording
     agentLoop.stop();

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

@@ -1,8 +1,10 @@
+import { execFile } from "node:child_process";
 import type { InboundMessage } from "../types.js";
 import type { WsHandler } from "./ws-handler.js";
 import type { AudioPipeline } from "../audio/pipeline.js";
 import type { CoreConfig } from "../types.js";
 import { WebSocket } from "ws";
+import { loadedEnvPath } from "../config.js";
 import { log } from "../log.js";
 
 const TAG = "cmd";
@@ -151,6 +153,16 @@ function handleCommand(action: string, deps: CommandDeps): void {
       log(TAG, `traits toggled ${nowEnabled ? "ON" : "OFF"}`);
       break;
     }
+    case "open_settings": {
+      const envPath = loadedEnvPath || `${process.env.HOME || process.env.USERPROFILE}/.sinain/.env`;
+      const cmd = process.platform === "win32" ? "notepad" : "open";
+      const args = process.platform === "win32" ? [envPath] : ["-t", envPath];
+      execFile(cmd, args, (err) => {
+        if (err) log(TAG, `open_settings failed: ${err.message}`);
+      });
+      log(TAG, `open_settings: ${envPath}`);
+      break;
+    }
     default:
       log(TAG, `unhandled command: ${action}`);
   }

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

@@ -7,6 +7,8 @@ import type {
   FeedMessage,
   StatusMessage,
   SpawnTaskMessage,
+  CostMessage,
+  CostSnapshot,
   Priority,
   FeedChannel,
 } from "../types.js";
@@ -39,6 +41,7 @@ export class WsHandler {
   };
   private replayBuffer: FeedMessage[] = [];
   private spawnTaskBuffer: Map<string, SpawnTaskMessage> = new Map();
+  private latestCostMsg: CostMessage | null = null;
 
   constructor() {
     this.startHeartbeat();
@@ -89,6 +92,16 @@ export class WsHandler {
       log(TAG, `replayed ${this.spawnTaskBuffer.size} spawn tasks to new client`);
     }
 
+    // Replay current cost snapshot (or send zeroed snapshot so client resets)
+    this.sendTo(ws, this.latestCostMsg ?? {
+      type: "cost" as const,
+      totalCost: 0,
+      costBySource: {},
+      callCount: 0,
+      startedAt: Date.now(),
+      displayEnabled: false,
+    });
+
     ws.on("message", (raw) => {
       try {
         const data = JSON.parse(raw.toString()) as InboundMessage;
@@ -158,6 +171,20 @@ export class WsHandler {
     this.broadcastMessage(msg);
   }
 
+  /** Broadcast cost snapshot to all connected overlays. */
+  broadcastCost(snapshot: CostSnapshot, displayEnabled: boolean): void {
+    const msg: CostMessage = {
+      type: "cost",
+      totalCost: snapshot.totalCost,
+      costBySource: snapshot.costBySource,
+      callCount: snapshot.callCount,
+      startedAt: snapshot.startedAt,
+      displayEnabled,
+    };
+    this.latestCostMsg = msg;
+    this.broadcastMessage(msg);
+  }
+
   /** Update internal state and broadcast. */
   updateState(partial: Partial<BridgeState>): void {
     Object.assign(this.state, partial);

package/sinain-core/src/server.ts

@@ -2,6 +2,7 @@ import { createServer, type IncomingMessage, type ServerResponse } from "node:ht
 import { WebSocketServer, WebSocket } from "ws";
 import type { CoreConfig, SenseEvent } from "./types.js";
 import type { Profiler } from "./profiler.js";
+import type { CostTracker } from "./cost/tracker.js";
 import type { FeedbackStore } from "./learning/feedback-store.js";
 import { FeedBuffer } from "./buffers/feed-buffer.js";
 import { SenseBuffer, type SemanticSenseEvent, type TextDelta } from "./buffers/sense-buffer.js";
@@ -20,6 +21,7 @@ export interface ServerDeps {
   senseBuffer: SenseBuffer;
   wsHandler: WsHandler;
   profiler?: Profiler;
+  costTracker?: CostTracker;
   onSenseEvent: (event: SenseEvent) => void;
   onSenseDelta?: (data: { app: string; activity: string; changes: TextDelta[]; priority?: string; ts: number }) => void;
   onFeedPost: (text: string, priority: string) => void;
@@ -65,6 +67,8 @@ function readBody(req: IncomingMessage, maxBytes: number): Promise<string> {
 export function createAppServer(deps: ServerDeps) {
   const { config, feedBuffer, senseBuffer, wsHandler } = deps;
   let senseInBytes = 0;
+  const seenVisionCostIds = new Set<string>();
+  const visionCostCleanup = setInterval(() => seenVisionCostIds.clear(), 60_000);
 
   const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
@@ -91,6 +95,24 @@ export function createAppServer(deps: ServerDeps) {
         senseInBytes += Buffer.byteLength(body);
         deps.profiler?.gauge("network.senseInBytes", senseInBytes);
         const data = JSON.parse(body);
+
+        // Record vision API cost before dedup — the call is already billed.
+        // Dedup by cost_id to avoid double-counting on sender retries.
+        const vc = data.vision_cost;
+        if (vc && typeof vc.cost === "number" && vc.cost > 0) {
+          const costId = vc.cost_id as string | undefined;
+          if (!costId || !seenVisionCostIds.has(costId)) {
+            if (costId) seenVisionCostIds.add(costId);
+            deps.costTracker?.record({
+              source: "vision",
+              model: vc.model || "unknown",
+              cost: vc.cost,
+              tokensIn: vc.tokens_in || 0,
+              tokensOut: vc.tokens_out || 0,
+              ts: Date.now(),
+            });
+          }
+        }
         if (!data.type || data.ts === undefined) {
           res.writeHead(400);
           res.end(JSON.stringify({ ok: false, error: "missing type or ts" }));
@@ -309,6 +331,24 @@ export function createAppServer(deps: ServerDeps) {
         return;
       }
 
+      // ── /setup/status ── (used by overlay onboarding wizard)
+      if (req.method === "GET" && url.pathname === "/setup/status") {
+        const health = deps.getHealthPayload();
+        res.end(JSON.stringify({
+          ok: true,
+          setup: {
+            openrouterKey: !!config.transcriptionConfig.openrouterApiKey,
+            gatewayConfigured: !!config.openclawConfig.gatewayToken,
+            gatewayConnected: !!(health as Record<string, any>)?.escalation?.gatewayConnected,
+            audioActive: (health as Record<string, any>)?.audio?.state === "active" || (health as Record<string, any>)?.audioPipeline?.state === "running",
+            screenActive: deps.isScreenActive(),
+            transcriptionBackend: config.transcriptionConfig.backend,
+            escalationMode: config.escalationConfig.mode,
+          },
+        }));
+        return;
+      }
+
       // ── /user/command ──
       if (req.method === "POST" && url.pathname === "/user/command") {
         const body = await readBody(req, 4096);
@@ -504,6 +544,7 @@ export function createAppServer(deps: ServerDeps) {
       });
     },
     async destroy(): Promise<void> {
+      clearInterval(visionCostCleanup);
       wsHandler.destroy();
       wss.close();
       await new Promise<void>((resolve) => httpServer.close(() => resolve()));

package/sinain-core/src/types.ts

@@ -78,7 +78,36 @@ export interface SpawnCommandMessage {
   text: string;
 }
 
-export type OutboundMessage = FeedMessage | StatusMessage | PingMessage | SpawnTaskMessage;
+/** Cost update broadcast to overlay. */
+export interface CostMessage {
+  type: "cost";
+  totalCost: number;
+  costBySource: Record<string, number>;
+  callCount: number;
+  startedAt: number;
+  displayEnabled: boolean;
+}
+
+/** Entry recorded by CostTracker for each LLM call. */
+export interface CostEntry {
+  source: "analyzer" | "transcription" | "vision";
+  model: string;
+  cost: number;
+  tokensIn: number;
+  tokensOut: number;
+  ts: number;
+}
+
+/** Snapshot of accumulated cost state. */
+export interface CostSnapshot {
+  totalCost: number;
+  costBySource: Record<string, number>;
+  costByModel: Record<string, number>;
+  callCount: number;
+  startedAt: number;
+}
+
+export type OutboundMessage = FeedMessage | StatusMessage | PingMessage | SpawnTaskMessage | CostMessage;
 export type InboundMessage = UserMessage | CommandMessage | PongMessage | ProfilingMessage | UserCommandMessage | SpawnCommandMessage;
 
 /** Abstraction for user commands (text now, voice later). */
@@ -218,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;
@@ -253,6 +285,8 @@ export interface AgentResult {
   voice?: string;
   voice_stat?: number;
   voice_confidence?: number;
+  /** Actual USD cost returned by OpenRouter (undefined if not available). */
+  cost?: number;
 }
 
 export interface AgentEntry extends AgentResult {
@@ -437,11 +471,12 @@ export interface CoreConfig {
   micConfig: AudioPipelineConfig;
   micEnabled: boolean;
   transcriptionConfig: TranscriptionConfig;
-  agentConfig: AgentConfig;
+  agentConfig: AnalysisConfig;
   escalationConfig: EscalationConfig;
   openclawConfig: OpenClawConfig;
   situationMdPath: string;
   traceEnabled: boolean;
+  costDisplayEnabled: boolean;
   traceDir: string;
   learningConfig: LearningConfig;
   traitConfig: TraitConfig;

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-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