@geravant/sinain 1.8.0 → 1.10.0

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

@@ -2,8 +2,9 @@ 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";
 import { analyzeContext } from "./analyzer.js";
 import { writeSituationMd } from "./situation-writer.js";
@@ -17,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. */
@@ -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 {
@@ -103,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;
     }
@@ -174,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. */
@@ -216,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
@@ -235,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;
@@ -317,6 +321,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 +390,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 +493,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

@@ -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));
@@ -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;
@@ -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),
   };
 
@@ -252,6 +255,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. */