@geravant/sinain 1.22.8 → 1.22.9

package/onboard.js

@@ -267,15 +267,39 @@ export async function runOnboard(args = {}) {
       }
     }
 
-    // stepGateway returns { envVars, agentsPatch }: tokens go to .env,
-    // URLs + session + escalation mode go to agents.json's openclaw profile.
-    const gatewayResult = await stepGateway(base, "[3/6] OpenClaw gateway");
-    Object.assign(vars, gatewayResult.envVars);
-    Object.assign(agentsPatch, gatewayResult.agentsPatch);
-    if (gatewayResult.agentsPatch.escalationMode === "off") {
-      p.log.info("Standalone mode (no gateway).");
+    // OpenClaw gateway is opt-in: most users run sinain in standalone mode
+    // and never need a gateway. Default the prompt to "No" on fresh installs
+    // (when no openclaw profile already exists) so accepting all wizard
+    // defaults never silently provisions a gateway profile or starts a WS
+    // reconnect loop. Mirrors the Quick-path gate at line ~177.
+    const hasExistingGateway = (() => {
+      try {
+        const agentsPath = path.join(SINAIN_DIR, "agents.json");
+        if (!fs.existsSync(agentsPath)) return false;
+        const cfg = JSON.parse(fs.readFileSync(agentsPath, "utf-8"));
+        return !!cfg?.profiles?.openclaw;
+      } catch { return false; }
+    })();
+    const enableGateway = guard(await p.confirm({
+      message: "[3/6] Configure OpenClaw gateway?",
+      initialValue: hasExistingGateway,
+    }));
+    if (enableGateway) {
+      // stepGateway returns { envVars, agentsPatch }: tokens go to .env,
+      // URLs + session + escalation mode go to agents.json's openclaw profile.
+      const gatewayResult = await stepGateway(base, "[3/6] OpenClaw gateway");
+      Object.assign(vars, gatewayResult.envVars);
+      Object.assign(agentsPatch, gatewayResult.agentsPatch);
+      if (gatewayResult.agentsPatch.escalationMode === "off") {
+        p.log.info("Standalone mode (no gateway).");
+      } else {
+        p.log.success("Gateway configured.");
+      }
     } else {
-      p.log.success("Gateway configured.");
+      // Explicitly clear any inherited openclaw profile so the runtime doesn't
+      // auto-register the gateway or attempt WS reconnects (matches Quick path).
+      agentsPatch.openclawProfile = null;
+      p.log.info("Standalone mode (no gateway).");
     }
 
     const privacy = await stepPrivacy(base, "[4/6] Privacy mode");

package/package.json

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

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

@@ -31,6 +31,12 @@ export interface AgentLoopDeps {
   profiler?: Profiler;
   /** Called after each successful SITUATION.md write with the content string. */
   onSituationUpdate?: (content: string) => void;
+  /** Predicate to skip SITUATION.md writes entirely when no consumer is
+   *  listening. Today only the openclaw module reads SITUATION.md, so when
+   *  no gateway-typed agent is selected this returns false and the disk
+   *  write is skipped on every tick. Defaults to "always write" if absent
+   *  (preserves prior behavior for callers that don't pass the predicate). */
+  shouldWriteSituation?: () => boolean;
   /** Optional: path to sinain-knowledge.md for startup recap. */
   getKnowledgeDocPath?: () => string | null;
   /** Optional: feedback store for startup recap context. */
@@ -376,9 +382,14 @@ export class AgentLoop extends EventEmitter {
       // Calculate escalation score for both SITUATION.md and escalation check
       const escalationScore = calculateEscalationScore(digest, contextWindow);
 
-      // Write SITUATION.md (enhanced with escalation context and recorder status)
-      const situationContent = writeSituationMd(this.deps.situationMdPath, contextWindow, digest, entry, escalationScore, recorderStatus);
-      this.deps.onSituationUpdate?.(situationContent);
+      // Write SITUATION.md only when something consumes it (today: an openclaw
+      // gateway lane is selected). Without a consumer, skip the disk write to
+      // avoid pinning ~/.openclaw/workspace/SITUATION.md on every tick of users
+      // who chose claude/openclaude/etc as both lanes.
+      if (this.deps.shouldWriteSituation?.() ?? true) {
+        const situationContent = writeSituationMd(this.deps.situationMdPath, contextWindow, digest, entry, escalationScore, recorderStatus);
+        this.deps.onSituationUpdate?.(situationContent);
+      }
 
       // Notify for escalation check
       traceCtx?.startSpan("escalation-check");

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

@@ -170,17 +170,38 @@ export class Escalator {
     log(TAG, `user command set: "${preview}"`);
   }
 
+  /** True iff a gateway-typed profile is the active agent on at least one
+   *  lane. WS-bearing operations (connect, reset, situation push) are gated
+   *  on this so a user with a configured-but-unselected gateway pays no
+   *  reconnect tax. */
+  private isGatewayLaneSelected(): boolean {
+    const isGw = this.deps.isGatewayAgent;
+    if (!isGw) return false;
+    const esc = this.deps.getEscalationAgent?.() ?? "";
+    const spawn = this.deps.getSpawnAgent?.() ?? "";
+    return isGw(esc) || isGw(spawn);
+  }
+
+  /** Public predicate so the agent loop / index.ts can ask "should I do
+   *  openclaw-only side-effects on this tick?" without depending on the
+   *  internals. Mirrors isGatewayLaneSelected. */
+  shouldDriveGateway(): boolean {
+    const wsConfigured = !!this.deps.openclawConfig.gatewayWsUrl;
+    return wsConfigured && this.isGatewayLaneSelected();
+  }
+
   /** Start the WS connection to OpenClaw.
    *
-   * Connects whenever the gateway URL is configured AND escalation isn't
-   * fully off. WS is the transport for the openclaw lane — the user selects
-   * it via the overlay's agent picker, and dispatch routes accordingly.
-   * Removing the openclaw profile from agents.json (and unsetting the env
-   * vars) leaves gatewayWsUrl empty → no connect attempt.
+   * Connects whenever the gateway URL is configured AND a gateway-typed
+   * profile is selected on a lane AND escalation isn't fully off. WS is
+   * the transport for the openclaw lane — the user selects it via the
+   * overlay's agent picker, and dispatch routes accordingly. Removing the
+   * openclaw profile from agents.json (and unsetting the env vars) leaves
+   * gatewayWsUrl empty → no connect attempt. Likewise, if the profile
+   * exists but no lane selects it, no connect attempt.
    */
   start(): void {
-    const wsConfigured = !!this.deps.openclawConfig.gatewayWsUrl;
-    if (this.deps.escalationConfig.mode !== "off" && wsConfigured) {
+    if (this.deps.escalationConfig.mode !== "off" && this.shouldDriveGateway()) {
       this.wsClient.connect();
       const tokenHash = this.deps.openclawConfig.gatewayToken
         ? createHash("sha256").update(this.deps.openclawConfig.gatewayToken).digest("hex").slice(0, 12)
@@ -194,11 +215,26 @@ export class Escalator {
     this.wsClient.disconnect();
   }
 
+  /** Re-evaluate WS lifecycle after lane selection changes. Connects when a
+   *  gateway lane just got selected; disconnects when the user moved off
+   *  every gateway lane. Called from the set_agent overlay handler. */
+  evaluateGatewayLifecycle(): void {
+    const shouldConnect =
+      this.deps.escalationConfig.mode !== "off" && this.shouldDriveGateway();
+    if (shouldConnect && !this.wsClient.isConnected) {
+      log(TAG, "lane switched to gateway — connecting WS");
+      this.wsClient.resetConnection();
+    } else if (!shouldConnect && this.wsClient.isConnected) {
+      log(TAG, "lane switched off gateway — disconnecting WS");
+      this.wsClient.disconnect();
+    }
+  }
+
   /** Update escalation mode at runtime. */
   setMode(mode: EscalatorDeps["escalationConfig"]["mode"]): void {
     const wasOff = this.deps.escalationConfig.mode === "off";
     this.deps.escalationConfig.mode = mode;
-    if (mode !== "off" && !this.wsClient.isConnected) {
+    if (mode !== "off" && !this.wsClient.isConnected && this.shouldDriveGateway()) {
       this.wsClient.resetConnection();
     }
     if (mode === "off") {

package/sinain-core/src/index.ts

@@ -743,6 +743,11 @@ async function main() {
     onSituationUpdate: (content) => {
       escalator.pushSituationMd(content);
     },
+    // Gate SITUATION.md writes (and the subsequent push) on a gateway lane
+    // being active — see escalator.shouldDriveGateway. Users with no openclaw
+    // profile, or with the profile but no lane selecting it, pay zero disk
+    // I/O on every tick.
+    shouldWriteSituation: () => escalator.shouldDriveGateway(),
     onHudUpdate: (text) => {
       wsHandler.broadcastRaw({ type: "thinking", active: false } as any);
       wsHandler.broadcast(text, "normal", "stream");
@@ -1241,6 +1246,12 @@ async function main() {
         // Spawn "off" just means run.sh won't poll /spawn/pending; no
         // server-side state to flip. Queued spawn tasks TTL out naturally.
       }
+      // Re-evaluate WS lifecycle: connect when a gateway lane just got
+      // selected (zero attempts before this point), disconnect when the user
+      // moved off every gateway lane. This is what makes the "no resources
+      // when not in use" guarantee hold across runtime selection changes,
+      // not just startup config.
+      escalator.evaluateGatewayLifecycle();
       // 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

package/sinain-core/src/util/event-bus.ts

@@ -0,0 +1,69 @@
+import { EventEmitter } from "node:events";
+import type { AgentEntry, ContextWindow } from "../types.js";
+
+/**
+ * Domain-generic events emitted by sinain-core. Optional agent modules
+ * (currently just openclaw, future bridges to other gateways) subscribe
+ * to these instead of being wired directly into Escalator. The contract
+ * here is the only stable surface modules can rely on.
+ */
+export interface CoreEvents {
+  /** An escalation has been routed to an agent. Modules whose roster
+   *  matches `agent` should run their delivery (WS, HTTP, etc). */
+  "escalation:dispatched": {
+    entry: AgentEntry;
+    contextWindow: ContextWindow;
+    message: string;
+    agent: string;
+  };
+
+  /** User typed a direct message in the overlay command input. */
+  "user:direct": { text: string; ts: number };
+
+  /** Periodic feedback summary ready for forwarding to long-running agents. */
+  "feedback:periodic": { summary: string; lastNTicks: number };
+
+  /** Agent loop completed an analysis tick. Used by SITUATION.md writers
+   *  and other context consumers. */
+  "tick:complete": { entry: AgentEntry };
+}
+
+export interface CoreEventBus {
+  on<K extends keyof CoreEvents>(
+    event: K,
+    listener: (payload: CoreEvents[K]) => void,
+  ): () => void;
+  emit<K extends keyof CoreEvents>(event: K, payload: CoreEvents[K]): void;
+  removeAllListeners(): void;
+}
+
+class TypedEventBus implements CoreEventBus {
+  private readonly emitter = new EventEmitter();
+
+  constructor() {
+    // Default Node limit (10) is too low for a long-running bus with many
+    // subscribers across the lifetime of the process. Disable the warning;
+    // we control the listener set internally.
+    this.emitter.setMaxListeners(0);
+  }
+
+  on<K extends keyof CoreEvents>(
+    event: K,
+    listener: (payload: CoreEvents[K]) => void,
+  ): () => void {
+    this.emitter.on(event, listener as (...args: unknown[]) => void);
+    return () => this.emitter.off(event, listener as (...args: unknown[]) => void);
+  }
+
+  emit<K extends keyof CoreEvents>(event: K, payload: CoreEvents[K]): void {
+    this.emitter.emit(event, payload);
+  }
+
+  removeAllListeners(): void {
+    this.emitter.removeAllListeners();
+  }
+}
+
+export function createCoreEventBus(): CoreEventBus {
+  return new TypedEventBus();
+}