@@ -73,15 +73,35 @@ export namespace LLM {
     return [value, value.slice(start)]
   }
 
-  export function repairToolInput(input: { toolInput: string; errorMessage: string }) {
+  function str(input: unknown) {
+    if (typeof input !== "string") return
+    const value = input.trim()
+    if (!value) return
+    return value
+  }
+
+  function normalize(input: Record<string, unknown>, tool: string) {
+    const lower = tool.toLowerCase()
+    if (!["write", "read", "edit", "multiedit", "lsp"].includes(lower)) return input
+    if (str(input.filePath)) return input
+    const filePath = [input.filepath, input.path, input.file, input.filename].map(str).find((x) => x)
+    if (!filePath) return input
+    return {
+      ...input,
+      filePath,
+    }
+  }
+
+  export function repairToolInput(input: { toolName: string; toolInput: string; errorMessage: string }) {
     const match = input.errorMessage.match(/Text:\s*([\s\S]*)$/)
     const text = match?.[1] ?? ""
     const list = [input.toolInput, text].flatMap(candidates).filter(Boolean)
     for (const item of list) {
       const parsed = object(item)
       if (!parsed) continue
-      if (Object.keys(parsed).length === 0) continue
-      return JSON.stringify(parsed)
+      const fixed = normalize(parsed, input.toolName)
+      if (Object.keys(fixed).length === 0) continue
+      return JSON.stringify(fixed)
     }
   }
 
@@ -227,6 +247,7 @@ export namespace LLM {
           })
         }
         const repaired = repairToolInput({
+          toolName: failed.toolCall.toolName,
           toolInput: InvalidToolInputError.isInstance(failed.error) ? failed.error.toolInput : failed.toolCall.input,
           errorMessage: failed.error.message,
         })
 
@@ -203,15 +203,17 @@ export namespace SessionProcessor {
 
                 case "tool-error": {
                   const match = toolcalls[value.toolCallId]
-                  if (match && match.state.status === "running") {
+                  if (match && (match.state.status === "running" || match.state.status === "pending")) {
+                    const start = match.state.status === "running" ? match.state.time.start : Date.now()
+                    const input = value.input ?? match.state.input
                     await Session.updatePart({
                       ...match,
                       state: {
                         status: "error",
-                        input: value.input ?? match.state.input,
+                        input,
                         error: (value.error as any).toString(),
                         time: {
-                          start: match.state.time.start,
+                          start,
                           end: Date.now(),
                         },
                       },
 
@@ -102,6 +102,7 @@ describe("session.llm.hasToolCalls", () => {
 describe("session.llm.repairToolInput", () => {
   test("repairs truncated tool input json", () => {
     const repaired = LLM.repairToolInput({
+      toolName: "write",
       toolInput: `{"filePath":"src/app.ts","content":"hello`,
       errorMessage: "Invalid input for tool write",
     })
@@ -114,6 +115,7 @@ describe("session.llm.repairToolInput", () => {
 
   test("repairs from error text when tool input is empty", () => {
     const repaired = LLM.repairToolInput({
+      toolName: "write",
       toolInput: "",
       errorMessage:
         'Invalid input for tool write: JSON parsing failed: Text: {"filePath":"src/app.ts","content":"hello"}',
@@ -125,8 +127,22 @@ describe("session.llm.repairToolInput", () => {
     })
   })
 
+  test("normalizes filepath aliases for write tool", () => {
+    const repaired = LLM.repairToolInput({
+      toolName: "write",
+      toolInput: '{"filepath":"src/app.ts","content":"hello"}',
+      errorMessage:
+        'The write tool was called with invalid arguments: [{"expected":"string","code":"invalid_type","path":["filePath"],"message":"Invalid input: expected string, received undefined"}]',
+    })
+    expect(repaired).toBeDefined()
+    const parsed = JSON.parse(repaired!)
+    expect(parsed.filePath).toBe("src/app.ts")
+    expect(parsed.content).toBe("hello")
+  })
+
   test("returns undefined when input is not json-like", () => {
     const repaired = LLM.repairToolInput({
+      toolName: "write",
       toolInput: "not-json",
       errorMessage: "Invalid input for tool write",
     })