@geravant/sinain 1.10.0 → 1.11.0

package/package.json

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

package/sinain-agent/CLAUDE.md

@@ -55,6 +55,56 @@ When responding to escalations:
 4. Optionally call `sinain_get_knowledge` to review the portable knowledge document
 5. Optionally call `sinain_get_feedback` to review recent escalation scores
 
+## Knowledge System
+
+Knowledge is stored in a **dual-database** architecture with two SQLite triplestore databases:
+
+| Database | Path | Written by |
+|----------|------|------------|
+| **Local** | `~/.sinain/memory/knowledge-graph.db` | `LocalCurationService` (session distillation on shutdown, periodic curation every 30 min) |
+| **Workspace** | `~/.openclaw/workspace/memory/knowledge-graph.db` | Heartbeat curation scripts (`sinain_heartbeat_tick`) |
+
+### Knowledge Tools
+
+| Tool | What it does |
+|------|-------------|
+| `sinain_get_knowledge` | Read the portable knowledge document (playbook + top facts) from workspace |
+| `sinain_knowledge_query` | Query facts by entity/keyword — queries **both** DBs via sinain-core API |
+| `sinain_distill_session` | Explicitly distill current session into knowledge updates |
+
+### HTTP Knowledge API (sinain-core, port 9500)
+
+These endpoints query **both** databases and merge results:
+
+| Endpoint | Purpose |
+|----------|---------|
+| `GET /knowledge` | Portable knowledge document |
+| `GET /knowledge/facts?entities=X&max=N` | Query facts by keyword tags |
+| `GET /knowledge/entities?max=N` | List all entities with attributes |
+| `GET /knowledge/export?domain=X&max=N` | Export facts as portable JSON |
+| `POST /knowledge/import` | Import facts (deduplicates automatically) |
+| `GET /knowledge/ui` | Web UI for browsing/managing knowledge |
+
+### How Knowledge Flows
+
+```
+Session (screen + audio) → LocalCurationService → Local DB
+                                                      ↓ (queried together)
+Heartbeat tick → curation scripts ──────────→ Workspace DB
+                                                      ↓
+Knowledge API (localhost:9500) ← merges both DBs ← queries
+```
+
+- **Local DB** gets real-time session knowledge (audio transcripts, screen patterns, German lessons, etc.)
+- **Workspace DB** gets heartbeat-curated knowledge (playbook patterns, feedback analysis)
+- The Knowledge API merges both — use `sinain_knowledge_query` for combined results
+- Facts have confidence decay (60-day half-life) — reinforcement resets the clock
+- Export/import via `/knowledge/export` → `/knowledge/import` enables cross-instance transfer
+
+### Using Knowledge in Escalation Responses
+
+When responding to escalations, call `sinain_knowledge_query` with relevant entities to enrich your response with long-term knowledge. Example: if the user is working on German grammar, query `sinain_knowledge_query(entities=["german", "grammar"])` to retrieve previously learned patterns.
+
 ## Spawning Background Tasks
 
 When an escalation suggests deeper research would help:

package/sinain-agent/run.sh

@@ -69,11 +69,22 @@ invoke_agent() {
   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 \
-        -p "$prompt"
+      if [ -n "${SINAIN_SPAWN:-}" ]; then
+        # Spawn: PreToolUse hook routes permission prompts to overlay HUD
+        claude \
+          --mcp-config "$MCP_CONFIG" \
+          --settings "$SCRIPT_DIR/.claude/settings.json" \
+          ${ALLOWED_TOOLS:+--allowedTools $ALLOWED_TOOLS} \
+          --max-turns "$turns" --output-format text \
+          -p "$prompt"
+      else
+        # Escalation: auto-approve for speed (short-lived, read-heavy)
+        claude --enable-auto-mode \
+          --mcp-config "$MCP_CONFIG" \
+          ${ALLOWED_TOOLS:+--allowedTools $ALLOWED_TOOLS} \
+          --max-turns "$turns" --output-format text \
+          -p "$prompt"
+      fi
       ;;
     codex)
       codex exec -s danger-full-access \
@@ -97,6 +108,8 @@ invoke_agent() {
       local turns="${2:-$AGENT_MAX_TURNS}"
       GOOSE_MODE=auto goose run --text "$prompt" \
         --output-format text \
+        --quiet \
+        --no-session \
         --max-turns "$turns"
       ;;
     aider)
@@ -186,6 +199,34 @@ if [ "$AGENT" = "codex" ]; then
   fi
 fi
 
+# Goose: auto-register sinain MCP server in config.yaml if not present
+if [ "$AGENT" = "goose" ]; then
+  TSX_BIN="$(cd "$SCRIPT_DIR/.." && pwd)/sinain-core/node_modules/.bin/tsx"
+  MCP_ENTRY="$(cd "$SCRIPT_DIR/.." && pwd)/sinain-mcp-server/index.ts"
+  GOOSE_CONFIG="${HOME}/.config/goose/config.yaml"
+  if [ -f "$GOOSE_CONFIG" ] && ! grep -q "sinain:" "$GOOSE_CONFIG" 2>/dev/null; then
+    echo "Registering sinain MCP server with goose..."
+    python3 -c "
+import yaml, os, sys
+config_path = sys.argv[1]
+with open(config_path) as f:
+    cfg = yaml.safe_load(f) or {}
+cfg.setdefault('extensions', {})['sinain'] = {
+    'name': 'Sinain MCP Server',
+    'cmd': sys.argv[2],
+    'args': [sys.argv[3]],
+    'enabled': True,
+    'envs': {'SINAIN_CORE_URL': sys.argv[4], 'SINAIN_WORKSPACE': sys.argv[5]},
+    'type': 'stdio',
+    'timeout': 300,
+}
+with open(config_path, 'w') as f:
+    yaml.dump(cfg, f, default_flow_style=False)
+print('  sinain extension added to ' + config_path)
+" "$GOOSE_CONFIG" "$TSX_BIN" "$MCP_ENTRY" "$CORE_URL" "$WORKSPACE"
+  fi
+fi
+
 # Agent mode label
 if agent_has_mcp; then
   AGENT_MODE="MCP"
@@ -221,15 +262,24 @@ Call sinain_get_escalation to see the full context, then call sinain_respond wit
 Response guidelines: 5-10 sentences, address errors first, reference specific screen/audio context, never NO_REPLY. Max 4000 chars for coding context, 3000 otherwise.'
 
 HEARTBEAT_PROMPT='You are the sinain HUD agent. Run the heartbeat cycle:
-1. Call sinain_heartbeat_tick with a brief session summary
-2. If the result contains a suggestion, post it to HUD via sinain_post_feed
-3. Call sinain_get_feedback to review recent scores'
+1. Call sinain_heartbeat_tick with a brief session summary (runs signal analysis, session distillation, knowledge integration, insight synthesis)
+2. If the result contains a suggestion or insight, post it to HUD via sinain_post_feed
+3. Call sinain_get_knowledge to review the merged knowledge document (draws from both local and workspace databases)
+4. Optionally call sinain_knowledge_query with relevant entities to check long-term knowledge state
+5. Call sinain_get_feedback to review recent escalation scores
+
+Knowledge context: sinain-core maintains two knowledge databases — local (session distillation) and workspace (heartbeat curation). The knowledge tools query both via the sinain-core API. Facts have confidence decay (60-day half-life).'
 
 # --- Main loop ---
 
 while true; do
   # Poll for pending escalation
   ESC=$(curl -sf "$CORE_URL/escalation/pending" 2>/dev/null || echo '{"ok":false}')
+  ESC_PAUSED=$(echo "$ESC" | python3 -c "import sys,json; d=json.load(sys.stdin); print('true' if d.get('paused') else '')" 2>/dev/null || true)
+  if [ -n "$ESC_PAUSED" ]; then
+    sleep 10  # Slow polling when paused
+    continue
+  fi
   ESC_ID=$(echo "$ESC" | python3 -c "import sys,json; d=json.load(sys.stdin); e=d.get('escalation'); print(e['id'] if e else '')" 2>/dev/null || true)
 
   if [ -n "$ESC_ID" ]; then
@@ -270,10 +320,23 @@ while true; do
 
     if agent_has_mcp; then
       # MCP path: agent runs task with sinain tools available
+      # Pre-fetch knowledge context so the spawn doesn't waste turns calling tools
+      SPAWN_KNOWLEDGE=$(curl -sf "$CORE_URL/knowledge" 2>/dev/null | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+k = d.get('knowledge', '')
+# Trim to 2000 chars to avoid prompt bloat
+print(k[:2000])
+" 2>/dev/null || true)
       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_KNOWLEDGE:+
+## Knowledge Context
+$SPAWN_KNOWLEDGE
+}
+Complete this task thoroughly. You also have sinain_get_knowledge and sinain_knowledge_query tools available for additional context. Summarize your findings concisely."
+      export SINAIN_SPAWN=1 SINAIN_SPAWN_TASK_ID="$SPAWN_ID"
       SPAWN_RESULT=$(invoke_agent "$SPAWN_PROMPT" "$SPAWN_MAX_TURNS" || echo "ERROR: agent invocation failed")
+      unset SINAIN_SPAWN SINAIN_SPAWN_TASK_ID
     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

@@ -53,13 +53,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
@@ -67,25 +66,6 @@ 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
-
 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.
 
@@ -95,7 +75,7 @@ Rules:
 - If nothing is happening, hud="Idle" and digest explains what was last seen.
 - Include specific filenames, URLs, error messages, UI text from OCR in digest.
 - Do NOT suggest actions in digest — just describe the situation factually.
-- Only include "record" or "task" when genuinely appropriate — most responses won't have them.
+- Only include "record" when genuinely appropriate — most responses won't have it.
 - CRITICAL: Output ONLY the JSON object, nothing else.`;
 
 /**
@@ -210,7 +190,6 @@ export async function analyzeContext(
   contextWindow: ContextWindow,
   config: AnalysisConfig,
   recorderStatus: RecorderStatus | null = null,
-  traitSystemPrompt?: string,
 ): Promise<AgentResult> {
   const userPrompt = buildUserPrompt(contextWindow, recorderStatus);
 
@@ -221,10 +200,8 @@ export async function analyzeContext(
     if (levelFor("screen_images", privacyDest) === "none") images = [];
   } catch { /* privacy not initialized, keep images */ }
 
-  const systemPrompt = traitSystemPrompt ?? SYSTEM_PROMPT;
-
   if (config.provider === "ollama") {
-    return await callOllama(systemPrompt, userPrompt, images, config);
+    return await callOllama(SYSTEM_PROMPT, userPrompt, images, config);
   }
 
   // OpenRouter path: model chain with fallbacks
@@ -241,7 +218,7 @@ export async function analyzeContext(
   let lastError: Error | null = null;
   for (const model of models) {
     try {
-      return await callOpenRouter(systemPrompt, userPrompt, images, model, config);
+      return await callOpenRouter(SYSTEM_PROMPT, userPrompt, images, model, config);
     } catch (err: any) {
       lastError = err;
       log(TAG, `model ${model} failed: ${err.message || err}, trying next...`);

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

@@ -10,8 +10,6 @@ import { analyzeContext } from "./analyzer.js";
 import { writeSituationMd } from "./situation-writer.js";
 import { calculateEscalationScore } from "../escalation/scorer.js";
 import { log, warn, error, debug } from "../log.js";
-import type { TraitEngine, TraitSelection } from "./traits.js";
-import { writeTraitLog } from "./traits.js";
 
 const TAG = "agent";
 
@@ -33,10 +31,6 @@ export interface AgentLoopDeps {
   profiler?: Profiler;
   /** Called after each successful SITUATION.md write with the content string. */
   onSituationUpdate?: (content: string) => void;
-  /** Optional trait engine for personality voice selection. */
-  traitEngine?: TraitEngine;
-  /** Directory to write per-day trait log JSONL files. */
-  traitLogDir?: string;
   /** Optional: path to sinain-knowledge.md for startup recap. */
   getKnowledgeDocPath?: () => string | null;
   /** Optional: feedback store for startup recap context. */
@@ -283,14 +277,6 @@ export class AgentLoop extends EventEmitter {
       traceCtx?.startSpan("llm-call");
       const recorderStatus = this.deps.getRecorderStatus?.() ?? null;
 
-      // Trait selection: pick the best personality voice for this tick
-      let traitSelection: TraitSelection | null = null;
-      if (this.deps.traitEngine?.enabled) {
-        const ocrText = contextWindow.screen.map(e => e.ocr ?? "").join(" ");
-        const audioText = contextWindow.audio.map(e => e.text).join(" ");
-        traitSelection = this.deps.traitEngine.selectTrait(ocrText, audioText);
-      }
-
       const result = await analyzeContext(contextWindow, this.deps.agentConfig, recorderStatus);
       this.deps.profiler?.timerRecord("agent.llmCall", result.latencyMs);
       traceCtx?.endSpan({ model: result.model, tokensIn: result.tokensIn, tokensOut: result.tokensOut, latencyMs: result.latencyMs });
@@ -346,11 +332,6 @@ export class AgentLoop extends EventEmitter {
           screenCount: contextWindow.screenCount,
         },
       };
-      if (traitSelection) {
-        entry.voice = traitSelection.trait.name;
-        entry.voice_stat = traitSelection.stat;
-        entry.voice_confidence = traitSelection.confidence;
-      }
       this.agentBuffer.push(entry);
       const historyLimit = this.deps.agentConfig.historyLimit || 50;
       if (this.agentBuffer.length > historyLimit) this.agentBuffer.shift();
@@ -362,17 +343,22 @@ export class AgentLoop extends EventEmitter {
         debug(TAG, `#${entry.id} (${latencyMs}ms) hud unchanged`);
       }
 
-      // Push HUD line to feed (suppress "—", "Idle", and all in focus mode)
+      // Always push HUD to feed buffer for data capture (curation pipeline reads this)
       if (this.deps.agentConfig.pushToFeed &&
-          this.deps.escalationMode !== "focus" &&
-          this.deps.escalationMode !== "rich" &&
           hud !== "\u2014" && hud !== "Idle" && hud !== this.lastPushedHud) {
         feedBuffer.push(`[\ud83e\udde0] ${hud}`, "normal", "agent", "stream");
-        this.deps.onHudUpdate(`[\ud83e\udde0] ${hud}`);
         this.lastPushedHud = hud;
         entry.pushed = true;
       }
 
+      // Broadcast to overlay only when NOT in focus/rich mode
+      // (in those modes, the overlay gets updates via escalation instead)
+      if (entry.pushed &&
+          this.deps.escalationMode !== "focus" &&
+          this.deps.escalationMode !== "rich") {
+        this.deps.onHudUpdate(`[\ud83e\udde0] ${hud}`);
+      }
+
       // Store digest
       this.latestDigest = entry;
 
@@ -380,7 +366,7 @@ export class AgentLoop extends EventEmitter {
       const escalationScore = calculateEscalationScore(digest, contextWindow);
 
       // Write SITUATION.md (enhanced with escalation context and recorder status)
-      const situationContent = writeSituationMd(this.deps.situationMdPath, contextWindow, digest, entry, escalationScore, recorderStatus, traitSelection);
+      const situationContent = writeSituationMd(this.deps.situationMdPath, contextWindow, digest, entry, escalationScore, recorderStatus);
       this.deps.onSituationUpdate?.(situationContent);
 
       // Notify for escalation check
@@ -406,22 +392,6 @@ export class AgentLoop extends EventEmitter {
         hudChanged: entry.pushed,
       });
 
-      // Fire-and-forget trait log
-      if (this.deps.traitEngine?.enabled && this.deps.traitLogDir) {
-        writeTraitLog(this.deps.traitLogDir, {
-          ts: new Date().toISOString(),
-          tickId: entry.id,
-          enabled: true,
-          voice: traitSelection?.trait.name ?? "none",
-          voice_stat: traitSelection?.stat ?? 0,
-          voice_confidence: traitSelection?.confidence ?? 0,
-          activation_scores: traitSelection?.allScores ?? {},
-          context_app: contextWindow.currentApp,
-          hud_length: entry.hud.length,
-          synthesis: false,
-        }).catch(() => {});
-      }
-
     } catch (err: any) {
       error(TAG, "tick error:", err.message || err);
       traceCtx?.endSpan({ status: "error", error: err.message });

package/sinain-core/src/agent/situation-writer.ts

@@ -2,7 +2,6 @@ import fs from "node:fs";
 import path from "node:path";
 import type { ContextWindow, AgentEntry, RecorderStatus } from "../types.js";
 import type { EscalationScore } from "../escalation/scorer.js";
-import type { TraitSelection } from "./traits.js";
 import { normalizeAppName } from "./context-window.js";
 import { log, error } from "../log.js";
 
@@ -46,7 +45,6 @@ export function writeSituationMd(
   entry: AgentEntry,
   escalationScore?: EscalationScore,
   recorderStatus?: RecorderStatus | null,
-  traitSelection?: TraitSelection | null,
 ): string {
   const dir = path.dirname(situationMdPath);
   const tmpPath = situationMdPath + ".tmp";
@@ -151,20 +149,6 @@ export function writeSituationMd(
     lines.push("");
   }
 
-  // Trait voice: frame downstream agent's perspective
-  if (traitSelection) {
-    const { trait, stat } = traitSelection;
-    const voiceFlavor = stat >= 7 ? trait.voice_high : stat <= 2 ? trait.voice_low : trait.description;
-    lines.push("## Active Voice");
-    lines.push("");
-    lines.push(`- Trait: ${trait.name} (stat ${stat}/10)`);
-    lines.push(`- Tagline: ${trait.tagline}`);
-    lines.push(`- Voice: "${voiceFlavor}"`);
-    lines.push("");
-    lines.push("> Frame your response through this lens naturally. Do not name the trait explicitly.");
-    lines.push("");
-  }
-
   lines.push("## Metadata");
   lines.push("");
   lines.push(`- Screen events in window: ${contextWindow.screenCount}`);

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, AnalysisConfig, EscalationConfig, OpenClawConfig, EscalationMode, EscalationTransport, LearningConfig, TraitConfig, PrivacyConfig, PrivacyMatrix, PrivacyLevel, PrivacyRow } from "./types.js";
+import type { CoreConfig, AudioPipelineConfig, TranscriptionConfig, AnalysisConfig, EscalationConfig, OpenClawConfig, EscalationMode, EscalationTransport, LearningConfig, PrivacyConfig, PrivacyMatrix, PrivacyLevel, PrivacyRow } from "./types.js";
 import { PRESETS } from "./privacy/presets.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -234,13 +234,6 @@ export function loadConfig(): CoreConfig {
     retentionDays: intEnv("FEEDBACK_RETENTION_DAYS", 30),
   };
 
-  const traitConfig: TraitConfig = {
-    enabled: boolEnv("TRAITS_ENABLED", false),
-    configPath: resolvePath(env("TRAITS_CONFIG", "~/.sinain/traits.json")),
-    entropyHigh: boolEnv("TRAIT_ENTROPY_HIGH", false),
-    logDir: resolvePath(env("TRAIT_LOG_DIR", "~/.sinain-core/traits")),
-  };
-
   const privacyConfig = loadPrivacyConfig();
 
   return {
@@ -257,7 +250,6 @@ export function loadConfig(): CoreConfig {
     traceDir: resolvePath(env("TRACE_DIR", resolve(sinainDataDir(), "traces"))),
     costDisplayEnabled: boolEnv("COST_DISPLAY_ENABLED", false),
     learningConfig,
-    traitConfig,
     privacyConfig,
   };
 }

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

@@ -520,11 +520,11 @@ ${recentLines.join("\n")}`;
         message: task,
         sessionKey: childSessionKey,
         lane: "subagent",
-        extraSystemPrompt: this.buildChildSystemPrompt(task, label),
+        extraSystemPrompt: await this.buildChildSystemPrompt(task, label),
         deliver: false,
         idempotencyKey: idemKey,
         label: label || undefined,
-      }, 45_000, { expectFinal: true });
+      }, 10 * 60_000, { expectFinal: true });
 
       log(TAG, `spawn-task RPC response: ${JSON.stringify(result).slice(0, 500)}`);
       this.stats.totalSpawnResponses++;
@@ -581,8 +581,44 @@ ${recentLines.join("\n")}`;
     }
   }
 
-  /** Build a focused system prompt for the child subagent. */
-  private buildChildSystemPrompt(task: string, label?: string): string {
+  /** Build a focused system prompt for the child subagent, enriched with knowledge. */
+  private async buildChildSystemPrompt(task: string, label?: string): Promise<string> {
+    // Fetch relevant knowledge facts (same enrichment as escalations)
+    let knowledgeSection = "";
+    if (this.deps.queryKnowledgeFacts) {
+      try {
+        const entities: string[] = [];
+        // Extract keywords from task text for entity matching
+        const techKeywords = [
+          "react-native", "react", "flutter", "swift", "kotlin", "python",
+          "typescript", "node", "docker", "sinain", "openclaw", "overlay",
+          "sense", "audio", "transcription", "escalation", "knowledge",
+        ];
+        const lower = task.toLowerCase();
+        for (const kw of techKeywords) {
+          if (lower.includes(kw)) entities.push(kw);
+        }
+        // Also extract capitalized proper nouns (file names, project names)
+        const nouns = task.match(/\b[A-Z][a-z]{2,}\b/g);
+        if (nouns) entities.push(...nouns.map(n => n.toLowerCase()).slice(0, 3));
+
+        if (entities.length > 0) {
+          const facts = await this.deps.queryKnowledgeFacts(entities.slice(0, 5), 5);
+          if (facts && facts.trim().length > 20) {
+            knowledgeSection = `\n## Relevant Knowledge\n${facts.trim()}`;
+          }
+        }
+      } catch (err) {
+        log(TAG, `spawn knowledge enrichment failed: ${String(err)}`);
+      }
+    }
+
+    // Include latest digest for screen/audio context
+    const latestDigest = this.deps.feedBuffer.latest()?.text;
+    const contextSection = latestDigest
+      ? `\n## Current User Context\n${latestDigest.slice(0, 500)}`
+      : "";
+
     return [
       "# Subagent Context",
       "",
@@ -596,8 +632,9 @@ ${recentLines.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}` : "",
+      label ? `\nLabel: ${label}` : "",
+      knowledgeSection,
+      contextSection,
     ].filter(Boolean).join("\n");
   }
 
@@ -633,19 +670,9 @@ ${recentLines.join("\n")}`;
       return;
     }
 
-    const maxWaitMs = 5 * 60 * 1000; // 5 minutes
     const pollIntervalMs = 5000; // 5 seconds
 
     const poll = async (): Promise<void> => {
-      const elapsed = Date.now() - task.startedAt;
-      if (elapsed > maxWaitMs) {
-        log(TAG, `spawn-task timeout: taskId=${taskId}`);
-        this.broadcastTaskEvent(taskId, "timeout", task.label, task.startedAt);
-        this.pendingSpawnTasks.delete(taskId);
-        savePendingTasks(this.pendingSpawnTasks);
-        this.finishPoll();
-        return;
-      }
 
       if (!this.wsClient.isConnected) {
         // Retry later