chainlesschain 0.162.47 → 0.162.49

package/src/repl/agent-repl.js

@@ -76,6 +76,7 @@ import { composeSystemPrompt } from "../runtime/system-prompt.js";
 import { makeFallbackChatFn } from "../runtime/fallback-model.js";
 import { resolveSlashMacro } from "./slash-macro.js";
 import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
+import { newCostStore, addUsage } from "./session-cost.js";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -757,21 +758,30 @@ export async function startAgentRepl(options = {}) {
       "/cd",
       "/clear",
       "/compact",
+      "/config",
       "/context",
+      "/cost",
       "/cowork",
+      "/doctor",
       "/exit",
+      "/export",
       "/help",
+      "/ide",
       "/mcp",
+      "/memory",
       "/model",
       "/output-style",
+      "/permissions",
       "/plan",
       "/profile",
       "/provider",
       "/quit",
       "/reindex",
+      "/reload-skills",
       "/rewind",
       "/search",
       "/session",
+      "/sessions",
       "/stats",
       "/statusline",
       "/sub-agents",
@@ -879,6 +889,7 @@ export async function startAgentRepl(options = {}) {
   let _curModel = model; // tracks the per-turn active model for the readout
   let _ctxUsedTokens = 0;
   let _turnCount = 0;
+  const _costStore = newCostStore(); // running token spend for `/cost`
   let _renderStatus = null;
   try {
     const slm = await import("../lib/status-line.cjs");
@@ -953,8 +964,16 @@ export async function startAgentRepl(options = {}) {
         const { runBangCommand } = await import("../lib/repl-bang-memorize.js");
         const res = runBangCommand(trimmed, { cwd: process.cwd() });
         logger.log(chalk.gray(`$ ${res.cmd}`));
-        if (res.stdout) process.stdout.write(res.stdout.endsWith("\n") ? res.stdout : `${res.stdout}\n`);
-        if (res.stderr) process.stderr.write(chalk.red(res.stderr.endsWith("\n") ? res.stderr : `${res.stderr}\n`));
+        if (res.stdout)
+          process.stdout.write(
+            res.stdout.endsWith("\n") ? res.stdout : `${res.stdout}\n`,
+          );
+        if (res.stderr)
+          process.stderr.write(
+            chalk.red(
+              res.stderr.endsWith("\n") ? res.stderr : `${res.stderr}\n`,
+            ),
+          );
         if (res.error) logger.error(`shell error: ${res.error.message}`);
         logger.log(chalk.gray(`(exit ${res.exitCode})`));
         messages.push(res.contextMessage);
@@ -969,14 +988,17 @@ export async function startAgentRepl(options = {}) {
     // cc.md (auto-loaded next session) and keep it active in this one.
     if (trimmed.startsWith("#") && trimmed.slice(1).trim()) {
       try {
-        const { appendMemoryNote } = await import("../lib/repl-bang-memorize.js");
+        const { appendMemoryNote } =
+          await import("../lib/repl-bang-memorize.js");
         const res = appendMemoryNote(trimmed, { cwd: process.cwd() });
         messages.push({
           role: "system",
           content: `<memory-note source="${res.target}">${res.note}</memory-note>`,
         });
         logger.log(
-          chalk.green(`✔ remembered in ${res.target}${res.created ? " (created)" : ""}`),
+          chalk.green(
+            `✔ remembered in ${res.target}${res.created ? " (created)" : ""}`,
+          ),
         );
       } catch (err) {
         logger.error(`# memorize failed: ${err.message}`);
@@ -1009,15 +1031,36 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/statusline")} Context-usage line on/off (/statusline [on|off])`,
       );
+      logger.log(
+        `  ${chalk.cyan("/config")}     Effective config (provider/model, keys masked)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/doctor")}     Session health check (provider/key/IDE/MCP/hooks)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/memory")}     Project-memory files loaded (cc.md hierarchy + rules)`,
+      );
       logger.log(
         `  ${chalk.cyan("/context")}    Live context-window usage by role`,
       );
+      logger.log(
+        `  ${chalk.cyan("/cost")}       Session token spend + estimated $ (so far)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/permissions")} Allow/ask/deny rules in effect this session`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/export")}     Save this conversation to a Markdown file (/export [path])`,
+      );
       logger.log(
         `  ${chalk.cyan("/rewind")}     Rewind conversation to an earlier turn (double-Esc lists)`,
       );
       logger.log(
         `  ${chalk.cyan("/cd <dir>")}   Change working directory mid-session (completion/memory follow)`,
       );
+      logger.log(
+        `  ${chalk.cyan("/reload-skills")} Re-scan skill layers without restarting`,
+      );
       logger.log(
         `  ${chalk.cyan("/compact")}    Smart compact (importance-based)`,
       );
@@ -1026,6 +1069,9 @@ export async function startAgentRepl(options = {}) {
       );
       logger.log(`  ${chalk.cyan("/task clear")} Clear current task`);
       logger.log(`  ${chalk.cyan("/session")}    Show current session info`);
+      logger.log(
+        `  ${chalk.cyan("/sessions")}   List recent resumable sessions (/session resume <id> to switch)`,
+      );
       logger.log(
         `  ${chalk.cyan("/reindex")}    Reindex notes for BM25 search`,
       );
@@ -1055,6 +1101,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/sub-agents")}  Show active/completed sub-agents`,
       );
+      logger.log(
+        `  ${chalk.cyan("/ide")}        IDE bridge status (connected editor, tools, or why not)`,
+      );
       logger.log(chalk.bold("\nCapabilities:"));
       logger.log("  Read, write, and edit files");
       logger.log("  Run shell commands (git, npm, etc.)");
@@ -1278,14 +1327,11 @@ export async function startAgentRepl(options = {}) {
 
     if (trimmed === "/rewind" || trimmed.startsWith("/rewind ")) {
       try {
-        const { listUserTurns, rewindToTurn, renderTurnList } = await import(
-          "../lib/repl-rewind.js"
-        );
+        const { listUserTurns, rewindToTurn, renderTurnList } =
+          await import("../lib/repl-rewind.js");
         const arg = trimmed.slice("/rewind".length).trim();
         if (!arg) {
-          logger.log(
-            chalk.bold("\nRewind — pick a user turn (newest first):"),
-          );
+          logger.log(chalk.bold("\nRewind — pick a user turn (newest first):"));
           logger.log(renderTurnList(listUserTurns(messages)));
           logger.log(
             chalk.gray(
@@ -1320,9 +1366,8 @@ export async function startAgentRepl(options = {}) {
       // window. Reuses the same categorizer + estimator as the archived view.
       try {
         const { categorizeContext } = await import("../commands/context.js");
-        const { estimateTokens } = await import(
-          "../harness/prompt-compressor.js"
-        );
+        const { estimateTokens } =
+          await import("../harness/prompt-compressor.js");
         const { buckets, counts, total } = categorizeContext(
           messages,
           estimateTokens,
@@ -1417,7 +1462,7 @@ export async function startAgentRepl(options = {}) {
     }
 
     // Session info
-    if (trimmed.startsWith("/session")) {
+    if (trimmed === "/session" || trimmed.startsWith("/session ")) {
       const sessionArg = trimmed.slice(8).trim();
       if (sessionArg.startsWith("resume ")) {
         const resumeId = sessionArg.slice(7).trim();
@@ -1462,6 +1507,24 @@ export async function startAgentRepl(options = {}) {
     }
 
     // Reindex notes
+    // `/reload-skills` (Claude-Code 2.1.152 parity): re-scan the 6 skill
+    // layers (incl. .claude/skills) without restarting the session.
+    if (trimmed === "/reload-skills") {
+      try {
+        const { reloadSkills } = await import("../runtime/agent-core.js");
+        const n = reloadSkills();
+        logger.log(
+          chalk.green(
+            `✔ skills reloaded — ${n} available (6 layers re-scanned)`,
+          ),
+        );
+      } catch (err) {
+        logger.error(`/reload-skills failed: ${err.message}`);
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/reindex") {
       if (contextEngine) {
         contextEngine.reindexNotes();
@@ -2077,6 +2140,42 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/sessions` — list recent RESUMABLE conversations (read-only; the ids
+    // work with `cc agent --resume <id>`). `/session` shows the current one.
+    if (trimmed === "/sessions" || trimmed === "/sessions ") {
+      try {
+        const { listRecentSessions } = await import("../lib/recent-session.js");
+        const { renderRecentSessions } = await import("./recent-sessions.js");
+        const sessions = listRecentSessions({ db: _hookDb }, { scan: 20 });
+        logger.log(renderRecentSessions(sessions, { currentId: sessionId }));
+      } catch (err) {
+        logger.error(chalk.red(`/sessions failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/memory` — project-memory files auto-loaded into the system prompt
+    // (cc.md hierarchy + imports + path-scoped rules). Distinct from `#` (add
+    // a note) and `cc memory recall` (scoped store).
+    if (trimmed === "/memory" || trimmed === "/memory ") {
+      try {
+        const { loadProjectInstructions } =
+          await import("../lib/project-instructions.js");
+        const { renderMemoryFiles } = await import("./memory-status.js");
+        const loaded = loadProjectInstructions({ cwd: process.cwd() });
+        logger.log(
+          renderMemoryFiles(loaded, {
+            enabled: process.env.CC_PROJECT_MEMORY !== "0",
+          }),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/memory failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
     // `/mcp` — overview of connected MCP servers' resources + prompts.
     if (trimmed === "/mcp" || trimmed === "/mcp ") {
       const mcpClient = _adhocMcp?.mcpClient || _bundleMcpClient;
@@ -2085,6 +2184,131 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/config` — effective configuration (secret-safe): the LLM provider/model
+    // in effect, whether keys are set, web-search backend, config path.
+    if (trimmed === "/config" || trimmed === "/config ") {
+      try {
+        const { loadConfig } = await import("../lib/config-manager.js");
+        const { getConfigPath } = await import("../lib/paths.js");
+        const { renderConfigSummary } = await import("./config-summary.js");
+        logger.log(
+          renderConfigSummary(loadConfig(), {
+            path: getConfigPath(),
+            activeProvider: provider,
+            activeModel: _curModel || model,
+          }),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/config failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/doctor` — consolidated session-health readout (Claude-Code parity):
+    // provider/key/IDE/MCP/permissions/hooks in one pass-or-warn view.
+    if (trimmed === "/doctor" || trimmed === "/doctor ") {
+      let config = {};
+      try {
+        config = (await import("../lib/config-manager.js")).loadConfig() || {};
+      } catch (_err) {
+        // config read is best-effort; checks degrade gracefully
+      }
+      const { buildDoctorChecks, renderDoctor } =
+        await import("./doctor-status.js");
+      const { ideToolNames } = await import("./ide-status.js");
+      const checks = buildDoctorChecks({
+        config,
+        ideTools: ideToolNames(_adhocMcp),
+        mcpServers: _adhocMcp?.connected,
+        permissionRules: _permissionRules,
+        settingsHooks: _settingsHooks,
+      });
+      logger.log(renderDoctor(checks));
+      prompt();
+      return;
+    }
+
+    // `/export [path]` — dump the live conversation to a Markdown transcript
+    // (Claude-Code parity). Distinct from `cc export` (knowledge base). Captures
+    // exactly what's in context now, persisted or not.
+    if (trimmed === "/export" || trimmed.startsWith("/export ")) {
+      const arg = trimmed.slice("/export".length).trim();
+      try {
+        const { renderConversationMarkdown, defaultExportFilename } =
+          await import("./conversation-export.js");
+        const fs = await import("fs");
+        const path = await import("path");
+        const md = renderConversationMarkdown(messages, {
+          provider,
+          model: _curModel || model,
+          sessionId,
+          exportedAt: new Date().toISOString(),
+        });
+        const file = arg
+          ? path.resolve(process.cwd(), arg)
+          : path.resolve(process.cwd(), defaultExportFilename(new Date()));
+        fs.writeFileSync(file, md, "utf-8");
+        logger.log(
+          chalk.green(`Exported ${messages.length} messages → ${file}`),
+        );
+      } catch (err) {
+        logger.error(chalk.red(`/export failed: ${err.message}`));
+      }
+      prompt();
+      return;
+    }
+
+    // `/permissions` — allow/ask/deny rules in effect this session (Claude-Code
+    // parity): what the agent runs unprompted, asks about, or is blocked from.
+    if (trimmed === "/permissions" || trimmed === "/permissions ") {
+      let files = [];
+      try {
+        const { loadSettings } = await import("../lib/settings-loader.cjs");
+        files = loadSettings({ cwd: process.cwd() }).files || [];
+      } catch (_err) {
+        // source listing is best-effort — still show the live rules
+      }
+      const { renderPermissions } = await import("./permissions-status.js");
+      logger.log(renderPermissions(_permissionRules, { files }));
+      prompt();
+      return;
+    }
+
+    // `/cost` — running token spend + estimated $ for this session (Claude-Code
+    // parity). In-memory accumulation, so it works without session persistence.
+    if (trimmed === "/cost" || trimmed === "/cost ") {
+      let overrides;
+      try {
+        const { loadConfig } = await import("../lib/config-manager.js");
+        overrides = loadConfig()?.llm?.pricing;
+      } catch (_err) {
+        // pricing overrides are optional — fall back to the built-in table
+      }
+      const { renderSessionCost } = await import("./session-cost.js");
+      logger.log(
+        renderSessionCost(_costStore, { pricingOverrides: overrides }),
+      );
+      prompt();
+      return;
+    }
+
+    // `/ide` — IDE bridge connection status (Claude-Code parity): which editor
+    // is connected, its tools, or why discovery came up empty.
+    if (trimmed === "/ide" || trimmed === "/ide ") {
+      let diag = null;
+      try {
+        const { diagnoseIde } = await import("../lib/ide-bridge.js");
+        diag = diagnoseIde({ cwd: process.cwd(), env: process.env });
+      } catch (_err) {
+        // discovery is best-effort — fall back to in-session tools only
+      }
+      const { renderIdeStatus } = await import("./ide-status.js");
+      logger.log(renderIdeStatus(_adhocMcp, diag));
+      prompt();
+      return;
+    }
+
     // User-defined slash-command macros (.claude/commands/*.md), Claude-Code
     // parity. resolveSlashMacro maps a leading /name to a command macro and
     // expands its template; a non-match returns the line unchanged so a literal
@@ -2201,9 +2425,17 @@ export async function startAgentRepl(options = {}) {
     // Ephemeral: persistence stores effectivePrompt, not this snapshot.
     // Best-effort; CC_IDE_CONTEXT=0 disables.
     try {
-      const { buildIdePromptContext } = await import("../lib/ide-context.js");
+      const { buildIdePromptContext, expandIdeMentions } =
+        await import("../lib/ide-context.js");
       const ideCtx = await buildIdePromptContext(_adhocMcp);
       if (ideCtx) userContent += `\n\n${ideCtx}`;
+      // Explicit @selection / @diagnostics mentions (Claude-Code parity);
+      // scan the user's original prompt, append the expansion ephemerally.
+      const mentioned = await expandIdeMentions(effectivePrompt, _adhocMcp);
+      for (const w of mentioned.warnings) {
+        logger.info(chalk.yellow(`[@ide] ${w}`));
+      }
+      if (mentioned.block) userContent += `\n\n${mentioned.block}`;
     } catch (_err) {
       // optional polish — never fail the turn over it
     }
@@ -2305,6 +2537,9 @@ export async function startAgentRepl(options = {}) {
       });
       _turnAbort = null;
 
+      // Running spend for `/cost` (in-memory, works without persistence).
+      if (usageEvents?.length) addUsage(_costStore, usageEvents);
+
       if (sessionId && usageEvents?.length) {
         for (const ue of usageEvents) {
           try {
@@ -2433,9 +2668,7 @@ export async function startAgentRepl(options = {}) {
       // Esc interrupt: an aborted turn is normal flow, not an error — the
       // partial conversation stays usable and queued lines still drain.
       if (err?.name === "AbortError" || /abort/i.test(err?.message || "")) {
-        logger.log(
-          chalk.yellow("⎋ turn interrupted — partial progress kept"),
-        );
+        logger.log(chalk.yellow("⎋ turn interrupted — partial progress kept"));
         prompt();
         return;
       }

package/src/repl/config-summary.js

@@ -0,0 +1,59 @@
+/**
+ * `/config` REPL command (Claude-Code parity) — show the effective
+ * configuration in a readable, SECRET-SAFE form: the LLM provider/model/baseURL
+ * actually in effect, whether an API key is set (never the key itself), the
+ * web-search backend, and the config-file path. Also surfaces the session's
+ * active provider/model, which can differ from the file (a --provider flag or
+ * .claude/settings.json overrides it).
+ *
+ * Pure: takes the loaded config + context, returns plain text. The REPL does
+ * the I/O. NEVER prints a secret — only "set (…1234)" / "not set".
+ */
+
+/** Mask a secret: presence + last 4 chars only, or "not set". */
+export function maskSecret(v) {
+  if (v == null || v === "") return "not set";
+  const s = String(v);
+  return s.length <= 4 ? "set (hidden)" : `set (…${s.slice(-4)})`;
+}
+
+/**
+ * @param {object|null} config  loaded config.json
+ * @param {object} [opts]  { path, activeProvider, activeModel }
+ * @returns {string}
+ */
+export function renderConfigSummary(config, opts = {}) {
+  const cfg = config || {};
+  const llm = cfg.llm || {};
+  const lines = ["Effective configuration:"];
+  if (opts.path) lines.push(`  config file: ${opts.path}`);
+
+  lines.push("  llm:");
+  lines.push(`    provider: ${llm.provider || "(unset → defaults to ollama)"}`);
+  lines.push(`    model:    ${llm.model || "(unset)"}`);
+  if (llm.visionModel) lines.push(`    vision:   ${llm.visionModel}`);
+  if (llm.baseUrl) lines.push(`    baseUrl:  ${llm.baseUrl}`);
+  lines.push(`    apiKey:   ${maskSecret(llm.apiKey)}`);
+
+  const ws = cfg.webSearch || {};
+  if (ws.provider || ws.apiKey) {
+    lines.push("  webSearch:");
+    lines.push(`    provider: ${ws.provider || "(unset → auto)"}`);
+    lines.push(`    apiKey:   ${maskSecret(ws.apiKey)}`);
+  }
+
+  if (opts.activeProvider || opts.activeModel) {
+    const ap = opts.activeProvider || "?";
+    const am = opts.activeModel || "?";
+    const differs = !!llm.provider && (ap !== llm.provider || am !== llm.model);
+    lines.push(
+      `  active this session: ${ap} · ${am}` +
+        (differs ? "  (overrides config)" : ""),
+    );
+  }
+
+  lines.push(
+    "  note: keys are hidden; env vars (e.g. *_API_KEY) can override config at runtime.",
+  );
+  return lines.join("\n");
+}

package/src/repl/conversation-export.js

@@ -0,0 +1,133 @@
+/**
+ * `/export` REPL command — dump the LIVE in-memory conversation to a Markdown
+ * transcript (Claude-Code parity). Distinct from `cc export` (knowledge-base
+ * export) and from `cc session export` (which reads the persisted JSONL store):
+ * this renders the agent REPL's working `messages` array, so it captures
+ * exactly what's in context right now, persisted or not.
+ *
+ * Pure over the OpenAI-shaped message list the agent loop maintains:
+ *   {role:"user"|"assistant"|"system", content}              content: string | parts[]
+ *   {role:"assistant", content, tool_calls:[{function:{name,arguments}}]}
+ *   {role:"tool", content, tool_call_id}
+ * The REPL does the file I/O; this only produces text + a default filename.
+ */
+
+export const TOOL_BLOCK_CAP = 4000;
+
+/** Render message content (string, or OpenAI multimodal parts[]) as text. */
+function contentToText(content) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (!part || typeof part !== "object") return "";
+        if (part.type === "text" || typeof part.text === "string") {
+          return part.text || "";
+        }
+        if (part.type === "image_url" || part.image_url) return "[image]";
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n");
+  }
+  try {
+    return JSON.stringify(content, null, 2);
+  } catch {
+    return String(content);
+  }
+}
+
+function fence(body, lang = "") {
+  const text =
+    typeof body === "string"
+      ? body
+      : (() => {
+          try {
+            return JSON.stringify(body, null, 2);
+          } catch {
+            return String(body);
+          }
+        })();
+  const capped =
+    text.length > TOOL_BLOCK_CAP
+      ? `${text.slice(0, TOOL_BLOCK_CAP)}\n… [truncated]`
+      : text;
+  const guard = capped.includes("```") ? "````" : "```";
+  return `${guard}${lang}\n${capped}\n${guard}`;
+}
+
+/** Pretty-print a tool_call's JSON-string arguments, falling back to raw. */
+function prettyArgs(argStr) {
+  if (typeof argStr !== "string") return fence(argStr, "json");
+  try {
+    return fence(JSON.parse(argStr), "json");
+  } catch {
+    return fence(argStr);
+  }
+}
+
+const two = (n) => String(n).padStart(2, "0");
+
+/**
+ * A timestamped default filename, e.g. chainlesschain-export-20260613-130600.md.
+ * Takes a Date so callers/tests stay deterministic.
+ */
+export function defaultExportFilename(date = new Date()) {
+  const d = date instanceof Date && !isNaN(date) ? date : new Date(0);
+  const stamp =
+    `${d.getFullYear()}${two(d.getMonth() + 1)}${two(d.getDate())}` +
+    `-${two(d.getHours())}${two(d.getMinutes())}${two(d.getSeconds())}`;
+  return `chainlesschain-export-${stamp}.md`;
+}
+
+/**
+ * Render the conversation as Markdown.
+ * @param {Array} messages  the REPL's working message list
+ * @param {object} [meta]   { provider, model, sessionId, exportedAt }
+ * @returns {string}
+ */
+export function renderConversationMarkdown(messages, meta = {}) {
+  const msgs = Array.isArray(messages) ? messages : [];
+  const L = ["# ChainlessChain Conversation Export", ""];
+  const bits = [];
+  if (meta.sessionId) bits.push(`session: ${meta.sessionId}`);
+  if (meta.provider) bits.push(`provider: ${meta.provider}`);
+  if (meta.model) bits.push(`model: ${meta.model}`);
+  if (meta.exportedAt) bits.push(`exported: ${meta.exportedAt}`);
+  if (bits.length) {
+    L.push(`> ${bits.join(" · ")}`, "");
+  }
+
+  let users = 0;
+  let assistants = 0;
+  for (const m of msgs) {
+    if (!m || typeof m !== "object") continue;
+    const role = m.role;
+    if (role === "user") {
+      users += 1;
+      L.push("## 👤 User", "", contentToText(m.content), "");
+    } else if (role === "assistant") {
+      const text = contentToText(m.content);
+      if (text) {
+        assistants += 1;
+        L.push("## 🤖 Assistant", "", text, "");
+      }
+      if (Array.isArray(m.tool_calls)) {
+        for (const tc of m.tool_calls) {
+          const name = tc?.function?.name || tc?.name || "?";
+          L.push(`**🔧 tool_call — \`${name}\`**`, "");
+          L.push(prettyArgs(tc?.function?.arguments ?? tc?.arguments), "");
+        }
+      }
+    } else if (role === "tool") {
+      L.push("**↩ tool_result**", "", fence(contentToText(m.content)), "");
+    } else if (role === "system") {
+      L.push("## ⚙ System", "", contentToText(m.content), "");
+    }
+  }
+
+  L.push("---", `_${users} user / ${assistants} assistant turns_`, "");
+  return L.join("\n");
+}