@geravant/sinain 1.7.1 → 1.8.0

package/.env.example

@@ -20,6 +20,11 @@ SINAIN_CORE_URL=http://localhost:9500
 SINAIN_POLL_INTERVAL=5             # seconds between escalation polls
 SINAIN_HEARTBEAT_INTERVAL=900      # seconds between heartbeat ticks (15 min)
 SINAIN_WORKSPACE=~/.openclaw/workspace  # knowledge files, curation scripts, playbook
+# SINAIN_ALLOWED_TOOLS=mcp__sinain     # MCP tools auto-approved for bare agent
+SINAIN_AGENT_MAX_TURNS=5               # max tool-use turns for escalation responses
+SINAIN_SPAWN_MAX_TURNS=25              # max tool-use turns for spawn tasks (Shift+Enter)
+                                       # auto-derived from mcp-config.json if unset
+                                       # format: mcp__<server> (all) | mcp__<server>__<tool> (specific)
 
 # ── Escalation ───────────────────────────────────────────────────────────────
 ESCALATION_MODE=rich               # off | selective | focus | rich
@@ -27,7 +32,7 @@ ESCALATION_MODE=rich               # off | selective | focus | rich
                                    # selective: score-based (errors, questions trigger it)
                                    # focus: always escalate every tick
                                    # rich: always escalate with maximum context
-ESCALATION_COOLDOWN_MS=30000
+# ESCALATION_COOLDOWN_MS=10000
 # ESCALATION_TRANSPORT=auto        # ws | http | auto
                                    # auto = WS when gateway connected, HTTP fallback
                                    # http = bare agent only (no gateway)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Ambient intelligence that sees what you see, hears what you hear, and acts on your behalf",
   "type": "module",
   "bin": {

package/sinain-agent/run.sh

@@ -5,7 +5,9 @@ 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)
-if [ -f "$SCRIPT_DIR/.env" ]; then
+# Load project root .env (single config for all subsystems)
+ENV_FILE="$SCRIPT_DIR/../.env"
+if [ -f "$ENV_FILE" ]; then
   while IFS='=' read -r key val; do
     # Skip comments and blank lines
     [[ -z "$key" || "$key" =~ ^[[:space:]]*# ]] && continue
@@ -19,15 +21,17 @@ if [ -f "$SCRIPT_DIR/.env" ]; then
     if [ -z "${!key+x}" ]; then
       export "$key=$val"
     fi
-  done < "$SCRIPT_DIR/.env"
+  done < "$ENV_FILE"
 fi
 
 MCP_CONFIG="${MCP_CONFIG:-$SCRIPT_DIR/mcp-config.json}"
 CORE_URL="${SINAIN_CORE_URL:-http://localhost:9500}"
-POLL_INTERVAL="${SINAIN_POLL_INTERVAL:-5}"
+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.
@@ -64,10 +68,11 @@ 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 5 --output-format text \
+        --max-turns "$turns" --output-format text \
         -p "$prompt"
       ;;
     codex)
@@ -88,9 +93,10 @@ invoke_agent() {
       fi
       ;;
     goose)
+      local turns="${2:-$AGENT_MAX_TURNS}"
       GOOSE_MODE=auto goose run --text "$prompt" \
         --output-format text \
-        --max-turns 10
+        --max-turns "$turns"
       ;;
     aider)
       # No MCP support — signal pipe mode
@@ -265,8 +271,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. Summarize your findings concisely."
-      SPAWN_RESULT=$(invoke_agent "$SPAWN_PROMPT" || echo "ERROR: agent invocation failed")
+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")
     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,13 +56,12 @@ 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":"..."},"task":"..."}
+{"hud":"...","digest":"...","record":{"command":"start"|"stop","label":"..."}}
 
 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
@@ -70,24 +69,7 @@ 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
 
-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
+Do NOT set a "task" field — background tasks are spawned by user commands only.
 
 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.

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

@@ -75,6 +75,7 @@ export class AgentLoop extends EventEmitter {
   private running = false;
   private started = false;
   private firstTick = true;
+  private urgentPending = false;
 
   private lastPushedHud = "";
   private agentNextId = 1;
@@ -137,11 +138,12 @@ export class AgentLoop extends EventEmitter {
    * Called by sense POST handler and transcription callback.
    * Triggers debounced analysis.
    */
-  onNewContext(): void {
+  onNewContext(urgent = false): void {
     if (!this.started) return;
 
-    // Fast first tick: 500ms debounce on startup, normal debounce after
-    const delay = this.firstTick ? 500 : this.deps.agentConfig.debounceMs;
+    // Urgent: user command — minimal debounce, bypass cooldown
+    const delay = urgent ? 200 : this.firstTick ? 500 : this.deps.agentConfig.debounceMs;
+    if (urgent) this.urgentPending = true;
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
     this.debounceTimer = setTimeout(() => {
       this.debounceTimer = null;
@@ -235,8 +237,10 @@ export class AgentLoop extends EventEmitter {
     if (this.running) return;
     if (!this.deps.agentConfig.openrouterApiKey) return;
 
-    // Cooldown: don't re-analyze within cooldownMs of last run
-    if (Date.now() - this.lastRunTs < this.deps.agentConfig.cooldownMs) return;
+    // Cooldown: don't re-analyze within cooldownMs of last run (unless urgent)
+    const isUrgent = this.urgentPending;
+    this.urgentPending = false;
+    if (!isUrgent && Date.now() - this.lastRunTs < this.deps.agentConfig.cooldownMs) return;
 
     // Idle suppression: skip if no new events since last tick
     const { feedBuffer, senseBuffer } = this.deps;

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 sinain-core/.env first, then project root .env
+  // Try project root .env first, then sinain-core/.env fallback
   const candidates = [
-    resolve(__dirname, "..", ".env"),
     resolve(__dirname, "..", "..", ".env"),
+    resolve(__dirname, "..", ".env"),
   ];
   for (const envPath of candidates) {
     if (!existsSync(envPath)) continue;

package/sinain-core/src/escalation/escalator.ts

@@ -13,6 +13,14 @@ 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;
@@ -465,7 +473,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): Promise<void> {
+  async dispatchSpawnTask(task: string, label?: string, context?: SpawnContext): 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`);
@@ -485,9 +493,12 @@ ${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 = label ? ` (label: "${label}")` : "";
+    const labelStr = safeLabel ? ` (label: "${safeLabel}")` : "";
     const idemKey = `spawn-task-${Date.now()}`;
 
     // Generate a unique child session key — bypasses the main agent entirely
@@ -498,11 +509,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", label, startedAt);
+    this.broadcastTaskEvent(taskId, "spawned", safeLabel, startedAt);
 
     if (!this.wsClient.isConnected) {
       // No OpenClaw gateway — queue for bare agent HTTP polling
-      this.spawnHttpPending = { id: taskId, task, label: label || "background-task", ts: startedAt };
+      this.spawnHttpPending = { id: taskId, task, label: safeLabel || "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");
@@ -510,6 +521,10 @@ ${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.
@@ -520,11 +535,11 @@ ${recentLines.join("\n")}`;
         message: task,
         sessionKey: childSessionKey,
         lane: "subagent",
-        extraSystemPrompt: this.buildChildSystemPrompt(task, label),
+        extraSystemPrompt: this.buildChildSystemPrompt(context),
         deliver: false,
         idempotencyKey: idemKey,
-        label: label || undefined,
-      }, 45_000, { expectFinal: true });
+        label: safeLabel || undefined,
+      }, timeoutMs, { expectFinal: true });
 
       log(TAG, `spawn-task RPC response: ${JSON.stringify(result).slice(0, 500)}`);
       this.stats.totalSpawnResponses++;
@@ -536,15 +551,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(`${label || "Background task"}:\n${output}`);
-          this.broadcastTaskEvent(taskId, "completed", label, startedAt, output);
+          this.pushResponse(`${safeLabel || "Background task"}:\n${output}`);
+          this.broadcastTaskEvent(taskId, "completed", safeLabel, 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", label, startedAt,
+          this.broadcastTaskEvent(taskId, "completed", safeLabel, startedAt,
             historyText || "task completed (no output)");
           if (historyText) {
-            this.pushResponse(`${label || "Background task"}:\n${historyText}`);
+            this.pushResponse(`${safeLabel || "Background task"}:\n${historyText}`);
           }
         }
       } else {
@@ -552,10 +567,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(`${label || "Background task"}:\n${historyText}`);
-          this.broadcastTaskEvent(taskId, "completed", label, startedAt, historyText);
+          this.pushResponse(`${safeLabel || "Background task"}:\n${historyText}`);
+          this.broadcastTaskEvent(taskId, "completed", safeLabel, startedAt, historyText);
         } else {
-          this.broadcastTaskEvent(taskId, "completed", label, startedAt,
+          this.broadcastTaskEvent(taskId, "completed", safeLabel, startedAt,
             "task completed (no output captured)");
         }
       }
@@ -564,7 +579,7 @@ ${recentLines.join("\n")}`;
       this.pendingSpawnTasks.set(taskId, {
         runId,
         childSessionKey,
-        label,
+        label: safeLabel,
         startedAt,
         pollingEmitted: false,
       });
@@ -575,30 +590,43 @@ ${recentLines.join("\n")}`;
       savePendingTasks(this.pendingSpawnTasks);
     } catch (err: any) {
       error(TAG, `spawn-task failed: ${err.message}`);
-      this.broadcastTaskEvent(taskId, "failed", label, startedAt);
+      this.broadcastTaskEvent(taskId, "failed", safeLabel, startedAt);
     } finally {
       this.spawnInFlight = false;
     }
   }
 
-  /** 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.",
+  /** Build a context-rich system prompt for the child subagent. */
+  private buildChildSystemPrompt(context?: SpawnContext): string {
+    const parts = [
+      "# Background Agent",
       "",
-      "## Your Role",
-      `- Task: ${task.replace(/\s+/g, " ").trim().slice(0, 500)}`,
-      "- Complete this task. That's your entire purpose.",
+      "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.",
       "",
       "## Rules",
-      "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");
+      "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");
   }
 
   /** Fetch the latest assistant reply from a child session's chat history. */

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 } from "./escalation/escalator.js";
+import { Escalator, type SpawnContext } from "./escalation/escalator.js";
 import { Recorder } from "./recorder.js";
 import { Tracer } from "./trace/tracer.js";
 import { TraceStore } from "./trace/trace-store.js";
@@ -25,6 +25,41 @@ 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`;
@@ -65,6 +100,9 @@ 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();
 
@@ -108,35 +146,11 @@ async function main() {
     getRecorderStatus: () => recorder.getStatus(),
     profiler,
     onAnalysis: (entry, contextWindow) => {
-      // 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 = "";
-        }
+      // Handle recorder commands (recording start/stop still works)
+      recorder.handleCommand(entry.record);
 
-        if (task) {
-          escalator.dispatchSpawnTask(task, label).catch(err => {
-            error(TAG, "spawn task dispatch error:", err);
-          });
-        }
-      }
+      // Cache context for user-initiated spawn commands (Shift+Enter)
+      lastSpawnContext = buildSpawnContext(entry, feedBuffer, senseBuffer);
 
       // Escalation continues as normal
       escalator.onAgentAnalysis(entry, contextWindow);
@@ -433,7 +447,7 @@ async function main() {
 
     // Spawn background agent task (from HUD Shift+Enter or bare agent POST /spawn)
     onSpawnCommand: (text: string) => {
-      escalator.dispatchSpawnTask(text, "user-command").catch((err) => {
+      escalator.dispatchSpawnTask(text, text.slice(0, 64), lastSpawnContext ?? undefined).catch((err) => {
         log("srv", `spawn via HTTP failed: ${err}`);
       });
     },
@@ -457,9 +471,11 @@ async function main() {
     },
     onUserCommand: (text) => {
       escalator.setUserCommand(text);
+      // Trigger agent loop immediately for user commands (bypass debounce + cooldown)
+      agentLoop.onNewContext(true);
     },
     onSpawnCommand: (text) => {
-      escalator.dispatchSpawnTask(text, "user-command").catch((err) => {
+      escalator.dispatchSpawnTask(text, text.slice(0, 64), lastSpawnContext ?? undefined).catch((err) => {
         log("cmd", `spawn command failed: ${err}`);
         wsHandler.broadcast(`\u26a0 Spawn failed: ${String(err).slice(0, 100)}`, "normal");
       });

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

@@ -60,6 +60,15 @@ 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 {

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

@@ -199,6 +199,9 @@ 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-agent/.env.example

@@ -1,23 +0,0 @@
-# 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 *)