@ridit/lens 0.3.6 → 0.3.8

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

@@ -13,6 +13,8 @@ import {
   buildMemorySummary,
   addMemory,
   deleteMemory,
+  getSessionToolSummary,
+  logToolCall,
 } from "../../../utils/memory";
 import { fetchFileTree, readImportantFiles } from "../../../utils/files";
 import { readLensFile } from "../../../utils/lensfile";
@@ -26,9 +28,19 @@ import {
   buildSystemPrompt,
   parseResponse,
   callChat,
+  type ChatResult,
 } from "../../../utils/chat";
 
-export function useChat(repoPath: string) {
+function hasUnclosedToolTag(text: string): boolean {
+  for (const tag of registry.names()) {
+    if (text.includes(`<${tag}>`) && !text.includes(`</${tag}>`)) return true;
+  }
+  const fences = text.match(/```/g);
+  if (fences && fences.length % 2 !== 0) return true;
+  return false;
+}
+
+export function useChat(repoPath: string, autoForce = false) {
   const [stage, setStage] = useState<ChatStage>({ type: "picking-provider" });
   const [committed, setCommitted] = useState<Message[]>([]);
   const [provider, setProvider] = useState<Provider | null>(null);
@@ -38,8 +50,8 @@ export function useChat(repoPath: string) {
   const [clonedUrls, setClonedUrls] = useState<Set<string>>(new Set());
   const [showTimeline, setShowTimeline] = useState(false);
   const [showReview, setShowReview] = useState(false);
-  const [autoApprove, setAutoApprove] = useState(false);
-  const [forceApprove, setForceApprove] = useState(false);
+  const [autoApprove, setAutoApprove] = useState(autoForce);
+  const [forceApprove, setForceApprove] = useState(autoForce);
   const [showForceWarning, setShowForceWarning] = useState(false);
   const [chatName, setChatName] = useState<string | null>(null);
   const [recentChats, setRecentChats] = useState<string[]>([]);
@@ -50,6 +62,7 @@ export function useChat(repoPath: string) {
   const abortControllerRef = useRef<AbortController | null>(null);
   const toolResultCache = useRef<Map<string, string>>(new Map());
   const batchApprovedRef = useRef(false);
+  const forceApproveRef = useRef(autoForce);
 
   const updateChatName = (name: string) => {
     chatNameRef.current = name;
@@ -62,6 +75,9 @@ export function useChat(repoPath: string) {
   React.useEffect(() => {
     systemPromptRef.current = systemPrompt;
   }, [systemPrompt]);
+  React.useEffect(() => {
+    forceApproveRef.current = forceApprove;
+  }, [forceApprove]);
 
   React.useEffect(() => {
     const chats = listChats(repoPath);
@@ -74,6 +90,13 @@ export function useChat(repoPath: string) {
     }
   }, [allMessages]);
 
+  const pushMsg = (msg: Message, currentAll: Message[]): Message[] => {
+    const next = [...currentAll, msg];
+    setAllMessages(next);
+    setCommitted((prev) => [...prev, msg]);
+    return next;
+  };
+
   const handleError = (currentAll: Message[]) => (err: unknown) => {
     batchApprovedRef.current = false;
     if (err instanceof Error && err.name === "AbortError") {
@@ -85,130 +108,156 @@ export function useChat(repoPath: string) {
       content: `Error: ${err instanceof Error ? err.message : "Something went wrong"}`,
       type: "text",
     };
-    setAllMessages([...currentAll, errMsg]);
-    setCommitted((prev) => [...prev, errMsg]);
+    pushMsg(errMsg, currentAll);
     setStage({ type: "idle" });
   };
 
-  const TOOL_TAG_NAMES = [
-    "shell",
-    "fetch",
-    "read-file",
-    "read-folder",
-    "grep",
-    "write-file",
-    "delete-file",
-    "delete-folder",
-    "open-url",
-    "generate-pdf",
-    "search",
-    "clone",
-    "changes",
-  ];
-
-  function isLikelyTruncated(text: string): boolean {
-    return TOOL_TAG_NAMES.some(
-      (tag) => text.includes(`<${tag}>`) && !text.includes(`</${tag}>`),
-    );
-  }
+  const callNext = async (
+    messages: Message[],
+    signal: AbortSignal,
+    maxRetries = 3,
+  ): Promise<ChatResult> => {
+    const currentProvider = providerRef.current;
+    const currentSystemPrompt = systemPromptRef.current;
+
+    if (!currentProvider || signal.aborted)
+      return { text: "", truncated: false };
+
+    let currentMessages = messages;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (signal.aborted) return { text: "", truncated: false };
+
+      const result = await callChat(
+        currentProvider,
+        currentSystemPrompt,
+        currentMessages,
+        signal,
+      );
+
+      if (result.text.trim()) return result;
 
-  const processResponse = (
+      if (attempt < maxRetries) {
+        const nudge: Message = {
+          role: "assistant",
+          content: `(model stalled — retrying ${attempt + 1}/${maxRetries})`,
+          type: "text",
+        };
+        setCommitted((prev) => [...prev, nudge]);
+        currentMessages = [
+          ...currentMessages,
+          {
+            role: "user",
+            content: "Please continue your response.",
+            type: "text",
+          },
+        ];
+      }
+    }
+
+    return { text: "", truncated: false };
+  };
+
+  const MAX_CONTINUATIONS = 3;
+
+  const handleTruncation = async (
     raw: string,
     currentAll: Message[],
     signal: AbortSignal,
-  ) => {
-    if (signal.aborted) {
-      batchApprovedRef.current = false;
-      setStage({ type: "idle" });
-      return;
-    }
+    depth: number,
+  ): Promise<{ text: string; messages: Message[] } | null> => {
+    if (depth >= MAX_CONTINUATIONS) return null;
 
-    if (isLikelyTruncated(raw)) {
-      const truncMsg: Message = {
-        role: "assistant",
-        content:
-          "(response cut off — the model hit its output limit mid-tool-call. Try asking it to continue, or simplify the request.)",
-        type: "text",
-      };
-      setAllMessages([...currentAll, truncMsg]);
-      setCommitted((prev) => [...prev, truncMsg]);
-      setStage({ type: "idle" });
-      return;
-    }
+    const truncNotice: Message = {
+      role: "assistant",
+      content: `(response cut off — continuing ${depth + 1}/${MAX_CONTINUATIONS}…)`,
+      type: "text",
+    };
+    setCommitted((prev) => [...prev, truncNotice]);
+
+    const partialMsg: Message = {
+      role: "assistant",
+      content: raw,
+      type: "text",
+    };
+    const nudgeMsg: Message = {
+      role: "user",
+      content:
+        "Your response was cut off. Please continue exactly from where you left off.",
+      type: "text",
+    };
+    const withContext = [...currentAll, partialMsg, nudgeMsg];
+
+    const result = await callNext(withContext, signal);
+    return { text: result.text ?? "", messages: withContext };
+  };
 
-    const memAddMatches = [
+  const processMemoryTags = (raw: string): string => {
+    const addMatches = [
       ...raw.matchAll(/<memory-add>([\s\S]*?)<\/memory-add>/g),
     ];
-    const memDelMatches = [
+    const delMatches = [
       ...raw.matchAll(/<memory-delete>([\s\S]*?)<\/memory-delete>/g),
     ];
-    for (const match of memAddMatches) {
-      const content = match[1]!.trim();
+    for (const m of addMatches) {
+      const content = m[1]!.trim();
       if (content) addMemory(content, repoPath);
     }
-    for (const match of memDelMatches) {
-      const id = match[1]!.trim();
+    for (const m of delMatches) {
+      const id = m[1]!.trim();
       if (id) deleteMemory(id, repoPath);
     }
-    const cleanRaw = raw
+    return raw
       .replace(/<memory-add>[\s\S]*?<\/memory-add>/g, "")
       .replace(/<memory-delete>[\s\S]*?<\/memory-delete>/g, "")
       .trim();
+  };
 
-    const parsed = parseResponse(cleanRaw);
-
-    if (parsed.kind === "changes") {
+  const processResponse = async (
+    raw: string,
+    currentAll: Message[],
+    signal: AbortSignal,
+    truncated = false,
+    continuationDepth = 0,
+  ): Promise<void> => {
+    if (signal.aborted) {
       batchApprovedRef.current = false;
-      if (parsed.patches.length === 0) {
+      setStage({ type: "idle" });
+      return;
+    }
+
+    if (truncated || hasUnclosedToolTag(raw)) {
+      const cont = await handleTruncation(
+        raw,
+        currentAll,
+        signal,
+        continuationDepth,
+      );
+      if (!cont) {
+        batchApprovedRef.current = false;
         const msg: Message = {
           role: "assistant",
-          content: parsed.content,
+          content:
+            raw.trim() ||
+            "(response was empty after multiple continuation attempts)",
           type: "text",
         };
-        setAllMessages([...currentAll, msg]);
-        setCommitted((prev) => [...prev, msg]);
+        pushMsg(msg, currentAll);
         setStage({ type: "idle" });
         return;
       }
-      const assistantMsg: Message = {
-        role: "assistant",
-        content: parsed.content,
-        type: "plan",
-        patches: parsed.patches,
-        applied: false,
-      };
-      const withAssistant = [...currentAll, assistantMsg];
-      setAllMessages(withAssistant);
-      setPendingMsgIndex(withAssistant.length - 1);
-      const diffLines = buildDiffs(repoPath, parsed.patches);
-      setStage({
-        type: "preview",
-        patches: parsed.patches,
-        diffLines,
-        scrollOffset: 0,
-        pendingMessages: currentAll,
-      });
-      return;
+      return processResponse(
+        cont.text,
+        cont.messages,
+        signal,
+        false,
+        continuationDepth + 1,
+      );
     }
 
-    if (parsed.kind === "clone") {
-      batchApprovedRef.current = false;
-      if (parsed.content) {
-        const preambleMsg: Message = {
-          role: "assistant",
-          content: parsed.content,
-          type: "text",
-        };
-        setAllMessages([...currentAll, preambleMsg]);
-        setCommitted((prev) => [...prev, preambleMsg]);
-      }
-      setStage({
-        type: "clone-offer",
-        repoUrl: parsed.repoUrl,
-        launchAnalysis: true,
-      });
-      return;
-    }
+    const cleanRaw = processMemoryTags(raw);
+
+    const parsed = parseResponse(cleanRaw);
 
     if (parsed.kind === "text") {
       batchApprovedRef.current = false;
@@ -217,11 +266,10 @@ export function useChat(repoPath: string) {
         const stallMsg: Message = {
           role: "assistant",
           content:
-            '(no response — the model may have stalled. Try sending a short follow-up like "continue" or start a new message.)',
+            '(no response — try sending "continue" or start a new message)',
           type: "text",
         };
-        setAllMessages([...currentAll, stallMsg]);
-        setCommitted((prev) => [...prev, stallMsg]);
+        pushMsg(stallMsg, currentAll);
         setStage({ type: "idle" });
         return;
       }
@@ -231,9 +279,8 @@ export function useChat(repoPath: string) {
         content: parsed.content,
         type: "text",
       };
-      const withMsg = [...currentAll, msg];
-      setAllMessages(withMsg);
-      setCommitted((prev) => [...prev, msg]);
+      const withMsg = pushMsg(msg, currentAll);
+
       const lastUserMsg = [...currentAll]
         .reverse()
         .find((m) => m.role === "user");
@@ -251,149 +298,276 @@ export function useChat(repoPath: string) {
       return;
     }
 
-    const tool = registry.get(parsed.toolName);
-    if (!tool) {
+    if (parsed.kind === "changes") {
       batchApprovedRef.current = false;
-      setStage({ type: "idle" });
-      return;
-    }
 
-    if (parsed.content) {
-      const preambleMsg: Message = {
+      if (parsed.patches.length === 0) {
+        const msg: Message = {
+          role: "assistant",
+          content: parsed.content,
+          type: "text",
+        };
+        pushMsg(msg, currentAll);
+        setStage({ type: "idle" });
+        return;
+      }
+
+      const diffLines = buildDiffs(repoPath, parsed.patches);
+
+      if (forceApproveRef.current) {
+        const assistantMsg: Message = {
+          role: "assistant",
+          content: parsed.content,
+          type: "plan",
+          patches: parsed.patches,
+          diffLines,
+          applied: true,
+        };
+        const withAssistant = [...currentAll, assistantMsg];
+        setAllMessages(withAssistant);
+        setCommitted((prev) => [...prev, assistantMsg]);
+        try {
+          applyPatches(repoPath, parsed.patches);
+          logToolCall(
+            "changes",
+            parsed.patches.map((p) => p.path).join(", "),
+            `Applied changes to ${parsed.patches.length} file(s)`,
+            repoPath,
+          );
+        } catch {}
+        continueAfterChanges(withAssistant, parsed.content || "code changes");
+        return;
+      }
+
+      const assistantMsg: Message = {
         role: "assistant",
         content: parsed.content,
-        type: "text",
+        type: "plan",
+        patches: parsed.patches,
+        diffLines,
+        applied: false,
       };
-      setAllMessages([...currentAll, preambleMsg]);
-      setCommitted((prev) => [...prev, preambleMsg]);
-    }
+      const withAssistant = [...currentAll, assistantMsg];
+      setAllMessages(withAssistant);
+      setCommitted((prev) => [...prev, assistantMsg]);
+      setPendingMsgIndex(withAssistant.length - 1);
 
-    const remainder = parsed.remainder;
-    const isSafe = tool.safe ?? false;
+      setStage({
+        type: "preview",
+        patches: parsed.patches,
+        diffLines,
+        scrollOffset: 0,
+        pendingMessages: currentAll,
+      });
+      return;
+    }
 
-    const executeAndContinue = async (approved: boolean) => {
-      if (approved && remainder) {
-        batchApprovedRef.current = true;
+    if (parsed.kind === "clone") {
+      batchApprovedRef.current = false;
+      if (parsed.content) {
+        const preambleMsg: Message = {
+          role: "assistant",
+          content: parsed.content,
+          type: "text",
+        };
+        pushMsg(preambleMsg, currentAll);
       }
+      setStage({
+        type: "clone-offer",
+        repoUrl: parsed.repoUrl,
+        launchAnalysis: true,
+      });
+      return;
+    }
 
-      const currentProvider = providerRef.current;
-      const currentSystemPrompt = systemPromptRef.current;
-
-      if (!currentProvider) {
+    if (parsed.kind === "tool") {
+      const tool = registry.get(parsed.toolName);
+      if (!tool) {
         batchApprovedRef.current = false;
         setStage({ type: "idle" });
         return;
       }
 
-      let result = "(denied by user)";
-
-      if (approved) {
-        const cacheKey = isSafe
-          ? `${parsed.toolName}:${parsed.rawInput}`
-          : null;
-        if (cacheKey && toolResultCache.current.has(cacheKey)) {
-          result =
-            toolResultCache.current.get(cacheKey)! +
-            "\n\n[NOTE: This result was already retrieved earlier. Do not request it again.]";
-        } else {
-          try {
-            setStage({ type: "thinking" });
-            const toolResult = await tool.execute(parsed.input, {
-              repoPath,
-              messages: currentAll,
-            });
-            result = toolResult.value;
-            if (cacheKey && toolResult.kind === "text") {
-              toolResultCache.current.set(cacheKey, result);
+      if (parsed.content) {
+        const preambleMsg: Message = {
+          role: "assistant",
+          content: parsed.content,
+          type: "text",
+        };
+        pushMsg(preambleMsg, currentAll);
+      }
+
+      const isSafe = tool.safe ?? false;
+      const remainder = parsed.remainder;
+
+      const executeAndContinue = async (approved: boolean): Promise<void> => {
+        if (approved && remainder) batchApprovedRef.current = true;
+
+        const currentProvider = providerRef.current;
+        const currentSystemPrompt = systemPromptRef.current;
+
+        if (!currentProvider) {
+          batchApprovedRef.current = false;
+          setStage({ type: "idle" });
+          return;
+        }
+
+        let result = "(denied by user)";
+
+        if (approved) {
+          const cacheKey = isSafe
+            ? `${parsed.toolName}:${parsed.rawInput}`
+            : null;
+          if (cacheKey && toolResultCache.current.has(cacheKey)) {
+            result =
+              toolResultCache.current.get(cacheKey)! +
+              "\n\n[NOTE: This result was already retrieved earlier. Do not request it again.]";
+          } else {
+            try {
+              setStage({ type: "thinking" });
+              const toolResult = await tool.execute(parsed.input, {
+                repoPath,
+                messages: currentAll,
+              });
+              result = toolResult.value;
+              if (cacheKey && toolResult.kind === "text") {
+                toolResultCache.current.set(cacheKey, result);
+              }
+            } catch (err: unknown) {
+              result = `Error: ${err instanceof Error ? err.message : "failed"}`;
             }
-          } catch (err: unknown) {
-            result = `Error: ${err instanceof Error ? err.message : "failed"}`;
           }
         }
-      }
 
-      if (approved && !result.startsWith("Error:")) {
-        appendMemory({
-          kind: "shell-run",
-          detail: tool.summariseInput
-            ? String(tool.summariseInput(parsed.input))
-            : parsed.rawInput,
-          summary: result.split("\n")[0]?.slice(0, 120) ?? "",
-        });
-      }
+        if (approved && !result.startsWith("Error:")) {
+          logToolCall(
+            parsed.toolName,
+            tool.summariseInput
+              ? String(tool.summariseInput(parsed.input))
+              : parsed.rawInput,
+            result,
+            repoPath,
+          );
+        }
 
-      const displayContent = tool.summariseInput
-        ? String(tool.summariseInput(parsed.input))
-        : parsed.rawInput;
+        const displayContent = tool.summariseInput
+          ? String(tool.summariseInput(parsed.input))
+          : parsed.rawInput;
 
-      const toolMsg: Message = {
-        role: "assistant",
-        type: "tool",
-        toolName: parsed.toolName as any,
-        content: displayContent,
-        result,
-        approved,
-      };
+        const toolMsg: Message = {
+          role: "assistant",
+          type: "tool",
+          toolName: parsed.toolName as any,
+          content: displayContent,
+          result,
+          approved,
+        };
 
-      const withTool = [...currentAll, toolMsg];
-      setAllMessages(withTool);
-      setCommitted((prev) => [...prev, toolMsg]);
+        const withTool = pushMsg(toolMsg, currentAll);
 
-      if (approved && remainder && remainder.length > 0) {
-        processResponse(remainder, withTool, signal);
-        return;
-      }
+        if (approved && remainder && remainder.length > 0) {
+          return processResponse(
+            remainder,
+            withTool,
+            signal,
+            false,
+            continuationDepth,
+          );
+        }
 
-      batchApprovedRef.current = false;
+        batchApprovedRef.current = false;
 
-      const nextAbort = new AbortController();
-      abortControllerRef.current = nextAbort;
-      setStage({ type: "thinking" });
+        const nextAbort = new AbortController();
+        abortControllerRef.current = nextAbort;
+        setStage({ type: "thinking" });
+
+        try {
+          const nextResult = await callNext(withTool, nextAbort.signal);
 
-      callChat(currentProvider, currentSystemPrompt, withTool, nextAbort.signal)
-        .then((r: string) => {
           if (nextAbort.signal.aborted) return;
-          if (!r.trim()) {
-            const nudged: Message[] = [
-              ...withTool,
-              { role: "user", content: "Please continue.", type: "text" },
-            ];
-            return callChat(
-              currentProvider,
-              currentSystemPrompt,
-              nudged,
-              nextAbort.signal,
-            );
+
+          if (!nextResult.text.trim()) {
+            const stallMsg: Message = {
+              role: "assistant",
+              content: '(model stopped responding — try sending "continue")',
+              type: "text",
+            };
+            pushMsg(stallMsg, withTool);
+            setStage({ type: "idle" });
+            return;
           }
-          return r;
-        })
-        .then((r: string | undefined) => {
-          if (nextAbort.signal.aborted) return;
-          processResponse(r ?? "", withTool, nextAbort.signal);
-        })
-        .catch(handleError(withTool));
-    };
 
-    if (forceApprove || (autoApprove && isSafe) || batchApprovedRef.current) {
-      executeAndContinue(true);
+          return processResponse(
+            nextResult.text,
+            withTool,
+            nextAbort.signal,
+            nextResult.truncated,
+          );
+        } catch (err) {
+          handleError(withTool)(err);
+        }
+      };
+
+      if (forceApprove || isSafe || batchApprovedRef.current) {
+        return executeAndContinue(true);
+      }
+
+      const permLabel = tool.permissionLabel ?? tool.name;
+      const permValue = tool.summariseInput
+        ? String(tool.summariseInput(parsed.input))
+        : parsed.rawInput;
+
+      setStage({
+        type: "permission",
+        tool: {
+          type: parsed.toolName as any,
+          _display: permValue,
+          _label: permLabel,
+        } as any,
+        pendingMessages: currentAll,
+        resolve: executeAndContinue,
+      });
+    }
+  };
+
+  const continueAfterChanges = (currentAll: Message[], summary: string) => {
+    if (!providerRef.current) {
+      setStage({ type: "idle" });
       return;
     }
 
-    const permLabel = tool.permissionLabel ?? tool.name;
-    const permValue = tool.summariseInput
-      ? String(tool.summariseInput(parsed.input))
-      : parsed.rawInput;
-
-    setStage({
-      type: "permission",
-      tool: {
-        type: parsed.toolName as any,
-        _display: permValue,
-        _label: permLabel,
-      } as any,
-      pendingMessages: currentAll,
-      resolve: executeAndContinue,
-    });
+    const resultMsg: Message = {
+      role: "assistant",
+      type: "tool",
+      toolName: "changes",
+      content: summary,
+      result: "Changes applied successfully.",
+      approved: true,
+    };
+
+    const withResult = [...currentAll, resultMsg];
+    setAllMessages(withResult);
+    setCommitted((prev) => [...prev, resultMsg]);
+
+    const abort = new AbortController();
+    abortControllerRef.current = abort;
+    setStage({ type: "thinking" });
+
+    callNext(withResult, abort.signal)
+      .then((result) => {
+        if (abort.signal.aborted) return;
+        if (!result.text.trim()) {
+          setStage({ type: "idle" });
+          return;
+        }
+        return processResponse(
+          result.text,
+          withResult,
+          abort.signal,
+          result.truncated,
+        );
+      })
+      .catch(handleError(withResult));
   };
 
   const sendMessage = (
@@ -424,15 +598,25 @@ export function useChat(repoPath: string) {
 
     const intent = classifyIntent(text);
     const scopedToolsSection = registry.buildSystemPromptSection(intent);
+    const sessionSummary = getSessionToolSummary(repoPath);
 
-    const scopedSystemPrompt = currentSystemPrompt.replace(
+    let scopedSystemPrompt = currentSystemPrompt.replace(
       /## TOOLS[\s\S]*?(?=\n## (?!TOOLS))/,
       scopedToolsSection + "\n\n",
     );
+    if (sessionSummary) {
+      scopedSystemPrompt = scopedSystemPrompt.replace(
+        /## CODEBASE/,
+        sessionSummary + "\n\n## CODEBASE",
+      );
+    }
 
     setStage({ type: "thinking" });
+
     callChat(currentProvider, scopedSystemPrompt, nextAll, abort.signal)
-      .then((raw: string) => processResponse(raw, nextAll, abort.signal))
+      .then((result: ChatResult) =>
+        processResponse(result.text, nextAll, abort.signal, result.truncated),
+      )
       .catch(handleError(nextAll));
   };
 
@@ -440,6 +624,7 @@ export function useChat(repoPath: string) {
     setProvider(p);
     providerRef.current = p;
     setStage({ type: "loading" });
+
     fetchFileTree(repoPath)
       .catch(() => walkDir(repoPath))
       .then((fileTree) => {
@@ -453,13 +638,16 @@ export function useChat(repoPath: string) {
         const prompt =
           buildSystemPrompt(importantFiles, historySummary, toolsSection) +
           lensContext;
+
         setSystemPrompt(prompt);
         systemPromptRef.current = prompt;
+
         const greeting: Message = {
           role: "assistant",
           content: `Welcome to Lens\nCodebase loaded — ${importantFiles.length} files indexed.${historySummary ? "\n\nI have memory of previous actions in this repo." : ""}${lensFile ? "\n\nFound LENS.md — I have context from a previous analysis of this repo." : ""}\nAsk me anything, tell me what to build, share a URL, or ask me to read/write files.\n\nTip: type /timeline to browse commit history.\nTip: ⭐ Star Lens on GitHub — github.com/ridit-jangra/Lens`,
           type: "text",
         };
+
         setCommitted([greeting]);
         setAllMessages([greeting]);
         setStage({ type: "idle" });
@@ -477,22 +665,24 @@ export function useChat(repoPath: string) {
   const applyPatchesAndContinue = (patches: any[]) => {
     try {
       applyPatches(repoPath, patches);
-      appendMemory({
-        kind: "code-applied",
-        detail: patches.map((p) => p.path).join(", "),
-        summary: `Applied changes to ${patches.length} file(s)`,
-      });
+      logToolCall(
+        "changes",
+        patches.map((p) => p.path).join(", "),
+        `Applied changes to ${patches.length} file(s)`,
+        repoPath,
+      );
     } catch {
       /* non-fatal */
     }
   };
 
   const skipPatches = (patches: any[]) => {
-    appendMemory({
-      kind: "code-skipped",
-      detail: patches.map((p: { path: string }) => p.path).join(", "),
-      summary: `Skipped changes to ${patches.length} file(s)`,
-    });
+    logToolCall(
+      "changes-skipped",
+      patches.map((p: { path: string }) => p.path).join(", "),
+      `Skipped changes to ${patches.length} file(s)`,
+      repoPath,
+    );
   };
 
   return {
@@ -533,6 +723,7 @@ export function useChat(repoPath: string) {
     handleProviderDone,
     abortThinking,
     applyPatchesAndContinue,
+    continueAfterChanges,
     skipPatches,
     processResponse,
     handleError,