feat: update Edit tool with broader backslash matching; add support for stripping accidental read-result tabs in Edit tool; add /continue command to resume conversations and update related functionality

Author: qorzj

src/cli.tsx

@@ -42,6 +42,7 @@ if (args.includes("--help") || args.includes("-h")) {
       "  /new             Start a fresh conversation",
       "  /init            Initialize an AGENTS.md file with instructions for LLM",
       "  /resume          Pick a previous conversation to continue",
+      "  /continue        Continue the active conversation, or resume one if empty",
       "  /exit            Quit",
       "  ctrl+d twice     Quit",
     ].join("\n") + "\n"

src/session.ts

@@ -957,6 +957,12 @@ ${skillMd}
       return;
     }
 
+    if (this.isContinuePrompt(userPrompt)) {
+      this.activeSessionId = sessionId;
+      await this.activateSession(sessionId, controller);
+      return;
+    }
+
     this.reportNewPrompt();
 
     if (userPrompt.text) {
@@ -996,6 +1002,15 @@ ${skillMd}
     await this.activateSession(sessionId, controller);
   }
 
+  private isContinuePrompt(userPrompt: UserPromptContent): boolean {
+    return (
+      typeof userPrompt.text === "string" &&
+      userPrompt.text.trim() === "/continue" &&
+      (!userPrompt.imageUrls || userPrompt.imageUrls.length === 0) &&
+      (!userPrompt.skills || userPrompt.skills.length === 0)
+    );
+  }
+
   async activateSession(sessionId: string, controller?: AbortController): Promise<void> {
     const startedAt = Date.now();
     const { client, model, baseURL, thinkingEnabled, reasoningEffort, debugLogEnabled, notify, env } =
@@ -1055,6 +1070,23 @@ ${skillMd}
           return;
         }
 
+        const pendingToolCalls = this.getTrailingPendingToolCalls(this.listSessionMessages(sessionId));
+        if (pendingToolCalls.length > 0) {
+          const toolAppendResult = await this.appendToolMessages(sessionId, pendingToolCalls);
+          if (this.isInterrupted(sessionId)) {
+            return;
+          }
+          if (toolAppendResult.waitingForUser) {
+            this.updateSessionEntry(sessionId, (entry) => ({
+              ...entry,
+              toolCalls: pendingToolCalls,
+              status: "waiting_for_user",
+              updateTime: new Date().toISOString(),
+            }));
+            return;
+          }
+        }
+
         const compactPromptTokenThreshold = getCompactPromptTokenThreshold(model);
         if (session.activeTokens > compactPromptTokenThreshold) {
           const message = this.buildAssistantMessage(
@@ -1859,6 +1891,20 @@ ${skillMd}
     return pairings;
   }
 
+  private getTrailingPendingToolCalls(messages: SessionMessage[]): unknown[] {
+    const activeMessages = messages.filter((message) => !message.compacted);
+    const latestMessage = activeMessages[activeMessages.length - 1];
+    if (!latestMessage || latestMessage.role !== "assistant") {
+      return [];
+    }
+
+    const toolCalls = this.getAssistantToolCalls(latestMessage);
+    if (toolCalls.length === 0) {
+      return [];
+    }
+    return toolCalls.filter((toolCall) => Boolean(this.getToolCallId(toolCall)));
+  }
+
   private findPairableToolMessageIndex(
     messages: SessionMessage[],
     assistantIndex: number,

src/tests/session.test.ts

@@ -723,6 +723,100 @@ test("replySession reports a new prompt with the machineId token", async () => {
   assert.equal((fetchCalls[0].init?.headers as Record<string, string>).Token, "machine-id-456");
 });
 
+test("replySession continues without appending /continue as a user message", async () => {
+  const workspace = createTempDir("deepcode-continue-workspace-");
+  const home = createTempDir("deepcode-continue-home-");
+  setHomeDir(home);
+
+  const fetchCalls: Array<{ input: string | URL; init?: RequestInit }> = [];
+  globalThis.fetch = (async (input: string | URL, init?: RequestInit) => {
+    fetchCalls.push({ input, init });
+    return {
+      ok: true,
+      text: async () => "",
+    } as Response;
+  }) as typeof fetch;
+
+  const manager = createSessionManager(workspace, "machine-id-continue");
+  const activatedSessionIds: string[] = [];
+  (manager as any).activateSession = async (sessionId: string) => {
+    activatedSessionIds.push(sessionId);
+  };
+
+  const sessionId = await manager.createSession({ text: "first prompt" });
+  await flushPromises();
+  const messagesBefore = manager.listSessionMessages(sessionId);
+  fetchCalls.length = 0;
+  activatedSessionIds.length = 0;
+
+  await manager.replySession(sessionId, { text: "/continue" });
+  await flushPromises();
+
+  const messagesAfter = manager.listSessionMessages(sessionId);
+  const userMessages = messagesAfter.filter((message) => message.role === "user");
+
+  assert.equal(activatedSessionIds.length, 1);
+  assert.equal(activatedSessionIds[0], sessionId);
+  assert.equal(messagesAfter.length, messagesBefore.length);
+  assert.equal(
+    userMessages.some((message) => message.content === "/continue"),
+    false
+  );
+  assert.equal(fetchCalls.length, 0);
+});
+
+test("replySession /continue runs trailing pending tool calls before requesting another response", async () => {
+  const workspace = createTempDir("deepcode-continue-tool-workspace-");
+  const home = createTempDir("deepcode-continue-tool-home-");
+  setHomeDir(home);
+
+  const responses = [
+    createChatResponse("continued after tool", {
+      prompt_tokens: 9,
+      completion_tokens: 2,
+      total_tokens: 11,
+    }),
+  ];
+  const manager = createMockedClientSessionManager(workspace, responses);
+  const originalActivateSession = manager.activateSession.bind(manager);
+  (manager as any).activateSession = async () => {};
+
+  const sessionId = await manager.createSession({ text: "first prompt" });
+  const pendingAssistant = (manager as any).buildAssistantMessage(
+    sessionId,
+    "Need to read a file",
+    [
+      {
+        id: "call-pending-read",
+        type: "function",
+        function: { name: "read", arguments: JSON.stringify({ file_path: path.join(workspace, "note.txt") }) },
+      },
+    ],
+    null
+  ) as SessionMessage;
+  fs.writeFileSync(path.join(workspace, "note.txt"), "hello from pending tool\n", "utf8");
+  (manager as any).appendSessionMessage(sessionId, pendingAssistant);
+  (manager as any).activateSession = originalActivateSession;
+
+  await manager.replySession(sessionId, { text: "/continue" });
+
+  const messages = manager.listSessionMessages(sessionId);
+  const toolMessage = messages.find((message) => {
+    const params = message.messageParams as { tool_call_id?: string } | null;
+    return message.role === "tool" && params?.tool_call_id === "call-pending-read";
+  });
+  const assistantMessages = messages.filter((message) => message.role === "assistant");
+  const userMessages = messages.filter((message) => message.role === "user");
+
+  assert.ok(toolMessage);
+  assert.match(toolMessage.content ?? "", /hello from pending tool/);
+  assert.equal(assistantMessages[assistantMessages.length - 1]?.content, "continued after tool");
+  assert.equal(
+    userMessages.some((message) => message.content === "/continue"),
+    false
+  );
+});
+
 test("replySession preserves raw session messages when a previous tool call is pending", async () => {
   const workspace = createTempDir("deepcode-pending-tool-workspace-");
   const home = createTempDir("deepcode-pending-tool-home-");

src/tests/slashCommands.test.ts

@@ -19,7 +19,7 @@ test("buildSlashCommands prefixes skills before built-ins", () => {
   assert.equal(items[0].kind, "skill");
   assert.equal(items[0].name, "skill-writer");
   const builtinNames = items.filter((i) => i.kind !== "skill").map((i) => i.name);
-  assert.deepEqual(builtinNames, ["skills", "model", "new", "init", "resume", "mcp", "exit"]);
+  assert.deepEqual(builtinNames, ["skills", "model", "new", "init", "resume", "continue", "mcp", "exit"]);
 });
 
 test("filterSlashCommands matches partial prefixes", () => {
@@ -59,6 +59,13 @@ test("findExactSlashCommand returns built-in /init", () => {
   assert.equal(item?.description, "Initialize an AGENTS.md file with instructions for LLM");
 });
 
+test("findExactSlashCommand returns built-in /continue", () => {
+  const items = buildSlashCommands(skills);
+  const item = findExactSlashCommand(items, "/continue");
+  assert.ok(item);
+  assert.equal(item?.kind, "continue");
+});
+
 test("findExactSlashCommand returns built-in /skills", () => {
   const items = buildSlashCommands(skills);
   const item = findExactSlashCommand(items, "/skills");

src/tests/tool-handlers.test.ts

@@ -356,6 +356,80 @@ test("Edit accepts a unique loose-escape match when only escaping differs", asyn
   assert.equal(fs.readFileSync(filePath, "utf8"), "params['city_json'] = city\n");
 });
 
+test("Edit accepts a unique loose-escape match for over-escaped unicode sequences", async () => {
+  const workspace = createTempWorkspace();
+  const filePath = path.join(workspace, "keys.ts");
+  fs.writeFileSync(filePath, 'const sequence = "\\u001B[13;2~";\n', "utf8");
+
+  const sessionId = "unicode-loose-escape";
+  await handleReadTool({ file_path: filePath }, createContext(sessionId, workspace));
+
+  let llmCalls = 0;
+  const editResult = await handleEditTool(
+    {
+      file_path: filePath,
+      old_string: 'const sequence = "\\\\u001B[13;2~";',
+      new_string: 'const sequence = "\\\\u001B[13;130u";',
+    },
+    createContext(sessionId, workspace, {
+      createOpenAIClient: () => ({
+        client: {
+          chat: {
+            completions: {
+              create: async (request: { messages?: Array<{ content?: string }> }) => {
+                llmCalls += 1;
+                assert.match(String(request.messages?.[1]?.content ?? ""), /<matched_text><!\[CDATA\[/);
+                return {
+                  choices: [
+                    {
+                      message: {
+                        content:
+                          "<response>" +
+                          '<corrected_old_string><![CDATA[const sequence = "\\u001B[13;2~";]]></corrected_old_string>' +
+                          '<corrected_new_string><![CDATA[const sequence = "\\u001B[13;130u";]]></corrected_new_string>' +
+                          "</response>",
+                      },
+                    },
+                  ],
+                };
+              },
+            },
+          },
+        } as any,
+        model: "test-model",
+        thinkingEnabled: false,
+      }),
+    })
+  );
+
+  assert.equal(editResult.ok, true);
+  assert.equal(llmCalls, 1);
+  assert.equal(editResult.metadata?.matched_via, "llm_escape_correction");
+  assert.equal(fs.readFileSync(filePath, "utf8"), 'const sequence = "\\u001B[13;130u";\n');
+});
+
+test("Edit strips accidental read-result tabs after newlines when that creates a unique match", async () => {
+  const workspace = createTempWorkspace();
+  const filePath = path.join(workspace, "tabs.ts");
+  fs.writeFileSync(filePath, ["function demo() {", "  return 1;", "}"].join("\n") + "\n", "utf8");
+
+  const sessionId = "line-leading-tab-correction";
+  await handleReadTool({ file_path: filePath }, createContext(sessionId, workspace));
+
+  const editResult = await handleEditTool(
+    {
+      file_path: filePath,
+      old_string: "function demo() {\n\t  return 1;\n\t}",
+      new_string: "function demo() {\n\t  return 2;\n\t}",
+    },
+    createContext(sessionId, workspace)
+  );
+
+  assert.equal(editResult.ok, true);
+  assert.equal(editResult.metadata?.matched_via, "line_leading_tab_correction");
+  assert.equal(fs.readFileSync(filePath, "utf8"), ["function demo() {", "  return 2;", "}"].join("\n") + "\n");
+});
+
 test("Write repairs JSON object content for .json files", async () => {
   const workspace = createTempWorkspace();
   const filePath = path.join(workspace, "package.json");

src/tools/edit-handler.ts

@@ -213,10 +213,23 @@ export async function handleEditTool(
         const lineIndex = buildLineIndex(raw);
         const scope = buildSearchScope(filePath, raw, lineIndex, snippet ?? null);
         let matches = findOccurrences(raw, oldString, scope);
-        let matchedVia: "exact" | "loose_escape" | "llm_escape_correction" = "exact";
+        let matchedVia: "exact" | "line_leading_tab_correction" | "loose_escape" | "llm_escape_correction" = "exact";
         let replacementOldString = oldString;
         let replacementNewString = newString;
 
+        if (matches.length === 0) {
+          const tabStrippedOldString = stripReadResultLineTabs(oldString);
+          if (tabStrippedOldString !== oldString) {
+            const tabStrippedMatches = findOccurrences(raw, tabStrippedOldString, scope);
+            if (tabStrippedMatches.length === 1) {
+              matches = tabStrippedMatches;
+              matchedVia = "line_leading_tab_correction";
+              replacementOldString = tabStrippedOldString;
+              replacementNewString = stripReadResultLineTabs(newString);
+            }
+          }
+        }
+
         if (matches.length === 0) {
           const looseEscapeMatches = findLooseEscapeMatches(raw, oldString, scope);
           if (looseEscapeMatches.length === 1 && looseEscapeMatches[0]?.score === 1) {
@@ -545,6 +558,10 @@ function applyReplacement(
   return result;
 }
 
+function stripReadResultLineTabs(value: string): string {
+  return value.replaceAll("\n\t", "\n");
+}
+
 function buildCandidateMetadata(
   sessionId: string,
   filePath: string,
@@ -691,7 +708,7 @@ function buildLooseEscapeRegex(source: string): RegExp | null {
         slashEnd += 1;
       }
 
-      if (slashEnd < source.length && isEscapeSensitiveChar(source[slashEnd])) {
+      if (slashEnd < source.length) {
         pattern += "\\\\*";
         pattern += escapeRegExp(source[slashEnd]);
         index = slashEnd;
@@ -807,10 +824,6 @@ function parseCorrectedEditStrings(content: string): CorrectedEditStrings | null
   return null;
 }
 
-function isEscapeSensitiveChar(value: string): boolean {
-  return value === '"' || value === "'" || value === "`" || value === "\\";
-}
-
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

src/ui/App.tsx

@@ -190,6 +190,12 @@ export function App({ projectRoot, version = "", onRestart }: AppProps): React.R
         setView("session-list");
         return;
       }
+      if (submission.command === "continue" && isCurrentSessionEmpty(sessionManager)) {
+        setShowWelcome(false);
+        refreshSessionsList();
+        setView("session-list");
+        return;
+      }
       if (submission.command === "mcp") {
         setShowWelcome(false);
         setMcpStatuses(sessionManager.getMcpStatus());
@@ -211,7 +217,7 @@ export function App({ projectRoot, version = "", onRestart }: AppProps): React.R
         (selectedSkillNames.length > 0 ? `Use skills: ${selectedSkillNames.join(", ")}` : "") ||
         (submission.imageUrls.length > 0 ? "[Image]" : "");
 
-      if (userDisplayContent) {
+      if (userDisplayContent && submission.command !== "continue") {
         setMessages((prev) => [...prev, buildSyntheticUserMessage(userDisplayContent, submission.imageUrls.length)]);
       }
 
@@ -506,6 +512,11 @@ function buildSyntheticUserMessage(content: string, imageCount: number): Session
   };
 }
 
+function isCurrentSessionEmpty(sessionManager: SessionManager): boolean {
+  const activeSessionId = sessionManager.getActiveSessionId();
+  return !activeSessionId || !sessionManager.getSession(activeSessionId);
+}
+
 function buildStatusLine(entry: SessionEntry): string {
   const parts: string[] = [];
   parts.push(`status: ${entry.status}`);