@p-sw/brainbox 0.1.2-alpha.8 → 0.2.0

package/dist/index.js

@@ -4,12 +4,17 @@
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 
 // src/utils/logger.ts
 import chalk from "chalk";
-import { existsSync, mkdirSync, createWriteStream } from "fs";
-import { dirname } from "path";
+import {
+  existsSync,
+  mkdirSync,
+  createWriteStream,
+  writeFileSync
+} from "fs";
+import { join } from "path";
 var LEVELS = {
   debug: { rank: 0, color: chalk.gray, stderr: false },
   info: { rank: 1, color: chalk.blue, stderr: false },
@@ -26,29 +31,61 @@ 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,
-  file: undefined,
-  fileStream: undefined,
   json: false,
   silent: false
 };
-function openFile(path) {
-  if (path === shared.file)
-    return;
-  shared.fileStream?.end();
-  shared.file = path;
-  if (path) {
-    const dir = dirname(path);
-    if (!existsSync(dir))
-      mkdirSync(dir, { recursive: true });
-    shared.fileStream = createWriteStream(path, { flags: "a" });
-  } else {
-    shared.fileStream = undefined;
-  }
-}
+var mainSink = new DailyFileSink;
+var llmLogDir;
 function applyShared(options) {
   if (options.level !== undefined)
     shared.level = options.level;
@@ -60,8 +97,8 @@ function applyShared(options) {
     shared.silent = options.silent;
   if (options.json !== undefined)
     shared.json = options.json;
-  if ("file" in options)
-    openFile(options.file);
+  if ("logDir" in options)
+    mainSink.setDir(options.logDir);
 }
 
 class Logger {
@@ -75,8 +112,7 @@ class Logger {
   }
   formatTimestamp() {
     const now = new Date;
-    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())}`;
+    return `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())} ${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())}`;
   }
   format(level, message) {
     const ts = shared.timestamps ? `[${this.formatTimestamp()}]` : "";
@@ -114,8 +150,8 @@ class Logger {
       out.write(consoleLine + `
 `);
     }
-    if (shared.fileStream) {
-      shared.fileStream.write(shared.json ? jsonLine : fileLine);
+    if (mainSink.enabled) {
+      mainSink.write(shared.json ? jsonLine : fileLine);
     }
   }
   debug(message) {
@@ -146,22 +182,48 @@ class Logger {
     applyShared(options);
   }
   close() {
-    shared.fileStream?.end();
-    shared.fileStream = undefined;
-    shared.file = undefined;
+    mainSink.close();
+    llmLogDir = undefined;
   }
 }
 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 as dirname2, join, resolve } from "path";
+import { dirname, join as join2, 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 } from "fs";
-var brainboxRoot = process.env["BRAINBOX_ROOT_PATH"] ? resolve(process.cwd(), process.env["BRAINBOX_ROOT_PATH"]) : join(homedir(), ".brainbox");
+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");
 function configFile(file, options) {
-  const path = () => join(brainboxRoot, file);
+  const path = () => join2(brainboxRoot, file);
   const read = () => {
     const p = path();
     let raw;
@@ -173,8 +235,8 @@ function configFile(file, options) {
       const defaults = defaultsFromSchema(options.schema);
       const templateStr = (options.header ? options.header + `
 ` : "") + (defaults === undefined ? "" : stringifyYaml(defaults));
-      mkdirSync2(dirname2(p), { recursive: true });
-      writeFileSync(p, templateStr);
+      mkdirSync2(dirname(p), { recursive: true });
+      writeFileSync2(p, templateStr);
       raw = defaults ?? {};
     }
     try {
@@ -191,8 +253,8 @@ function configFile(file, options) {
   };
   const write = (value) => {
     const p = path();
-    mkdirSync2(dirname2(p), { recursive: true });
-    writeFileSync(p, stringifyYaml(value));
+    mkdirSync2(dirname(p), { recursive: true });
+    writeFileSync2(p, stringifyYaml(value));
   };
   const update = (fn) => {
     const next = fn(read());
@@ -313,7 +375,7 @@ function registerCommand(program, config2) {
 
 // src/brain/manager.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var log = logger.child("brain-manager");
 
 class BrainDBManager {
@@ -322,7 +384,7 @@ class BrainDBManager {
     this.root = root;
   }
   dbFile() {
-    return join2(this.root, "brains.json");
+    return join3(this.root, "brains.json");
   }
   async readDB() {
     try {
@@ -427,15 +489,100 @@ function stripThinkTags(content) {
 }
 function parseModelJson(content) {
   const cleaned = stripThinkTags(content);
-  try {
-    return JSON.parse(cleaned);
-  } catch (first) {
-    const fence = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/i);
-    if (fence?.[1]) {
-      return JSON.parse(fence[1].trim());
+  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;
     }
-    throw first;
+    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;
@@ -450,6 +597,56 @@ 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) {
+        const nudge = options.onNoToolCalls ? await options.onNoToolCalls(last) : null;
+        if (nudge == null)
+          return last;
+        log2.debug(`chatWithToolExecution: bare end rejected, re-prompting`);
+        messages.push({
+          role: "assistant",
+          content: last.message.content ?? ""
+        });
+        messages.push({ role: "user", content: nudge });
+        continue;
+      }
+      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
+        });
+      }
+      if (options.shouldEnd?.(toolCalls)) {
+        log2.debug(`chatWithToolExecution: shouldEnd after step ${step + 1}`);
+        return last;
+      }
+    }
+    log2.warn(`chatWithToolExecution: reached maxSteps (${maxSteps}) without final reply`);
+    return last;
+  }
   static providers = [];
   static registerProvider(p) {
     LLMExecutor.providers.push(p);
@@ -516,6 +713,19 @@ 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();
 }
@@ -584,27 +794,27 @@ 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 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 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;
     if (!content) {
@@ -616,22 +826,22 @@ class OpenRouterExecutor extends LLMExecutor {
   }
   async chatWithTools(model, options) {
     log3.debug(`chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
-    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 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 choice = result.choices[0];
     if (!choice) {
       log3.debug(`chatWithTools: no choice in response`);
@@ -706,6 +916,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
   chatPath;
   noBearerPrefix;
   reasoningEffortInQuery;
+  supportsResponseFormat;
   constructor(opts) {
     super();
     this.providerName = opts.providerName;
@@ -715,6 +926,7 @@ 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
@@ -745,7 +957,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
     }
     return url.toString();
   }
-  async sendRequest(body, reasoningEffort) {
+  async sendRequest(body, reasoningEffort, caller) {
     const modelName = body["model"];
     const modelStr = typeof modelName === "string" ? modelName : "";
     const url = this.buildRequestUrl(modelStr, reasoningEffort);
@@ -755,24 +967,40 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       ...authHeader,
       ...this.defaultHeaders
     };
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(url, {
       method: "POST",
       headers,
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      log4.error(`${this.providerName}: HTTP ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      log4.error(`${this.providerName}: HTTP ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
       throw new Error(`${this.providerName} request failed: ${res.status} ${res.statusText}`);
     }
-    const data = await res.json();
+    let data;
+    try {
+      data = JSON.parse(responseRaw);
+    } catch {
+      throw new Error(`${this.providerName}: invalid JSON response`);
+    }
     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}`);
@@ -785,16 +1013,32 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       responseFormat: jsonMode ? buildResponseFormat(options.jsonSchemaName, options.jsonSchema) : undefined,
       reasoningEffort: reasoning
     });
-    const data = await this.sendRequest(body, options.reasoningEffort);
-    const raw = data.choices?.[0]?.message?.content;
+    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;
     if (!content) {
-      log4.debug(`call: empty content in choice 0`);
-      throw new Error("Empty response from model");
+      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: 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);
+  }
   async chatWithTools(model, options) {
     const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     log4.debug(`chatWithTools: provider=${this.providerName} model=${model} msgs=${options.messages.length} tools=${options.tools.length}`);
@@ -808,7 +1052,7 @@ class OpenAICompatibleExecutor extends LLMExecutor {
       parallelToolCalls: options.parallelToolCalls ?? false,
       reasoningEffort: reasoning
     });
-    const data = await this.sendRequest(body, options.reasoningEffort);
+    const data = await this.sendRequest(body, options.reasoningEffort, resolveLlmCaller(options));
     const choice = data.choices?.[0];
     if (!choice) {
       log4.debug(`chatWithTools: no choice in response`);
@@ -1110,10 +1354,15 @@ 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["thinking"] = opts.reasoningEffort && opts.reasoningEffort !== "none" ? { type: "adaptive" } : { type: "disabled" };
+    body["max_completion_tokens"] = 16384;
+    const wantThink = !jsonMode && opts.reasoningEffort !== undefined && opts.reasoningEffort !== "none";
+    body["thinking"] = wantThink ? { type: "adaptive" } : { type: "disabled" };
     return body;
   }
 }
@@ -1123,7 +1372,8 @@ function minimaxOpts(providerName, baseURL, opts) {
     baseURL,
     apiKey: opts.apiKey,
     conversationModel: opts.conversationModel,
-    identityModel: opts.identityModel
+    identityModel: opts.identityModel,
+    supportsResponseFormat: false
   };
 }
 
@@ -1199,7 +1449,8 @@ class LmStudioExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:1234/v1",
       apiKey: opts.apiKey || "lm-studio",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1212,7 +1463,8 @@ class OllamaExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:11434/v1",
       apiKey: opts.apiKey || "ollama",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1238,7 +1490,8 @@ class LlamaCppExecutor extends OpenAICompatibleExecutor {
       baseURL: "http://127.0.0.1:8080/v1",
       apiKey: opts.apiKey || "llama.cpp",
       conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel
+      identityModel: opts.identityModel,
+      supportsResponseFormat: false
     });
   }
 }
@@ -1321,21 +1574,23 @@ 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) {
+  async run(model, body, caller) {
     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: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`cloudflare-workers request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`cloudflare-workers request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
@@ -1356,7 +1611,7 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.run(model, body);
+    const data = await this.run(model, body, resolveLlmCaller(options));
     if (data.errors && data.errors.length > 0) {
       throw new Error(`cloudflare-workers API error: ${data.errors.map((e) => e.message).join("; ")}`);
     }
@@ -1385,7 +1640,7 @@ class CloudflareWorkersExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.run(model, body);
+    const data = await this.run(model, body, resolveLlmCaller(options));
     if (data.errors && data.errors.length > 0) {
       throw new Error(`cloudflare-workers API error: ${data.errors.map((e) => e.message).join("; ")}`);
     }
@@ -1475,17 +1730,17 @@ var AnthropicAuthSchema = z4.object({
   apiVersion: z4.string().optional()
 }).loose();
 function toAnthropicMessages(messages) {
-  let system;
-  const msgs = [];
+  let system2;
+  const msgs2 = [];
   for (const m of messages) {
     if (m.role === "system") {
-      system = (system ? system + `
+      system2 = (system2 ? system2 + `
 
 ` : "") + m.content;
       continue;
     }
     if (m.role === "user") {
-      msgs.push({ role: "user", content: m.content });
+      msgs2.push({ role: "user", content: m.content });
       continue;
     }
     if (m.role === "assistant") {
@@ -1508,11 +1763,11 @@ function toAnthropicMessages(messages) {
           });
         }
       }
-      msgs.push({ role: "assistant", content: blocks });
+      msgs2.push({ role: "assistant", content: blocks });
       continue;
     }
     if (m.role === "tool") {
-      msgs.push({
+      msgs2.push({
         role: "user",
         content: [
           {
@@ -1524,7 +1779,7 @@ function toAnthropicMessages(messages) {
       });
     }
   }
-  return { system, msgs };
+  return { system: system2, msgs: msgs2 };
 }
 function toAnthropicTool(t) {
   return {
@@ -1552,7 +1807,8 @@ 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) {
+  async send(body, caller) {
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(`${this.baseURL}/v1/messages`, {
       method: "POST",
       headers: {
@@ -1560,19 +1816,35 @@ class AnthropicExecutor extends LLMExecutor {
         "anthropic-version": this.apiVersion,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`anthropic request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`anthropic request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in 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 reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:anthropic");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const outputCap = 4096;
     const body = {
       model,
@@ -1588,7 +1860,7 @@ class AnthropicExecutor extends LLMExecutor {
         budget_tokens: budget
       };
     }
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`anthropic API error: ${data.error.message ?? "unknown"}`);
     }
@@ -1596,21 +1868,27 @@ class AnthropicExecutor extends LLMExecutor {
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(text) : text;
+    return 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, msgs } = toAnthropicMessages(options.messages);
+    const { system: system2, msgs: msgs2 } = toAnthropicMessages(options.messages);
     const outputCap = 4096;
     const body = {
       model,
       max_tokens: outputCap,
-      system: system ?? options.instruction,
-      messages: msgs,
+      system: system2 ?? options.instruction,
+      messages: msgs2,
       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;
@@ -1619,7 +1897,7 @@ class AnthropicExecutor extends LLMExecutor {
         budget_tokens: budget
       };
     }
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`anthropic API error: ${data.error.message ?? "unknown"}`);
     }
@@ -1638,11 +1916,11 @@ class AnthropicExecutor extends LLMExecutor {
 
 // src/provider/providers/bedrock.ts
 import { createHmac, createHash } from "node:crypto";
-var pad2 = (n) => n.toString().padStart(2, "0");
+var pad22 = (n) => n.toString().padStart(2, "0");
 function amzDate(now) {
   return {
-    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`
+    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`
   };
 }
 function signRequest(opts) {
@@ -1689,58 +1967,6 @@ 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,
@@ -1782,7 +2008,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) {
+  async invoke(model, body, caller) {
     const bodyStr = JSON.stringify(body);
     const path = `/model/${encodeURIComponent(model)}/invoke`;
     const headers = signRequest({
@@ -1801,16 +2027,32 @@ class BedrockExecutor extends LLMExecutor {
       headers,
       body: bodyStr
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, bodyStr, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`bedrock request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`bedrock request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:bedrock");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    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}`);
     if (!model.startsWith("anthropic.") && !model.startsWith("us.anthropic.")) {
       throw new Error(`bedrock provider currently only supports Anthropic models (got ${model})`);
     }
@@ -1820,12 +2062,12 @@ class BedrockExecutor extends LLMExecutor {
       system: options.instruction,
       messages: [{ role: "user", content: options.message }]
     };
-    const data = await this.invoke(model, body);
+    const data = await this.invoke(model, body, resolveLlmCaller(options));
     const { text } = extractAnthropicContent(data);
     if (!text) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(text) : text;
+    return text;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:bedrock");
@@ -1833,7 +2075,6 @@ 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,
@@ -1841,7 +2082,13 @@ class BedrockExecutor extends LLMExecutor {
       messages: msgs,
       tools: options.tools.map(toAnthropicTool2)
     };
-    const data = await this.invoke(model, body);
+    if (options.toolChoice) {
+      body.tool_choice = {
+        type: "tool",
+        name: options.toolChoice.name
+      };
+    }
+    const data = await this.invoke(model, body, resolveLlmCaller(options));
     const { text, toolCalls } = extractAnthropicContent(data);
     return { message: { content: text || undefined, toolCalls } };
   }
@@ -1957,21 +2204,23 @@ 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) {
+  async generate(model, body, caller) {
     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: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`vertex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`vertex request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
     const jsonMode = "jsonSchemaName" in options;
@@ -1992,7 +2241,7 @@ class VertexExecutor extends LLMExecutor {
         responseSchema: options.jsonSchema
       };
     }
-    const data = await this.generate(model, body);
+    const data = await this.generate(model, body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2011,7 +2260,7 @@ class VertexExecutor extends LLMExecutor {
       systemInstruction: { parts: [{ text: options.instruction }] },
       tools: options.tools.length > 0 ? [toGeminiTools(options.tools)] : undefined
     };
-    const data = await this.generate(model, body);
+    const data = await this.generate(model, body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2087,25 +2336,41 @@ 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) {
+  async send(body, caller) {
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(this.baseURL, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`gitlab-duo request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`gitlab-duo request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
     const log5 = logger.child("llm:gitlab-duo");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    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}`);
     const body = {
       model,
       messages: [
@@ -2113,7 +2378,7 @@ class GitLabDuoExecutor extends LLMExecutor {
         { role: "user", content: options.message }
       ]
     };
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`gitlab-duo API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2121,7 +2386,7 @@ class GitLabDuoExecutor extends LLMExecutor {
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(content) : content;
+    return content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:gitlab-duo");
@@ -2134,7 +2399,7 @@ class GitLabDuoExecutor extends LLMExecutor {
       ],
       tools: options.tools.map(toTool)
     };
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`gitlab-duo API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2202,26 +2467,43 @@ 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) {
+  async send(body, caller) {
+    const requestRaw = JSON.stringify(body);
     const res = await fetch(this.baseURL, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: requestRaw
     });
+    const responseRaw = await res.text().catch(() => "");
+    logLlmWire(caller, requestRaw, responseRaw);
     if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`snowflake-cortex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`);
+      throw new Error(`snowflake-cortex request failed: ${res.status} ${res.statusText} body=${responseRaw.slice(0, 500)}`);
     }
-    return await res.json();
+    return JSON.parse(responseRaw);
   }
   async call(model, options) {
-    const jsonMode = "jsonSchemaName" in options;
-    const reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
     const log5 = logger.child("llm:snowflake-cortex");
-    log5.debug(`call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`);
+    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 reasoning = defaultReasoningEffort(options.reasoningEffort, model, this.models.identity);
+    log5.debug(`call: model=${model} jsonSchema=- msgLen=${options.message.length}`);
     const body = {
       model,
       messages: [
@@ -2232,7 +2514,7 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     if (reasoning !== "none") {
       body["reasoning_effort"] = reasoning;
     }
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`snowflake-cortex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2240,7 +2522,7 @@ class SnowflakeCortexExecutor extends LLMExecutor {
     if (!content) {
       throw new Error("Empty response from model");
     }
-    return jsonMode ? parseModelJson(content) : content;
+    return content;
   }
   async chatWithTools(model, options) {
     const log5 = logger.child("llm:snowflake-cortex");
@@ -2253,7 +2535,7 @@ class SnowflakeCortexExecutor extends LLMExecutor {
       ],
       tools: options.tools.map(toCortexTool)
     };
-    const data = await this.send(body);
+    const data = await this.send(body, resolveLlmCaller(options));
     if (data.error) {
       throw new Error(`snowflake-cortex API error: ${data.error.message ?? "unknown"}`);
     }
@@ -2332,14 +2614,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 dirname3 } from "path";
+import path, { dirname as dirname2 } 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 = dirname3(__filename2);
+var __dirname2 = dirname2(__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));
@@ -2464,14 +2746,14 @@ function translateMessageHistory(personaName, entries) {
 }
 
 // src/brain/schedule.ts
-function pad22(n) {
+function pad23(n) {
   return n < 10 ? `0${n}` : `${n}`;
 }
 function formatDateKey(d) {
-  return `${d.getFullYear()}-${pad22(d.getMonth() + 1)}-${pad22(d.getDate())}`;
+  return `${d.getFullYear()}-${pad23(d.getMonth() + 1)}-${pad23(d.getDate())}`;
 }
 function formatMonthKey(d) {
-  return `${d.getFullYear()}-${pad22(d.getMonth() + 1)}`;
+  return `${d.getFullYear()}-${pad23(d.getMonth() + 1)}`;
 }
 
 // src/brain/memory.ts
@@ -2569,12 +2851,12 @@ class Brain {
     log7.debug(`Brain constructed: id=${brainbase.brainId} name=${brainbase.displayName} space=${space.name}`);
   }
   async createDailySchedule(datetime) {
-    const dateKey = formatDateKey(datetime);
-    log7.debug(`createDailySchedule: starting for ${dateKey}`);
+    const dateKey2 = formatDateKey(datetime);
+    log7.debug(`createDailySchedule: starting for ${dateKey2}`);
     try {
-      const existing = await this.memory.get(`daily-schedule:${dateKey}`);
+      const existing = await this.memory.get(`daily-schedule:${dateKey2}`);
       if (existing) {
-        log7.debug(`createDailySchedule: cache hit for ${dateKey}`);
+        log7.debug(`createDailySchedule: cache hit for ${dateKey2}`);
         try {
           return JSON.parse(existing.content);
         } catch (parseErr) {
@@ -2602,7 +2884,7 @@ class Brain {
       }
       const instruction = await loadPrompt("DAILY_SCHEDULE");
       const promptMessage = [
-        `Target date: ${dateKey} (${datetime.toLocaleDateString("en-US", { weekday: "long" })})`,
+        `Target date: ${dateKey2} (${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)"}`,
@@ -2613,6 +2895,7 @@ 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",
@@ -2620,15 +2903,15 @@ class Brain {
       });
       log7.debug(`createDailySchedule: model returned ${schedule.items.length} slots`);
       await this.memory.add({
-        customId: `daily-schedule:${dateKey}`,
+        customId: `daily-schedule:${dateKey2}`,
         content: JSON.stringify(schedule),
         metadata: {
           kind: "schedule",
           source: "createDailySchedule",
-          date: dateKey
+          date: dateKey2
         }
       });
-      log7.debug(`createDailySchedule: persisted ${dateKey}`);
+      log7.debug(`createDailySchedule: persisted ${dateKey2}`);
       return schedule;
     } catch (error) {
       let reason = error instanceof Error ? error.message + `(${error.name})` : String(error);
@@ -2640,17 +2923,21 @@ 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}-${pad22(month + 1)}`;
+    const monthKey = `${year}-${pad23(month + 1)}`;
     log7.debug(`createMonthlySchedule: starting for ${monthKey}`);
     try {
       const existing = await this.memory.get(`monthly-schedule:${monthKey}`);
@@ -2663,7 +2950,7 @@ class Brain {
         }
       }
       const twoMonthsAgo = new Date(year, month - 2, 1);
-      const twoMonthsAgoKey = `${twoMonthsAgo.getFullYear()}-${pad22(twoMonthsAgo.getMonth() + 1)}`;
+      const twoMonthsAgoKey = `${twoMonthsAgo.getFullYear()}-${pad23(twoMonthsAgo.getMonth() + 1)}`;
       log7.debug(`createMonthlySchedule: gathering context (history, ${twoMonthsAgoKey})`);
       const [history, twoMonthsAgoStored] = await Promise.all([
         this.getHistoryFacts(),
@@ -2691,6 +2978,7 @@ 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",
@@ -2721,11 +3009,11 @@ class Brain {
     }
     log7.debug(`sleepMemory: starting, ${history.length} messages`);
     try {
-      const dateKey = formatDateKey(datetime);
+      const dateKey2 = formatDateKey(datetime);
       const instruction = await loadPrompt("MEMOIR");
       const historyBlock = translateMessageHistory(this.brainbase.displayName, history);
       const promptMessage = [
-        `Date: ${dateKey}`,
+        `Date: ${dateKey2}`,
         `Personality: ${this.brainbase.baseSystemPrompt}`,
         `Conversation log:`,
         historyBlock
@@ -2734,20 +3022,21 @@ 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:${dateKey}`,
+        customId: `daily-journal:${dateKey2}`,
         content: memoir,
         metadata: {
           kind: "daily-journal",
           source: "sleepMemory",
-          date: dateKey
+          date: dateKey2
         }
       });
-      log7.debug(`sleepMemory: journal persisted for ${dateKey}`);
+      log7.debug(`sleepMemory: journal persisted for ${dateKey2}`);
       return memoir;
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
@@ -2756,22 +3045,22 @@ class Brain {
     }
   }
   async getTodayScheduledAvailability(datetime) {
-    const dateKey = formatDateKey(datetime);
+    const dateKey2 = formatDateKey(datetime);
     try {
-      const cached = this.availabilityCache.get(dateKey);
+      const cached = this.availabilityCache.get(dateKey2);
       if (cached) {
-        log7.debug(`getTodayScheduledAvailability: cache hit for ${dateKey}`);
+        log7.debug(`getTodayScheduledAvailability: cache hit for ${dateKey2}`);
         return cached;
       }
-      const stored = await this.memory.get(`daily-schedule:${dateKey}`);
+      const stored = await this.memory.get(`daily-schedule:${dateKey2}`);
       if (!stored) {
-        log7.debug(`getTodayScheduledAvailability: no schedule for ${dateKey}`);
+        log7.debug(`getTodayScheduledAvailability: no schedule for ${dateKey2}`);
         return null;
       }
       const dailySchedule = JSON.parse(stored.content);
       const availability = await this.deriveAvailabilityFromSchedule(dailySchedule);
-      this.availabilityCache.set(dateKey, availability);
-      log7.debug(`getTodayScheduledAvailability: cached ${availability.items.length} windows for ${dateKey}`);
+      this.availabilityCache.set(dateKey2, availability);
+      log7.debug(`getTodayScheduledAvailability: cached ${availability.items.length} windows for ${dateKey2}`);
       return availability;
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
@@ -2782,7 +3071,7 @@ class Brain {
   async getAvailability(datetime = new Date) {
     const h = datetime.getHours();
     const m = datetime.getMinutes();
-    const hhmm = `${pad22(h)}:${pad22(m)}`;
+    const hhmm = `${pad23(h)}:${pad23(m)}`;
     const current = h * 60 + m;
     const toMinutes = (s) => {
       const [hh = 0, mm = 0] = s.split(":").map((x) => parseInt(x, 10));
@@ -2795,10 +3084,10 @@ class Brain {
     return result;
   }
   async getCurrentAndAdjacentSlots(now) {
-    const dateKey = formatDateKey(now);
-    const stored = await this.memory.get(`daily-schedule:${dateKey}`);
+    const dateKey2 = formatDateKey(now);
+    const stored = await this.memory.get(`daily-schedule:${dateKey2}`);
     if (!stored) {
-      log7.debug(`getCurrentAndAdjacentSlots: no schedule for ${dateKey}`);
+      log7.debug(`getCurrentAndAdjacentSlots: no schedule for ${dateKey2}`);
       return [];
     }
     let schedule;
@@ -2831,6 +3120,7 @@ class Brain {
         personality: this.brainbase.baseSystemPrompt
       });
       const result = await llm.call(llm.models.identity, {
+        caller: "availability",
         instruction,
         message: promptMessage,
         jsonSchemaName: "availability",
@@ -2901,74 +3191,56 @@ class Brain {
         content: userPrompt
       }
     ];
-    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}
+    try {
+      await llm.chatWithToolExecution(llm.models.conversation, {
+        caller: initiate ? "start-conversation" : "send-message",
+        instruction: `${this.brainbase.baseSystemPrompt}
 
 ${instruction}`,
-          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 {
+        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
+              });
+            }
             log7.debug(`sendMessage: addReplyMessage rejected (invalid arguments: ${call.function.arguments})`);
+            return JSON.stringify({ ok: false, error: "invalid arguments" });
           }
-          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;
-        }
-        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({
+          if (call.function.name === "searchMemory") {
+            log7.debug(`sendMessage: searchMemory tool call`);
+            return this.executeSearchTool(call.function.arguments);
+          }
+          if (call.function.name === "stop") {
+            log7.debug(`sendMessage: stop tool call`);
+            return JSON.stringify({ ok: true });
+          }
+          log7.debug(`sendMessage: unknown tool "${call.function.name}"`);
+          return 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;
-      }
+          });
+        },
+        shouldEnd: (toolCalls) => toolCalls.some((c) => c.function.name === "stop"),
+        onNoToolCalls: () => {
+          if (replyMessages.length > 0)
+            return null;
+          return "If you do not want to send a message, call the `stop` tool explicitly to end your turn. " + "If you meant to send a message but ended by mistake, call `addReplyMessage`.";
+        }
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      logger.error(`sendMessage: LLM call failed: ${reason}`);
     }
-    logger.warn(`sendMessage: reached maxSteps (${maxSteps}) without final reply`);
+    log7.debug(`sendMessage: done with ${replyMessages.length} replies`);
     return replyMessages;
   }
   async buildMemoryBlock() {
@@ -2977,11 +3249,11 @@ ${instruction}`,
 ${facts || "(none indexed)"}`;
   }
   async buildScheduleBlock(now) {
-    const dateKey = formatDateKey(now);
+    const dateKey2 = 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 (${dateKey} ${now.toTimeString().slice(0, 5)}): (no matching slot in today's schedule)`;
+`)}` : `Currently (${dateKey2} ${now.toTimeString().slice(0, 5)}): (no matching slot in today's schedule)`;
     const days = [
       {
         label: "Yesterday",
@@ -3004,9 +3276,9 @@ ${currentBlock}
 ${blocks.join(`
 `)}`;
   }
-  async getDailyScheduleSummary(dateKey) {
+  async getDailyScheduleSummary(dateKey2) {
     try {
-      const stored = await this.memory.get(`daily-schedule:${dateKey}`);
+      const stored = await this.memory.get(`daily-schedule:${dateKey2}`);
       if (!stored)
         return null;
       const schedule = JSON.parse(stored.content);
@@ -3077,6 +3349,7 @@ ${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
       });
@@ -3084,6 +3357,7 @@ ${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",
@@ -3169,7 +3443,7 @@ function buildSendMessageTools() {
   return [
     {
       name: "addReplyMessage",
-      description: "Append one chat bubble to the reply stream. Call once per bubble you want to send. Do not call when you are done — just return text without tool calls.",
+      description: "Append one chat bubble to the reply stream. Call once per bubble you want to send. After at least one successful call, you may end your turn without calling stop.",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -3193,6 +3467,15 @@ function buildSendMessageTools() {
         },
         required: ["query"]
       }
+    },
+    {
+      name: "stop",
+      description: "End your turn without sending any further messages. Required when you choose not to send a message. Not needed once you have already called addReplyMessage at least once.",
+      parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {}
+      }
     }
   ];
 }
@@ -3218,13 +3501,6 @@ function parseSearchArguments(json) {
   }
   return null;
 }
-function stripAssistantForHistory(message) {
-  return {
-    role: "assistant",
-    content: message.content,
-    toolCalls: message.toolCalls
-  };
-}
 
 // src/channel/discord.ts
 import {
@@ -3244,10 +3520,18 @@ 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 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 * * *";
+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"
+];
 
 class BaseChannel {
   brain;
@@ -3267,24 +3551,27 @@ class BaseChannel {
   static activeChannels = new Map;
   constructor(brain) {
     this.brain = brain;
-    this.registerCron(SLEEP_MEMORY_CRON_KEY, SLEEP_MEMORY_CRON_PATTERN, async () => {
-      const dateKey = formatDateKey(new Date);
+    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) {
       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:${dateKey}`);
+      const existing = await this.brain.memory.get(`daily-journal:${dateKey2}`);
       if (existing) {
-        logger.debug(`sleepMemory cron: skip — journal for ${dateKey} exists`);
+        logger.debug(`sleepMemory cron: skip — journal for ${dateKey2} exists`);
         return;
       }
-      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());
+    }
+    const history = await this.getMessageHistoryBetween(new Date(Date.now() - 24 * 60 * 60 * 1000), new Date);
+    await this.brain.sleepMemory(new Date, history);
   }
   async regenerateSchedules() {
     logger.debug(`regenerateSchedules: tick for ${this.brain.brainbase.displayName}`);
@@ -3305,8 +3592,8 @@ class BaseChannel {
       return;
     }
     const now = new Date;
-    const dateKey = formatDateKey(now);
-    const count = this.startConversationCounters.get(dateKey) ?? 0;
+    const dateKey2 = formatDateKey(now);
+    const count = this.startConversationCounters.get(dateKey2) ?? 0;
     const countThreshold = this.brain.brainbase.startConversationCountThreshold;
     if (count >= countThreshold)
       return;
@@ -3319,7 +3606,7 @@ class BaseChannel {
       });
       if (replies.length === 0)
         return;
-      this.startConversationCounters.set(dateKey, count + 1);
+      this.startConversationCounters.set(dateKey2, count + 1);
       this.startConversationTimeout = true;
       setTimeout(() => {
         this.startConversationTimeout = false;
@@ -3506,6 +3793,88 @@ 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()));
   }
@@ -3891,8 +4260,8 @@ class TelegramChannel extends BaseChannel {
 
 // src/utils/daemonClient.ts
 import { connect } from "node:net";
-import { join as join3 } from "node:path";
-var DAEMON_SOCKET_PATH = join3(config.brainboxRoot, "daemon.sock");
+import { join as join4 } from "node:path";
+var DAEMON_SOCKET_PATH = join4(config.brainboxRoot, "daemon.sock");
 async function sendToDaemon(payload) {
   logger.debug(`sendToDaemon: command="${payload.command}" args=${JSON.stringify(payload.args) ?? "null"}`);
   let reply;
@@ -3954,7 +4323,7 @@ function exchangeOnce(payload) {
 // src/commands/daemon.ts
 import { createServer } from "node:net";
 import { chmodSync, unlinkSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/commands/daemon/commands.ts
 var log8 = logger.child("daemon-cmd");
@@ -4015,6 +4384,63 @@ 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();
@@ -4049,9 +4475,10 @@ async function startChannels() {
   return started;
 }
 async function daemon() {
-  const logFile = join4(config.brainboxRoot, "brainbox.log");
-  logger.configure({ file: logFile });
-  logger.debug(`daemon: boot (log=${logFile})`);
+  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})`);
   const started = await startChannels();
   if (started === 0) {
     logger.info("No activated brains with channels. Daemon idling.");
@@ -4218,6 +4645,33 @@ 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",
@@ -4228,6 +4682,8 @@ 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;
 }
 
@@ -5572,12 +6028,12 @@ function register8(program) {
 
 // src/index.ts
 var __filename3 = fileURLToPath2(import.meta.url);
-var __dirname3 = dirname4(__filename3);
+var __dirname3 = dirname3(__filename3);
 logger.configure({ level: config.debug ? "debug" : "info" });
 logger.debug(`brainbox starting (debug=${config.debug}, root=${config.brainboxRoot})`);
 function getVersion() {
   try {
-    const pkgPath = join5(__dirname3, "..", "package.json");
+    const pkgPath = join6(__dirname3, "..", "package.json");
     const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {