@geravant/sinain 1.7.2 → 1.9.0

package/sinain-agent/run.sh

@@ -72,10 +72,15 @@ invoke_agent() {
       ;;
     codex)
       codex exec -s danger-full-access \
+        --dangerously-bypass-approvals-and-sandbox \
+        --skip-git-repo-check \
         "$prompt"
       ;;
     junie)
       if $JUNIE_HAS_MCP; then
+        if [ ! -f "$HOME/.junie/allowlist.json" ]; then
+          echo "  ⚠ Junie: no allowlist.json — MCP tools may prompt. Run junie --brave once to create it." >&2
+        fi
         junie --output-format text \
           --mcp-location "$JUNIE_MCP_DIR" \
           --task "$prompt"
@@ -84,7 +89,7 @@ invoke_agent() {
       fi
       ;;
     goose)
-      goose run --text "$prompt" \
+      GOOSE_MODE=auto goose run --text "$prompt" \
         --output-format text \
         --max-turns 10
       ;;

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

@@ -342,6 +342,7 @@ async function callModel(
     try {
       const jsonStr = raw.replace(/^```\w*\s*\n?/, "").replace(/\n?\s*```\s*$/, "").trim();
       const parsed = JSON.parse(jsonStr);
+      const apiCost = typeof data.usage?.cost === "number" ? data.usage.cost : undefined;
       return {
         hud: parsed.hud || "\u2014",
         digest: parsed.digest || "\u2014",
@@ -352,10 +353,12 @@ async function callModel(
         tokensOut: data.usage?.completion_tokens || 0,
         model,
         parsedOk: true,
+        cost: apiCost,
       };
     } catch {
       // Second chance: extract embedded JSON object
       const match = raw.match(/\{[\s\S]*\}/);
+      const apiCost = typeof data.usage?.cost === "number" ? data.usage.cost : undefined;
       if (match) {
         try {
           const parsed = JSON.parse(match[0]);
@@ -370,6 +373,7 @@ async function callModel(
               tokensOut: data.usage?.completion_tokens || 0,
               model,
               parsedOk: true,
+              cost: apiCost,
             };
           }
         } catch { /* fall through */ }
@@ -385,6 +389,7 @@ async function callModel(
         tokensOut: data.usage?.completion_tokens || 0,
         model,
         parsedOk: false,
+        cost: apiCost,
       };
     }
   } finally {

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

@@ -4,6 +4,7 @@ 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 { Profiler } from "../profiler.js";
+import type { CostTracker } from "../cost/tracker.js";
 import { buildContextWindow, RICHNESS_PRESETS } from "./context-window.js";
 import { analyzeContext } from "./analyzer.js";
 import { writeSituationMd } from "./situation-writer.js";
@@ -40,6 +41,8 @@ export interface AgentLoopDeps {
   getKnowledgeDocPath?: () => string | null;
   /** Optional: feedback store for startup recap context. */
   feedbackStore?: { queryRecent(n: number): FeedbackRecord[] };
+  /** Optional: cost tracker for LLM cost accumulation. */
+  costTracker?: CostTracker;
 }
 
 export interface TraceContext {
@@ -317,6 +320,17 @@ export class AgentLoop extends EventEmitter {
       this.deps.profiler?.gauge("agent.parseSuccesses", this.stats.parseSuccesses);
       this.deps.profiler?.gauge("agent.parseFailures", this.stats.parseFailures);
 
+      if (typeof result.cost === "number" && result.cost > 0) {
+        this.deps.costTracker?.record({
+          source: "analyzer",
+          model: usedModel,
+          cost: result.cost,
+          tokensIn,
+          tokensOut,
+          ts: Date.now(),
+        });
+      }
+
       // Build entry
       const entry: AgentEntry = {
         ...result,
@@ -375,12 +389,13 @@ export class AgentLoop extends EventEmitter {
 
       // Finish trace
       const costPerToken = { in: 0.075 / 1_000_000, out: 0.3 / 1_000_000 };
+      const estimatedCost = tokensIn * costPerToken.in + tokensOut * costPerToken.out;
       traceCtx?.finish({
         totalLatencyMs: Date.now() - entry.ts + latencyMs,
         llmLatencyMs: latencyMs,
         llmInputTokens: tokensIn,
         llmOutputTokens: tokensOut,
-        llmCost: tokensIn * costPerToken.in + tokensOut * costPerToken.out,
+        llmCost: result.cost ?? estimatedCost,
         escalated: false, // Updated by escalator
         escalationScore: 0,
         contextScreenEvents: contextWindow.screenCount,
@@ -477,6 +492,16 @@ export class AgentLoop extends EventEmitter {
       };
 
       const result = await analyzeContext(recapWindow, this.deps.agentConfig, null);
+      if (typeof result.cost === "number" && result.cost > 0) {
+        this.deps.costTracker?.record({
+          source: "analyzer",
+          model: result.model,
+          cost: result.cost,
+          tokensIn: result.tokensIn,
+          tokensOut: result.tokensOut,
+          ts: Date.now(),
+        });
+      }
       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}"`);

package/sinain-core/src/audio/transcription.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from "node:events";
 import type { TranscriptionConfig, AudioChunk, TranscriptResult } from "../types.js";
 import type { Profiler } from "../profiler.js";
+import type { CostTracker } from "../cost/tracker.js";
 import { LocalTranscriptionBackend } from "./transcription-local.js";
 import { log, warn, error, debug } from "../log.js";
 
@@ -41,7 +42,10 @@ export class TranscriptionService extends EventEmitter {
   private dropCount: number = 0;
   private totalCalls: number = 0;
 
+  private costTracker: CostTracker | null = null;
+
   setProfiler(p: Profiler): void { this.profiler = p; }
+  setCostTracker(ct: CostTracker): void { this.costTracker = ct; }
 
   constructor(config: TranscriptionConfig) {
     super();
@@ -219,7 +223,7 @@ export class TranscriptionService extends EventEmitter {
 
       const data = await response.json() as {
         choices?: Array<{ message?: { content?: string } }>;
-        usage?: { prompt_tokens?: number; completion_tokens?: number };
+        usage?: { prompt_tokens?: number; completion_tokens?: number; cost?: number };
       };
 
       const text = data.choices?.[0]?.message?.content?.trim();
@@ -231,6 +235,21 @@ export class TranscriptionService extends EventEmitter {
       this.profiler?.timerRecord("transcription.call", elapsed);
       this.totalAudioDurationMs += chunk.durationMs;
 
+      // Track tokens and cost before any early returns — the API call is already billed
+      if (data.usage) {
+        this.totalTokensConsumed += (data.usage.prompt_tokens || 0) + (data.usage.completion_tokens || 0);
+      }
+      if (typeof data.usage?.cost === "number" && data.usage.cost > 0) {
+        this.costTracker?.record({
+          source: "transcription",
+          model: this.config.geminiModel,
+          cost: data.usage.cost,
+          tokensIn: data.usage?.prompt_tokens || 0,
+          tokensOut: data.usage?.completion_tokens || 0,
+          ts: Date.now(),
+        });
+      }
+
       if (!text) {
         warn(TAG, `OpenRouter returned empty transcript (${elapsed}ms)`);
         return;
@@ -248,10 +267,6 @@ export class TranscriptionService extends EventEmitter {
 
       log(TAG, `transcript (${elapsed}ms): "${text.slice(0, 100)}${text.length > 100 ? "..." : ""}"`);
 
-      if (data.usage) {
-        this.totalTokensConsumed += (data.usage.prompt_tokens || 0) + (data.usage.completion_tokens || 0);
-      }
-
       const result: TranscriptResult = {
         text,
         source: "openrouter",

package/sinain-core/src/config.ts

@@ -252,6 +252,7 @@ export function loadConfig(): CoreConfig {
     situationMdPath,
     traceEnabled: boolEnv("TRACE_ENABLED", true),
     traceDir: resolvePath(env("TRACE_DIR", resolve(sinainDataDir(), "traces"))),
+    costDisplayEnabled: boolEnv("COST_DISPLAY_ENABLED", false),
     learningConfig,
     traitConfig,
     privacyConfig,

package/sinain-core/src/cost/tracker.ts

@@ -0,0 +1,64 @@
+import type { CostEntry, CostSnapshot } from "../types.js";
+import { log } from "../log.js";
+
+const TAG = "cost";
+
+export class CostTracker {
+  private totalCost = 0;
+  private costBySource = new Map<string, number>();
+  private costByModel = new Map<string, number>();
+  private callCount = 0;
+  private startedAt = Date.now();
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private onCostUpdate: (snapshot: CostSnapshot) => void;
+
+  constructor(onCostUpdate: (snapshot: CostSnapshot) => void) {
+    this.onCostUpdate = onCostUpdate;
+  }
+
+  record(entry: CostEntry): void {
+    if (entry.cost <= 0) return;
+    this.totalCost += entry.cost;
+    this.callCount++;
+    this.costBySource.set(
+      entry.source,
+      (this.costBySource.get(entry.source) || 0) + entry.cost,
+    );
+    this.costByModel.set(
+      entry.model,
+      (this.costByModel.get(entry.model) || 0) + entry.cost,
+    );
+    this.onCostUpdate(this.getSnapshot());
+  }
+
+  getSnapshot(): CostSnapshot {
+    return {
+      totalCost: this.totalCost,
+      costBySource: Object.fromEntries(this.costBySource),
+      costByModel: Object.fromEntries(this.costByModel),
+      callCount: this.callCount,
+      startedAt: this.startedAt,
+    };
+  }
+
+  startPeriodicLog(intervalMs: number): void {
+    this.timer = setInterval(() => {
+      if (this.callCount === 0) return;
+      const elapsed = ((Date.now() - this.startedAt) / 60_000).toFixed(1);
+      const sources = [...this.costBySource.entries()]
+        .map(([k, v]) => `${k}=$${v.toFixed(6)}`)
+        .join(" ");
+      const models = [...this.costByModel.entries()]
+        .map(([k, v]) => `${k}=$${v.toFixed(6)}`)
+        .join(" ");
+      log(TAG, `$${this.totalCost.toFixed(6)} total (${this.callCount} calls, ${elapsed} min) | ${sources} | ${models}`);
+    }, intervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}

package/sinain-core/src/index.ts

@@ -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";
@@ -58,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;
@@ -170,6 +175,7 @@ async function main() {
       return null;
     },
     feedbackStore: feedbackStore ?? undefined,
+    costTracker,
   });
 
   // ── Wire learning signal collector (needs agentLoop) ──
@@ -197,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) => {
@@ -308,6 +315,7 @@ async function main() {
     senseBuffer,
     wsHandler,
     profiler,
+    costTracker,
     feedbackStore: feedbackStore ?? undefined,
     isScreenActive: () => screenActive,
 
@@ -537,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";
@@ -142,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);

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;