@geravant/sinain 1.18.1 → 1.18.3

package/onboard.js

@@ -154,25 +154,58 @@ export async function runOnboard(args = {}) {
   p.log.success("API key saved.");
 
   if (flow === "quickstart") {
-    // QuickStart: sensible defaults. Gateway is opt-in (skip by default);
-    // agent + escalation defaults go to agents.json.
+    // QuickStart: sensible defaults + a single opt-in question for OpenClaw.
+    // Gateway integration is off by default; users who want it run Advanced
+    // (or answer Yes here, which then walks them through stepGateway).
     vars.TRANSCRIPTION_BACKEND = base.TRANSCRIPTION_BACKEND || "openrouter";
     vars.PRIVACY_MODE = base.PRIVACY_MODE || "standard";
     vars.AGENT_MODEL = base.AGENT_MODEL || "google/gemini-2.5-flash-lite";
+
+    // Ask explicitly so first-run installs don't silently inherit a gateway
+    // profile from agents.example.json. Default reflects current state — No
+    // for fresh installs (silences the WS reconnect loop), Yes for re-runs
+    // that already had OpenClaw configured (so we don't surprise-delete it).
+    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: "Enable OpenClaw gateway integration?",
+      initialValue: hasExistingGateway,
+    }));
+
     agentsPatch = {
       default: base.SINAIN_AGENT || "claude",
-      escalationMode: "off",
-      // Don't touch openclawProfile in quickstart — keeps existing config
-      // intact for re-runs; first-time users get the "skip" state from
-      // agents.example.json bootstrap (no openclaw profile means no gateway).
+      // No `escalationMode` written — lane (default agent) is the single
+      // source of truth for whether escalation runs. If the user picks a
+      // local agent (claude), the runtime's default mode ("rich" from
+      // config.ts) takes effect and registerBareAgent ensures lane and
+      // mode stay reconciled at boot.
     };
 
+    if (enableGateway) {
+      // Walk through full gateway setup (URL, tokens, session key) — same
+      // step Advanced uses. Returns { envVars, agentsPatch } we merge in.
+      const gatewayResult = await stepGateway(base, "OpenClaw gateway");
+      Object.assign(vars, gatewayResult.envVars);
+      Object.assign(agentsPatch, gatewayResult.agentsPatch);
+    } else {
+      // Explicitly clear any inherited openclaw profile so the runtime
+      // doesn't auto-register the gateway or attempt WS reconnects.
+      agentsPatch.openclawProfile = null;
+    }
+
     p.note(
       [
         `Transcription: ${vars.TRANSCRIPTION_BACKEND}`,
         `Privacy: ${vars.PRIVACY_MODE}`,
         `Model: ${vars.AGENT_MODEL}`,
-        `Escalation: off (pick a gateway agent in the overlay to enable)`,
+        `OpenClaw gateway: ${enableGateway ? "enabled" : "disabled"}`,
+        `Escalation: ${agentsPatch.escalationMode || "off"}`,
         "",
         `Change later: sinain config`,
       ].join("\n"),
@@ -368,10 +401,9 @@ if (flags.nonInteractive) {
   }
 
   writeEnv(vars);
-  // Default agent + escalation off (no gateway by default for non-interactive).
-  // openclaw profile is left as-is from the example template (or absent
-  // if first run) — gateway is opt-in via the wizard or `sinain config`.
-  writeAgentsConfig({ default: "claude", escalationMode: "off" });
+  // Default agent + openclaw explicitly disabled. No escalation mode written
+  // — lane is the source of truth, registerBareAgent reconciles at boot.
+  writeAgentsConfig({ default: "claude", openclawProfile: null });
   console.log(c.green(`  Config written to ${ENV_PATH} + ~/.sinain/agents.json`));
   process.exit(0);
 } else {

package/package.json

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

package/sinain-agent/agents.example.json

@@ -64,7 +64,7 @@
   },
 
   "escalation": {
-    "mode": "rich",
+    "_comment": "Lane (the agent picked for escalation in agents.json `default` or via the overlay chip) is the source of truth for whether escalation runs. `mode` is intentionally omitted here — the runtime default (rich) applies, and registerBareAgent reconciles mode with lane at boot. Override `mode` only if you want to force selective/focus/off semantics.",
     "cooldownMs": 30000,
     "staleMs": 90000
   },
@@ -81,8 +81,15 @@
         "OPENAI_API_KEY": "${OPENROUTER_API_KEY}"
       }
     },
+    "codex":      { "type": "codex" },
+    "goose":      { "type": "goose" },
+    "junie":      { "type": "junie" },
+    "aider":      { "type": "aider" }
+  },
+
+  "_examples": {
     "openclaw": {
-      "_comment": "Remote gateway routing. Selecting openclaw for a lane sends that lane's traffic to the OpenClaw gateway via WS RPC instead of the local bare agent. sinain-core reads these fields directly at startup to construct the WS client. Removing this profile disables the gateway path entirely (no WS client, no openclaw chip in the overlay roster).",
+      "_comment": "OpenClaw gateway routing. Move this entry into `profiles` to enable. The wizard's `sinain onboard --advanced` step or `sinain config gateway` populates this section automatically with your gateway URL/tokens. Selecting openclaw for a lane sends that lane's traffic via WS RPC to the gateway instead of the local bare agent. Disabled by default so first-run installs don't attempt WS connections to a gateway that isn't running.",
       "type": "openclaw",
       "wsUrl": "ws://localhost:18789",
       "wsToken": "${OPENCLAW_WS_TOKEN}",
@@ -93,13 +100,6 @@
       "phase2TimeoutMs": 120000,
       "pingIntervalMs": 30000
     },
-    "codex":      { "type": "codex" },
-    "goose":      { "type": "goose" },
-    "junie":      { "type": "junie" },
-    "aider":      { "type": "aider" }
-  },
-
-  "_examples": {
     "pclaude": {
       "_comment": "Personal claude config. `bin` must be a real PATH binary — replicate a shell alias as bin+env (the alias `pclaude=CLAUDE_CONFIG_DIR=$HOME/.claude-personal claude` becomes the entry below).",
       "type": "claude",

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

@@ -99,6 +99,12 @@ export class Escalator {
   // Store context from last escalation for response handling
   private lastEscalationContext: ContextWindow | null = null;
 
+  // Knowledge enrichment is skipped on the very first escalation per process
+  // to avoid the 5s fetchKnowledgeFacts() cold-start tax on user-perceived
+  // first-response latency. Each subsequent escalation does its own fetch
+  // independently — no cross-escalation cache, no shared content state.
+  private firstEscalationDone = false;
+
   // User command to inject into the next escalation
   private pendingUserCommand: UserCommand | null = null;
   private static readonly USER_COMMAND_EXPIRY_MS = 120_000; // 2 minutes
@@ -281,8 +287,10 @@ export class Escalator {
     // Clear user command after building the message (consumed once)
     this.pendingUserCommand = null;
 
-    // Enrich with long-term knowledge facts (best-effort, 5s max)
-    if (this.deps.queryKnowledgeFacts) {
+    // Enrich with long-term knowledge facts (best-effort, 5s max).
+    // Skipped on the inaugural escalation per process to eliminate cold-start
+    // latency — the user's first response shouldn't wait for KG warmup.
+    if (this.deps.queryKnowledgeFacts && this.firstEscalationDone) {
       try {
         const knowledgeSection = await fetchKnowledgeFacts(
           contextWindow, entry.digest, this.deps.queryKnowledgeFacts,
@@ -294,7 +302,10 @@ export class Escalator {
       } catch (err) {
         log(TAG, `knowledge enrichment failed: ${String(err)}`);
       }
+    } else if (!this.firstEscalationDone) {
+      log(TAG, `first escalation: skipping knowledge fetch (fast path)`);
     }
+    this.firstEscalationDone = true;
 
     const slotId = createHash("sha256").update(this.deps.openclawConfig.sessionKey + entry.ts).digest("hex").slice(0, 16);
     const slotEntry: SlotEntry = {

package/sinain-core/src/index.ts

@@ -734,6 +734,16 @@ async function main() {
     }
     wsHandler.updateState({ agents: { ...bareAgentState } });
     log(TAG, `bareagent register: available=[${clean.join(",")}] current=${current} → lanes esc=${bareAgentState.escalationAgent} spawn=${bareAgentState.spawnAgent}`);
+
+    // Lane is the source of truth for "is escalation active?". If a lane is
+    // set but mode is still "off" (e.g. an old wizard run wrote mode=off and
+    // the user has since picked an agent in the chip selector — or we just
+    // booted from agents.json with that combination), reconcile by promoting
+    // mode to match. Mirrors the existing set_agent → resumeEscalation flow,
+    // applied at register time so the boot-from-disk case isn't an exception.
+    if (bareAgentState.escalationAgent && config.escalationConfig.mode === "off") {
+      resumeEscalationInternal();
+    }
   }
 
   // ── Create HTTP + WS server ──