@geravant/sinain 1.14.0 → 1.15.0

package/sinain-core/src/index.ts

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { loadConfig } from "./config.js";
+import { loadAgentsConfig, isGatewayProfile, gatewayProfileNames } from "./agents-loader.js";
 import { FeedBuffer } from "./buffers/feed-buffer.js";
 import { SenseBuffer } from "./buffers/sense-buffer.js";
 import { WsHandler } from "./overlay/ws-handler.js";
@@ -375,7 +376,12 @@ async function main() {
   embeddingService.loadAsync(); // ~9s background load, server starts immediately
 
   // ── Initialize local knowledge pipeline ──
-  const localCuration = new LocalCurationService();
+  // Pass wsHandler.broadcast so the periodic curator (insight_synthesizer)
+  // can push suggestions/insights directly to HUD without going through the
+  // bare-agent heartbeat. Replaces the old sinain_post_feed MCP roundtrip.
+  const localCuration = new LocalCurationService(
+    (text) => wsHandler.broadcast(text),
+  );
   // Distill pending session in background — don't block server startup
   setImmediate(() => {
     localCuration.distillPendingSession();
@@ -390,6 +396,14 @@ async function main() {
   });
 
   // ── Initialize escalation ──
+  // getSpawnAgent reads bareAgentState (declared later in this function) via
+  // closure at call-time, NOT at construction time. Safe because
+  // dispatchSpawnTask only fires after an overlay message, which can't
+  // happen before server setup completes.
+  // Load agents.json once for lookup helpers passed to escalator. Same file
+  // config.ts reads at startup; re-loading here keeps the dispatch lookup
+  // contained to a closure (no need to expose agentsCfg through CoreConfig).
+  const escalatorAgentsCfg = loadAgentsConfig();
   const escalator = new Escalator({
     feedBuffer,
     wsHandler,
@@ -398,6 +412,12 @@ async function main() {
     profiler,
     feedbackStore: feedbackStore ?? undefined,
     queryKnowledgeFacts: queryKnowledgeFactsMulti,
+    getSpawnAgent: () => bareAgentState.spawnAgent,
+    getEscalationAgent: () => bareAgentState.escalationAgent,
+    // Type-based gateway lookup. Routing key is agents.json `profiles[name].type`,
+    // so any custom profile with `type: "openclaw"` (e.g. "nemoclaw",
+    // "nanoclaw-prod") gets WS dispatch automatically — no name-matching.
+    isGatewayAgent: (name: string) => isGatewayProfile(escalatorAgentsCfg, name),
   });
 
   // ── Initialize agent loop (event-driven) ──
@@ -579,6 +599,88 @@ async function main() {
   // ── Escalation pause/resume state ──
   let savedEscalationMode: typeof config.escalationConfig.mode | null = null;
 
+  /** Pause escalation (idempotent). Caches the pre-pause mode so resume
+   *  can restore it. Re-entering while already paused is a no-op — crucially,
+   *  does NOT overwrite savedEscalationMode with "off". */
+  function pauseEscalationInternal(): void {
+    const current = config.escalationConfig.mode;
+    if (current === "off") return;
+    savedEscalationMode = current;
+    escalator.setMode("off");
+    log(TAG, `escalation paused (was: ${savedEscalationMode})`);
+  }
+
+  /** Resume escalation (idempotent). Restores the saved mode or falls back
+   *  to "rich" if no saved mode exists. Re-entering while already active
+   *  is a no-op. */
+  function resumeEscalationInternal(): void {
+    const current = config.escalationConfig.mode;
+    if (current !== "off") return;
+    const mode = savedEscalationMode ?? "rich";
+    savedEscalationMode = null;
+    escalator.setMode(mode);
+    log(TAG, `escalation resumed (mode: ${mode})`);
+  }
+
+  // ── Bare-agent roster & per-lane current agent ──
+  // In-memory only (matches escalation-mode lifecycle). Populated when the
+  // bare agent POSTs /bareagent/register on startup; mutated by set_agent
+  // command from the overlay. Empty-string lane values = "Off" (disabled).
+  // Profile names from agents.json may be custom (e.g. "pclaude",
+  // "openclaude-spawn"), so the server validates by character class
+  // rather than a fixed whitelist. The bare agent owns the source of
+  // truth for which profiles actually exist on its host. The validator
+  // just rejects names that could break shell logging, paths, or be
+  // injection vectors.
+  const AGENT_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+  // "openclaw" is reserved-injected below when gatewayWsUrl is set —
+  // it's not a local CLI, it's a routing choice that sends tasks to the
+  // remote OpenClaw gateway via WS RPC instead of the local bare agent.
+  const bareAgentState: {
+    available: string[];
+    escalationAgent: string;
+    spawnAgent: string;
+  } = { available: [], escalationAgent: "", spawnAgent: "" };
+
+  function registerBareAgent(availableList: string[], current: string): void {
+    const clean = availableList.filter((a) => typeof a === "string" && AGENT_NAME_RE.test(a));
+    // Inject every gateway-style profile (any agents.json profile with
+    // `type: "openclaw"`) into the roster — they have no local binary, so
+    // run.sh's PATH filter drops them, but sinain-core knows they exist
+    // and routes them via WS RPC.
+    //
+    // This generalizes the legacy "auto-inject the literal name 'openclaw'"
+    // behavior: now custom gateway profiles like "nemoclaw" or
+    // "nanoclaw-prod" appear in the overlay roster automatically as soon
+    // as you add them to agents.json. The single WS client uses the first
+    // gateway profile's connection params (config.ts findGatewayProfile);
+    // simultaneous multi-gateway is a follow-up.
+    if (config.openclawConfig.gatewayWsUrl) {
+      for (const gwName of gatewayProfileNames(escalatorAgentsCfg)) {
+        if (!clean.includes(gwName)) clean.push(gwName);
+      }
+      // Legacy fallback: if no gateway profiles are defined in agents.json
+      // but gatewayWsUrl is set via env, still inject the canonical name.
+      if (clean.filter((n) => isGatewayProfile(escalatorAgentsCfg, n)).length === 0
+          && !clean.includes("openclaw")) {
+        clean.push("openclaw");
+      }
+    }
+    bareAgentState.available = clean;
+    // If neither lane is set yet (fresh boot), adopt the bare agent's
+    // reported current. If state survives from a prior register call AND
+    // the agent still exists in the roster, keep it; otherwise fall back
+    // to the new current.
+    if (!bareAgentState.escalationAgent || !clean.includes(bareAgentState.escalationAgent)) {
+      bareAgentState.escalationAgent = clean.includes(current) ? current : (clean[0] ?? "");
+    }
+    if (!bareAgentState.spawnAgent || !clean.includes(bareAgentState.spawnAgent)) {
+      bareAgentState.spawnAgent = clean.includes(current) ? current : (clean[0] ?? "");
+    }
+    wsHandler.updateState({ agents: { ...bareAgentState } });
+    log(TAG, `bareagent register: available=[${clean.join(",")}] current=${current} → lanes esc=${bareAgentState.escalationAgent} spawn=${bareAgentState.spawnAgent}`);
+  }
+
   // ── Create HTTP + WS server ──
   const server = createAppServer({
     config,
@@ -692,6 +794,18 @@ async function main() {
     isEscalationPaused: () => savedEscalationMode !== null,
     respondEscalation: (id: string, response: string) => escalator.respondHttp(id, response),
 
+    // Bare-agent roster & config (wired to server endpoints in step 2).
+    registerBareAgent,
+    getBareAgentConfig: () => ({
+      escalationAgent: bareAgentState.escalationAgent,
+      spawnAgent: bareAgentState.spawnAgent,
+      // Tells the bare agent whether core still has its roster. On core
+      // restart this flips to false until the next /bareagent/register POST
+      // — distinguishes "user picked Off/Off" (registered=true, lanes="")
+      // from "core forgot about us" (registered=false).
+      registered: bareAgentState.available.length > 0,
+    }),
+
     // Knowledge graph integration (checks both local and workspace DBs)
     getKnowledgeDocPath: () => {
       // Check local first, then workspace
@@ -752,20 +866,62 @@ async function main() {
       return screenActive;
     },
     onToggleEscalation: () => {
-      if (savedEscalationMode === null) {
-        // Pause: save current mode, switch to off
-        savedEscalationMode = config.escalationConfig.mode;
-        escalator.setMode("off");
-        log(TAG, `escalation paused (was: ${savedEscalationMode})`);
+      // Routes through the shared helpers so the set_agent("escalation","")
+      // path and the flash-icon-toggle path share a single source of truth
+      // for savedEscalationMode. Kept for WS backward-compat; new UI uses
+      // the agent selector.
+      if (config.escalationConfig.mode === "off") {
+        resumeEscalationInternal();
+        return true;
+      } else {
+        pauseEscalationInternal();
         return false;
+      }
+    },
+    onSetAgent: (lane: "escalation" | "spawn", agent: string): { ok: boolean; error?: string } => {
+      // Empty-string agent = Off (lane disabled). Non-empty agent must be
+      // in the current roster; stale overlay state can send something that
+      // isn't available — reject with a clear error.
+      if (agent !== "" && !bareAgentState.available.includes(agent)) {
+        return { ok: false, error: `Agent "${agent}" not available` };
+      }
+      if (lane === "escalation") {
+        const prevAgent = bareAgentState.escalationAgent;
+        bareAgentState.escalationAgent = agent;
+        if (agent === "") {
+          pauseEscalationInternal();
+        } else {
+          resumeEscalationInternal();
+        }
+        // If the user flipped to a gateway-typed agent (openclaw, nemoclaw,
+        // ...) and there's a stale httpPending escalation queued from BEFORE
+        // the switch, re-dispatch it through the WS path. Without this, the
+        // bare agent picks up the stale entry on its next poll and posts a
+        // "[skipped: gateway-routed]" message to the HUD — confusing for
+        // the user, who just told us "use the gateway".
+        const wasGateway = isGatewayProfile(escalatorAgentsCfg, prevAgent);
+        const isGateway = isGatewayProfile(escalatorAgentsCfg, agent);
+        if (!wasGateway && isGateway) {
+          const did = escalator.redispatchHttpPendingToWs();
+          if (did) log(TAG, `lane switch ${prevAgent || "<empty>"} → ${agent}: stale httpPending redispatched`);
+        }
       } else {
-        // Resume: restore saved mode
-        const mode = savedEscalationMode;
-        savedEscalationMode = null;
-        escalator.setMode(mode);
-        log(TAG, `escalation resumed (mode: ${mode})`);
-        return true;
+        bareAgentState.spawnAgent = agent;
+        // Spawn "off" just means run.sh won't poll /spawn/pending; no
+        // server-side state to flip. Queued spawn tasks TTL out naturally.
       }
+      // Rebroadcast state so the overlay sees the switch immediately, and
+      // the bare agent sees it on its next poll-response config piggyback.
+      // `escalation` field reflects the current escalator mode so the flash
+      // icon's color (active/paused) updates on Off-for-escalation.
+      wsHandler.updateState({
+        agents: { ...bareAgentState },
+        escalation: config.escalationConfig.mode === "off" ? "paused" : "active",
+      });
+      const displayAgent = agent || "off";
+      wsHandler.broadcast(`Agent switched: ${lane} → ${displayAgent}`, "normal", "stream");
+      log(TAG, `set_agent lane=${lane} agent=${displayAgent}`);
+      return { ok: true };
     },
   });
 

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 {