ethagent 2.3.0 → 3.0.0

package/src/providers/openai-responses.ts

@@ -5,7 +5,8 @@ import { providerErrorFromResponse } from './errors.js'
 import { fetchWithRetryStreamEvents } from './retry.js'
 import { iterSseEvents } from './sse.js'
 import { buildResponsesBody } from './openai-responses-format.js'
-import type { OpenAIToolDefinition } from './openai-chat.js'
+import { supportsOpenAIImages, type OpenAIToolDefinition } from './openai-chat.js'
+import { hasImageBlocks, ImageLoadError } from '../utils/images.js'
 
 const READ_TIMEOUT_MS = 45_000
 
@@ -64,15 +65,29 @@ export class OpenAIResponsesProvider implements Provider {
       return
     }
 
+    if (hasImageBlocks(messages) && !supportsOpenAIImages(this.model)) {
+      yield { type: 'error', message: `image input is not enabled for ${this.model}` }
+      return
+    }
+
     let attempt = 0
     while (true) {
       attempt += 1
-      const body = JSON.stringify(buildResponsesBody({
-        model: this.model,
-        messages,
-        tools: this.tools,
-        maxOutputTokens: options.maxTokens,
-      }))
+      let body: string
+      try {
+        body = JSON.stringify(await buildResponsesBody({
+          model: this.model,
+          messages,
+          tools: this.tools,
+          maxOutputTokens: options.maxTokens,
+        }))
+      } catch (err: unknown) {
+        if (err instanceof ImageLoadError) {
+          yield { type: 'error', message: err.message }
+          return
+        }
+        throw err
+      }
 
       let response: Response
       try {
@@ -261,15 +276,30 @@ function parseToolArguments(input: string): Record<string, unknown> {
   const trimmed = input.trim()
   if (!trimmed) return {}
   try {
-    const parsed = JSON.parse(trimmed) as unknown
-    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : {}
+    return coerceToToolArguments(JSON.parse(trimmed))
   } catch {
     return {}
   }
 }
 
+function coerceToToolArguments(value: unknown): Record<string, unknown> {
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+      try {
+        return coerceToToolArguments(JSON.parse(trimmed))
+      } catch {
+        return {}
+      }
+    }
+    return {}
+  }
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>
+  }
+  return {}
+}
+
 function networkErrorMessage(baseUrl: string, err: unknown, fallback = 'network error'): string {
   const message = (err as Error).message || fallback
   return `openai request failed at ${baseUrl}: ${message}`

package/src/providers/registry.ts

@@ -34,6 +34,7 @@ export function createProvider(config: EthagentConfig, options: { mode?: Session
         baseUrl: localProviderBaseUrlFor('llamacpp', config.baseUrl),
         apiKey: 'llamacpp',
         tools: openAITools(mode, toolContext),
+        hasVisionProjector: Boolean(config.localMmprojPath),
       })
     case 'openai':
       return createOpenAIProvider(config, openAITools(mode, toolContext))

package/src/runtime/toolExecution.ts

@@ -50,8 +50,8 @@ export async function executeToolWithPermissions(
     return {
       result: {
         ok: false,
-        summary: `unknown tool ${options.name}`,
-        content: `tool '${options.name}' is not registered`,
+        summary: `Unknown tool ${options.name}`,
+        content: `Tool '${options.name}' is not registered`,
       },
     }
   }
@@ -98,6 +98,7 @@ export async function executeToolWithPermissions(
     options.permissionMode === 'plan' &&
     request.kind !== 'read' &&
     request.kind !== 'private-continuity-read' &&
+    request.kind !== 'private-skill-read' &&
     !(request.kind === 'mcp' && request.readOnly)
   ) {
     return {
@@ -111,7 +112,7 @@ export async function executeToolWithPermissions(
 
   const matchedRule = matchPermissionRule(options.getPermissionRules(), request)
   const decision: PermissionDecision =
-    modePolicy(options.permissionMode).autoAllowToolKind(request.kind)
+    modePolicy(options.permissionMode).autoAllowToolKind(tool.kind)
       ? 'allow-once'
       : matchedRule
         ? 'allow-once'

package/src/runtime/turn.ts

@@ -10,6 +10,7 @@ import {
 type ProviderTurnEvent =
   | { type: 'text'; delta: string }
   | { type: 'thinking'; delta: string }
+  | { type: 'thinking_end' }
   | ProviderRetryStreamEvent
   | { type: 'tool_use_start'; id: string; name: string }
   | { type: 'tool_use_delta'; id: string; delta: string }
@@ -46,6 +47,7 @@ function normalize(event: StreamEvent): ProviderTurnEvent {
   switch (event.type) {
     case 'text': return { type: 'text', delta: event.delta }
     case 'thinking': return { type: 'thinking', delta: event.delta }
+    case 'thinking_end': return { type: 'thinking_end' }
     case 'retry': return event
     case 'tool_use_start': return event
     case 'tool_use_delta': return event
@@ -67,6 +69,7 @@ export type ContinuationNudgeReason =
   | 'tool_budget'
   | 'private_continuity_tool'
   | 'private_continuity_tool_repair'
+  | 'write_file_repair'
   | 'reasoning_only'
 
 const CONTINUATION_NUDGE_TEXT =
@@ -93,6 +96,9 @@ const PRIVATE_CONTINUITY_NUDGE_TEXT =
 const PRIVATE_CONTINUITY_REPAIR_NUDGE_TEXT =
   'The previous propose_private_continuity_edit call had invalid or missing input. Retry the same native tool now with complete arguments. Do not answer in prose and do not search for markdown files. For memory/preferences use {"file":"MEMORY.md","appendToSection":"Durable User Preferences","appendText":"- User preference or memory note."}. For persona use {"file":"SOUL.md","appendToSection":"Persona","appendText":"- Persona or standing behavior note."}.'
 
+const WRITE_FILE_REPAIR_NUDGE_TEXT =
+  'The previous write_file call was rejected because the arguments were missing or malformed. Retry the same native tool now with a JSON object (not a JSON string) shaped exactly like {"path":"relative/path.ext","content":"...complete file contents..."}. Both fields are required and must be non-empty. Do not answer in prose.'
+
 const REASONING_ONLY_NUDGE_TEXT =
   'You produced private reasoning but no user-visible answer. Answer the user now in visible text. Do not continue only with reasoning.'
 
@@ -100,6 +106,7 @@ export type TurnEvent =
   | { type: 'iteration_start'; index: number }
   | { type: 'text'; delta: string }
   | { type: 'thinking'; delta: string }
+  | { type: 'thinking_end' }
   | ProviderRetryStreamEvent
   | { type: 'tool_use_start'; id: string; name: string }
   | { type: 'tool_use_delta'; id: string; delta: string }
@@ -203,6 +210,8 @@ export async function* runRuntimeTurn(
         } else if (ev.type === 'thinking') {
           thinkingSeen = true
           yield { type: 'thinking', delta: ev.delta }
+        } else if (ev.type === 'thinking_end') {
+          yield { type: 'thinking_end' }
         } else if (ev.type === 'tool_use_start') {
           yield { type: 'tool_use_start', id: ev.id, name: ev.name }
         } else if (ev.type === 'tool_use_delta') {
@@ -279,7 +288,7 @@ export async function* runRuntimeTurn(
       }
       yield {
         type: 'error',
-        message: 'model printed tool names instead of making a tool call',
+        message: 'Model printed tool names instead of making a tool call',
         discardAssistant: true,
       }
       yield doneEvent(false, stopReason)
@@ -302,7 +311,7 @@ export async function* runRuntimeTurn(
       }
       yield {
         type: 'error',
-        message: 'model asked the user to run a tool instead of making a tool call',
+        message: 'Model asked the user to run a tool instead of making a tool call',
         discardAssistant: true,
       }
       yield doneEvent(false, stopReason)
@@ -333,7 +342,7 @@ export async function* runRuntimeTurn(
         }
         yield {
           type: 'error',
-          message: 'model claimed workspace state without matching tool evidence',
+          message: 'Model claimed workspace state without matching tool evidence',
           discardAssistant: true,
         }
         yield doneEvent(false, stopReason)
@@ -342,26 +351,18 @@ export async function* runRuntimeTurn(
     }
 
     if (pendingToolUses.length === 0) {
-      if (!assistantText && thinkingSeen) {
-        if (continuationNudges < maxContinuationNudges) {
-          continuationNudges += 1
-          yield {
-            type: 'continuation_nudge',
-            attempt: continuationNudges,
-            reason: 'reasoning_only',
-          }
-          workingMessages = [
-            ...await rebuildMessages(),
-            { role: 'user', content: REASONING_ONLY_NUDGE_TEXT },
-          ]
-          continue
-        }
+      if (!assistantText && thinkingSeen && continuationNudges < maxContinuationNudges) {
+        continuationNudges += 1
         yield {
-          type: 'error',
-          message: 'model produced reasoning but no visible answer',
+          type: 'continuation_nudge',
+          attempt: continuationNudges,
+          reason: 'reasoning_only',
         }
-        yield doneEvent(false, stopReason)
-        return
+        workingMessages = [
+          ...await rebuildMessages(),
+          { role: 'user', content: REASONING_ONLY_NUDGE_TEXT },
+        ]
+        continue
       }
 
       const nudge = nextNudge(provider, assistantText)
@@ -387,7 +388,7 @@ export async function* runRuntimeTurn(
       if (assistantText && nudge?.reason === 'tool_capability') {
         yield {
           type: 'error',
-          message: 'model refused available tools after corrective nudges',
+          message: 'Model refused available tools after corrective nudges',
         }
         yield doneEvent(false, stopReason)
         return
@@ -456,17 +457,17 @@ export async function* runRuntimeTurn(
         yield {
           type: 'continuation_nudge',
           attempt: continuationNudges,
-          reason: 'private_continuity_tool_repair',
+          reason: repairNudge.reason,
         }
         workingMessages = [
           ...await rebuildMessages(),
-          { role: 'user', content: repairNudge },
+          { role: 'user', content: repairNudge.text },
         ]
         continue
       }
       yield {
         type: 'error',
-        message: 'model called propose_private_continuity_edit with invalid input after corrective nudges',
+        message: repairNudge.failureMessage,
         discardAssistant: true,
       }
       yield doneEvent(false, stopReason)
@@ -485,26 +486,56 @@ function doneEvent(finishedNormally: boolean, stopReason?: TurnStopReason): Extr
   return { type: 'done', finishedNormally }
 }
 
+type RepairNudge = {
+  text: string
+  reason: ContinuationNudgeReason
+  failureMessage: string
+}
+
 function nextToolResultRepairNudge(
   provider: Pick<Provider, 'id' | 'supportsTools'>,
   completedTools: ExecutedToolUse[],
-): string | null {
+): RepairNudge | null {
   if (!provider.supportsTools) return null
   const failedPrivateEdit = completedTools.some(completed =>
     completed.name === 'propose_private_continuity_edit'
     && !completed.result.ok
     && completed.result.summary === 'propose_private_continuity_edit rejected input',
   )
-  if (failedPrivateEdit) return PRIVATE_CONTINUITY_REPAIR_NUDGE_TEXT
+  if (failedPrivateEdit) {
+    return {
+      text: PRIVATE_CONTINUITY_REPAIR_NUDGE_TEXT,
+      reason: 'private_continuity_tool_repair',
+      failureMessage: 'Model called propose_private_continuity_edit with invalid input after corrective nudges',
+    }
+  }
+
+  const failedWriteFile = completedTools.some(completed =>
+    completed.name === 'write_file'
+    && !completed.result.ok
+    && completed.result.summary === 'write_file rejected input',
+  )
+  if (failedWriteFile) {
+    return {
+      text: WRITE_FILE_REPAIR_NUDGE_TEXT,
+      reason: 'write_file_repair',
+      failureMessage: 'Model called write_file with invalid input after corrective nudges',
+    }
+  }
 
   const failedWorkspacePrivateRead = completedTools.some(completed =>
     completed.name === 'read_file'
     && !completed.result.ok
     && /read_private_continuity_file/.test(completed.result.content),
   )
-  return failedWorkspacePrivateRead
-    ? 'The previous read_file call targeted private identity continuity markdown. Retry now with read_private_continuity_file and complete input such as {"file":"MEMORY.md"} or {"file":"SOUL.md"}. Do not search workspace folders.'
-    : null
+  if (failedWorkspacePrivateRead) {
+    return {
+      text: 'The previous read_file call targeted private identity continuity markdown. Retry now with read_private_continuity_file and complete input such as {"file":"MEMORY.md"} or {"file":"SOUL.md"}. Do not search workspace folders.',
+      reason: 'private_continuity_tool_repair',
+      failureMessage: 'Model kept reading private continuity files via read_file after corrective nudges',
+    }
+  }
+  return null
 }
 
 export function parseLocalModelTextToolUse(

package/src/storage/config.ts

@@ -80,6 +80,7 @@ const ConfigSchema = z.object({
   provider: z.enum(PROVIDERS),
   model: z.string().min(1),
   baseUrl: z.string().url().optional(),
+  localMmprojPath: z.string().min(1).optional(),
   firstRunAt: z.string(),
   identity: IdentitySchema.optional(),
   erc8004: z.object({

package/src/storage/sessions.ts

@@ -11,9 +11,10 @@ import {
   isUserCorrectionOfToolState,
   looksLikeToolStateClaim,
 } from '../runtime/toolClaimGuards.js'
+import { userTextToContentBlocks } from '../utils/images.js'
 
 export type SessionMessage =
-  | { version?: 2; role: 'user'; content: string; createdAt: string; turnId?: string; synthetic?: boolean }
+  | { version?: 2; role: 'user'; content: string; providerContent?: Message['content']; createdAt: string; turnId?: string; synthetic?: boolean }
   | { version?: 2; role: 'assistant'; content: string; createdAt: string; model?: string; usage?: { in?: number; out?: number }; turnId?: string; synthetic?: boolean }
   | { version?: 2; role: 'system'; content: string; createdAt: string; turnId?: string; synthetic?: boolean }
   | { version: 2; role: 'tool_use'; toolUseId: string; name: string; input: Record<string, unknown>; createdAt: string; turnId?: string }
@@ -244,6 +245,17 @@ export type ProviderMessageProjectionOptions = {
 export const TOOL_CORRECTION_CONTEXT_MESSAGE =
   'The latest user message corrects a prior assistant claim about tool or filesystem state. Treat user correction and tool_result messages as authoritative. Ignore any recent assistant claim about files, directories, cwd, or tool execution unless it is backed by a tool_result, and retry with the appropriate tool.'
 
+function resolveUserContent(
+  message: Extract<SessionMessage, { role: 'system' | 'user' | 'assistant' }>,
+): Message['content'] {
+  if (message.role !== 'user') return message.content
+  if (message.providerContent) return message.providerContent
+  if (message.content.includes('[image:')) {
+    return userTextToContentBlocks(message.content)
+  }
+  return message.content
+}
+
 export function sessionMessagesToProviderMessages(
   messages: SessionMessage[],
   options: ProviderMessageProjectionOptions = {},
@@ -255,7 +267,7 @@ export function sessionMessagesToProviderMessages(
   for (const [index, message] of messages.entries()) {
     if (message.role === 'system' || message.role === 'user' || message.role === 'assistant') {
       if (message.role === 'assistant' && invalidatedAssistantMessages.has(index)) continue
-      out.push({ role: message.role, content: message.content })
+      out.push({ role: message.role, content: resolveUserContent(message) })
       continue
     }
     if (message.role === 'tool_use') {

package/src/tools/changeDirectoryTool.ts

@@ -32,7 +32,7 @@ export const changeDirectoryTool: Tool<typeof schema> = {
       path: fullPath,
       relativePath: path.relative(context.workspaceRoot, fullPath) || path.basename(fullPath),
       directoryPath: path.dirname(fullPath),
-      title: 'allow directory change?',
+      title: 'Allow directory change?',
       subtitle: fullPath,
     }
   },

package/src/tools/contracts.ts

@@ -48,6 +48,16 @@ export type PermissionRequest =
       file: 'SOUL.md' | 'MEMORY.md'
       range: string
     }
+  | {
+      kind: 'private-skill-read'
+      path: string
+      relativePath: string
+      directoryPath: string
+      title: string
+      subtitle: string
+      skillName: string
+      mode: 'list' | 'read'
+    }
   | {
       kind: 'private-continuity-edit'
       path: string

package/src/tools/deleteFileTool.ts

@@ -32,7 +32,7 @@ export const deleteFileTool: Tool<typeof schema> = {
       path: prepared.fullPath,
       relativePath: prepared.relativePath,
       directoryPath: path.dirname(prepared.fullPath),
-      title: 'allow file delete?',
+      title: 'Allow file delete?',
       subtitle: prepared.fullPath,
       before: preview(prepared.before),
       after: '(deleted)',

package/src/tools/editTool.ts

@@ -41,7 +41,7 @@ export const editTool: Tool<typeof schema> = {
       path: fullPath,
       relativePath,
       directoryPath: path.dirname(fullPath),
-      title: 'allow file edit?',
+      title: 'Allow file edit?',
       subtitle: fullPath,
       before: applied.previewBefore,
       after: applied.previewAfter,

package/src/tools/listDirectoryTool.ts

@@ -31,7 +31,7 @@ export const listDirectoryTool: Tool<typeof schema> = {
       path: fullPath,
       relativePath,
       directoryPath: fullPath,
-      title: 'allow directory listing?',
+      title: 'Allow directory listing?',
       subtitle: fullPath,
     }
   },

package/src/tools/listSkillFilesTool.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod'
+import path from 'node:path'
+import {
+  continuityVaultRef,
+} from '../identity/continuity/storage.js'
+import { listSkillFiles } from '../identity/continuity/skills/loadSkills.js'
+import type { Tool } from './contracts.js'
+
+const schema = z.object({
+  name: z.string().min(1),
+})
+
+export const listSkillFilesTool: Tool<typeof schema> = {
+  name: 'list_private_skill_files',
+  kind: 'private-continuity-read',
+  readOnly: true,
+  description: [
+    'List every file inside a private skill folder for the active identity.',
+    'Returns each file as `- <relativePath> (<bytes>) — <absolutePath>`, including SKILL.md and any supporting files (references, examples, scripts).',
+    'Use this after list_private_skills shows a skill with `(+N supporting files)` to discover what is available, then call read_private_skill with `file` to load text content.',
+    'Pass the absolute path directly to run_bash to execute supporting scripts (e.g. `python "<absolutePath>" <args>`).',
+  ].join(' '),
+  inputSchema: schema,
+  inputSchemaJson: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Skill folder name from the private skills index.' },
+    },
+    required: ['name'],
+    additionalProperties: false,
+  },
+  parse(input) {
+    return schema.parse(input)
+  },
+  async buildPermissionRequest(input, context) {
+    const identity = context.config?.identity
+    if (!identity) throw new Error('No active identity; create or load an identity before listing private skill files')
+    const ref = continuityVaultRef(identity)
+    const folder = input.name.replace(/^.*:/, '')
+    const skillDir = path.join(ref.skillsDir, folder)
+    return {
+      kind: 'private-skill-read',
+      path: skillDir,
+      relativePath: `identity-vault/skills/${folder}`,
+      directoryPath: skillDir,
+      title: 'Allow private skill folder list?',
+      subtitle: `List files in ${folder}/`,
+      skillName: input.name,
+      mode: 'list',
+    }
+  },
+  async execute(input, context) {
+    const identity = context.config?.identity
+    if (!identity) {
+      return { ok: false, summary: 'no active identity', content: 'No active identity; cannot list private skill files.' }
+    }
+    try {
+      const folder = input.name.replace(/^.*:/, '')
+      const files = await listSkillFiles(identity, folder)
+      if (files.length === 0) {
+        return { ok: true, summary: `no files in ${folder}`, content: `Skill folder ${folder}/ is empty or does not exist.` }
+      }
+      const lines = files.map(f => `- ${f.relativePath} (${f.sizeBytes} bytes) — ${f.absolutePath}`)
+      return {
+        ok: true,
+        summary: `listed ${files.length} file${files.length === 1 ? '' : 's'} in ${folder}`,
+        content: lines.join('\n'),
+      }
+    } catch (err: unknown) {
+      return {
+        ok: false,
+        summary: 'list failed',
+        content: (err as Error).message,
+      }
+    }
+  },
+}

package/src/tools/listSkillsTool.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod'
+import {
+  continuityVaultRef,
+} from '../identity/continuity/storage.js'
+import { listSkillsTree } from '../identity/continuity/skills/loadSkills.js'
+import type { Tool } from './contracts.js'
+
+const schema = z.object({})
+
+export const listSkillsTool: Tool<typeof schema> = {
+  name: 'list_private_skills',
+  kind: 'private-continuity-read',
+  readOnly: true,
+  description: [
+    'List private skills available in the owner-authored skills tree for the active identity.',
+    'Returns each skill folder name with its one-line description; bodies are loaded separately via read_private_skill.',
+    'When a skill has supporting files beyond SKILL.md, the entry is annotated with (+N supporting files) so you know to call list_private_skill_files.',
+    'Use this when the user mentions a skill not in the injected skill index, or to discover what skills exist.',
+  ].join(' '),
+  inputSchema: schema,
+  inputSchemaJson: {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+  },
+  parse(input) {
+    return schema.parse(input ?? {})
+  },
+  async buildPermissionRequest(_input, context) {
+    const identity = context.config?.identity
+    if (!identity) throw new Error('No active identity; create or load an identity before listing private skills')
+    const ref = continuityVaultRef(identity)
+    return {
+      kind: 'private-skill-read',
+      path: ref.skillsDir,
+      relativePath: 'identity-vault/skills',
+      directoryPath: ref.skillsDir,
+      title: 'Allow private skills index read?',
+      subtitle: 'List skill names and descriptions from the private skills tree',
+      skillName: '*',
+      mode: 'list',
+    }
+  },
+  async execute(_input, context) {
+    const identity = context.config?.identity
+    if (!identity) {
+      return { ok: false, summary: 'no active identity', content: 'No active identity; cannot list private skills.' }
+    }
+    const { skills, supportingCounts } = await listSkillsTree(identity)
+    if (skills.length === 0) {
+      return { ok: true, summary: 'no private skills', content: 'The private skills tree is empty.' }
+    }
+    const lines = skills.map(entry => {
+      const display = entry.displayName ?? entry.name
+      const desc = entry.description ? ` — ${entry.description}` : ''
+      const when = entry.whenToUse ? ` (when: ${entry.whenToUse})` : ''
+      const vis = entry.visibility !== 'private' ? ` [visibility: ${entry.visibility}]` : ''
+      const supporting = supportingCounts[entry.name] ?? 0
+      const trailer = supporting > 0 ? ` (+${supporting} supporting file${supporting === 1 ? '' : 's'})` : ''
+      return `- ${display}${desc}${when}${vis}${trailer}`
+    })
+    return {
+      ok: true,
+      summary: `listed ${skills.length} private skill${skills.length === 1 ? '' : 's'}`,
+      content: lines.join('\n'),
+    }
+  },
+}

package/src/tools/mcpResourceTools.ts

@@ -30,7 +30,7 @@ export const listMcpResourcesTool: Tool<typeof ListMcpResourcesInput> = {
     const serverName = input.server ?? '*'
     return {
       kind: 'mcp',
-      title: 'allow MCP resource listing?',
+      title: 'Allow MCP resource listing?',
       subtitle: input.server ? `list resources from ${input.server}` : 'list resources from all connected MCP servers',
       serverName,
       normalizedServerName: normalizeNameForMcp(serverName),
@@ -72,7 +72,7 @@ export const readMcpResourceTool: Tool<typeof ReadMcpResourceInput> = {
   async buildPermissionRequest(input) {
     return {
       kind: 'mcp',
-      title: 'allow MCP resource read?',
+      title: 'Allow MCP resource read?',
       subtitle: `${input.server} / ${input.uri}`,
       serverName: input.server,
       normalizedServerName: normalizeNameForMcp(input.server),

package/src/tools/privateContinuityReadTool.ts

@@ -43,7 +43,7 @@ export const privateContinuityReadTool: Tool<typeof schema> = {
       path: prepared.fullPath,
       relativePath: prepared.relativePath,
       directoryPath: prepared.directoryPath,
-      title: 'allow private continuity read?',
+      title: 'Allow private continuity read?',
       subtitle: input.startLine || input.endLine
         ? `${prepared.fullPath} · lines ${input.startLine ?? 1}-${input.endLine ?? 'end'}`
         : prepared.fullPath,