@geravant/sinain 1.8.0 → 1.9.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";
@@ -60,15 +62,6 @@ 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 {
@@ -151,6 +144,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);
@@ -199,9 +226,6 @@ 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/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). */
@@ -253,6 +282,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 {
@@ -442,6 +473,7 @@ export interface CoreConfig {
   openclawConfig: OpenClawConfig;
   situationMdPath: string;
   traceEnabled: boolean;
+  costDisplayEnabled: boolean;
   traceDir: string;
   learningConfig: LearningConfig;
   traitConfig: TraitConfig;