@geravant/sinain 1.10.1 → 1.11.0

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

@@ -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,6 +79,27 @@ 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);
         log(TAG, `command processed: ${msg.action}`);
@@ -142,15 +163,14 @@ 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;
-      }
-      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"}`);
+    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 "open_settings": {

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

@@ -37,6 +37,7 @@ export class WsHandler {
     audio: "muted",
     mic: "muted",
     screen: "off",
+    escalation: "active",
     connection: "disconnected",
   };
   private replayBuffer: FeedMessage[] = [];
@@ -72,6 +73,7 @@ export class WsHandler {
       audio: this.state.audio,
       mic: this.state.mic,
       screen: this.state.screen,
+      escalation: this.state.escalation,
       connection: this.state.connection,
     });
 
@@ -149,11 +151,12 @@ 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 } = {
       type: "status",
       audio: this.state.audio,
       mic: this.state.mic,
       screen: this.state.screen,
+      escalation: this.state.escalation,
       connection: this.state.connection,
     };
     if (loadedEnvPath) msg.envPath = loadedEnvPath;
@@ -229,6 +232,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) {

package/sinain-core/src/types.ts

@@ -18,6 +18,7 @@ export interface StatusMessage {
   audio: string;
   mic: string;
   screen: string;
+  escalation?: string;
   connection: string;
 }
 
@@ -28,7 +29,7 @@ export interface PingMessage {
 }
 
 /** sinain-core → Overlay: spawn task lifecycle update */
-export type SpawnTaskStatus = "spawned" | "polling" | "completed" | "failed" | "timeout";
+export type SpawnTaskStatus = "spawned" | "polling" | "completed" | "failed" | "timeout" | "awaiting_input" | "awaiting_permission";
 
 export interface SpawnTaskMessage {
   type: "spawn_task";
@@ -38,6 +39,10 @@ export interface SpawnTaskMessage {
   startedAt: number;
   completedAt?: number;
   resultPreview?: string;
+  /** Question the spawn is asking the user (status=awaiting_input) */
+  question?: string;
+  /** Tool permission request (status=awaiting_permission) */
+  permission?: { tool: string; input: Record<string, unknown> };
 }
 
 /** Overlay → sinain-core: user typed a message */
@@ -78,6 +83,20 @@ export interface SpawnCommandMessage {
   text: string;
 }
 
+/** Overlay → sinain-core: reply to a spawn question */
+export interface SpawnReplyMessage {
+  type: "spawn_reply";
+  taskId: string;
+  text: string;
+}
+
+/** Overlay → sinain-core: reply to a spawn permission request */
+export interface SpawnPermissionReplyMessage {
+  type: "spawn_permission_reply";
+  taskId: string;
+  decision: "allow" | "deny";
+}
+
 /** Cost update broadcast to overlay. */
 export interface CostMessage {
   type: "cost";
@@ -108,7 +127,7 @@ export interface CostSnapshot {
 }
 
 export type OutboundMessage = FeedMessage | StatusMessage | PingMessage | SpawnTaskMessage | CostMessage;
-export type InboundMessage = UserMessage | CommandMessage | PongMessage | ProfilingMessage | UserCommandMessage | SpawnCommandMessage;
+export type InboundMessage = UserMessage | CommandMessage | PongMessage | ProfilingMessage | UserCommandMessage | SpawnCommandMessage | SpawnReplyMessage | SpawnPermissionReplyMessage;
 
 /** Abstraction for user commands (text now, voice later). */
 export interface UserCommand {
@@ -163,27 +182,6 @@ export interface AudioPipelineConfig {
   gainDb: number;
 }
 
-export interface TraitConfig {
-  enabled: boolean;
-  configPath: string;   // path to ~/.sinain/traits.json
-  entropyHigh: boolean; // Phase 2: boosts entropy roll to 15%
-  logDir: string;       // path to ~/.sinain-core/traits/
-}
-
-export interface TraitLogEntry {
-  ts: string;
-  tickId: number;
-  enabled: boolean;
-  voice: string;
-  voice_stat: number;
-  voice_confidence: number;
-  activation_scores: Record<string, number>;
-  context_app: string;
-  hud_length: number;
-  synthesis: boolean;
-}
-
-
 export interface AudioChunk {
   buffer: Buffer;
   source: string;
@@ -282,9 +280,6 @@ export interface AgentResult {
   tokensOut: number;
   model: string;
   parsedOk: boolean;
-  voice?: string;
-  voice_stat?: number;
-  voice_confidence?: number;
   /** Actual USD cost returned by OpenRouter (undefined if not available). */
   cost?: number;
 }
@@ -396,7 +391,7 @@ export interface BridgeState {
   audio: "active" | "muted";
   mic: "active" | "muted";
   screen: "active" | "off";
-  traits?: "active" | "off";
+  escalation: "active" | "paused";
   connection: "connected" | "disconnected" | "connecting";
 }
 
@@ -479,6 +474,5 @@ export interface CoreConfig {
   costDisplayEnabled: boolean;
   traceDir: string;
   learningConfig: LearningConfig;
-  traitConfig: TraitConfig;
   privacyConfig: PrivacyConfig;
 }

package/sinain-mcp-server/index.ts

@@ -451,6 +451,34 @@ server.tool(
   },
 );
 
+// 15. sinain_ask_user — blocking question to the user via overlay
+server.tool(
+  "sinain_ask_user",
+  "Ask the user a question and wait for their reply. Use when you need clarification, confirmation, or a decision. The question appears on the user's HUD overlay and blocks until they respond.",
+  {
+    question: z.string().describe("The question to ask the user"),
+  },
+  async ({ question }) => {
+    // Use the spawn task ID from the environment if available
+    const taskId = process.env.SINAIN_SPAWN_TASK_ID || `ask-${Date.now()}`;
+    try {
+      const resp = await fetch(`${SINAIN_CORE_URL}/spawn/ask`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ taskId, question }),
+        signal: AbortSignal.timeout(6 * 60_000), // 6 min (server times out at 5)
+      });
+      const data = await resp.json() as { ok: boolean; answer?: string };
+      if (data.ok && data.answer) {
+        return textResult(`User replied: ${data.answer}`);
+      }
+      return textResult("User did not reply.");
+    } catch (err: any) {
+      return textResult(`Failed to ask user: ${err.message}`);
+    }
+  },
+);
+
 // ---------------------------------------------------------------------------
 // Startup
 // ---------------------------------------------------------------------------

package/sinain-memory/eval/assertions.py

@@ -206,27 +206,6 @@ def assert_playbook_header_footer_intact(playbook_text: str) -> dict:
                    f"missing playbook comments: {', '.join(missing)}")
 
 
-# ---------------------------------------------------------------------------
-# Trait voice assertions (sinain-core wiring verification)
-# ---------------------------------------------------------------------------
-
-def assert_situation_has_active_voice(
-    situation_content: str, expected_trait: str | None = None
-) -> dict:
-    """Check SITUATION.md contains an Active Voice section (after trait wiring).
-
-    Called by tick_evaluator.py when processing live ticks that have SITUATION.md
-    content and a trait was selected for that tick.
-    """
-    has_section = "## Active Voice" in situation_content
-    if not has_section:
-        return _result("situation_has_active_voice", False, "no '## Active Voice' section")
-    if expected_trait and expected_trait not in situation_content:
-        return _result("situation_has_active_voice", False,
-                       f"section present but '{expected_trait}' not found")
-    return _result("situation_has_active_voice", True, "Active Voice section present")
-
-
 # ---------------------------------------------------------------------------
 # Runner: execute all applicable assertions for a tick
 # ---------------------------------------------------------------------------