Tolk

1// Tolk: Claude Code's interface in your language.
2//
3// It changes only what Claude Code draws and lists, never what the model
4// reads: command descriptions in the typeahead, /config labels, the
5// spinner, the line that closes a turn, the hint line under the prompt,
6// the folded line for a run of searches and reads, footer mode labels and
7// the notices under the logo. Anything it has no translation for stays
8// exactly as Claude Code drew it.
9
10import type { EngineInterface, Register } from 'claude-code'
11
12import { CODES, LOCALES, SOURCE } from './locales/index'
13import type { Locale } from './locales/types'
14import { fill, formatDuration, groupLine, pick, resolveCode, tallyCalls, translateHint, translatePhrases } from './translate'
15
16const PLUGIN = 'tolk'
17const CONFIG_KEY = 'tolk.language'
18const LANGUAGE_PANE = 'tolk-language'
19const SPINNER_WORDS: ReadonlySet<string> = new Set(SOURCE.spinner)
20const TURN_WORDS: ReadonlySet<string> = new Set(SOURCE.turn.words)
21
22/**
23 * Built-in commands Tolk leaves in English on purpose: internal ones,
24 * and skill guides whose description is written for Claude to decide when
25 * to load them rather than for you to read.
26 */
27const LEFT_IN_ENGLISH: ReadonlySet<string> = new Set([
28  '__remote-workflow', 'workflow-launch-exec', 'heapdump', 'agents',
29  'artifact-capabilities', 'artifact-design', 'artifact-diagramming', 'claude-api', 'cowork-plugin',
30  'dataviz', 'design-sync', 'explain-usage', 'keybindings-help', 'plugin-authoring', 'run',
31  'run-skill-generator', 'setup-claude', 'update-config',
32])
33
34/**
35 * Built-in commands whose description is a live status line
36 * (`◯ sandbox disabled (⏎ to configure)`), translated phrase by phrase.
37 */
38const STATUS_LINES: ReadonlySet<string> = new Set(['sandbox'])
39
40/** A command or /config row Claude Code itself provides, or a plugin it ships with. */
41function isClaudeCodes(provider: { readonly plugin: string; readonly tier: string }): boolean {
42  return provider.plugin === 'engine' || provider.tier === 'core' || provider.tier === 'builtin'
43}
44
45/** Whether the locale has something to draw for command `name`. */
46function translatesCommand(loc: Locale, name: string): boolean {
47  return STATUS_LINES.has(name) || loc.commands[name] !== undefined
48}
49
50/**
51 * `translated` in place of `base`, carrying over the live detail Claude
52 * Code appends in parentheses (`Toggle fast mode (Opus 5.5)`).
53 */
54function withDetail(translated: string, base: string | undefined, english: string): string {
55  if (base !== undefined && english !== base && english.startsWith(`${base} (`)) {
56    return translated + english.slice(base.length)
57  }
58  return translated
59}
60
61/** Whether `text` is one of the English descriptions the catalog knows for `name`. */
62function isKnownEnglish(name: string, text: string): boolean {
63  const base = SOURCE.commands[name]
64  if (SOURCE.byText?.[text] !== undefined) return true
65  return base !== undefined && (text === base || text.startsWith(`${base} (`))
66}
67
68/**
69 * The translation of one command's description, or `undefined`. A wording
70 * that depends on the situation is looked up by its text; a live detail
71 * Claude Code appends in parentheses (`Toggle fast mode (Opus 5.5)`) is
72 * carried over.
73 */
74function describeCommand(loc: Locale, name: string, english: string): string | undefined {
75  const exact = loc.byText?.[english]
76  if (exact !== undefined) return exact
77  if (STATUS_LINES.has(name)) {
78    const line = translatePhrases(english, loc)
79    return line === english ? undefined : line
80  }
81  const translated = loc.commands[name]
82  return translated === undefined ? undefined : withDetail(translated, SOURCE.commands[name], english)
83}
84
85/**
86 * Writes `code` as the interface language and returns the confirmation line.
87 * `apply` stores the locale the rest of the session draws with.
88 */
89async function choose(
90  $: EngineInterface,
91  code: string,
92  apply: (next: Locale | undefined) => void,
93): Promise<string> {
94  const set = await $.config.set({ key: CONFIG_KEY, value: code })
95  if (set.deny !== undefined) return set.deny
96  const next = LOCALES[code]
97  apply(next)
98  refresh($)
99  return fill((next ?? SOURCE).ui.switched, { name: next?.name ?? code })
100}
101
102/** Redraws everything Tolk touches, after the language changed. */
103function refresh($: EngineInterface): void {
104  $.ui.invalidate('command.describe')
105  $.ui.invalidate('config.describe')
106  $.ui.invalidate('ui.render')
107}
108
109/** Reads one variable; a variable that can't be read is just not a hint. */
110async function readEnv($: EngineInterface, name: 'LC_ALL' | 'LC_MESSAGES' | 'LANGUAGE' | 'LANG'): Promise<string | undefined> {
111  try {
112    // `$.env.get` takes its name as a literal, so each one is spelled out.
113    const value =
114      name === 'LC_ALL'
115        ? await $.env.get('LC_ALL')
116        : name === 'LC_MESSAGES'
117          ? await $.env.get('LC_MESSAGES')
118          : name === 'LANGUAGE'
119            ? await $.env.get('LANGUAGE')
120            : await $.env.get('LANG')
121    // LANGUAGE is a list (`de:en`): its first entry is the preference.
122    return value?.split(':')[0]
123  } catch {
124    return undefined
125  }
126}
127
128/**
129 * The language `auto` resolves to: Claude Code's own `language` setting
130 * first (the one replies follow), then the system locale.
131 */
132async function detectCode($: EngineInterface): Promise<string | undefined> {
133  const candidates: Array<string | undefined> = []
134  try {
135    const row = (await $.config.list()).find(r => r.key === 'language')
136    candidates.push(typeof row?.value === 'string' ? row.value : undefined)
137  } catch {
138    // No /config here (a headless run): fall through to the environment.
139  }
140  candidates.push(await readEnv($, 'LC_ALL'))
141  candidates.push(await readEnv($, 'LC_MESSAGES'))
142  candidates.push(await readEnv($, 'LANGUAGE'))
143  candidates.push(await readEnv($, 'LANG'))
144  for (const raw of candidates) {
145    const code = resolveCode(raw, CODES)
146    if (code !== undefined) return code
147  }
148  return undefined
149}
150
151export const register: Register = (on, options) => {
152  const setting = typeof options.language === 'string' ? options.language : 'auto'
153
154  // The language in force; `undefined` (or English) means draw as Claude Code does.
155  let locale: Locale | undefined = setting === 'auto' ? undefined : LOCALES[setting]
156  // English command descriptions as Claude Code declared them, for `/tolk missing`.
157  const english = new Map<string, string>()
158
159  const active = (): Locale | undefined =>
160    locale !== undefined && locale.code !== 'en' ? locale : undefined
161  const ui = () => (locale ?? SOURCE).ui
162
163  const languageList = (): string => {
164    const rows = CODES.map(code => {
165      const one = LOCALES[code]
166      const mark = (locale?.code ?? 'en') === code ? '●' : '○'
167      return `${mark} \`${code}\` ${one?.name ?? code}`
168    })
169    return [ui().available, ...rows].join('\n')
170  }
171
172  const apply = (next: Locale | undefined) => {
173    locale = next
174  }
175
176  on('session.start', async ($, e, next) => {
177    if (setting === 'auto') {
178      const code = await detectCode($)
179      if (code !== undefined) locale = LOCALES[code]
180    }
181    await $.command.register({
182      name: 'tolk',
183      description: ui().commandDescription,
184      argumentHint: '[list | set <code> | missing]',
185    })
186    refresh($)
187    return next(e)
188  })
189
190  // ── Lists: the command typeahead and /config ──────────────────────────
191
192  on('command.describe', async ($, e, next) => {
193    if (isClaudeCodes(e.provider)) english.set(e.command, e.description)
194    const described = await next(e)
195    const loc = active()
196    if (loc === undefined) return described
197    if (e.command === PLUGIN) return { ...described, description: loc.ui.commandDescription }
198    // Leave alone what another plugin already rewrote, and what isn't Claude Code's.
199    if (!isClaudeCodes(e.provider) || described.description !== e.description) return described
200    if (LEFT_IN_ENGLISH.has(e.command)) return described
201    const translated = describeCommand(loc, e.command, e.description)
202    return translated === undefined ? described : { ...described, description: translated }
203  })
204
205  on('config.describe', async ($, e, next) => {
206    const described = await next(e)
207    const loc = active()
208    if (loc === undefined) return described
209    if (e.key === CONFIG_KEY) return { ...described, label: loc.ui.configLabel }
210    if (!isClaudeCodes(e.provider) || described.label !== e.label) return described
211    const translated = loc.config[e.key]
212    if (translated === undefined) return described
213    return { ...described, label: withDetail(translated, SOURCE.config[e.key], e.label) }
214  })
215
216  // ── What Claude Code draws ────────────────────────────────────────────
217
218  on('ui.render', { component: 'Spinner' }, async ($, e, next) => {
219    const loc = active()
220    if (loc === undefined) return next(e)
221    const { word, message } = e.props
222    // Only Claude Code's own words: a custom `spinnerVerbs` setting stays.
223    const localWord = SPINNER_WORDS.has(word) ? (pick(loc.spinner, word) ?? word) : word
224    const localMessage = message === null ? null : translatePhrases(message, loc)
225    if (localWord === word && localMessage === message) return next(e)
226    return next({ ...e, props: { ...e.props, word: localWord, message: localMessage } })
227  })
228
229  on('ui.render', { component: 'TurnDuration' }, async ($, e, next) => {
230    const loc = active()
231    if (loc === undefined || !TURN_WORDS.has(e.props.word)) return next(e)
232    const { Text } = $.ui.resolve(e)
233    const word = pick(loc.turn.words, e.props.word + e.requestId) ?? e.props.word
234    const line = fill(loc.turn.template, { word, duration: formatDuration(e.props.durationMs, loc) })
235    return Text({ dimColor: true, children: [`✻ ${line}`] })
236  })
237
238  on('ui.render', { component: 'PromptHint' }, async ($, e, next) => {
239    const loc = active()
240    if (loc === undefined) return next(e)
241    const hint = translateHint(e.props.hint, loc)
242    // A rewritten hint replaces the whole line, so only do it when it pays.
243    return hint === e.props.hint ? next(e) : next({ ...e, props: { ...e.props, hint } })
244  })
245
246  on('ui.render', { component: 'ToolGroup' }, async ($, e, next) => {
247    const loc = active()
248    if (loc === undefined || e.surface !== 'terminal' || e.props.isActive || e.props.isExpanded) return next(e)
249    const { calls } = e.props
250    // Only a finished run of plain searches, reads and listings: any other
251    // call adds what the props don't carry (diffs, commits, memories).
252    const clean = calls.length > 0 && calls.every(c => !c.isRunning && !c.isErrored && !c.isInterrupted)
253    const tally = clean ? tallyCalls(calls) : undefined
254    if (tally === undefined) return next(e)
255    const { Box, Text } = $.ui.resolve(e)
256    const line = groupLine(tally, loc).map(s => (s.bold ? Text({ bold: true, children: [s.text] }) : s.text))
257    // ctrl+o is Claude Code's default; a mod cannot read a rebound key.
258    const expand = fill(loc.phrases.toExpand ?? '(ctrl+o to expand)', { 1: 'ctrl+o' })
259    return Box({
260      flexDirection: 'row',
261      children: [Box({ minWidth: 2 }), Text({ color: 'inactive', children: [...line, ` ${expand}`] })],
262    })
263  })
264
265  on('ui.render', { component: 'ToolProgress' }, async ($, e, next) => {
266    const loc = active()
267    if (loc === undefined) return next(e)
268    const hint = translatePhrases(e.props.hint, loc)
269    return hint === e.props.hint ? next(e) : next({ ...e, props: { ...e.props, hint } })
270  })
271
272  on('ui.render', { component: 'InfoNotice' }, async ($, e, next) => {
273    const loc = active()
274    if (loc === undefined) return next(e)
275    const text = translatePhrases(e.props.text, loc)
276    return text === e.props.text ? next(e) : next({ ...e, props: { ...e.props, text } })
277  })
278
279  on('ui.render', { component: 'SessionMode' }, async ($, e, next) => {
280    const loc = active()
281    if (loc === undefined || e.props.modes.length === 0) return next(e)
282    const modes = e.props.modes.map(mode => loc.modes[mode] ?? mode)
283    return modes.every((mode, i) => mode === e.props.modes[i])
284      ? next(e)
285      : next({ ...e, props: { ...e.props, modes } })
286  })
287
288  // ── /tolk ─────────────────────────────────────────────────────────
289
290  on('ui.render', { component: 'Pane' }, async ($, e, next) => {
291    if (e.requestId !== LANGUAGE_PANE) return next(e)
292    const current = locale?.code ?? 'en'
293    const { Box, Button } = $.ui.resolve(e)
294    // A pick answers the dialog: close it with the press, then switch.
295    const picked = async (code: string) => {
296      await $.ui.close({ id: LANGUAGE_PANE }).catch(() => undefined)
297      $.ui.log(await choose($, code, apply))
298    }
299    return Box({
300      flexDirection: 'column',
301      children: CODES.map(code =>
302        Button({
303          key: code,
304          plain: true,
305          label: `${code === current ? '●' : '○'} ${code}  ${LOCALES[code]?.name ?? code}`,
306          ...(code === current ? { autoFocus: true as const } : {}),
307          onPress: () => picked(code),
308        }),
309      ),
310    })
311  })
312
313  on('command.run', { command: 'tolk' }, async ($, e) => {
314    const [verb = '', arg = ''] = e.args.trim().split(/\s+/)
315    const strings = ui()
316    const codes = CODES.join(', ')
317
318    if (verb === 'list') return { text: languageList() }
319
320    if (verb === 'set') {
321      if (arg === '') {
322        const opened = await $.ui.open({
323          id: LANGUAGE_PANE,
324          title: strings.available.replace(/[:：]\s*$/, '').trim(),
325          focus: true,
326          closeOnEscape: true,
327          rows: CODES.length,
328        })
329        // A narrow terminal or a headless run cannot show the pane.
330        return opened.isPlaced ? {} : { text: languageList() }
331      }
332      const code = resolveCode(arg, CODES)
333      if (code === undefined) return { text: fill(strings.unknown, { code: arg, codes }) }
334      return { text: await choose($, code, apply) }
335    }
336
337    const commands = (await $.command.list()).filter(
338      c => c.source === 'builtin' && !LEFT_IN_ENGLISH.has(c.name),
339    )
340    const loc = locale ?? SOURCE
341
342    if (verb === 'missing') {
343      const untranslated = loc.code === 'en' ? [] : commands.filter(c => !translatesCommand(loc, c.name))
344      const drifted = [...english].filter(
345        ([name, text]) => SOURCE.commands[name] !== undefined && !isKnownEnglish(name, text),
346      )
347      if (untranslated.length === 0 && drifted.length === 0) return { text: strings.missingNone }
348      const lines: string[] = []
349      if (untranslated.length > 0) {
350        lines.push(strings.missingHeader)
351        for (const c of untranslated) lines.push(`- \`/${c.name}\`: ${english.get(c.name) ?? c.description}`)
352      }
353      if (drifted.length > 0) {
354        if (lines.length > 0) lines.push('')
355        lines.push(strings.driftHeader)
356        for (const [name, text] of drifted) lines.push(`- \`/${name}\`: ${text}`)
357      }
358      return { text: lines.join('\n') }
359    }
360
361    if (verb !== '') return { text: fill(strings.usage, { codes }) }
362
363    const settings = (await $.config.list()).filter(row => isClaudeCodes(row.provider))
364    const status = fill(strings.status, { name: loc.name, code: loc.code })
365    if (loc.code === 'en') return { text: `${status}\n${fill(strings.usage, { codes })}` }
366    const coverage = fill(strings.coverage, {
367      commands: commands.filter(c => translatesCommand(loc, c.name)).length,
368      commandsTotal: commands.length,
369      settings: settings.filter(row => loc.config[row.key] !== undefined).length,
370      settingsTotal: settings.length,
371    })
372    return { text: `${status}\n${coverage}\n${fill(strings.usage, { codes })}` }
373  })
374}
375

1// Every language Tolk ships. To add one: create `<code>.ts` next to
2// this file (copy de.ts), import it here, and add its code to the
3// `options` of `language` in .claude-plugin/plugin.json.
4
5import de from './de'
6import en from './en'
7import es from './es'
8import fr from './fr'
9import it from './it'
10import ja from './ja'
11import ptBR from './pt-BR'
12import vi from './vi'
13import zhCN from './zh-CN'
14import type { Locale } from './types'
15
16export const SOURCE: Locale = en
17
18export const LOCALES: Readonly<Record<string, Locale>> = {
19  en,
20  de,
21  es,
22  fr,
23  it,
24  'pt-BR': ptBR,
25  ja,
26  'zh-CN': zhCN,
27  vi,
28}
29
30export const CODES: readonly string[] = Object.keys(LOCALES)
31

1// The shape every language file fills in. Copy `de.ts` to start a new
2// language; every field except `code`, `name` and `ui` may be partial, and
3// anything left out simply stays in English.
4
5/** The hint and notice phrases Tolk recognises (see ../phrases.ts). */
6export type PhraseId =
7  | 'shortcuts'
8  | 'shellMode'
9  | 'escInterrupt'
10  | 'escAgainClear'
11  | 'doubleEscClear'
12  | 'pressAgainExit'
13  | 'editQueued'
14  | 'acceptEdits'
15  | 'planMode'
16  | 'autoMode'
17  | 'bypassPermissions'
18  | 'manualMode'
19  | 'forAgents'
20  | 'toCycle'
21  | 'toExpand'
22  | 'runInBackground'
23  | 'pasteToExpand'
24  | 'toStop'
25  | 'holdToSpeak'
26  | 'sandboxEnabled'
27  | 'sandboxDisabled'
28  | 'sandboxAutoAllow'
29  | 'sandboxFallback'
30  | 'sandboxManaged'
31  | 'toConfigure'
32
33/** Tolk's own messages, shown by the /tolk command. */
34export type UiStrings = {
35  /** `{name}` the language's own name, `{code}` its code. */
36  status: string
37  /** `{commands}`, `{commandsTotal}`, `{settings}`, `{settingsTotal}`. */
38  coverage: string
39  /** Heading above the list of languages. */
40  available: string
41  /** `{name}` the language switched to. */
42  switched: string
43  /** `{code}` the code given, `{codes}` the codes there are. */
44  unknown: string
45  /** Shown when every command on screen has a translation. */
46  missingNone: string
47  /** Heading above untranslated commands. */
48  missingHeader: string
49  /** Heading above commands whose English changed since the translation. */
50  driftHeader: string
51  /** The /tolk usage text; `{codes}` the language codes. */
52  usage: string
53  /** The /tolk command's own description in the command list. */
54  commandDescription: string
55  /** Label of Tolk's row in /config. */
56  configLabel: string
57}
58
59/** A text in the singular (`n` is 1) and in the plural. */
60export type Plural = { one: string; other: string }
61
62export type Locale = {
63  /** BCP 47 code, matching the file name: `de`, `pt-BR`, `zh-CN`. */
64  code: string
65  /** The language's name in itself: `Deutsch`, `日本語`. */
66  name: string
67  /** Contributors, as GitHub handles. */
68  credits?: string[]
69  /** Slash command name (no slash) → its description in the command list. */
70  commands: Record<string, string>
71  /**
72   * Exact English description → translation, for the commands whose
73   * description changes with the situation (`/config` reads "Open
74   * settings" in a terminal and "Set a setting by key" headless).
75   * Checked before `commands`.
76   */
77  byText?: Record<string, string>
78  /** /config row key → its label. */
79  config: Record<string, string>
80  /** Phrase id → template. `{1}` stands for the key binding the phrase names. */
81  phrases: Partial<Record<PhraseId, string>>
82  /** Footer mode label (as Claude Code draws it) → translation. */
83  modes: Record<string, string>
84  /** Playful words for the spinner while Claude works ("Baking…"). */
85  spinner: string[]
86  /** The line that closes a turn ("Baked for 3s"). */
87  turn: {
88    /** Past-tense words, one is picked per turn. */
89    words: string[]
90    /** `{word}` and `{duration}`. */
91    template: string
92  }
93  /**
94   * The line a finished run of searches, reads and listings folds into
95   * ("Searched for 2 patterns, read 3 files"). Each part is written as it
96   * reads mid-line; the line's first letter is capitalised. `{n}` is the
97   * count, drawn bold.
98   */
99  group: {
100    searched: Plural
101    read: Plural
102    listed: Plural
103    /** Between the two parts (`, `). */
104    separator: string
105  }
106  /** Units for durations: `1h 2m 3s` in English. */
107  duration: { h: string; m: string; s: string; separator: string }
108  ui: UiStrings
109}
110

1// Pure helpers: no `$`, so the tests can exercise them directly.
2
3import type { Locale, PhraseId } from './locales/types'
4
5/**
6 * The English phrases Claude Code puts in the hint line under the prompt,
7 * the run-in-background pill, the notices under the logo and the spinner.
8 * A capture group is the key binding the phrase names, kept as the user
9 * bound it and handed to the template as `{1}`.
10 */
11export const PHRASES: ReadonlyArray<readonly [PhraseId, RegExp]> = [
12  ['pressAgainExit', /Press (\S+) again to exit/gi],
13  ['doubleEscClear', /double tap esc to clear input/gi],
14  ['escAgainClear', /\bEsc again to clear\b/gi],
15  ['escInterrupt', /\besc to interrupt\b/gi],
16  ['editQueued', /Press up to edit queued messages/gi],
17  ['runInBackground', /\(([^()\s]+) to run in background\)/gi],
18  ['toCycle', /\(([^()\s]+) to cycle\)/gi],
19  ['toExpand', /\(([^()\s]+) to expand\)/gi],
20  ['pasteToExpand', /paste again to expand/gi],
21  ['shortcuts', /\? for shortcuts/g],
22  ['forAgents', /← for agents/g],
23  ['shellMode', /! for shell mode/g],
24  ['acceptEdits', /\baccept edits on\b/gi],
25  ['planMode', /\bplan mode on\b/gi],
26  ['autoMode', /\bauto mode on\b/gi],
27  ['bypassPermissions', /\bbypass permissions on\b/gi],
28  ['manualMode', /\bmanual mode on\b/gi],
29  ['toStop', /\b(ctrl\+\S+) to stop\b/gi],
30  ['holdToSpeak', /\bhold (\S+) to speak\b/gi],
31  // The /sandbox description, a status line: `◯ sandbox disabled (⏎ to configure)`.
32  ['sandboxEnabled', /\bsandbox enabled\b/g],
33  ['sandboxDisabled', /\bsandbox disabled\b/g],
34  ['sandboxAutoAllow', /\(auto-allow\)/g],
35  ['sandboxFallback', /, fallback allowed\b/g],
36  ['sandboxManaged', /\(managed\)/g],
37  ['toConfigure', /\(⏎ to configure\)/g],
38]
39
40/** Fills `{name}` (and `{1}`) placeholders; unknown ones are left as typed. */
41export function fill(template: string, vars: Record<string, string | number>): string {
42  return template.replace(/\{(\w+)\}/g, (whole, name: string) =>
43    Object.prototype.hasOwnProperty.call(vars, name) ? String(vars[name]) : whole,
44  )
45}
46
47/**
48 * Replaces every phrase the locale translates. Returns the text unchanged
49 * (the same string) when nothing matched, so callers can tell and leave
50 * Claude Code's own drawing alone.
51 */
52export function translatePhrases(text: string, locale: Locale): string {
53  let out = text
54  for (const [id, pattern] of PHRASES) {
55    const template = locale.phrases[id]
56    if (template === undefined) continue
57    out = out.replace(pattern, (_whole, key?: string) =>
58      fill(template, { 1: typeof key === 'string' ? key : '' }),
59    )
60  }
61  return out
62}
63
64const LEADING_CYCLE = /^\(([^()\s]+) to cycle\)/i
65
66/**
67 * The hint line under the prompt. Claude Code draws the mode label
68 * (`⏵⏵ auto mode on`) itself and joins a rewritten hint to it with ` · `,
69 * so a cycle hint opening the line loses its parentheses and reads as a
70 * part of its own: `auto mode on · shift+tab zum Wechseln`.
71 */
72export function translateHint(text: string, locale: Locale): string {
73  const template = locale.phrases.toCycle
74  const lead = template === undefined ? null : LEADING_CYCLE.exec(text)
75  if (template === undefined || lead === null) return translatePhrases(text, locale)
76  const cycle = fill(template.replace(/^[(（]\s*/, '').replace(/\s*[)）]$/, ''), { 1: lead[1] ?? '' })
77  return cycle + translatePhrases(text.slice(lead[0].length), locale)
78}
79
80/** One piece of the folded tool line: plain text, or a count drawn bold. */
81export type Segment = { text: string; bold: boolean }
82
83/** How many searches, files read and directories listed a folded line counts. */
84export type Tally = { searches: number; reads: number; lists: number }
85
86// Claude Code 2.1.294's own sorting of shell commands for the folded line.
87const SEARCH_COMMANDS: ReadonlySet<string> = new Set(['find', 'grep', 'rg', 'ag', 'ack', 'locate', 'which', 'whereis'])
88const READ_COMMANDS: ReadonlySet<string> = new Set([
89  'cat', 'head', 'tail', 'less', 'more', 'wc', 'stat', 'file', 'strings', 'jq', 'awk', 'cut', 'sort', 'uniq', 'tr',
90])
91const LIST_COMMANDS: ReadonlySet<string> = new Set(['ls', 'tree', 'du'])
92const NEUTRAL_COMMANDS: ReadonlySet<string> = new Set(['echo', 'printf', 'true', 'false', ':'])
93
94/**
95 * The commands of a plain shell pipeline or list (`grep -n x f | head`), or
96 * `undefined` for anything a simple split could get wrong: substitutions,
97 * subshells, heredocs, several lines.
98 */
99function shellCommands(command: string): string[] | undefined {
100  if (/[\n`{}()]|\$\(|<</.test(command)) return undefined
101  const parts: string[] = []
102  let current = ''
103  let quote: string | undefined
104  for (let i = 0; i < command.length; i++) {
105    const c = command.charAt(i)
106    if (quote !== undefined) {
107      current += c
108      if (c === '\\' && quote === '"') current += command.charAt(++i)
109      else if (c === quote) quote = undefined
110    } else if (c === "'" || c === '"') {
111      quote = c
112      current += c
113    } else if (c === '\\') {
114      current += c + command.charAt(++i)
115    } else if (c === '|' || c === ';' || (c === '&' && !/[<>]/.test(command.charAt(i - 1)) && command.charAt(i + 1) !== '>')) {
116      if (command.charAt(i + 1) === c) i++
117      parts.push(current)
118      current = ''
119    } else {
120      current += c
121    }
122  }
123  if (quote !== undefined) return undefined
124  parts.push(current)
125  return parts.map(p => p.trim()).filter(p => p !== '')
126}
127
128/**
129 * What one call of a folded run adds to its line, as Claude Code counts it,
130 * or `undefined` when Tolk can't be sure. A file read counts once per path,
131 * so it comes back as `read:<path>`. Memory files (anything under `.claude/`)
132 * Claude Code counts as memories, so those are left to it too.
133 */
134export function foldedAs(tool: string, input: unknown): 'search' | 'list' | `read:${string}` | undefined {
135  const field = (name: string): string | undefined => {
136    const value = typeof input === 'object' && input !== null ? (input as Record<string, unknown>)[name] : undefined
137    return typeof value === 'string' ? value : undefined
138  }
139  const touchesMemory = (text: string | undefined) => text !== undefined && /(^|[\\/])\.claude[\\/]/.test(text)
140  if (tool === 'Read') {
141    const path = field('file_path')
142    return path === undefined || touchesMemory(path) ? undefined : `read:${path}`
143  }
144  if (tool === 'Grep' || tool === 'Glob') return touchesMemory(field('path')) ? undefined : 'search'
145  const command = tool === 'Bash' ? field('command') : undefined
146  if (command === undefined || touchesMemory(command)) return undefined
147  const words = shellCommands(command)?.map(part => part.split(/\s+/)[0] ?? '')
148  if (words === undefined) return undefined
149  let search = false
150  let list = false
151  let counted = false
152  for (const word of words) {
153    if (NEUTRAL_COMMANDS.has(word)) continue
154    if (!SEARCH_COMMANDS.has(word) && !READ_COMMANDS.has(word) && !LIST_COMMANDS.has(word)) return undefined
155    counted = true
156    search ||= SEARCH_COMMANDS.has(word)
157    list ||= LIST_COMMANDS.has(word)
158  }
159  // A shell read counts by paths Claude Code finds in the command; Tolk can't.
160  return !counted ? undefined : list ? 'list' : search ? 'search' : undefined
161}
162
163/** Adds up a folded run, or `undefined` when any call can't be counted. */
164export function tallyCalls(calls: ReadonlyArray<{ tool: string; input: unknown }>): Tally | undefined {
165  let searches = 0
166  let lists = 0
167  const paths = new Set<string>()
168  for (const call of calls) {
169    const kind = foldedAs(call.tool, call.input)
170    if (kind === undefined) return undefined
171    if (kind === 'search') searches++
172    else if (kind === 'list') lists++
173    else paths.add(kind)
174  }
175  return { searches, reads: paths.size, lists }
176}
177
178/** The folded line for a run, in pieces: searches, then reads, then listings. */
179export function groupLine({ searches, reads, lists }: Tally, locale: Locale): Segment[] {
180  const { group } = locale
181  const parts: Array<readonly [string, number]> = []
182  if (searches > 0) parts.push([searches === 1 ? group.searched.one : group.searched.other, searches])
183  if (reads > 0) parts.push([reads === 1 ? group.read.one : group.read.other, reads])
184  if (lists > 0) parts.push([lists === 1 ? group.listed.one : group.listed.other, lists])
185  const out: Segment[] = []
186  parts.forEach(([template, n], i) => {
187    const [before = '', after = ''] = template.split('{n}')
188    const lead = i === 0 ? before.charAt(0).toLocaleUpperCase(locale.code) + before.slice(1) : before
189    if (i > 0) out.push({ text: group.separator, bold: false })
190    out.push({ text: lead, bold: false }, { text: String(n), bold: true }, { text: after, bold: false })
191  })
192  return out.filter(s => s.text !== '')
193}
194
195/** A small, stable string hash (FNV-1a), so a pick never flickers. */
196export function hash(text: string): number {
197  let h = 0x811c9dc5
198  for (let i = 0; i < text.length; i++) {
199    h ^= text.charCodeAt(i)
200    h = Math.imul(h, 0x01000193)
201  }
202  return h >>> 0
203}
204
205/** Picks one entry of `list` for `seed`, the same one every time. */
206export function pick(list: readonly string[], seed: string): string | undefined {
207  if (list.length === 0) return undefined
208  return list[hash(seed) % list.length]
209}
210
211/** `64000` → `1m 4s` in the locale's units. */
212export function formatDuration(ms: number, locale: Locale): string {
213  const total = Math.max(0, Math.round(ms / 1000))
214  const h = Math.floor(total / 3600)
215  const m = Math.floor((total % 3600) / 60)
216  const s = total % 60
217  const { duration } = locale
218  const parts: string[] = []
219  if (h > 0) parts.push(`${h}${duration.h}`)
220  if (m > 0) parts.push(`${m}${duration.m}`)
221  if (s > 0 || parts.length === 0) parts.push(`${s}${duration.s}`)
222  return parts.join(duration.separator)
223}
224
225const NAMES: ReadonlyArray<readonly [string, readonly string[]]> = [
226  ['en', ['en', 'english', 'inglés', 'anglais', 'englisch', 'inglese']],
227  ['de', ['de', 'german', 'deutsch', 'alemán', 'allemand', 'tedesco', 'swiss german', 'schweizerdeutsch']],
228  ['es', ['es', 'spanish', 'español', 'espanol', 'castellano', 'castilian', 'spagnolo']],
229  ['fr', ['fr', 'french', 'français', 'francais', 'francese']],
230  ['it', ['it', 'italian', 'italiano', 'italienisch', 'italien']],
231  ['pt-BR', ['pt', 'pt-br', 'pt_br', 'portuguese', 'português', 'portugues', 'brazilian portuguese', 'português brasileiro']],
232  ['ja', ['ja', 'jp', 'japanese', '日本語', 'nihongo']],
233  ['zh-CN', ['zh', 'zh-cn', 'zh_cn', 'zh-hans', 'zh-sg', 'chinese', 'simplified chinese', '中文', '简体中文', '汉语', '普通话']],
234  ['vi', ['vi', 'vietnamese', 'tiếng việt', 'tieng viet', 'việt']],
235]
236
237/**
238 * Turns whatever a person or a system wrote into one of `codes`, or
239 * `undefined`: `de_CH.UTF-8`, `pt_BR`, `German`, `日本語`, `zh-Hans`.
240 * Traditional Chinese (`zh_TW`, `zh-Hant`) is not Simplified Chinese and
241 * resolves to nothing until someone contributes it.
242 */
243export function resolveCode(raw: string | undefined, codes: readonly string[]): string | undefined {
244  if (raw === undefined) return undefined
245  const text = raw.trim().toLowerCase().replace(/\.[\w-]+$/, '').replace(/@.*$/, '')
246  if (text === '' || text === 'c' || text === 'posix') return undefined
247  if (/^zh[-_](tw|hk|mo|hant)/.test(text)) return undefined
248  const exact = codes.find(code => code.toLowerCase() === text.replace('_', '-'))
249  if (exact !== undefined) return exact
250  for (const [code, names] of NAMES) {
251    if (!codes.includes(code)) continue
252    if (names.includes(text)) return code
253    const lang = text.split(/[-_\s]/)[0]
254    if (lang !== undefined && names.includes(lang)) return code
255  }
256  return undefined
257}
258

1import type { Locale } from './types'
2
3const de: Locale = {
4  code: 'de',
5  name: 'Deutsch',
6  commands: {
7    'add-dir': 'Ein weiteres Arbeitsverzeichnis hinzufügen',
8    advisor: 'Claude in wichtigen Momenten ein stärkeres Modell fragen lassen',
9    artifacts: 'Deine veröffentlichten und geteilten Artefakte durchsuchen',
10    'auto-mode-setup': 'Dem Automodus deine Umgebung beibringen, optional mit angepassten Regeln',
11    autocompact: 'Fenstergröße für das automatische Komprimieren einstellen',
12    'autofix-pr': 'Den aktuellen PR überwachen und Probleme automatisch beheben',
13    background: 'Diese Sitzung in den Hintergrund schicken und das Terminal freigeben',
14    batch: 'Eine große Änderung recherchieren und planen, dann parallel in 5–30 isolierten Worktree-Agenten ausführen, die je einen PR öffnen.',
15    branch: 'An dieser Stelle einen Zweig der aktuellen Unterhaltung anlegen',
16    brief: 'Kurzmodus ein- oder ausschalten',
17    btw: 'Eine schnelle Nebenfrage stellen, ohne die Unterhaltung zu unterbrechen',
18    bug: 'Einen Fehler melden oder deine Unterhaltung teilen',
19    cd: 'Diese Sitzung in ein anderes Arbeitsverzeichnis verschieben',
20    clear: 'Neue Sitzung mit leerem Kontext starten; die vorherige bleibt gespeichert (mit /resume fortsetzbar)',
21    'cloud-plugins': 'Festlegen, ob Cloud-Sitzungen die auf diesem Rechner aktivierten Plugins nutzen',
22    color: 'Farbe der Eingabeleiste für diese Sitzung festlegen',
23    compact: 'Kontext freigeben, indem die bisherige Unterhaltung zusammengefasst wird',
24    config: 'Einstellungen öffnen',
25    context: 'Aktuelle Kontextnutzung als farbiges Raster anzeigen',
26    copy: 'Claudes letzte Antwort in die Zwischenablage kopieren (oder /copy N für die N-letzte)',
27    daemon: 'Hintergrunddienste und Routinen verwalten',
28    debug: 'Debug-Protokollierung für diese Sitzung aktivieren und bei der Fehlersuche helfen',
29    design: 'Aus einem Briefing ein neues Design-Artefakt erstellen',
30    desktop: 'Die aktuelle Sitzung in Claude Desktop fortsetzen',
31    effort: 'Aufwandsstufe für die Modellnutzung festlegen',
32    exit: 'Claude Code beenden',
33    export: 'Die aktuelle Unterhaltung in eine Datei oder die Zwischenablage exportieren',
34    fast: 'Schnellmodus ein- oder ausschalten',
35    feedback: 'Feedback an Anthropic senden oder einen Fehler melden',
36    focus: 'Fokusansicht umschalten: nur deine Eingabe, Zusammenfassung und Antwort',
37    fork: 'Einen Hintergrund-Agenten starten, der die gesamte Unterhaltung übernimmt',
38    goal: 'Ein Ziel setzen – weiterarbeiten, bis die Bedingung erfüllt ist',
39    help: 'Hilfe und verfügbare Befehle anzeigen',
40    hooks: 'Hook-Konfigurationen für Tool-Ereignisse anzeigen',
41    ide: 'IDE-Integrationen verwalten und Status anzeigen',
42    import: 'Konfiguration aus einem anderen KI-Coding-Agenten importieren',
43    init: 'Eine neue CLAUDE.md mit Dokumentation der Codebasis anlegen',
44    insights: 'Einen Bericht über deine Claude-Code-Sitzungen erstellen',
45    'install-github-app': 'Claude GitHub Actions für ein Repository einrichten',
46    'install-slack-app': 'Die Claude-App für Slack installieren',
47    'list-agents': 'Subagenten, Teammitglieder und andere Claude-Sitzungen auflisten, denen du schreiben kannst',
48    login: 'Mit deinem Anthropic-Konto anmelden',
49    logout: 'Von deinem Anthropic-Konto abmelden',
50    loop: 'Einen Prompt oder Slash-Befehl in regelmäßigen Abständen ausführen (z. B. /loop 5m /foo). Ohne Intervall bestimmt das Modell das Tempo.',
51    loops: 'Schleifen auflisten, erstellen und löschen',
52    mcp: 'MCP-Server verwalten',
53    memory: 'CLAUDE.md-Dateien und Speichereinstellungen bearbeiten',
54    mobile: 'QR-Code zum Herunterladen der Claude-App anzeigen',
55    model: 'KI-Modell für Claude Code festlegen',
56    'output-style': 'Ausgabestile auflisten oder zu einem wechseln',
57    permissions: 'Erlaubnis- und Verbotsregeln für Tools verwalten',
58    plan: 'Planmodus aktivieren oder den aktuellen Sitzungsplan anzeigen',
59    plugin: 'Claude-Code-Plugins verwalten',
60    powerup: 'Funktionen von Claude Code in kurzen interaktiven Lektionen entdecken',
61    'privacy-settings': 'Datenschutzeinstellungen anzeigen und ändern',
62    radio: 'Claude FM hören – Lo-Fi-Radio',
63    recap: 'Jetzt eine einzeilige Zusammenfassung der Sitzung erstellen',
64    'release-notes': 'Versionshinweise anzeigen',
65    'reload-plugins': 'Ausstehende Plugin-Änderungen in der aktuellen Sitzung aktivieren',
66    'reload-skills': 'Während dieser Sitzung hinzugefügte oder geänderte Skills übernehmen',
67    'remote-env': 'Standardumgebung für Cloud-Agenten wählen',
68    rename: 'Die aktuelle Unterhaltung umbenennen',
69    resume: 'Eine frühere Unterhaltung fortsetzen',
70    rewind: 'Code und/oder Unterhaltung auf einen früheren Stand zurücksetzen',
71    'security-review': 'Sicherheitsprüfung der ausstehenden Änderungen im aktuellen Branch durchführen',
72    session: 'URL und QR-Code der Cloud-Sitzung anzeigen',
73    'skill-doctor': 'Anzeigen, welche geladenen Skills ungenutzt sind und Kontext kosten',
74    skills: 'Verfügbare Skills auflisten',
75    slides: 'Aus einem Briefing eine neue Foliensammlung erstellen',
76    status: 'Status von Claude Code anzeigen: Version, Modell, Konto, API-Verbindung und Tools',
77    statusline: 'Statuszeile von Claude Code einrichten',
78    stickers: 'Claude-Code-Sticker bestellen',
79    stop: 'Diese Hintergrundsitzung beenden; Verlauf und Worktree bleiben erhalten',
80    subtask: 'Einen Subagenten mit deinem gesamten Kontext losschicken; sein Ergebnis kommt hierher zurück',
81    tasks: 'Alles anzeigen und verwalten, was im Hintergrund läuft',
82    'team-onboarding': 'Teammitgliedern mit einer Anleitung aus deiner Nutzung den Einstieg in Claude Code erleichtern',
83    teleport: 'Diese Sitzung in die Cloud schicken oder eine von claude.ai fortsetzen',
84    theme: 'Design ändern',
85    tui: 'Darstellung der Terminal-Oberfläche festlegen (default | fullscreen)',
86    upgrade: 'Auf Max upgraden für höhere Limits und mehr Opus',
87    usage: 'Sitzungskosten, Plan-Nutzung und das, was zu deinen Limits beiträgt, anzeigen',
88    'usage-credits': 'Nutzungsguthaben einrichten oder bei Erreichen eines Limits beim Admin anfragen',
89    version: 'Version dieser Sitzung anzeigen (das Auto-Update hat eventuell eine neuere)',
90    voice: 'Sprachmodus ein- oder ausschalten',
91    'web-setup': 'Cloud-Sitzungen mit deinem GitHub-Konto einrichten',
92    wellbeing: 'Optionale Pausenerinnerungen und Ruhezeiten einrichten',
93    workflows: 'Laufende und abgeschlossene Workflows durchsuchen',
94    "code-review": "Den aktuellen Diff, einen PR, Branch oder Pfad auf Fehler prüfen, mit wählbarem Aufwand (low bis max; ultra: Multi-Agenten in der Cloud); --comment postet Befunde als PR-Kommentare, --fix wendet sie an, --post/--no-post steuert den GitHub-Kommentar",
95    "design-consent": "Claude-Agenten Zugriff auf deine Design-Projekte geben",
96    "design-revoke": "Claude-Agenten den Zugriff auf deine Design-Projekte entziehen",
97    "doctor": "Deine Claude-Code-Einrichtung prüfen und Probleme beheben: Installation, Einstellungen, ungenutzte Skills, MCP-Server und Plugins, CLAUDE.md-Dateien, langsame Hooks",
98    "fewer-permission-prompts": "Deine Verläufe nach häufigen lesenden Bash- und MCP-Aufrufen durchsuchen und eine Erlaubnisliste in .claude/settings.json anlegen, damit weniger Rückfragen kommen",
99    "simplify": "Geänderten Code auf Wiederverwendung, Vereinfachung und Effizienz prüfen und die Verbesserungen anwenden. Nur Qualität – für Fehlersuche gibt es /code-review",
100    "verify": "Prüfen, ob eine Änderung wirklich tut, was sie soll, indem der betroffene Ablauf von Anfang bis Ende ausgeführt wird – nicht nur Tests oder Typprüfung",
101    chrome: 'Einstellungen für Claude in Chrome öffnen',
102    'claim-credit': 'Die Seite des beim Start gezeigten Angebots öffnen',
103    'design-login': 'Zugriff auf Design-Systeme für /design-sync mit deinem claude.ai-Konto erlauben',
104    diff: 'Nicht committete Änderungen und Diffs pro Runde anzeigen',
105    'extra-usage': 'Umbenannt in /usage-credits',
106    keybindings: 'Deine Datei mit Tastenkürzeln öffnen',
107    'limit-reset': 'Sitzungslimit jetzt zurücksetzen und weiterarbeiten; einmal pro Woche, zählt trotzdem zum Wochenlimit',
108    'low-priority': 'Nach Erreichen des Sitzungslimits jetzt mit niedrigerer Priorität weitermachen; erneut ausführen zum Beenden',
109    passes: 'Eine kostenlose Woche Claude Code mit Freunden teilen und Nutzungsguthaben verdienen',
110    'pro-trial-expired': 'Optionen nach dem Ende der Claude-Code-Testphase im Pro-Plan',
111    'rate-limit-options': 'Nutzungslimits und Upgrade-Optionen verwalten',
112    'remote-control': 'Diese Sitzung vom Handy oder von claude.ai/code aus steuern',
113    schedule: 'Geplante Cloud-Agenten (Routinen) erstellen, ändern, auflisten oder ausführen, die nach einem Cron-Zeitplan laufen.',
114    'setup-bedrock': 'Anmeldung, Region und feste Modelle für Amazon Bedrock neu einrichten',
115    'setup-vertex': 'Anmeldung, Projekt, Region und feste Modelle für Google Vertex AI neu einrichten',
116    'terminal-setup': 'Tastenkürzel Shift+Enter für Zeilenumbrüche installieren',
117    ultrareview: 'Einen Cloud-Agenten starten, der Fehler in deinem Branch findet und bestätigt (~15–25 Min., 5–25 USD) · Läuft in einer Cloud-Sitzung. Siehe https://code.claude.com/docs/en/claude-code-on-the-web',
118  },
119  byText: {
120    "Set a setting by key":
121      "Eine Einstellung über ihren Schlüssel setzen",
122    "Copy this conversation into a new background session and keep working here":
123      "Diese Unterhaltung in eine neue Hintergrundsitzung kopieren und hier weiterarbeiten",
124    "Set a goal Claude checks before stopping":
125      "Ein Ziel setzen, das Claude vor dem Aufhören prüft",
126    "Set how full the context gets before auto-summarizing":
127      "Festlegen, wie voll der Kontext vor dem automatischen Zusammenfassen werden darf",
128    "Show session cost, plan usage, and activity stats":
129      "Sitzungskosten, Plan-Nutzung und Aktivitätsstatistik anzeigen",
130    "Print the version this session is running (not what autoupdate downloaded)":
131      "Version dieser Sitzung ausgeben (nicht die vom Auto-Update geladene)",
132    'Show current context usage':
133      'Aktuelle Kontextnutzung anzeigen',
134    'Grant or revoke Claude agent access to your Design projects':
135      'Claude-Agenten Zugriff auf deine Design-Projekte geben oder entziehen',
136    'Toggle the diff panel showing uncommitted changes':
137      'Diff-Bereich mit nicht committeten Änderungen ein- oder ausblenden',
138  },
139  config: {
140    autoCompact: 'Automatisch komprimieren',
141    autoContinueAtUsageLimit: 'Beim Nutzungslimit automatisch fortfahren',
142    switchModelsOnFlag: 'Modell wechseln, wenn eine Nachricht markiert wird',
143    tips: 'Tipps anzeigen',
144    reduceMotion: 'Bewegung reduzieren',
145    thinking: 'Denkmodus',
146    promptSuggestionEnabled: 'Prompt-Vorschläge',
147    recap: 'Sitzungszusammenfassung',
148    checkpoints: 'Code zurückspulen (Checkpoints)',
149    artifacts: 'Artefakte',
150    verbose: 'Ausführliche Ausgabe',
151    progressBar: 'Fortschrittsbalken im Terminal',
152    turnDuration: 'Dauer pro Runde anzeigen',
153    timeFormat: 'Zeitformat',
154    permissionMode: 'Standard-Berechtigungsmodus',
155    worktreeBaseRef: 'Basis-Ref für Worktrees',
156    useAutoModeDuringPlan: 'Automodus während der Planung nutzen',
157    gitignore: '.gitignore in der Dateiauswahl beachten',
158    copyFullResponse: 'Auswahl bei /copy überspringen',
159    copyOnSelect: 'Beim Markieren kopieren',
160    autoScroll: 'Automatisch scrollen',
161    defaultToAgentsView: 'Agentenansicht standardmäßig öffnen',
162    leftArrowOpensAgents: '← öffnet Agenten',
163    autoUpdatesChannel: 'Update-Kanal',
164    theme: 'Design',
165    notifChannel: 'Lokale Benachrichtigungen',
166    inputNeededNotifEnabled: 'Push, wenn Aktionen nötig sind',
167    agentPushNotifEnabled: 'Push, wenn Claude entscheidet',
168    outputStyle: 'Ausgabestil',
169    language: 'Sprache',
170    editor: 'Editormodus',
171    askUserQuestionTimeout: 'Zeitlimit für automatisches Fortfahren bei Fragen',
172    externalEditorContext: 'Letzte Antwort im externen Editor zeigen',
173    prStatus: 'PR-Status in der Fußzeile anzeigen',
174    model: 'Modell',
175    autoConnectIde: 'Automatisch mit IDE verbinden (externes Terminal)',
176    chrome: 'Claude in Chrome standardmäßig aktiviert',
177    dialogExpiry: 'Ablauf von Dialogen',
178    feedbackDrafts: 'Von Claude entworfenes Feedback',
179    fast: 'Schnellmodus',
180    workflows: 'Dynamische Workflows',
181    workflowKeywordTriggerEnabled: 'Auslösen mit dem Stichwort ultracode',
182    workflowSizeGuideline: 'Größe dynamischer Workflows',
183    remoteControl: 'Remote Control für alle Sitzungen aktivieren',
184    'cc-plugin-agents-md.instructionFiles': 'Projektanweisungen',
185  },
186  phrases: {
187    shortcuts: '? für Tastenkürzel',
188    shellMode: '! für Shell-Modus',
189    escInterrupt: 'Esc zum Unterbrechen',
190    escAgainClear: 'Esc erneut zum Leeren',
191    doubleEscClear: 'zweimal Esc zum Leeren der Eingabe',
192    pressAgainExit: '{1} erneut drücken zum Beenden',
193    editQueued: '↑ zum Bearbeiten wartender Nachrichten',
194    acceptEdits: 'Änderungen annehmen an',
195    planMode: 'Planmodus an',
196    autoMode: 'Automodus an',
197    bypassPermissions: 'Berechtigungen umgehen an',
198    manualMode: 'Manuellmodus an',
199    forAgents: '← für Agenten',
200    toCycle: '({1} zum Wechseln)',
201    toExpand: '({1} zum Aufklappen)',
202    runInBackground: '({1} für Hintergrund)',
203    pasteToExpand: 'erneut einfügen zum Aufklappen',
204    toStop: '{1} zum Stoppen',
205    holdToSpeak: '{1} halten zum Sprechen',
206    sandboxEnabled: 'Sandbox aktiv',
207    sandboxDisabled: 'Sandbox aus',
208    sandboxAutoAllow: '(automatisch erlaubt)',
209    sandboxFallback: ', Ausweichen erlaubt',
210    sandboxManaged: '(verwaltet)',
211    toConfigure: '(⏎ zum Einrichten)',
212  },
213  modes: {
214    focus: 'Fokus',
215    'memory paused': 'Speicher pausiert',
216    brief: 'kurz',
217    fast: 'schnell',
218    voice: 'Sprache',
219  },
220  spinner: [
221    'Brüte', 'Tüftle', 'Grüble', 'Werkle', 'Köchle', 'Knoble', 'Sinniere', 'Backe', 'Braue', 'Rühre',
222    'Schmiede', 'Bastle', 'Sortiere', 'Jongliere', 'Fabuliere', 'Philosophiere', 'Kombiniere', 'Puzzle',
223    'Zaubere', 'Hexe', 'Knete', 'Würze', 'Simmere', 'Schraube', 'Wurstle', 'Fuchse mich rein', 'Denke nach',
224    'Rechne', 'Feile', 'Schwurble',
225  ],
226  turn: {
227    words: ['Gebacken', 'Gebraut', 'Gerührt', 'Gegrübelt', 'Gekocht', 'Getüftelt', 'Geschmort', 'Gearbeitet'],
228    template: '{word}: {duration}',
229  },
230  group: {
231    searched: { one: 'nach {n} Muster gesucht', other: 'nach {n} Mustern gesucht' },
232    read: { one: '{n} Datei gelesen', other: '{n} Dateien gelesen' },
233    listed: { one: '{n} Verzeichnis aufgelistet', other: '{n} Verzeichnisse aufgelistet' },
234    separator: ', ',
235  },
236  duration: { h: ' Std.', m: ' Min.', s: ' s', separator: ' ' },
237  ui: {
238    status: 'Tolk: Die Oberfläche ist auf {name} ({code}).',
239    coverage: '{commands} von {commandsTotal} Befehlsbeschreibungen und {settings} von {settingsTotal} Einstellungen sind übersetzt.',
240    available: 'Verfügbare Sprachen:',
241    switched: 'Auf {name} umgestellt. Claude Code aktualisiert die Beschriftungen gleich.',
242    unknown: 'Unbekannte Sprache „{code}“. Verfügbar: {codes}',
243    missingNone: 'Jeder eingebaute Befehl hat eine Übersetzung.',
244    missingHeader: 'Befehle ohne Übersetzung:',
245    driftHeader: 'Befehle, deren englischer Text sich seit der Übersetzung geändert hat:',
246    usage: 'Verwendung: /tolk [list | set <Code> | missing]. Codes: {codes}',
247    commandDescription: 'Sprache der Oberfläche anzeigen oder ändern (Tolk)',
248    configLabel: 'Sprache der Oberfläche (Tolk)',
249  },
250}
251
252export default de
253

1// The English source catalog, as Claude Code 2.1.294 ships it.
2//
3// Tolk never draws these: it uses them to recognise what Claude Code
4// shows and to tell translators when an English text has changed since
5// they translated it (`/tolk missing`). When Claude Code changes a
6// description, update it here and in every language file.
7
8import type { Locale } from './types'
9
10const en: Locale = {
11  code: 'en',
12  name: 'English',
13  commands: {
14    'add-dir': 'Add a new working directory',
15    advisor: 'Let Claude consult a stronger model at key moments',
16    artifacts: 'Browse your published and shared artifacts',
17    'auto-mode-setup': 'Teach auto mode about your environment, plus optional rule tweaks',
18    autocompact: 'Configure the auto-compact window size',
19    'autofix-pr': 'Monitor and autofix any issues with the current PR',
20    background: 'Send this session to the background and free the terminal',
21    batch: 'Research and plan a large-scale change, then execute it in parallel across 5–30 isolated worktree agents that each open a PR.',
22    branch: 'Create a branch of the current conversation at this point',
23    brief: 'Toggle brief-only mode',
24    btw: 'Ask a quick side question without interrupting the main conversation',
25    bug: 'Report a bug or share your conversation',
26    cd: 'Move this session to a new working directory',
27    chrome: 'Open Claude in Chrome settings',
28    'claim-credit': 'Open the page of the offer shown at start-up',
29    clear: 'Start a new session with empty context; previous session stays on disk (resumable with /resume)',
30    'cloud-plugins': 'Choose whether cloud sessions use the plugins enabled on this machine',
31    'code-review': 'Review the current diff, or a PR number/branch/path target, for correctness bugs (plus reuse/simplification/efficiency cleanups where the model\'s review recipe covers them) at the given effort level (low|medium|high|xhigh|max: from few high-confidence findings up to many, some of them uncertain; ultra: deep multi-agent review in the cloud); with no level given, it reuses the level you typed last. Pass --comment to post findings as inline PR comments, or --fix to apply the findings to the working tree after the review. Pass --max-findings <n> to report up to n findings, or --max-findings all for every finding. The choice stays until you pass --max-findings default. For ultra on a GitHub.com PR target, --post asks to post the finished review’s findings to the PR as a single comment from the user’s GitHub account (not a review; the launch dialog still confirms in interactive sessions, while non-interactive mode posts on the flag alone) and --no-post hides that option.',
32    color: 'Set the prompt bar color for this session',
33    compact: 'Free up context by summarizing the conversation so far',
34    config: 'Open settings',
35    context: 'Visualize current context usage as a colored grid',
36    copy: "Copy Claude's last response to clipboard (or /copy N for the Nth-latest)",
37    daemon: 'Manage background services and routines',
38    debug: 'Enable debug logging for this session and help diagnose issues',
39    design: 'Make a new Design artifact from a brief',
40    'design-consent': 'Grant Claude agent access to your Design projects',
41    'design-login': 'Authorize design-system access for /design-sync with your claude.ai account',
42    'design-revoke': 'Revoke Claude agent access to your Design projects',
43    desktop: 'Continue the current session in Claude Desktop',
44    diff: 'View uncommitted changes and per-turn diffs',
45    doctor: "Health-check the user's Claude Code setup and fix issues: diagnose installation health — what the `claude doctor` terminal diagnostics cover — from local data (duplicate or leftover installs, PATH, unparseable settings files, broken or colliding agent definitions, skills whose frontmatter fails to parse); find unused skills, MCP servers, and plugins versus their context cost and disable dead weight; deduplicate local CLAUDE.md files against checked-in ones; trim checked-in CLAUDE.md files by cutting content a session could derive from the codebase (directory layouts, tech-stack lists, architecture overviews) while keeping gotchas, rationale, and non-standard conventions; migrate always-loaded CLAUDE.md guidance into lazy skills and nested CLAUDE.md files; flag slow hooks and context-heavy extensions; check the installed version is current; make auto mode the default permission mode; and pre-approve frequently denied read-only commands. Use when the user asks for a doctor run, checkup, audit, tune-up, or cleanup of their Claude Code setup or configuration.",
46    effort: 'Set effort level for model usage',
47    exit: 'Exit the CLI',
48    export: 'Export the current conversation to a file or clipboard',
49    'extra-usage': 'Renamed to /usage-credits',
50    fast: 'Toggle fast mode',
51    feedback: 'Send feedback to Anthropic or report a bug',
52    'fewer-permission-prompts': 'Scan your transcripts for common read-only Bash and MCP tool calls, then add a prioritized allowlist to project .claude/settings.json to reduce permission prompts.',
53    focus: 'Toggle focus view: just your prompt, summary, and response',
54    fork: 'Spawn a background agent that inherits the full conversation',
55    goal: 'Set a goal — keep working until the condition is met',
56    help: 'Show help and available commands',
57    hooks: 'View hook configurations for tool events',
58    ide: 'Manage IDE integrations and show status',
59    import: 'Import config from another AI coding agent',
60    init: 'Initialize a new CLAUDE.md file with codebase documentation',
61    insights: 'Generate a report analyzing your Claude Code sessions',
62    'install-github-app': 'Set up Claude GitHub Actions for a repository',
63    'install-slack-app': 'Install the Claude Slack app',
64    keybindings: 'Open your keyboard shortcuts file',
65    'limit-reset': 'Reset your session limit now and keep working; once a week, still counts toward your weekly limit',
66    'list-agents': 'List subagents, teammates, and other Claude sessions you can message',
67    login: 'Sign in with your Anthropic account',
68    logout: 'Sign out from your Anthropic account',
69    loop: 'Run a prompt or slash command on a recurring interval (e.g. /loop 5m /foo). Omit the interval to let the model self-pace.',
70    loops: 'List, create, and delete loops',
71    'low-priority': 'Continue now at lower priority after reaching your session limit; run again to stop',
72    mcp: 'Manage MCP servers',
73    memory: 'Edit CLAUDE.md files and memory settings',
74    mobile: 'Show QR code to download the Claude mobile app',
75    model: 'Set the AI model for Claude Code',
76    'output-style': 'List output styles or switch to one',
77    passes: 'Share a free week of Claude Code with friends and earn usage credits',
78    permissions: 'Manage allow and deny tool permission rules',
79    plan: 'Enable plan mode or view the current session plan',
80    plugin: 'Manage Claude Code plugins',
81    powerup: 'Discover Claude Code features through quick interactive lessons',
82    'privacy-settings': 'View and update your privacy settings',
83    'pro-trial-expired': 'Options shown when the Pro plan Claude Code trial has ended',
84    radio: 'Listen to Claude FM lo-fi radio',
85    'rate-limit-options': 'Manage usage limits and upgrade options',
86    recap: 'Generate a one-line session recap now',
87    'release-notes': 'View release notes',
88    'reload-plugins': 'Activate pending plugin changes in the current session',
89    'reload-skills': 'Pick up skills added or changed on disk during this session',
90    'remote-control': 'Control this session from your phone or claude.ai/code',
91    'remote-env': 'Choose the default environment for cloud agents',
92    rename: 'Rename the current conversation',
93    resume: 'Resume a previous conversation',
94    rewind: 'Restore the code and/or conversation to a previous point',
95    schedule: 'Create, update, list, or run scheduled cloud agents (routines) that execute on a cron schedule.',
96    'security-review': 'Complete a security review of the pending changes on the current branch',
97    session: 'Show cloud session URL and QR code',
98    'setup-bedrock': 'Reconfigure Amazon Bedrock authentication, region, or model pins',
99    'setup-vertex': 'Reconfigure Google Vertex AI authentication, project, region, or model pins',
100    simplify: 'Review the changed code for reuse, simplification, efficiency, and altitude cleanups, then apply the fixes. Quality only — it does not hunt for bugs; use /code-review for that.',
101    'skill-doctor': 'Show which loaded skills are unused and costing context',
102    skills: 'List available skills',
103    slides: 'Make a new Slides deck artifact from a brief',
104    status: 'Show Claude Code status including version, model, account, API connectivity, and tool statuses',
105    statusline: "Set up Claude Code's status line UI",
106    stickers: 'Order Claude Code stickers',
107    stop: 'Stop this background session; transcript and worktree are kept',
108    subtask: 'Send a subagent off with your full context; its result comes back here',
109    tasks: 'View and manage everything running in the background',
110    'team-onboarding': 'Help teammates ramp on Claude Code with a guide from your usage',
111    teleport: 'Send this session to the cloud, or resume one from claude.ai',
112    'terminal-setup': 'Install Shift+Enter key binding for newlines',
113    theme: 'Change the theme',
114    tui: 'Set the terminal UI renderer (default | fullscreen)',
115    ultrareview: 'Start a cloud agent that finds and verifies bugs in your branch (~15-25 min, $5-$25 USD) · Runs in a cloud session. See https://code.claude.com/docs/en/claude-code-on-the-web',
116    upgrade: 'Upgrade to Max for higher rate limits and more Opus',
117    usage: "Show session cost, plan usage, and what's contributing to your limits",
118    'usage-credits': 'Configure usage credits or request them from your admin when you hit a limit',
119    verify: "Verify that a code change actually does what it's supposed to by exercising it end-to-end and observing behavior — drive the affected flow, not just tests or typecheck. Run before committing nontrivial changes; bootstraps this repo's project verify skill if none exists yet. Don't invoke it on a diff that only touches tests, docs, or other code with no runtime surface to drive (a change to product source always has one) — there's nothing to observe.",
120    version: "Show this session's version (autoupdate may have a newer one)",
121    voice: 'Toggle voice mode',
122    'web-setup': 'Set up cloud sessions with your GitHub account',
123    wellbeing: 'Configure optional break reminders and quiet-hours nudges',
124    workflows: 'Browse running and completed workflows',
125  },
126  // The other wording some commands show, depending on where Claude Code
127  // runs (a terminal or headless) or what the session is doing.
128  byText: {
129    'Set a setting by key': 'Set a setting by key',
130    'Copy this conversation into a new background session and keep working here':
131      'Copy this conversation into a new background session and keep working here',
132    'Set a goal Claude checks before stopping': 'Set a goal Claude checks before stopping',
133    'Set how full the context gets before auto-summarizing': 'Set how full the context gets before auto-summarizing',
134    'Show session cost, plan usage, and activity stats': 'Show session cost, plan usage, and activity stats',
135    'Print the version this session is running (not what autoupdate downloaded)':
136      'Print the version this session is running (not what autoupdate downloaded)',
137    'Show current context usage': 'Show current context usage',
138    'Grant or revoke Claude agent access to your Design projects':
139      'Grant or revoke Claude agent access to your Design projects',
140    'Toggle the diff panel showing uncommitted changes':
141      'Toggle the diff panel showing uncommitted changes',
142  },
143  config: {
144    autoCompact: 'Auto-compact',
145    autoContinueAtUsageLimit: 'Continue automatically at usage limit',
146    switchModelsOnFlag: 'Switch models when a message is flagged',
147    tips: 'Show tips',
148    feedbackDrafts: 'Claude-drafted feedback',
149    reduceMotion: 'Reduce motion',
150    thinking: 'Thinking mode',
151    fast: 'Fast mode',
152    promptSuggestionEnabled: 'Prompt suggestions',
153    recap: 'Session recap',
154    checkpoints: 'Rewind code (checkpoints)',
155    workflows: 'Dynamic workflows',
156    workflowKeywordTriggerEnabled: 'Ultracode keyword trigger',
157    workflowSizeGuideline: 'Dynamic workflow size',
158    artifacts: 'Artifacts',
159    verbose: 'Verbose output',
160    progressBar: 'Terminal progress bar',
161    turnDuration: 'Show turn duration',
162    timeFormat: 'Time format',
163    permissionMode: 'Default permission mode',
164    worktreeBaseRef: 'Worktree base ref',
165    useAutoModeDuringPlan: 'Use auto mode during plan',
166    gitignore: 'Respect .gitignore in file picker',
167    copyFullResponse: 'Skip the /copy picker',
168    copyOnSelect: 'Copy on select',
169    autoScroll: 'Auto-scroll',
170    defaultToAgentsView: 'Open agents view by default',
171    leftArrowOpensAgents: '← opens agents',
172    autoUpdatesChannel: 'Auto-update channel',
173    theme: 'Theme',
174    notifChannel: 'Local notifications',
175    inputNeededNotifEnabled: 'Push when actions required',
176    agentPushNotifEnabled: 'Push when Claude decides',
177    outputStyle: 'Output style',
178    language: 'Language',
179    editor: 'Editor mode',
180    askUserQuestionTimeout: 'Question auto-continue timeout',
181    externalEditorContext: 'Show last response in external editor',
182    prStatus: 'Show PR status footer',
183    model: 'Model',
184    autoConnectIde: 'Auto-connect to IDE (external terminal)',
185    chrome: 'Claude in Chrome enabled by default',
186    remoteControl: 'Enable Remote Control for all sessions',
187    dialogExpiry: 'Dialog expiry',
188    // From the AGENTS.md plugin Claude Code ships with.
189    'cc-plugin-agents-md.instructionFiles': 'Project instructions',
190  },
191  phrases: {
192    sandboxEnabled: 'sandbox enabled',
193    sandboxDisabled: 'sandbox disabled',
194    sandboxAutoAllow: '(auto-allow)',
195    sandboxFallback: ', fallback allowed',
196    sandboxManaged: '(managed)',
197    toConfigure: '(⏎ to configure)',
198  },
199  modes: {},
200  // Claude Code's own spinner words. Tolk only replaces these, so a
201  // custom `spinnerVerbs` setting is left alone.
202  spinner: [
203    'Accomplishing', 'Actioning', 'Actualizing', 'Architecting', 'Baking', 'Beaming', "Beboppin'", 'Befuddling',
204    'Billowing', 'Blanching', 'Bloviating', 'Boogieing', 'Boondoggling', 'Booping', 'Bootstrapping', 'Brewing',
205    'Bunning', 'Burrowing', 'Calculating', 'Canoodling', 'Caramelizing', 'Cascading', 'Catapulting', 'Cerebrating',
206    'Channeling', 'Choreographing', 'Churning', 'Clauding', 'Coalescing', 'Cogitating', 'Combobulating', 'Composing',
207    'Computing', 'Concocting', 'Considering', 'Contemplating', 'Cooking', 'Crafting', 'Creating', 'Crunching',
208    'Crystallizing', 'Cultivating', 'Deciphering', 'Deliberating', 'Determining', 'Dilly-dallying', 'Discombobulating',
209    'Doing', 'Doodling', 'Drizzling', 'Ebbing', 'Effecting', 'Elucidating', 'Embellishing', 'Enchanting', 'Envisioning',
210    'Fermenting', 'Fiddle-faddling', 'Finagling', 'Flambéing', 'Flibbertigibbeting', 'Flowing', 'Flummoxing',
211    'Fluttering', 'Forging', 'Forming', 'Frolicking', 'Frosting', 'Gallivanting', 'Galloping', 'Garnishing',
212    'Generating', 'Gesticulating', 'Germinating', 'Gitifying', 'Grooving', 'Gusting', 'Harmonizing', 'Hashing',
213    'Hatching', 'Herding', 'Honking', 'Hullaballooing', 'Hyperspacing', 'Ideating', 'Imagining', 'Improvising',
214    'Incubating', 'Inferring', 'Infusing', 'Ionizing', 'Jitterbugging', 'Julienning', 'Kerfuffling', 'Kneading',
215    'Leavening', 'Levitating', 'Lollygagging', 'Manifesting', 'Marinating', 'Meandering', 'Metamorphosing', 'Misting',
216    'Moonwalking', 'Moseying', 'Mulling', 'Mustering', 'Musing', 'Nebulizing', 'Nesting', 'Newspapering', 'Noodling',
217    'Nucleating', 'Onioning', 'Orbiting', 'Orchestrating', 'Osmosing', 'Perambulating', 'Percolating', 'Perusing',
218    'Philosophizing', 'Photosynthesizing', 'Polishing', 'Pollinating', 'Pondering', 'Pontificating', 'Pouncing',
219    'Precipitating', 'Prestidigitating', 'Processing', 'Proofing', 'Propagating', 'Puttering', 'Puzzling',
220    'Quantumizing', 'Razzle-dazzling', 'Razzmatazzing', 'Recombobulating', 'Reticulating', 'Roosting', 'Ruminating',
221    'Sautéing', 'Scampering', 'Schlepping', 'Scurrying', 'Seasoning', 'Shenaniganing', 'Shimmying', 'Simmering',
222    'Skedaddling', 'Sketching', 'Slithering', 'Smooshing', 'Sock-hopping', 'Spelunking', 'Spinning', 'Sprouting',
223    'Stewing', 'Sublimating', 'Swirling', 'Swooping', 'Symbioting', 'Synthesizing', 'Tempering', 'Thinking',
224    'Thundering', 'Tinkering', 'Tomfoolering', 'Topsy-turvying', 'Transfiguring', 'Transmogrifying', 'Transmuting',
225    'Twisting', 'Undulating', 'Unfurling', 'Unraveling', 'Vibing', 'Waddling', 'Wandering', 'Warping',
226    'Whatchamacalliting', 'Whirlpooling', 'Whirring', 'Whisking', 'Wibbling', 'Working', 'Wrangling', 'Zesting',
227    'Zigzagging',
228  ],
229  turn: {
230    words: ['Baked', 'Brewed', 'Churned', 'Cogitated', 'Cooked', 'Crunched', 'Sautéed', 'Worked'],
231    template: '{word} for {duration}',
232  },
233  group: {
234    searched: { one: 'searched for {n} pattern', other: 'searched for {n} patterns' },
235    read: { one: 'read {n} file', other: 'read {n} files' },
236    listed: { one: 'listed {n} directory', other: 'listed {n} directories' },
237    separator: ', ',
238  },
239  duration: { h: 'h', m: 'm', s: 's', separator: ' ' },
240  ui: {
241    status: 'Tolk: the interface is in {name} ({code}).',
242    coverage: '{commands} of {commandsTotal} command descriptions and {settings} of {settingsTotal} settings are translated.',
243    available: 'Available languages:',
244    switched: 'Switched to {name}. Claude Code updates its labels in a moment.',
245    unknown: 'Unknown language "{code}". Available: {codes}',
246    missingNone: 'Every built-in command on screen has a translation.',
247    missingHeader: 'Commands without a translation:',
248    driftHeader: 'Commands whose English text changed since they were translated:',
249    usage: 'Usage: /tolk [list | set <code> | missing]. Codes: {codes}',
250    commandDescription: 'Show or change the interface language (Tolk)',
251    configLabel: 'Interface language (Tolk)',
252  },
253}
254
255export default en
256

1import type { Locale } from './types'
2
3const es: Locale = {
4  code: 'es',
5  name: 'Español',
6  commands: {
7    'add-dir': 'Añadir un nuevo directorio de trabajo',
8    advisor: 'Dejar que Claude consulte a un modelo más potente en momentos clave',
9    artifacts: 'Explorar tus artefactos publicados y compartidos',
10    'auto-mode-setup': 'Enseñar al modo automático cómo es tu entorno, con ajustes opcionales de reglas',
11    autocompact: 'Configurar el tamaño de la ventana de compactación automática',
12    'autofix-pr': 'Vigilar el PR actual y corregir sus problemas automáticamente',
13    background: 'Enviar esta sesión a segundo plano y liberar la terminal',
14    batch: 'Investigar y planificar un cambio a gran escala y ejecutarlo en paralelo con 5–30 agentes en worktrees aislados que abren un PR cada uno.',
15    branch: 'Crear una rama de la conversación actual en este punto',
16    brief: 'Activar o desactivar el modo breve',
17    btw: 'Hacer una pregunta rápida sin interrumpir la conversación principal',
18    bug: 'Informar de un error o compartir tu conversación',
19    cd: 'Mover esta sesión a otro directorio de trabajo',
20    clear: 'Empezar una sesión nueva con el contexto vacío; la anterior queda guardada (se reanuda con /resume)',
21    'cloud-plugins': 'Elegir si las sesiones en la nube usan los plugins activados en este equipo',
22    color: 'Elegir el color de la barra de entrada para esta sesión',
23    compact: 'Liberar contexto resumiendo la conversación hasta ahora',
24    config: 'Abrir la configuración',
25    context: 'Mostrar el uso actual del contexto como una cuadrícula de colores',
26    copy: 'Copiar la última respuesta de Claude al portapapeles (o /copy N para la N-ésima más reciente)',
27    daemon: 'Gestionar servicios y rutinas en segundo plano',
28    debug: 'Activar el registro de depuración en esta sesión y ayudar a diagnosticar problemas',
29    design: 'Crear un nuevo artefacto de diseño a partir de un briefing',
30    desktop: 'Continuar la sesión actual en Claude Desktop',
31    effort: 'Elegir el nivel de esfuerzo del modelo',
32    exit: 'Salir de Claude Code',
33    export: 'Exportar la conversación actual a un archivo o al portapapeles',
34    fast: 'Activar o desactivar el modo rápido',
35    feedback: 'Enviar comentarios a Anthropic o informar de un error',
36    focus: 'Alternar la vista de enfoque: solo tu mensaje, el resumen y la respuesta',
37    fork: 'Lanzar un agente en segundo plano que hereda toda la conversación',
38    goal: 'Fijar un objetivo: seguir trabajando hasta que se cumpla la condición',
39    help: 'Mostrar la ayuda y los comandos disponibles',
40    hooks: 'Ver la configuración de hooks para eventos de herramientas',
41    ide: 'Gestionar integraciones con el IDE y ver su estado',
42    import: 'Importar la configuración de otro agente de programación con IA',
43    init: 'Crear un archivo CLAUDE.md con la documentación del código',
44    insights: 'Generar un informe que analiza tus sesiones de Claude Code',
45    'install-github-app': 'Configurar Claude GitHub Actions para un repositorio',
46    'install-slack-app': 'Instalar la app de Claude para Slack',
47    'list-agents': 'Listar subagentes, compañeros de equipo y otras sesiones de Claude a las que puedes escribir',
48    login: 'Iniciar sesión con tu cuenta de Anthropic',
49    logout: 'Cerrar la sesión de tu cuenta de Anthropic',
50    loop: 'Ejecutar un prompt o comando a intervalos (p. ej. /loop 5m /foo). Sin intervalo, el modelo marca el ritmo.',
51    loops: 'Listar, crear y eliminar bucles',
52    mcp: 'Gestionar servidores MCP',
53    memory: 'Editar archivos CLAUDE.md y la configuración de memoria',
54    mobile: 'Mostrar el código QR para descargar la app móvil de Claude',
55    model: 'Elegir el modelo de IA de Claude Code',
56    'output-style': 'Listar los estilos de salida o cambiar a uno',
57    permissions: 'Gestionar las reglas que permiten o deniegan herramientas',
58    plan: 'Activar el modo plan o ver el plan de la sesión actual',
59    plugin: 'Gestionar los plugins de Claude Code',
60    powerup: 'Descubrir funciones de Claude Code con lecciones interactivas breves',
61    'privacy-settings': 'Ver y cambiar tu configuración de privacidad',
62    radio: 'Escuchar Claude FM, radio lo-fi',
63    recap: 'Generar ahora un resumen de la sesión en una línea',
64    'release-notes': 'Ver las notas de la versión',
65    'reload-plugins': 'Aplicar los cambios pendientes de plugins en la sesión actual',
66    'reload-skills': 'Cargar las skills añadidas o modificadas durante esta sesión',
67    'remote-env': 'Elegir el entorno predeterminado para los agentes en la nube',
68    rename: 'Renombrar la conversación actual',
69    resume: 'Reanudar una conversación anterior',
70    rewind: 'Restaurar el código y/o la conversación a un punto anterior',
71    'security-review': 'Hacer una revisión de seguridad de los cambios pendientes en la rama actual',
72    session: 'Mostrar la URL y el código QR de la sesión en la nube',
73    'skill-doctor': 'Mostrar qué skills cargadas no se usan y consumen contexto',
74    skills: 'Listar las skills disponibles',
75    slides: 'Crear una nueva presentación a partir de un briefing',
76    status: 'Mostrar el estado de Claude Code: versión, modelo, cuenta, conexión con la API y herramientas',
77    statusline: 'Configurar la línea de estado de Claude Code',
78    stickers: 'Pedir pegatinas de Claude Code',
79    stop: 'Detener esta sesión en segundo plano; se conservan el historial y el worktree',
80    subtask: 'Enviar un subagente con todo tu contexto; su resultado vuelve aquí',
81    tasks: 'Ver y gestionar todo lo que se ejecuta en segundo plano',
82    'team-onboarding': 'Ayudar a tu equipo a empezar con Claude Code con una guía basada en tu uso',
83    teleport: 'Enviar esta sesión a la nube o reanudar una desde claude.ai',
84    theme: 'Cambiar el tema',
85    tui: 'Elegir cómo se dibuja la interfaz de la terminal (default | fullscreen)',
86    upgrade: 'Pasar a Max para tener límites más altos y más Opus',
87    usage: 'Mostrar el coste de la sesión, el uso del plan y lo que cuenta para tus límites',
88    'usage-credits': 'Configurar créditos de uso o pedirlos a tu administrador al llegar a un límite',
89    version: 'Mostrar la versión de esta sesión (la actualización automática puede tener una más nueva)',
90    voice: 'Activar o desactivar el modo de voz',
91    'web-setup': 'Configurar las sesiones en la nube con tu cuenta de GitHub',
92    wellbeing: 'Configurar recordatorios opcionales de descanso y horas de silencio',
93    workflows: 'Explorar flujos de trabajo en curso y terminados',
94    "code-review": "Revisar el diff actual, un PR, rama o ruta en busca de errores, con el nivel de esfuerzo que elijas (low a max; ultra: revisión multiagente en la nube); --comment publica los hallazgos en el PR, --fix los aplica y --post/--no-post controla el comentario de GitHub",
95    "design-consent": "Dar a los agentes de Claude acceso a tus proyectos de Design",
96    "design-revoke": "Retirar a los agentes de Claude el acceso a tus proyectos de Design",
97    "doctor": "Revisar tu instalación de Claude Code y corregir problemas: instalación, configuración, skills, servidores MCP y plugins sin uso, archivos CLAUDE.md, hooks lentos",
98    "fewer-permission-prompts": "Buscar en tus historiales llamadas de solo lectura frecuentes a Bash y MCP y añadir una lista de permitidos en .claude/settings.json para recibir menos solicitudes de permiso",
99    "simplify": "Revisar el código cambiado para reutilizar, simplificar y ganar eficiencia, y aplicar las mejoras. Solo calidad: para buscar errores usa /code-review",
100    "verify": "Comprobar que un cambio hace lo que debe ejecutando el flujo afectado de principio a fin, no solo los tests o la comprobación de tipos",
101    chrome: 'Abrir la configuración de Claude in Chrome',
102    'claim-credit': 'Abrir la página de la oferta que se muestra al iniciar',
103    'design-login': 'Autorizar el acceso a sistemas de diseño para /design-sync con tu cuenta de claude.ai',
104    diff: 'Ver los cambios sin confirmar y los diffs de cada turno',
105    'extra-usage': 'Ahora se llama /usage-credits',
106    keybindings: 'Abrir tu archivo de atajos de teclado',
107    'limit-reset': 'Restablecer ya tu límite de sesión y seguir trabajando; una vez por semana, sigue contando para tu límite semanal',
108    'low-priority': 'Seguir ahora con menor prioridad tras alcanzar tu límite de sesión; ejecútalo de nuevo para parar',
109    passes: 'Compartir una semana gratis de Claude Code con amigos y ganar créditos de uso',
110    'pro-trial-expired': 'Opciones al terminar la prueba de Claude Code del plan Pro',
111    'rate-limit-options': 'Gestionar los límites de uso y las opciones de mejora',
112    'remote-control': 'Controlar esta sesión desde tu móvil o claude.ai/code',
113    schedule: 'Crear, modificar, listar o ejecutar agentes en la nube programados (rutinas) que se ejecutan según un horario cron.',
114    'setup-bedrock': 'Volver a configurar la autenticación, la región o los modelos fijados de Amazon Bedrock',
115    'setup-vertex': 'Volver a configurar la autenticación, el proyecto, la región o los modelos fijados de Google Vertex AI',
116    'terminal-setup': 'Instalar el atajo Shift+Enter para saltos de línea',
117    ultrareview: 'Iniciar un agente en la nube que encuentra y verifica errores en tu rama (~15-25 min, 5-25 USD) · Se ejecuta en una sesión en la nube. Más información: https://code.claude.com/docs/en/claude-code-on-the-web',
118  },
119  byText: {
120    "Set a setting by key":
121      "Cambiar un ajuste por su clave",
122    "Copy this conversation into a new background session and keep working here":
123      "Copiar esta conversación a una nueva sesión en segundo plano y seguir trabajando aquí",
124    "Set a goal Claude checks before stopping":
125      "Fijar un objetivo que Claude comprueba antes de parar",
126    "Set how full the context gets before auto-summarizing":
127      "Elegir cuánto se llena el contexto antes de resumirlo automáticamente",
128    "Show session cost, plan usage, and activity stats":
129      "Mostrar el coste de la sesión, el uso del plan y estadísticas de actividad",
130    "Print the version this session is running (not what autoupdate downloaded)":
131      "Mostrar la versión que ejecuta esta sesión (no la que descargó la actualización automática)",
132    'Show current context usage':
133      'Mostrar el uso actual del contexto',
134    'Grant or revoke Claude agent access to your Design projects':
135      'Dar o quitar a los agentes de Claude el acceso a tus proyectos de Design',
136    'Toggle the diff panel showing uncommitted changes':
137      'Mostrar u ocultar el panel de diff con los cambios sin confirmar',
138  },
139  config: {
140    autoCompact: 'Compactación automática',
141    autoContinueAtUsageLimit: 'Continuar automáticamente al llegar al límite de uso',
142    switchModelsOnFlag: 'Cambiar de modelo cuando se marca un mensaje',
143    tips: 'Mostrar consejos',
144    reduceMotion: 'Reducir el movimiento',
145    thinking: 'Modo de razonamiento',
146    promptSuggestionEnabled: 'Sugerencias de prompts',
147    recap: 'Resumen de la sesión',
148    checkpoints: 'Rebobinar código (puntos de control)',
149    artifacts: 'Artefactos',
150    verbose: 'Salida detallada',
151    progressBar: 'Barra de progreso en la terminal',
152    turnDuration: 'Mostrar la duración de cada turno',
153    timeFormat: 'Formato de hora',
154    permissionMode: 'Modo de permisos predeterminado',
155    worktreeBaseRef: 'Ref base de los worktrees',
156    useAutoModeDuringPlan: 'Usar el modo automático durante el plan',
157    gitignore: 'Respetar .gitignore en el selector de archivos',
158    copyFullResponse: 'Omitir el selector de /copy',
159    copyOnSelect: 'Copiar al seleccionar',
160    autoScroll: 'Desplazamiento automático',
161    defaultToAgentsView: 'Abrir la vista de agentes por defecto',
162    leftArrowOpensAgents: '← abre los agentes',
163    autoUpdatesChannel: 'Canal de actualizaciones',
164    theme: 'Tema',
165    notifChannel: 'Notificaciones locales',
166    inputNeededNotifEnabled: 'Notificar cuando hagan falta acciones',
167    agentPushNotifEnabled: 'Notificar cuando Claude decida',
168    outputStyle: 'Estilo de salida',
169    language: 'Idioma',
170    editor: 'Modo del editor',
171    askUserQuestionTimeout: 'Tiempo para continuar solo tras una pregunta',
172    externalEditorContext: 'Mostrar la última respuesta en el editor externo',
173    prStatus: 'Mostrar el estado del PR en el pie',
174    model: 'Modelo',
175    autoConnectIde: 'Conectar automáticamente con el IDE (terminal externa)',
176    chrome: 'Claude en Chrome activado por defecto',
177    dialogExpiry: 'Caducidad de los diálogos',
178    feedbackDrafts: 'Comentarios redactados por Claude',
179    fast: 'Modo rápido',
180    workflows: 'Flujos de trabajo dinámicos',
181    workflowKeywordTriggerEnabled: 'Activar con la palabra clave ultracode',
182    workflowSizeGuideline: 'Tamaño de los flujos de trabajo dinámicos',
183    remoteControl: 'Activar Remote Control en todas las sesiones',
184    'cc-plugin-agents-md.instructionFiles': 'Instrucciones del proyecto',
185  },
186  phrases: {
187    shortcuts: '? para atajos',
188    shellMode: '! para modo shell',
189    escInterrupt: 'Esc para interrumpir',
190    escAgainClear: 'Esc otra vez para borrar',
191    doubleEscClear: 'pulsa Esc dos veces para borrar la entrada',
192    pressAgainExit: 'pulsa {1} otra vez para salir',
193    editQueued: '↑ para editar los mensajes en cola',
194    acceptEdits: 'aceptar cambios activado',
195    planMode: 'modo plan activado',
196    autoMode: 'modo automático activado',
197    bypassPermissions: 'omitir permisos activado',
198    manualMode: 'modo manual activado',
199    forAgents: '← para agentes',
200    toCycle: '({1} para cambiar)',
201    toExpand: '({1} para desplegar)',
202    runInBackground: '({1} para segundo plano)',
203    pasteToExpand: 'pega de nuevo para desplegar',
204    toStop: '{1} para detener',
205    holdToSpeak: 'mantén {1} para hablar',
206    sandboxEnabled: 'sandbox activado',
207    sandboxDisabled: 'sandbox desactivado',
208    sandboxAutoAllow: '(permitir automáticamente)',
209    sandboxFallback: ', alternativa permitida',
210    sandboxManaged: '(gestionado)',
211    toConfigure: '(⏎ para configurar)',
212  },
213  modes: {
214    focus: 'enfoque',
215    'memory paused': 'memoria en pausa',
216    brief: 'breve',
217    fast: 'rápido',
218    voice: 'voz',
219  },
220  spinner: [
221    'Cocinando', 'Horneando', 'Rumiando', 'Cavilando', 'Maquinando', 'Tramando', 'Pensando', 'Hilvanando',
222    'Amasando', 'Sazonando', 'Removiendo', 'Fermentando', 'Destilando', 'Elucubrando', 'Trasteando',
223    'Cacharreando', 'Garabateando', 'Ensamblando', 'Puliendo', 'Calculando', 'Deshojando la margarita',
224    'Atando cabos', 'Barruntando', 'Pergeñando', 'Fraguando', 'Bordando', 'Afinando', 'Cuadrando',
225    'Rebuscando', 'Desenredando',
226  ],
227  turn: {
228    words: ['Horneado', 'Destilado', 'Batido', 'Cavilado', 'Cocinado', 'Triturado', 'Salteado', 'Trabajado'],
229    template: '{word} en {duration}',
230  },
231  group: {
232    searched: { one: 'se buscó {n} patrón', other: 'se buscaron {n} patrones' },
233    read: { one: 'se leyó {n} archivo', other: 'se leyeron {n} archivos' },
234    listed: { one: 'se listó {n} directorio', other: 'se listaron {n} directorios' },
235    separator: ', ',
236  },
237  duration: { h: ' h', m: ' min', s: ' s', separator: ' ' },
238  ui: {
239    status: 'Tolk: la interfaz está en {name} ({code}).',
240    coverage: 'Hay {commands} de {commandsTotal} descripciones de comandos y {settings} de {settingsTotal} ajustes traducidos.',
241    available: 'Idiomas disponibles:',
242    switched: 'Cambiado a {name}. Claude Code actualizará las etiquetas en un momento.',
243    unknown: 'Idioma desconocido «{code}». Disponibles: {codes}',
244    missingNone: 'Todos los comandos integrados tienen traducción.',
245    missingHeader: 'Comandos sin traducción:',
246    driftHeader: 'Comandos cuyo texto en inglés cambió desde que se tradujeron:',
247    usage: 'Uso: /tolk [list | set <código> | missing]. Códigos: {codes}',
248    commandDescription: 'Ver o cambiar el idioma de la interfaz (Tolk)',
249    configLabel: 'Idioma de la interfaz (Tolk)',
250  },
251}
252
253export default es
254

1import type { Locale } from './types'
2
3const fr: Locale = {
4  code: 'fr',
5  name: 'Français',
6  commands: {
7    'add-dir': 'Ajouter un nouveau répertoire de travail',
8    advisor: 'Laisser Claude consulter un modèle plus puissant aux moments clés',
9    artifacts: 'Parcourir tes artefacts publiés et partagés',
10    'auto-mode-setup': 'Présenter ton environnement au mode automatique, avec des règles ajustables',
11    autocompact: 'Régler la taille de la fenêtre de compactage automatique',
12    'autofix-pr': 'Surveiller la PR en cours et corriger ses problèmes automatiquement',
13    background: 'Passer cette session en arrière-plan et libérer le terminal',
14    batch: 'Étudier et planifier un changement d’envergure, puis l’exécuter en parallèle avec 5 à 30 agents dans des worktrees isolés qui ouvrent chacun une PR.',
15    branch: 'Créer une branche de la conversation à partir d’ici',
16    brief: 'Activer ou désactiver le mode concis',
17    btw: 'Poser une petite question annexe sans interrompre la conversation',
18    bug: 'Signaler un bug ou partager ta conversation',
19    cd: 'Déplacer cette session dans un autre répertoire de travail',
20    clear: 'Démarrer une nouvelle session au contexte vide ; la précédente reste sur le disque (reprise avec /resume)',
21    'cloud-plugins': 'Choisir si les sessions cloud utilisent les plugins activés sur cette machine',
22    color: 'Choisir la couleur de la barre de saisie pour cette session',
23    compact: 'Libérer du contexte en résumant la conversation jusqu’ici',
24    config: 'Ouvrir les paramètres',
25    context: 'Afficher l’utilisation actuelle du contexte en grille colorée',
26    copy: 'Copier la dernière réponse de Claude dans le presse-papiers (ou /copy N pour la N-ième plus récente)',
27    daemon: 'Gérer les services et routines en arrière-plan',
28    debug: 'Activer la journalisation de débogage pour cette session et aider à diagnostiquer',
29    design: 'Créer un nouvel artefact Design à partir d’un brief',
30    desktop: 'Continuer la session en cours dans Claude Desktop',
31    effort: 'Régler le niveau d’effort du modèle',
32    exit: 'Quitter Claude Code',
33    export: 'Exporter la conversation en cours vers un fichier ou le presse-papiers',
34    fast: 'Activer ou désactiver le mode rapide',
35    feedback: 'Envoyer un avis à Anthropic ou signaler un bug',
36    focus: 'Basculer la vue concentrée : ton message, le résumé et la réponse',
37    fork: 'Lancer un agent en arrière-plan qui reprend toute la conversation',
38    goal: 'Fixer un objectif : continuer jusqu’à ce que la condition soit remplie',
39    help: 'Afficher l’aide et les commandes disponibles',
40    hooks: 'Voir la configuration des hooks pour les événements d’outils',
41    ide: 'Gérer les intégrations IDE et afficher leur état',
42    import: 'Importer la configuration d’un autre agent de code IA',
43    init: 'Créer un fichier CLAUDE.md documentant la base de code',
44    insights: 'Générer un rapport d’analyse de tes sessions Claude Code',
45    'install-github-app': 'Configurer Claude GitHub Actions pour un dépôt',
46    'install-slack-app': 'Installer l’app Claude pour Slack',
47    'list-agents': 'Lister les sous-agents, coéquipiers et autres sessions Claude à qui écrire',
48    login: 'Se connecter avec ton compte Anthropic',
49    logout: 'Se déconnecter de ton compte Anthropic',
50    loop: 'Exécuter un prompt ou une commande à intervalle régulier (ex. /loop 5m /foo). Sans intervalle, le modèle fixe le rythme.',
51    loops: 'Lister, créer et supprimer des boucles',
52    mcp: 'Gérer les serveurs MCP',
53    memory: 'Modifier les fichiers CLAUDE.md et les réglages de mémoire',
54    mobile: 'Afficher le QR code pour télécharger l’app mobile Claude',
55    model: 'Choisir le modèle d’IA de Claude Code',
56    'output-style': 'Lister les styles de sortie ou en changer',
57    permissions: 'Gérer les règles d’autorisation et d’interdiction des outils',
58    plan: 'Activer le mode plan ou afficher le plan de la session',
59    plugin: 'Gérer les plugins de Claude Code',
60    powerup: 'Découvrir Claude Code en courtes leçons interactives',
61    'privacy-settings': 'Voir et modifier tes paramètres de confidentialité',
62    radio: 'Écouter Claude FM, la radio lo-fi',
63    recap: 'Générer maintenant un résumé de la session en une ligne',
64    'release-notes': 'Voir les notes de version',
65    'reload-plugins': 'Appliquer les changements de plugins en attente dans cette session',
66    'reload-skills': 'Prendre en compte les skills ajoutées ou modifiées pendant cette session',
67    'remote-env': 'Choisir l’environnement par défaut des agents cloud',
68    rename: 'Renommer la conversation en cours',
69    resume: 'Reprendre une conversation précédente',
70    rewind: 'Restaurer le code et/ou la conversation à un point antérieur',
71    'security-review': 'Faire une revue de sécurité des changements en attente sur la branche actuelle',
72    session: 'Afficher l’URL et le QR code de la session cloud',
73    'skill-doctor': 'Montrer les skills chargées inutilisées qui coûtent du contexte',
74    skills: 'Lister les skills disponibles',
75    slides: 'Créer une nouvelle présentation à partir d’un brief',
76    status: 'Afficher l’état de Claude Code : version, modèle, compte, connexion à l’API et outils',
77    statusline: 'Configurer la ligne d’état de Claude Code',
78    stickers: 'Commander des autocollants Claude Code',
79    stop: 'Arrêter cette session en arrière-plan ; l’historique et le worktree sont conservés',
80    subtask: 'Envoyer un sous-agent avec tout ton contexte ; son résultat revient ici',
81    tasks: 'Voir et gérer tout ce qui tourne en arrière-plan',
82    'team-onboarding': 'Aider tes coéquipiers à démarrer avec Claude Code grâce à un guide tiré de ton usage',
83    teleport: 'Envoyer cette session dans le cloud, ou en reprendre une depuis claude.ai',
84    theme: 'Changer le thème',
85    tui: 'Choisir le rendu de l’interface du terminal (default | fullscreen)',
86    upgrade: 'Passer à Max pour des limites plus hautes et plus d’Opus',
87    usage: 'Afficher le coût de la session, l’usage du forfait et ce qui pèse sur tes limites',
88    'usage-credits': 'Configurer des crédits d’usage ou en demander à ton admin quand tu atteins une limite',
89    version: 'Afficher la version de cette session (la mise à jour auto en a peut-être une plus récente)',
90    voice: 'Activer ou désactiver le mode vocal',
91    'web-setup': 'Configurer les sessions cloud avec ton compte GitHub',
92    wellbeing: 'Configurer des rappels de pause et des heures calmes facultatifs',
93    workflows: 'Parcourir les workflows en cours et terminés',
94    "code-review": "Relire le diff actuel, une PR, une branche ou un chemin pour y trouver des bugs, au niveau d’effort choisi (low à max ; ultra : revue multi-agents dans le cloud) ; --comment publie les remarques sur la PR, --fix les applique, --post/--no-post règle le commentaire GitHub",
95    "design-consent": "Donner aux agents Claude l’accès à tes projets Design",
96    "design-revoke": "Retirer aux agents Claude l’accès à tes projets Design",
97    "doctor": "Vérifier ton installation de Claude Code et corriger les problèmes : installation, paramètres, skills, serveurs MCP et plugins inutilisés, fichiers CLAUDE.md, hooks lents",
98    "fewer-permission-prompts": "Repérer dans tes historiques les appels Bash et MCP en lecture seule fréquents et ajouter une liste d’autorisations à .claude/settings.json pour moins de demandes",
99    "simplify": "Revoir le code modifié pour la réutilisation, la simplicité et l’efficacité, puis appliquer les corrections. Qualité uniquement : pour les bugs, utilise /code-review",
100    "verify": "Vérifier qu’un changement fait vraiment ce qu’il doit en exécutant le parcours concerné de bout en bout, pas seulement les tests ou le typage",
101    chrome: 'Ouvrir les paramètres de Claude in Chrome',
102    'claim-credit': 'Ouvrir la page de l’offre affichée au démarrage',
103    'design-login': 'Autoriser l’accès aux design systems pour /design-sync avec ton compte claude.ai',
104    diff: 'Voir les modifications non validées et les diffs de chaque tour',
105    'extra-usage': 'Renommée en /usage-credits',
106    keybindings: 'Ouvrir ton fichier de raccourcis clavier',
107    'limit-reset': 'Réinitialiser ta limite de session maintenant et continuer ; une fois par semaine, compte quand même dans ta limite hebdomadaire',
108    'low-priority': 'Continuer maintenant en priorité basse une fois ta limite de session atteinte ; relance pour arrêter',
109    passes: 'Offrir une semaine gratuite de Claude Code à tes amis et gagner des crédits d’usage',
110    'pro-trial-expired': 'Options affichées à la fin de l’essai Claude Code du forfait Pro',
111    'rate-limit-options': 'Gérer les limites d’usage et les options de mise à niveau',
112    'remote-control': 'Piloter cette session depuis ton téléphone ou claude.ai/code',
113    schedule: 'Créer, modifier, lister ou lancer des agents cloud planifiés (routines) qui s’exécutent selon un planning cron.',
114    'setup-bedrock': 'Reconfigurer l’authentification, la région ou les modèles épinglés d’Amazon Bedrock',
115    'setup-vertex': 'Reconfigurer l’authentification, le projet, la région ou les modèles épinglés de Google Vertex AI',
116    'terminal-setup': 'Installer le raccourci Shift+Enter pour aller à la ligne',
117    ultrareview: 'Lancer un agent cloud qui trouve et vérifie les bugs de ta branche (~15-25 min, 5-25 USD) · S’exécute dans une session cloud. Voir https://code.claude.com/docs/en/claude-code-on-the-web',
118  },
119  byText: {
120    "Set a setting by key":
121      "Modifier un paramètre par sa clé",
122    "Copy this conversation into a new background session and keep working here":
123      "Copier cette conversation dans une nouvelle session en arrière-plan et continuer ici",
124    "Set a goal Claude checks before stopping":
125      "Fixer un objectif que Claude vérifie avant de s’arrêter",
126    "Set how full the context gets before auto-summarizing":
127      "Régler le remplissage du contexte avant le résumé automatique",
128    "Show session cost, plan usage, and activity stats":
129      "Afficher le coût de la session, l’usage du forfait et les statistiques d’activité",
130    "Print the version this session is running (not what autoupdate downloaded)":
131      "Afficher la version qu’exécute cette session (pas celle téléchargée par la mise à jour auto)",
132    'Show current context usage':
133      'Afficher l’utilisation actuelle du contexte',
134    'Grant or revoke Claude agent access to your Design projects':
135      'Donner ou retirer aux agents Claude l’accès à tes projets Design',
136    'Toggle the diff panel showing uncommitted changes':
137      'Afficher ou masquer le panneau des modifications non validées',
138  },
139  config: {
140    autoCompact: 'Compactage automatique',
141    autoContinueAtUsageLimit: 'Continuer automatiquement à la limite d’usage',
142    switchModelsOnFlag: 'Changer de modèle quand un message est signalé',
143    tips: 'Afficher les astuces',
144    reduceMotion: 'Réduire les animations',
145    thinking: 'Mode réflexion',
146    promptSuggestionEnabled: 'Suggestions de prompts',
147    recap: 'Résumé de session',
148    checkpoints: 'Rembobiner le code (points de contrôle)',
149    artifacts: 'Artefacts',
150    verbose: 'Sortie détaillée',
151    progressBar: 'Barre de progression du terminal',
152    turnDuration: 'Afficher la durée de chaque tour',
153    timeFormat: 'Format de l’heure',
154    permissionMode: 'Mode d’autorisation par défaut',
155    worktreeBaseRef: 'Réf de base des worktrees',
156    useAutoModeDuringPlan: 'Utiliser le mode auto pendant le plan',
157    gitignore: 'Respecter .gitignore dans le sélecteur de fichiers',
158    copyFullResponse: 'Passer le sélecteur de /copy',
159    copyOnSelect: 'Copier à la sélection',
160    autoScroll: 'Défilement automatique',
161    defaultToAgentsView: 'Ouvrir la vue des agents par défaut',
162    leftArrowOpensAgents: '← ouvre les agents',
163    autoUpdatesChannel: 'Canal de mise à jour',
164    theme: 'Thème',
165    notifChannel: 'Notifications locales',
166    inputNeededNotifEnabled: 'Notifier quand une action est requise',
167    agentPushNotifEnabled: 'Notifier quand Claude décide',
168    outputStyle: 'Style de sortie',
169    language: 'Langue',
170    editor: 'Mode de l’éditeur',
171    askUserQuestionTimeout: 'Délai avant de poursuivre après une question',
172    externalEditorContext: 'Afficher la dernière réponse dans l’éditeur externe',
173    prStatus: 'Afficher l’état de la PR en pied de page',
174    model: 'Modèle',
175    autoConnectIde: 'Connexion auto à l’IDE (terminal externe)',
176    chrome: 'Claude dans Chrome activé par défaut',
177    dialogExpiry: 'Expiration des dialogues',
178    feedbackDrafts: 'Retours rédigés par Claude',
179    fast: 'Mode rapide',
180    workflows: 'Workflows dynamiques',
181    workflowKeywordTriggerEnabled: 'Déclenchement par le mot-clé ultracode',
182    workflowSizeGuideline: 'Taille des workflows dynamiques',
183    remoteControl: 'Activer Remote Control pour toutes les sessions',
184    'cc-plugin-agents-md.instructionFiles': 'Instructions du projet',
185  },
186  phrases: {
187    shortcuts: '? pour les raccourcis',
188    shellMode: '! pour le mode shell',
189    escInterrupt: 'Échap pour interrompre',
190    escAgainClear: 'Échap à nouveau pour effacer',
191    doubleEscClear: 'Échap deux fois pour effacer la saisie',
192    pressAgainExit: 'appuie à nouveau sur {1} pour quitter',
193    editQueued: '↑ pour modifier les messages en attente',
194    acceptEdits: 'accepter les modifs activé',
195    planMode: 'mode plan activé',
196    autoMode: 'mode auto activé',
197    bypassPermissions: 'contourner les autorisations activé',
198    manualMode: 'mode manuel activé',
199    forAgents: '← pour les agents',
200    toCycle: '({1} pour changer)',
201    toExpand: '({1} pour déplier)',
202    runInBackground: '({1} pour l’arrière-plan)',
203    pasteToExpand: 'colle à nouveau pour déplier',
204    toStop: '{1} pour arrêter',
205    holdToSpeak: 'maintiens {1} pour parler',
206    sandboxEnabled: 'sandbox activé',
207    sandboxDisabled: 'sandbox désactivé',
208    sandboxAutoAllow: '(autorisation auto)',
209    sandboxFallback: ', repli autorisé',
210    sandboxManaged: '(géré)',
211    toConfigure: '(⏎ pour configurer)',
212  },
213  modes: {
214    focus: 'concentration',
215    'memory paused': 'mémoire en pause',
216    brief: 'concis',
217    fast: 'rapide',
218    voice: 'voix',
219  },
220  spinner: [
221    'Mijote', 'Cogite', 'Rumine', 'Bricole', 'Mitonne', 'Pétrit', 'Fignole', 'Concocte', 'Réfléchit',
222    'Phosphore', 'Gamberge', 'Turbine', 'Bidouille', 'Peaufine', 'Médite', 'Calcule', 'Assaisonne',
223    'Fait lever la pâte', 'Brasse', 'Distille', 'Tricote', 'Jongle', 'Mouline', 'Échafaude', 'Trame',
224    'Démêle', 'Mûrit', 'Infuse', 'Flambe', 'Tamise',
225  ],
226  turn: {
227    words: ['Cuit', 'Brassé', 'Baratté', 'Cogité', 'Mijoté', 'Concassé', 'Sauté', 'Travaillé'],
228    template: '{word} en {duration}',
229  },
230  group: {
231    searched: { one: '{n} motif recherché', other: '{n} motifs recherchés' },
232    read: { one: '{n} fichier lu', other: '{n} fichiers lus' },
233    listed: { one: '{n} dossier listé', other: '{n} dossiers listés' },
234    separator: ', ',
235  },
236  duration: { h: ' h', m: ' min', s: ' s', separator: ' ' },
237  ui: {
238    status: 'Tolk : l’interface est en {name} ({code}).',
239    coverage: '{commands} descriptions de commandes sur {commandsTotal} et {settings} paramètres sur {settingsTotal} sont traduits.',
240    available: 'Langues disponibles :',
241    switched: 'Passé en {name}. Claude Code met ses libellés à jour dans un instant.',
242    unknown: 'Langue inconnue « {code} ». Disponibles : {codes}',
243    missingNone: 'Chaque commande intégrée a une traduction.',
244    missingHeader: 'Commandes sans traduction :',
245    driftHeader: 'Commandes dont le texte anglais a changé depuis la traduction :',
246    usage: 'Usage : /tolk [list | set <code> | missing]. Codes : {codes}',
247    commandDescription: 'Afficher ou changer la langue de l’interface (Tolk)',
248    configLabel: 'Langue de l’interface (Tolk)',
249  },
250}
251
252export default fr
253

1import type { Locale } from './types'
2
3const it: Locale = {
4  code: 'it',
5  name: 'Italiano',
6  commands: {
7    'add-dir': 'Aggiungi una nuova directory di lavoro',
8    advisor: 'Lascia che Claude consulti un modello più potente nei momenti chiave',
9    artifacts: 'Sfoglia i tuoi artefatti pubblicati e condivisi',
10    'auto-mode-setup': 'Insegna alla modalità automatica il tuo ambiente, con eventuali ritocchi alle regole',
11    autocompact: 'Configura la dimensione della finestra di compattazione automatica',
12    'autofix-pr': 'Monitora la PR attuale e correggi automaticamente i problemi',
13    background: 'Manda questa sessione in background e libera il terminale',
14    batch: 'Studia e pianifica una modifica su larga scala, poi eseguila in parallelo con 5–30 agenti in worktree isolati che aprono una PR ciascuno.',
15    branch: 'Crea un ramo della conversazione attuale a questo punto',
16    brief: 'Attiva o disattiva la modalità breve',
17    btw: 'Fai una domanda veloce a parte senza interrompere la conversazione',
18    bug: 'Segnala un bug o condividi la conversazione',
19    cd: 'Sposta questa sessione in un’altra directory di lavoro',
20    chrome: 'Apri le impostazioni di Claude in Chrome',
21    'claim-credit': 'Apri la pagina dell’offerta mostrata all’avvio',
22    clear: 'Avvia una nuova sessione con contesto vuoto; la precedente resta salvata (riprendibile con /resume)',
23    'cloud-plugins': 'Scegli se le sessioni cloud usano i plugin attivi su questo computer',
24    'code-review': 'Cerca bug nel diff attuale, in una PR, un branch o un percorso, con il livello di impegno scelto (da low a max; ultra: revisione multi-agente nel cloud); --comment pubblica i risultati come commenti nella PR, --fix li applica, --post/--no-post regola il commento su GitHub',
25    color: 'Imposta il colore della barra del prompt per questa sessione',
26    compact: 'Libera contesto riassumendo la conversazione finora',
27    config: 'Apri le impostazioni',
28    context: 'Mostra l’uso attuale del contesto come griglia colorata',
29    copy: 'Copia l’ultima risposta di Claude negli appunti (o /copy N per la N-ultima)',
30    daemon: 'Gestisci servizi in background e routine',
31    debug: 'Attiva il log di debug per questa sessione e aiuta a diagnosticare i problemi',
32    design: 'Crea un nuovo artefatto Design da un brief',
33    'design-consent': 'Dai agli agenti Claude l’accesso ai tuoi progetti Design',
34    'design-login': 'Autorizza l’accesso ai design system per /design-sync con il tuo account claude.ai',
35    'design-revoke': 'Revoca agli agenti Claude l’accesso ai tuoi progetti Design',
36    desktop: 'Continua la sessione attuale in Claude Desktop',
37    diff: 'Vedi le modifiche non committate e i diff di ogni turno',
38    doctor: 'Controlla la configurazione di Claude Code e risolvi i problemi: installazione, impostazioni, skill, server MCP e plugin inutilizzati, file CLAUDE.md, hook lenti',
39    effort: 'Imposta il livello di impegno del modello',
40    exit: 'Esci da Claude Code',
41    export: 'Esporta la conversazione attuale in un file o negli appunti',
42    'extra-usage': 'Rinominato in /usage-credits',
43    fast: 'Attiva o disattiva la modalità veloce',
44    feedback: 'Invia un feedback ad Anthropic o segnala un bug',
45    'fewer-permission-prompts': 'Cerca nelle tue trascrizioni le chiamate Bash e MCP di sola lettura più frequenti e aggiungi una allowlist in .claude/settings.json, per avere meno richieste di permesso',
46    focus: 'Attiva o disattiva la vista focus: solo prompt, riepilogo e risposta',
47    fork: 'Avvia un agente in background che eredita tutta la conversazione',
48    goal: 'Imposta un obiettivo — continua a lavorare finché la condizione non è soddisfatta',
49    help: 'Mostra l’aiuto e i comandi disponibili',
50    hooks: 'Vedi le configurazioni degli hook per gli eventi degli strumenti',
51    ide: 'Gestisci le integrazioni con l’IDE e mostra lo stato',
52    import: 'Importa la configurazione da un altro agente di coding IA',
53    init: 'Crea un nuovo file CLAUDE.md con la documentazione del codice',
54    insights: 'Genera un report che analizza le tue sessioni di Claude Code',
55    'install-github-app': 'Configura Claude GitHub Actions per un repository',
56    'install-slack-app': 'Installa l’app Claude per Slack',
57    keybindings: 'Apri il file delle tue scorciatoie da tastiera',
58    'limit-reset': 'Azzera ora il limite della sessione e continua a lavorare; una volta a settimana, conta comunque nel limite settimanale',
59    'list-agents': 'Elenca subagenti, compagni di team e altre sessioni Claude a cui puoi scrivere',
60    login: 'Accedi con il tuo account Anthropic',
61    logout: 'Esci dal tuo account Anthropic',
62    loop: 'Esegui un prompt o un comando slash a intervalli regolari (es. /loop 5m /foo). Senza intervallo il ritmo lo decide il modello.',
63    loops: 'Elenca, crea ed elimina i loop',
64    'low-priority': 'Continua subito a priorità più bassa dopo aver raggiunto il limite della sessione; eseguilo di nuovo per fermarti',
65    mcp: 'Gestisci i server MCP',
66    memory: 'Modifica i file CLAUDE.md e le impostazioni della memoria',
67    mobile: 'Mostra il codice QR per scaricare l’app Claude',
68    model: 'Imposta il modello IA per Claude Code',
69    'output-style': 'Elenca gli stili di output o passa a uno',
70    passes: 'Regala agli amici una settimana gratis di Claude Code e guadagna crediti di utilizzo',
71    permissions: 'Gestisci le regole che consentono o negano gli strumenti',
72    plan: 'Attiva la modalità piano o vedi il piano della sessione',
73    plugin: 'Gestisci i plugin di Claude Code',
74    powerup: 'Scopri le funzioni di Claude Code con brevi lezioni interattive',
75    'privacy-settings': 'Vedi e modifica le impostazioni sulla privacy',
76    'pro-trial-expired': 'Opzioni mostrate alla fine della prova di Claude Code nel piano Pro',
77    radio: 'Ascolta Claude FM, radio lo-fi',
78    'rate-limit-options': 'Gestisci i limiti di utilizzo e le opzioni di upgrade',
79    recap: 'Genera ora un riepilogo della sessione in una riga',
80    'release-notes': 'Vedi le note di rilascio',
81    'reload-plugins': 'Attiva le modifiche ai plugin in sospeso nella sessione attuale',
82    'reload-skills': 'Carica le skill aggiunte o modificate su disco durante questa sessione',
83    'remote-control': 'Controlla questa sessione dal telefono o da claude.ai/code',
84    'remote-env': 'Scegli l’ambiente predefinito per gli agenti cloud',
85    rename: 'Rinomina la conversazione attuale',
86    resume: 'Riprendi una conversazione precedente',
87    rewind: 'Riporta il codice e/o la conversazione a un punto precedente',
88    schedule: 'Crea, modifica, elenca o esegui agenti cloud pianificati (routine) che girano secondo una pianificazione cron.',
89    'security-review': 'Esegui una revisione di sicurezza delle modifiche in sospeso nel branch attuale',
90    session: 'Mostra l’URL e il codice QR della sessione cloud',
91    'setup-bedrock': 'Riconfigura autenticazione, regione o modelli fissati di Amazon Bedrock',
92    'setup-vertex': 'Riconfigura autenticazione, progetto, regione o modelli fissati di Google Vertex AI',
93    simplify: 'Rivedi il codice modificato per riuso, semplificazione ed efficienza, poi applica le correzioni. Solo qualità: per cercare bug usa /code-review',
94    'skill-doctor': 'Mostra quali skill caricate sono inutilizzate e consumano contesto',
95    skills: 'Elenca le skill disponibili',
96    slides: 'Crea una nuova presentazione Slides da un brief',
97    status: 'Mostra lo stato di Claude Code: versione, modello, account, connessione API e strumenti',
98    statusline: 'Configura la riga di stato di Claude Code',
99    stickers: 'Ordina gli adesivi di Claude Code',
100    stop: 'Ferma questa sessione in background; trascrizione e worktree restano',
101    subtask: 'Manda un subagente con tutto il tuo contesto; il risultato torna qui',
102    tasks: 'Vedi e gestisci tutto ciò che gira in background',
103    'team-onboarding': 'Aiuta i colleghi a iniziare con Claude Code grazie a una guida basata sul tuo uso',
104    teleport: 'Manda questa sessione nel cloud, o riprendine una da claude.ai',
105    'terminal-setup': 'Installa la scorciatoia Shift+Enter per andare a capo',
106    theme: 'Cambia il tema',
107    tui: 'Imposta il renderer dell’interfaccia del terminale (default | fullscreen)',
108    ultrareview: 'Avvia un agente cloud che trova e verifica i bug nel tuo branch (~15-25 min, 5-25 USD) · Gira in una sessione cloud. Vedi https://code.claude.com/docs/en/claude-code-on-the-web',
109    upgrade: 'Passa a Max per limiti più alti e più Opus',
110    usage: 'Mostra il costo della sessione, l’uso del piano e cosa incide sui tuoi limiti',
111    'usage-credits': 'Configura i crediti di utilizzo o chiedili al tuo admin quando raggiungi un limite',
112    verify: 'Verifica che una modifica faccia davvero ciò che deve, eseguendo il flusso interessato da capo a fondo — non solo test o controllo dei tipi',
113    version: 'Mostra la versione di questa sessione (l’aggiornamento automatico potrebbe averne una più nuova)',
114    voice: 'Attiva o disattiva la modalità vocale',
115    'web-setup': 'Configura le sessioni cloud con il tuo account GitHub',
116    wellbeing: 'Configura promemoria facoltativi per le pause e avvisi nelle ore di quiete',
117    workflows: 'Sfoglia i workflow in corso e completati',
118  },
119  byText: {
120    'Set a setting by key':
121      'Cambia un’impostazione tramite la sua chiave',
122    'Copy this conversation into a new background session and keep working here':
123      'Copia questa conversazione in una nuova sessione in background e continua a lavorare qui',
124    'Set a goal Claude checks before stopping':
125      'Imposta un obiettivo che Claude controlla prima di fermarsi',
126    'Set how full the context gets before auto-summarizing':
127      'Imposta quanto può riempirsi il contesto prima del riassunto automatico',
128    'Show session cost, plan usage, and activity stats':
129      'Mostra il costo della sessione, l’uso del piano e le statistiche di attività',
130    'Print the version this session is running (not what autoupdate downloaded)':
131      'Stampa la versione di questa sessione (non quella scaricata dall’aggiornamento automatico)',
132    'Show current context usage':
133      'Mostra l’uso attuale del contesto',
134    'Grant or revoke Claude agent access to your Design projects':
135      'Dai o revoca agli agenti Claude l’accesso ai tuoi progetti Design',
136    'Toggle the diff panel showing uncommitted changes':
137      'Mostra o nascondi il pannello del diff con le modifiche non committate',
138  },
139  config: {
140    autoCompact: 'Compattazione automatica',
141    autoContinueAtUsageLimit: 'Continua automaticamente al limite di utilizzo',
142    switchModelsOnFlag: 'Cambia modello quando un messaggio viene segnalato',
143    tips: 'Mostra suggerimenti',
144    feedbackDrafts: 'Feedback scritto da Claude',
145    reduceMotion: 'Riduci movimento',
146    thinking: 'Modalità ragionamento',
147    fast: 'Modalità veloce',
148    promptSuggestionEnabled: 'Suggerimenti di prompt',
149    recap: 'Riepilogo della sessione',
150    checkpoints: 'Riavvolgi codice (checkpoint)',
151    workflows: 'Workflow dinamici',
152    workflowKeywordTriggerEnabled: 'Attivazione con la parola chiave ultracode',
153    workflowSizeGuideline: 'Dimensione dei workflow dinamici',
154    artifacts: 'Artefatti',
155    verbose: 'Output dettagliato',
156    progressBar: 'Barra di avanzamento nel terminale',
157    turnDuration: 'Mostra durata del turno',
158    timeFormat: 'Formato dell’ora',
159    permissionMode: 'Modalità di autorizzazione predefinita',
160    worktreeBaseRef: 'Ref di base dei worktree',
161    useAutoModeDuringPlan: 'Usa la modalità automatica durante il piano',
162    gitignore: 'Rispetta .gitignore nel selettore di file',
163    copyFullResponse: 'Salta la scelta di /copy',
164    copyOnSelect: 'Copia alla selezione',
165    autoScroll: 'Scorrimento automatico',
166    defaultToAgentsView: 'Apri la vista agenti all’avvio',
167    leftArrowOpensAgents: '← apre gli agenti',
168    autoUpdatesChannel: 'Canale degli aggiornamenti',
169    theme: 'Tema',
170    notifChannel: 'Notifiche locali',
171    inputNeededNotifEnabled: 'Push quando serve un’azione',
172    agentPushNotifEnabled: 'Push quando Claude decide',
173    outputStyle: 'Stile di output',
174    language: 'Lingua',
175    editor: 'Modalità editor',
176    askUserQuestionTimeout: 'Timeout per continuare dopo una domanda',
177    externalEditorContext: 'Mostra l’ultima risposta nell’editor esterno',
178    prStatus: 'Mostra lo stato della PR nel piè di pagina',
179    model: 'Modello',
180    autoConnectIde: 'Connetti automaticamente all’IDE (terminale esterno)',
181    chrome: 'Claude in Chrome attivo per impostazione predefinita',
182    remoteControl: 'Attiva Remote Control per tutte le sessioni',
183    dialogExpiry: 'Scadenza delle finestre di dialogo',
184    'cc-plugin-agents-md.instructionFiles': 'Istruzioni del progetto',
185  },
186  phrases: {
187    shortcuts: '? per le scorciatoie',
188    shellMode: '! per la modalità shell',
189    escInterrupt: 'Esc per interrompere',
190    escAgainClear: 'Esc di nuovo per cancellare',
191    doubleEscClear: 'Esc due volte per cancellare l’input',
192    pressAgainExit: 'Premi di nuovo {1} per uscire',
193    editQueued: '↑ per modificare i messaggi in coda',
194    acceptEdits: 'accetta modifiche attivo',
195    planMode: 'modalità piano attiva',
196    autoMode: 'modalità automatica attiva',
197    bypassPermissions: 'bypass dei permessi attivo',
198    manualMode: 'modalità manuale attiva',
199    forAgents: '← per gli agenti',
200    toCycle: '({1} per cambiare)',
201    toExpand: '({1} per espandere)',
202    runInBackground: '({1} in background)',
203    pasteToExpand: 'incolla di nuovo per espandere',
204    toStop: '{1} per fermare',
205    holdToSpeak: 'tieni premuto {1} per parlare',
206    sandboxEnabled: 'sandbox attiva',
207    sandboxDisabled: 'sandbox disattivata',
208    sandboxAutoAllow: '(consenso automatico)',
209    sandboxFallback: ', fallback consentito',
210    sandboxManaged: '(gestita)',
211    toConfigure: '(⏎ per configurare)',
212  },
213  modes: {
214    focus: 'focus',
215    'memory paused': 'memoria in pausa',
216    brief: 'breve',
217    fast: 'veloce',
218    voice: 'voce',
219  },
220  spinner: [
221    'Rimuginando', 'Arzigogolando', 'Almanaccando', 'Elucubrando', 'Lambiccando', 'Escogitando', 'Macchinando',
222    'Congegnando', 'Armeggiando', 'Trafficando', 'Pasticciando', 'Rimestando', 'Cucinando', 'Spignattando',
223    'Impastando', 'Mantecando', 'Rosolando', 'Sobbollendo', 'Lievitando', 'Infornando', 'Frullando',
224    'Sferruzzando', 'Scarabocchiando', 'Fantasticando', 'Filosofeggiando', 'Ponderando', 'Distillando',
225    'Gironzolando', 'Bighellonando', 'Zampettando', 'Ghiribizzando', 'Tramando',
226  ],
227  turn: {
228    words: ['Cotto', 'Sfornato', 'Cucinato', 'Rosolato', 'Mantecato', 'Rimuginato', 'Almanaccato', 'Lavorato'],
229    template: '{word} per {duration}',
230  },
231  group: {
232    searched: { one: 'cercato {n} pattern', other: 'cercati {n} pattern' },
233    read: { one: 'letto {n} file', other: 'letti {n} file' },
234    listed: { one: 'elencata {n} cartella', other: 'elencate {n} cartelle' },
235    separator: ', ',
236  },
237  duration: { h: ' h', m: ' min', s: ' s', separator: ' ' },
238  ui: {
239    status: 'Tolk: l’interfaccia è in {name} ({code}).',
240    coverage: 'Tradotte {commands} descrizioni di comandi su {commandsTotal} e {settings} impostazioni su {settingsTotal}.',
241    available: 'Lingue disponibili:',
242    switched: 'Lingua impostata su {name}. Claude Code aggiorna le etichette tra un attimo.',
243    unknown: 'Lingua «{code}» sconosciuta. Disponibili: {codes}',
244    missingNone: 'Ogni comando integrato sullo schermo ha una traduzione.',
245    missingHeader: 'Comandi senza traduzione:',
246    driftHeader: 'Comandi il cui testo inglese è cambiato dopo la traduzione:',
247    usage: 'Uso: /tolk [list | set <codice> | missing]. Codici: {codes}',
248    commandDescription: 'Mostra o cambia la lingua dell’interfaccia (Tolk)',
249    configLabel: 'Lingua dell’interfaccia (Tolk)',
250  },
251}
252
253export default it
254

1import type { Locale } from './types'
2
3const ja: Locale = {
4  code: 'ja',
5  name: '日本語',
6  commands: {
7    'add-dir': '作業ディレクトリを追加',
8    advisor: '重要な場面で Claude がより強力なモデルに相談できるようにする',
9    artifacts: '公開・共有したアーティファクトを表示',
10    'auto-mode-setup': 'オートモードに環境を教え、必要に応じてルールを調整',
11    autocompact: '自動コンパクトのウィンドウサイズを設定',
12    'autofix-pr': '現在の PR を監視し、問題を自動で修正',
13    background: 'このセッションをバックグラウンドに移し、ターミナルを空ける',
14    batch: '大規模な変更を調査・計画し、5〜30 個の独立した worktree エージェントで並行実行して、それぞれが PR を作成します。',
15    branch: '現在の会話をこの時点から分岐',
16    brief: '簡潔モードを切り替え',
17    btw: 'メインの会話を中断せずにちょっとした質問をする',
18    bug: 'バグを報告、または会話を共有',
19    cd: 'このセッションを別の作業ディレクトリに移動',
20    clear: 'コンテキストを空にして新しいセッションを開始（前のセッションは保存され、/resume で再開可能）',
21    'cloud-plugins': 'クラウドセッションでこのマシンの有効なプラグインを使うか選択',
22    color: 'このセッションの入力バーの色を設定',
23    compact: 'これまでの会話を要約してコンテキストを空ける',
24    config: '設定を開く',
25    context: '現在のコンテキスト使用量を色付きのグリッドで表示',
26    copy: 'Claude の最後の応答をクリップボードにコピー（/copy N で N 番目に新しい応答）',
27    daemon: 'バックグラウンドのサービスとルーチンを管理',
28    debug: 'このセッションでデバッグログを有効にし、問題の診断を手伝う',
29    design: 'ブリーフから新しいデザインのアーティファクトを作成',
30    desktop: '現在のセッションを Claude Desktop で続ける',
31    effort: 'モデルの思考レベルを設定',
32    exit: 'Claude Code を終了',
33    export: '現在の会話をファイルまたはクリップボードに書き出す',
34    fast: '高速モードを切り替え',
35    feedback: 'Anthropic にフィードバックを送る、またはバグを報告',
36    focus: 'フォーカス表示を切り替え（プロンプト・要約・応答のみ）',
37    fork: '会話全体を引き継ぐバックグラウンドエージェントを起動',
38    goal: '目標を設定し、条件を満たすまで作業を続ける',
39    help: 'ヘルプと使えるコマンドを表示',
40    hooks: 'ツールイベントのフック設定を表示',
41    ide: 'IDE 連携を管理し、状態を表示',
42    import: '他の AI コーディングエージェントから設定を取り込む',
43    init: 'コードベースの説明を書いた CLAUDE.md を新規作成',
44    insights: 'Claude Code のセッションを分析したレポートを作成',
45    'install-github-app': 'リポジトリに Claude GitHub Actions を設定',
46    'install-slack-app': 'Slack 用 Claude アプリをインストール',
47    'list-agents': 'メッセージを送れるサブエージェント・チームメイト・他の Claude セッションを一覧表示',
48    login: 'Anthropic アカウントでログイン',
49    logout: 'Anthropic アカウントからログアウト',
50    loop: 'プロンプトやコマンドを一定間隔で実行（例: /loop 5m /foo）。間隔を省くとモデルがペースを決めます。',
51    loops: 'ループの一覧・作成・削除',
52    mcp: 'MCP サーバーを管理',
53    memory: 'CLAUDE.md ファイルとメモリ設定を編集',
54    mobile: 'Claude モバイルアプリのダウンロード用 QR コードを表示',
55    model: 'Claude Code の AI モデルを設定',
56    'output-style': '出力スタイルの一覧表示・切り替え',
57    permissions: 'ツールの許可・拒否ルールを管理',
58    plan: 'プランモードを有効にする、または現在のプランを表示',
59    plugin: 'Claude Code のプラグインを管理',
60    powerup: '短いインタラクティブなレッスンで Claude Code の機能を知る',
61    'privacy-settings': 'プライバシー設定を表示・変更',
62    radio: 'Claude FM（ローファイラジオ）を聴く',
63    recap: 'セッションの一行要約を今すぐ作成',
64    'release-notes': 'リリースノートを表示',
65    'reload-plugins': '保留中のプラグイン変更を現在のセッションに反映',
66    'reload-skills': 'このセッション中に追加・変更されたスキルを読み込む',
67    'remote-env': 'クラウドエージェントの既定の環境を選択',
68    rename: '現在の会話の名前を変更',
69    resume: '以前の会話を再開',
70    rewind: 'コードや会話を以前の状態に戻す',
71    'security-review': '現在のブランチの未確定の変更をセキュリティレビュー',
72    session: 'クラウドセッションの URL と QR コードを表示',
73    'skill-doctor': '読み込まれているのに使われず、コンテキストを消費しているスキルを表示',
74    skills: '使えるスキルを一覧表示',
75    slides: 'ブリーフから新しいスライドを作成',
76    status: 'Claude Code の状態を表示（バージョン、モデル、アカウント、API 接続、ツール）',
77    statusline: 'Claude Code のステータスラインを設定',
78    stickers: 'Claude Code のステッカーを注文',
79    stop: 'このバックグラウンドセッションを停止（履歴と worktree は残ります）',
80    subtask: '全コンテキストを持たせてサブエージェントを送り出し、結果をここで受け取る',
81    tasks: 'バックグラウンドで実行中のものを表示・管理',
82    'team-onboarding': 'あなたの使い方をもとにしたガイドで、チームメイトの Claude Code 導入を手助け',
83    teleport: 'このセッションをクラウドに送る、または claude.ai から再開',
84    theme: 'テーマを変更',
85    tui: 'ターミナル UI の描画方式を設定（default | fullscreen）',
86    upgrade: 'Max にアップグレードして上限を引き上げ、Opus をもっと使う',
87    usage: 'セッションのコスト、プランの使用量、上限に影響しているものを表示',
88    'usage-credits': '利用クレジットを設定、または上限に達したとき管理者に依頼',
89    version: 'このセッションのバージョンを表示（自動更新で新しい版がある場合があります）',
90    voice: '音声モードを切り替え',
91    'web-setup': 'GitHub アカウントでクラウドセッションを設定',
92    wellbeing: '休憩リマインダーと静かな時間帯を設定（任意）',
93    workflows: '実行中・完了したワークフローを表示',
94    "code-review": "現在の差分、PR、ブランチ、パスのバグをレビュー（思考レベル low〜max、ultra はクラウドのマルチエージェント）。--comment で PR にコメント、--fix で修正を適用、--post/--no-post で GitHub コメントを制御",
95    "design-consent": "Claude エージェントに Design プロジェクトへのアクセスを許可",
96    "design-revoke": "Claude エージェントの Design プロジェクトへのアクセスを取り消す",
97    "doctor": "Claude Code の環境を点検して問題を修正（インストール、設定、未使用のスキル・MCP サーバー・プラグイン、CLAUDE.md、遅いフック）",
98    "fewer-permission-prompts": "履歴からよく使う読み取り専用の Bash・MCP 呼び出しを探し、.claude/settings.json に許可リストを追加して確認を減らす",
99    "simplify": "変更したコードを再利用・簡素化・効率の観点で見直し、修正を適用。品質のみが対象で、バグ探しは /code-review",
100    "verify": "テストや型チェックだけでなく、影響する処理を最初から最後まで実際に動かして、変更が意図どおりか確かめる",
101    chrome: 'Claude in Chrome の設定を開く',
102    'claim-credit': '起動時に表示されたオファーのページを開く',
103    'design-login': 'claude.ai アカウントで /design-sync のデザインシステムへのアクセスを許可',
104    diff: '未コミットの変更とターンごとの差分を表示',
105    'extra-usage': '/usage-credits に名前が変わりました',
106    keybindings: 'キーボードショートカットのファイルを開く',
107    'limit-reset': 'セッションの上限を今すぐリセットして作業を続ける（週 1 回、週の上限には計上されます）',
108    'low-priority': 'セッションの上限に達した後、優先度を下げて今すぐ続ける（もう一度実行で停止）',
109    passes: '友だちに Claude Code の無料 1 週間をシェアして利用クレジットを獲得',
110    'pro-trial-expired': 'Pro プランの Claude Code トライアル終了時のオプション',
111    'rate-limit-options': '利用上限とアップグレードのオプションを管理',
112    'remote-control': 'スマートフォンや claude.ai/code からこのセッションを操作',
113    schedule: 'cron スケジュールで実行されるクラウドエージェント（ルーティン）を作成・更新・一覧表示・実行',
114    'setup-bedrock': 'Amazon Bedrock の認証、リージョン、固定モデルを設定し直す',
115    'setup-vertex': 'Google Vertex AI の認証、プロジェクト、リージョン、固定モデルを設定し直す',
116    'terminal-setup': '改行用の Shift+Enter キーバインドをインストール',
117    ultrareview: 'ブランチのバグを見つけて検証するクラウドエージェントを開始（約 15〜25 分、5〜25 米ドル）· クラウドセッションで実行。詳細: https://code.claude.com/docs/en/claude-code-on-the-web',
118  },
119  byText: {
120    "Set a setting by key":
121      "キーを指定して設定を変更",
122    "Copy this conversation into a new background session and keep working here":
123      "この会話を新しいバックグラウンドセッションにコピーし、ここで作業を続ける",
124    "Set a goal Claude checks before stopping":
125      "Claude が終了前に確認する目標を設定",
126    "Set how full the context gets before auto-summarizing":
127      "自動要約の前にコンテキストをどこまで使うか設定",
128    "Show session cost, plan usage, and activity stats":
129      "セッションのコスト、プランの使用量、アクティビティの統計を表示",
130    "Print the version this session is running (not what autoupdate downloaded)":
131      "このセッションで実行中のバージョンを表示（自動更新でダウンロードされたものではありません）",
132    'Show current context usage':
133      '現在のコンテキスト使用量を表示',
134    'Grant or revoke Claude agent access to your Design projects':
135      'Claude エージェントの Design プロジェクトへのアクセスを許可・取り消し',
136    'Toggle the diff panel showing uncommitted changes':
137      '未コミットの変更を表示する差分パネルを切り替え',
138  },
139  config: {
140    autoCompact: '自動コンパクト',
141    autoContinueAtUsageLimit: '使用上限で自動的に続行',
142    switchModelsOnFlag: 'メッセージにフラグが付いたらモデルを切り替え',
143    tips: 'ヒントを表示',
144    reduceMotion: '動きを減らす',
145    thinking: '思考モード',
146    promptSuggestionEnabled: 'プロンプトの提案',
147    recap: 'セッションの要約',
148    checkpoints: 'コードの巻き戻し（チェックポイント）',
149    artifacts: 'アーティファクト',
150    verbose: '詳細な出力',
151    progressBar: 'ターミナルの進行状況バー',
152    turnDuration: 'ターンの所要時間を表示',
153    timeFormat: '時刻の形式',
154    permissionMode: '既定の権限モード',
155    worktreeBaseRef: 'worktree の基準 ref',
156    useAutoModeDuringPlan: 'プラン中にオートモードを使う',
157    gitignore: 'ファイル選択で .gitignore を尊重',
158    copyFullResponse: '/copy の選択をスキップ',
159    copyOnSelect: '選択時にコピー',
160    autoScroll: '自動スクロール',
161    defaultToAgentsView: 'エージェント表示を既定で開く',
162    leftArrowOpensAgents: '← でエージェントを開く',
163    autoUpdatesChannel: '自動更新チャンネル',
164    theme: 'テーマ',
165    notifChannel: 'ローカル通知',
166    inputNeededNotifEnabled: '操作が必要なときにプッシュ通知',
167    agentPushNotifEnabled: 'Claude が判断したときにプッシュ通知',
168    outputStyle: '出力スタイル',
169    language: '言語',
170    editor: 'エディターモード',
171    askUserQuestionTimeout: '質問の自動続行までの時間',
172    externalEditorContext: '外部エディターに最後の応答を表示',
173    prStatus: 'フッターに PR の状態を表示',
174    model: 'モデル',
175    autoConnectIde: 'IDE に自動接続（外部ターミナル）',
176    chrome: 'Claude in Chrome を既定で有効化',
177    dialogExpiry: 'ダイアログの有効期限',
178    feedbackDrafts: 'Claude が下書きしたフィードバック',
179    fast: '高速モード',
180    workflows: '動的ワークフロー',
181    workflowKeywordTriggerEnabled: 'ultracode キーワードで起動',
182    workflowSizeGuideline: '動的ワークフローの規模',
183    remoteControl: 'すべてのセッションで Remote Control を有効化',
184    'cc-plugin-agents-md.instructionFiles': 'プロジェクトの指示',
185  },
186  phrases: {
187    shortcuts: '? でショートカット',
188    shellMode: '! でシェルモード',
189    escInterrupt: 'Esc で中断',
190    escAgainClear: 'もう一度 Esc でクリア',
191    doubleEscClear: 'Esc を 2 回押して入力をクリア',
192    pressAgainExit: 'もう一度 {1} で終了',
193    editQueued: '↑ で待機中のメッセージを編集',
194    acceptEdits: '編集の自動承認 オン',
195    planMode: 'プランモード オン',
196    autoMode: 'オートモード オン',
197    bypassPermissions: '権限確認スキップ オン',
198    manualMode: 'マニュアルモード オン',
199    forAgents: '← でエージェント',
200    toCycle: '（{1} で切り替え）',
201    toExpand: '（{1} で展開）',
202    runInBackground: '（{1} でバックグラウンド実行）',
203    pasteToExpand: 'もう一度貼り付けで展開',
204    toStop: '{1} で停止',
205    holdToSpeak: '{1} を押したまま話す',
206    sandboxEnabled: 'サンドボックス有効',
207    sandboxDisabled: 'サンドボックス無効',
208    sandboxAutoAllow: '（自動許可）',
209    sandboxFallback: '、フォールバック可',
210    sandboxManaged: '（管理対象）',
211    toConfigure: '（⏎ で設定）',
212  },
213  modes: {
214    focus: 'フォーカス',
215    'memory paused': 'メモリ一時停止',
216    brief: '簡潔',
217    fast: '高速',
218    voice: '音声',
219  },
220  spinner: [
221    '考え中', '思案中', '熟考中', '煮込み中', '焼き上げ中', '仕込み中', '発酵中', '醸造中', '練り上げ中',
222    '組み立て中', '磨き上げ中', '計算中', '調理中', '下ごしらえ中', 'ひらめき待ち', '試行錯誤中',
223    '頭をひねり中', '構想中', '編み上げ中', 'こね回し中', '味見中', '寝かせ中', '整理中', 'ひもとき中',
224    '紡ぎ中', '工夫中', '錬成中', '推敲中', 'もくもく作業中', 'うんうん唸り中',
225  ],
226  turn: {
227    words: ['焼き上がり', '醸造完了', '撹拌完了', '熟考完了', '調理完了', '粉砕完了', 'ソテー完了', '作業完了'],
228    template: '{word}（{duration}）',
229  },
230  group: {
231    searched: { one: '{n} 件のパターンを検索', other: '{n} 件のパターンを検索' },
232    read: { one: '{n} 件のファイルを読み込み', other: '{n} 件のファイルを読み込み' },
233    listed: { one: '{n} 件のディレクトリを一覧表示', other: '{n} 件のディレクトリを一覧表示' },
234    separator: '、',
235  },
236  duration: { h: '時間', m: '分', s: '秒', separator: '' },
237  ui: {
238    status: 'Tolk: インターフェースの言語は {name}（{code}）です。',
239    coverage: 'コマンド説明 {commandsTotal} 件中 {commands} 件、設定 {settingsTotal} 件中 {settings} 件を翻訳済み。',
240    available: '利用できる言語:',
241    switched: '{name} に切り替えました。まもなく表示が更新されます。',
242    unknown: '不明な言語「{code}」です。利用可能: {codes}',
243    missingNone: 'すべての組み込みコマンドに翻訳があります。',
244    missingHeader: '翻訳のないコマンド:',
245    driftHeader: '翻訳後に英語の原文が変わったコマンド:',
246    usage: '使い方: /tolk [list | set <コード> | missing]。コード: {codes}',
247    commandDescription: 'インターフェースの言語を表示・変更（Tolk）',
248    configLabel: 'インターフェースの言語（Tolk）',
249  },
250}
251
252export default ja
253

1import type { Locale } from './types'
2
3const ptBR: Locale = {
4  code: 'pt-BR',
5  name: 'Português (Brasil)',
6  commands: {
7    'add-dir': 'Adicionar um novo diretório de trabalho',
8    advisor: 'Deixar o Claude consultar um modelo mais forte em momentos importantes',
9    artifacts: 'Ver seus artefatos publicados e compartilhados',
10    'auto-mode-setup': 'Ensinar ao modo automático como é seu ambiente, com ajustes opcionais de regras',
11    autocompact: 'Configurar o tamanho da janela de compactação automática',
12    'autofix-pr': 'Acompanhar o PR atual e corrigir problemas automaticamente',
13    background: 'Mandar esta sessão para segundo plano e liberar o terminal',
14    batch: 'Pesquisar e planejar uma mudança grande e executá-la em paralelo com 5–30 agentes em worktrees isolados, cada um abrindo um PR.',
15    branch: 'Criar um ramo da conversa atual a partir deste ponto',
16    brief: 'Ativar ou desativar o modo resumido',
17    btw: 'Fazer uma pergunta rápida sem interromper a conversa principal',
18    bug: 'Relatar um bug ou compartilhar sua conversa',
19    cd: 'Mover esta sessão para outro diretório de trabalho',
20    clear: 'Começar uma sessão nova com o contexto vazio; a anterior fica salva (retome com /resume)',
21    'cloud-plugins': 'Escolher se as sessões na nuvem usam os plugins ativados nesta máquina',
22    color: 'Definir a cor da barra de entrada nesta sessão',
23    compact: 'Liberar contexto resumindo a conversa até aqui',
24    config: 'Abrir as configurações',
25    context: 'Mostrar o uso atual do contexto como uma grade colorida',
26    copy: 'Copiar a última resposta do Claude para a área de transferência (ou /copy N para a N-ésima mais recente)',
27    daemon: 'Gerenciar serviços e rotinas em segundo plano',
28    debug: 'Ativar o log de depuração nesta sessão e ajudar a diagnosticar problemas',
29    design: 'Criar um novo artefato de design a partir de um briefing',
30    desktop: 'Continuar a sessão atual no Claude Desktop',
31    effort: 'Definir o nível de esforço do modelo',
32    exit: 'Sair do Claude Code',
33    export: 'Exportar a conversa atual para um arquivo ou para a área de transferência',
34    fast: 'Ativar ou desativar o modo rápido',
35    feedback: 'Enviar feedback para a Anthropic ou relatar um bug',
36    focus: 'Alternar a visão de foco: só seu prompt, o resumo e a resposta',
37    fork: 'Criar um agente em segundo plano que herda a conversa inteira',
38    goal: 'Definir uma meta: continuar trabalhando até a condição ser cumprida',
39    help: 'Mostrar a ajuda e os comandos disponíveis',
40    hooks: 'Ver as configurações de hooks para eventos de ferramentas',
41    ide: 'Gerenciar integrações com IDEs e ver o status',
42    import: 'Importar configurações de outro agente de programação com IA',
43    init: 'Criar um arquivo CLAUDE.md com a documentação do código',
44    insights: 'Gerar um relatório que analisa suas sessões do Claude Code',
45    'install-github-app': 'Configurar o Claude GitHub Actions em um repositório',
46    'install-slack-app': 'Instalar o app do Claude para o Slack',
47    'list-agents': 'Listar subagentes, colegas de equipe e outras sessões do Claude para quem você pode escrever',
48    login: 'Entrar com sua conta da Anthropic',
49    logout: 'Sair da sua conta da Anthropic',
50    loop: 'Executar um prompt ou comando em intervalos (ex.: /loop 5m /foo). Sem intervalo, o modelo define o ritmo.',
51    loops: 'Listar, criar e excluir loops',
52    mcp: 'Gerenciar servidores MCP',
53    memory: 'Editar arquivos CLAUDE.md e configurações de memória',
54    mobile: 'Mostrar o QR code para baixar o app do Claude',
55    model: 'Definir o modelo de IA do Claude Code',
56    'output-style': 'Listar estilos de saída ou trocar para um deles',
57    permissions: 'Gerenciar regras que permitem ou bloqueiam ferramentas',
58    plan: 'Ativar o modo de planejamento ou ver o plano da sessão',
59    plugin: 'Gerenciar plugins do Claude Code',
60    powerup: 'Descobrir recursos do Claude Code em lições interativas rápidas',
61    'privacy-settings': 'Ver e alterar suas configurações de privacidade',
62    radio: 'Ouvir a Claude FM, rádio lo-fi',
63    recap: 'Gerar agora um resumo da sessão em uma linha',
64    'release-notes': 'Ver as notas da versão',
65    'reload-plugins': 'Aplicar as alterações pendentes de plugins na sessão atual',
66    'reload-skills': 'Carregar skills adicionadas ou alteradas durante esta sessão',
67    'remote-env': 'Escolher o ambiente padrão dos agentes na nuvem',
68    rename: 'Renomear a conversa atual',
69    resume: 'Retomar uma conversa anterior',
70    rewind: 'Restaurar o código e/ou a conversa para um ponto anterior',
71    'security-review': 'Fazer uma revisão de segurança das alterações pendentes no branch atual',
72    session: 'Mostrar a URL e o QR code da sessão na nuvem',
73    'skill-doctor': 'Mostrar quais skills carregadas não são usadas e gastam contexto',
74    skills: 'Listar as skills disponíveis',
75    slides: 'Criar uma nova apresentação a partir de um briefing',
76    status: 'Mostrar o status do Claude Code: versão, modelo, conta, conexão com a API e ferramentas',
77    statusline: 'Configurar a linha de status do Claude Code',
78    stickers: 'Pedir adesivos do Claude Code',
79    stop: 'Encerrar esta sessão em segundo plano; o histórico e o worktree são mantidos',
80    subtask: 'Enviar um subagente com todo o seu contexto; o resultado volta para cá',
81    tasks: 'Ver e gerenciar tudo o que roda em segundo plano',
82    'team-onboarding': 'Ajudar colegas a começar no Claude Code com um guia baseado no seu uso',
83    teleport: 'Mandar esta sessão para a nuvem ou retomar uma do claude.ai',
84    theme: 'Mudar o tema',
85    tui: 'Definir como a interface do terminal é desenhada (default | fullscreen)',
86    upgrade: 'Fazer upgrade para o Max e ter limites maiores e mais Opus',
87    usage: 'Mostrar o custo da sessão, o uso do plano e o que pesa nos seus limites',
88    'usage-credits': 'Configurar créditos de uso ou pedi-los ao administrador ao atingir um limite',
89    version: 'Mostrar a versão desta sessão (a atualização automática pode ter uma mais nova)',
90    voice: 'Ativar ou desativar o modo de voz',
91    'web-setup': 'Configurar sessões na nuvem com sua conta do GitHub',
92    wellbeing: 'Configurar lembretes opcionais de pausa e horários de silêncio',
93    workflows: 'Ver fluxos de trabalho em andamento e concluídos',
94    "code-review": "Revisar o diff atual, um PR, branch ou caminho em busca de bugs, no nível de esforço escolhido (low a max; ultra: revisão multiagente na nuvem); --comment publica os achados no PR, --fix os aplica e --post/--no-post controla o comentário no GitHub",
95    "design-consent": "Dar aos agentes do Claude acesso aos seus projetos do Design",
96    "design-revoke": "Remover o acesso dos agentes do Claude aos seus projetos do Design",
97    "doctor": "Verificar sua instalação do Claude Code e corrigir problemas: instalação, configurações, skills, servidores MCP e plugins sem uso, arquivos CLAUDE.md, hooks lentos",
98    "fewer-permission-prompts": "Procurar nos seus históricos chamadas frequentes de Bash e MCP só de leitura e adicionar uma lista de permissões em .claude/settings.json para receber menos pedidos de permissão",
99    "simplify": "Revisar o código alterado buscando reaproveitamento, simplificação e eficiência, e aplicar as melhorias. Só qualidade: para caçar bugs, use /code-review",
100    "verify": "Verificar se uma mudança faz mesmo o que deveria, executando o fluxo afetado de ponta a ponta, não só os testes ou a checagem de tipos",
101    chrome: 'Abrir as configurações do Claude in Chrome',
102    'claim-credit': 'Abrir a página da oferta mostrada na inicialização',
103    'design-login': 'Autorizar o acesso a design systems para o /design-sync com sua conta do claude.ai',
104    diff: 'Ver alterações não commitadas e os diffs de cada turno',
105    'extra-usage': 'Agora se chama /usage-credits',
106    keybindings: 'Abrir seu arquivo de atalhos de teclado',
107    'limit-reset': 'Zerar agora seu limite da sessão e continuar trabalhando; uma vez por semana, ainda conta para o limite semanal',
108    'low-priority': 'Continuar agora com prioridade menor depois de atingir o limite da sessão; rode de novo para parar',
109    passes: 'Compartilhar uma semana grátis de Claude Code com amigos e ganhar créditos de uso',
110    'pro-trial-expired': 'Opções exibidas quando o teste do Claude Code no plano Pro termina',
111    'rate-limit-options': 'Gerenciar limites de uso e opções de upgrade',
112    'remote-control': 'Controlar esta sessão pelo celular ou pelo claude.ai/code',
113    schedule: 'Criar, atualizar, listar ou executar agentes na nuvem agendados (rotinas) que rodam em um agendamento cron.',
114    'setup-bedrock': 'Reconfigurar autenticação, região ou modelos fixados do Amazon Bedrock',
115    'setup-vertex': 'Reconfigurar autenticação, projeto, região ou modelos fixados do Google Vertex AI',
116    'terminal-setup': 'Instalar o atalho Shift+Enter para quebras de linha',
117    ultrareview: 'Iniciar um agente na nuvem que encontra e verifica bugs no seu branch (~15-25 min, US$ 5-25) · Roda em uma sessão na nuvem. Veja https://code.claude.com/docs/en/claude-code-on-the-web',
118  },
119  byText: {
120    "Set a setting by key":
121      "Alterar uma configuração pela chave",
122    "Copy this conversation into a new background session and keep working here":
123      "Copiar esta conversa para uma nova sessão em segundo plano e continuar trabalhando aqui",
124    "Set a goal Claude checks before stopping":
125      "Definir uma meta que o Claude confere antes de parar",
126    "Set how full the context gets before auto-summarizing":
127      "Definir o quanto o contexto enche antes do resumo automático",
128    "Show session cost, plan usage, and activity stats":
129      "Mostrar o custo da sessão, o uso do plano e estatísticas de atividade",
130    "Print the version this session is running (not what autoupdate downloaded)":
131      "Mostrar a versão que esta sessão está rodando (não a baixada pela atualização automática)",
132    'Show current context usage':
133      'Mostrar o uso atual do contexto',
134    'Grant or revoke Claude agent access to your Design projects':
135      'Dar ou revogar o acesso dos agentes do Claude aos seus projetos do Design',
136    'Toggle the diff panel showing uncommitted changes':
137      'Mostrar ou ocultar o painel de diff com as alterações não commitadas',
138  },
139  config: {
140    autoCompact: 'Compactação automática',
141    autoContinueAtUsageLimit: 'Continuar automaticamente no limite de uso',
142    switchModelsOnFlag: 'Trocar de modelo quando uma mensagem for sinalizada',
143    tips: 'Mostrar dicas',
144    reduceMotion: 'Reduzir animações',
145    thinking: 'Modo de raciocínio',
146    promptSuggestionEnabled: 'Sugestões de prompt',
147    recap: 'Resumo da sessão',
148    checkpoints: 'Voltar o código (checkpoints)',
149    artifacts: 'Artefatos',
150    verbose: 'Saída detalhada',
151    progressBar: 'Barra de progresso no terminal',
152    turnDuration: 'Mostrar a duração de cada turno',
153    timeFormat: 'Formato de hora',
154    permissionMode: 'Modo de permissão padrão',
155    worktreeBaseRef: 'Ref base dos worktrees',
156    useAutoModeDuringPlan: 'Usar o modo automático durante o planejamento',
157    gitignore: 'Respeitar o .gitignore no seletor de arquivos',
158    copyFullResponse: 'Pular o seletor do /copy',
159    copyOnSelect: 'Copiar ao selecionar',
160    autoScroll: 'Rolagem automática',
161    defaultToAgentsView: 'Abrir a visão de agentes por padrão',
162    leftArrowOpensAgents: '← abre os agentes',
163    autoUpdatesChannel: 'Canal de atualização',
164    theme: 'Tema',
165    notifChannel: 'Notificações locais',
166    inputNeededNotifEnabled: 'Notificar quando houver ação necessária',
167    agentPushNotifEnabled: 'Notificar quando o Claude decidir',
168    outputStyle: 'Estilo de saída',
169    language: 'Idioma',
170    editor: 'Modo do editor',
171    askUserQuestionTimeout: 'Tempo para continuar sozinho após uma pergunta',
172    externalEditorContext: 'Mostrar a última resposta no editor externo',
173    prStatus: 'Mostrar o status do PR no rodapé',
174    model: 'Modelo',
175    autoConnectIde: 'Conectar automaticamente ao IDE (terminal externo)',
176    chrome: 'Claude no Chrome ativado por padrão',
177    dialogExpiry: 'Expiração de diálogos',
178    feedbackDrafts: 'Feedback redigido pelo Claude',
179    fast: 'Modo rápido',
180    workflows: 'Workflows dinâmicos',
181    workflowKeywordTriggerEnabled: 'Ativar pela palavra-chave ultracode',
182    workflowSizeGuideline: 'Tamanho dos workflows dinâmicos',
183    remoteControl: 'Ativar o Remote Control em todas as sessões',
184    'cc-plugin-agents-md.instructionFiles': 'Instruções do projeto',
185  },
186  phrases: {
187    shortcuts: '? para atalhos',
188    shellMode: '! para modo shell',
189    escInterrupt: 'Esc para interromper',
190    escAgainClear: 'Esc de novo para limpar',
191    doubleEscClear: 'Esc duas vezes para limpar a entrada',
192    pressAgainExit: 'aperte {1} de novo para sair',
193    editQueued: '↑ para editar mensagens na fila',
194    acceptEdits: 'aceitar edições ativado',
195    planMode: 'modo de planejamento ativado',
196    autoMode: 'modo automático ativado',
197    bypassPermissions: 'ignorar permissões ativado',
198    manualMode: 'modo manual ativado',
199    forAgents: '← para agentes',
200    toCycle: '({1} para alternar)',
201    toExpand: '({1} para expandir)',
202    runInBackground: '({1} para segundo plano)',
203    pasteToExpand: 'cole de novo para expandir',
204    toStop: '{1} para parar',
205    holdToSpeak: 'segure {1} para falar',
206    sandboxEnabled: 'sandbox ativado',
207    sandboxDisabled: 'sandbox desativado',
208    sandboxAutoAllow: '(permissão automática)',
209    sandboxFallback: ', alternativa permitida',
210    sandboxManaged: '(gerenciado)',
211    toConfigure: '(⏎ para configurar)',
212  },
213  modes: {
214    focus: 'foco',
215    'memory paused': 'memória pausada',
216    brief: 'resumido',
217    fast: 'rápido',
218    voice: 'voz',
219  },
220  spinner: [
221    'Cozinhando', 'Assando', 'Matutando', 'Ruminando', 'Fuçando', 'Bolando', 'Tramando', 'Pensando',
222    'Amassando', 'Temperando', 'Mexendo', 'Fermentando', 'Destilando', 'Ponderando', 'Garimpando',
223    'Rabiscando', 'Montando', 'Lapidando', 'Calculando', 'Costurando', 'Arquitetando', 'Esquentando',
224    'Remexendo', 'Tricotando', 'Desembaraçando', 'Afinando', 'Fazendo malabarismo', 'Coando o café',
225    'Filosofando', 'Engendrando',
226  ],
227  turn: {
228    words: ['Assado', 'Coado', 'Batido', 'Matutado', 'Cozido', 'Triturado', 'Refogado', 'Trabalhado'],
229    template: '{word} em {duration}',
230  },
231  group: {
232    searched: { one: '{n} padrão buscado', other: '{n} padrões buscados' },
233    read: { one: '{n} arquivo lido', other: '{n} arquivos lidos' },
234    listed: { one: '{n} diretório listado', other: '{n} diretórios listados' },
235    separator: ', ',
236  },
237  duration: { h: ' h', m: ' min', s: ' s', separator: ' ' },
238  ui: {
239    status: 'Tolk: a interface está em {name} ({code}).',
240    coverage: '{commands} de {commandsTotal} descrições de comandos e {settings} de {settingsTotal} configurações estão traduzidas.',
241    available: 'Idiomas disponíveis:',
242    switched: 'Idioma alterado para {name}. O Claude Code atualiza os rótulos em instantes.',
243    unknown: 'Idioma desconhecido "{code}". Disponíveis: {codes}',
244    missingNone: 'Todos os comandos nativos têm tradução.',
245    missingHeader: 'Comandos sem tradução:',
246    driftHeader: 'Comandos cujo texto em inglês mudou desde a tradução:',
247    usage: 'Uso: /tolk [list | set <código> | missing]. Códigos: {codes}',
248    commandDescription: 'Ver ou mudar o idioma da interface (Tolk)',
249    configLabel: 'Idioma da interface (Tolk)',
250  },
251}
252
253export default ptBR
254

1import type { Locale } from './types'
2
3const vi: Locale = {
4  code: 'vi',
5  name: 'Tiếng Việt',
6  commands: {
7    'add-dir': 'Thêm một thư mục làm việc mới',
8    advisor: 'Cho Claude hỏi ý kiến một mô hình mạnh hơn vào những lúc quan trọng',
9    artifacts: 'Duyệt các artifact bạn đã xuất bản và được chia sẻ',
10    'auto-mode-setup': 'Cho chế độ tự động biết về môi trường của bạn, kèm tùy chỉnh quy tắc nếu muốn',
11    autocompact: 'Cấu hình kích thước cửa sổ tự động thu gọn',
12    'autofix-pr': 'Theo dõi PR hiện tại và tự động sửa lỗi',
13    background: 'Đưa phiên này xuống nền và giải phóng terminal',
14    batch: 'Nghiên cứu và lập kế hoạch cho một thay đổi lớn, rồi thực hiện song song trên 5–30 agent worktree riêng biệt, mỗi agent mở một PR.',
15    branch: 'Tạo một nhánh của cuộc trò chuyện hiện tại tại điểm này',
16    brief: 'Bật/tắt chế độ ngắn gọn',
17    btw: 'Hỏi nhanh một câu bên lề mà không làm gián đoạn cuộc trò chuyện chính',
18    bug: 'Báo lỗi hoặc chia sẻ cuộc trò chuyện của bạn',
19    cd: 'Chuyển phiên này sang một thư mục làm việc mới',
20    chrome: 'Mở cài đặt Claude in Chrome',
21    'claim-credit': 'Mở trang của ưu đãi hiển thị lúc khởi động',
22    clear: 'Bắt đầu phiên mới với ngữ cảnh trống; phiên trước vẫn được lưu (tiếp tục bằng /resume)',
23    'cloud-plugins': 'Chọn xem các phiên đám mây có dùng plugin đã bật trên máy này không',
24    'code-review': 'Rà soát diff hiện tại, một PR, nhánh hoặc đường dẫn để tìm lỗi, với mức nỗ lực tùy chọn (low đến max; ultra: nhiều agent trên đám mây); --comment đăng kết quả thành bình luận PR, --fix áp dụng chúng, --post/--no-post điều khiển bình luận trên GitHub',
25    color: 'Đặt màu thanh nhập lệnh cho phiên này',
26    compact: 'Giải phóng ngữ cảnh bằng cách tóm tắt cuộc trò chuyện đến giờ',
27    config: 'Mở cài đặt',
28    context: 'Hiển thị mức dùng ngữ cảnh hiện tại dưới dạng lưới màu',
29    copy: 'Sao chép câu trả lời gần nhất của Claude vào clipboard (hoặc /copy N cho câu thứ N tính từ cuối)',
30    daemon: 'Quản lý dịch vụ nền và routine',
31    debug: 'Bật ghi log gỡ lỗi cho phiên này và giúp chẩn đoán sự cố',
32    design: 'Tạo một artifact Design mới từ bản mô tả',
33    'design-consent': 'Cho phép agent Claude truy cập các dự án Design của bạn',
34    'design-login': 'Cấp quyền truy cập design system cho /design-sync bằng tài khoản claude.ai',
35    'design-revoke': 'Thu hồi quyền truy cập dự án Design của agent Claude',
36    desktop: 'Tiếp tục phiên hiện tại trong Claude Desktop',
37    diff: 'Xem các thay đổi chưa commit và diff theo từng lượt',
38    doctor: 'Kiểm tra và sửa lỗi thiết lập Claude Code của bạn: cài đặt, file cấu hình, skill, MCP server và plugin không dùng đến, file CLAUDE.md, hook chậm',
39    effort: 'Đặt mức nỗ lực khi dùng mô hình',
40    exit: 'Thoát Claude Code',
41    export: 'Xuất cuộc trò chuyện hiện tại ra file hoặc clipboard',
42    'extra-usage': 'Đã đổi tên thành /usage-credits',
43    fast: 'Bật/tắt chế độ nhanh',
44    feedback: 'Gửi phản hồi cho Anthropic hoặc báo lỗi',
45    'fewer-permission-prompts': 'Quét lịch sử tìm các lệnh Bash và MCP chỉ đọc thường dùng, rồi thêm danh sách cho phép vào .claude/settings.json để bớt hỏi quyền',
46    focus: 'Bật/tắt chế độ tập trung: chỉ prompt, tóm tắt và câu trả lời',
47    fork: 'Khởi chạy một agent nền kế thừa toàn bộ cuộc trò chuyện',
48    goal: 'Đặt mục tiêu – tiếp tục làm cho đến khi đạt điều kiện',
49    help: 'Hiện trợ giúp và các lệnh có sẵn',
50    hooks: 'Xem cấu hình hook cho các sự kiện công cụ',
51    ide: 'Quản lý tích hợp IDE và xem trạng thái',
52    import: 'Nhập cấu hình từ một agent lập trình AI khác',
53    init: 'Tạo file CLAUDE.md mới với tài liệu về codebase',
54    insights: 'Tạo báo cáo phân tích các phiên Claude Code của bạn',
55    'install-github-app': 'Thiết lập Claude GitHub Actions cho một repository',
56    'install-slack-app': 'Cài ứng dụng Claude cho Slack',
57    keybindings: 'Mở file phím tắt của bạn',
58    'limit-reset': 'Đặt lại giới hạn phiên ngay và tiếp tục làm việc; mỗi tuần một lần, vẫn tính vào giới hạn tuần',
59    'list-agents': 'Liệt kê subagent, đồng đội và các phiên Claude khác mà bạn có thể nhắn tin',
60    login: 'Đăng nhập bằng tài khoản Anthropic',
61    logout: 'Đăng xuất khỏi tài khoản Anthropic',
62    loop: 'Chạy một prompt hoặc lệnh slash theo chu kỳ (vd. /loop 5m /foo). Bỏ khoảng thời gian để mô hình tự điều chỉnh nhịp.',
63    loops: 'Liệt kê, tạo và xóa vòng lặp',
64    'low-priority': 'Tiếp tục ngay với độ ưu tiên thấp hơn sau khi chạm giới hạn phiên; chạy lại để dừng',
65    mcp: 'Quản lý MCP server',
66    memory: 'Chỉnh sửa file CLAUDE.md và cài đặt bộ nhớ',
67    mobile: 'Hiện mã QR để tải ứng dụng Claude trên điện thoại',
68    model: 'Chọn mô hình AI cho Claude Code',
69    'output-style': 'Liệt kê hoặc chuyển kiểu đầu ra',
70    passes: 'Chia sẻ một tuần dùng thử Claude Code miễn phí với bạn bè và nhận tín dụng sử dụng',
71    permissions: 'Quản lý quy tắc cho phép và chặn công cụ',
72    plan: 'Bật chế độ lập kế hoạch hoặc xem kế hoạch của phiên hiện tại',
73    plugin: 'Quản lý plugin Claude Code',
74    powerup: 'Khám phá tính năng Claude Code qua các bài học tương tác ngắn',
75    'privacy-settings': 'Xem và cập nhật cài đặt quyền riêng tư',
76    'pro-trial-expired': 'Các lựa chọn khi bản dùng thử Claude Code của gói Pro đã hết hạn',
77    radio: 'Nghe radio lo-fi Claude FM',
78    'rate-limit-options': 'Quản lý giới hạn sử dụng và tùy chọn nâng cấp',
79    recap: 'Tạo bản tóm tắt phiên một dòng ngay bây giờ',
80    'release-notes': 'Xem ghi chú phát hành',
81    'reload-plugins': 'Kích hoạt các thay đổi plugin đang chờ trong phiên hiện tại',
82    'reload-skills': 'Nạp các skill được thêm hoặc sửa trên đĩa trong phiên này',
83    'remote-control': 'Điều khiển phiên này từ điện thoại hoặc claude.ai/code',
84    'remote-env': 'Chọn môi trường mặc định cho agent đám mây',
85    rename: 'Đổi tên cuộc trò chuyện hiện tại',
86    resume: 'Tiếp tục một cuộc trò chuyện trước đó',
87    rewind: 'Khôi phục code và/hoặc cuộc trò chuyện về một thời điểm trước',
88    schedule: 'Tạo, cập nhật, liệt kê hoặc chạy các agent đám mây theo lịch (routine) chạy theo cron.',
89    'security-review': 'Rà soát bảo mật các thay đổi đang chờ trên nhánh hiện tại',
90    session: 'Hiện URL và mã QR của phiên đám mây',
91    'setup-bedrock': 'Cấu hình lại xác thực, vùng hoặc mô hình cố định cho Amazon Bedrock',
92    'setup-vertex': 'Cấu hình lại xác thực, dự án, vùng hoặc mô hình cố định cho Google Vertex AI',
93    simplify: 'Rà soát code đã thay đổi để tái sử dụng, đơn giản hóa và tối ưu, rồi áp dụng các sửa đổi. Chỉ về chất lượng – để tìm lỗi hãy dùng /code-review',
94    'skill-doctor': 'Hiện các skill đã nạp nhưng không dùng và đang tốn ngữ cảnh',
95    skills: 'Liệt kê các skill có sẵn',
96    slides: 'Tạo một bộ slide artifact mới từ bản mô tả',
97    status: 'Hiện trạng thái Claude Code: phiên bản, mô hình, tài khoản, kết nối API và công cụ',
98    statusline: 'Thiết lập dòng trạng thái của Claude Code',
99    stickers: 'Đặt mua sticker Claude Code',
100    stop: 'Dừng phiên nền này; lịch sử và worktree được giữ lại',
101    subtask: 'Gửi một subagent đi với toàn bộ ngữ cảnh của bạn; kết quả sẽ trả về đây',
102    tasks: 'Xem và quản lý mọi thứ đang chạy nền',
103    'team-onboarding': 'Giúp đồng đội làm quen Claude Code bằng hướng dẫn từ cách bạn sử dụng',
104    teleport: 'Gửi phiên này lên đám mây, hoặc tiếp tục một phiên từ claude.ai',
105    'terminal-setup': 'Cài phím tắt Shift+Enter để xuống dòng',
106    theme: 'Đổi giao diện',
107    tui: 'Chọn trình hiển thị giao diện terminal (default | fullscreen)',
108    ultrareview: 'Khởi chạy agent đám mây tìm và xác minh lỗi trong nhánh của bạn (~15–25 phút, 5–25 USD) · Chạy trong phiên đám mây. Xem https://code.claude.com/docs/en/claude-code-on-the-web',
109    upgrade: 'Nâng cấp lên Max để có giới hạn cao hơn và dùng Opus nhiều hơn',
110    usage: 'Hiện chi phí phiên, mức dùng gói và những gì đang góp vào giới hạn của bạn',
111    'usage-credits': 'Cấu hình tín dụng sử dụng hoặc xin admin khi bạn chạm giới hạn',
112    verify: 'Kiểm tra xem một thay đổi có thực sự làm đúng việc không bằng cách chạy luồng liên quan từ đầu đến cuối – không chỉ test hay kiểm tra kiểu',
113    version: 'Hiện phiên bản của phiên này (bản tự cập nhật có thể mới hơn)',
114    voice: 'Bật/tắt chế độ giọng nói',
115    'web-setup': 'Thiết lập phiên đám mây với tài khoản GitHub của bạn',
116    wellbeing: 'Cấu hình nhắc nghỉ giải lao và giờ yên tĩnh (tùy chọn)',
117    workflows: 'Duyệt các workflow đang chạy và đã hoàn tất',
118  },
119  byText: {
120    'Set a setting by key':
121      'Đặt một cài đặt theo khóa',
122    'Copy this conversation into a new background session and keep working here':
123      'Sao chép cuộc trò chuyện này sang một phiên nền mới và tiếp tục làm việc ở đây',
124    'Set a goal Claude checks before stopping':
125      'Đặt mục tiêu để Claude kiểm tra trước khi dừng',
126    'Set how full the context gets before auto-summarizing':
127      'Đặt mức đầy của ngữ cảnh trước khi tự động tóm tắt',
128    'Show session cost, plan usage, and activity stats':
129      'Hiện chi phí phiên, mức dùng gói và thống kê hoạt động',
130    'Print the version this session is running (not what autoupdate downloaded)':
131      'In phiên bản mà phiên này đang chạy (không phải bản tự cập nhật đã tải)',
132    'Show current context usage':
133      'Hiện mức dùng ngữ cảnh hiện tại',
134    'Grant or revoke Claude agent access to your Design projects':
135      'Cấp hoặc thu hồi quyền truy cập dự án Design của agent Claude',
136    'Toggle the diff panel showing uncommitted changes':
137      'Bật/tắt bảng diff hiển thị các thay đổi chưa commit',
138  },
139  config: {
140    autoCompact: 'Tự động thu gọn',
141    autoContinueAtUsageLimit: 'Tự động tiếp tục khi chạm giới hạn',
142    switchModelsOnFlag: 'Đổi mô hình khi tin nhắn bị gắn cờ',
143    tips: 'Hiện mẹo',
144    feedbackDrafts: 'Phản hồi do Claude soạn',
145    reduceMotion: 'Giảm chuyển động',
146    thinking: 'Chế độ suy nghĩ',
147    fast: 'Chế độ nhanh',
148    promptSuggestionEnabled: 'Gợi ý prompt',
149    recap: 'Tóm tắt phiên',
150    checkpoints: 'Tua lại code (checkpoint)',
151    workflows: 'Workflow động',
152    workflowKeywordTriggerEnabled: 'Kích hoạt bằng từ khóa ultracode',
153    workflowSizeGuideline: 'Quy mô workflow động',
154    artifacts: 'Artifact',
155    verbose: 'Đầu ra chi tiết',
156    progressBar: 'Thanh tiến trình terminal',
157    turnDuration: 'Hiện thời gian mỗi lượt',
158    timeFormat: 'Định dạng giờ',
159    permissionMode: 'Chế độ quyền mặc định',
160    worktreeBaseRef: 'Ref gốc cho worktree',
161    useAutoModeDuringPlan: 'Dùng chế độ tự động khi lập kế hoạch',
162    gitignore: 'Tuân theo .gitignore khi chọn file',
163    copyFullResponse: 'Bỏ qua bảng chọn của /copy',
164    copyOnSelect: 'Sao chép khi bôi đen',
165    autoScroll: 'Tự động cuộn',
166    defaultToAgentsView: 'Mở chế độ xem agent theo mặc định',
167    leftArrowOpensAgents: '← mở agent',
168    autoUpdatesChannel: 'Kênh tự động cập nhật',
169    theme: 'Giao diện',
170    notifChannel: 'Thông báo cục bộ',
171    inputNeededNotifEnabled: 'Đẩy thông báo khi cần thao tác',
172    agentPushNotifEnabled: 'Đẩy thông báo khi Claude quyết định',
173    outputStyle: 'Kiểu đầu ra',
174    language: 'Ngôn ngữ',
175    editor: 'Chế độ trình soạn thảo',
176    askUserQuestionTimeout: 'Thời gian chờ tự tiếp tục khi hỏi',
177    externalEditorContext: 'Hiện câu trả lời gần nhất trong trình soạn thảo ngoài',
178    prStatus: 'Hiện trạng thái PR ở chân trang',
179    model: 'Mô hình',
180    autoConnectIde: 'Tự động kết nối IDE (terminal ngoài)',
181    chrome: 'Bật Claude in Chrome theo mặc định',
182    remoteControl: 'Bật Remote Control cho mọi phiên',
183    dialogExpiry: 'Thời hạn hộp thoại',
184    'cc-plugin-agents-md.instructionFiles': 'Hướng dẫn dự án',
185  },
186  phrases: {
187    shortcuts: '? xem phím tắt',
188    shellMode: '! vào chế độ shell',
189    escInterrupt: 'Esc để ngắt',
190    escAgainClear: 'Esc lần nữa để xóa',
191    doubleEscClear: 'Esc hai lần để xóa ô nhập',
192    pressAgainExit: 'Nhấn {1} lần nữa để thoát',
193    editQueued: '↑ sửa tin nhắn đang chờ',
194    acceptEdits: 'tự chấp nhận sửa đổi bật',
195    planMode: 'chế độ kế hoạch bật',
196    autoMode: 'chế độ tự động bật',
197    bypassPermissions: 'bỏ qua quyền bật',
198    manualMode: 'chế độ thủ công bật',
199    forAgents: '← xem agent',
200    toCycle: '({1} để chuyển)',
201    toExpand: '({1} để mở rộng)',
202    runInBackground: '({1} để chạy nền)',
203    pasteToExpand: 'dán lần nữa để mở rộng',
204    toStop: '{1} để dừng',
205    holdToSpeak: 'giữ {1} để nói',
206    sandboxEnabled: 'sandbox đang bật',
207    sandboxDisabled: 'sandbox đang tắt',
208    sandboxAutoAllow: '(tự động cho phép)',
209    sandboxFallback: ', cho phép dự phòng',
210    sandboxManaged: '(được quản lý)',
211    toConfigure: '(⏎ để cấu hình)',
212  },
213  modes: {
214    focus: 'tập trung',
215    'memory paused': 'bộ nhớ tạm dừng',
216    brief: 'ngắn gọn',
217    fast: 'nhanh',
218    voice: 'giọng nói',
219  },
220  spinner: [
221    'Đang nghiền ngẫm', 'Đang suy tư', 'Đang mày mò', 'Đang loay hoay', 'Đang nấu nướng', 'Đang nướng bánh',
222    'Đang pha chế', 'Đang ninh nhừ', 'Đang ủ men', 'Đang nhào bột', 'Đang nêm nếm', 'Đang khuấy đều',
223    'Đang rèn giũa', 'Đang chắp vá', 'Đang lắp ráp', 'Đang xoay xở', 'Đang tung hứng', 'Đang triết lý',
224    'Đang ấp ủ', 'Đang gỡ rối', 'Đang phù phép', 'Đang vẽ vời', 'Đang mài dũa', 'Đang tính toán',
225    'Đang cân nhắc', 'Đang lục lọi', 'Đang chế biến', 'Đang ươm mầm', 'Đang dệt chữ', 'Đang lẩm nhẩm',
226  ],
227  turn: {
228    words: ['Đã nướng', 'Đã pha', 'Đã khuấy', 'Đã nghiền ngẫm', 'Đã nấu', 'Đã nhào', 'Đã xào', 'Đã làm việc'],
229    template: '{word} trong {duration}',
230  },
231  group: {
232    searched: { one: 'đã tìm {n} mẫu', other: 'đã tìm {n} mẫu' },
233    read: { one: 'đã đọc {n} tệp', other: 'đã đọc {n} tệp' },
234    listed: { one: 'đã liệt kê {n} thư mục', other: 'đã liệt kê {n} thư mục' },
235    separator: ', ',
236  },
237  duration: { h: ' giờ', m: ' phút', s: ' giây', separator: ' ' },
238  ui: {
239    status: 'Tolk: giao diện đang dùng {name} ({code}).',
240    coverage: 'Đã dịch {commands}/{commandsTotal} mô tả lệnh và {settings}/{settingsTotal} cài đặt.',
241    available: 'Ngôn ngữ có sẵn:',
242    switched: 'Đã chuyển sang {name}. Claude Code sẽ cập nhật nhãn trong giây lát.',
243    unknown: 'Không biết ngôn ngữ "{code}". Có sẵn: {codes}',
244    missingNone: 'Mọi lệnh có sẵn đều đã được dịch.',
245    missingHeader: 'Các lệnh chưa được dịch:',
246    driftHeader: 'Các lệnh có văn bản tiếng Anh đã thay đổi kể từ khi dịch:',
247    usage: 'Cách dùng: /tolk [list | set <mã> | missing]. Mã: {codes}',
248    commandDescription: 'Xem hoặc đổi ngôn ngữ giao diện (Tolk)',
249    configLabel: 'Ngôn ngữ giao diện (Tolk)',
250  },
251}
252
253export default vi
254