@geravant/sinain 1.13.0 → 1.15.0

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

@@ -60,11 +60,17 @@ export class LocalCurationService {
   private _incrementalRunning = false;
   private _rearmCb: (() => void) | null = null; // callback to re-arm feed buffer onFull
   private _senseBuffer: SenseBuffer | null = null;
+  // Optional HUD broadcast callback — when insight_synthesizer emits a
+  // suggestion/insight, we push it here so the overlay sees it. Replaces the
+  // bare-agent's prior `sinain_post_feed` roundtrip during heartbeat.
+  // Always posts at default priority; curation isn't the place for urgent pings.
+  private _broadcast: ((text: string) => void) | null = null;
 
-  constructor() {
+  constructor(broadcast?: (text: string) => void) {
     this.memoryDir = resolveMemoryDir();
     this.scriptsDir = resolveScriptsDir();
     this.sessionStartTs = Date.now();
+    if (broadcast) this._broadcast = broadcast;
 
     // Ensure memory directory exists
     for (const subdir of ["", "playbook-logs", "playbook-archive", "eval-logs", "eval-reports"]) {
@@ -384,39 +390,87 @@ export class LocalCurationService {
     }
   }
 
-  /** Run the periodic curation pipeline (feedback → mining → curation). */
+  /** Run the periodic curation pipeline.
+   * Replaces the bare-agent heartbeat entirely:
+   *   signal_analyzer + insight_synthesizer (formerly heartbeat-only)
+   *   + feedback_analyzer + memory_miner + playbook_curator (existing).
+   * insight_synthesizer output is parsed and, if it emits a suggestion or
+   * insight, broadcast to HUD via the constructor's broadcast callback.
+   */
   private runCurationPipeline(): void {
     log(TAG, "running periodic curation...");
 
-    const scripts = [
-      "feedback_analyzer.py",
-      "memory_miner.py",
-      "playbook_curator.py",
-    ];
+    const sessionSummary = "Periodic curation cycle";
+    const currentTime = new Date().toISOString();
+
+    // Step 1: signal_analyzer — detects actionable signals from session memory
+    this.runScript("signal_analyzer.py", [
+      "--memory-dir", this.memoryDir,
+      "--session-summary", sessionSummary,
+      "--current-time", currentTime,
+    ]);
+
+    // Step 2: insight_synthesizer — produces {suggestion, insight}, broadcast to HUD
+    const insightOut = this.runScript("insight_synthesizer.py", [
+      "--memory-dir", this.memoryDir,
+      "--session-summary", sessionSummary,
+      "--current-time", currentTime,
+    ], /* captureStdout */ true);
+    if (insightOut) this.maybeBroadcastInsight(insightOut);
+
+    // Steps 3-5: existing periodic pipeline (feedback → mining → curation)
+    for (const script of ["feedback_analyzer.py", "memory_miner.py", "playbook_curator.py"]) {
+      this.runScript(script, ["--memory-dir", this.memoryDir]);
+    }
 
-    for (const script of scripts) {
-      const scriptPath = resolve(this.scriptsDir, script);
-      if (!existsSync(scriptPath)) {
-        warn(TAG, `${script} not found — skipping`);
-        continue;
-      }
+    log(TAG, "periodic curation complete");
+  }
 
-      try {
-        execFileSync("python3", [
-          scriptPath,
-          "--memory-dir", this.memoryDir,
-        ], {
-          timeout: 60_000,
-          encoding: "utf-8",
-          env: { ...process.env, PYTHONPATH: this.scriptsDir },
-        });
-        log(TAG, `  ✓ ${script}`);
-      } catch (err: any) {
-        warn(TAG, `  ✗ ${script}: ${err.message?.slice(0, 100)}`);
-      }
+  /** Run a single curation script. Returns captured stdout when requested, else empty. */
+  private runScript(script: string, args: string[], captureStdout = false): string {
+    const scriptPath = resolve(this.scriptsDir, script);
+    if (!existsSync(scriptPath)) {
+      warn(TAG, `${script} not found — skipping`);
+      return "";
+    }
+    try {
+      const stdout = execFileSync("python3", [scriptPath, ...args], {
+        timeout: 60_000,
+        encoding: "utf-8",
+        env: { ...process.env, PYTHONPATH: this.scriptsDir },
+      });
+      log(TAG, `  ✓ ${script}`);
+      return captureStdout ? (stdout || "") : "";
+    } catch (err: any) {
+      warn(TAG, `  ✗ ${script}: ${err.message?.slice(0, 100)}`);
+      return "";
     }
+  }
 
-    log(TAG, "periodic curation complete");
+  /** Parse insight_synthesizer stdout (expects JSON with {suggestion?, insight?})
+   *  and broadcast non-empty fields to the HUD feed. Safe no-op if JSON parsing
+   *  fails or if no broadcast callback was wired. */
+  private maybeBroadcastInsight(stdout: string): void {
+    if (!this._broadcast) return;
+    const lines = stdout.trim().split("\n").filter((l) => l.trim().length > 0);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (!line.startsWith("{")) continue;
+      try {
+        const parsed = JSON.parse(line);
+        const suggestion = typeof parsed.suggestion === "string" ? parsed.suggestion.trim() : "";
+        const insight = typeof parsed.insight === "string" ? parsed.insight.trim() : "";
+        if (suggestion) {
+          log(TAG, `  posting suggestion to HUD (${suggestion.length} chars)`);
+          this._broadcast(suggestion);
+        }
+        if (insight && insight !== suggestion) {
+          log(TAG, `  posting insight to HUD (${insight.length} chars)`);
+          this._broadcast(insight);
+        }
+        return;
+      } catch { /* try previous line */ }
+    }
   }
 
   /** Write distilled session notes to daily file. */

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

@@ -23,6 +23,9 @@ export interface CommandDeps {
   onToggleScreen: () => boolean;
   /** Toggle escalation pause/resume — returns true if now active */
   onToggleEscalation: () => boolean;
+  /** Set the agent for a lane. agent="" means Off (lane disabled).
+   *  Returns { ok: false, error } if agent isn't in the current roster. */
+  onSetAgent?: (lane: "escalation" | "spawn", agent: string) => { ok: boolean; error?: string };
 }
 
 /**
@@ -186,6 +189,28 @@ function handleCommand(msg: InboundMessage & { action: string }, deps: CommandDe
       }
       break;
     }
+    case "set_agent": {
+      const lane = (msg as any).lane as "escalation" | "spawn" | undefined;
+      const agent = (msg as any).agent;
+      if (lane !== "escalation" && lane !== "spawn") {
+        log(TAG, `set_agent: invalid lane "${lane}"`);
+        break;
+      }
+      if (typeof agent !== "string") {
+        log(TAG, `set_agent: missing or non-string agent field`);
+        break;
+      }
+      if (!deps.onSetAgent) {
+        log(TAG, `set_agent: no handler wired`);
+        break;
+      }
+      const result = deps.onSetAgent(lane, agent);
+      if (!result.ok) {
+        wsHandler.broadcast(`⚠ ${result.error ?? "set_agent failed"}`, "normal");
+      }
+      log(TAG, `set_agent lane=${lane} agent=${agent || "<off>"} (ok=${result.ok})`);
+      break;
+    }
     case "open_settings": {
       const envPath = loadedEnvPath || `${process.env.HOME || process.env.USERPROFILE}/.sinain/.env`;
       const cmd = process.platform === "win32" ? "notepad" : "open";

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

@@ -40,6 +40,7 @@ export class WsHandler {
     escalation: "active",
     connection: "disconnected",
     responseSize: "medium",
+    agents: { available: [], escalationAgent: "", spawnAgent: "" },
   };
   private replayBuffer: FeedMessage[] = [];
   private spawnTaskBuffer: Map<string, SpawnTaskMessage> = new Map();
@@ -77,6 +78,7 @@ export class WsHandler {
       escalation: this.state.escalation,
       connection: this.state.connection,
       responseSize: this.state.responseSize,
+      agents: this.state.agents,
     });
 
     // Replay recent feed messages for late-joining clients
@@ -161,6 +163,7 @@ export class WsHandler {
       escalation: this.state.escalation,
       connection: this.state.connection,
       responseSize: this.state.responseSize,
+      agents: this.state.agents,
     };
     if (loadedEnvPath) msg.envPath = loadedEnvPath;
     this.broadcastMessage(msg);

package/sinain-core/src/server.ts

@@ -186,6 +186,15 @@ export interface ServerDeps {
   respondSpawn?: (id: string, result: string) => { ok: boolean; error?: string };
   embedTexts?: (texts: string[]) => Promise<Float32Array[]>;
   isEmbeddingReady?: () => boolean;
+
+  /** Bare-agent announced its roster on startup. */
+  registerBareAgent?: (available: string[], current: string) => void;
+  /** Current per-lane agent choice; read by run.sh via the piggyback field
+   *  on /escalation/pending and /spawn/pending responses, and by manual
+   *  debug via GET /bareagent/config. `registered` distinguishes "user
+   *  chose Off" (registered=true, lanes="") from "core forgot our
+   *  registration" (registered=false) so run.sh heals only on the latter. */
+  getBareAgentConfig?: () => { escalationAgent: string; spawnAgent: string; registered: boolean };
 }
 
 function readBody(req: IncomingMessage, maxBytes: number): Promise<string> {
@@ -209,6 +218,17 @@ 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>();
 
+// YOLO mode: "allow all" for the current agent session. Keyed on the openclaude
+// session_id from the PreToolUse hook input (stable across tool calls within
+// one invoke_agent run, discarded when that run ends). User enters YOLO by
+// clicking the YOLO button on any permission prompt. Session id is cleared
+// implicitly when the bare agent restarts (new session_id on next run).
+const yoloSessions = new Set<string>();
+// Map permission-request id (perm-<ts>) -> session id it came from. Used so
+// that /spawn/permission-reply can flag the right session as YOLO when the
+// user picks the YOLO button. Cleaned on resolve/timeout.
+const permissionToSession = new Map<string, string>();
+
 export function createAppServer(deps: ServerDeps) {
   const { config, feedBuffer, senseBuffer, wsHandler } = deps;
   let senseInBytes = 0;
@@ -596,14 +616,17 @@ export function createAppServer(deps: ServerDeps) {
       }
 
       // ── /escalation/pending ──
+      // Response piggybacks the per-lane agent config so run.sh learns
+      // about overlay-side agent switches without a separate poll.
       if (req.method === "GET" && url.pathname === "/escalation/pending") {
+        const config = deps.getBareAgentConfig?.() ?? { escalationAgent: "", spawnAgent: "", registered: false };
         const paused = deps.isEscalationPaused?.() ?? false;
         if (paused) {
-          res.end(JSON.stringify({ ok: true, escalation: null, paused: true }));
+          res.end(JSON.stringify({ ok: true, escalation: null, paused: true, config }));
           return;
         }
         const pending = deps.getEscalationPending?.();
-        res.end(JSON.stringify({ ok: true, escalation: pending ?? null }));
+        res.end(JSON.stringify({ ok: true, escalation: pending ?? null, config }));
         return;
       }
 
@@ -640,9 +663,11 @@ export function createAppServer(deps: ServerDeps) {
       }
 
       // ── /spawn/pending (bare agent polls for queued tasks) ──
+      // Response piggybacks the per-lane agent config (see /escalation/pending).
       if (req.method === "GET" && url.pathname === "/spawn/pending") {
+        const config = deps.getBareAgentConfig?.() ?? { escalationAgent: "", spawnAgent: "", registered: false };
         const task = deps.getSpawnPending?.() ?? null;
-        res.end(JSON.stringify({ ok: true, task }));
+        res.end(JSON.stringify({ ok: true, task, config }));
         return;
       }
 
@@ -715,17 +740,43 @@ export function createAppServer(deps: ServerDeps) {
         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")) {
+        // session_id is provided by Claude Code / openclaude per the standard
+        // PreToolUse hook contract — stable within one CLI invocation. Falls
+        // back to sinainTaskId (injected by approve-tool.sh from env) for
+        // hosts that don't emit session_id.
+        const sessionId: string =
+          (typeof hookInput?.session_id === "string" && hookInput.session_id) ||
+          (typeof hookInput?.sinainTaskId === "string" && hookInput.sinainTaskId) ||
+          "";
+
+        // Auto-approve safe tools (configured via SINAIN_AUTO_APPROVE_TOOLS).
+        // Tokens are exact matches, or prefix patterns ending with "*".
+        const autoApproveTools = deps.config.permissionsConfig.autoApproveTools;
+        const autoApproved = autoApproveTools.some((p) =>
+          p.endsWith("*") ? tool.startsWith(p.slice(0, -1)) : tool === p,
+        );
+        if (autoApproved) {
           res.end(JSON.stringify({
             hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" },
           }));
           return;
         }
 
+        // YOLO short-circuit: if this session previously clicked YOLO, auto-allow
+        // without routing to overlay. No user interaction needed.
+        if (sessionId && yoloSessions.has(sessionId)) {
+          res.end(JSON.stringify({
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "allow",
+              permissionDecisionReason: "YOLO mode active for this session",
+            },
+          }));
+          return;
+        }
+
         const taskId = `perm-${Date.now()}`;
+        if (sessionId) permissionToSession.set(taskId, sessionId);
         // Broadcast permission request to overlay
         deps.wsHandler?.broadcastRaw({
           type: "spawn_task",
@@ -746,17 +797,49 @@ export function createAppServer(deps: ServerDeps) {
             }
           }, 2 * 60_000);
         });
+        // Clean up the permission→session mapping once we're done with it.
+        permissionToSession.delete(taskId);
+        const allowed = decision === "allow" || decision === "yolo";
         res.end(JSON.stringify({
           hookSpecificOutput: {
             hookEventName: "PreToolUse",
-            permissionDecision: decision === "allow" ? "allow" : "deny",
-            permissionDecisionReason: decision === "allow" ? "User approved via HUD" : "User denied or timed out",
+            permissionDecision: allowed ? "allow" : "deny",
+            permissionDecisionReason:
+              decision === "yolo" ? "User engaged YOLO mode — allow all for this session"
+              : decision === "allow" ? "User approved via HUD"
+              : "User denied or timed out",
           },
         }));
         return;
       }
 
-      // ── /spawn/permission-reply (overlay sends allow/deny) ──
+      // ── /bareagent/register (bare agent announces its roster on startup) ──
+      if (req.method === "POST" && url.pathname === "/bareagent/register") {
+        const body = await readBody(req, 4096);
+        let parsed: any;
+        try { parsed = JSON.parse(body); }
+        catch { res.writeHead(400); res.end(JSON.stringify({ ok: false, error: "invalid json" })); return; }
+        const available = Array.isArray(parsed?.available) ? parsed.available : null;
+        const current = typeof parsed?.current === "string" ? parsed.current : "";
+        if (!available) {
+          res.writeHead(400);
+          res.end(JSON.stringify({ ok: false, error: "missing available[]" }));
+          return;
+        }
+        deps.registerBareAgent?.(available, current);
+        res.end(JSON.stringify({ ok: true }));
+        return;
+      }
+
+      // ── /bareagent/config (debug; the hot path uses the config field
+      // piggybacked on /escalation/pending and /spawn/pending responses) ──
+      if (req.method === "GET" && url.pathname === "/bareagent/config") {
+        const cfg = deps.getBareAgentConfig?.() ?? { escalationAgent: "", spawnAgent: "", registered: false };
+        res.end(JSON.stringify({ ok: true, ...cfg }));
+        return;
+      }
+
+      // ── /spawn/permission-reply (overlay sends allow | deny | yolo) ──
       if (req.method === "POST" && url.pathname === "/spawn/permission-reply") {
         const body = await readBody(req, 1024);
         const { taskId, decision } = JSON.parse(body);
@@ -764,6 +847,14 @@ export function createAppServer(deps: ServerDeps) {
         const resolve = pendingSpawnQuestions.get(key);
         if (resolve) {
           pendingSpawnQuestions.delete(key);
+          // YOLO: flag the session so subsequent permission requests for the
+          // same openclaude invocation auto-allow without routing to overlay.
+          // Session id was captured in permissionToSession when we broadcast
+          // the request; it's cleared by the /spawn/approve handler after resolve.
+          if (decision === "yolo") {
+            const sid = permissionToSession.get(taskId);
+            if (sid) yoloSessions.add(sid);
+          }
           resolve(decision || "deny");
           res.end(JSON.stringify({ ok: true }));
         } else {

package/sinain-core/src/types.ts

@@ -21,6 +21,14 @@ export interface StatusMessage {
   escalation?: string;
   connection: string;
   responseSize?: string;
+  /** Bare-agent roster + per-lane current choice. Omitted until the bare
+   *  agent has registered via POST /bareagent/register. empty-string lane
+   *  values mean "Off" (lane disabled). */
+  agents?: {
+    available: string[];
+    escalationAgent: string;
+    spawnAgent: string;
+  };
 }
 
 /** sinain-core → Overlay: heartbeat ping */
@@ -323,14 +331,16 @@ export interface ContextWindow {
 }
 
 // ── Escalation types ──
-
-export type EscalationTransport = "ws" | "http" | "auto";
+//
+// Transport choice is per-lane now (driven by the overlay's agent selector):
+// `escalationAgent === "openclaw"` → WS; any other non-empty agent → HTTP.
+// The old global `transport` setting was removed — picking an agent IS the
+// transport.
 
 export interface EscalationConfig {
   mode: EscalationMode;
   cooldownMs: number;
   staleMs: number;  // force escalation after this many ms of silence (0 = disabled)
-  transport: EscalationTransport;
 }
 
 export interface OpenClawConfig {
@@ -396,6 +406,13 @@ export interface BridgeState {
   escalation: "active" | "paused";
   connection: "connected" | "disconnected" | "connecting";
   responseSize: ResponseSize;
+  /** Bare-agent roster + per-lane current choice. Populated after the
+   *  bare agent's POST /bareagent/register. "" lane value = lane disabled. */
+  agents: {
+    available: string[];
+    escalationAgent: string;
+    spawnAgent: string;
+  };
 }
 
 // ── Learning / feedback types ──
@@ -461,6 +478,14 @@ export interface PrivacyConfig {
   matrix: PrivacyMatrix;
 }
 
+// ── Permission gating for /spawn/approve ──
+// Controls which tool-invocations auto-approve (vs. route to overlay for user).
+// Tokens are exact tool names (e.g. "Read") or prefix patterns ending with `*`
+// (e.g. "mcp__sinain*"). Everything else gets the overlay Allow/Deny prompt.
+export interface PermissionsConfig {
+  autoApproveTools: string[];
+}
+
 // ── Full core config ──
 
 export interface CoreConfig {
@@ -478,4 +503,5 @@ export interface CoreConfig {
   traceDir: string;
   learningConfig: LearningConfig;
   privacyConfig: PrivacyConfig;
+  permissionsConfig: PermissionsConfig;
 }

package/sinain-memory/graph_query.py

@@ -330,6 +330,10 @@ def query_facts_hybrid(
             if eid and eid not in fact_map:
                 fact_map[eid] = f
 
+    # Return top RRF candidates. Embedding re-ranking is done by the caller
+    # (sinain-core Node.js) to avoid deadlock — the Python subprocess can't call
+    # back to sinain-core's /embed endpoint while sinain-core is blocked waiting
+    # for the subprocess.
     results = [fact_map[eid] for eid in sorted_ids[:max_facts] if eid in fact_map]
 
     # Expand top results with 1-hop graph neighbors
@@ -396,7 +400,7 @@ def format_facts_text(facts: list[dict], max_chars: int = 500) -> str:
     return "\n".join(lines)
 
 
-def format_facts_compact(facts: list[dict], max_chars: int = 400) -> str:
+def format_facts_compact(facts: list[dict], max_chars: int = 1200) -> str:
     """Encode facts for efficient escalation context injection.
 
     Compact format: domain/entity: value (conf, Nx)
@@ -409,7 +413,7 @@ def format_facts_compact(facts: list[dict], max_chars: int = 400) -> str:
     total = 0
     for f in facts:
         entity = f.get("entityId", "").split(":")[-1][:20]
-        value = f.get("value", "")[:60]
+        value = f.get("value", "")
         conf = f.get("confidence", "?")
         count = f.get("reinforce_count", "1")
         domain = f.get("domain", "")
@@ -469,7 +473,12 @@ def main() -> None:
         facts = query_top_facts(args.db, limit=args.top)
     elif args.entities:
         entities = json.loads(args.entities)
-        facts = query_facts_by_entities(args.db, entities, max_facts=args.max_facts)
+        # Use hybrid retrieval (FTS5 + tags + entity graph + RRF) for best results
+        query_text = " ".join(entities)
+        facts = query_facts_hybrid(args.db, query_text, max_facts=args.max_facts)
+        # Fallback to tag-only if hybrid returns nothing
+        if not facts:
+            facts = query_facts_by_entities(args.db, entities, max_facts=args.max_facts)
     else:
         facts = query_top_facts(args.db, limit=args.max_facts)