fix(llm): stop leaking instruction prompts instead of processed text

Running a custom instruction (translate, summarise, rewrite, explain code,
free prompt) inserted the instruction's own wording instead of the result.
Two faults stacked:

The instruction was passed as the text to process, leaving the system-prompt
argument empty. `BASE_SYSTEM_PROMPTS` has no `custom` key, so resolution fell
back to `refine` without saying so, and the model dutifully polished the
instruction it had been handed. The transcript never reached it.

And only `{{text}}` was substituted, which none of the five built-in
instructions use — they carry `{{targetLanguage}}`, `{{userPrompt}}`, or no
placeholder at all. The substitution was a no-op from the day it was written:
the presets landed ten hours before the code that expected them.

- Instruction prompts now go to the system-prompt argument and the transcript
  to the text argument. Instructions that spell out `{{text}}` keep their old
  meaning, so hand-written ones still work.
- `renderInstructionPrompt` resolves `{{text}}`, `{{userPrompt}}` and
  `{{targetLanguage}}` in one place, and warns by name when a placeholder is
  left standing rather than letting it reach the model.
- `resolveSystemPrompt` no longer drops silently to `refine` for `custom`.
- Voice shortcuts no longer die at the `defaultLLMAction === 'none'` gate; an
  explicitly named instruction outranks the default. Without one, `none` still
  passes the transcript through untouched.
- `translate` receives its target language instead of relying on a default two
  call frames away. It is still always English — `AppConfig` has no key for it,
  and neither `language` (UI locale) nor `sttLanguage` (source language) can
  stand in. Choosing a target language needs a setting and is not in this fix.
- Chains ran instructions with placeholders intact; they share the same
  resolution now.
- The command screen's pipeline bench called `llm.generate`, which preload does
  not expose, so every run threw and the catch showed the input back as if it
  had succeeded. It uses `llm.process` now, over the same path production
  takes, and a failure reads as a failure.

Present since the feature shipped: the custom-instruction path has never
worked. Plain actions (refine, summarise, grammar, expand) were unaffected and
are now covered by tests so they stay that way.

apps/desktop/src/main/services/VoiceModeService.ts

@@ -18,6 +18,7 @@ import type { KeyBindingTriggerPayload } from './KeyBindingService'
 import { configGet } from './ConfigService'
 import { getTextInsertService } from './TextInsertService'
 import { getLocalLLMService } from './LocalLLMService'
+import { buildInstructionInvocation, resolveTargetLanguage } from './llm-prompts'
 import { D3ROError, ErrorCode } from '@d3ro/core/errors'
 import { TIMING } from '@d3ro/core/constants'
 import { RecognitionState, AudioState } from '@d3ro/core/types'
@@ -772,12 +773,17 @@ class VoiceModeService extends EventEmitter {
     if (this._isInTerminalState()) return
 
     try {
-      const action = configGet('defaultLLMAction')
-      if (action === 'none') {
+      const configuredAction = configGet('defaultLLMAction')
+      // 음성 단축키가 특정 명령을 지목해 들어왔다면 기본 액션이 'none'이어도 처리한다.
+      // 명시적 요청을 기본 설정이 무효화하면 안 된다.
+      if (configuredAction === 'none' && !overrideInstructionId) {
         this._completeSession(transcribedText)
         return
       }
 
+      // 여기서 'none'이 남아 있다면 overrideInstructionId가 반드시 있다 → custom 경로.
+      const action: LLMAction = configuredAction === 'none' ? 'custom' : configuredAction
+
       // Phase 10.2: 스크린 컨텍스트를 LLM 프롬프트에 주입
       let contextPrefix = ''
       if (this._session?.screenContext) {
@@ -818,22 +824,49 @@ class VoiceModeService extends EventEmitter {
       const effectiveInstructionId = overrideInstructionId
         ?? configGet('activeInstructionId')
 
+      const targetLanguage = resolveTargetLanguage()
+
       if (action === 'custom' || overrideInstructionId) {
-        let customPrompt = contextPrefix + transcribedText
+        const userText = contextPrefix + transcribedText
+        let invocationText = userText
+        let instructionPrompt: string | undefined
 
         if (effectiveInstructionId) {
           const { getCustomInstructionService } = await import('./CustomInstructionService')
           const instruction = getCustomInstructionService().getById(effectiveInstructionId)
           if (instruction) {
-            customPrompt = instruction.prompt.replace(/\{\{text\}\}/g, contextPrefix + transcribedText)
+            const invocation = buildInstructionInvocation(
+              instruction.prompt,
+              userText,
+              targetLanguage,
+            )
+            invocationText = invocation.text
+            instructionPrompt = invocation.systemPrompt
             logger.info(`Using custom instruction: "${instruction.name}"`)
+          } else {
+            logger.warn(
+              `Custom instruction not found: ${effectiveInstructionId} — processing without an instruction`,
+            )
           }
         }
 
-        processedText = await this._runProcessorWithFallback(customPrompt, 'custom')
+        processedText = await this._runProcessorWithFallback(
+          invocationText,
+          'custom',
+          undefined,
+          instructionPrompt,
+        )
       } else {
-        logger.info(`Processing with LLM (action: ${action})`)
-        processedText = await this._runProcessorWithFallback(contextPrefix + transcribedText, action)
+        logger.info(
+          action === 'translate'
+            ? `Processing with LLM (action: ${action}, targetLanguage: ${targetLanguage})`
+            : `Processing with LLM (action: ${action})`,
+        )
+        processedText = await this._runProcessorWithFallback(
+          contextPrefix + transcribedText,
+          action,
+          action === 'translate' ? targetLanguage : undefined,
+        )
       }
 
       if (this._isInTerminalState()) return