@p-sw/brainbox 0.1.2-alpha.13 → 0.1.2-alpha.2

package/dist/index.js

@@ -4,17 +4,12 @@
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join6 } from "path";
+import { dirname as dirname4, join as join4 } from "path";
 
 // src/utils/logger.ts
 import chalk from "chalk";
-import {
-  existsSync,
-  mkdirSync,
-  createWriteStream,
-  writeFileSync
-} from "fs";
-import { join } from "path";
+import { existsSync, mkdirSync, createWriteStream } from "fs";
+import { dirname } from "path";
 var LEVELS = {
   debug: { rank: 0, color: chalk.gray, stderr: false },
   info: { rank: 1, color: chalk.blue, stderr: false },
@@ -31,98 +26,48 @@ var ICONS = {
   error: "✖",
   fatal: "▲"
 };
-function pad2(n) {
-  return n < 10 ? `0${n}` : `${n}`;
-}
-function dateKey(d = new Date) {
-  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
-}
-
-class DailyFileSink {
-  dir;
-  date;
-  stream;
-  setDir(dir) {
-    if (dir === this.dir)
-      return;
-    this.stream?.end();
-    this.stream = undefined;
-    this.date = undefined;
-    this.dir = dir;
-    if (dir && !existsSync(dir))
-      mkdirSync(dir, { recursive: true });
-  }
-  write(data) {
-    if (!this.dir)
-      return;
-    const today = dateKey();
-    if (!this.stream || this.date !== today) {
-      this.stream?.end();
-      this.date = today;
-      if (!existsSync(this.dir))
-        mkdirSync(this.dir, { recursive: true });
-      this.stream = createWriteStream(join(this.dir, `${today}.log`), {
-        flags: "a"
-      });
-    }
-    this.stream.write(data);
-  }
-  close() {
-    this.stream?.end();
-    this.stream = undefined;
-    this.date = undefined;
-    this.dir = undefined;
-  }
-  get enabled() {
-    return this.dir !== undefined;
-  }
-}
-var shared = {
-  level: "info",
-  timestamps: true,
-  colors: chalk.level > 0,
-  json: false,
-  silent: false
-};
-var mainSink = new DailyFileSink;
-var llmLogDir;
-function applyShared(options) {
-  if (options.level !== undefined)
-    shared.level = options.level;
-  if (options.timestamps !== undefined)
-    shared.timestamps = options.timestamps;
-  if (options.colors !== undefined)
-    shared.colors = options.colors;
-  if (options.silent !== undefined)
-    shared.silent = options.silent;
-  if (options.json !== undefined)
-    shared.json = options.json;
-  if ("logDir" in options)
-    mainSink.setDir(options.logDir);
-}
 
 class Logger {
+  level;
+  timestamps;
+  colors;
   tag;
+  file;
+  json;
+  silent;
+  fileStream;
   constructor(options = {}) {
+    this.level = options.level ?? "info";
+    this.timestamps = options.timestamps ?? true;
+    this.colors = options.colors ?? chalk.level > 0;
     this.tag = options.tag;
-    applyShared(options);
+    this.file = options.file;
+    this.json = options.json ?? false;
+    this.silent = options.silent ?? false;
+    if (this.file) {
+      const dir = dirname(this.file);
+      if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+      this.fileStream = createWriteStream(this.file, { flags: "a" });
+    }
   }
   shouldLog(level) {
-    return LEVELS[level].rank >= LEVELS[shared.level].rank;
+    return LEVELS[level].rank >= LEVELS[this.level].rank;
   }
   formatTimestamp() {
     const now = new Date;
-    return `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())} ${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())}`;
+    const pad = (n) => n.toString().padStart(2, "0");
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
   }
   format(level, message) {
-    const ts = shared.timestamps ? `[${this.formatTimestamp()}]` : "";
+    const ts = this.timestamps ? `[${this.formatTimestamp()}]` : "";
     const tag = this.tag ? `[${this.tag}]` : "";
     const icon = ICONS[level];
     const levelStr = level.toUpperCase();
     const consoleParts = [
       ts,
       tag,
-      shared.colors ? LEVELS[level].color(icon) : icon,
+      this.colors ? LEVELS[level].color(icon) : icon,
       message
     ].filter(Boolean);
     const consoleLine = consoleParts.join(" ");
@@ -145,13 +90,13 @@ class Logger {
       return;
     const { console: consoleLine, file: fileLine } = this.format(level, message);
     const jsonLine = this.formatJson(level, message);
-    if (!shared.silent) {
+    if (!this.silent) {
       const out = LEVELS[level].stderr ? process.stderr : process.stdout;
       out.write(consoleLine + `
 `);
     }
-    if (mainSink.enabled) {
-      mainSink.write(shared.json ? jsonLine : fileLine);
+    if (this.fileStream) {
+      this.fileStream.write(this.json ? jsonLine : fileLine);
     }
   }
   debug(message) {
@@ -174,56 +119,57 @@ class Logger {
   }
   child(tag) {
     const combined = this.tag ? `${this.tag}:${tag}` : tag;
-    return new Logger({ tag: combined });
+    return new Logger({
+      level: this.level,
+      timestamps: this.timestamps,
+      colors: this.colors,
+      tag: combined,
+      file: this.file,
+      json: this.json,
+      silent: this.silent
+    });
   }
   configure(options) {
+    if (options.level !== undefined)
+      this.level = options.level;
+    if (options.timestamps !== undefined)
+      this.timestamps = options.timestamps;
+    if (options.colors !== undefined)
+      this.colors = options.colors;
     if (options.tag !== undefined)
       this.tag = options.tag;
-    applyShared(options);
+    if (options.silent !== undefined)
+      this.silent = options.silent;
+    if (options.json !== undefined)
+      this.json = options.json;
+    if (options.file !== undefined && options.file !== this.file) {
+      this.fileStream?.end();
+      this.file = options.file;
+      if (this.file) {
+        const dir = dirname(this.file);
+        if (!existsSync(dir))
+          mkdirSync(dir, { recursive: true });
+        this.fileStream = createWriteStream(this.file, { flags: "a" });
+      } else {
+        this.fileStream = undefined;
+      }
+    }
   }
   close() {
-    mainSink.close();
-    llmLogDir = undefined;
+    this.fileStream?.end();
   }
 }
 var logger = new Logger;
-function configureLlmLog(logDir) {
-  llmLogDir = logDir;
-  if (logDir && !existsSync(logDir))
-    mkdirSync(logDir, { recursive: true });
-}
-function isLlmLogEnabled() {
-  return llmLogDir !== undefined;
-}
-function sanitizeCaller(caller) {
-  const s = caller.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  return s.length > 0 ? s : "unknown";
-}
-function dateTimeKey(d = new Date) {
-  return `${dateKey(d)}-${pad2(d.getHours())}-${pad2(d.getMinutes())}-${pad2(d.getSeconds())}`;
-}
-function writeLlmExchange(caller, content) {
-  if (!llmLogDir)
-    return;
-  if (!existsSync(llmLogDir))
-    mkdirSync(llmLogDir, { recursive: true });
-  const base = `${dateTimeKey()}-${sanitizeCaller(caller)}`;
-  let path = join(llmLogDir, `${base}.log`);
-  for (let n = 2;existsSync(path); n += 1) {
-    path = join(llmLogDir, `${base}-${n}.log`);
-  }
-  writeFileSync(path, content, "utf8");
-}
 
 // src/config/loader.ts
-import { dirname, join as join2, resolve } from "path";
+import { dirname as dirname2, join, resolve } from "path";
 import { z, ZodError } from "zod";
 import { homedir } from "os";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import { mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
-var brainboxRoot = process.env["BRAINBOX_ROOT_PATH"] ? resolve(process.cwd(), process.env["BRAINBOX_ROOT_PATH"]) : join2(homedir(), ".brainbox");
+import { mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+var brainboxRoot = process.env["BRAINBOX_ROOT_PATH"] ? resolve(process.cwd(), process.env["BRAINBOX_ROOT_PATH"]) : join(homedir(), ".brainbox");
 function configFile(file, options) {
-  const path = () => join2(brainboxRoot, file);
+  const path = () => join(brainboxRoot, file);
   const read = () => {
     const p = path();
     let raw;
@@ -235,8 +181,8 @@ function configFile(file, options) {
       const defaults = defaultsFromSchema(options.schema);
       const templateStr = (options.header ? options.header + `
 ` : "") + (defaults === undefined ? "" : stringifyYaml(defaults));
-      mkdirSync2(dirname(p), { recursive: true });
-      writeFileSync2(p, templateStr);
+      mkdirSync2(dirname2(p), { recursive: true });
+      writeFileSync(p, templateStr);
       raw = defaults ?? {};
     }
     try {
@@ -253,8 +199,8 @@ function configFile(file, options) {
   };
   const write = (value) => {
     const p = path();
-    mkdirSync2(dirname(p), { recursive: true });
-    writeFileSync2(p, stringifyYaml(value));
+    mkdirSync2(dirname2(p), { recursive: true });
+    writeFileSync(p, stringifyYaml(value));
   };
   const update = (fn) => {
     const next = fn(read());
@@ -349,7 +295,7 @@ function removeProviderAuth(provider) {
 // src/config/index.ts
 var config = {
   get debug() {
-    return process.env.DEBUG_MODE ? process.env.DEBUG_MODE.toLowerCase() === "true" : readRootFile().debug;
+    return readRootFile().debug;
   },
   brainboxRoot,
   get supermemoryApiKey() {
@@ -375,7 +321,7 @@ function registerCommand(program, config2) {
 
 // src/brain/manager.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 var log = logger.child("brain-manager");
 
 class BrainDBManager {
@@ -384,7 +330,7 @@ class BrainDBManager {
     this.root = root;
   }
   dbFile() {
-    return join3(this.root, "brains.json");
+    return join2(this.root, "brains.json");
   }
   async readDB() {
     try {
@@ -484,106 +430,6 @@ function defaultReasoningEffort(effort, model, identityModel) {
     return effort;
   return model === identityModel ? "medium" : "none";
 }
-function stripThinkTags(content) {
-  return content.replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, "").trim();
-}
-function parseModelJson(content) {
-  const cleaned = stripThinkTags(content);
-  const candidates = [cleaned];
-  const fence = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  if (fence?.[1])
-    candidates.push(fence[1].trim());
-  const extracted = extractJsonSlice(cleaned);
-  if (extracted)
-    candidates.push(extracted);
-  let lastErr;
-  for (const candidate of candidates) {
-    try {
-      return decodeJsonValue(candidate);
-    } catch (err) {
-      lastErr = err;
-    }
-  }
-  throw lastErr instanceof Error ? lastErr : new Error("Failed to parse model JSON");
-}
-function decodeJsonValue(text) {
-  let value = JSON.parse(text);
-  for (let i = 0;i < 2 && typeof value === "string"; i++) {
-    const inner = value.trim();
-    if (!(inner.startsWith("{") && inner.endsWith("}") || inner.startsWith("[") && inner.endsWith("]") || inner.startsWith('"') && inner.endsWith('"'))) {
-      break;
-    }
-    value = JSON.parse(inner);
-  }
-  return value;
-}
-function extractJsonSlice(text) {
-  const start = text.search(/[\{\[]/);
-  if (start < 0)
-    return;
-  const open = text[start];
-  const close = open === "{" ? "}" : "]";
-  let depth = 0;
-  let inString = false;
-  let escape = false;
-  for (let i = start;i < text.length; i++) {
-    const ch = text[i];
-    if (inString) {
-      if (escape) {
-        escape = false;
-      } else if (ch === "\\") {
-        escape = true;
-      } else if (ch === '"') {
-        inString = false;
-      }
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-      continue;
-    }
-    if (ch === open)
-      depth++;
-    else if (ch === close) {
-      depth--;
-      if (depth === 0)
-        return text.slice(start, i + 1);
-    }
-  }
-  return;
-}
-function schemaToolName(name) {
-  const cleaned = name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
-  return cleaned.length > 0 ? cleaned : "submit_result";
-}
-function buildStructuredJsonRequest(options) {
-  const toolName = schemaToolName(options.jsonSchemaName);
-  return {
-    toolName,
-    tool: {
-      name: toolName,
-      description: `Submit the structured ${options.jsonSchemaName} result.`,
-      parameters: options.jsonSchema ?? {
-        type: "object",
-        additionalProperties: true
-      }
-    },
-    instruction: `${options.instruction}
-
-You MUST call the \`${toolName}\` tool exactly once with the complete answer.
-Do not write the JSON as plain text or inside a markdown code fence.`
-  };
-}
-function parseStructuredJsonResult(choice, toolName) {
-  const call = choice.message.toolCalls?.find((c) => c.function.name === toolName) ?? choice.message.toolCalls?.[0];
-  if (call?.function.arguments) {
-    return parseModelJson(call.function.arguments);
-  }
-  if (choice.message.content) {
-    return parseModelJson(choice.message.content);
-  }
-  throw new Error("Empty response from model");
-}
 function readAuthString(auth, key, envName) {
   const fromAuth = typeof auth?.[key] === "string" ? auth[key] : undefined;
   if (fromAuth)
@@ -597,42 +443,6 @@ function readAuthString(auth, key, envName) {
 }
 
 class LLMExecutor {
-  async chatWithToolExecution(model, options) {
-    const messages = options.messages.slice();
-    const maxSteps = options.maxSteps ?? 20;
-    let last;
-    for (let step = 0;step < maxSteps; step += 1) {
-      log2.debug(`chatWithToolExecution: step ${step + 1}/${maxSteps} msgs=${messages.length}`);
-      last = await this.chatWithTools(model, {
-        instruction: options.instruction,
-        messages,
-        tools: options.tools,
-        caller: options.caller,
-        reasoningEffort: options.reasoningEffort,
-        parallelToolCalls: options.parallelToolCalls,
-        toolChoice: options.toolChoice
-      });
-      const toolCalls = last.message.toolCalls ?? [];
-      log2.debug(`chatWithToolExecution: step ${step + 1} toolCalls=${toolCalls.length}`);
-      if (toolCalls.length === 0)
-        return last;
-      messages.push({
-        role: "assistant",
-        content: last.message.content,
-        toolCalls
-      });
-      for (const call of toolCalls) {
-        const content = await options.executeTool(call);
-        messages.push({
-          role: "tool",
-          toolCallId: call.id,
-          content
-        });
-      }
-    }
-    log2.warn(`chatWithToolExecution: reached maxSteps (${maxSteps}) without final reply`);
-    return last;
-  }
   static providers = [];
   static registerProvider(p) {
     LLMExecutor.providers.push(p);
@@ -699,19 +509,6 @@ class LLMExecutor {
     };
   }
 }
-function resolveLlmCaller(options, fallback = "llm") {
-  return options.caller ?? options.jsonSchemaName ?? fallback;
-}
-function logLlmWire(caller, request, response) {
-  if (!isLlmLogEnabled())
-    return;
-  writeLlmExchange(caller, `======== REQUEST ========
-${request}
-
-======== RESPONSE ========
-${response}
-`);
-}
 function listProviderNames() {
   return LLMExecutor.listProviderNames();
 }
@@ -749,7 +546,7 @@ function fromOrChoice(choice) {
   }));
   return {
     message: {
-      content: typeof msg.content === "string" ? stripThinkTags(msg.content) : undefined,
+      content: typeof msg.content === "string" ? msg.content : undefined,
       toolCalls
     }
   };
@@ -780,54 +577,53 @@ class OpenRouterExecutor extends LLMExecutor {
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
     log3.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
-    const chatRequest = {
-      model,
-      messages: [
-        { role: "system", content: options.instruction },
-        { role: "user", content: options.message }
-      ],
-      reasoning: {
-        effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
-      },
-      responseFormat: jsonMode ? {
-        type: "json_schema",
-        jsonSchema: {
-          name: options.jsonSchemaName,
-          schema: options.jsonSchema,
-          strict: true
-        }
-      } : { type: "text" },
-      stream: false
-    };
-    const result = await this.client.chat.send({ chatRequest });
-    logLlmWire(resolveLlmCaller(options), JSON.stringify(chatRequest), JSON.stringify(result));
-    const raw = result.choices[0]?.message?.content;
-    const content = typeof raw === "string" ? stripThinkTags(raw) : raw;
+    const result = await this.client.chat.send({
+      chatRequest: {
+        model,
+        messages: [
+          { role: "system", content: options.instruction },
+          { role: "user", content: options.message }
+        ],
+        reasoning: {
+          effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
+        },
+        responseFormat: jsonMode ? {
+          type: "json_schema",
+          jsonSchema: {
+            name: options.jsonSchemaName,
+            schema: options.jsonSchema,
+            strict: true
+          }
+        } : { type: "text" },
+        stream: false
+      }
+    });
+    const content = result.choices[0]?.message?.content;
     if (!content) {
       log3.debug(`call: empty content in choice 0`);
       throw new Error("Empty response from model");
     }
     log3.debug(`call: response ${content.length} chars`);
-    return jsonMode ? parseModelJson(content) : content;
+    return jsonMode ? JSON.parse(content) : content;
   }
   async chatWithTools(model, options) {
     log3.debug(`chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
-    const chatRequest = {
-      model,
-      messages: [
-        { role: "system", content: options.instruction },
-        ...options.messages.map(toOrMessage)
-      ],
-      reasoning: {
-        effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
-      },
-      responseFormat: { type: "text" },
-      tools: options.tools.map(toOrTool),
-      parallelToolCalls: options.parallelToolCalls ?? false,
-      stream: false
-    };
-    const result = await this.client.chat.send({ chatRequest });
-    logLlmWire(resolveLlmCaller(options), JSON.stringify(chatRequest), JSON.stringify(result));
+    const result = await this.client.chat.send({
+      chatRequest: {
+        model,
+        messages: [
+          { role: "system", content: options.instruction },
+          ...options.messages.map(toOrMessage)
+        ],
+        reasoning: {
+          effort: options.reasoningEffort ?? (model === this.models.identity ? REASONING_EFFORT_MAP.medium : REASONING_EFFORT_MAP.none)
+        },
+        responseFormat: { type: "text" },
+        tools: options.tools.map(toOrTool),
+        parallelToolCalls: options.parallelToolCalls ?? false,
+        stream: false
+      }
+    });
     const choice = result.choices[0];
     if (!choice) {
       log3.debug(`chatWithTools: no choice in response`);
@@ -867,7 +663,7 @@ function fromChoice(choice) {
   }));
   return {
     message: {
-      content: typeof msg.content === "string" ? stripThinkTags(msg.content) : undefined,
+      content: typeof msg.content === "string" ? msg.content : undefined,
       toolCalls
     }
   };
@@ -902,7 +698,6 @@ class OpenAICompatibleExecutor extends LLMExecutor {
   chatPath;
   noBearerPrefix;
   reasoningEffortInQuery;
-  supportsResponseFormat;
   constructor(opts) {
     super();
     this.providerName = opts.providerName;
@@ -912,7 +707,6 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     this.chatPath = opts.chatPath ?? "/chat/completions";
     this.noBearerPrefix = opts.noBearerPrefix ?? false;
     this.reasoningEffortInQuery = opts.reasoningEffortInQuery ?? false;
-    this.supportsResponseFormat = opts.supportsResponseFormat ?? true;
     this.models = {
       conversation: opts.conversationModel,
       identity: opts.identityModel
@@ -943,7 +737,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     }
     return url.toString();
   }
-  async sendRequest(body, reasoningEffort, caller) {
+  async sendRequest(body, reasoningEffort) {
     const modelName = body["model"];
     const modelStr = typeof modelName === "string" ? modelName : "";
     const url = this.buildRequestUrl(modelStr, reasoningEffort);
@@ -953,40 +747,24 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       ...authHeader,
       ...this.defaultHeaders
     };
-    const requestRaw = JSON.stringify(body);
     const res = await fetch(url, {
       method: "POST",
       headers,
-      body: requestRaw
+      body: JSON.stringify(body)
     });
-    const responseRaw = await res.text().catch(() => "");
-    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      log4.error(`${this.providerName}: HTTP ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
+      const text = await res.text().catch(() => "");
+      log4.error(`${this.providerName}: HTTP ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
       throw new Error(`${this.providerName} request failed: ${res.status} ${res.statusText}`);
     }
-    let data;
-    try {
-      data = JSON.parse(responseRaw);
-    } catch {
-      throw new Error(`${this.providerName}: invalid JSON response`);
-    }
+    const data = await res.json();
     if (data.error) {
       log4.error(`${this.providerName}: API error ${data.error.type ?? ""} ${data.error.message ?? ""}`);
       throw new Error(`${this.providerName} API error: ${data.error.message ?? "unknown"}`);
     }
-    const baseCode = data.base_resp?.status_code;
-    if (typeof baseCode === "number" && baseCode !== 0) {
-      const msg = data.base_resp?.status_msg?.trim() || `status_code ${baseCode}`;
-      log4.error(`${this.providerName}: base_resp ${baseCode} ${msg}`);
-      throw new Error(`${this.providerName} API error: ${msg}`);
-    }
     return data;
   }
   async call(model, options) {
-    if ("jsonSchemaName" in options && !this.supportsResponseFormat) {
-      return this.callJsonViaTool(model, options);
-    }
     const jsonMode = "jsonSchemaName" in options;
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     log4.debug(`call: provider=${this.providerName} model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
@@ -999,31 +777,14 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       responseFormat: jsonMode ? buildResponseFormat(options.jsonSchemaName, options.jsonSchema) : undefined,
       reasoningEffort: reasoning
     });
-    const data = await this.sendRequest(body, options.reasoningEffort, resolveLlmCaller(options));
-    const choice = data.choices?.[0];
-    const raw = choice?.message?.content;
-    const content = typeof raw === "string" ? stripThinkTags(raw) : raw;
+    const data = await this.sendRequest(body, options.reasoningEffort);
+    const content = data.choices?.[0]?.message?.content;
     if (!content) {
-      const finish = choice?.finish_reason ?? "no-choice";
-      const reasoningLen = typeof choice?.message?.reasoning_content === "string" ? choice.message.reasoning_content.length : 0;
-      log4.debug(`call: empty content in choice 0 finish_reason=${finish} reasoning_len=${reasoningLen} rawType=${raw === null ? "null" : typeof raw}`);
-      throw new Error(reasoningLen > 0 ? `Empty response from model (finish_reason=${finish}; reasoning present but no content)` : "Empty response from model");
+      log4.debug(`call: empty content in choice 0`);
+      throw new Error("Empty response from model");
     }
     log4.debug(`call: response ${content.length} chars`);
-    return jsonMode ? parseModelJson(content) : content;
-  }
-  async callJsonViaTool(model, options) {
-    const { toolName, tool, instruction } = buildStructuredJsonRequest(options);
-    log4.debug(`callJsonViaTool: provider=${this.providerName} model=${model} tool=${toolName}`);
-    const choice = await this.chatWithTools(model, {
-      caller: options.caller ?? options.jsonSchemaName,
-      instruction,
-      messages: [{ role: "user", content: options.message }],
-      tools: [tool],
-      reasoningEffort: "none",
-      parallelToolCalls: false
-    });
-    return parseStructuredJsonResult(choice, toolName);
+    return jsonMode ? JSON.parse(content) : content;
   }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
@@ -1038,7 +799,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       parallelToolCalls: options.parallelToolCalls ?? false,
       reasoningEffort: reasoning
     });
-    const data = await this.sendRequest(body, options.reasoningEffort, resolveLlmCaller(options));
+    const data = await this.sendRequest(body, options.reasoningEffort);
     const choice = data.choices?.[0];
     if (!choice) {
       log4.debug(`chatWithTools: no choice in response`);
@@ -1337,41 +1098,16 @@ class ZenMuxExecutor extends OpenAICompatibleExecutor {
   }
 }
 
-// src/provider/providers/minimax.ts
-class MiniMaxBase extends OpenAICompatibleExecutor {
-  buildBody(opts) {
-    const jsonMode = opts.responseFormat !== undefined;
-    const body = super.buildBody(opts);
-    delete body["reasoning_effort"];
-    delete body["response_format"];
-    delete body["parallel_tool_calls"];
-    body["reasoning_split"] = true;
-    body["max_completion_tokens"] = 16384;
-    const wantThink = !jsonMode && opts.reasoningEffort !== undefined && opts.reasoningEffort !== "none";
-    body["thinking"] = wantThink ? { type: "adaptive" } : { type: "disabled" };
-    return body;
-  }
-}
-function minimaxOpts(providerName, baseURL, opts) {
-  return {
-    providerName,
-    baseURL,
-    apiKey: opts.apiKey,
-    conversationModel: opts.conversationModel,
-    identityModel: opts.identityModel,
-    supportsResponseFormat: false
-  };
-}
-
-class MiniMaxExecutor extends MiniMaxBase {
-  constructor(opts) {
-    super(minimaxOpts("minimax", "https://api.minimax.io/v1", opts));
-  }
-}
-
-class MiniMaxCnExecutor extends MiniMaxBase {
+// src/provider/providers/MiniMax.ts
+class MiniMaxExecutor extends OpenAICompatibleExecutor {
   constructor(opts) {
-    super(minimaxOpts("minimax-cn", "https://api.minimaxi.com/v1", opts));
+    super({
+      providerName: "MiniMax",
+      baseURL: "https://api.MiniMax.chat/v1",
+      apiKey: opts.apiKey,
+      conversationModel: opts.conversationModel,
+      identityModel: opts.identityModel
+    });
   }
 }
 
@@ -1435,8 +1171,7 @@ class LmStudioExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:1234/v1",
       apiKey: opts.apiKey || "lm-studio",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-      supportsResponseFormat: false
+      identityModel: opts.identityModel
     });
   }
 }
@@ -1449,8 +1184,7 @@ class OllamaExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:11434/v1",
       apiKey: opts.apiKey || "ollama",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-      supportsResponseFormat: false
+      identityModel: opts.identityModel
     });
   }
 }
@@ -1476,8 +1210,7 @@ class LlamaCppExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:8080/v1",
       apiKey: opts.apiKey || "llama.cpp",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-      supportsResponseFormat: false
+      identityModel: opts.identityModel
     });
   }
 }
@@ -1527,17 +1260,7 @@ class CloudflareGatewayExecutor extends OpenAICompatibleExecutor {
 // src/provider/providers/cloudflare_workers.ts
 function toCloudflareMessage(m) {
   if (m.role === "assistant") {
-    return {
-      role: "assistant",
-      content: m.content ?? "",
-      tool_calls: m.toolCalls?.map((c) => {
-        let args = c.function.arguments;
-        try {
-          args = JSON.parse(c.function.arguments);
-        } catch {}
-        return { id: c.id, name: c.function.name, arguments: args };
-      })
-    };
+    return { role: "assistant", content: m.content ?? "" };
   }
   if (m.role === "tool") {
     return { role: "tool", content: m.content, tool_call_id: m.toolCallId };
@@ -1560,23 +1283,21 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     const accountId = readAuthString(opts.auth, "accountId", "CLOUDFLARE_ACCOUNT_ID");
     this.baseURL = accountId ? `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run` : "https://api.cloudflare.com/client/v4/accounts/__cf_account_id__/ai/run";
   }
-  async run(model, body, caller) {
+  async run(model, body) {
     const url = `${this.baseURL}/${encodeURIComponent(model)}`;
-    const requestRaw = JSON.stringify(body);
     const res = await fetch(url, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: requestRaw
+      body: JSON.stringify(body)
     });
-    const responseRaw = await res.text().catch(() => "");
-    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      throw new Error(`cloudflare-workers request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
+      const text = await res.text().catch(() => "");
+      throw new Error(`cloudflare-workers request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
     }
-    return JSON.parse(responseRaw);
+    return await res.json();
   }
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
@@ -1597,15 +1318,15 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.run(model, body, resolveLlmCaller(options));
+    const data = await this.run(model, body);
     if (data.errors && data.errors.length > 0) {
       throw new Error(`cloudflare-workers API error: ${data.errors.map((e) => e.message).join("; ")}`);
     }
-    const content = stripThinkTags(data.result?.response ?? "");
+    const content = data.result?.response ?? "";
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(content) : content;
+    return jsonMode ? JSON.parse(content) : content;
   }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
@@ -1626,11 +1347,11 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.run(model, body, resolveLlmCaller(options));
+    const data = await this.run(model, body);
     if (data.errors && data.errors.length > 0) {
       throw new Error(`cloudflare-workers API error: ${data.errors.map((e) => e.message).join("; ")}`);
     }
-    const content = stripThinkTags(data.result?.response ?? "");
+    const content = data.result?.response ?? "";
     const toolCalls = data.result?.tool_calls?.map((c, idx) => ({
       id: `call_${idx}`,
       function: {
@@ -1668,8 +1389,7 @@ class AzureOpenAIExecutor extends OpenAICompatibleExecutor {
     super({
       providerName: "azure-openai",
       baseURL: `https://${resource || "__resource__"}.openai.azure.com/openai/deployments`,
-      apiKey: "",
-      defaultHeaders: { "api-key": opts.apiKey },
+      apiKey: opts.apiKey,
       conversationModel: opts.conversationModel,
       identityModel: opts.identityModel
     });
@@ -1689,8 +1409,7 @@ class AzureCognitiveExecutor extends OpenAICompatibleExecutor {
     super({
       providerName: "azure-cognitive",
       baseURL: `https://${resource || "__resource__"}.cognitiveservices.azure.com/openai/deployments`,
-      apiKey: "",
-      defaultHeaders: { "api-key": opts.apiKey },
+      apiKey: opts.apiKey,
       conversationModel: opts.conversationModel,
       identityModel: opts.identityModel
     });
@@ -1716,17 +1435,17 @@ var AnthropicAuthSchema = z4.object({
   apiVersion: z4.string().optional()
 }).loose();
 function toAnthropicMessages(messages) {
-  let system2;
-  const msgs2 = [];
+  let system;
+  const msgs = [];
   for (const m of messages) {
     if (m.role === "system") {
-      system2 = (system2 ? system2 + `
+      system = (system ? system + `
 
 ` : "") + m.content;
       continue;
     }
     if (m.role === "user") {
-      msgs2.push({ role: "user", content: m.content });
+      msgs.push({ role: "user", content: m.content });
       continue;
     }
     if (m.role === "assistant") {
@@ -1749,11 +1468,11 @@ function toAnthropicMessages(messages) {
           });
         }
       }
-      msgs2.push({ role: "assistant", content: blocks });
+      msgs.push({ role: "assistant", content: blocks });
       continue;
     }
     if (m.role === "tool") {
-      msgs2.push({
+      msgs.push({
         role: "user",
         content: [
           {
@@ -1765,7 +1484,7 @@ function toAnthropicMessages(messages) {
       });
     }
   }
-  return { system: system2, msgs: msgs2 };
+  return { system, msgs };
 }
 function toAnthropicTool(t) {
   return {
@@ -1793,8 +1512,7 @@ class AnthropicExecutor extends LLMExecutor {
     this.baseURL = (extra.baseURL ?? readAuthString(opts.auth, "baseURL", "ANTHROPIC_BASE_URL") ?? "https://api.anthropic.com").replace(/\/v1\/?$/, "");
     this.apiVersion = extra.apiVersion ?? "2023-06-01";
   }
-  async send(body, caller) {
-    const requestRaw = JSON.stringify(body);
+  async send(body) {
     const res = await fetch(`${this.baseURL}/v1/messages`, {
       method: "POST",
       headers: {
@@ -1802,93 +1520,65 @@ class AnthropicExecutor extends LLMExecutor {
         "anthropic-version": this.apiVersion,
         "Content-Type": "application/json"
       },
-      body: requestRaw
+      body: JSON.stringify(body)
     });
-    const responseRaw = await res.text().catch(() => "");
-    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      throw new Error(`anthropic request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
+      const text = await res.text().catch(() => "");
+      throw new Error(`anthropic request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
     }
-    return JSON.parse(responseRaw);
+    return await res.json();
   }
   async call(model, options) {
-    if ("jsonSchemaName" in options) {
-      const { toolName, tool, instruction } = buildStructuredJsonRequest({
-        instruction: options.instruction,
-        jsonSchemaName: options.jsonSchemaName,
-        jsonSchema: options.jsonSchema
-      });
-      const choice = await this.chatWithTools(model, {
-        caller: options.caller ?? options.jsonSchemaName,
-        instruction,
-        messages: [{ role: "user", content: options.message }],
-        tools: [tool],
-        reasoningEffort: "none",
-        toolChoice: { type: "tool", name: toolName }
-      });
-      return parseStructuredJsonResult(choice, toolName);
-    }
+    const jsonMode = "jsonSchemaName" in options;
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:anthropic");
-    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
-    const outputCap = 4096;
+    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
     const body = {
       model,
-      max_tokens: outputCap,
+      max_tokens: 4096,
       system: options.instruction,
       messages: [{ role: "user", content: options.message }]
     };
     if (reasoning !== "none") {
-      const budget = REASONING_BUDGET[reasoning];
-      body["max_tokens"] = budget + outputCap;
       body["thinking"] = {
         type: "enabled",
-        budget_tokens: budget
+        budget_tokens: REASONING_BUDGET[reasoning]
       };
     }
-    const data = await this.send(body, resolveLlmCaller(options));
+    const data = await this.send(body);
     if (data.error) {
       throw new Error(`anthropic API error: ${data.error.message ?? "unknown"}`);
     }
-    const text = stripThinkTags((data.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join(""));
+    const text = (data.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("");
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return text;
+    return jsonMode ? JSON.parse(text) : text;
   }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:anthropic");
     log5.debug(`chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
-    const { system: system2, msgs: msgs2 } = toAnthropicMessages(options.messages);
-    const outputCap = 4096;
+    const { system, msgs } = toAnthropicMessages(options.messages);
     const body = {
       model,
-      max_tokens: outputCap,
-      system: system2 ?? options.instruction,
-      messages: msgs2,
+      max_tokens: 4096,
+      system: system ?? options.instruction,
+      messages: msgs,
       tools: options.tools.map(toAnthropicTool)
     };
-    if (options.toolChoice) {
-      body["tool_choice"] = {
-        type: "tool",
-        name: options.toolChoice.name
-      };
-    }
     if (reasoning !== "none") {
-      const budget = REASONING_BUDGET[reasoning];
-      body["max_tokens"] = budget + outputCap;
       body["thinking"] = {
         type: "enabled",
-        budget_tokens: budget
+        budget_tokens: REASONING_BUDGET[reasoning]
       };
     }
-    const data = await this.send(body, resolveLlmCaller(options));
+    const data = await this.send(body);
     if (data.error) {
       throw new Error(`anthropic API error: ${data.error.message ?? "unknown"}`);
     }
     const blocks = data.content ?? [];
-    const text = stripThinkTags(blocks.filter((b) => b.type === "text").map((b) => b.text).join(""));
+    const text = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
     const toolCalls = blocks.filter((b) => b.type === "tool_use").map((b) => ({
       id: b.id,
       function: {
@@ -1902,11 +1592,11 @@ class AnthropicExecutor extends LLMExecutor {
 
 // src/provider/providers/bedrock.ts
 import { createHmac, createHash } from "node:crypto";
-var pad22 = (n) => n.toString().padStart(2, "0");
+var pad2 = (n) => n.toString().padStart(2, "0");
 function amzDate(now) {
   return {
-    date: `${now.getUTCFullYear()}${pad22(now.getUTCMonth() + 1)}${pad22(now.getUTCDate())}`,
-    datetime: `${now.getUTCFullYear()}${pad22(now.getUTCMonth() + 1)}${pad22(now.getUTCDate())}T` + `${pad22(now.getUTCHours())}${pad22(now.getUTCMinutes())}${pad22(now.getUTCSeconds())}Z`
+    date: `${now.getUTCFullYear()}${pad2(now.getUTCMonth() + 1)}${pad2(now.getUTCDate())}`,
+    datetime: `${now.getUTCFullYear()}${pad2(now.getUTCMonth() + 1)}${pad2(now.getUTCDate())}T` + `${pad2(now.getUTCHours())}${pad2(now.getUTCMinutes())}${pad2(now.getUTCSeconds())}Z`
   };
 }
 function signRequest(opts) {
@@ -1953,6 +1643,58 @@ function signRequest(opts) {
     headers["X-Amz-Security-Token"] = opts.sessionToken;
   return headers;
 }
+function toAnthropicMessages2(messages) {
+  let system;
+  const msgs = [];
+  for (const m of messages) {
+    if (m.role === "system") {
+      system = (system ? system + `
+
+` : "") + m.content;
+      continue;
+    }
+    if (m.role === "user") {
+      msgs.push({ role: "user", content: [{ type: "text", text: m.content }] });
+      continue;
+    }
+    if (m.role === "assistant") {
+      const blocks = [];
+      if (m.content)
+        blocks.push({ type: "text", text: m.content });
+      if (m.toolCalls) {
+        for (const c of m.toolCalls) {
+          let input = {};
+          try {
+            input = c.function.arguments ? JSON.parse(c.function.arguments) : {};
+          } catch {
+            input = {};
+          }
+          blocks.push({
+            type: "tool_use",
+            id: c.id,
+            name: c.function.name,
+            input
+          });
+        }
+      }
+      msgs.push({ role: "assistant", content: blocks });
+      continue;
+    }
+    if (m.role === "tool") {
+      msgs.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: m.toolCallId,
+            content: [{ type: "text", text: m.content }]
+          }
+        ]
+      });
+    }
+  }
+  return { system, msgs };
+}
 function toAnthropicTool2(t) {
   return {
     name: t.name,
@@ -1962,7 +1704,7 @@ function toAnthropicTool2(t) {
 }
 function extractAnthropicContent(data) {
   const content = data["content"] ?? [];
-  const text = stripThinkTags(content.filter((b) => b["type"] === "text").map((b) => b["text"]).join(""));
+  const text = content.filter((b) => b["type"] === "text").map((b) => b["text"]).join("");
   const toolCalls = content.filter((b) => b["type"] === "tool_use").map((b) => ({
     id: b["id"],
     function: {
@@ -1994,7 +1736,7 @@ class BedrockExecutor extends LLMExecutor {
     this.sessionToken = readAuthString(opts.auth, "sessionToken", "AWS_SESSION_TOKEN");
     this.baseURL = `https://bedrock-runtime.${this.region}.amazonaws.com`;
   }
-  async invoke(model, body, caller) {
+  async invoke(model, body) {
     const bodyStr = JSON.stringify(body);
     const path = `/model/${encodeURIComponent(model)}/invoke`;
     const headers = signRequest({
@@ -2013,32 +1755,16 @@ class BedrockExecutor extends LLMExecutor {
       headers,
       body: bodyStr
     });
-    const responseRaw = await res.text().catch(() => "");
-    logLlmWire(caller, bodyStr, responseRaw);
     if (!res.ok) {
-      throw new Error(`bedrock request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
+      const text = await res.text().catch(() => "");
+      throw new Error(`bedrock request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
     }
-    return JSON.parse(responseRaw);
+    return await res.json();
   }
   async call(model, options) {
+    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:bedrock");
-    if ("jsonSchemaName" in options) {
-      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
-      const { toolName, tool, instruction } = buildStructuredJsonRequest({
-        instruction: options.instruction,
-        jsonSchemaName: options.jsonSchemaName,
-        jsonSchema: options.jsonSchema
-      });
-      const choice = await this.chatWithTools(model, {
-        caller: options.caller ?? options.jsonSchemaName,
-        instruction,
-        messages: [{ role: "user", content: options.message }],
-        tools: [tool],
-        toolChoice: { type: "tool", name: toolName }
-      });
-      return parseStructuredJsonResult(choice, toolName);
-    }
-    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
+    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
     if (!model.startsWith("anthropic.") && !model.startsWith("us.anthropic.")) {
       throw new Error(`bedrock provider currently only supports Anthropic models (got ${model})`);
     }
@@ -2048,12 +1774,12 @@ class BedrockExecutor extends LLMExecutor {
       system: options.instruction,
       messages: [{ role: "user", content: options.message }]
     };
-    const data = await this.invoke(model, body, resolveLlmCaller(options));
+    const data = await this.invoke(model, body);
     const { text } = extractAnthropicContent(data);
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return text;
+    return jsonMode ? JSON.parse(text) : text;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:bedrock");
@@ -2061,6 +1787,7 @@ class BedrockExecutor extends LLMExecutor {
     if (!model.startsWith("anthropic.") && !model.startsWith("us.anthropic.")) {
       throw new Error(`bedrock provider currently only supports Anthropic models (got ${model})`);
     }
+    const { system, msgs } = toAnthropicMessages2(options.messages);
     const body = {
       anthropic_version: "bedrock-2023-05-31",
       max_tokens: 4096,
@@ -2068,13 +1795,7 @@ class BedrockExecutor extends LLMExecutor {
       messages: msgs,
       tools: options.tools.map(toAnthropicTool2)
     };
-    if (options.toolChoice) {
-      body.tool_choice = {
-        type: "tool",
-        name: options.toolChoice.name
-      };
-    }
-    const data = await this.invoke(model, body, resolveLlmCaller(options));
+    const data = await this.invoke(model, body);
     const { text, toolCalls } = extractAnthropicContent(data);
     return { message: { content: text || undefined, toolCalls } };
   }
@@ -2088,7 +1809,6 @@ var VertexAuthSchema = z5.object({
 }).loose();
 function toGeminiContents(messages) {
   const out = [];
-  const nameByCallId = new Map;
   for (const m of messages) {
     if (m.role === "system")
       continue;
@@ -2102,7 +1822,6 @@ function toGeminiContents(messages) {
         parts.push({ text: m.content });
       if (m.toolCalls) {
         for (const c of m.toolCalls) {
-          nameByCallId.set(c.id, c.function.name);
           let args = {};
           try {
             args = c.function.arguments ? JSON.parse(c.function.arguments) : {};
@@ -2124,26 +1843,21 @@ function toGeminiContents(messages) {
       }
       out.push({
         role: "user",
-        parts: [
-          {
-            functionResponse: {
-              name: nameByCallId.get(m.toolCallId) ?? "",
-              response
-            }
-          }
-        ]
+        parts: [{ functionResponse: { name: "", response } }]
       });
     }
   }
   return out;
 }
-function toGeminiTools(tools) {
+function toGeminiTool(t) {
   return {
-    functionDeclarations: tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters ?? { type: "object", properties: {} }
-    }))
+    functionDeclarations: [
+      {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters ?? { type: "object", properties: {} }
+      }
+    ]
   };
 }
 function extractFromGemini(data) {
@@ -2164,10 +1878,7 @@ function extractFromGemini(data) {
       });
     }
   }
-  return {
-    text: stripThinkTags(text),
-    toolCalls: toolCalls.length > 0 ? toolCalls : undefined
-  };
+  return { text, toolCalls: toolCalls.length > 0 ? toolCalls : undefined };
 }
 
 class VertexExecutor extends LLMExecutor {
@@ -2190,23 +1901,21 @@ class VertexExecutor extends LLMExecutor {
     this.region = extra.region ?? readAuthString(opts.auth, "region", "GOOGLE_CLOUD_REGION") ?? "us-central1";
     this.baseURL = this.project ? `https://${this.region}-aiplatform.googleapis.com/v1/projects/${this.project}/locations/${this.region}/publishers/google/models` : "https://us-central1-aiplatform.googleapis.com/v1";
   }
-  async generate(model, body, caller) {
+  async generate(model, body) {
     const url = `${this.baseURL}/${encodeURIComponent(model)}:generateContent`;
-    const requestRaw = JSON.stringify(body);
     const res = await fetch(url, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: requestRaw
+      body: JSON.stringify(body)
     });
-    const responseRaw = await res.text().catch(() => "");
-    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      throw new Error(`vertex request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
+      const text = await res.text().catch(() => "");
+      throw new Error(`vertex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
     }
-    return JSON.parse(responseRaw);
+    return await res.json();
   }
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
@@ -2227,7 +1936,7 @@ class VertexExecutor extends LLMExecutor {
         responseSchema: options.jsonSchema
       };
     }
-    const data = await this.generate(model, body, resolveLlmCaller(options));
+    const data = await this.generate(model, body);
     if (data.error) {
       throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2235,7 +1944,7 @@ class VertexExecutor extends LLMExecutor {
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(text) : text;
+    return jsonMode ? JSON.parse(text) : text;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:vertex");
@@ -2244,9 +1953,9 @@ class VertexExecutor extends LLMExecutor {
     const body = {
       contents,
       systemInstruction: { parts: [{ text: options.instruction }] },
-      tools: options.tools.length > 0 ? [toGeminiTools(options.tools)] : undefined
+      tools: options.tools.length > 0 ? [toGeminiTool(options.tools[0])] : undefined
     };
-    const data = await this.generate(model, body, resolveLlmCaller(options));
+    const data = await this.generate(model, body);
     if (data.error) {
       throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2322,41 +2031,25 @@ class GitLabDuoExecutor extends LLMExecutor {
     const extra = parsed.success ? parsed.data : {};
     this.baseURL = (extra.baseURL ?? readAuthString(opts.auth, "baseURL", "GITLAB_BASE_URL") ?? "https://gitlab.com/api/v4/ai/llm/proxy").replace(/\/+$/, "");
   }
-  async send(body, caller) {
-    const requestRaw = JSON.stringify(body);
+  async send(body) {
     const res = await fetch(this.baseURL, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: requestRaw
+      body: JSON.stringify(body)
     });
-    const responseRaw = await res.text().catch(() => "");
-    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      throw new Error(`gitlab-duo request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
+      const text = await res.text().catch(() => "");
+      throw new Error(`gitlab-duo request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
     }
-    return JSON.parse(responseRaw);
+    return await res.json();
   }
   async call(model, options) {
+    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:gitlab-duo");
-    if ("jsonSchemaName" in options) {
-      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
-      const { toolName, tool, instruction } = buildStructuredJsonRequest({
-        instruction: options.instruction,
-        jsonSchemaName: options.jsonSchemaName,
-        jsonSchema: options.jsonSchema
-      });
-      const choice = await this.chatWithTools(model, {
-        caller: options.caller ?? options.jsonSchemaName,
-        instruction,
-        messages: [{ role: "user", content: options.message }],
-        tools: [tool]
-      });
-      return parseStructuredJsonResult(choice, toolName);
-    }
-    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
+    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
     const body = {
       model,
       messages: [
@@ -2364,15 +2057,15 @@ class GitLabDuoExecutor extends LLMExecutor {
         { role: "user", content: options.message }
       ]
     };
-    const data = await this.send(body, resolveLlmCaller(options));
+    const data = await this.send(body);
     if (data.error) {
       throw new Error(`gitlab-duo API error: ${data.error.message ?? "unknown"}`);
     }
-    const content = stripThinkTags(data.choices?.[0]?.message?.content ?? "");
+    const content = data.choices?.[0]?.message?.content ?? "";
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return content;
+    return jsonMode ? JSON.parse(content) : content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:gitlab-duo");
@@ -2385,7 +2078,7 @@ class GitLabDuoExecutor extends LLMExecutor {
       ],
       tools: options.tools.map(toTool)
     };
-    const data = await this.send(body, resolveLlmCaller(options));
+    const data = await this.send(body);
     if (data.error) {
       throw new Error(`gitlab-duo API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2396,7 +2089,7 @@ class GitLabDuoExecutor extends LLMExecutor {
     }));
     return {
       message: {
-        content: choice?.message?.content ? stripThinkTags(choice.message.content) : undefined,
+        content: choice?.message?.content ?? undefined,
         toolCalls
       }
     };
@@ -2453,43 +2146,26 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     const account = extra.account ?? readAuthString(opts.auth, "account", "SNOWFLAKE_ACCOUNT") ?? "";
     this.baseURL = account ? `https://${account}.snowflakecomputing.com/api/v2/cortex/inference:complete` : "https://__account__.snowflakecomputing.com/api/v2/cortex/inference:complete";
   }
-  async send(body, caller) {
-    const requestRaw = JSON.stringify(body);
+  async send(body) {
     const res = await fetch(this.baseURL, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: requestRaw
+      body: JSON.stringify(body)
     });
-    const responseRaw = await res.text().catch(() => "");
-    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      throw new Error(`snowflake-cortex request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
+      const text = await res.text().catch(() => "");
+      throw new Error(`snowflake-cortex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
     }
-    return JSON.parse(responseRaw);
+    return await res.json();
   }
   async call(model, options) {
-    const log5 = logger.child("llm:snowflake-cortex");
-    if ("jsonSchemaName" in options) {
-      log5.debug(`call: model=${model} jsonSchema=${options.jsonSchemaName} via tool`);
-      const { toolName, tool, instruction } = buildStructuredJsonRequest({
-        instruction: options.instruction,
-        jsonSchemaName: options.jsonSchemaName,
-        jsonSchema: options.jsonSchema
-      });
-      const choice = await this.chatWithTools(model, {
-        caller: options.caller ?? options.jsonSchemaName,
-        instruction,
-        messages: [{ role: "user", content: options.message }],
-        tools: [tool],
-        reasoningEffort: "none"
-      });
-      return parseStructuredJsonResult(choice, toolName);
-    }
+    const jsonMode = "jsonSchemaName" in options;
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
-    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
+    const log5 = logger.child("llm:snowflake-cortex");
+    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
     const body = {
       model,
       messages: [
@@ -2500,15 +2176,15 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.send(body, resolveLlmCaller(options));
+    const data = await this.send(body);
     if (data.error) {
       throw new Error(`snowflake-cortex API error: ${data.error.message ?? "unknown"}`);
     }
-    const content = stripThinkTags(data.choices?.[0]?.message?.content ?? data.message ?? "");
+    const content = data.choices?.[0]?.message?.content ?? data.message ?? "";
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return content;
+    return jsonMode ? JSON.parse(content) : content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:snowflake-cortex");
@@ -2521,12 +2197,12 @@ class SnowflakeCortexExecutor extends LLMExecutor {
       ],
       tools: options.tools.map(toCortexTool)
     };
-    const data = await this.send(body, resolveLlmCaller(options));
+    const data = await this.send(body);
     if (data.error) {
       throw new Error(`snowflake-cortex API error: ${data.error.message ?? "unknown"}`);
     }
     const choice = data.choices?.[0];
-    const content = stripThinkTags(choice?.message?.content ?? data.message ?? "");
+    const content = choice?.message?.content ?? data.message ?? "";
     const toolCalls = choice?.message?.tool_calls?.map((c) => ({
       id: c.id,
       function: {
@@ -2565,8 +2241,7 @@ register("stackit", StackitExecutor);
 register("gmi", GmiExecutor);
 register("zai", ZaiExecutor);
 register("zenmux", ZenMuxExecutor);
-register("minimax", MiniMaxExecutor);
-register("minimax-cn", MiniMaxCnExecutor);
+register("MiniMax", MiniMaxExecutor);
 register("ionet", IoNetExecutor);
 register("baseten", BasetenExecutor);
 register("cortecs", CortecsExecutor);
@@ -2600,14 +2275,14 @@ var llm = new Proxy({}, {
 // src/provider/promptLoader.ts
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
-import path, { dirname as dirname2 } from "path";
+import path, { dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var log5 = logger.child("prompt-loader");
 function fileName(promptKey) {
   return promptKey.toLowerCase() + ".md";
 }
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname2(__filename2);
+var __dirname2 = dirname3(__filename2);
 var PROMPTS_DIR = existsSync2(path.resolve(__dirname2, "prompts")) ? path.resolve(__dirname2, "prompts") : path.resolve(__dirname2, "../../prompts");
 async function loadPrompt(promptKey) {
   const filePath = path.join(PROMPTS_DIR, fileName(promptKey));
@@ -2732,14 +2407,14 @@ function translateMessageHistory(personaName, entries) {
 }
 
 // src/brain/schedule.ts
-function pad23(n) {
+function pad22(n) {
   return n < 10 ? `0${n}` : `${n}`;
 }
 function formatDateKey(d) {
-  return `${d.getFullYear()}-${pad23(d.getMonth() + 1)}-${pad23(d.getDate())}`;
+  return `${d.getFullYear()}-${pad22(d.getMonth() + 1)}-${pad22(d.getDate())}`;
 }
 function formatMonthKey(d) {
-  return `${d.getFullYear()}-${pad23(d.getMonth() + 1)}`;
+  return `${d.getFullYear()}-${pad22(d.getMonth() + 1)}`;
 }
 
 // src/brain/memory.ts
@@ -2827,22 +2502,22 @@ class Brain {
   db;
   space;
   brainbase;
-  availabilityCache = new Map;
   memory;
-  constructor(db, space, brainbase, memory) {
+  availabilityCache = new Map;
+  constructor(db, space, brainbase, memory = new Memory(this.db, this.space)) {
     this.db = db;
     this.space = space;
     this.brainbase = brainbase;
-    this.memory = memory ?? new Memory(this.db, this.space);
+    this.memory = memory;
     log7.debug(`Brain constructed: id=${brainbase.brainId} name=${brainbase.displayName} space=${space.name}`);
   }
   async createDailySchedule(datetime) {
-    const dateKey2 = formatDateKey(datetime);
-    log7.debug(`createDailySchedule: starting for ${dateKey2}`);
+    const dateKey = formatDateKey(datetime);
+    log7.debug(`createDailySchedule: starting for ${dateKey}`);
     try {
-      const existing = await this.memory.get(`daily-schedule:${dateKey2}`);
+      const existing = await this.memory.get(`daily-schedule:${dateKey}`);
       if (existing) {
-        log7.debug(`createDailySchedule: cache hit for ${dateKey2}`);
+        log7.debug(`createDailySchedule: cache hit for ${dateKey}`);
         try {
           return JSON.parse(existing.content);
         } catch (parseErr) {
@@ -2870,7 +2545,7 @@ class Brain {
       }
       const instruction = await loadPrompt("DAILY_SCHEDULE");
       const promptMessage = [
-        `Target date: ${dateKey2} (${datetime.toLocaleDateString("en-US", { weekday: "long" })})`,
+        `Target date: ${dateKey} (${datetime.toLocaleDateString("en-US", { weekday: "long" })})`,
         `Personality: ${this.brainbase.baseSystemPrompt}`,
         monthlySummary ? `Monthly summary for this day: ${monthlySummary}` : "(no monthly summary available for this date)",
         `Recent schedule (${twoDaysAgoKey}, 2 days ago): ${twoDaysAgoSchedule ? twoDaysAgoSchedule.items.map((s) => `${s.start} ${s.activity}`).join(", ") : "(no schedule on file for 2 days ago)"}`,
@@ -2881,7 +2556,6 @@ class Brain {
 `);
       log7.debug(`createDailySchedule: calling identity model`);
       const schedule = await llm.call(llm.models.identity, {
-        caller: "daily-schedule",
         instruction,
         message: promptMessage,
         jsonSchemaName: "daily-schedule",
@@ -2889,15 +2563,15 @@ class Brain {
       });
       log7.debug(`createDailySchedule: model returned ${schedule.items.length} slots`);
       await this.memory.add({
-        customId: `daily-schedule:${dateKey2}`,
+        customId: `daily-schedule:${dateKey}`,
         content: JSON.stringify(schedule),
         metadata: {
           kind: "schedule",
           source: "createDailySchedule",
-          date: dateKey2
+          date: dateKey
         }
       });
-      log7.debug(`createDailySchedule: persisted ${dateKey2}`);
+      log7.debug(`createDailySchedule: persisted ${dateKey}`);
       return schedule;
     } catch (error) {
       let reason = error instanceof Error ? error.message + `(${error.name})` : String(error);
@@ -2909,21 +2583,17 @@ class Brain {
   }
   async regenerateSchedules() {
     const today = new Date;
-    const nextMonth = new Date(today.getFullYear(), today.getMonth() + 1, today.getDate());
-    const monthly = await this.createMonthlySchedule(nextMonth);
-    if (!monthly) {
-      log7.debug(`regenerateSchedules: skip daily — monthly schedule generation failed`);
-      return;
-    }
     const tomorrow = new Date(today.getFullYear(), today.getMonth(), today.getDate() + 1);
     await this.createDailySchedule(tomorrow);
     await this.createDailySchedule(today);
+    const nextMonth = new Date(today.getFullYear(), today.getMonth() + 1, today.getDate());
+    await this.createMonthlySchedule(nextMonth);
   }
   async createMonthlySchedule(datetime) {
     const year = datetime.getMonth() === 11 ? datetime.getFullYear() + 1 : datetime.getFullYear();
     const month = (datetime.getMonth() + 1) % 12;
     const daysInMonth = new Date(year, month + 1, 0).getDate();
-    const monthKey = `${year}-${pad23(month + 1)}`;
+    const monthKey = `${year}-${pad22(month + 1)}`;
     log7.debug(`createMonthlySchedule: starting for ${monthKey}`);
     try {
       const existing = await this.memory.get(`monthly-schedule:${monthKey}`);
@@ -2936,7 +2606,7 @@ class Brain {
         }
       }
       const twoMonthsAgo = new Date(year, month - 2, 1);
-      const twoMonthsAgoKey = `${twoMonthsAgo.getFullYear()}-${pad23(twoMonthsAgo.getMonth() + 1)}`;
+      const twoMonthsAgoKey = `${twoMonthsAgo.getFullYear()}-${pad22(twoMonthsAgo.getMonth() + 1)}`;
       log7.debug(`createMonthlySchedule: gathering context (history, ${twoMonthsAgoKey})`);
       const [history, twoMonthsAgoStored] = await Promise.all([
         this.getHistoryFacts(),
@@ -2964,7 +2634,6 @@ class Brain {
 `);
       log7.debug(`createMonthlySchedule: calling identity model`);
       const schedule = await llm.call(llm.models.identity, {
-        caller: "monthly-schedule",
         instruction,
         message: promptMessage,
         jsonSchemaName: "monthly-schedule",
@@ -2995,11 +2664,11 @@ class Brain {
     }
     log7.debug(`sleepMemory: starting, ${history.length} messages`);
     try {
-      const dateKey2 = formatDateKey(datetime);
+      const dateKey = formatDateKey(datetime);
       const instruction = await loadPrompt("MEMOIR");
       const historyBlock = translateMessageHistory(this.brainbase.displayName, history);
       const promptMessage = [
-        `Date: ${dateKey2}`,
+        `Date: ${dateKey}`,
         `Personality: ${this.brainbase.baseSystemPrompt}`,
         `Conversation log:`,
         historyBlock
@@ -3008,21 +2677,20 @@ class Brain {
 `);
       log7.debug(`sleepMemory: calling identity model`);
       const memoir = await llm.call(llm.models.identity, {
-        caller: "sleep-memory",
         instruction,
         message: promptMessage
       });
       log7.debug(`sleepMemory: model returned ${memoir.length} chars`);
       await this.memory.add({
-        customId: `daily-journal:${dateKey2}`,
+        customId: `daily-journal:${dateKey}`,
         content: memoir,
         metadata: {
           kind: "daily-journal",
           source: "sleepMemory",
-          date: dateKey2
+          date: dateKey
         }
       });
-      log7.debug(`sleepMemory: journal persisted for ${dateKey2}`);
+      log7.debug(`sleepMemory: journal persisted for ${dateKey}`);
       return memoir;
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
@@ -3031,22 +2699,22 @@ class Brain {
     }
   }
   async getTodayScheduledAvailability(datetime) {
-    const dateKey2 = formatDateKey(datetime);
+    const dateKey = formatDateKey(datetime);
     try {
-      const cached = this.availabilityCache.get(dateKey2);
+      const cached = this.availabilityCache.get(dateKey);
       if (cached) {
-        log7.debug(`getTodayScheduledAvailability: cache hit for ${dateKey2}`);
+        log7.debug(`getTodayScheduledAvailability: cache hit for ${dateKey}`);
         return cached;
       }
-      const stored = await this.memory.get(`daily-schedule:${dateKey2}`);
+      const stored = await this.memory.get(`daily-schedule:${dateKey}`);
       if (!stored) {
-        log7.debug(`getTodayScheduledAvailability: no schedule for ${dateKey2}`);
+        log7.debug(`getTodayScheduledAvailability: no schedule for ${dateKey}`);
         return null;
       }
       const dailySchedule = JSON.parse(stored.content);
       const availability = await this.deriveAvailabilityFromSchedule(dailySchedule);
-      this.availabilityCache.set(dateKey2, availability);
-      log7.debug(`getTodayScheduledAvailability: cached ${availability.items.length} windows for ${dateKey2}`);
+      this.availabilityCache.set(dateKey, availability);
+      log7.debug(`getTodayScheduledAvailability: cached ${availability.items.length} windows for ${dateKey}`);
       return availability;
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
@@ -3057,7 +2725,7 @@ class Brain {
   async getAvailability(datetime = new Date) {
     const h = datetime.getHours();
     const m = datetime.getMinutes();
-    const hhmm = `${pad23(h)}:${pad23(m)}`;
+    const hhmm = `${pad22(h)}:${pad22(m)}`;
     const current = h * 60 + m;
     const toMinutes = (s) => {
       const [hh = 0, mm = 0] = s.split(":").map((x) => parseInt(x, 10));
@@ -3070,10 +2738,10 @@ class Brain {
     return result;
   }
   async getCurrentAndAdjacentSlots(now) {
-    const dateKey2 = formatDateKey(now);
-    const stored = await this.memory.get(`daily-schedule:${dateKey2}`);
+    const dateKey = formatDateKey(now);
+    const stored = await this.memory.get(`daily-schedule:${dateKey}`);
     if (!stored) {
-      log7.debug(`getCurrentAndAdjacentSlots: no schedule for ${dateKey2}`);
+      log7.debug(`getCurrentAndAdjacentSlots: no schedule for ${dateKey}`);
       return [];
     }
     let schedule;
@@ -3106,7 +2774,6 @@ class Brain {
         personality: this.brainbase.baseSystemPrompt
       });
       const result = await llm.call(llm.models.identity, {
-        caller: "availability",
         instruction,
         message: promptMessage,
         jsonSchemaName: "availability",
@@ -3177,46 +2844,74 @@ class Brain {
         content: userPrompt
       }
     ];
-    try {
-      await llm.chatWithToolExecution(llm.models.conversation, {
-        caller: initiate ? "start-conversation" : "send-message",
-        instruction: `${this.brainbase.baseSystemPrompt}
+    for (let step = 0;step < maxSteps; step += 1) {
+      log7.debug(`sendMessage: step ${step + 1}/${maxSteps} → model`);
+      let choice;
+      try {
+        choice = await llm.chatWithTools(llm.models.conversation, {
+          instruction: `${this.brainbase.baseSystemPrompt}
 
 ${instruction}`,
-        messages,
-        tools,
-        maxSteps,
-        executeTool: async (call) => {
-          if (call.function.name === "addReplyMessage") {
-            const content = parseAddReplyMessageArguments(call.function.arguments);
-            if (content !== null) {
-              log7.debug(`sendMessage: addReplyMessage[${replyMessages.length}] (${content.length} chars)`);
-              await send(content);
-              replyMessages.push(content);
-              return JSON.stringify({
-                ok: true,
-                index: replyMessages.length - 1
-              });
-            }
+          messages,
+          tools
+        });
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.error(`sendMessage: LLM call failed at step ${step}: ${reason}`);
+        return replyMessages;
+      }
+      const assistantMessage = choice.message;
+      const toolCalls = assistantMessage.toolCalls ?? [];
+      const hasContent = typeof assistantMessage.content === "string" && assistantMessage.content.length > 0;
+      log7.debug(`sendMessage: step ${step + 1} → toolCalls=${toolCalls.length} hasContent=${hasContent}`);
+      if (toolCalls.length === 0) {
+        log7.debug(`sendMessage: model returned no tool calls; finalising with ${replyMessages.length} replies`);
+        return replyMessages;
+      }
+      messages.push(stripAssistantForHistory(assistantMessage));
+      for (const call of toolCalls) {
+        if (call.function.name === "addReplyMessage") {
+          const content = parseAddReplyMessageArguments(call.function.arguments);
+          if (content !== null) {
+            log7.debug(`sendMessage: addReplyMessage[${replyMessages.length}] (${content.length} chars)`);
+            send(content);
+            replyMessages.push(content);
+          } else {
             log7.debug(`sendMessage: addReplyMessage rejected (invalid arguments: ${call.function.arguments})`);
-            return JSON.stringify({ ok: false, error: "invalid arguments" });
-          }
-          if (call.function.name === "searchMemory") {
-            log7.debug(`sendMessage: searchMemory tool call`);
-            return this.executeSearchTool(call.function.arguments);
           }
-          log7.debug(`sendMessage: unknown tool "${call.function.name}"`);
-          return JSON.stringify({
-            ok: false,
-            error: `Unknown tool: ${call.function.name}`
+          messages.push({
+            role: "tool",
+            toolCallId: call.id,
+            content: content === null ? JSON.stringify({ ok: false, error: "invalid arguments" }) : JSON.stringify({ ok: true, index: replyMessages.length - 1 })
           });
+          continue;
         }
-      });
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      logger.error(`sendMessage: LLM call failed: ${reason}`);
+        if (call.function.name === "searchMemory") {
+          log7.debug(`sendMessage: searchMemory tool call`);
+          const result = await this.executeSearchTool(call.function.arguments);
+          messages.push({
+            role: "tool",
+            toolCallId: call.id,
+            content: result
+          });
+          continue;
+        }
+        log7.debug(`sendMessage: unknown tool "${call.function.name}"`);
+        messages.push({
+          role: "tool",
+          toolCallId: call.id,
+          content: JSON.stringify({
+            ok: false,
+            error: `Unknown tool: ${call.function.name}`
+          })
+        });
+      }
+      if (!hasContent && toolCalls.every((c) => c.function.name === "searchMemory")) {
+        log7.debug(`sendMessage: step was pure searchMemory, looping back`);
+        continue;
+      }
     }
-    log7.debug(`sendMessage: done with ${replyMessages.length} replies`);
+    logger.warn(`sendMessage: reached maxSteps (${maxSteps}) without final reply`);
     return replyMessages;
   }
   async buildMemoryBlock() {
@@ -3225,11 +2920,11 @@ ${instruction}`,
 ${facts || "(none indexed)"}`;
   }
   async buildScheduleBlock(now) {
-    const dateKey2 = formatDateKey(now);
+    const dateKey = formatDateKey(now);
     const currentSlots = await this.getCurrentAndAdjacentSlots(now);
     const currentBlock = currentSlots.length > 0 ? `Currently (around ${now.toTimeString().slice(0, 5)}):
 ${currentSlots.map((s) => `  ${s.start}-${s.end} ${s.activity}${s.notes ? ` (${s.notes})` : ""}`).join(`
-`)}` : `Currently (${dateKey2} ${now.toTimeString().slice(0, 5)}): (no matching slot in today's schedule)`;
+`)}` : `Currently (${dateKey} ${now.toTimeString().slice(0, 5)}): (no matching slot in today's schedule)`;
     const days = [
       {
         label: "Yesterday",
@@ -3252,9 +2947,9 @@ ${currentBlock}
 ${blocks.join(`
 `)}`;
   }
-  async getDailyScheduleSummary(dateKey2) {
+  async getDailyScheduleSummary(dateKey) {
     try {
-      const stored = await this.memory.get(`daily-schedule:${dateKey2}`);
+      const stored = await this.memory.get(`daily-schedule:${dateKey}`);
       if (!stored)
         return null;
       const schedule = JSON.parse(stored.content);
@@ -3325,7 +3020,6 @@ ${blocks.join(`
       const personaInitInstruction = await loadPrompt("PERSONA_INIT");
       log7.debug(`Brain.create: generating description`);
       const description = await llm.call(llm.models.identity, {
-        caller: "persona-init",
         instruction: personaInitInstruction,
         message: seed
       });
@@ -3333,7 +3027,6 @@ ${blocks.join(`
       const personaSystemInstruction = await loadPrompt("PERSONA_BASE_SYSTEM_PROMPT");
       log7.debug(`Brain.create: generating base system prompt + dials`);
       const generated = await llm.call(llm.models.identity, {
-        caller: "base-system-prompt",
         instruction: personaSystemInstruction,
         message: description,
         jsonSchemaName: "base-system-prompt",
@@ -3371,12 +3064,9 @@ ${personaSystemFixed}`;
       log7.debug(`Brain.create: brainbase saved (id=${brainId})`);
       return { brainId, brain: new Brain(db, space, brainbase, memory) };
     } catch (error) {
-      let reason = error instanceof Error ? `${error.message} (${error.name})` : String(error);
-      if (error instanceof BadRequestResponseError) {
-        reason = `${reason} ${JSON.stringify(error.body)}`;
-      }
-      log7.debug(`Brain.create failed: ${reason}`);
-      return { error: reason };
+      const reason = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to create brain "${displayName}": ${reason}`);
+      return null;
     }
   }
   static async delete(brainId) {
@@ -3468,6 +3158,13 @@ function parseSearchArguments(json) {
   }
   return null;
 }
+function stripAssistantForHistory(message) {
+  return {
+    role: "assistant",
+    content: message.content,
+    toolCalls: message.toolCalls
+  };
+}
 
 // src/channel/discord.ts
 import {
@@ -3487,18 +3184,10 @@ var SLEEP_MEMORY_CRON_KEY = "__sleep-memory__";
 var SLEEP_MEMORY_CRON_PATTERN = "0 * * * *";
 var START_CONVERSATION_CRON_KEY = "__start-conversation__";
 var START_CONVERSATION_CRON_PATTERN = "*/10 * * * *";
-var SCHEDULE_CRON_KEY = "__schedule__";
-var SCHEDULE_CRON_PATTERN = "0 0 * * *";
-var SCHEDULE_NOON_CRON_KEY = "__schedule-noon__";
-var SCHEDULE_NOON_CRON_PATTERN = "0 12 * * *";
-var DO_ACTIONS = ["generateSchedule", "sleepMemory"];
-var VIEW_THINGS = [
-  "daily-schedule",
-  "monthly-schedule",
-  "sending-queue",
-  "deferred-queue",
-  "today-availability"
-];
+var DAILY_SCHEDULE_CRON_KEY = "__daily-schedule__";
+var DAILY_SCHEDULE_CRON_PATTERN = "0 0 * * *";
+var DAILY_SCHEDULE_NOON_CRON_KEY = "__daily-schedule-noon__";
+var DAILY_SCHEDULE_NOON_CRON_PATTERN = "0 12 * * *";
 
 class BaseChannel {
   brain;
@@ -3518,27 +3207,24 @@ class BaseChannel {
   static activeChannels = new Map;
   constructor(brain) {
     this.brain = brain;
-    this.registerCron(SLEEP_MEMORY_CRON_KEY, SLEEP_MEMORY_CRON_PATTERN, () => this.runSleepMemory());
-    this.registerCron(SCHEDULE_CRON_KEY, SCHEDULE_CRON_PATTERN, () => this.regenerateSchedules());
-    this.registerCron(SCHEDULE_NOON_CRON_KEY, SCHEDULE_NOON_CRON_PATTERN, () => this.regenerateSchedules());
-    this.registerCron(START_CONVERSATION_CRON_KEY, START_CONVERSATION_CRON_PATTERN, () => this.runStartConversation());
-  }
-  async runSleepMemory(force = false) {
-    const dateKey2 = formatDateKey(new Date);
-    if (!force) {
+    this.registerCron(SLEEP_MEMORY_CRON_KEY, SLEEP_MEMORY_CRON_PATTERN, async () => {
+      const dateKey = formatDateKey(new Date);
       const availability = await this.brain.getAvailability();
       if (availability.status !== "offline") {
         logger.debug(`sleepMemory cron: skip — availability=${availability.status}`);
         return;
       }
-      const existing = await this.brain.memory.get(`daily-journal:${dateKey2}`);
+      const existing = await this.brain.memory.get(`daily-journal:${dateKey}`);
       if (existing) {
-        logger.debug(`sleepMemory cron: skip — journal for ${dateKey2} exists`);
+        logger.debug(`sleepMemory cron: skip — journal for ${dateKey} exists`);
         return;
       }
-    }
-    const history = await this.getMessageHistoryBetween(new Date(Date.now() - 24 * 60 * 60 * 1000), new Date);
-    await this.brain.sleepMemory(new Date, history);
+      const history = await this.getMessageHistoryBetween(new Date(Date.now() - 24 * 60 * 60 * 1000), new Date);
+      await this.brain.sleepMemory(new Date, history);
+    });
+    this.registerCron(DAILY_SCHEDULE_CRON_KEY, DAILY_SCHEDULE_CRON_PATTERN, () => this.regenerateSchedules());
+    this.registerCron(DAILY_SCHEDULE_NOON_CRON_KEY, DAILY_SCHEDULE_NOON_CRON_PATTERN, () => this.regenerateSchedules());
+    this.registerCron(START_CONVERSATION_CRON_KEY, START_CONVERSATION_CRON_PATTERN, () => this.runStartConversation());
   }
   async regenerateSchedules() {
     logger.debug(`regenerateSchedules: tick for ${this.brain.brainbase.displayName}`);
@@ -3559,8 +3245,8 @@ class BaseChannel {
       return;
     }
     const now = new Date;
-    const dateKey2 = formatDateKey(now);
-    const count = this.startConversationCounters.get(dateKey2) ?? 0;
+    const dateKey = formatDateKey(now);
+    const count = this.startConversationCounters.get(dateKey) ?? 0;
     const countThreshold = this.brain.brainbase.startConversationCountThreshold;
     if (count >= countThreshold)
       return;
@@ -3573,7 +3259,7 @@ class BaseChannel {
       });
       if (replies.length === 0)
         return;
-      this.startConversationCounters.set(dateKey2, count + 1);
+      this.startConversationCounters.set(dateKey, count + 1);
       this.startConversationTimeout = true;
       setTimeout(() => {
         this.startConversationTimeout = false;
@@ -3602,7 +3288,7 @@ class BaseChannel {
     }, callback);
   }
   getRegisteredCrons() {
-    return scheduledJobs.filter((c) => c.name && c.name.startsWith(this.resolveCronPrefix()));
+    return scheduledJobs.filter((c) => c.name && c.name.startsWith(this.resolveCronPrefix())).map((c) => c.name);
   }
   pauseCron(key) {
     const job = scheduledJobs.find((c) => c.name === this.resolveCronName(key));
@@ -3693,13 +3379,6 @@ class BaseChannel {
       this.isChattingDebounce = null;
     }, IS_CHATTING_DEBOUNCE_MS);
   }
-  async initAvailability() {
-    const current = await this.brain.getAvailability();
-    this.previousAvailability = current.status;
-    logger.debug(`initAvailability: ${current.status}`);
-    await this.setAvailability(current.status);
-    this.ensureAvailabilityWatcher();
-  }
   ensureAvailabilityWatcher() {
     if (this.isCronStarted(AVAILABILITY_WATCHER_KEY))
       return;
@@ -3709,9 +3388,6 @@ class BaseChannel {
       const prev = this.previousAvailability;
       this.previousAvailability = current.status;
       logger.debug(`availabilityWatcher: ${prev ?? "(initial)"} → ${current.status}`);
-      if (prev !== current.status) {
-        await this.setAvailability(current.status);
-      }
       if (prev !== null && prev !== "online" && current.status === "online") {
         await this.flushDeferred();
       }
@@ -3760,88 +3436,6 @@ class BaseChannel {
   static all() {
     return Array.from(BaseChannel.activeChannels.values());
   }
-  static forceDo(brainId, action) {
-    const channel = BaseChannel.activeChannels.get(brainId);
-    if (!channel) {
-      return {
-        ok: false,
-        error: `no active channel for brain "${brainId}" (is it activated and daemon running?)`
-      };
-    }
-    const displayName = channel.brain.brainbase.displayName;
-    logger.info(`do ${action}: queued for "${displayName}" (${brainId})`);
-    (async () => {
-      try {
-        if (action === "generateSchedule") {
-          await channel.regenerateSchedules();
-        } else {
-          await channel.runSleepMemory(true);
-        }
-        logger.success(`do ${action}: done for "${displayName}" (${brainId})`);
-      } catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        logger.error(`do ${action}: failed for "${displayName}" (${brainId}): ${reason}`);
-      }
-    })();
-    return { ok: true, displayName };
-  }
-  static async view(brainId, thing) {
-    const channel = BaseChannel.activeChannels.get(brainId);
-    if (!channel) {
-      return {
-        ok: false,
-        error: `no active channel for brain "${brainId}" (is it activated and daemon running?)`
-      };
-    }
-    const displayName = channel.brain.brainbase.displayName;
-    logger.debug(`view ${thing}: "${displayName}" (${brainId})`);
-    return {
-      ok: true,
-      displayName,
-      value: await channel.readView(thing)
-    };
-  }
-  async readView(thing) {
-    const now = new Date;
-    switch (thing) {
-      case "daily-schedule": {
-        const key = formatDateKey(now);
-        const stored = await this.brain.memory.get(`daily-schedule:${key}`);
-        if (!stored)
-          return null;
-        try {
-          return { key, schedule: JSON.parse(stored.content) };
-        } catch {
-          return { key, raw: stored.content };
-        }
-      }
-      case "monthly-schedule": {
-        const key = formatMonthKey(now);
-        const stored = await this.brain.memory.get(`monthly-schedule:${key}`);
-        if (!stored)
-          return null;
-        try {
-          return { key, schedule: JSON.parse(stored.content) };
-        } catch {
-          return { key, raw: stored.content };
-        }
-      }
-      case "sending-queue":
-        return this.isSendingQueue.map((m) => ({
-          sender: m.sender,
-          time: m.time.toISOString(),
-          content: m.content
-        }));
-      case "deferred-queue":
-        return this.deferredQueue.map((m) => ({
-          sender: m.sender,
-          time: m.time.toISOString(),
-          content: m.content
-        }));
-      case "today-availability":
-        return await this.brain.getTodayScheduledAvailability(now);
-    }
-  }
   static async shutdownAll() {
     await Promise.all(BaseChannel.all().map((c) => c.shutdown()));
   }
@@ -3854,8 +3448,8 @@ class BaseChannel {
     logger.debug(`shutdown: done`);
   }
   stopOwnCrons() {
-    for (const cron of this.getRegisteredCrons()) {
-      cron.stop();
+    for (const key of this.getRegisteredCrons()) {
+      this.removeCron(key);
     }
   }
   clearTimers() {
@@ -3965,7 +3559,6 @@ class DiscordChannel extends BaseChannel {
         logger.debug(`DiscordClientReady: resolving configured channel ${channelId}`);
         this.resolveConfiguredChannel(channelId);
       }
-      this.initAvailability();
     });
     this.client.on(Events.MessageCreate, (msg) => {
       if (msg.author.bot)
@@ -4134,7 +3727,6 @@ class TelegramChannel extends BaseChannel {
     this.registerActive();
     this.bot.onStart(({ info }) => {
       logger.success(`Telegram ready as @${info.username}`);
-      this.initAvailability();
     });
     this.bot.on("message", (ctx) => {
       if (ctx.from?.isBot())
@@ -4227,8 +3819,8 @@ class TelegramChannel extends BaseChannel {
 
 // src/utils/daemonClient.ts
 import { connect } from "node:net";
-import { join as join4 } from "node:path";
-var DAEMON_SOCKET_PATH = join4(config.brainboxRoot, "daemon.sock");
+import { join as join3 } from "node:path";
+var DAEMON_SOCKET_PATH = join3(config.brainboxRoot, "daemon.sock");
 async function sendToDaemon(payload) {
   logger.debug(`sendToDaemon: command="${payload.command}" args=${JSON.stringify(payload.args) ?? "null"}`);
   let reply;
@@ -4290,7 +3882,6 @@ function exchangeOnce(payload) {
 // src/commands/daemon.ts
 import { createServer } from "node:net";
 import { chmodSync, unlinkSync } from "node:fs";
-import { join as join5 } from "node:path";
 
 // src/commands/daemon/commands.ts
 var log8 = logger.child("daemon-cmd");
@@ -4351,63 +3942,6 @@ defineCommand({
   }
 });
 
-// src/commands/daemon/doCommand.ts
-defineCommand({
-  name: "do",
-  handler: async (args) => {
-    const action = args?.action;
-    const brainId = args?.brainId;
-    logger.debug(`do handler: action="${action}" brainId="${brainId}"`);
-    if (typeof action !== "string" || !DO_ACTIONS.includes(action)) {
-      return {
-        ok: false,
-        error: `invalid action (expected one of: ${DO_ACTIONS.join(", ")})`
-      };
-    }
-    if (typeof brainId !== "string" || brainId.trim().length === 0) {
-      return { ok: false, error: "missing brainId" };
-    }
-    const result = BaseChannel.forceDo(brainId.trim(), action);
-    if (!result.ok)
-      return result;
-    return {
-      ok: true,
-      result: { action, brainId: brainId.trim(), displayName: result.displayName }
-    };
-  }
-});
-
-// src/commands/daemon/viewCommand.ts
-defineCommand({
-  name: "view",
-  handler: async (args) => {
-    const thing = args?.thing;
-    const brainId = args?.brainId;
-    logger.debug(`view handler: thing="${thing}" brainId="${brainId}"`);
-    if (typeof thing !== "string" || !VIEW_THINGS.includes(thing)) {
-      return {
-        ok: false,
-        error: `invalid thing (expected one of: ${VIEW_THINGS.join(", ")})`
-      };
-    }
-    if (typeof brainId !== "string" || brainId.trim().length === 0) {
-      return { ok: false, error: "missing brainId" };
-    }
-    const result = await BaseChannel.view(brainId.trim(), thing);
-    if (!result.ok)
-      return result;
-    return {
-      ok: true,
-      result: {
-        thing,
-        brainId: brainId.trim(),
-        displayName: result.displayName,
-        value: result.value
-      }
-    };
-  }
-});
-
 // src/commands/daemon.ts
 async function startChannels() {
   const items = await brainManager.listAvailableBrain();
@@ -4442,10 +3976,7 @@ async function startChannels() {
   return started;
 }
 async function daemon() {
-  const logDir = join5(config.brainboxRoot, "logs");
-  logger.configure({ logDir });
-  configureLlmLog(config.debug ? join5(logDir, "llm") : undefined);
-  logger.debug(`daemon: boot (debug=${config.debug}, logDir=${logDir}, llmLog=${config.debug})`);
+  logger.debug(`daemon: boot`);
   const started = await startChannels();
   if (started === 0) {
     logger.info("No activated brains with channels. Daemon idling.");
@@ -4585,8 +4116,7 @@ async function deactivateBrain(brainId) {
 async function createBrain(displayName, seed, options) {
   logger.debug(`createBrain: name="${displayName}" seed length=${seed.length} schedule=${options.schedule}`);
   const result = await Brain.create(displayName, seed);
-  if ("error" in result) {
-    logger.error(`Failed to create brain "${displayName}": ${result.error}`);
+  if (!result) {
     process.exitCode = 1;
     return;
   }
@@ -4612,33 +4142,6 @@ async function removeBrain(brainId) {
   }
   logger.success(`Removed brain "${brain.displayName}" (${chalk2.cyan(brainId)})`);
 }
-async function doAction(action, brainId) {
-  if (!DO_ACTIONS.includes(action)) {
-    logger.error(`Unknown action "${action}". Expected one of: ${DO_ACTIONS.join(", ")}`);
-    process.exit(1);
-  }
-  logger.debug(`do: action=${action} brainId=${brainId}`);
-  const response = await sendToDaemon({
-    command: "do",
-    args: { action, brainId }
-  });
-  const name = response.result?.displayName ?? brainId;
-  logger.success(`Successfully sent ${action} for "${name}" (${brainId}).`);
-}
-async function viewThing(thing, brainId) {
-  if (!VIEW_THINGS.includes(thing)) {
-    logger.error(`Unknown thing "${thing}". Expected one of: ${VIEW_THINGS.join(", ")}`);
-    process.exit(1);
-  }
-  logger.debug(`view: thing=${thing} brainId=${brainId}`);
-  const response = await sendToDaemon({
-    command: "view",
-    args: { thing, brainId }
-  });
-  const name = response.result?.displayName ?? brainId;
-  logger.info(`${thing} — "${name}" (${brainId})`);
-  console.log(JSON.stringify(response.result?.value ?? null, null, 2));
-}
 function register3(program) {
   const cmd = registerCommand(program, {
     name: "brain",
@@ -4649,8 +4152,6 @@ function register3(program) {
   cmd.command("remove <brainId>").description("Remove a brain and its memory").action(removeBrain);
   cmd.command("activate <brainId>").description("Activate a brain").action(activateBrain);
   cmd.command("deactivate <brainId>").description("Deactivate a brain").action(deactivateBrain);
-  cmd.command("do <action> <brainId>").description(`Force-run a daemon job (${DO_ACTIONS.join(" | ")}) for a live brain`).action(doAction);
-  cmd.command("view <thing> <brainId>").description(`Inspect a live brain value (${VIEW_THINGS.join(" | ")})`).action(viewThing);
   return cmd;
 }
 
@@ -4772,9 +4273,6 @@ function RawInput({
   onSubmit
 }) {
   const [value, setValue] = useState(initialValue);
-  useEffect(() => {
-    setValue(initialValue);
-  }, [prompt, initialValue]);
   useInput((input, key) => {
     if (key.return) {
       onSubmit(value);
@@ -5470,19 +4968,6 @@ function Select(props) {
 
 // src/commands/onboard.tsx
 import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
-function ok(msg) {
-  console.log(chalk3.green(`✔ ${msg}`));
-}
-function info(msg) {
-  console.log(msg);
-}
-function show(active, node, status) {
-  active.current.unmount();
-  console.clear();
-  if (status)
-    ok(status);
-  active.current = render3(node);
-}
 function ProviderApp({
   providers,
   onDone
@@ -5554,6 +5039,7 @@ function ProviderApp({
             const extras = PROVIDER_EXTRA_FIELDS[stage.provider] ?? [];
             if (extras.length === 0) {
               setProviderAuth(stage.provider, { apiKey });
+              logger.success(`Saved ${stage.provider} to auth.yaml`);
               onDone({ provider: stage.provider });
               return;
             }
@@ -5574,6 +5060,13 @@ function ProviderApp({
     }, undefined, true, undefined, this);
   }
   const nextField = stage.fields[0];
+  if (!nextField) {
+    setProviderAuth(stage.provider, stage.values);
+    logger.success(`Saved ${stage.provider} to auth.yaml`);
+    return /* @__PURE__ */ jsxDEV5(Text5, {
+      children: "Continuing…"
+    }, undefined, false, undefined, this);
+  }
   return /* @__PURE__ */ jsxDEV5(Box4, {
     flexDirection: "column",
     children: [
@@ -5599,11 +5092,6 @@ function ProviderApp({
           const values = { ...stage.values };
           if (value)
             values[nextField] = value;
-          if (remaining.length === 0) {
-            setProviderAuth(stage.provider, values);
-            onDone({ provider: stage.provider });
-            return;
-          }
           setStage({
             kind: "extras",
             provider: stage.provider,
@@ -5632,7 +5120,7 @@ function ModelApp2({
       /* @__PURE__ */ jsxDEV5(Text5, {
         dimColor: true,
         children: [
-          "model name, or ",
+          "e.g. ",
           /* @__PURE__ */ jsxDEV5(Text5, {
             color: "cyan",
             children: [
@@ -5640,7 +5128,7 @@ function ModelApp2({
               "/"
             ]
           }, undefined, true, undefined, this),
-          "model — fine-tune later with ",
+          "model-name — fine-tune later with ",
           /* @__PURE__ */ jsxDEV5(Text5, {
             color: "cyan",
             children: "brainbox model"
@@ -5655,15 +5143,14 @@ function ModelApp2({
             setError("Model cannot be empty");
             return;
           }
-          const prefix = `${provider}/`;
-          const full = value.startsWith(prefix) ? value : `${prefix}${value}`;
-          if (full === prefix) {
-            setError("Model cannot be empty");
+          if (!value.startsWith(`${provider}/`)) {
+            setError(`Must start with "${provider}/"`);
             return;
           }
-          setModelSlot("identity", full);
-          setModelSlot("conversation", full);
-          onDone(full);
+          setModelSlot("identity", value);
+          setModelSlot("conversation", value);
+          logger.success(`Set identity + conversation model to ${value}`);
+          onDone();
         }
       }, undefined, false, undefined, this),
       error && /* @__PURE__ */ jsxDEV5(Text5, {
@@ -5699,6 +5186,7 @@ function SuperMemoryApp({
             return;
           }
           setSupermemoryKey(key);
+          logger.success("Saved supermemory key to brainbox.yaml");
           onDone();
         }
       }, undefined, false, undefined, this),
@@ -5714,7 +5202,6 @@ function BrainApp({
 }) {
   const [stage, setStage] = useState5({ kind: "name" });
   const [error, setError] = useState5(null);
-  const [busy, setBusy] = useState5(false);
   if (stage.kind === "name") {
     return /* @__PURE__ */ jsxDEV5(Box4, {
       flexDirection: "column",
@@ -5766,14 +5253,12 @@ function BrainApp({
         dimColor: true,
         children: "One sentence about who they are. The model will expand it."
       }, undefined, false, undefined, this),
-      busy ? /* @__PURE__ */ jsxDEV5(Text5, {
-        dimColor: true,
-        children: "Creating brain… (This can take few minutes depending on the model's response speed)"
-      }, undefined, false, undefined, this) : /* @__PURE__ */ jsxDEV5(TextInput, {
+      /* @__PURE__ */ jsxDEV5(TextInput, {
         prompt: "seed> ",
-        onSubmit: (raw) => {
+        onSubmit: async (raw) => {
           const seed = raw.trim();
           if (seed === "skip") {
+            logger.info("Skipped brain creation.");
             onDone({ brainId: "", displayName: stage.displayName });
             return;
           }
@@ -5781,19 +5266,13 @@ function BrainApp({
             setError("Seed cannot be empty (or type 'skip')");
             return;
           }
-          setBusy(true);
-          setError(null);
-          Brain.create(stage.displayName, seed).then((result) => {
-            setBusy(false);
-            if ("error" in result) {
-              setError(`Brain creation failed: ${result.error} (fix seed, or type 'skip')`);
-              return;
-            }
-            onDone({
-              brainId: result.brainId,
-              displayName: stage.displayName
-            });
-          });
+          const result = await Brain.create(stage.displayName, seed);
+          if (!result) {
+            setError("Brain creation failed (check logs above, or type 'skip')");
+            return;
+          }
+          logger.success(`Created brain "${stage.displayName}" (${chalk3.cyan(result.brainId)})`);
+          onDone({ brainId: result.brainId, displayName: stage.displayName });
         }
       }, undefined, false, undefined, this),
       error && /* @__PURE__ */ jsxDEV5(Text5, {
@@ -5834,7 +5313,8 @@ function ChannelApp({
           items: ["discord", "telegram", "skip"],
           onSelect: (v) => {
             if (v === "skip") {
-              onDone("Skipped channel setup.");
+              logger.info("Skipped channel setup.");
+              onDone();
               return;
             }
             setError(null);
@@ -5893,41 +5373,37 @@ function ChannelApp({
       }, undefined, true, undefined, this),
       /* @__PURE__ */ jsxDEV5(TextInput, {
         prompt: `${stage.kind_ === "discord" ? "channelId" : "chatId"}> `,
-        onSubmit: (raw) => {
+        onSubmit: async (raw) => {
           const target = raw.trim();
-          (async () => {
-            const existing = await brainManager.loadBrain(brainId);
-            if (!existing) {
-              setError(`Brain ${brainId} no longer exists`);
+          const existing = await brainManager.loadBrain(brainId);
+          if (!existing) {
+            setError(`Brain ${brainId} no longer exists`);
+            return;
+          }
+          let updated;
+          if (stage.kind_ === "discord") {
+            updated = {
+              ...existing,
+              channel: "discord",
+              discord: { token: stage.token, channelId: target || undefined },
+              activated: true
+            };
+          } else {
+            const chatId = target ? Number(target) : undefined;
+            if (target && Number.isNaN(chatId)) {
+              setError("chatId must be a number");
               return;
             }
-            let updated;
-            if (stage.kind_ === "discord") {
-              updated = {
-                ...existing,
-                channel: "discord",
-                discord: {
-                  token: stage.token,
-                  channelId: target || undefined
-                },
-                activated: true
-              };
-            } else {
-              const chatId = target ? Number(target) : undefined;
-              if (target && Number.isNaN(chatId)) {
-                setError("chatId must be a number");
-                return;
-              }
-              updated = {
-                ...existing,
-                channel: "telegram",
-                telegram: { token: stage.token, chatId },
-                activated: true
-              };
-            }
-            await brainManager.saveBrain(brainId, updated);
-            onDone(`Bound ${displayName} → ${stage.kind_}${target ? ` (${target})` : " (pairing mode)"}`);
-          })();
+            updated = {
+              ...existing,
+              channel: "telegram",
+              telegram: { token: stage.token, chatId },
+              activated: true
+            };
+          }
+          await brainManager.saveBrain(brainId, updated);
+          logger.success(`Bound ${displayName} → ${stage.kind_}${target ? ` (${target})` : " (pairing mode)"}`);
+          onDone();
         }
       }, undefined, false, undefined, this),
       error && /* @__PURE__ */ jsxDEV5(Text5, {
@@ -5938,52 +5414,46 @@ function ChannelApp({
   }, undefined, true, undefined, this);
 }
 async function runOnboard() {
-  console.clear();
-  info(`Welcome — let's get ${chalk3.bold("brainbox")} ready.`);
+  logger.info(`Welcome — let's get ${chalk3.bold("brainbox")} ready.`);
   const providers = listProviderNames().slice().sort();
   const { promise, resolve: resolve2 } = Promise.withResolvers();
-  const active = { current: null };
-  active.current = render3(/* @__PURE__ */ jsxDEV5(ProviderApp, {
+  let active = render3(/* @__PURE__ */ jsxDEV5(ProviderApp, {
     providers,
     onDone: (p) => {
-      show(active, /* @__PURE__ */ jsxDEV5(ModelApp2, {
+      active.unmount();
+      active = render3(/* @__PURE__ */ jsxDEV5(ModelApp2, {
         provider: p.provider,
-        onDone: (model) => {
-          show(active, /* @__PURE__ */ jsxDEV5(SuperMemoryApp, {
+        onDone: () => {
+          active.unmount();
+          active = render3(/* @__PURE__ */ jsxDEV5(SuperMemoryApp, {
             onDone: () => {
-              show(active, /* @__PURE__ */ jsxDEV5(BrainApp, {
+              active.unmount();
+              active = render3(/* @__PURE__ */ jsxDEV5(BrainApp, {
                 onDone: (b) => {
+                  active.unmount();
                   if (!b.brainId) {
-                    active.current.unmount();
-                    console.clear();
-                    info("Skipped brain creation.");
                     resolve2();
                     return;
                   }
-                  show(active, /* @__PURE__ */ jsxDEV5(ChannelApp, {
+                  active = render3(/* @__PURE__ */ jsxDEV5(ChannelApp, {
                     brainId: b.brainId,
                     displayName: b.displayName,
-                    onDone: (status) => {
-                      active.current.unmount();
-                      console.clear();
-                      if (status.startsWith("Skipped"))
-                        info(status);
-                      else
-                        ok(status);
+                    onDone: () => {
+                      active.unmount();
                       resolve2();
                     }
-                  }, undefined, false, undefined, this), `Created brain "${b.displayName}" (${chalk3.cyan(b.brainId)})`);
+                  }, undefined, false, undefined, this));
                 }
-              }, undefined, false, undefined, this), "Saved supermemory key to brainbox.yaml");
+              }, undefined, false, undefined, this));
             }
-          }, undefined, false, undefined, this), `Set identity + conversation model to ${model}`);
+          }, undefined, false, undefined, this));
         }
-      }, undefined, false, undefined, this), `Saved ${p.provider} to auth.yaml`);
+      }, undefined, false, undefined, this));
     }
   }, undefined, false, undefined, this));
   await promise;
-  ok("Onboarding complete.");
-  info(`Run ${chalk3.cyan("brainbox daemon")} to bring it online.`);
+  logger.success("Onboarding complete.");
+  logger.info(`Run ${chalk3.cyan("brainbox daemon")} to bring it online.`);
 }
 function register8(program) {
   return registerCommand(program, {
@@ -5995,12 +5465,12 @@ function register8(program) {
 
 // src/index.ts
 var __filename3 = fileURLToPath2(import.meta.url);
-var __dirname3 = dirname3(__filename3);
+var __dirname3 = dirname4(__filename3);
 logger.configure({ level: config.debug ? "debug" : "info" });
 logger.debug(`brainbox starting (debug=${config.debug}, root=${config.brainboxRoot})`);
 function getVersion() {
   try {
-    const pkgPath = join6(__dirname3, "..", "package.json");
+    const pkgPath = join4(__dirname3, "..", "package.json");
     const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {