@geravant/sinain 1.13.0 → 1.15.0

package/.env.example

@@ -22,30 +22,34 @@ PRIVACY_MODE=standard              # off | standard | strict | paranoid
                                    # strict: only summaries leave your machine
                                    # paranoid: almost nothing leaves your machine
 
-# ── Agent ────────────────────────────────────────────────────────────────────
-SINAIN_AGENT=claude                # claude | codex | junie | goose | aider | <custom command>
-                                   # MCP agents (claude, codex, junie, goose) call sinain tools directly
-                                   # Pipe agents (aider, custom) receive escalation text on stdin
+# ── Agent + OpenClaw config → sinain-agent/agents.json ──────────────────────
+# All bare-agent and OpenClaw gateway config (default agent, allowed-tools
+# whitelists, max turns, poll interval, escalation mode/transport, gateway
+# URLs/timeouts) lives in sinain-agent/agents.json. See agents.example.json
+# in that directory for the full schema and per-profile overrides.
+#
+# .env still works as a fallback for individual values during migration —
+# uncomment any of the lines below to override agents.json on this host:
+# SINAIN_AGENT=openclaude            # → agents.json `default`
+# SINAIN_POLL_INTERVAL=5             # → agents.json `pollIntervalSec`
+# SINAIN_AGENT_MAX_TURNS=8           # → agents.json `agentMaxTurns`
+# SINAIN_SPAWN_MAX_TURNS=25          # → agents.json `spawnMaxTurns`
+# SINAIN_ALLOWED_TOOLS=mcp__sinain   # → agents.json `allowedTools`
+# SINAIN_ESC_ALLOWED_TOOLS=...       # → agents.json `escAllowedTools`
+# SINAIN_SPAWN_ALLOWED_TOOLS=...     # → agents.json `spawnAllowedTools`
+# SINAIN_AUTO_APPROVE_TOOLS=...      # → agents.json `autoApproveTools`
+# AGENT_DEBOUNCE_MS=6000             # → agents.json `analyzer.debounceMs`
+# AGENT_MAX_INTERVAL_MS=60000        # → agents.json `analyzer.maxIntervalMs`
+# ESCALATION_MODE=rich               # → agents.json `escalation.mode`
+# ESCALATION_COOLDOWN_MS=30000       # → agents.json `escalation.cooldownMs`
+# ESCALATION_TRANSPORT was REMOVED — agent identity (openclaw vs local) is
+# the transport now. Pick "openclaw" in the overlay selector for WS dispatch.
+
 SINAIN_CORE_URL=http://localhost:9500
-SINAIN_POLL_INTERVAL=5             # seconds between escalation polls
-SINAIN_HEARTBEAT_INTERVAL=900      # seconds between heartbeat ticks (15 min)
 SINAIN_WORKSPACE=~/.openclaw/workspace  # knowledge files, curation scripts, playbook
-# SINAIN_ALLOWED_TOOLS=mcp__sinain     # MCP tools auto-approved for bare agent
-SINAIN_AGENT_MAX_TURNS=5               # max tool-use turns for escalation responses
-SINAIN_SPAWN_MAX_TURNS=25              # max tool-use turns for spawn tasks (Shift+Enter)
-                                       # auto-derived from mcp-config.json if unset
-                                       # format: mcp__<server> (all) | mcp__<server>__<tool> (specific)
-
-# ── Escalation ───────────────────────────────────────────────────────────────
-ESCALATION_MODE=rich               # off | selective | focus | rich
-                                   # off: no escalation
-                                   # selective: score-based (errors, questions trigger it)
-                                   # focus: always escalate every tick
-                                   # rich: always escalate with maximum context
-# ESCALATION_COOLDOWN_MS=10000
-# ESCALATION_TRANSPORT=auto        # ws | http | auto
-                                   # auto = WS when gateway connected, HTTP fallback
-                                   # http = bare agent only (no gateway)
+# Heartbeat (signal/insight/memory/playbook) now runs natively in sinain-core's
+# LocalCurationService every 30 min — no bare-agent heartbeat configuration needed.
+SINAIN_HEARTBEAT_INTERVAL=900
 
 # ── Server ───────────────────────────────────────────────────────────────────
 PORT=9500
@@ -88,15 +92,17 @@ TRANSCRIPTION_LANGUAGE=en-US
 # ── OpenClaw / NemoClaw Gateway ──────────────────────────────────────────────
 # Leave blank to run without a gateway (bare agent mode).
 # The setup wizard fills these in if you have an OpenClaw gateway.
-OPENCLAW_WS_URL=ws://localhost:18789
+# Gateway URLs + session moved to agents.json (`profiles.openclaw` block).
+# Tokens stay here as secrets and are referenced from agents.json via
+# ${OPENCLAW_WS_TOKEN} / ${OPENCLAW_HTTP_TOKEN} indirection.
 OPENCLAW_WS_TOKEN=                 # 48-char hex — from gateway config
-OPENCLAW_HTTP_URL=http://localhost:18789/hooks/agent
 OPENCLAW_HTTP_TOKEN=               # same token as WS_TOKEN
-OPENCLAW_SESSION_KEY=agent:main:sinain
+# Override URLs/timeouts here too if you don't want to edit agents.json:
+# OPENCLAW_WS_URL=ws://localhost:18789
+# OPENCLAW_HTTP_URL=http://localhost:18789/hooks/agent
+# OPENCLAW_SESSION_KEY=agent:main:sinain
 # OPENCLAW_PHASE1_TIMEOUT_MS=10000
 # OPENCLAW_PHASE2_TIMEOUT_MS=120000
-# OPENCLAW_QUEUE_TTL_MS=300000
-# OPENCLAW_QUEUE_MAX_SIZE=10
 # OPENCLAW_PING_INTERVAL_MS=30000
 
 # ── SITUATION.md ─────────────────────────────────────────────────────────────

package/cli.js

@@ -4,6 +4,7 @@ import net from "net";
 import os from "os";
 import fs from "fs";
 import path from "path";
+import { writeAgentsConfig } from "./config-shared.js";
 
 const cmd = process.argv[2];
 const IS_WINDOWS = os.platform() === "win32";
@@ -168,34 +169,46 @@ async function runSetupWizard() {
     if (key.trim()) vars.OPENROUTER_API_KEY = key.trim();
   }
 
-  // Agent
-  const agent = await ask(`  Agent? [${BOLD}claude${RESET}/codex/goose/junie/aider]: `);
-  vars.SINAIN_AGENT = agent.trim().toLowerCase() || "claude";
+  // Agent + escalation + gateway → agents.json (not .env). Tokens stay in
+  // .env as secrets, referenced from agents.json via ${VAR} indirection.
+  const agentsPatch = {};
+
+  // Default agent — overlay's chip selector lets the user switch at runtime;
+  // this just sets the boot-time default.
+  const agent = await ask(`  Default agent? [${BOLD}claude${RESET}/openclaude/codex/goose/junie/aider]: `);
+  agentsPatch.default = agent.trim().toLowerCase() || "claude";
 
-  // Escalation
+  // Escalation mode
   console.log(`\n  ${DIM}Escalation: off | selective | focus | rich${RESET}`);
   const esc = await ask(`  Escalation mode? [${BOLD}selective${RESET}]: `);
-  vars.ESCALATION_MODE = esc.trim().toLowerCase() || "selective";
+  agentsPatch.escalationMode = esc.trim().toLowerCase() || "selective";
 
-  // Gateway
+  // Gateway — when enabled, writes the openclaw profile to agents.json
+  // (URLs + session) and tokens to .env. There's no transport choice
+  // anymore; picking openclaw vs a local agent in the overlay determines
+  // dispatch (WS vs HTTP).
   const gw = await ask(`  OpenClaw gateway? [y/N]: `);
   if (gw.trim().toLowerCase() === "y") {
     const url = await ask(`  Gateway WS URL [ws://localhost:18789]: `);
-    vars.OPENCLAW_WS_URL = url.trim() || "ws://localhost:18789";
+    const wsUrl = url.trim() || "ws://localhost:18789";
     const token = await ask(`  Auth token (48-char hex): `);
     if (token.trim()) {
       vars.OPENCLAW_WS_TOKEN = token.trim();
       vars.OPENCLAW_HTTP_TOKEN = token.trim();
     }
-    vars.OPENCLAW_HTTP_URL = vars.OPENCLAW_WS_URL.replace(/^ws/, "http") + "/hooks/agent";
-    vars.OPENCLAW_SESSION_KEY = "agent:main:sinain";
+    agentsPatch.openclawProfile = {
+      wsUrl,
+      httpUrl: wsUrl.replace(/^ws/, "http") + "/hooks/agent",
+      wsToken: "${OPENCLAW_WS_TOKEN}",
+      httpToken: "${OPENCLAW_HTTP_TOKEN}",
+      sessionKey: "agent:main:sinain",
+    };
   } else {
-    // No gateway — disable WS connection attempts
-    vars.OPENCLAW_WS_URL = "";
-    vars.OPENCLAW_HTTP_URL = "";
+    // Skip / disable: drop the openclaw profile entirely.
+    agentsPatch.openclawProfile = null;
+    agentsPatch.escalationMode = "off";
   }
 
-  vars.SINAIN_POLL_INTERVAL = "5";
   vars.SINAIN_HEARTBEAT_INTERVAL = "900";
   vars.PRIVACY_MODE = "standard";
 
@@ -230,8 +243,11 @@ async function runSetupWizard() {
     fs.writeFileSync(envPath, lines.join("\n"));
   }
 
+  // Patch ~/.sinain/agents.json with the wizard's agent + gateway choices.
+  writeAgentsConfig(agentsPatch);
+
   rl.close();
-  console.log(`\n  ${GREEN}✓${RESET} Config written to ${envPath}\n`);
+  console.log(`\n  ${GREEN}✓${RESET} Config written to ${envPath} + ~/.sinain/agents.json\n`);
 }
 
 // ── Stop ──────────────────────────────────────────────────────────────────────

package/config-shared.js

@@ -16,6 +16,16 @@ export const PKG_DIR = path.dirname(new URL(import.meta.url).pathname);
 export const IS_WINDOWS = os.platform() === "win32";
 export const IS_MAC = os.platform() === "darwin";
 
+// Wizard write target for agents.json. Lives in user home so npm-installed
+// users (whose package dir is often read-only) get a writable path.
+// sinain-agent/run.sh and sinain-core/agents-loader.ts both check this
+// path with the highest priority after AGENTS_CONFIG_PATH env override.
+export const AGENTS_JSON_PATH = path.join(SINAIN_DIR, "agents.json");
+// agents.example.json ships inside the package as the bootstrap template
+// for first-run wizard writes (and as the fallback when no agents.json
+// exists yet on this host).
+export const AGENTS_EXAMPLE_PATH = path.join(PKG_DIR, "sinain-agent", "agents.example.json");
+
 // ── Colors ──────────────────────────────────────────────────────────────────
 
 export const c = {
@@ -111,6 +121,74 @@ export function writeEnv(vars) {
   }
 }
 
+/** Read agents.json (the wizard's authoritative agent + gateway config).
+ *
+ * Resolution order mirrors agents-loader.ts and run.sh:
+ *   1. ~/.sinain/agents.json (the wizard write target)
+ *   2. <pkg>/sinain-agent/agents.example.json (bootstrap template fallback)
+ *
+ * Returns an empty object if neither file exists or parsing fails — callers
+ * treat null/missing fields as "use schema defaults".
+ */
+export function readAgentsConfig() {
+  for (const p of [AGENTS_JSON_PATH, AGENTS_EXAMPLE_PATH]) {
+    if (!fs.existsSync(p)) continue;
+    try {
+      return JSON.parse(fs.readFileSync(p, "utf-8"));
+    } catch (err) {
+      // Bad JSON — surface, but don't crash the wizard
+      console.warn(`[config] failed to parse ${p}: ${err.message}`);
+    }
+  }
+  return {};
+}
+
+/** Patch ~/.sinain/agents.json with the given updates.
+ *
+ * `patch` shape (all optional):
+ *   - default:        string  — top-level default agent name
+ *   - escalationMode: string  — sets escalation.mode
+ *   - openclawProfile: object | null — sets profiles.openclaw
+ *                       (null deletes the openclaw profile entirely,
+ *                        which disables the gateway path)
+ *
+ * Reads the existing config first (or falls back to the shipped example),
+ * applies the patch, writes pretty-printed JSON to AGENTS_JSON_PATH.
+ * The example file is the "schema source of truth" — patches preserve any
+ * other fields the user has customized (custom profiles, allowedTools,
+ * analyzer pacing, etc.).
+ */
+export function writeAgentsConfig(patch) {
+  fs.mkdirSync(SINAIN_DIR, { recursive: true });
+  // Start from existing user config if present, else the example template
+  // (so first-run writes get the full schema, not just the patched fields).
+  let cfg;
+  if (fs.existsSync(AGENTS_JSON_PATH)) {
+    cfg = JSON.parse(fs.readFileSync(AGENTS_JSON_PATH, "utf-8"));
+  } else if (fs.existsSync(AGENTS_EXAMPLE_PATH)) {
+    cfg = JSON.parse(fs.readFileSync(AGENTS_EXAMPLE_PATH, "utf-8"));
+  } else {
+    cfg = { profiles: {} };
+  }
+
+  if (patch.default !== undefined) {
+    cfg.default = patch.default;
+  }
+  if (patch.escalationMode !== undefined) {
+    cfg.escalation = cfg.escalation || {};
+    cfg.escalation.mode = patch.escalationMode;
+  }
+  if (patch.openclawProfile === null) {
+    // Explicit removal: user picked "skip / no gateway"
+    if (cfg.profiles?.openclaw) delete cfg.profiles.openclaw;
+  } else if (patch.openclawProfile) {
+    cfg.profiles = cfg.profiles || {};
+    cfg.profiles.openclaw = { type: "openclaw", ...patch.openclawProfile };
+  }
+
+  fs.writeFileSync(AGENTS_JSON_PATH, JSON.stringify(cfg, null, 2) + "\n");
+}
+
 export async function fetchHealth(port = 9500) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(2000) });
@@ -118,16 +196,28 @@ export async function fetchHealth(port = 9500) {
   } catch { return null; }
 }
 
-/** Build a config summary for display */
+/** Build a config summary for display.
+ * Reads BOTH .env (existing arg) AND ~/.sinain/agents.json — agent + gateway
+ * config moved out of .env into agents.json after the migration, so we
+ * have to consult both to render an accurate snapshot. */
 export function summarizeConfig(existing) {
   const lines = [];
+  const agentsCfg = readAgentsConfig();
+  const openclaw = agentsCfg?.profiles?.openclaw;
+
   if (existing.OPENROUTER_API_KEY) lines.push(`API Key:       ${maskKey(existing.OPENROUTER_API_KEY)}`);
   if (existing.TRANSCRIPTION_BACKEND) lines.push(`Transcription: ${existing.TRANSCRIPTION_BACKEND}`);
   if (existing.AGENT_MODEL) lines.push(`Model:         ${existing.AGENT_MODEL}`);
   if (existing.PRIVACY_MODE) lines.push(`Privacy:       ${existing.PRIVACY_MODE}`);
-  if (existing.ESCALATION_MODE) lines.push(`Escalation:    ${existing.ESCALATION_MODE}`);
-  if (existing.OPENCLAW_WS_URL) lines.push(`Gateway:       ${existing.OPENCLAW_WS_URL}`);
-  if (existing.SINAIN_AGENT) lines.push(`Agent:         ${existing.SINAIN_AGENT}`);
+
+  // Escalation mode + agent default + gateway URL all live in agents.json
+  // now (with .env as a fallback override during the migration window).
+  const escMode = agentsCfg?.escalation?.mode || existing.ESCALATION_MODE;
+  if (escMode) lines.push(`Escalation:    ${escMode}`);
+  const gatewayUrl = openclaw?.wsUrl || existing.OPENCLAW_WS_URL;
+  if (gatewayUrl) lines.push(`Gateway:       ${gatewayUrl}`);
+  const defaultAgent = agentsCfg?.default || existing.SINAIN_AGENT;
+  if (defaultAgent) lines.push(`Agent:         ${defaultAgent}`);
   return lines;
 }
 
@@ -245,12 +335,40 @@ export async function stepTranscription(existing, label = "Audio transcription")
   return choice;
 }
 
+/**
+ * Gateway setup step.
+ *
+ * Returns `{ envVars, agentsPatch }`:
+ *   - envVars: tokens (OPENCLAW_WS_TOKEN, OPENCLAW_HTTP_TOKEN) — stay in
+ *     .env as secrets, referenced from agents.json via ${VAR} indirection
+ *   - agentsPatch: feed to writeAgentsConfig(); writes the openclaw profile
+ *     (urls + session) and escalation.mode into ~/.sinain/agents.json.
+ *
+ * The user picks whether to wire up the gateway-style profile at all.
+ * The dispatch decision (which lane uses WS vs HTTP) is made later via
+ * the overlay's per-lane agent selector — there's no transport question
+ * here anymore; agent identity IS the transport.
+ *
+ * Pre-existing gateway config is read from agents.json first, then .env
+ * as a backwards-compat fallback for users migrating from before the
+ * profile refactor.
+ */
 export async function stepGateway(existing, label = "OpenClaw gateway") {
+  // Read existing gateway config from BOTH places — wizard might be
+  // running mid-migration where some users still have OPENCLAW_WS_URL in
+  // .env but agents.json's openclaw profile is absent.
+  const agentsCfg = readAgentsConfig();
+  const oc = agentsCfg?.profiles?.openclaw;
+  const existingWsUrl = oc?.wsUrl || existing.OPENCLAW_WS_URL || "";
+
   p.note(
-    "The gateway gives sinain a persistent AI agent (Claude/Codex/Goose)\n" +
-    "that handles complex tasks, background research, and multi-step actions.\n" +
-    "Without it, sinain still works — HUD analysis runs locally via OpenRouter.",
-    "What is a gateway?",
+    "The gateway gives sinain a persistent agent backend (OpenClaw/NemoClaw)\n" +
+    "that handles escalations and background tasks via WS RPC. Without it,\n" +
+    "the local bare agent (claude, openclaude, etc.) handles everything via\n" +
+    "the HTTP path.\n\n" +
+    "You can pick which agent handles each lane (escalation/spawn) at runtime\n" +
+    "via the overlay's flash-icon selector.",
+    "About the gateway",
   );
 
   const choice = guard(await p.select({
@@ -259,7 +377,7 @@ export async function stepGateway(existing, label = "OpenClaw gateway") {
       {
         value: "skip",
         label: "Skip / Disable",
-        hint: "HUD works fine without it — add later with sinain config",
+        hint: "Local agents only — add a gateway later with `sinain config`",
       },
       {
         value: "local",
@@ -272,16 +390,15 @@ export async function stepGateway(existing, label = "OpenClaw gateway") {
         hint: "Connect to existing gateway (URL + token)",
       },
     ],
-    initialValue: existing.OPENCLAW_WS_URL ? "remote" : "skip",
+    initialValue: existingWsUrl ? "remote" : "skip",
   }));
 
   if (choice === "skip") {
+    // Drop the openclaw profile from agents.json entirely. Tokens cleared
+    // in .env so they don't linger as misleading secrets.
     return {
-      OPENCLAW_WS_URL: "",
-      OPENCLAW_HTTP_URL: "",
-      OPENCLAW_WS_TOKEN: "",
-      OPENCLAW_HTTP_TOKEN: "",
-      ESCALATION_MODE: "off",
+      envVars: { OPENCLAW_WS_TOKEN: "", OPENCLAW_HTTP_TOKEN: "" },
+      agentsPatch: { escalationMode: "off", openclawProfile: null },
     };
   }
 
@@ -293,7 +410,7 @@ export async function stepGateway(existing, label = "OpenClaw gateway") {
   const wsUrl = guard(await p.text({
     message: "Gateway WebSocket URL",
     placeholder: "Example: ws://192.168.1.100:18789",
-    defaultValue: existing.OPENCLAW_WS_URL || "",
+    defaultValue: existingWsUrl,
     validate: (val) => {
       if (!val) return "URL is required";
       if (!val.startsWith("ws://") && !val.startsWith("wss://")) return "Must start with ws:// or wss://";
@@ -322,13 +439,24 @@ export async function stepGateway(existing, label = "OpenClaw gateway") {
   }
 
   const httpUrl = wsUrl.replace(/^ws/, "http") + "/hooks/agent";
+  // Tokens → .env; URLs + session → agents.json. The agents.json profile
+  // references the env tokens via ${OPENCLAW_WS_TOKEN}/${OPENCLAW_HTTP_TOKEN}
+  // indirection (resolved by sinain-core's agents-loader at startup).
   return {
-    OPENCLAW_WS_URL: wsUrl,
-    OPENCLAW_HTTP_URL: httpUrl,
-    OPENCLAW_WS_TOKEN: token,
-    OPENCLAW_HTTP_TOKEN: token,
-    OPENCLAW_SESSION_KEY: "agent:main:sinain",
-    ESCALATION_MODE: "rich",
+    envVars: {
+      OPENCLAW_WS_TOKEN: token,
+      OPENCLAW_HTTP_TOKEN: token,
+    },
+    agentsPatch: {
+      escalationMode: "rich",
+      openclawProfile: {
+        wsUrl,
+        httpUrl,
+        wsToken: "${OPENCLAW_WS_TOKEN}",
+        httpToken: "${OPENCLAW_HTTP_TOKEN}",
+        sessionKey: "agent:main:sinain",
+      },
+    },
   };
 }
 
@@ -352,10 +480,16 @@ async function setupLocalGateway(existing) {
           "Install manually: npm install -g openclaw\nThen re-run setup.",
           "Manual install",
         );
-        return { OPENCLAW_WS_URL: "", OPENCLAW_HTTP_URL: "", ESCALATION_MODE: "off" };
+        return {
+          envVars: { OPENCLAW_WS_TOKEN: "", OPENCLAW_HTTP_TOKEN: "" },
+          agentsPatch: { escalationMode: "off", openclawProfile: null },
+        };
       }
     } else {
-      return { OPENCLAW_WS_URL: "", OPENCLAW_HTTP_URL: "", ESCALATION_MODE: "off" };
+      return {
+        envVars: { OPENCLAW_WS_TOKEN: "", OPENCLAW_HTTP_TOKEN: "" },
+        agentsPatch: { escalationMode: "off", openclawProfile: null },
+      };
     }
   }
 
@@ -380,12 +514,20 @@ async function setupLocalGateway(existing) {
   }
 
   return {
-    OPENCLAW_WS_URL: "ws://localhost:18789",
-    OPENCLAW_HTTP_URL: "http://localhost:18789/hooks/agent",
-    OPENCLAW_WS_TOKEN: token,
-    OPENCLAW_HTTP_TOKEN: token,
-    OPENCLAW_SESSION_KEY: "agent:main:sinain",
-    ESCALATION_MODE: "rich",
+    envVars: {
+      OPENCLAW_WS_TOKEN: token,
+      OPENCLAW_HTTP_TOKEN: token,
+    },
+    agentsPatch: {
+      escalationMode: "rich",
+      openclawProfile: {
+        wsUrl: "ws://localhost:18789",
+        httpUrl: "http://localhost:18789/hooks/agent",
+        wsToken: "${OPENCLAW_WS_TOKEN}",
+        httpToken: "${OPENCLAW_HTTP_TOKEN}",
+        sessionKey: "agent:main:sinain",
+      },
+    },
   };
 }
 
@@ -459,6 +601,7 @@ export async function stepAgent(existing, label = "Bare agent") {
     message: label,
     options: [
       { value: "claude", label: "Claude Code", hint: "Calls sinain tools directly — recommended" },
+      { value: "openclaude", label: "OpenClaude", hint: "Claude Code clone, local-first (Ollama/OpenAI-compat)" },
       { value: "codex", label: "Codex", hint: "Calls sinain tools directly" },
       { value: "goose", label: "Goose", hint: "Calls sinain tools directly" },
       { value: "junie", label: "Junie", hint: "JetBrains IDE agent" },

package/launcher.js

@@ -8,6 +8,7 @@ import path from "path";
 import os from "os";
 import net from "net";
 import readline from "readline";
+import { writeAgentsConfig, readAgentsConfig } from "./config-shared.js";
 
 // ── Colors ──────────────────────────────────────────────────────────────────
 
@@ -486,10 +487,14 @@ async function setupWizard(envPath) {
     else if (existingKey) vars.OPENROUTER_API_KEY = existingKey;
   }
 
-  // 3. Agent selection
-  const defaultAgent = existing.SINAIN_AGENT || "claude";
-  const agentChoice = await ask(`  Agent? [${BOLD}${defaultAgent}${RESET}/claude/codex/goose/junie/aider]: `);
-  vars.SINAIN_AGENT = agentChoice.trim().toLowerCase() || defaultAgent;
+  // 3. Agent selection — written to agents.json `default` field. Existing
+  // value is read from agents.json first, falling back to .env for users
+  // mid-migration.
+  const existingAgentsCfg = readAgentsConfig();
+  const agentsPatch = {};
+  const defaultAgent = existingAgentsCfg?.default || existing.SINAIN_AGENT || "claude";
+  const agentChoice = await ask(`  Default agent? [${BOLD}${defaultAgent}${RESET}/claude/openclaude/codex/goose/junie/aider]: `);
+  agentsPatch.default = agentChoice.trim().toLowerCase() || defaultAgent;
 
   // 3b. Local vision (Ollama)
   const IS_MACOS = os.platform() === "darwin";
@@ -543,28 +548,32 @@ async function setupWizard(envPath) {
     }
   }
 
-  // 4. Escalation mode
+  // 4. Escalation mode — agents.json `escalation.mode`
   console.log();
   console.log(`  ${DIM}Escalation modes:${RESET}`);
-  console.log(`    off       — no escalation to gateway`);
+  console.log(`    off       — no escalation`);
   console.log(`    selective — score-based (errors, questions trigger it)`);
   console.log(`    focus     — always escalate every tick`);
   console.log(`    rich      — always escalate with maximum context`);
-  const defaultEsc = existing.ESCALATION_MODE || "selective";
+  const defaultEsc = existingAgentsCfg?.escalation?.mode || existing.ESCALATION_MODE || "selective";
   const escMode = await ask(`  Escalation mode? [off/${BOLD}${defaultEsc}${RESET}/selective/focus/rich]: `);
-  vars.ESCALATION_MODE = escMode.trim().toLowerCase() || defaultEsc;
-
-  // 5. OpenClaw gateway
-  const hadGateway = !!(existing.OPENCLAW_WS_URL);
+  agentsPatch.escalationMode = escMode.trim().toLowerCase() || defaultEsc;
+
+  // 5. OpenClaw gateway — URLs/session → agents.json (openclaw profile),
+  // tokens → .env. No transport question; agent identity (openclaw vs
+  // local) determines dispatch path.
+  const existingOpenclaw = existingAgentsCfg?.profiles?.openclaw;
+  const existingWsUrl = existingOpenclaw?.wsUrl || existing.OPENCLAW_WS_URL || "";
+  const hadGateway = !!existingWsUrl;
   const gatewayDefault = hadGateway ? "Y" : "N";
   const hasGateway = await ask(`  Do you have an OpenClaw gateway? [${gatewayDefault === "Y" ? "Y/n" : "y/N"}]: `);
   const wantsGateway = hasGateway.trim()
     ? hasGateway.trim().toLowerCase() === "y"
     : hadGateway;
   if (wantsGateway) {
-    const defaultWs = existing.OPENCLAW_WS_URL || "ws://localhost:18789";
+    const defaultWs = existingWsUrl || "ws://localhost:18789";
     const wsUrl = await ask(`  Gateway WebSocket URL [${defaultWs}]: `);
-    vars.OPENCLAW_WS_URL = wsUrl.trim() || defaultWs;
+    const finalWsUrl = wsUrl.trim() || defaultWs;
 
     const existingToken = existing.OPENCLAW_WS_TOKEN;
     const tokenHint = existingToken ? ` [${existingToken.slice(0, 6)}...${existingToken.slice(-4)}]` : "";
@@ -577,14 +586,16 @@ async function setupWizard(envPath) {
       vars.OPENCLAW_HTTP_TOKEN = existing.OPENCLAW_HTTP_TOKEN || existingToken;
     }
 
-    // Derive HTTP URL from WS URL
-    const httpBase = vars.OPENCLAW_WS_URL.replace(/^ws/, "http");
-    vars.OPENCLAW_HTTP_URL = `${httpBase}/hooks/agent`;
-    vars.OPENCLAW_SESSION_KEY = existing.OPENCLAW_SESSION_KEY || "agent:main:sinain";
+    agentsPatch.openclawProfile = {
+      wsUrl: finalWsUrl,
+      httpUrl: finalWsUrl.replace(/^ws/, "http") + "/hooks/agent",
+      wsToken: "${OPENCLAW_WS_TOKEN}",
+      httpToken: "${OPENCLAW_HTTP_TOKEN}",
+      sessionKey: existingOpenclaw?.sessionKey || "agent:main:sinain",
+    };
   } else {
-    // No gateway — disable WS connection attempts
-    vars.OPENCLAW_WS_URL = "";
-    vars.OPENCLAW_HTTP_URL = "";
+    // No gateway — drop the openclaw profile entirely.
+    agentsPatch.openclawProfile = null;
   }
 
   // 6. Knowledge import (for standalone machines)
@@ -662,10 +673,16 @@ async function setupWizard(envPath) {
     fs.writeFileSync(envPath, lines.join("\n"));
   }
 
+  // Flush agent + gateway answers to ~/.sinain/agents.json (separate file
+  // from .env after the profile-config refactor).
+  if (Object.keys(agentsPatch).length > 0) {
+    writeAgentsConfig(agentsPatch);
+  }
+
   rl.close();
 
   console.log();
-  ok(`Config written to ${envPath}`);
+  ok(`Config written to ${envPath} + ~/.sinain/agents.json`);
   console.log();
 }