@geravant/sinain 1.8.0 → 1.9.0

package/sense_client/vision.py

@@ -18,6 +18,7 @@ import json
 import logging
 import os
 import time
+import uuid
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional
 
@@ -27,14 +28,23 @@ if TYPE_CHECKING:
 logger = logging.getLogger("sinain.vision")
 
 
+class VisionResult:
+    """Result of a vision call: text + optional cost info."""
+    __slots__ = ("text", "cost")
+
+    def __init__(self, text: Optional[str], cost: Optional[dict] = None):
+        self.text = text
+        self.cost = cost  # {cost, tokens_in, tokens_out, model, cost_id}
+
+
 class VisionProvider(ABC):
     """Abstract base for vision inference backends."""
 
     name: str = "unknown"
 
     @abstractmethod
-    def describe(self, image: "Image.Image", prompt: Optional[str] = None) -> Optional[str]:
-        """Describe image content. Returns None on failure."""
+    def describe(self, image: "Image.Image", prompt: Optional[str] = None) -> VisionResult:
+        """Describe image content. Returns VisionResult (text may be None on failure)."""
         ...
 
     @abstractmethod
@@ -53,8 +63,8 @@ class OllamaVisionProvider(VisionProvider):
                                      timeout=timeout, max_tokens=max_tokens)
         self.name = f"ollama ({model})"
 
-    def describe(self, image: "Image.Image", prompt: Optional[str] = None) -> Optional[str]:
-        return self._client.describe(image, prompt)
+    def describe(self, image: "Image.Image", prompt: Optional[str] = None) -> VisionResult:
+        return VisionResult(self._client.describe(image, prompt))
 
     def is_available(self) -> bool:
         return self._client.is_available()
@@ -73,9 +83,9 @@ class OpenRouterVisionProvider(VisionProvider):
         self._max_tokens = max_tokens
         self.name = f"openrouter ({model})"
 
-    def describe(self, image: "Image.Image", prompt: Optional[str] = None) -> Optional[str]:
+    def describe(self, image: "Image.Image", prompt: Optional[str] = None) -> VisionResult:
         if not self._api_key:
-            return None
+            return VisionResult(None)
 
         try:
             import requests
@@ -83,7 +93,7 @@ class OpenRouterVisionProvider(VisionProvider):
             # Encode image
             img_b64 = self._encode(image)
             if not img_b64:
-                return None
+                return VisionResult(None)
 
             prompt_text = prompt or "Describe what's on this screen concisely (2-3 sentences)."
 
@@ -112,13 +122,23 @@ class OpenRouterVisionProvider(VisionProvider):
             resp.raise_for_status()
             data = resp.json()
             content = data["choices"][0]["message"]["content"].strip()
-            logger.debug("openrouter vision: model=%s tokens=%s",
-                         self._model, data.get("usage", {}).get("total_tokens", "?"))
-            return content if content else None
+            usage = data.get("usage", {})
+            logger.debug("openrouter vision: model=%s tokens=%s cost=%s",
+                         self._model, usage.get("total_tokens", "?"), usage.get("cost", "?"))
+            cost_info = None
+            if usage.get("cost") is not None:
+                cost_info = {
+                    "cost": usage["cost"],
+                    "tokens_in": usage.get("prompt_tokens", 0),
+                    "tokens_out": usage.get("completion_tokens", 0),
+                    "model": self._model,
+                    "cost_id": uuid.uuid4().hex[:16],
+                }
+            return VisionResult(content if content else None, cost_info)
 
         except Exception as e:
             logger.debug("openrouter vision failed: %s", e)
-            return None
+            return VisionResult(None)
 
     def is_available(self) -> bool:
         return bool(self._api_key)

package/sinain-agent/.env.example

@@ -0,0 +1,23 @@
+# 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-agent/run.sh

@@ -5,9 +5,7 @@ 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)
-# Load project root .env (single config for all subsystems)
-ENV_FILE="$SCRIPT_DIR/../.env"
-if [ -f "$ENV_FILE" ]; then
+if [ -f "$SCRIPT_DIR/.env" ]; then
   while IFS='=' read -r key val; do
     # Skip comments and blank lines
     [[ -z "$key" || "$key" =~ ^[[:space:]]*# ]] && continue
@@ -21,7 +19,7 @@ if [ -f "$ENV_FILE" ]; then
     if [ -z "${!key+x}" ]; then
       export "$key=$val"
     fi
-  done < "$ENV_FILE"
+  done < "$SCRIPT_DIR/.env"
 fi
 
 MCP_CONFIG="${MCP_CONFIG:-$SCRIPT_DIR/mcp-config.json}"
@@ -30,8 +28,6 @@ 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.
@@ -68,16 +64,16 @@ 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 "$turns" --output-format text \
+        --max-turns 5 --output-format text \
         -p "$prompt"
       ;;
     codex)
       codex exec -s danger-full-access \
         --dangerously-bypass-approvals-and-sandbox \
+        --skip-git-repo-check \
         "$prompt"
       ;;
     junie)
@@ -93,10 +89,9 @@ invoke_agent() {
       fi
       ;;
     goose)
-      local turns="${2:-$AGENT_MAX_TURNS}"
       GOOSE_MODE=auto goose run --text "$prompt" \
         --output-format text \
-        --max-turns "$turns"
+        --max-turns 10
       ;;
     aider)
       # No MCP support — signal pipe mode
@@ -271,8 +266,8 @@ while true; do
       # MCP path: agent runs task with sinain tools available
       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. Use web search, file operations, and code execution as needed. Create end-to-end artifacts. Summarize your findings concisely."
-      SPAWN_RESULT=$(invoke_agent "$SPAWN_PROMPT" "$SPAWN_MAX_TURNS" || echo "ERROR: agent invocation failed")
+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")
     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

@@ -56,12 +56,13 @@ You produce outputs as JSON.
 Respond ONLY with valid JSON. No markdown, no code fences, no explanation.
 Your entire response must be parseable by JSON.parse().
 
-{"hud":"...","digest":"...","record":{"command":"start"|"stop","label":"..."}}
+{"hud":"...","digest":"...","record":{"command":"start"|"stop","label":"..."},"task":"..."}
 
 Output fields:
 - "hud" (required): max 60 words describing what user is doing NOW
 - "digest" (required): 5-8 sentences with detailed activity description
 - "record" (optional): control recording — {"command":"start","label":"Meeting name"} or {"command":"stop"}
+- "task" (optional): natural language instruction to spawn a background task
 
 When to use "record":
 - START when user begins a meeting, call, lecture, YouTube video, or important audio content
@@ -69,7 +70,24 @@ When to use "record":
 - Provide descriptive labels like "Team standup", "Client call", "YouTube: [video title from OCR]"
 - For YouTube/video content: extract video title from screen OCR for the label
 
-Do NOT set a "task" field — background tasks are spawned by user commands only.
+When to use "task":
+- User explicitly asks for research, lookup, or action
+- Something needs external search or processing that isn't a real-time response
+- Example: "Search for React 19 migration guide", "Find docs for this API"
+
+When to spawn "task" for video content:
+- If user watches a YouTube video for 2+ minutes AND no task has been spawned for this video yet, spawn: "Summarize YouTube video: [title or URL from OCR]"
+- ONLY spawn ONCE per video - do not repeat spawn for the same video in subsequent ticks
+- Extract video title or URL from screen OCR to include in the task
+
+When to spawn "task" for coding problems:
+- If user is actively working on a coding problem/challenge for 1+ minutes:
+  - Spawn: "Solve coding problem: [problem description/title from OCR]"
+- This includes LeetCode, HackerRank, interviews, coding assessments, or any visible coding challenge
+- Look for problem signals: "Input:", "Output:", "Example", "Constraints:", problem titles, test cases
+- Include as much context as possible from the screen OCR (problem description, examples, constraints)
+- ONLY spawn ONCE per distinct problem - do not repeat for the same problem
+- The spawned task should provide a complete solution with code and explanation
 
 Audio sources: [\ud83d\udd0a]=system/speaker audio, [\ud83c\udf99]=microphone (user's voice).
 Treat [\ud83c\udf99] as direct user speech. Treat [\ud83d\udd0a] as external audio.
@@ -324,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",
@@ -334,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]);
@@ -352,6 +373,7 @@ async function callModel(
               tokensOut: data.usage?.completion_tokens || 0,
               model,
               parsedOk: true,
+              cost: apiCost,
             };
           }
         } catch { /* fall through */ }
@@ -367,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

@@ -11,10 +11,10 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 export let loadedEnvPath: string | undefined;
 
 function loadDotEnv(): void {
-  // Try project root .env first, then sinain-core/.env fallback
+  // Try sinain-core/.env first, then project root .env
   const candidates = [
-    resolve(__dirname, "..", "..", ".env"),
     resolve(__dirname, "..", ".env"),
+    resolve(__dirname, "..", "..", ".env"),
   ];
   for (const envPath of candidates) {
     if (!existsSync(envPath)) continue;
@@ -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/escalation/escalator.ts

@@ -13,14 +13,6 @@ import { isCodingContext, buildEscalationMessage, fetchKnowledgeFacts } from "./
 import { loadPendingTasks, savePendingTasks, type PendingTaskEntry } from "../util/task-store.js";
 import { log, warn, error } from "../log.js";
 
-/** Context passed to spawn subagents so they can act on the user's current situation. */
-export interface SpawnContext {
-  currentApp?: string;
-  digest?: string;
-  recentAudio?: string;
-  recentScreen?: string;
-}
-
 export interface HttpPendingEscalation {
   id: string;
   message: string;
@@ -473,7 +465,7 @@ ${recentLines.join("\n")}`;
    * Creates a unique child session key and sends the task directly to the gateway
    * agent RPC — bypassing the main session to avoid dedup/NO_REPLY issues.
    */
-  async dispatchSpawnTask(task: string, label?: string, context?: SpawnContext): Promise<void> {
+  async dispatchSpawnTask(task: string, label?: string): Promise<void> {
     // Prevent sibling spawn RPCs from piling up (independent from escalation queue)
     if (this.spawnInFlight) {
       log(TAG, `spawn-task skipped — spawn RPC already in-flight`);
@@ -493,12 +485,9 @@ ${recentLines.join("\n")}`;
     this.lastSpawnFingerprint = fingerprint;
     this.lastSpawnTs = now;
 
-    // Truncate label to gateway's 64-char limit
-    const safeLabel = label?.slice(0, 64);
-
     const taskId = `spawn-${Date.now()}`;
     const startedAt = Date.now();
-    const labelStr = safeLabel ? ` (label: "${safeLabel}")` : "";
+    const labelStr = label ? ` (label: "${label}")` : "";
     const idemKey = `spawn-task-${Date.now()}`;
 
     // Generate a unique child session key — bypasses the main agent entirely
@@ -509,11 +498,11 @@ ${recentLines.join("\n")}`;
     log(TAG, `dispatching spawn-task${labelStr} → child=${childSessionKey}: "${task.slice(0, 80)}..."`);
 
     // ★ Broadcast "spawned" BEFORE the RPC — TSK tab shows ··· immediately
-    this.broadcastTaskEvent(taskId, "spawned", safeLabel, startedAt);
+    this.broadcastTaskEvent(taskId, "spawned", label, startedAt);
 
     if (!this.wsClient.isConnected) {
       // No OpenClaw gateway — queue for bare agent HTTP polling
-      this.spawnHttpPending = { id: taskId, task, label: safeLabel || "background-task", ts: startedAt };
+      this.spawnHttpPending = { id: taskId, task, label: label || "background-task", ts: startedAt };
       const preview = task.length > 60 ? task.slice(0, 60) + "…" : task;
       this.deps.feedBuffer.push(`🔧 Task queued for agent: ${preview}`, "normal", "system", "stream");
       this.deps.wsHandler.broadcast(`🔧 Task queued for agent: ${preview}`, "normal");
@@ -521,10 +510,6 @@ ${recentLines.join("\n")}`;
       return;
     }
 
-    // Dynamic timeout: scale with task length (long transcripts need more time)
-    // Base 30s + 1s per 200 chars, min 45s, max 180s
-    const timeoutMs = Math.min(180_000, Math.max(45_000, Math.ceil(task.length / 200) * 1000 + 30_000));
-
     // ★ Set spawnInFlight BEFORE first await — cleared in finally regardless of outcome.
     // Dedicated lane flag: never touches the escalation queue so regular escalations
     // continue unblocked while this spawn RPC is pending.
@@ -535,11 +520,11 @@ ${recentLines.join("\n")}`;
         message: task,
         sessionKey: childSessionKey,
         lane: "subagent",
-        extraSystemPrompt: this.buildChildSystemPrompt(context),
+        extraSystemPrompt: this.buildChildSystemPrompt(task, label),
         deliver: false,
         idempotencyKey: idemKey,
-        label: safeLabel || undefined,
-      }, timeoutMs, { expectFinal: true });
+        label: label || undefined,
+      }, 45_000, { expectFinal: true });
 
       log(TAG, `spawn-task RPC response: ${JSON.stringify(result).slice(0, 500)}`);
       this.stats.totalSpawnResponses++;
@@ -551,15 +536,15 @@ ${recentLines.join("\n")}`;
       if (Array.isArray(payloads) && payloads.length > 0) {
         const output = payloads.map((pl: any) => pl.text || "").join("\n").trim();
         if (output) {
-          this.pushResponse(`${safeLabel || "Background task"}:\n${output}`);
-          this.broadcastTaskEvent(taskId, "completed", safeLabel, startedAt, output);
+          this.pushResponse(`${label || "Background task"}:\n${output}`);
+          this.broadcastTaskEvent(taskId, "completed", label, startedAt, output);
         } else {
           log(TAG, `spawn-task: ${payloads.length} payloads but empty text, trying chat.history`);
           const historyText = await this.fetchChildResult(childSessionKey);
-          this.broadcastTaskEvent(taskId, "completed", safeLabel, startedAt,
+          this.broadcastTaskEvent(taskId, "completed", label, startedAt,
             historyText || "task completed (no output)");
           if (historyText) {
-            this.pushResponse(`${safeLabel || "Background task"}:\n${historyText}`);
+            this.pushResponse(`${label || "Background task"}:\n${historyText}`);
           }
         }
       } else {
@@ -567,10 +552,10 @@ ${recentLines.join("\n")}`;
         log(TAG, `spawn-task: no payloads, fetching chat.history for child=${childSessionKey}`);
         const historyText = await this.fetchChildResult(childSessionKey);
         if (historyText) {
-          this.pushResponse(`${safeLabel || "Background task"}:\n${historyText}`);
-          this.broadcastTaskEvent(taskId, "completed", safeLabel, startedAt, historyText);
+          this.pushResponse(`${label || "Background task"}:\n${historyText}`);
+          this.broadcastTaskEvent(taskId, "completed", label, startedAt, historyText);
         } else {
-          this.broadcastTaskEvent(taskId, "completed", safeLabel, startedAt,
+          this.broadcastTaskEvent(taskId, "completed", label, startedAt,
             "task completed (no output captured)");
         }
       }
@@ -579,7 +564,7 @@ ${recentLines.join("\n")}`;
       this.pendingSpawnTasks.set(taskId, {
         runId,
         childSessionKey,
-        label: safeLabel,
+        label,
         startedAt,
         pollingEmitted: false,
       });
@@ -590,43 +575,30 @@ ${recentLines.join("\n")}`;
       savePendingTasks(this.pendingSpawnTasks);
     } catch (err: any) {
       error(TAG, `spawn-task failed: ${err.message}`);
-      this.broadcastTaskEvent(taskId, "failed", safeLabel, startedAt);
+      this.broadcastTaskEvent(taskId, "failed", label, startedAt);
     } finally {
       this.spawnInFlight = false;
     }
   }
 
-  /** Build a context-rich system prompt for the child subagent. */
-  private buildChildSystemPrompt(context?: SpawnContext): string {
-    const parts = [
-      "# Background Agent",
+  /** Build a focused system prompt for the child subagent. */
+  private buildChildSystemPrompt(task: string, label?: string): string {
+    return [
+      "# Subagent Context",
+      "",
+      "You are a **subagent** spawned for a specific task.",
       "",
-      "You are a background agent spawned by the user to complete a specific task.",
-      "You have full tool access: file operations, web search, code execution.",
-      "Create end-to-end valuable artifacts — summaries, code files, emails, analysis docs.",
+      "## Your Role",
+      `- Task: ${task.replace(/\s+/g, " ").trim().slice(0, 500)}`,
+      "- Complete this task. That's your entire purpose.",
       "",
       "## Rules",
-      "1. Complete the task fully — actually do it, don't just describe what you'd do",
-      "2. Use your tools: search the web, write files, run code as needed",
-      "3. Your final message is shown in a small overlay — keep it concise (1-3 sentences + key links/paths)",
-      "4. For substantial output, write to a file and report the path",
-    ];
-
-    if (context?.currentApp || context?.digest) {
-      parts.push("", "## User Context");
-      if (context.currentApp) parts.push(`- Current app: ${context.currentApp}`);
-      if (context.digest) parts.push(`- Situation: ${context.digest.slice(0, 500)}`);
-    }
-
-    if (context?.recentScreen) {
-      parts.push("", "## Recent Screen (OCR, last ~60s)", context.recentScreen);
-    }
-
-    if (context?.recentAudio) {
-      parts.push("", "## Recent Audio (last ~60s)", context.recentAudio);
-    }
-
-    return parts.join("\n");
+      "1. Stay focused — do your assigned task, nothing else",
+      "2. Your final message will be reported to the requester",
+      "3. Be concise but informative",
+      "",
+      label ? `Label: ${label}` : "",
+    ].filter(Boolean).join("\n");
   }
 
   /** Fetch the latest assistant reply from a child session's chat history. */