@ridit/lens 0.3.6 → 0.3.8

package/src/components/chat/hooks/useCommandHandlers.ts

@@ -66,10 +66,6 @@ function makeMsg(content: string): Message {
   return { role: "assistant", content, type: "text" };
 }
 
-/**
- * Returns true if the command was handled, false if it should fall through
- * to the normal message flow.
- */
 export function handleCommand(text: string, ctx: CommandContext): boolean {
   const t = text.trim().toLowerCase();
 

package/src/components/repo/RepoAnalysis.tsx

@@ -105,7 +105,7 @@ function AskingFilesStep() {
   return (
     <Box gap={1}>
       <Text color={ACCENT}>
-        <Spinner />
+        <Spinner type="moon" />
       </Text>
       <Text color={ACCENT}>{phrase}</Text>
     </Box>
@@ -117,7 +117,7 @@ function AnalyzingStep() {
   return (
     <Box gap={1}>
       <Text color={ACCENT}>
-        <Spinner />
+        <Spinner type="earth" />
       </Text>
       <Text color={ACCENT}>{phrase}</Text>
     </Box>
@@ -174,11 +174,11 @@ function CodebaseQA({
     abortRef.current = abort;
 
     callChat(provider, systemPrompt, nextAll, abort.signal)
-      .then((answer) => {
+      .then((result) => {
         const assistantMsg: Message = {
           role: "assistant",
           type: "text",
-          content: answer,
+          content: result.text,
         };
         setCommitted((prev) => [...prev, assistantMsg]);
         setAllMessages([...nextAll, assistantMsg]);
@@ -366,7 +366,7 @@ export const RepoAnalysis = ({
     return (
       <Box marginTop={1}>
         <Text color={ACCENT}>
-          <Spinner />
+          <Spinner type="arc" />
         </Text>
         <Box marginLeft={1}>
           <Text>Writing file...</Text>

package/src/components/task/TaskRunner.tsx

@@ -88,7 +88,7 @@ function ThinkingAboutStep({ prompt }: { prompt: string }) {
   return (
     <Box gap={1}>
       <Text color={ACCENT}>
-        <Spinner />
+        <Spinner type="triangle" />
       </Text>
       <Text color={ACCENT}>{phrase}</Text>
       <Text color="gray">"{prompt}"</Text>
@@ -270,7 +270,7 @@ export const PromptRunner = ({
     return (
       <Box marginTop={1} gap={1}>
         <Text color={ACCENT}>
-          <Spinner />
+          <Spinner type="dots2" />
         </Text>
         <Text>Reading codebase...</Text>
       </Box>
@@ -322,7 +322,7 @@ export const PromptRunner = ({
     return (
       <Box marginTop={1} gap={1}>
         <Text color={ACCENT}>
-          <Spinner />
+          <Spinner type="bouncingBar" />
         </Text>
         <Text>Applying changes...</Text>
       </Box>

package/src/components/timeline/TimelineRunner.tsx

@@ -777,9 +777,9 @@ ${summarizeTimeline(commits)}`;
 
   const runChat = async (history: Message[], signal: AbortSignal) => {
     try {
-      const raw = await callChat(provider, systemPrompt, history, signal);
+      const result = await callChat(provider, systemPrompt, history, signal);
       if (signal.aborted) return;
-      processResponse(raw, history, signal);
+      processResponse(result.text, history, signal);
     } catch (e: any) {
       if (e?.name === "AbortError") return;
       setMessages((prev) => [

package/src/components/watch/RunRunner.tsx

@@ -602,12 +602,13 @@ ${lensFile.suggestions.length > 0 ? `\nProject suggestions:\n${lensFile.suggesti
 
       let raw: string;
       try {
-        raw = await callChat(
+        const result = await callChat(
           provider,
           systemPromptRef.current,
           messages,
           combinedSignal,
         );
+        raw = result.text;
       } finally {
         clearTimeout(timeoutId);
       }

package/src/index.tsx

@@ -16,6 +16,11 @@ import { loadAddons } from "./utils/addons/loadAddons";
 registerBuiltins();
 await loadAddons();
 
+if (process.stdout.isTTY) {
+  process.stdout.write("\x1b[>4;1m");
+  process.on("exit", () => process.stdout.write("\x1b[>4;0m"));
+}
+
 const program = new Command();
 
 program
@@ -51,8 +56,14 @@ program
   .command("chat")
   .description("Chat with your codebase — ask questions or make changes")
   .option("-p, --path <path>", "Path to the repo", ".")
-  .action((opts: { path: string }) => {
-    render(<ChatCommand path={opts.path} />);
+  .option(
+    "--auto-force",
+    "Start with force-all mode enabled (auto-approves all tools)",
+  )
+  .action((opts: { path: string; autoForce: boolean }) => {
+    render(
+      <ChatCommand path={opts.path} autoForce={opts.autoForce ?? false} />,
+    );
   });
 
 program

package/src/prompts/fewshot.ts

@@ -231,4 +231,22 @@ export const FEW_SHOT_MESSAGES: { role: string; content: string }[] = [
     content:
       "Done — addons/hello-world.js created using defineTool from @ridit/lens-sdk.",
   },
+  {
+    role: "user",
+    content: "I ran the app and got this error:\n[ERROR] slice(None, 2, None)",
+  },
+  {
+    role: "assistant",
+    content: "<read-file>webfetch/parser.py</read-file>",
+  },
+  {
+    role: "user",
+    content:
+      "Here is the output from read-file of webfetch/parser.py:\n\n# file content here\n\nPlease continue your response based on this output.",
+  },
+  {
+    role: "assistant",
+    content:
+      '<write-file>\n{"path": "webfetch/parser.py", "content": "...complete fixed content..."}\n</write-file>',
+  },
 ];

package/src/prompts/system.ts

@@ -21,34 +21,47 @@ ${tools}
 You can save and delete memories at any time by emitting these tags alongside your normal response.
 They are stripped before display — the user will not see the raw tags.
  
-### memory-add — save something important to long-term memory for this repo
+### memory-add — save something important to long-term memory
 <memory-add>User prefers TypeScript strict mode in all new files</memory-add>
  
+Use [global] prefix for things that apply across ALL repos (user preferences, name, coding style):
+<memory-add>[global] User prefers bun over npm for all projects</memory-add>
+ 
+Omit [global] for repo-specific memories (architecture decisions, patterns, agreed conventions):
+<memory-add>This repo uses path aliases defined in tsconfig.json</memory-add>
+ 
 ### memory-delete — delete a memory by its ID (shown in brackets like [abc123])
 <memory-delete>abc123</memory-delete>
  
-Use memory-add when the user asks you to remember something, or when you learn something project-specific that would be useful in future sessions.
+Use memory-add ONLY for information that cannot be inferred by reading the codebase:
+- User preferences and coding conventions
+- Decisions made during the session (e.g. "user chose bun over npm")
+- Things the user explicitly asked you to remember
+- Cross-session context that would otherwise be lost
+ 
+NEVER save memories that just describe what files exist or what the project does — that can be read directly from the codebase.
 Use memory-delete when the user asks you to forget something or a memory is outdated.
  
 ## RULES
  
 1. ONE tool per response — emit the XML tag, then stop. Never chain tools in one response except when scaffolding (see below).
 2. NEVER call a tool more than once for the same path in a session. If write-file or shell returned a result, it succeeded. Move on immediately.
-3. NEVER write the same file twice in one session. One write per file, period. If you already wrote it, it is done.
-4. shell is ONLY for running code, installing packages, building, and testing. NEVER use shell to inspect the filesystem or read files — use read-file, read-folder, or grep instead.
-5. write-file content must be the COMPLETE file content, never a placeholder or partial.
-6. NEVER read a file you just wrote. The write output confirms success.
-7. NEVER apologize and redo a tool call — one attempt is enough, trust the output.
-8. NEVER use shell to run git clone — use the clone tag instead.
-9. When the user asks you to CREATE a new file, write it immediately — do NOT read first.
-10. When the user asks you to MODIFY or FIX an existing file, read it first, then write the complete updated version ONCE.
-11. When fixing multiple files, use read-files to read ALL of them first, then write each one ONCE sequentially — never rewrite a file already written this session.
-12. If a read-folder or read-file returns not found, accept it and move on — do NOT retry the same path.
-13. Every shell command runs from the repo root — cd has no persistent effect. Use full paths or combine with && e.g. cd myapp && bun run index.ts
-14. write-file paths are relative to the repo root — use full relative paths e.g. myapp/src/index.tsx not src/index.tsx
-15. When explaining how to use a tool in text, use [tag] bracket notation — NEVER emit a real XML tool tag as part of an explanation.
-16. NEVER use markdown formatting in plain text responses — no bold, no headings, no bullet points. Only use fenced code blocks when showing actual code.
-17. When scaffolding multiple files, emit ONE write-file tag per response and wait for the result before writing the next file.
+3. shell is ONLY for running code, installing packages, building, and testing. NEVER use shell to inspect the filesystem or read files — use read-file, read-folder, or grep instead.
+4. NEVER use shell to run git clone — use the clone tag instead.
+5. NEVER read a file you just wrote. The write output confirms success.
+6. NEVER apologize and redo a tool call — one attempt is enough, trust the output.
+7. When the user asks you to CREATE a brand new file, use write-file immediately — do NOT read first. write-file content must be the COMPLETE file content.
+8. When the user asks you to MODIFY or FIX an existing file, read it first, then propose the edit using changes — NEVER use write-file on an existing file.
+9. When fixing multiple files, use read-files to read ALL of them first, then emit one changes tag with all patches together.
+10. If a read-folder or read-file returns not found, accept it and move on — do NOT retry the same path.
+11. Every shell command runs from the repo root — cd has no persistent effect. Use full paths or combine with && e.g. cd myapp && bun run index.ts
+12. write-file paths are relative to the repo root — use full relative paths e.g. myapp/src/index.tsx not src/index.tsx
+13. When explaining how to use a tool in text, use [tag] bracket notation — NEVER emit a real XML tool tag as part of an explanation.
+14. NEVER use markdown formatting in plain text responses — no bold, no headings, no bullet points. Only use fenced code blocks when showing actual code.
+15. When scaffolding multiple NEW files, emit ONE write-file per response and wait for the result before writing the next file.
+16. When you identify a bug or error, ALWAYS propose the fix immediately using changes. Never describe the fix without proposing it.
+17. NEVER use shell for filesystem inspection or searching — always use grep, read-file, or read-folder instead.
+18. changes patches must include the COMPLETE new file content for each path — never partial content.
  
 ## ADDON FORMAT
  

package/src/types/chat.ts

@@ -33,7 +33,8 @@ export type Message =
         | "delete-folder"
         | "open-url"
         | "generate-pdf"
-        | "search";
+        | "search"
+        | "changes";
       content: string;
       result: string;
       approved: boolean;
@@ -43,6 +44,7 @@ export type Message =
       type: "plan";
       content: string;
       patches: FilePatch[];
+      diffLines?: DiffLine[][];
       applied: boolean;
     };
 

package/src/utils/chat.ts

@@ -19,6 +19,11 @@ import { FEW_SHOT_MESSAGES } from "../prompts";
 import { registry } from "../utils/tools/registry";
 import type { FilePatch } from "../components/repo/DiffViewer";
 
+export type ChatResult = {
+  text: string;
+  truncated: boolean;
+};
+
 export type ParsedResponse =
   | { kind: "text"; content: string; remainder?: string }
   | {
@@ -190,12 +195,22 @@ export function toCloneUrl(url: string): string {
   return clean.endsWith(".git") ? clean : `${clean}.git`;
 }
 
+// Replace buildApiMessages in src/utils/chat.ts
+
 function buildApiMessages(
   messages: Message[],
 ): { role: string; content: string }[] {
   const recent = messages.slice(-MAX_HISTORY);
 
-  return recent.map((m) => {
+  const writtenFiles: string[] = [];
+  for (const m of recent) {
+    if (m.type === "tool" && m.toolName === "write-file" && m.approved) {
+      const pathMatch = m.content.match(/^(.+?)\s*\(/);
+      if (pathMatch?.[1]) writtenFiles.push(pathMatch[1]);
+    }
+  }
+
+  return recent.map((m, idx) => {
     if (m.type === "tool") {
       if (!m.approved) {
         return {
@@ -204,11 +219,39 @@ function buildApiMessages(
             "The tool call was denied by the user. Please respond without using that tool.",
         };
       }
+
+      if (m.toolName === "write-file") {
+        const remaining = writtenFiles.slice(
+          writtenFiles.indexOf(m.content.split(" (")[0]!) + 1,
+        );
+        const doneList = writtenFiles
+          .slice(0, writtenFiles.indexOf(m.content.split(" (")[0]!) + 1)
+          .map((f) => `- ${f}`)
+          .join("\n");
+
+        return {
+          role: "user",
+          content: [
+            `Tool result for write-file (${m.content}):`,
+            "",
+            m.result,
+            "",
+            `Files written so far:`,
+            doneList || `- ${m.content.split(" (")[0]}`,
+            "",
+            remaining.length > 0
+              ? `Continue with the NEXT file. Do NOT rewrite any file already written above.`
+              : `All files written. Summarize what was created.`,
+          ].join("\n"),
+        };
+      }
+
       return {
         role: "user",
-        content: `Here is the output from the ${m.toolName} of ${m.content}:\n\n${m.result}\n\nPlease continue your response based on this output.`,
+        content: `Tool result for ${m.toolName} (${m.content}):\n\n${m.result}\n\nPlease continue your response based on this output.`,
       };
     }
+
     return { role: m.role, content: m.content };
   });
 }
@@ -219,7 +262,7 @@ export async function callChat(
   messages: Message[],
   abortSignal?: AbortSignal,
   retries = 2,
-): Promise<string> {
+): Promise<ChatResult> {
   const apiMessages = [
     ...buildFewShotMessages(),
     ...buildApiMessages(messages),
@@ -257,7 +300,7 @@ export async function callChat(
   }
 
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 60_000);
+  const timer = setTimeout(() => controller.abort(), 180_000);
   abortSignal?.addEventListener("abort", () => controller.abort());
 
   try {
@@ -288,17 +331,39 @@ export async function callChat(
 
     if (provider.type === "anthropic") {
       const content = data.content as { type: string; text: string }[];
-      return content
+      const text = content
         .filter((b) => b.type === "text")
         .map((b) => b.text)
         .join("");
+      const truncated = (data as any).stop_reason === "max_tokens";
+      return { text, truncated };
     } else {
-      const choices = data.choices as { message: { content: string } }[];
-      return choices[0]?.message.content ?? "";
+      const choices = data.choices as {
+        message: { content: string };
+        finish_reason?: string;
+      }[];
+      const text = choices[0]?.message.content ?? "";
+      const truncated = choices[0]?.finish_reason === "length";
+      return { text, truncated };
     }
   } catch (err) {
     clearTimeout(timer);
-    if (err instanceof Error && err.name === "AbortError") throw err;
+    if (err instanceof Error && err.name === "AbortError") {
+      if (abortSignal?.aborted) throw err;
+      if (retries > 0) {
+        await new Promise((r) => setTimeout(r, 1500));
+        return callChat(
+          provider,
+          systemPrompt,
+          messages,
+          abortSignal,
+          retries - 1,
+        );
+      }
+      throw new Error(
+        "Request timed out. The model took too long to respond (>3 min).",
+      );
+    }
     if (retries > 0) {
       await new Promise((r) => setTimeout(r, 1500));
       return callChat(

package/src/utils/intentClassifier.ts

@@ -1,48 +1,33 @@
-/**
- * Classifies user message intent to scope which tools the LLM is allowed to use.
- *
- * readonly  → only read/search/fetch tools exposed (no write, delete, shell)
- * mutating  → all tools exposed
- * any       → all tools exposed (ambiguous / can't tell)
- */
 export type Intent = "readonly" | "mutating" | "any";
 
 const READONLY_PATTERNS: RegExp[] = [
-  // listing / exploring
   /\b(list|ls|dir|show|display|print|dump)\b/i,
   /\bwhat(('?s| is| are| does)\b| files| folder)/i,
   /\b(folder|directory|file) (structure|tree|layout|contents?)\b/i,
   /\bexplore\b/i,
 
-  // reading / explaining
   /\b(read|open|view|look at|check out|inspect|peek)\b/i,
   /\b(explain|describe|summarize|summarise|tell me about|walk me through)\b/i,
   /\bhow does\b/i,
   /\bwhat('?s| is) (in|inside|this|that|the)\b/i,
 
-  // searching
   /\b(find|search|grep|locate|where is|where are)\b/i,
   /\b(look for|scan|trace)\b/i,
 
-  // understanding
   /\bunderstand\b/i,
   /\bshow me (how|what|where|why)\b/i,
 ];
 
 const MUTATING_PATTERNS: RegExp[] = [
-  // writing
   /\b(write|create|make|generate|add|build|scaffold|init|initialize|setup|set up)\b/i,
   /\b(new file|new folder|new component|new page|new route)\b/i,
 
-  // editing
   /\b(edit|modify|update|change|refactor|rename|move|migrate)\b/i,
   /\b(fix|patch|resolve|correct|debug|repair)\b/i,
   /\b(implement|add .+ to|insert|inject|append|prepend)\b/i,
 
-  // deleting
   /\b(delete|remove|drop|clean ?up|purge|wipe)\b/i,
 
-  // running
   /\b(run|execute|install|deploy|build|test|start|launch|compile|lint|format)\b/i,
 ];
 

package/src/utils/memory.ts

@@ -15,16 +15,18 @@ export type MemoryEntry = {
   detail: string;
   summary: string;
   timestamp: string;
+  repoPath?: string;
 };
 
 export type Memory = {
   id: string;
   content: string;
   timestamp: string;
+  repoPath?: string;
+  scope: "repo" | "global";
 };
 
 export type MemoryFile = {
-  entries: MemoryEntry[];
   memories: Memory[];
 };
 
@@ -32,17 +34,14 @@ const LENS_DIR = path.join(os.homedir(), ".lens");
 const MEMORY_PATH = path.join(LENS_DIR, "memory.json");
 
 function loadMemoryFile(): MemoryFile {
-  if (!existsSync(MEMORY_PATH)) return { entries: [], memories: [] };
+  if (!existsSync(MEMORY_PATH)) return { memories: [] };
   try {
     const data = JSON.parse(
       readFileSync(MEMORY_PATH, "utf-8"),
     ) as Partial<MemoryFile>;
-    return {
-      entries: data.entries ?? [],
-      memories: data.memories ?? [],
-    };
+    return { memories: data.memories ?? [] };
   } catch {
-    return { entries: [], memories: [] };
+    return { memories: [] };
   }
 }
 
@@ -51,26 +50,48 @@ function saveMemoryFile(m: MemoryFile): void {
   writeFileSync(MEMORY_PATH, JSON.stringify(m, null, 2), "utf-8");
 }
 
-// ── Action entries (what the model has done) ──────────────────────────────────
+// ── Session-only action entries (in-memory, never written to disk) ────────────
 
-export function appendMemory(entry: Omit<MemoryEntry, "timestamp">): void {
-  const m = loadMemoryFile();
-  m.entries.push({ ...entry, timestamp: new Date().toISOString() });
-  if (m.entries.length > 500) m.entries = m.entries.slice(-500);
-  saveMemoryFile(m);
+const sessionEntries: MemoryEntry[] = [];
+
+export function appendMemory(
+  entry: Omit<MemoryEntry, "timestamp">,
+  repoPath?: string,
+): void {
+  sessionEntries.push({
+    ...entry,
+    repoPath,
+    timestamp: new Date().toISOString(),
+  });
+  if (sessionEntries.length > 200)
+    sessionEntries.splice(0, sessionEntries.length - 200);
 }
 
 export function buildMemorySummary(repoPath: string): string {
   const m = loadMemoryFile();
-  const relevant = m.entries.slice(-50);
 
-  const memories = m.memories;
+  const globalMemories = m.memories.filter((mem) => mem.scope === "global");
+  const repoMemories = m.memories.filter(
+    (mem) => mem.scope === "repo" && mem.repoPath === repoPath,
+  );
+
+  const relevant = sessionEntries
+    .filter((e) => !e.repoPath || e.repoPath === repoPath)
+    .slice(-50);
 
   const parts: string[] = [];
 
-  if (memories.length > 0) {
+  if (globalMemories.length > 0) {
+    parts.push(
+      `## GLOBAL MEMORIES (apply to all repos)\n\n${globalMemories
+        .map((mem) => `- [${mem.id}] ${mem.content}`)
+        .join("\n")}`,
+    );
+  }
+
+  if (repoMemories.length > 0) {
     parts.push(
-      `## MEMORIES ABOUT THIS REPO\n\n${memories
+      `## MEMORIES ABOUT THIS REPO\n\n${repoMemories
         .map((mem) => `- [${mem.id}] ${mem.content}`)
         .join("\n")}`,
     );
@@ -82,7 +103,7 @@ export function buildMemorySummary(repoPath: string): string {
       return `[${ts}] ${e.kind}: ${e.detail} — ${e.summary}`;
     });
     parts.push(
-      `## WHAT YOU HAVE ALREADY DONE IN THIS REPO\n\nThe following actions have already been completed. Do NOT repeat them unless the user explicitly asks you to redo something:\n\n${lines.join("\n")}`,
+      `## WHAT YOU HAVE ALREADY DONE THIS SESSION\n\nThe following actions have already been completed. Do NOT repeat them unless the user explicitly asks:\n\n${lines.join("\n")}`,
     );
   }
 
@@ -90,27 +111,42 @@ export function buildMemorySummary(repoPath: string): string {
 }
 
 export function getRepoMemory(repoPath: string): MemoryEntry[] {
-  return loadMemoryFile().entries;
+  return sessionEntries.filter((e) => !e.repoPath || e.repoPath === repoPath);
 }
 
 export function clearRepoMemory(repoPath: string): void {
+  // clear session entries for this repo
+  const toRemove = sessionEntries
+    .map((e, i) => (e.repoPath === repoPath ? i : -1))
+    .filter((i) => i >= 0)
+    .reverse();
+  for (const i of toRemove) sessionEntries.splice(i, 1);
+
+  // clear persisted memories for this repo (keep global)
   const m = loadMemoryFile();
-  m.entries = m.entries = [];
-  m.memories = m.memories = [];
+  m.memories = m.memories.filter(
+    (mem) => mem.scope === "global" || mem.repoPath !== repoPath,
+  );
   saveMemoryFile(m);
 }
 
-// ── User/model memories ───────────────────────────────────────────────────────
-
 function generateId(): string {
   return Math.random().toString(36).slice(2, 8);
 }
 
 export function addMemory(content: string, repoPath: string): Memory {
   const m = loadMemoryFile();
+
+  const isGlobal = content.startsWith("[global]");
+  const cleanContent = isGlobal
+    ? content.replace("[global]", "").trim()
+    : content;
+
   const memory: Memory = {
     id: generateId(),
-    content,
+    content: cleanContent,
+    repoPath: isGlobal ? undefined : repoPath,
+    scope: isGlobal ? "global" : "repo",
     timestamp: new Date().toISOString(),
   };
   m.memories.push(memory);
@@ -121,12 +157,53 @@ export function addMemory(content: string, repoPath: string): Memory {
 export function deleteMemory(id: string, repoPath: string): boolean {
   const m = loadMemoryFile();
   const before = m.memories.length;
-  m.memories = m.memories.filter((mem) => !(mem.id === id));
+  m.memories = m.memories.filter((mem) => mem.id !== id);
   if (m.memories.length === before) return false;
   saveMemoryFile(m);
   return true;
 }
 
 export function listMemories(repoPath: string): Memory[] {
-  return loadMemoryFile().memories;
+  return loadMemoryFile().memories.filter(
+    (mem) => mem.scope === "global" || mem.repoPath === repoPath,
+  );
+}
+
+type SessionToolLog = {
+  toolName: string;
+  input: string;
+  resultPreview: string;
+  timestamp: string;
+};
+
+const sessionToolLog: SessionToolLog[] = [];
+
+export function logToolCall(
+  toolName: string,
+  input: string,
+  result: string,
+  repoPath?: string,
+): void {
+  sessionToolLog.push({
+    toolName,
+    input,
+    resultPreview: result.slice(0, 120),
+    timestamp: new Date().toISOString(),
+  });
+  if (sessionToolLog.length > 100)
+    sessionToolLog.splice(0, sessionToolLog.length - 100);
+}
+
+export function getSessionToolSummary(repoPath: string): string {
+  if (sessionToolLog.length === 0) return "";
+  const recent = sessionToolLog.slice(-30);
+  const lines = recent.map((e) => {
+    const input = e.input.length > 60 ? e.input.slice(0, 60) + "…" : e.input;
+    return `- ${e.toolName}: ${input}`;
+  });
+  return `## TOOLS ALREADY USED THIS SESSION\n\nDo NOT call these again unless the user explicitly asks:\n\n${lines.join("\n")}`;
+}
+
+export function clearSessionLog(): void {
+  sessionToolLog.splice(0, sessionToolLog.length);
 }