@geravant/sinain 1.10.1 → 1.12.0

package/sinain-core/src/escalation/message-builder.ts

@@ -1,4 +1,4 @@
-import type { ContextWindow, AgentEntry, EscalationMode, FeedbackRecord, UserCommand } from "../types.js";
+import type { ContextWindow, AgentEntry, EscalationMode, FeedbackRecord, UserCommand, ResponseSize } from "../types.js";
 import { normalizeAppName } from "../agent/context-window.js";
 import { levelFor, applyLevel } from "../privacy/index.js";
 
@@ -67,11 +67,18 @@ export function isCodingContext(context: ContextWindow): CodingContextResult {
   };
 }
 
-function getInstructions(mode: EscalationMode, context: ContextWindow): string {
+function sizeInstruction(size: ResponseSize): string {
+  switch (size) {
+    case "small": return "1-2 sentences";
+    case "large": return "3-5 sentences";
+    default: return "2-3 sentences";
+  }
+}
+
+function getInstructions(context: ContextWindow): string {
   const { coding, needsSolution } = isCodingContext(context);
 
   if (needsSolution) {
-    // Coding challenge/problem - be very action-oriented
     return `The user is working on a coding problem. Be PROACTIVE and SOLVE IT:
 
 1. Provide a solution approach and working code based on what you can see
@@ -92,13 +99,10 @@ Response should be actionable: working code with brief explanation.`;
 - If it's a non-code file (config, markdown, email): share a relevant insight, action item, or connection to their current project
 - If context is minimal: tell a short clever joke (tech humor — never repeat recent ones)
 
-NEVER just describe what the user is doing. Every response must teach, suggest, or connect dots.
-(2-5 sentences, or more + code if there's an error or code question).`;
+NEVER just describe what the user is doing. Every response must teach, suggest, or connect dots.`;
   }
 
-  // Non-coding context — proactive insights instead of activity descriptions
-  if (mode === "focus" || mode === "rich") {
-    return `Based on the above, ALWAYS provide a useful response for the user's HUD.
+  return `Based on the above, ALWAYS provide a useful response for the user's HUD.
 Important: Do NOT respond with NO_REPLY — a response is always required.
 
 - If there's an error: investigate and suggest a fix
@@ -109,40 +113,25 @@ Important: Do NOT respond with NO_REPLY — a response is always required.
 
 NEVER just describe what the user is doing — they can see their own screen.
 NEVER respond with "standing by", "monitoring", or similar filler.
-Every response must teach something, suggest something, or connect dots the user hasn't noticed.
-(2-5 sentences). Be specific and actionable.`;
-  }
-
-  return `Based on the above, proactively help the user:
-- If there's an error: investigate and suggest a fix
-- If they seem stuck: offer guidance
-- If they're coding: provide relevant insights
-- Keep your response concise and actionable (2-5 sentences)`;
+Every response must teach something, suggest something, or connect dots the user hasn't noticed.`;
 }
 
 /**
- * Build a structured escalation message with richness proportional to the context window preset.
- *
- * Expected message sizes:
- *   lean (selective):  ~7 KB  / ~1,700 tokens
- *   standard (focus):  ~25 KB / ~6,000 tokens
- *   rich:              ~111 KB / ~28,000 tokens
+ * Build a structured escalation message with full context (rich mode).
  *
- * All fit within the 256 KB HTTP hooks limit and 200K+ model context.
- *
- * In selective mode, sections are prioritized by relevance:
- * - Error escalations prioritize error sections
- * - Question escalations prioritize audio sections
- * - App context is always included
+ * Always includes all sections (screen, audio, errors).
+ * Response length is controlled by the `responseSize` parameter (small/medium/large)
+ * which is set by the user via the HUD overlay slider.
  */
 export function buildEscalationMessage(
   digest: string,
   context: ContextWindow,
   entry: AgentEntry,
-  mode: EscalationMode,
+  _mode: EscalationMode,
   escalationReason?: string,
   recentFeedback?: FeedbackRecord[],
   userCommand?: UserCommand,
+  responseSize: ResponseSize = "medium",
 ): string {
   const sections: string[] = [];
 
@@ -167,7 +156,6 @@ export function buildEscalationMessage(
   // Errors — extracted from OCR, full stack traces in rich mode
   const errors = context.screen.filter(e => hasErrorPattern(e.ocr));
   const hasErrors = errors.length > 0;
-  const hasQuestion = escalationReason?.startsWith("question:");
 
   // Privacy levels for agent_gateway destination
   let ocrLevel: import("../types.js").PrivacyLevel = "full";
@@ -183,99 +171,35 @@ export function buildEscalationMessage(
   const applyAudio = (text: string) => applyLevel(text.slice(0, context.preset.maxTranscriptChars), audioLevel, "audio");
   const applyTitle = (title: string | undefined) => title ? applyLevel(title, titlesLevel, "titles") : "";
 
-  // In selective mode, prioritize sections based on escalation reason
-  // In focus/rich modes, include everything
-  if (mode === "selective") {
-    // Error-triggered: prioritize errors, then screen
-    if (hasErrors) {
-      sections.push("## Errors (high priority)");
-      for (const e of errors) {
-        sections.push(`\`\`\`\n${applyOcr(e.ocr)}\n\`\`\``);
-      }
-      // Include screen context (reduced)
-      if (context.screen.length > 0) {
-        sections.push("## Screen (recent OCR)");
-        for (const e of context.screen.slice(0, 5)) { // Limit in selective mode
-          const ago = Math.round((Date.now() - e.ts) / 1000);
-          const app = normalizeAppName(e.meta.app);
-          const title = applyTitle(e.meta.windowTitle);
-          const titlePart = title ? ` [${title}]` : "";
-          sections.push(`- [${ago}s ago] [${app}]${titlePart} ${applyOcr(e.ocr)}`);
-        }
-      }
-    }
-    // Question-triggered: prioritize audio, then screen
-    else if (hasQuestion) {
-      if (context.audio.length > 0) {
-        sections.push("## Audio (recent transcripts)");
-        for (const e of context.audio) {
-          const ago = Math.round((Date.now() - e.ts) / 1000);
-          sections.push(`- [${ago}s ago] "${applyAudio(e.text)}"`);
-        }
-      }
-      // Include screen context (reduced)
-      if (context.screen.length > 0) {
-        sections.push("## Screen (recent OCR)");
-        for (const e of context.screen.slice(0, 5)) {
-          const ago = Math.round((Date.now() - e.ts) / 1000);
-          const app = normalizeAppName(e.meta.app);
-          const title = applyTitle(e.meta.windowTitle);
-          const titlePart = title ? ` [${title}]` : "";
-          sections.push(`- [${ago}s ago] [${app}]${titlePart} ${applyOcr(e.ocr)}`);
-        }
-      }
-    }
-    // Other triggers: balanced sections
-    else {
-      if (context.screen.length > 0) {
-        sections.push("## Screen (recent OCR)");
-        for (const e of context.screen) {
-          const ago = Math.round((Date.now() - e.ts) / 1000);
-          const app = normalizeAppName(e.meta.app);
-          const title = applyTitle(e.meta.windowTitle);
-          const titlePart = title ? ` [${title}]` : "";
-          sections.push(`- [${ago}s ago] [${app}]${titlePart} ${applyOcr(e.ocr)}`);
-        }
-      }
-      if (context.audio.length > 0) {
-        sections.push("## Audio (recent transcripts)");
-        for (const e of context.audio) {
-          const ago = Math.round((Date.now() - e.ts) / 1000);
-          sections.push(`- [${ago}s ago] "${applyAudio(e.text)}"`);
-        }
-      }
-    }
-  } else {
-    // Focus/rich mode: include all sections
-    if (hasErrors) {
-      sections.push("## Errors (high priority)");
-      for (const e of errors) {
-        sections.push(`\`\`\`\n${applyOcr(e.ocr)}\n\`\`\``);
-      }
+  // Always include all sections (rich mode)
+  if (hasErrors) {
+    sections.push("## Errors (high priority)");
+    for (const e of errors) {
+      sections.push(`\`\`\`\n${applyOcr(e.ocr)}\n\`\`\``);
     }
+  }
 
-    if (context.screen.length > 0) {
-      sections.push("## Screen (recent OCR)");
-      for (const e of context.screen) {
-        const ago = Math.round((Date.now() - e.ts) / 1000);
-        const app = normalizeAppName(e.meta.app);
-        const title = applyTitle(e.meta.windowTitle);
-        const titlePart = title ? ` [${title}]` : "";
-        sections.push(`- [${ago}s ago] [${app}]${titlePart} ${applyOcr(e.ocr)}`);
-      }
+  if (context.screen.length > 0) {
+    sections.push("## Screen (recent OCR)");
+    for (const e of context.screen) {
+      const ago = Math.round((Date.now() - e.ts) / 1000);
+      const app = normalizeAppName(e.meta.app);
+      const title = applyTitle(e.meta.windowTitle);
+      const titlePart = title ? ` [${title}]` : "";
+      sections.push(`- [${ago}s ago] [${app}]${titlePart} ${applyOcr(e.ocr)}`);
     }
+  }
 
-    if (context.audio.length > 0) {
-      sections.push("## Audio (recent transcripts)");
-      for (const e of context.audio) {
-        const ago = Math.round((Date.now() - e.ts) / 1000);
-        sections.push(`- [${ago}s ago] "${applyAudio(e.text)}"`);
-      }
+  if (context.audio.length > 0) {
+    sections.push("## Audio (recent transcripts)");
+    for (const e of context.audio) {
+      const ago = Math.round((Date.now() - e.ts) / 1000);
+      sections.push(`- [${ago}s ago] "${applyAudio(e.text)}"`);
     }
   }
 
-  // Mode-specific instructions (now context-aware)
-  sections.push(getInstructions(mode, context));
+  // Context-aware instructions (no size — that's in the response length section below)
+  sections.push(getInstructions(context));
 
   // Stale escalation hint — forces a proactive response after prolonged silence
   if (escalationReason === "stale") {
@@ -293,7 +217,10 @@ the local analyzer reported idle/no-change. Provide a PROACTIVE response:
     sections.push(formatInlineFeedback(recentFeedback));
   }
 
-  sections.push("Respond naturally — this will appear on the user's HUD overlay.");
+  // Response length — single authoritative size instruction, placed last for salience
+  const limit = sizeInstruction(responseSize);
+  sections.push(`## Response Length
+Your response MUST be ${limit}. This appears on the user's HUD overlay — be specific and actionable.`);
 
   return sections.join("\n\n");
 }

package/sinain-core/src/index.ts

@@ -8,7 +8,6 @@ import { AudioPipeline } from "./audio/pipeline.js";
 import type { CaptureSpawner } from "./audio/capture-spawner.js";
 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 { Recorder } from "./recorder.js";
@@ -344,10 +343,6 @@ async function main() {
   localCuration.distillPendingSession(); // Recover any session saved before a force-kill
   localCuration.startPeriodicCuration();
 
-  // ── Initialize trait engine ──
-  const traitRoster = loadTraitRoster(config.traitConfig.configPath);
-  const traitEngine = new TraitEngine(traitRoster, config.traitConfig);
-
   // ── Initialize escalation ──
   const escalator = new Escalator({
     feedBuffer,
@@ -372,33 +367,6 @@ async function main() {
       // 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 = "";
-        }
-
-        if (task) {
-          escalator.dispatchSpawnTask(task, label).catch(err => {
-            error(TAG, "spawn task dispatch error:", err);
-          });
-        }
-      }
-
       // Escalation continues as normal
       escalator.onAgentAnalysis(entry, contextWindow);
     },
@@ -422,8 +390,6 @@ async function main() {
       };
       return ctx;
     } : undefined,
-    traitEngine,
-    traitLogDir: config.traitConfig.logDir,
     getKnowledgeDocPath: () => {
       const workspace = resolveWorkspace();
       const p = `${workspace}/memory/sinain-knowledge.md`;
@@ -564,6 +530,9 @@ async function main() {
   // ── Screen capture active flag ──
   let screenActive = true;
 
+  // ── Escalation pause/resume state ──
+  let savedEscalationMode: typeof config.escalationConfig.mode | null = null;
+
   // ── Create HTTP + WS server ──
   const server = createAppServer({
     config,
@@ -674,6 +643,7 @@ async function main() {
 
     // Bare agent HTTP escalation bridge
     getEscalationPending: () => escalator.getPendingHttp(),
+    isEscalationPaused: () => savedEscalationMode !== null,
     respondEscalation: (id: string, response: string) => escalator.respondHttp(id, response),
 
     // Knowledge graph integration (checks both local and workspace DBs)
@@ -733,7 +703,22 @@ async function main() {
       wsHandler.updateState({ screen: screenActive ? "active" : "off" });
       return screenActive;
     },
-    onToggleTraits: () => traitEngine.toggle(),
+    onToggleEscalation: () => {
+      if (savedEscalationMode === null) {
+        // Pause: save current mode, switch to off
+        savedEscalationMode = config.escalationConfig.mode;
+        escalator.setMode("off");
+        log(TAG, `escalation paused (was: ${savedEscalationMode})`);
+        return false;
+      } else {
+        // Resume: restore saved mode
+        const mode = savedEscalationMode;
+        savedEscalationMode = null;
+        escalator.setMode(mode);
+        log(TAG, `escalation resumed (mode: ${mode})`);
+        return true;
+      }
+    },
   });
 
   // Broadcast initial screen state so overlay gets correct status on connect
@@ -795,7 +780,6 @@ async function main() {
   log(TAG, `  mic:     ${config.micEnabled ? (config.micConfig.autoStart ? "active" : "standby") : "disabled"}`);
   log(TAG, `  agent:   ${config.agentConfig.enabled ? "enabled" : "disabled"}`);
   log(TAG, `  escal:   ${config.escalationConfig.mode}`);
-  log(TAG, `  traits:  ${config.traitConfig.enabled ? "enabled" : "disabled"} (${traitRoster.length} traits)`);
   log(TAG, `  cost:    display=${config.costDisplayEnabled ? "on" : "off"} (always logged)`);
 
   // ── Graceful shutdown ──

package/sinain-core/src/learning/local-curation.ts

@@ -95,7 +95,7 @@ export class LocalCurationService {
    * Called during shutdown — instant (no LLM), survives tsx force-kill.
    */
   savePendingSession(feedItems: FeedItem[]): void {
-    if (feedItems.length < 3) {
+    if (feedItems.length < 1) {
       log(TAG, `skipping save — only ${feedItems.length} feed items`);
       return;
     }
@@ -135,7 +135,7 @@ export class LocalCurationService {
     }
 
     const items: FeedItem[] = data.items || [];
-    if (items.length < 3) {
+    if (items.length < 1) {
       log(TAG, `pending session too small (${items.length} items) — removing`);
       unlinkSync(pendingPath);
       return;
@@ -160,7 +160,7 @@ export class LocalCurationService {
    * picked up on next startup via distillPendingSession().
    */
   async distillSession(feedItems: FeedItem[]): Promise<void> {
-    if (feedItems.length < 3) {
+    if (feedItems.length < 1) {
       log(TAG, `skipping distillation — only ${feedItems.length} feed items`);
       return;
     }
@@ -332,7 +332,7 @@ export class LocalCurationService {
 
   /** Fallback: write raw feed summary when distillation fails. */
   private writeDailyNotesFallback(feedItems: FeedItem[]): void {
-    if (feedItems.length < 3) return;
+    if (feedItems.length < 1) return;
 
     const date = new Date().toISOString().slice(0, 10);
     const notesPath = resolve(this.memoryDir, `${date}.md`);

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

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import type { InboundMessage } from "../types.js";
+import type { InboundMessage, ResponseSize } from "../types.js";
 import type { WsHandler } from "./ws-handler.js";
 import type { AudioPipeline } from "../audio/pipeline.js";
 import type { CoreConfig } from "../types.js";
@@ -21,8 +21,8 @@ export interface CommandDeps {
   onSpawnCommand?: (text: string) => void;
   /** Toggle screen capture — returns new state */
   onToggleScreen: () => boolean;
-  /** Toggle trait voices — returns new enabled state */
-  onToggleTraits?: () => boolean;
+  /** Toggle escalation pause/resume — returns true if now active */
+  onToggleEscalation: () => boolean;
 }
 
 /**
@@ -79,8 +79,29 @@ export function setupCommands(deps: CommandDeps): void {
         }
         break;
       }
+      case "spawn_reply": {
+        const { taskId, text } = msg as any;
+        log(TAG, `spawn reply for ${taskId}: "${(text || "").slice(0, 60)}"`);
+        // Forward to the /spawn/reply HTTP endpoint internally
+        fetch(`http://localhost:${deps.config.port}/spawn/reply`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ taskId, text }),
+        }).catch(() => {});
+        break;
+      }
+      case "spawn_permission_reply": {
+        const { taskId, decision } = msg as any;
+        log(TAG, `spawn permission reply for ${taskId}: ${decision}`);
+        fetch(`http://localhost:${deps.config.port}/spawn/permission-reply`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ taskId, decision }),
+        }).catch(() => {});
+        break;
+      }
       case "command": {
-        handleCommand(msg.action, deps);
+        handleCommand(msg, deps);
         log(TAG, `command processed: ${msg.action}`);
         break;
       }
@@ -88,8 +109,11 @@ export function setupCommands(deps: CommandDeps): void {
   });
 }
 
-function handleCommand(action: string, deps: CommandDeps): void {
+const VALID_RESPONSE_SIZES = new Set<ResponseSize>(["small", "medium", "large"]);
+
+function handleCommand(msg: InboundMessage & { action: string }, deps: CommandDeps): void {
   const { wsHandler, systemAudioPipeline, micPipeline } = deps;
+  const action = msg.action;
 
   switch (action) {
     case "toggle_audio": {
@@ -142,15 +166,24 @@ function handleCommand(action: string, deps: CommandDeps): void {
       log(TAG, `screen toggled ${nowActive ? "ON" : "OFF"}`);
       break;
     }
-    case "toggle_traits": {
-      if (!deps.onToggleTraits) {
-        wsHandler.broadcast("Trait voices not configured", "normal");
-        break;
+    case "toggle_escalation": {
+      const nowActive = deps.onToggleEscalation();
+      wsHandler.updateState({ escalation: nowActive ? "active" : "paused" });
+      wsHandler.broadcast(
+        nowActive ? "Escalations resumed" : "Escalations paused — context still accumulating",
+        "normal"
+      );
+      log(TAG, `escalation toggled ${nowActive ? "ON" : "OFF"}`);
+      break;
+    }
+    case "set_response_size": {
+      const size = (msg as any).responseSize as string;
+      if (VALID_RESPONSE_SIZES.has(size as ResponseSize)) {
+        wsHandler.updateState({ responseSize: size as ResponseSize });
+        log(TAG, `response size set to ${size}`);
+      } else {
+        log(TAG, `invalid response size: ${size}`);
       }
-      const nowEnabled = deps.onToggleTraits();
-      wsHandler.updateState({ traits: nowEnabled ? "active" : "off" });
-      wsHandler.broadcast(`Trait voices ${nowEnabled ? "on" : "off"}`, "normal");
-      log(TAG, `traits toggled ${nowEnabled ? "ON" : "OFF"}`);
       break;
     }
     case "open_settings": {

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

@@ -37,7 +37,9 @@ export class WsHandler {
     audio: "muted",
     mic: "muted",
     screen: "off",
+    escalation: "active",
     connection: "disconnected",
+    responseSize: "medium",
   };
   private replayBuffer: FeedMessage[] = [];
   private spawnTaskBuffer: Map<string, SpawnTaskMessage> = new Map();
@@ -72,7 +74,9 @@ export class WsHandler {
       audio: this.state.audio,
       mic: this.state.mic,
       screen: this.state.screen,
+      escalation: this.state.escalation,
       connection: this.state.connection,
+      responseSize: this.state.responseSize,
     });
 
     // Replay recent feed messages for late-joining clients
@@ -149,12 +153,14 @@ export class WsHandler {
 
   /** Send a status update to all connected overlays. */
   broadcastStatus(): void {
-    const msg: StatusMessage & { envPath?: string } = {
+    const msg: StatusMessage & { envPath?: string; escalation?: string; responseSize?: string } = {
       type: "status",
       audio: this.state.audio,
       mic: this.state.mic,
       screen: this.state.screen,
+      escalation: this.state.escalation,
       connection: this.state.connection,
+      responseSize: this.state.responseSize,
     };
     if (loadedEnvPath) msg.envPath = loadedEnvPath;
     this.broadcastMessage(msg);
@@ -229,6 +235,12 @@ export class WsHandler {
       case "spawn_command":
         log(TAG, `\u2190 spawn command: ${msg.text.slice(0, 100)}`);
         break;
+      case "spawn_reply":
+        log(TAG, `\u2190 spawn reply: taskId=${(msg as any).taskId}`);
+        break;
+      case "spawn_permission_reply":
+        log(TAG, `\u2190 spawn permission reply: taskId=${(msg as any).taskId} decision=${(msg as any).decision}`);
+        break;
       case "profiling":
         if (this.onProfilingCb) this.onProfilingCb(msg);
         return;

package/sinain-core/src/server.ts

@@ -174,6 +174,7 @@ export interface ServerDeps {
   feedbackStore?: FeedbackStore;
   setUserCommand?: (text: string) => void;
   getEscalationPending?: () => any;
+  isEscalationPaused?: () => boolean;
   respondEscalation?: (id: string, response: string) => any;
   getKnowledgeDocPath?: () => string | null;
   queryKnowledgeFacts?: (entities: string[], maxFacts: number) => Promise<string>;
@@ -203,6 +204,9 @@ function readBody(req: IncomingMessage, maxBytes: number): Promise<string> {
   });
 }
 
+/** Pending spawn questions/permissions — resolve callbacks keyed by "ask:{taskId}" or "perm:{taskId}" */
+const pendingSpawnQuestions = new Map<string, (answer: string) => void>();
+
 export function createAppServer(deps: ServerDeps) {
   const { config, feedBuffer, senseBuffer, wsHandler } = deps;
   let senseInBytes = 0;
@@ -562,6 +566,11 @@ export function createAppServer(deps: ServerDeps) {
 
       // ── /escalation/pending ──
       if (req.method === "GET" && url.pathname === "/escalation/pending") {
+        const paused = deps.isEscalationPaused?.() ?? false;
+        if (paused) {
+          res.end(JSON.stringify({ ok: true, escalation: null, paused: true }));
+          return;
+        }
         const pending = deps.getEscalationPending?.();
         res.end(JSON.stringify({ ok: true, escalation: pending ?? null }));
         return;
@@ -620,6 +629,118 @@ export function createAppServer(deps: ServerDeps) {
         return;
       }
 
+      // ── /spawn/ask (MCP tool posts question, blocks until user replies) ──
+      if (req.method === "POST" && url.pathname === "/spawn/ask") {
+        const body = await readBody(req, 8192);
+        const { taskId, question } = JSON.parse(body);
+        if (!taskId || !question) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "missing taskId or question" }));
+          return;
+        }
+        // Broadcast question to overlay
+        deps.wsHandler?.broadcastRaw({
+          type: "spawn_task",
+          taskId,
+          label: "user-command",
+          status: "awaiting_input",
+          startedAt: Date.now(),
+          question,
+        });
+        // Hold response open until user replies (or timeout after 5 min)
+        const answer = await new Promise<string>((resolve) => {
+          const key = `ask:${taskId}`;
+          pendingSpawnQuestions.set(key, resolve);
+          setTimeout(() => {
+            if (pendingSpawnQuestions.has(key)) {
+              pendingSpawnQuestions.delete(key);
+              resolve("(no reply — user did not respond within 5 minutes)");
+            }
+          }, 5 * 60_000);
+        });
+        res.end(JSON.stringify({ ok: true, answer }));
+        return;
+      }
+
+      // ── /spawn/reply (overlay sends answer to a spawn question) ──
+      if (req.method === "POST" && url.pathname === "/spawn/reply") {
+        const body = await readBody(req, 8192);
+        const { taskId, text } = JSON.parse(body);
+        const key = `ask:${taskId}`;
+        const resolve = pendingSpawnQuestions.get(key);
+        if (resolve) {
+          pendingSpawnQuestions.delete(key);
+          resolve(text || "(empty reply)");
+          res.end(JSON.stringify({ ok: true }));
+        } else {
+          res.end(JSON.stringify({ ok: false, error: "no pending question for this task" }));
+        }
+        return;
+      }
+
+      // ── /spawn/approve (Claude hook posts tool permission, blocks until user decides) ──
+      if (req.method === "POST" && url.pathname === "/spawn/approve") {
+        const body = await readBody(req, 16384);
+        const hookInput = JSON.parse(body);
+        const tool = hookInput?.tool_name || hookInput?.toolName || "unknown";
+        const input = hookInput?.tool_input || hookInput?.input || {};
+
+        // Auto-approve safe read-only tools
+        const safeTools = ["Read", "Glob", "Grep", "Ls", "Cat"];
+        if (safeTools.includes(tool) || tool.startsWith("mcp__sinain")) {
+          res.end(JSON.stringify({
+            hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" },
+          }));
+          return;
+        }
+
+        const taskId = `perm-${Date.now()}`;
+        // Broadcast permission request to overlay
+        deps.wsHandler?.broadcastRaw({
+          type: "spawn_task",
+          taskId,
+          label: "permission",
+          status: "awaiting_permission",
+          startedAt: Date.now(),
+          permission: { tool, input },
+        });
+        // Hold response open until user decides
+        const decision = await new Promise<string>((resolve) => {
+          const key = `perm:${taskId}`;
+          pendingSpawnQuestions.set(key, resolve);
+          setTimeout(() => {
+            if (pendingSpawnQuestions.has(key)) {
+              pendingSpawnQuestions.delete(key);
+              resolve("deny"); // default deny on timeout
+            }
+          }, 2 * 60_000);
+        });
+        res.end(JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: decision === "allow" ? "allow" : "deny",
+            permissionDecisionReason: decision === "allow" ? "User approved via HUD" : "User denied or timed out",
+          },
+        }));
+        return;
+      }
+
+      // ── /spawn/permission-reply (overlay sends allow/deny) ──
+      if (req.method === "POST" && url.pathname === "/spawn/permission-reply") {
+        const body = await readBody(req, 1024);
+        const { taskId, decision } = JSON.parse(body);
+        const key = `perm:${taskId}`;
+        const resolve = pendingSpawnQuestions.get(key);
+        if (resolve) {
+          pendingSpawnQuestions.delete(key);
+          resolve(decision || "deny");
+          res.end(JSON.stringify({ ok: true }));
+        } else {
+          res.end(JSON.stringify({ ok: false, error: "no pending permission for this task" }));
+        }
+        return;
+      }
+
       res.writeHead(404);
       res.end(JSON.stringify({ error: "not found" }));
     } catch (err: any) {