@yugabytedb/meko-mcp 2.2.0 → 2.3.0

package/lib/migrate/adapters/claude-code.mjs

@@ -10,7 +10,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { agentIdForClaude, slugifyCwd } from "../id.mjs";
+import { agentIdForClaude, deriveLegacyAgentId, slugifyCwd } from "../id.mjs";
 import { parseSessionStream, peekSessionMetadata } from "../claude-parser.mjs";
 
 function homeDir() {
@@ -46,6 +46,7 @@ export function userClaudeMdPath(opts = {}) {
  * @property {string} slug
  * @property {string} cwd             Derived from the first session in the slug dir.
  * @property {string} agentId
+ * @property {string} legacyAgentId   Pre-MEKO-590 resume-state alias.
  * @property {number} size
  * @property {number} mtimeMs
  * @property {boolean} likelyInProgress
@@ -96,12 +97,20 @@ export async function listSessions(opts) {
       let stat;
       try { stat = fs.statSync(full); } catch { continue; }
       const sessionUuid = e.name.replace(/\.jsonl$/, "");
+      const legacyAgentId = deriveLegacyAgentId({
+        client: "claude_code",
+        cwd: slugCwd,
+        envOverride: process.env.MEKO_AGENT_ID,
+      });
       out.push({
         sessionUuid,
         path: full,
         slug,
         cwd: slugCwd,
-        agentId: agentIdForClaude(slugCwd),
+        // Historical: `slugCwd` is a cwd recorded in an old transcript (or
+        // reverse-slugged from the project dir name) and may no longer exist.
+        agentId: agentIdForClaude(slugCwd, { historical: true }),
+        legacyAgentId,
         size: stat.size,
         mtimeMs: stat.mtimeMs,
         likelyInProgress: stat.mtimeMs > Date.now() - 60_000,

package/lib/migrate/adapters/codex.mjs

@@ -34,7 +34,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { agentIdForCodex } from "../id.mjs";
+import { agentIdForCodex, deriveLegacyAgentId } from "../id.mjs";
 
 // Cap for the first-record read. Codex embeds `base_instructions` in the
 // session_meta line, which routinely exceeds 16 KiB; read generously so the
@@ -80,6 +80,7 @@ export function sessionsRoot(opts = {}) {
  * @property {string} path            Absolute path to the rollout .jsonl.
  * @property {string} cwd             Project root from session_meta.
  * @property {string} agentId         `codex:<repo-basename>`.
+ * @property {string} legacyAgentId   Pre-MEKO-590 resume-state alias.
  * @property {"codex"} source
  * @property {number} mtimeMs
  * @property {boolean} likelyInProgress
@@ -202,7 +203,13 @@ export function listSessions(opts) {
       sessionUuid: sessionUuidForRollout(full),
       path: full,
       cwd: meta.cwd,
-      agentId: agentIdForCodex(meta.cwd),
+      // Historical: cwd recorded in the rollout, may be gone from disk.
+      agentId: agentIdForCodex(meta.cwd, { historical: true }),
+      legacyAgentId: deriveLegacyAgentId({
+        client: "codex",
+        cwd: meta.cwd,
+        envOverride: process.env.MEKO_AGENT_ID,
+      }),
       source: "codex",
       mtimeMs: stat.mtimeMs,
       likelyInProgress: stat.mtimeMs > Date.now() - 60_000,

package/lib/migrate/adapters/memory-md.mjs

@@ -14,6 +14,7 @@ import os from "node:os";
 import {
   CLAUDE_CODE_USER_AGENT_ID,
   agentIdForClaude,
+  deriveLegacyAgentId,
   memoryHash,
   slugifyCwd,
 } from "../id.mjs";
@@ -26,6 +27,7 @@ function homeDir() {
 /**
  * @typedef {Object} MemoryItem
  * @property {string} agentId
+ * @property {string} [legacyAgentId] Pre-MEKO-590 state alias.
  * @property {string} text
  * @property {string} hash
  * @property {{source: string, scope: "user"|"project", sourcePath: string, heading?: string, name?: string, description?: string, type?: string}} metadata
@@ -62,22 +64,35 @@ export async function enumerateMemoryItems(opts) {
         if (!stat.isDirectory()) continue;
         const cwd = await cwdForSlugDir(dir, slug);
         if (!cwd) continue;
-        const agentId = agentIdForClaude(cwd);
+        // Historical: recorded/reverse-slugged cwd, may be gone from disk.
+        const agentId = agentIdForClaude(cwd, { historical: true });
+        const legacyAgentId = deriveLegacyAgentId({
+          client: "claude_code",
+          cwd,
+          envOverride: process.env.MEKO_AGENT_ID,
+        });
         const projMd = path.join(cwd, ".claude", "CLAUDE.md");
-        items.push(...readClaudeMd(projMd, agentId, "project", cwd));
+        items.push(...readClaudeMd(projMd, agentId, "project", cwd, legacyAgentId));
         const memDir = path.join(dir, "memory");
-        items.push(...readMemoryDir(memDir, agentId, "project", cwd));
+        items.push(...readMemoryDir(memDir, agentId, "project", cwd, legacyAgentId));
       }
     }
   } else {
     const cwd = opts.projectCwd;
     if (!cwd) return [];
-    const agentId = agentIdForClaude(cwd);
+    // Keep project CLAUDE.md and indexed memories in the same bucket as the
+    // historical session adapter, including when the cwd is no longer a repo.
+    const agentId = agentIdForClaude(cwd, { historical: true });
+    const legacyAgentId = deriveLegacyAgentId({
+      client: "claude_code",
+      cwd,
+      envOverride: process.env.MEKO_AGENT_ID,
+    });
     const projMd = path.join(cwd, ".claude", "CLAUDE.md");
-    items.push(...readClaudeMd(projMd, agentId, "project", cwd));
+    items.push(...readClaudeMd(projMd, agentId, "project", cwd, legacyAgentId));
     const slug = slugifyCwd(cwd);
     const memDir = path.join(home, ".claude", "projects", slug, "memory");
-    items.push(...readMemoryDir(memDir, agentId, "project", cwd));
+    items.push(...readMemoryDir(memDir, agentId, "project", cwd, legacyAgentId));
   }
 
   return items;
@@ -94,9 +109,10 @@ export async function enumerateMemoryItems(opts) {
  *   so downstream consumers can correlate even after the agent_id is
  *   sanitized down to a basename. Null for user-scope items (which use the
  *   `meko_agent` common bucket).
+ * @param {string|null} [legacyAgentId] Pre-MEKO-590 compatibility alias.
  * @returns {MemoryItem[]}
  */
-export function readClaudeMd(filePath, agentId, scope, cwd = null) {
+export function readClaudeMd(filePath, agentId, scope, cwd = null, legacyAgentId = null) {
   let raw;
   try {
     raw = fs.readFileSync(filePath, "utf8");
@@ -112,6 +128,7 @@ export function readClaudeMd(filePath, agentId, scope, cwd = null) {
     const name = heading || path.basename(filePath);
     return {
       agentId,
+      ...(legacyAgentId && legacyAgentId !== agentId ? { legacyAgentId } : {}),
       text,
       hash: memoryHash(text, name),
       name,
@@ -166,9 +183,10 @@ export function splitTopLevelSections(md) {
  * @param {string} agentId
  * @param {"user"|"project"} scope
  * @param {string|null} [cwd] - Absolute project path; attached to metadata.
+ * @param {string|null} [legacyAgentId] Pre-MEKO-590 compatibility alias.
  * @returns {MemoryItem[]}
  */
-export function readMemoryDir(memDir, agentId, scope, cwd = null) {
+export function readMemoryDir(memDir, agentId, scope, cwd = null, legacyAgentId = null) {
   let entries;
   try {
     entries = fs.readdirSync(memDir);
@@ -192,6 +210,7 @@ export function readMemoryDir(memDir, agentId, scope, cwd = null) {
     const name = frontmatter.name || entry.replace(/\.md$/, "");
     out.push({
       agentId,
+      ...(legacyAgentId && legacyAgentId !== agentId ? { legacyAgentId } : {}),
       text,
       hash: memoryHash(text, name),
       name,

package/lib/migrate/adapters/opencode.mjs

@@ -0,0 +1,148 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import path from "node:path";
+import { agentIdForOpenCode } from "../id.mjs";
+import { normalizeOpenCodeSession } from "../opencode-normalizer.mjs";
+function defaultRunExport(sessionId, opts = {}) {
+  const runner = opts.runExport ?? defaultRunExportCommand;
+  return runner(sessionId, opts);
+}
+function defaultRunExportCommand(sessionId, opts = {}) {
+  const bin = opts.opencodeBin ?? probeOpenCode()?.path ?? "opencode";
+  const result = spawnSync(bin, ["export", sessionId], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: 10_000,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(
+      `opencode export ${sessionId} failed (${result.status}): ${(result.stderr || "").trim()}`,
+    );
+  }
+  return parseJsonStdout(result.stdout);
+}
+function defaultRunList(opts = {}) {
+  const runner = opts.runList ?? defaultRunListCommand;
+  return runner(opts);
+}
+function defaultRunListCommand(opts = {}) {
+  // OpenCode 1.18.x exposes roots only here; child sessions are not
+  // enumerable through the supported CLI.
+  const bin = opts.opencodeBin ?? probeOpenCode()?.path ?? "opencode";
+  const result = spawnSync(bin, ["session", "list", "--format", "json"], {
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 10_000,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(
+      `opencode session list failed (${result.status}): ${(result.stderr || "").trim()}`,
+    );
+  }
+  return parseJsonStdout(result.stdout);
+}
+function parseJsonStdout(stdout) {
+  const trimmed = String(stdout || "").trim();
+  if (!trimmed) return [];
+  try {
+    return JSON.parse(trimmed);
+  } catch (err) {
+    throw new Error(`invalid OpenCode JSON output: ${err.message}`);
+  }
+}
+export function probeOpenCode(opts = {}) {
+  const probe = opts.probe ?? opts.probeOpenCode ?? defaultProbeOpenCode;
+  return probe();
+}
+export function isSupportedOpenCodeVersion(version) {
+  const match = String(version || "").match(/(\d+)\.(\d+)\.(\d+)/);
+  return Boolean(match && Number(match[1]) === 1 && Number(match[2]) === 18);
+}
+function defaultProbeOpenCode() {
+  try {
+    const which = process.platform === "win32" ? "where" : "which";
+    const pathResult = execFileSync(which, ["opencode"], { encoding: "utf8", timeout: 10_000 }).trim().split(/\r?\n/)[0];
+    const version = execFileSync(pathResult, ["--version"], { encoding: "utf8", timeout: 10_000 }).trim();
+    return { found: true, path: pathResult, version };
+  } catch {
+    return { found: false, path: "", version: "" };
+  }
+}
+function sessionScopeMatches(sessionDir, opts) {
+  if (opts.scope !== "project") return true;
+  return path.resolve(sessionDir) === path.resolve(opts.projectCwd || process.cwd());
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+export async function listSessions(opts = {}) {
+  const installation = probeOpenCode(opts);
+  if (!installation?.found) return [];
+  if (!isSupportedOpenCodeVersion(installation.version)) {
+    return [];
+  }
+  const listed = await Promise.resolve(defaultRunList(opts));
+  const rows = Array.isArray(listed) ? listed : (listed?.sessions || listed?.data);
+  if (!Array.isArray(rows)) {
+    throw new Error("invalid OpenCode session list shape: expected an array");
+  }
+  const out = [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    const sessionId = firstString(row.id, row.sessionID, row.sessionId);
+    if (!sessionId) continue;
+    const cwd = firstString(row.directory, row.cwd, row.projectPath);
+    if (!cwd || !sessionScopeMatches(cwd, opts)) continue;
+    const mtimeMs = timestampMs(row.updated, row.updatedAt, row.time?.updated);
+    out.push({
+      sessionUuid: sessionId,
+      path: sessionId,
+      cwd,
+      agentId: agentIdForOpenCode(cwd, { historical: true }),
+      mtimeMs,
+      likelyInProgress: mtimeMs > Date.now() - 60_000,
+      parentSessionId: firstString(row.parentID, row.parentId) || null,
+    });
+  }
+  return out;
+}
+function timestampMs(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Date.parse(value);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return 0;
+}
+export async function parseSession(ref, opts = {}) {
+  let exportShape = ref.exportData;
+  if (!exportShape) {
+    exportShape = await Promise.resolve(defaultRunExport(ref.sessionUuid || ref.path, opts));
+  }
+  const normalized = normalizeOpenCodeSession(exportShape, {
+    terminalError: Boolean(ref.terminalError),
+    interrupted: Boolean(ref.interrupted),
+  });
+  return {
+    sessionUuid: normalized.sessionId,
+    firstUserText: normalized.firstUserText,
+    startedAt: normalized.startedAt,
+    exchanges: normalized.exchanges.map((ex) => ({
+      user_uuid: ex.userId,
+      input: ex.input,
+      output: ex.output,
+      reasoning: "",
+      timestamp: ex.timestamp,
+      interrupted: ex.interrupted,
+    })),
+    partial: Boolean(normalized.partial),
+    parentSessionId: normalized.parentSessionId,
+    cwd: normalized.cwd,
+  };
+}

package/lib/migrate/claude-parser.mjs

@@ -5,8 +5,12 @@
  *   - no CLI / side effects; only exports
  *   - streaming via readline so sessions larger than available RAM
  *     don't need to be loaded whole
- *   - filters isSidechain / isMeta / attachment-type entries up front
- *     (the hook-side version doesn't need to because it runs live)
+ *   - filters isSidechain / attachment-type entries up front, and drops
+ *     `isMeta` entries other than skill context and subagent hand-backs
+ *   - folds skill bodies, task notifications and subagent hand-backs into
+ *     the turn they belong to, with the same rules as capture.js
+ *     (MEKO-710). The whole session is parsed at once, so there is no parse
+ *     window; a session still being written holds its trailing turn.
  *
  * Kept deliberately independent of `skills/hooks-handlers/lib/capture.js`:
  * installer packages ship without that sibling directory, and mixing
@@ -15,6 +19,7 @@
  */
 
 import fs from "node:fs";
+import path from "node:path";
 import readline from "node:readline";
 
 export const MAX_THINKING_LEN = Number(process.env.MEKO_MAX_THINKING_LEN ?? 2000);
@@ -24,6 +29,8 @@ export const MAX_TOOL_RESULT_LEN = Number(process.env.MEKO_MAX_TOOL_RESULT_LEN ?
 const SKIP_INPUT_PATTERN =
   /^<(system-reminder|command-|local-command|available-deferred)/;
 
+const SKILL_BODY_PATTERN = /^Base directory for this skill: *(\S+)/;
+
 export function truncate(str, max) {
   if (!str || str.length <= max) return str;
   return str.slice(0, max) + "... [truncated]";
@@ -104,6 +111,84 @@ export function extractToolResultContent(msg) {
   return "TOOL RESULT:\n" + parts.join("\n---\n");
 }
 
+/**
+ * Render a Claude Code skill or prompt command entry as the command the user
+ * typed (`/commit fix typo`). Only the `<command-message>`-led shape loads a
+ * skill; built-in commands lead with `<command-name>` and return "".
+ * Mirrors skillCommandInput in capture.js.
+ */
+export function skillCommandInput(text) {
+  if (typeof text !== "string" || !/^<command-message>/.test(text)) return "";
+  const name = /<command-name>([\s\S]*?)<\/command-name>/.exec(text);
+  if (!name) return "";
+  const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(text);
+  return [name[1].trim(), args ? args[1].trim() : ""].filter(Boolean).join(" ");
+}
+
+/** Is this a background-task or subagent notification? Mirrors capture.js. */
+export function isTaskNotification(obj) {
+  if (obj?.type !== "user" || isToolResultMessage(obj)) return false;
+  if (obj.origin && obj.origin.kind === "task-notification") return true;
+  return /^\s*<task-notification>/.test(extractText(obj.message?.content));
+}
+
+/**
+ * Is this a subagent's hand-back report? Claude Code writes it as an
+ * `isMeta` entry tagged `origin: { kind: "peer", handback: true }`. Other
+ * peer messages are requests from another session. Mirrors capture.js.
+ */
+export function isSubagentHandback(obj) {
+  if (obj?.type !== "user" || isToolResultMessage(obj)) return false;
+  return obj.origin?.kind === "peer" && obj.origin.handback === true;
+}
+
+function handbackInput(obj) {
+  const name = obj.origin?.name || obj.origin?.from || "";
+  return name ? `Agent message: ${name}` : "Agent message";
+}
+
+/**
+ * Is this an `isMeta` entry Claude Code injected while loading a skill? The
+ * model-invoked shape carries `sourceToolUseID`; a typed `/skill` body starts
+ * with "Base directory for this skill:". Mirrors capture.js.
+ */
+export function isSkillContext(obj) {
+  if (obj?.type !== "user" || obj.isMeta !== true) return false;
+  if (isToolResultMessage(obj)) return false;
+  if (obj.sourceToolUseID) return true;
+  return SKILL_BODY_PATTERN.test(extractText(obj.message?.content));
+}
+
+function taskNotificationInput(text) {
+  const summary = /<summary>([\s\S]*?)<\/summary>/.exec(text || "");
+  return `Task notification: ${summary ? summary[1].trim() : "background task update"}`;
+}
+
+function skillContextInput(text) {
+  const dir = SKILL_BODY_PATTERN.exec(text || "");
+  const name = dir ? path.basename(dir[1].replace(/\/+$/, "")) : "";
+  return name ? `Skill loaded: ${name}` : "Skill context loaded";
+}
+
+/**
+ * The rendered input for a turn. A typed skill command that got its body is
+ * unwrapped to `/name args`; a turn opened by injected context gets a one-line
+ * summary so that context is never sent as user input.
+ */
+function turnInput(turn) {
+  const text = extractText(turn.userMsg.message?.content);
+  if (isTaskNotification(turn.userMsg)) return taskNotificationInput(text);
+  if (isSubagentHandback(turn.userMsg)) return handbackInput(turn.userMsg);
+  if (isSkillContext(turn.userMsg)) return skillContextInput(text);
+  return turn.injectedEntries.some((e) => e.isMeta === true && !isSubagentHandback(e))
+    ? skillCommandInput(text) || text
+    : text;
+}
+
+function isCapturableInput(input) {
+  return !!input && !SKIP_INPUT_PATTERN.test(input);
+}
+
 /**
  * Should this JSON entry be dropped before we start pairing turns?
  * Mirrors the plan: skip sidechains, meta turns, and the non-message types.
@@ -177,6 +262,10 @@ export async function parseSessionStream(sessionPath) {
   // Turn-assembly state.
   const exchanges = [];
   let current = null;
+  // The last entry kept for turn assembly, and whether consecutive injected
+  // isMeta entries are still arriving after a skill command or Skill call.
+  let prev = null;
+  let insideInjectedRun = false;
 
   for await (const raw of rl) {
     const line = raw.trim();
@@ -191,28 +280,63 @@ export async function parseSessionStream(sessionPath) {
     if (!cwd && typeof obj.cwd === "string") cwd = obj.cwd;
     if (!gitBranch && typeof obj.gitBranch === "string") gitBranch = obj.gitBranch;
     if (!startedAt && typeof obj.timestamp === "string") startedAt = obj.timestamp;
-    if (!firstUserText && obj.type === "user" && !isSkippable(obj) && !isToolResultMessage(obj)) {
+    if (!firstUserText && obj.type === "user" && !isSkippable(obj) && !isToolResultMessage(obj) && !isTaskNotification(obj)) {
       const txt = extractText(obj.message?.content);
       if (txt && !SKIP_INPUT_PATTERN.test(txt)) firstUserText = txt.slice(0, 240);
     }
 
-    if (isSkippable(obj)) continue;
+    // Skill context and hand-backs are isMeta but belong to their turn, so
+    // test them before isSkippable drops every other isMeta entry. A
+    // hand-back is never skill context, even if it carries sourceToolUseID.
+    const handback = isSubagentHandback(obj) && obj.isSidechain !== true;
+    const skillContext =
+      !handback && isSkillContext(obj) && obj.isSidechain !== true;
+    if (!skillContext && !handback && isSkippable(obj)) continue;
+
+    const isUserText = obj.type === "user" && !isToolResultMessage(obj);
+    let foldIntoCurrent = false;
+    if (isUserText && current) {
+      if (skillContext) {
+        const prevIsSkillCommand =
+          prev?.type === "user" &&
+          skillCommandInput(extractText(prev.message?.content)) !== "";
+        foldIntoCurrent =
+          !!obj.sourceToolUseID || insideInjectedRun || prevIsSkillCommand;
+      } else if (isTaskNotification(obj) || handback) {
+        // Folding into a turn that is never captured (a `/compact` or
+        // `<local-command-…>` turn) would drop the reply with it.
+        foldIntoCurrent = isCapturableInput(turnInput(current));
+      }
+    }
+    insideInjectedRun = skillContext && (!!obj.sourceToolUseID || foldIntoCurrent);
 
-    if (obj.type === "user" && !isToolResultMessage(obj)) {
+    if (isUserText && !foldIntoCurrent) {
       if (current) {
         const built = buildExchange(current);
         if (built) exchanges.push(built);
       }
-      current = { userMsg: obj, assistantEntries: [], toolResultEntries: [] };
+      current = {
+        userMsg: obj,
+        assistantEntries: [],
+        toolResultEntries: [],
+        injectedEntries: [],
+      };
     } else if (current) {
       if (obj.type === "assistant") {
         current.assistantEntries.push(obj);
       } else if (obj.type === "user" && isToolResultMessage(obj)) {
         current.toolResultEntries.push(obj);
+      } else if (isUserText) {
+        current.injectedEntries.push(obj);
       }
     }
+    prev = obj;
   }
-  if (current) {
+  // A session still being written can get more entries for its trailing
+  // turn, such as a task notification and its reply. Hold that turn, like
+  // the Codex adapter does: if it were sent now, resume would skip it on the
+  // next run and the new entries would never be migrated.
+  if (current && !partial) {
     const built = buildExchange(current);
     if (built) exchanges.push(built);
   }
@@ -236,8 +360,8 @@ function baseName(p) {
 }
 
 function buildExchange(ex) {
-  const input = extractText(ex.userMsg.message?.content);
-  if (!input || SKIP_INPUT_PATTERN.test(input)) return null;
+  const input = turnInput(ex);
+  if (!isCapturableInput(input)) return null;
   if (ex.assistantEntries.length === 0) return null;
 
   const outputParts = [];
@@ -257,9 +381,29 @@ function buildExchange(ex) {
     const trText = extractToolResultContent(tr);
     if (trText) reasoningParts.push(trText);
   }
+  const anchoredOnInjection =
+    isTaskNotification(ex.userMsg) || isSubagentHandback(ex.userMsg) || isSkillContext(ex.userMsg);
+  const injected = anchoredOnInjection
+    ? [ex.userMsg, ...ex.injectedEntries]
+    : ex.injectedEntries;
+  for (const inj of injected) {
+    const text = extractText(inj.message?.content);
+    if (text) {
+      const label = isTaskNotification(inj)
+        ? "TASK NOTIFICATION:\n"
+        : isSubagentHandback(inj)
+          ? "AGENT MESSAGE:\n"
+          : "INJECTED CONTEXT:\n";
+      reasoningParts.push(label + truncate(text, MAX_TOOL_RESULT_LEN));
+    }
+  }
 
   return {
     user_uuid: ex.userMsg.uuid || "unknown",
+    // Uuids of the injected entries folded into this turn. Older migrator
+    // versions sent a task notification as its own exchange, so a resume
+    // cursor saved by them can name one of these.
+    folded_uuids: ex.injectedEntries.map((e) => e.uuid).filter(Boolean),
     input,
     output: outputParts.join("\n\n"),
     reasoning: reasoningParts.join("\n---\n"),