dsh-mobile-plugin 0.5.28 → 0.5.29

package/extensions/magpie/plugins/routing/i18n.js

@@ -0,0 +1,2696 @@
+// The Routing page's words in each language, the English the key: the
+// kernel adds them to i18n.js's (magpie.strings).
+magpie.strings({
+  zh: {
+    "sign-in refused (answered since)": "登录曾被拒（之后已应答）",
+    "Free first uses it before paid ones, and Cheapest first counts it as costing nothing": "免费优先会先用它再用付费的，最便宜优先把它算作不花钱",
+    "{name}, {n} accounts: {windows}": "{name}（{n} 个账号）：{windows}",
+    "What is left of this provider's accounts the group can use, together: amounts of one unit added up, a share the mean of the accounts on one plan. Each account is on the Usage page.": "本组可用的这家供应商账号合起来还剩多少：同一单位的额度相加，百分比取同一套餐账号的平均值。各账号详情在用量页。",
+    "Each session's context window": "各会话的上下文窗口",
+    "Show this session's newest request": "显示这个会话最新的请求",
+    "Its plugin sent this request itself, so magpie can't split its time": "此请求由插件自行发出，magpie 无法拆分它的耗时",
+    "Claude Code sent this request itself, so magpie can't split its time": "此请求由 Claude Code 自行发出，magpie 无法拆分它的耗时",
+    "magpie is masking this request before routing it (Settings › Privacy), so who takes it isn't picked yet.": "magpie 正在给这个请求脱敏（设置 › 隐私），脱敏完才路由，所以还没选出由谁处理。",
+    "magpie hasn't routed this request yet, so who takes it isn't picked yet.": "magpie 还没开始路由这个请求，所以还没选出由谁处理。",
+    "Nothing took this request: {error}": "没有谁处理这个请求：{error}",
+    "{n} groups · {m} on": "{n} 个组 · {m} 个开启",
+    "Filter, or type an agent's name…": "筛选，或输入 Agent 名称…",
+    "the name its User-Agent begins with": "User-Agent 开头的名称",
+    "heard from in the last 30 days": "近 30 天有请求",
+    "The subagent effort set in magpie is {effort}; the model's supported levels and a routing group's fixed member effort still apply.": "magpie 为子代理设定的推理强度是 {effort}；仍按模型支持的等级适配，并保留路由组成员的固定强度。",
+    "{agent}'s call to magpie's web_search MCP tool": "{agent} 对 magpie 的 web_search MCP 工具的调用",
+    "{agent}'s call to magpie's analyze_image MCP tool": "{agent} 对 magpie 的 analyze_image MCP 工具的调用",
+    "a model that can't see images": "一个看不了图片的模型",
+    "{failed}, the Image recognition model picked in Settings › Models, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "{failed} 是在 设置 › 模型 里选的识图模型，但它没能为 {whom} 描述图片：{why}。所以 magpie 改让下一个可用的识图模型 {describer} 来描述。不属于对话轮次。",
+    "{failed}, the model magpie picked to describe images, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "{failed} 是 magpie 自动选的识图模型，但它没能为 {whom} 描述图片：{why}。所以 magpie 改让下一个可用的识图模型 {describer} 来描述。不属于对话轮次。",
+    "{agent}'s {model}": "{agent} 的 {model}",
+    "a model that can't search the web by itself": "一个自己不能联网搜索的模型",
+    "{failed}, the searcher picked in Settings › Models › Web search, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "{failed} 是在 设置 › 模型 › 联网搜索 里选的代搜模型，但它没能为 {whom} 搜索：{why}。所以 magpie 改让下一个可用的代搜模型 {searcher} 来搜。不属于对话轮次。",
+    "{failed}, the searcher magpie picked, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "{failed} 是 magpie 自动选的代搜模型，但它没能为 {whom} 搜索：{why}。所以 magpie 改让下一个可用的代搜模型 {searcher} 来搜。不属于对话轮次。",
+    "This routing group will no longer be available to agents.": "此路由组将不再供 Agent 使用。",
+    "These routing groups will no longer be available to agents.": "这些路由组将不再供 Agent 使用。",
+    "By session": "按会话",
+    "By key": "按密钥",
+    "These requests came with no gateway key: from this computer, or from before magpie noted the key.": "这些请求没有带网关密钥：来自这台电脑，或是在 magpie 记下密钥之前的。",
+    "No session ID": "未提供会话标识",
+    "{n} in progress": "{n} 个进行中",
+    "These requests did not provide a session ID; they are not treated as one conversation.": "这些请求没有提供会话标识，不视为同一个会话。",
+    "Estimated at effective model prices, including cache reads and writes; subscription billing may differ. Totals cover only the requests listed here.": "按模型有效价格估算，包含缓存读写；订阅实际计费可能不同。合计仅包含当前列表中的请求。",
+    "No known price or token counts for this request": "此请求缺少已知价格或 Token 用量",
+    "Drag to reorder — agents' model lists show the groups in this order · Alt+↑/↓ to move": "拖动排序，Agent 的模型列表按此顺序列出路由组 · Alt+↑/↓ 移动",
+    "Group order saved": "路由组顺序已保存",
+    "{picked}, the Image recognition model picked in Settings, isn't set up any more, so magpie had {describer}, its automatic choice, describe an image for {agent}'s {model} in its place. Pick another in Settings › Models › Image recognition. Not a turn of the conversation.": "设置里选的识图模型 {picked} 已不可用，所以 magpie 让自动选择的 {describer} 代为给 {agent} 的 {model} 描述图片。请在 设置 › 模型 › 识图模型 里另选一个。不属于对话轮次。",
+    "In agents’ lists": "Agent 列表里的名称",
+    "Names in agents’ lists": "Agent 列表里的名称",
+    "Whether “· routing group” follows a group’s name in the agents’ lists: one setting for every group, and for the provider after each model’s name, as on Settings.": "Agent 的模型列表里，路由组名后面是否带「· routing group」。这是所有路由组共用的一个设置，也决定模型名后面是否带供应商，和「设置」里的是同一个。",
+    "“· routing group” is set for every group, under the list": "是否带「· routing group」在列表下方统一设置，对所有路由组生效",
+    "{agent} guessed your next message for its composer by itself, reading the whole conversation again. Not a turn of the conversation; Codex composer predictions, under Settings in Codex's row on the Agents page, picks its model, and Codex's Settings › General › Show predictions turns it off.": "{agent} 自行为输入框猜测你的下一条消息，每次都把整段对话重读一遍。不属于对话轮次；在 Agent 页 Codex 那一行的设置里，用 Codex 输入框预测 选它用的模型，在 Codex 的 设置 › 常规 › 显示预测内容 里可以关掉。",
+    "{name} is switched off: the group skips it until it is on again": "{name} 已关闭：开启前这个组会跳过它",
+    "{n} switched off": "{n} 个已关闭",
+    "Off: agents aren't offered {name} and a request to it is turned away. Click to switch it on": "已关闭：Agent 列表里没有 {name}，发给它的请求会被拒绝。点击打开",
+    "On: agents may pick {name}. Click to switch it off and keep it as it is": "已打开：Agent 可以选用 {name}。点击暂时关闭，组的设置原样保留",
+    "{name} switched on": "已打开 {name}",
+    "{name} switched off": "已关闭 {name}",
+    "in {groups}": "已在 {groups}",
+    "By weight: it's {who}'s share \u2014 each key takes requests as its weight says.": "按权重：轮到 {who} 的份额——每个密钥按自己的权重接请求。",
+    "By weight: it's {who}'s share \u2014 each account takes requests as its weight says.": "按权重：轮到 {who} 的份额——每个账号按自己的权重接请求。",
+    "By weight: it's {who}'s share — each model takes requests as the weight set beside it says.": "按权重：轮到 {who} 的份额——每个模型按旁边设置的权重接请求。",
+    "By weight: each model takes its share of the requests by the weight set beside it — one weighing 3 three for every one a model weighing 1 takes, spread out rather than in bursts. One resting after a failure leaves the round and the others share its requests; the next model is the fallback when one fails.": "按权重：每个模型按旁边设置的权重分得请求——权重 3 的模型每接 3 个，权重 1 的接 1 个，均匀穿插而不是成批连发。失败后休息中的模型退出这一轮，其余模型分担它的请求；某个模型失败时，由下一个模型接替。",
+    "Its share of the requests: a model weighing 3 takes three for every one a model weighing 1 takes": "它在请求中的份额：权重 3 的模型每接 3 个请求，权重 1 的接 1 个",
+    "Weight of {name}": "{name} 的权重",
+    "A weight is 1 to 1000": "权重为 1 到 1000",
+    "{name}: {routing}": "{name}：{routing}",
+    "How {name} routes: click to change it": "{name} 的路由方式：点击更改",
+    "{n} available": "{n} 个可用",
+    "{n} resting": "{n} 个休息中",
+    "{n} held": "{n} 个暂不使用",
+    "Show each key": "展开每个密钥",
+    "Fold these keys into one row": "把这些密钥合并成一行",
+    "Show each account": "展开每个账号",
+    "Fold these accounts into one row": "把这些账号合并成一行",
+    "Show what this group routes to": "展开这个组路由到的每一项",
+    "Fold this group into one row": "把这个组折叠成一行",
+    "Sent by {agents}": "{agents} 在发往这里",
+    "Fold this route into one row": "把这条路由折叠成一行",
+    "Show where this route goes": "显示这条路由发往哪里",
+    "Its week was used up, so one of {account}'s Codex resets was used by itself first.": "本周额度已用完，已先自动使用 {account} 的一张 Codex 重置卡。",
+  "{who} answered {status}: its week is used up and nobody else could take the request, so one of {account}'s Codex resets was used by itself and the request is asked again, before any of the reply reaches {agent}.": "{who} 返回 {status}：本周额度已用完且无其他账号可接手，已自动使用 {account} 的一张 Codex 重置卡并重发请求，{agent} 尚未收到任何回复。",
+    "held: its allowance used up, set not to spend credits": "额度已用尽，且设为不使用积分",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. The request went to {next}.": "{who} 认证失败。请在 magpie 中重新登录；当前登录不再重试。请求已转给 {next}。",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. No other account could answer.": "{who} 认证失败。请在 magpie 中重新登录；当前登录不再重试。没有其他账号可以回答。",
+    "Duplicated {name}": "已复制 {name}",
+    "{name} as text to paste into another magpie: its models, routing and rules, no key": "把 {name} 复制成文字，粘贴到另一个 magpie：带上模型、路由和规则，不带密钥",
+    "{name} copied: paste it into Import on another magpie's Routing page": "已复制 {name}：在另一个 magpie 的路由页点「导入」粘贴即可",
+    "Add a routing group someone shared from their magpie": "添加别人从他们的 magpie 分享的路由组",
+    "Paste a group copied with Copy to share": "粘贴用「分享为文字」复制的路由组",
+    "Replace {name}": "替换 {name}",
+    "{name} has the same id: its models, routing and rules are replaced by this group's; its accounts and folder rules stay": "{name} 的 id 相同：它的模型、路由和规则会被这个路由组替换；账号和按文件夹的规则保留",
+    "Replaced {name}": "已替换 {name}",
+    "A routing group shared from magpie": "从 magpie 分享的路由组",
+    "Paste a routing group someone shared from their magpie: its models, routing and rules come with it, never a key": "粘贴别人从 magpie 分享的路由组：模型、路由和规则都会带上，密钥从不随之分享",
+    "Not in your magpie, left out: {models}": "你的 magpie 里没有，已略过：{models}",
+    "The same model from your own provider: {models}": "换成你自己服务商的同一模型：{models}",
+    "1 rule left out with them": "1 条规则随之略过",
+    "{n} rules left out with them": "{n} 条规则随之略过",
+    "Needs models from two providers: {name} is the only one": "需要两家供应商的模型：目前只有 {name}",
+    "Needs a model cheap beside {name}": "需要一个比 {name} 便宜的模型",
+    "Add a provider first": "请先添加供应商",
+    "Start from a template: made of your own models, added in a click": "从模板开始：用你自己的模型组成，一键添加",
+    "Edit first": "先编辑",
+    "A copy of {name} with its models, routing and rules, listed after it": "复制 {name}，连同其模型、路由方式和规则，排在它之后",
+    "Purpose filter": "用途",
+    "Purpose: {name}": "用途：{name}",
+    "Unmarked": "未标记",
+    "Unrecognized request purpose": "未知调用用途",
+    "No purpose was recorded; this may be a conversation turn or an older record.": "没有记录调用用途，可能是主对话请求或较早的记录。",
+    "Filter routing by purpose": "按调用用途筛选路由",
+    "Counts for the requests in this list": "当前列表中请求的统计",
+    "Counts since the gateway started": "网关启动以来的统计",
+    "No failed request in this list": "当前列表中没有失败的请求",
+    "View usage": "查看用量",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. To keep every request's, turn on Request archive at the top of Usage › Requests.": "magpie 只保留最近 40 个请求的请求体和响应体，且退出后不再保留。要保留每个请求的，请在「用量 › 请求」顶部打开「请求存档」。",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. Request archive is on, but this request isn't in it: it was made while the archive was off, or it couldn't be saved.": "magpie 只保留最近 40 个请求的请求体和响应体，且退出后不再保留。「请求存档」已开启，但存档里没有这个请求：它是在存档关闭时发出的，或者没能保存下来。",
+    "Routing history for this request is no longer available.": "此请求的路由历史已不可用。",
+    "Token breakdown": "Token 明细",
+    "Input (uncached)": "输入（未缓存）",
+    "No token breakdown was recorded": "没有记录 Token 明细",
+    "Includes token usage from billable retries; the row totals show the final attempts": "包含计费重试的用量；列表总量为最终尝试的用量",
+    "Breakdown available for {n} of {total} requests": "{total} 个请求中有 {n} 个记录了明细",
+    "Avg. cache": "平均缓存",
+    "Avg. speed": "平均速率",
+    "Metrics to show": "选择显示的指标",
+    "request cache hit rate {p}": "请求缓存命中率 {p}",
+    "Based on {n} of {total} completed requests": "基于 {total} 个已完成请求中的 {n} 个",
+    "Total cache reads divided by total prompt tokens; larger prompts carry more weight": "缓存读取总量除以输入 token 总量；输入越大的请求权重越高",
+    "Total output tokens divided by total decode time; excludes waiting and replies without usable timing": "输出 token 总量除以输出耗时总和；不计等待时间及缺少有效计时的回复",
+    "Read the accounts' allowances again": "重新读取各账号的额度",
+    "live, as the gateway decides": "实时 · 网关正在做的决定",
+    "Add another model": "再添加一个模型",
+    "Sort by weight": "按权重排序",
+    "Heaviest first. When a model fails, the next one in this order takes over": "权重大的排在前面：某个模型失败时按这个顺序接替",
+    "Add pattern": "添加模式",
+    "e.g. openrouter/*:free or re:…": "例如 openrouter/*:free 或 re:…",
+    "Every model this pattern matches is in the group, as providers list them": "此模式匹配的模型都在组内，随供应商模型列表变化",
+    "No model magpie serves matches this pattern now": "magpie 提供的模型中暂无匹配此模式的",
+    "Classifier failed {when}: {error}": "分类器{when}失败：{error}",
+    "{by} couldn't say which intent or effort a turn is the last time it was asked: {error}. Until it answers, no rule with an intent matches and turns reason as the agent asked. Each request's details say what it was asked.": "{by} 上次被问到时没能判断出这一轮的意图或推理强度：{error}。在它恢复回答之前，带意图的规则都不会匹配，每一轮按 Agent 自己要求的推理强度进行。每个请求的详情里有它被问了什么。",
+    "In the group by a pattern: switch it off to send it nothing": "由模式匹配进组：关闭它即可不再发送请求",
+    "A pattern has a * in it, or starts with re:": "模式需要包含 *，或以 re: 开头",
+    "{pattern} is not a regular expression magpie can read": "{pattern} 不是 magpie 能识别的正则表达式",
+    "Every model a pattern matches is in the group, now and as providers list new ones, after the models above: * is any run of characters in provider/model, re: starts a regular expression.": "模式匹配的模型均入组（含供应商日后新增的），排在上方模型之后：* 匹配 provider/model 中任意字符，re: 开头表示正则表达式。",
+    "{api} only · after the others": "仅 {api} · 排在其他之后",
+    "{who} is in reserve: {n} of its provider's accounts or keys take requests at once, the first in the list, so it's tried only once they have all failed.": "{who} 是备用的：其提供商同时只用列表中前 {n} 个账号或 Key，所以只有它们都失败后才会试它。",
+    "{who} answered this conversation last, but it is in reserve while those before it in the list can take requests, so the conversation moves back to them.": "{who} 上次回答了这个对话，但列表中排在它前面的账号能接请求时它只作备用，所以对话回到它们那里。",
+    "in reserve · {n} at once": "备用 · 同时 {n} 个",
+    "key set to {api} only, no {api} URL · sent on the others": "key 只用 {api}，没有 {api} 地址 · 改走其他地址",
+    "{who} is made for {api}, not {other} as the keys routed over are, so it isn't one of them: it's tried after them.": "{who} 用于 {api}，与参与路由的 {other} 密钥不同，不算其中一员，排在它们之后尝试。",
+    "{n} keys for {api}": "{n} 个 {api} 密钥",
+    "New group": "新建组",
+    "Turn on routing groups": "打开路由组",
+    "Routing groups are on": "路由组已开启",
+    "Routing groups are off in Plugins › Built-in: the groups magpie finds, one model several providers serve, still route, but your own can't be made or changed here.": "路由组在「插件 › 内置」中已关闭：magpie 自动找到的组（多个供应商提供的同一个模型）照常路由，但这里不能新建或修改你自己的组。",
+    "Make a routing group of any models you like — agents pick it as one model": "用任意模型新建一个路由组，Agent 会把它当作一个模型来选",
+    "Filter groups and models": "筛选路由组和模型",
+    "No group or model matches “{q}”": "没有路由组或模型匹配“{q}”",
+    "This group can't be shown: {error}": "这个路由组无法显示：{error}",
+    "No group yet. A model two of your providers serve becomes one on its own; New group makes one of any models you like.": "还没有路由组。两个供应商都提供的模型会自动成组；「新建组」可组合任意模型。",
+    "1 found group removed": "已移除 1 个自动创建的组",
+    "{n} found groups removed": "已移除 {n} 个自动创建的组",
+    "magpie doesn't make them again. Click to bring one back.": "magpie 不会再自动创建它们。点击可恢复其中一个。",
+    "Pick several groups to remove together": "选出几个组一起移除",
+    "Select every group": "全选",
+    "Pick the groups to remove": "勾选要移除的组",
+    "{n} groups removed": "已移除 {n} 个组",
+    "No group yet. New group makes one of any models you like.": "还没有路由组。「新建组」可组合任意模型。",
+    "Find groups on their own": "自动创建路由组",
+    "Their models join no found group; the groups you made or changed keep them": "它们的模型不再自动成组；你新建或改过的组不受影响",
+    "Left out: {names}": "不参与自动成组：{names}",
+    "Leave out a provider…": "排除供应商…",
+    "Leave out of found groups": "不参与自动成组",
+    "Found groups changed": "自动路由组已更新",
+    "A model two or more of your providers serve becomes a group of them (auto/…). Switch it off to list and serve only the groups you made or changed.": "两个及以上供应商都提供的模型会自动成组（auto/…）。关闭后只列出和提供你新建或改过的组。",
+    "Off: only the groups you made or changed are listed and served. An agent set to a found group is moved to its model from one provider, and a request still naming one goes there too.": "已关闭：只列出和提供你新建或改过的组。选了自动组的 Agent 改用其中一个供应商的该模型，仍指定自动组的请求也发往那里。",
+    "Found groups are on": "已开启自动创建路由组",
+    "Found groups are off: only yours are listed and served": "已关闭自动创建路由组：只保留你自己的组",
+    "Bring it back": "恢复",
+    "{name} is back": "{name} 已恢复",
+    "Manual: every request goes to the model you pick on the group's card, over its own accounts or keys; the others, and the rules, wait until you pick another — none takes over when it fails.": "手动：所有请求发给在路由组卡片上选中的模型（在其账号或 Key 间路由）；改选前其他模型和规则不生效，失败时也不切换。",
+    "Manual: every request goes to the model picked on the group's card, over its own accounts or keys.": "手动：所有请求发给在路由组卡片上选中的模型，在其账号或 Key 间路由。",
+    "The rules wait while you pick the model by hand.":"手动选择模型时，规则暂不生效。",
+    "Model every request goes to": "所有请求发往的模型",
+    "no provider serves it now": "当前没有提供商可用",
+    "Every request goes to {name}": "所有请求都发给 {name}",
+    "Send every request to {name}": "把所有请求改发给 {name}",
+    "{name}: every request to {model}": "{name}：所有请求改发给 {model}",
+    "Click to fold it": "点击收起",
+    "Save or Cancel your changes first": "有未保存的修改，请先保存或取消",
+    "found by magpie — saving a change makes it yours": "由 magpie 自动发现，保存修改后归你管理",
+    "e.g. Opus anywhere": "例如：Opus 多家备份",
+    "Agents pick it as {id}": "Agent 里选 {id}",
+    "an agent set to {id} needs setting again": "已选 {id} 的 agent 需重新选择",
+    "The first answers for what the model can do. In order, they are tried top first.": "排第一的模型决定本组对外的能力；按顺序模式下从上往下尝试。",
+    "Rate limited to the back": "限流后排到最后",
+    "Its models too": "也列出成员模型",
+    "The group alone": "只列出本组",
+    "Its models unlisted": "成员模型不单独列出",
+    "Agents' model lists and the gateway's /v1/models show the group and each of its models.": "Agent 的模型列表和网关的 /v1/models 会列出本组，也列出组里的每个模型。",
+    "Agents' model lists and the gateway's /v1/models show the group, not the models it names or its patterns match: they are used through it. Codex keeps its ChatGPT sign-in's own models. A request naming one is still answered.": "Agent 的模型列表和网关的 /v1/models 只列出本组，不列出它点名的模型和模式匹配到的模型：这些模型通过本组使用。Codex 仍列出它所登录的 ChatGPT 账号自己的模型。直接点名其中一个模型的请求仍会被应答。",
+    "Slow to start": "迟迟不出字",
+    "Every member busy": "成员全都忙",
+    "When every member has failed with an error that may pass — overloaded, unavailable, rate limited for a moment — and nothing of the reply has reached the agent, each is asked again after a pause, longer each time and never shorter than the vendor asks, for up to {n} more. A streaming agent is kept waiting meanwhile.": "每个成员都因暂时性错误（过载、暂不可用、短暂限流）失败，而回复还一点都没到智能体时，过一会儿依次再问一遍每个成员，间隔一次比一次长，也不短于厂商要求的等待，最多再等 {n}。流式请求的智能体在此期间会一直被保持等待。",
+    "When every member has failed, the agent gets the last one's error at once.": "每个成员都失败时，智能体立刻拿到最后一个的错误。",
+    "{who} answered {status} · {fail}, and every member had failed with an error that may pass, so after {d} the {n} of them are asked again, in turn, before any of the reply reaches {agent}. The group waits up to {p} for one to answer.": "{who} 回了 {status} · {fail}，而每个成员都因暂时性错误失败，所以 {d} 后依次再问这 {n} 个，回复还一点都没到 {agent}。这个分组最多等 {p} 让其中一个回答。",
+    "Largest model's": "最大模型的",
+    "Smallest model's": "最小模型的",
+    "{v} is not a number of minutes": "{v} 不是有效的分钟数",
+    "Agents are told the group takes {n} tokens; a longer conversation still goes on to a member with room for it.": "告诉 agent 这个组的上下文是 {n} tokens；更长的对话仍会交给放得下它的成员。",
+    "Agents are told {n} tokens, its smallest model's, so they compact before any member would turn the conversation away.": "告诉 agent {n} tokens（组里最小模型的），这样 agent 会在任何成员拒收之前先压缩对话。",
+    "Agents are told its smallest model's window, so they compact before any member would turn the conversation away.": "告诉 agent 组里最小模型的上下文，这样 agent 会在任何成员拒收之前先压缩对话。",
+    "Agents are told {n} tokens, its largest model's; a conversation too long for one member goes on to one with room for it.": "告诉 agent {n} tokens（组里最大模型的）；某个成员放不下的对话会交给放得下的成员。",
+    "Agents are told {n} tokens, its largest model's; a conversation longer than {m} skips {who} for a member with room for it.": "告诉 agent {n} tokens（组里最大模型的）；超过 {m} 的对话会跳过 {who}，交给放得下的成员。",
+    "Agents are told its largest model's window; a conversation too long for one member goes on to one with room for it.": "告诉 agent 组里最大模型的上下文；某个成员放不下的对话会交给放得下的成员。",
+    "{v} is not a length of tokens like 200k or 1m": "{v} 不是有效的 token 长度，例如 200k 或 1m",
+    "Every member is waited for, however long it takes to begin answering.": "每个成员都会一直等到它开始回答，不论多久。",
+    "A member that hasn't begun answering after {n} — no text, reasoning or tool call yet — is let go and the next one asked, before any of it reaches the agent. Let go once, it doesn't rest; let go twice in a row, its model rests on that account, a minute and longer each time, until it answers again. The last one left is always waited for. Only for streamed requests.": "成员超过 {n} 仍未开始回答（无文字、思考或工具调用）时，改问下一个，此时尚无内容发给 agent。偶尔一次不休息；连续两次，该模型在这个账号上休息，从一分钟起每次更久，直到它再次回答。最后一个总会等到底。仅对流式请求生效。",
+    "Next after {n} without a first token": "{n} 无首字换下一个",
+    "{who} hadn't begun answering after {ms}, so the request went on to the next before any of it reached {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 超过 {ms} 未开始回答，请求在发给 {agent} 任何内容前转给下一个。{who} 本身没有出错，不休息。",
+    "{who} hadn't begun answering after {ms}, {n} times in a row, so the request went on to the next before any of it reached {agent}. It rests {d} for {model} alone, longer each time it is slow again; its other models answer as before.": "{who} 连续 {n} 次超过 {ms} 未开始回答，请求在发给 {agent} 任何内容前转给下一个。它仅就 {model} 休息 {d}，再慢则休息更久；它的其他模型照常回答。",
+    "{who} was rate limited at {time} while it had quota left, so it went to the back: it comes round again once those ahead of it are rate limited in turn.": "{who} 在 {time} 仍有额度时被限流，已排到最后：前面的账号依次被限流后才再轮到它。",
+    "rate limited at {time} · at the back": "{time} 被限流 · 排在最后",
+    "A group needs a model in it": "组里至少要有一个模型",
+    "Couldn't save the group: {error}": "分组没能保存：{error}",
+    "Add a rule": "添加规则",
+    "Add a condition": "添加条件",
+    "Conversation length": "对话长度",
+    "Hours and days": "时段",
+    "Remove condition": "移除条件",
+    "Actions for rule {n}": "规则 {n} 的操作",
+    "Move rule {n}": "移动规则 {n}",
+    "Pause the model instead": "改为暂停该模型",
+    "Send to the model instead": "改为先发给该模型",
+    "Remove rule": "删除规则",
+    "It can pick the model too: add a rule with an intent": "它也能挑模型：添加一条带意图的规则",
+    "in {folders}": "在 {folders} 中",
+    "The agent works in {folder}.": "Agent 的工作目录是 {folder}。",
+    "The agent works in one of these folders or a folder inside one, as it tells the model (Claude Code, Codex, OpenCode, Pi); an agent that doesn't say isn't matched": "Agent 的工作目录是这些文件夹之一或其子文件夹（以它告诉模型的为准：Claude Code、Codex、OpenCode、Pi）；不说明工作目录的 Agent 不匹配",
+    "Rule {n}: a folder is a whole path, like ~/work or /Users/me/work": "规则 {n}：文件夹需是完整路径，如 ~/work 或 /Users/me/work",
+    "The turn begins within these hours, in your time zone — a provider's peak-price hours sent to another, say": "本轮在此时段内（按你的时区）开始时生效，例如把某家高峰计价时段的请求转给另一家",
+    "{hours} ({zone})": "{hours}（{zone}）",
+    "{zone} time": "{zone} 时间",
+    "server time, {offset}": "服务器时间 {offset}",
+    "weekends": "周末",
+    "{from}–{to}": "{from}–{to}",
+    "{hours} {days}": "{days} {hours}",
+    "runs past midnight, into the next day": "跨过午夜，到第二天",
+    "Rule {n}: the hours are two times like 09:00 and 18:00": "第 {n} 条规则：时段要填两个时间，例如 09:00 和 18:00",
+    "Rule {n}: its hours are the whole day — pick days, or other hours": "第 {n} 条规则：时段为全天，请选择星期或其他时段",
+    "The agent summarizes the conversation to go on in less room (Claude Code's /compact, Codex, OpenCode…): a cheaper, faster model can do it": "Agent 总结对话以腾出上下文（Claude Code 的 /compact、Codex、OpenCode…）：可交给更便宜、更快的模型来做",
+    "longer conversations skip it: it takes {n} tokens": "更长的对话会跳过它：它的上下文只有 {n} tokens",
+    "The agent is compacting the conversation, so rule {n} sends the summary to {use}; the conversation stays on the model it was on.": "Agent 正在压缩上下文，规则 {n} 将总结交给 {use}；对话仍留在原模型。",
+    "Passed over, as the conversation is longer than they take: {models}.": "对话比它们的上下文长，已跳过：{models}。",
+    "reasoning ≥ {level}": "推理 ≥ {level}",
+    "not a condition": "不作为条件",
+    "thinking or any effort level": "开了 thinking 或任意推理强度",
+    "it doesn't take images": "它不支持图片",
+    "it takes {n} tokens": "它的上下文只有 {n} tokens",
+    "≥ {n} tokens": "≥ {n} tokens",
+    "1 rule": "1 条规则",
+    "{n} rules": "{n} 条规则",
+    "Rule {n} has no condition. Add one with its +, or remove the rule from its ⋯ menu": "第 {n} 条规则还没有条件：用它的 + 添加一个，或在它的 ⋯ 菜单里删除这条规则",
+    "This rule has no condition. Add one with its +, or remove the rule from its ⋯ menu": "这条规则还没有条件：用它的 + 添加一个，或在它的 ⋯ 菜单里删除这条规则",
+    "goes first; the others stay behind it": "先发给它；其余的在它后面备用",
+    "left out of the group: not tried, not a fallback": "移出分组：不会被调用，也不做备用",
+    "left out of the group then: not tried, not a fallback": "这段时间移出分组：不会被调用，也不做备用",
+    "not in {folders}": "不在 {folders} 中",
+    "not in folder": "不在文件夹",
+    "The agent works in none of these folders, nor a folder inside one, as it tells the model; an agent that doesn't say counts as outside them": "Agent 的工作目录不是这些文件夹，也不在它们之中（以它告诉模型的为准）；不说明工作目录的 Agent 算在它们之外",
+    "The agent didn't say which folder it works in.": "Agent 没有说明它的工作目录。",
+    "Rule {n}: a pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "第 {n} 条规则：暂停需要设时段、星期、Agent 或文件夹。用它的 + 添加，或在它的 ⋯ 菜单里删除这条规则",
+    "A pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "暂停需要设时段、星期、Agent 或文件夹：用它的 + 添加，或在它的 ⋯ 菜单里删除这条规则",
+    "{model} is paused by rule {n} ({when}), so it is left out until that ends.": "{model} 被规则 {n}（{when}）暂停，在此之前不会被调用。",
+    "{model} is paused by rule {n} of {group} ({when}), so it is left out until that ends.": "{model} 被 {group} 的规则 {n}（{when}）暂停，在此之前不会被调用。",
+    "asks for “{intent}”": "意图是“{intent}”",
+    "what it asks for, e.g. writing tests": "用户想做什么，例如：写测试",
+    "Intent told by": "意图判断模型",
+    "choose a model": "选择模型",
+    "As a turn begins, this model is asked which of the intents the message is — once; a small, fast one without reasoning is best. If it fails or can't say, no intent matches. Its calls show in the usage as magpie’s own.": "每轮开始时问此模型一次消息属于哪个意图，建议选小而快、不带推理的模型。出错或无法判断时，意图条件均不命中。其调用在用量中记为 magpie 自身的调用。",
+    "Choose the model that tells which intent a message is": "请选择用来判断消息意图的模型",
+    "A routing group classifies as any request to it goes: if its first model fails, the next is asked.": "路由组作判断模型时与普通请求相同：第一个模型失败则问下一个。",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so no rule with an intent matches it.": "{by} 未能判断第 {turn} 轮属于 {kinds} 中的哪一个（{err}），带意图的规则均不命中。",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so the turn keeps “{intent}”, as turn {prev} was.": "{by} 未能判断第 {turn} 轮属于 {kinds} 中的哪一个（{err}），因此沿用第 {prev} 轮的“{intent}”。",
+    "{by} was asked which of {kinds} turn {turn} is, and said none ({took}).": "{by} 判断第 {turn} 轮不属于 {kinds} 中的任何一个（{took}）。",
+    "{by} was asked which of {kinds} turn {turn} is, and answered “{said}”, which is no rule's intent ({took}).": "{by} 被问到第 {turn} 轮属于 {kinds} 中的哪一个，回答了“{said}”，但这不是任何规则的意图（{took}）。",
+    "{by} was asked which of {kinds} turn {turn} is, and said “{intent}” ({took}).": "{by} 判断第 {turn} 轮属于 {kinds} 中的“{intent}”（{took}）。",
+    "It was told turn {prev} was “{after}”, which a message that only carries on from it is too.": "并告知它第 {prev} 轮为“{after}”，仅承接上一轮的消息也归为此类。",
+    "{by} was to rate how hard turn {turn} is, but couldn't — {err} — so it reasons as the agent asked.": "{by} 未能评估第 {turn} 轮的难度（{err}），按 agent 要求的推理强度。",
+    "{by} wasn't asked how hard turn {turn} is: the group above picked {level} reasoning for it.": "{by} 未被要求评估第 {turn} 轮的难度：上一层分组已为这一轮选了 {level} 推理强度。",
+    "{by} rated turn {turn} {score} of 3, so it picks {level} reasoning for the turn — each model gets the level it has nearest.": "{by} 给第 {turn} 轮难度打 {score} 分（满分 3），选用 {level} 推理强度，各模型取最接近的档位。",
+    ", {n} sure": "，把握 {n}",
+    "Decided by": "决策模型",
+    "at {level} reasoning": "以 {level} 推理强度",
+    "The turn's pick replaced the {asked} {agent} asked for.": "由本轮判断选出，替代 {agent} 要求的 {asked}。",
+    "{level} is the model's nearest to the {asked} {agent} asked for.": "{level} 是模型最接近 {agent} 要求的 {asked} 的档位。",
+    "{level} reasoning, picked for the turn; {agent} asked for {asked}": "{level} 推理强度，由本轮判断选出；{agent} 原要求 {asked}",
+    "{level} reasoning, picked for the turn": "{level} 推理强度，这一轮判断选的",
+    "{level} reasoning, fixed on this model in the group; {agent} asked for {asked}": "{level} 推理强度，分组为此模型固定；{agent} 原要求 {asked}",
+    "{level} reasoning, fixed on this model in the group": "{level} 推理强度，分组为此模型固定",
+    "{level} reasoning, set by the rule; {agent} asked for {asked}": "{level} 推理强度，由规则设定；{agent} 原要求 {asked}",
+    "{level} reasoning, set by the rule": "{level} 推理强度，由规则设定",
+    "The rule asks this model for {level} reasoning, in place of the {asked} {agent} asked for.": "规则要求此模型使用 {level} 推理强度，取代 {agent} 要求的 {asked}。",
+    "As the agent asks": "跟随 Agent",
+    "the rule sets none": "规则不设定",
+    "The rule asks the model for {level} reasoning whatever the agent asks, at the model's nearest level; a model whose levels aren't known is asked as the agent asked": "无论 Agent 要求什么，规则都让该模型使用 {level} 推理强度（取模型最接近的档位）；不知道档位的模型按 Agent 的要求",
+    "Set its reasoning": "设定推理强度",
+    "Change its reasoning": "更改推理强度",
+    "The group fixes this model at {fixed} reasoning, in place of the {asked} {agent} asked for.": "分组为此模型固定 {fixed} 推理强度，取代 {agent} 要求的 {asked}。",
+    "{level} reasoning": "{level} 推理强度",
+    "Group's reasoning": "跟随分组推理",
+    "Follows {name}": "跟随 {name} 组",
+    "Its models reason as {name} says: set that up on {name}'s own card, not here": "它的模型按「{name}」组的档位推理，要改请到「{name}」那张卡片上改",
+    "Sent at {level} reasoning whatever the agent asks, at the model's nearest level": "无论 Agent 要求什么，都以 {level} 推理强度发送（取模型最接近的档位）",
+    "Reasons as the group's effort says": "推理强度按分组的设置",
+    "Follow the group": "跟随分组",
+    "Several levels…": "多个强度…",
+    "Mapped reasoning": "映射推理强度",
+    "Sent {pairs}; other levels as asked": "按 {pairs} 发送，其他强度按要求",
+    "Map levels…": "映射强度…",
+    "a level in place of the one asked": "以另一档强度代替所要求的",
+    "As asked": "按要求",
+    "the agent picks among them": "由 Agent 从中选择",
+    "The agent picks among {levels} reasoning, each sent at the model's nearest level": "由 Agent 在 {levels} 推理强度中选择，各取模型最接近的档位",
+    "{name} at that reasoning is in the group already": "{name} 以这个推理强度已经在分组里了",
+    "Standard speed": "标准速度",
+    "Sent in its vendor's fast mode whatever the agent asks: quicker, at a higher price": "无论 Agent 要求什么，都以服务商的快速模式发送：更快，价格更高",
+    "Sent at its vendor's usual speed; click to send it in fast mode": "以服务商的常规速度发送；点击改为快速模式",
+    "Asked for OpenAI's fast mode (service_tier \"priority\") whatever the agent asks: quicker, at a higher price, where your provider serves it. One that turns it away is asked without it": "无论代理怎么请求，都向服务商请求 OpenAI 的快速模式（service_tier \"priority\"）：服务商支持时更快，价格更高。服务商拒绝这个字段时，会去掉它再请求一次",
+    "Sent as the agent asks; click to ask your provider for OpenAI's fast mode (service_tier \"priority\")": "按代理的请求发送；点击向你的服务商请求 OpenAI 的快速模式（service_tier \"priority\"）",
+    "Off: kept in its place, sent nothing. Click to switch it on": "已停用：保留位置，不会收到请求。点击启用",
+    "On: requests may go to it. Click to switch it off and keep its place": "已启用：请求可能发给它。点击停用（保留位置）",
+    "Sent in its vendor's fast mode, as the group says": "按分组设置，以服务商的快速模式发送",
+    "{level} reasoning: the model's nearest to the {asked} {agent} asked for": "{level} 推理强度：模型最接近 {agent} 要求的 {asked} 的档位",
+    "{level} reasoning, as {agent} asked": "{level} 推理强度，按 {agent} 的要求",
+    "Jev is asked once as each turn begins, with the message and what it said of the turn before. Its calls show in the usage as magpie’s own.": "每轮开始时问 Jev 一次，附上消息和它对上一轮的判断。其调用在用量中记为 magpie 自身的。",
+    "Picked per turn": "每轮判断",
+    "Choose the model that rates how hard a turn is": "请选择判断每轮难度的模型",
+    "Turn {turn} reasons at {level}, as the classifier picked when it began.": "第 {turn} 轮按 {level} 推理，由判断模型在本轮开始时选定。",
+    "As a turn begins, the classifier rates how hard it is and the turn's requests ask their model for low, medium, high or xhigh reasoning — the level each model has nearest. Only where the agent asked for reasoning: a request without any (a session title) stays without.": "每轮开始时由判断模型评估难度，本轮请求按 low、medium、high 或 xhigh 推理（取各模型最接近的档位）。仅作用于 agent 要求推理的请求，不带推理的请求（如会话标题）保持不变。",
+    "As a turn begins, this model is asked how hard the turn is — once; a small, fast one without reasoning is best. If it fails or can't say, the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "每轮开始时问此模型一次本轮难度，建议选小而快、不带推理的模型。失败或无法判断时按 agent 要求的强度推理。其调用在用量中记为 magpie 自身的。",
+    "As a turn begins, this model is asked which of the intents the message is and how hard the turn is, each once; a small, fast one without reasoning is best. If it can't say, no intent matches and the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "每轮开始时分别问此模型一次消息意图和本轮难度，建议选小而快、不带推理的模型。无法判断时不匹配任何意图，并按 agent 要求的强度推理。其调用在用量中记为 magpie 自身的。",
+    "Each request reasons as much as the agent asked.": "每个请求按 agent 自己要求的强度推理。",
+    "Its models' shared": "成员共有",
+    "Agents are offered the levels every model has: {levels}.": "对 Agent 提供所有模型都有的档位：{levels}。",
+    "Agents are offered the levels every model has.": "对 Agent 提供所有模型都有的档位。",
+    "Agents are offered these. A model without the level asked is sent the one it has nearest.": "向 Agent 提供这些档位。模型没有所选档位时按最接近的发送。",
+    "Pick a level to offer, or leave them to its models": "请至少选一个档位，或改回成员共有",
+    "As a turn begins, Jev is asked once which of the intents the message is, and how hard the turn is when it picks the effort. An intent it isn't sure of matches no rule. Its calls show in the usage as magpie’s own.": "每轮开始时问 Jev 一次消息意图；若由它选推理强度，同时问本轮难度。没把握的意图不命中任何规则。其调用在用量中记为 magpie 自身的。",
+    "It was told turn {prev} reasoned at {level}, which a message that only carries on from it needs too.": "并告知它第 {prev} 轮按 {level} 推理，仅承接上一轮的消息也需同等强度。",
+    "Add an example rule": "添加示例规则",
+    "planning, design, or a hard problem to think through": "规划、设计，或需要深入思考的难题",
+    "With two models or more, a rule can send some turns to one of them first.": "组内有两个及以上模型时，可用规则将某些轮次先发给其中一个。",
+    "Checked top first when you send a message: the first that matches sends that turn to its model first; the rest stay behind it if it fails. A turn under way is never moved.": "发送消息时从上往下检查：第一条命中的规则将本轮先发给其指定的模型，其余成员作为故障转移。进行中的一轮不会换模型。",
+    "Rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "第 {turn} 轮开始时命中规则 {n}（{when}），先发给 {use}；本轮留在当时接手的模型上。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; if it fails, {then}, which the rules after it that match too name, then the group's others.": "第 {turn} 轮开始，命中规则 {n}（{when}），{use} 排第一；失败时先换后续命中规则指定的 {then}，再换组内其他模型。",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "规则 {n} 命中，但 {use} 没有能接这次请求的账号或 Key；后续命中的规则指定 {instead} 优先。",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "在 {group} 中，规则 {n} 命中，但 {use} 没有能接这次请求的账号或 Key；后续命中的规则指定 {instead} 优先。",
+    "Remove {name} from this rule": "从这条规则移除 {name}",
+    "Add a model it goes to next": "添加下一个模型",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first.": "规则 {n} 命中，但 {use} 没有能接这次请求的账号或 Key，于是由这条规则的下一个模型 {instead} 排第一。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first, then {more}, which the rule names after it; the later rules' and the group's others stay behind them.": "第 {turn} 轮开始，命中规则 {n}（{when}），{use} 排第一，其次是这条规则的 {more}；之后才是后续规则和组内的其他成员。",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first there.": "在 {group} 中，规则 {n} 命中，但 {use} 没有能接这次请求的账号或 Key，于是由这条规则的下一个模型 {instead} 在那里排第一。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; the group's others stay behind it if it fails.": "第 {turn} 轮开始，命中规则 {n}（{when}），{use} 排第一；失败时由组内其他成员接手。",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so the group's order stands.": "规则 {n} 命中，但 {use} 没有能接这次请求的账号或 Key，按组原本的顺序路由。",
+    "This turn began before magpie saw it, so the rules wait for the next one.": "本轮在 magpie 接收前已开始，规则从下一轮起判断。",
+    "No rule matches turn {turn} (about {n} tokens{img}).": "第 {turn} 轮没有命中规则（约 {n} tokens{img}）。",
+    "the group {name}": "路由组 {name}",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {group}'s order stands.": "在 {group} 中，规则 {n} 命中，但 {use} 没有能接这次请求的账号或 Key，组内顺序不变。",
+    "In {group}, rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "在 {group} 中，第 {turn} 轮开始时规则 {n}（{when}）先交给 {use}，本轮留在当时接手的模型上。",
+    "In {group}, rule {n} matches — {when} — so {use} goes first there.": "在 {group} 中，规则 {n} 命中（{when}），{use} 在组内排第一。",
+    "In {group}, no rule matches.": "在 {group} 中没有命中规则。",
+    "In {group}: {text}": "在 {group} 里：{text}",
+    "{who} is one of {path}, a group in {name}; that group routes {mode}.": "{who} 属于 {path}，即 {name} 中的子路由组，按「{mode}」路由。",
+    ", with an image": "，带图片",
+    "Within turn {turn} the conversation grew to about {tokens} tokens, more than the model it was on takes, so rule {n} ({when}) moves it to {use}.": "第 {turn} 轮中会话增至约 {tokens} tokens，超出当前模型的上限，按规则 {n}（{when}）换到 {use}。",
+    "{who} answered this conversation last, but a new turn begins and the group's rule {n} puts {use} first.": "{who} 上次回答了此会话，但新一轮命中分组规则 {n}，{use} 排第一。",
+    "Several accounts or keys": "多账号 / 多 Key",
+    "each provider routes over its own": "各供应商在自己的账号或 Key 间路由",
+    "Change how {name} routes": "改 {name} 的路由方式",
+    "Only one account or key is on for this, so routing has nothing to choose between. Turn on a second in the provider's editor, and how it routes is set under Several accounts or keys below.": "这里只开了一个账号或 Key，路由没有可选的。在供应商的编辑页再开一个，路由方式就在下面的「多账号 / 多 Key」里设置。",
+    "Smart, over the members' accounts and keys together: of the subscriptions with quota to spare, the one whose allowance renews soonest goes first — the week decides, and an account with five hours and no week (Claude Enterprise) goes by its five hours, so ahead of every week renewing later; one resting after a failure goes last.": "智能：成员的账号和 Key 统一排序。有余量的订阅中额度最先重置的排第一，以周额度为准；只有 5 小时额度的账号（如 Claude Enterprise）按 5 小时重置，排在更晚重置的周额度之前；失败后休息中的排最后。",
+    "In order: the first model until it can't answer, then the next — each over its own accounts or keys as its provider routes them.": "按顺序：先用第一个模型，无法响应再换下一个；各成员按其供应商的路由在自己的账号或 Key 间分配。",
+    "In turn: each conversation's next turn goes to the next member's account or key, spreading the load.": "轮流：会话的每一轮交给下一个成员的账号或 Key，均摊负载。",
+    "Least used first: the account or key with the most of its allowance left goes first.": "最少使用优先：剩余额度最多的账号或 Key 排第一。",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — its week at its reset, or credits in it that expire sooner — so less of each member's allowance is lost; an account with five hours and no week (Claude Enterprise) by what its five hours have left per hour until they renew, so almost always first; a key by the tokens magpie sent it lately.": "到期前用完：按剩余额度 ÷ 距作废小时数排序，越高越先用——周额度在重置时作废，更早过期的积分按过期时间算。只有 5 小时额度的账号（如 Claude Enterprise）按 5 小时窗口计算，几乎总排第一；Key 按最近发给它的 token 数排。",
+    "A group among the models, and a model whose provider routes its accounts or keys other than Smart, keeps its own routing: this group only picks between it and the others, weighing it by the account or key it would try first, then tries it whole in its own order. A group among the models left on Smart is routed as this group is, unless this one goes In order, By weight or Manual.": "成员中的路由组，以及服务商路由不是“智能”的模型，都保留自己的路由：本组只在它与其他成员间选择（按它会先用的账号或 Key 比较），选中后按其自身顺序整体尝试。成员中路由留在“智能”的路由组，按本组的路由走，除非本组是“按顺序”“按权重”或“手动”。",
+    "errors your agent saw": "Agent 收到的错误",
+    "It said: {error}": "原话：{error}",
+    "Copilot's Auto picked {model} ({via})": "Copilot 的 Auto 选了 {model}（{via}）",
+    "the model the account may pick by hand": "账号可手动选的模型",
+    "not from /auto: {why}": "未取自 /auto：{why}",
+    "sent to {api}": "发往 {api}",
+    "sent to {api} with Auto's session token": "发往 {api}，带 Auto 的会话令牌",
+    "Copilot refused it: {error}": "Copilot 拒绝了它：{error}",
+    "Show the latest request that failed": "查看最近一个失败的请求",
+    "another account's reasoning": "另一个账号的推理",
+    "reply too short": "回复长度过短",
+    "reply asked past the window left": "回复上限超出剩余上下文",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：服务商不接受 {agent} 的系统提示词，换哪个账号都一样，已在回复到达 {agent} 前转给下一个。{who} 本身无问题，不休息。",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, and nobody else is left to try, so {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：服务商不接受 {agent} 的系统提示词，换哪个账号都一样，且没有其他可尝试的，{agent} 收到该错误。{who} 本身无问题，不休息。",
+    "request not understood": "请求格式不被接受",
+    "images not taken": "不接受图片",
+    "{who} answered {status}: it takes no images, so it is asked again with the images described by the image recognition model, before any of the reply reaches {agent}. Later requests to it are described first. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：它不接受图片，已改用看图模型描述图片后重新询问，回复尚未到达 {agent}。之后发给它的请求会先描述图片。{who} 本身无问题，不休息。",
+    "reasoning effort not in its plan": "套餐不支持该推理强度",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, so another account goes on with it before any of the reply reaches {agent}. {who} serves other efforts, so it doesn't rest.": "{who} 返回 {status}：其套餐不支持所请求的推理强度，已在回复到达 {agent} 前转给另一个账号。{who} 仍支持其他强度，不休息。",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, and no account left that does could answer, so {agent} gets an error saying so.": "{who} 返回 {status}：其套餐不支持所请求的推理强度，也没有其他支持且能应答的账号，{agent} 收到说明原因的错误。",
+    "{who}: this computer had no network, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the network is back it is asked first again.": "{who}：这台电脑没有网络，请求未到达厂商，已转给下一个。{who} 本身无问题，不休息：网络恢复后仍最先问它。",
+    "{who}: this computer had no network, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who}：这台电脑没有网络，请求未到达厂商，且没有其他可尝试的，{agent} 收到该错误。{who} 本身无问题，不休息。",
+    "network down": "没有网络",
+    "servers overloaded": "服务器过载",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the proxy is up it is asked first again.": "{who}：magpie 使用的代理未接受连接，请求未到达厂商，已转给下一个。{who} 本身无问题，不休息：代理恢复后仍最先问它。",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Start the proxy, or change it in Settings.": "{who}：magpie 使用的代理未接受连接，请求未到达厂商，且无其他可试，{agent} 收到此错误。请启动代理，或在设置中更换。",
+    "{who} answered {status}: its API couldn't read something in the request that another's may, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：其 API 无法解析请求中的部分内容，其他家可能可以，已在回复到达 {agent} 前转给下一个。{who} 本身无问题，不休息。",
+    "{who}'s safety filter refused the request before saying anything, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 的安全过滤在输出任何内容前拒绝了此请求，已在回复到达 {agent} 前转给下一个。{who} 本身无问题，不休息。",
+    "{who}'s safety filter refused the request before saying anything, and nobody is left to try, so {agent} gets an error saying so, not an empty reply to ask again for.": "{who} 的安全过滤在输出任何内容前拒绝了此请求，且无其他可试，{agent} 收到说明拒绝的错误，而非会导致反复重试的空回复。",
+    "The vendor wants the account verified first: it rests half an hour, or until you say it's verified": "服务商要求先验证这个账号：它休息半小时，或等你确认已验证",
+    "{who} answered {status}: the vendor wants the account verified before it serves it again, and nobody is left to try, so {agent} gets the error with how to verify it. For a minute {agent}'s retries get the same answer without asking the vendor.": "{who} 返回 {status}：服务商要求先验证账号，且无其他可试，{agent} 收到此错误及验证方法。一分钟内 {agent} 的重试直接得到相同回复，不再请求服务商。",
+    "Verify the account ↗": "去验证账号 ↗",
+    "It's verified — try it again": "已验证，重新使用",
+    "account restricted by the vendor": "账号被服务商限制",
+    "The vendor restricted the account: it rests {d}, as only the vendor lifting the restriction brings it back. Appeal with the vendor; once it's lifted, try it again here": "服务商限制了这个账号：它休息 {d}，因为只有服务商解除限制才能让它恢复。请向服务商申诉；解除后，在这里重新使用",
+    "The restriction is lifted — try it again": "限制已解除，重新使用",
+    "{who} turned away the reasoning effort changed mid-conversation as an update that keeps its cache, so it is asked again at the new effort the usual way, before any of the reply reaches {agent}.": "{who} 不接受对话中途以保留缓存的「更新」方式切换推理强度，已在回复到达 {agent} 前按常规方式以新强度重问。",
+    "{who} takes no request for a reply as short as this one asked for, so it is asked again for the shortest it gives, before any of the reply reaches {agent}.": "{who} 不接受这么短的回复长度（max_tokens），已在回复到达 {agent} 前按其允许的最小值重问。",
+    "{who} couldn't read the reasoning another account wrote earlier in this conversation, so it is asked again without it, before any of the reply reaches {agent}.": "{who} 无法读取此会话中另一个账号先前写下的推理，已在回复到达 {agent} 前去掉这部分重问。",
+    "{agent} canceled the request while {who} was answering: nobody failed, so nobody rests and nobody else is asked.": "{who} 回答时 {agent} 取消了请求：无人出错，不休息，也不再问其他账号。",
+    "{who} answered {status} · {fail}, a failure that may pass. The conversation is kept on {who} for what its vendor cached of it, so it is asked once more in {d} before the request moves to another.": "{who} 返回 {status} · {fail}，这可能是暂时性错误。会话因其供应商缓存的内容而保持在 {who}，所以 {d} 后再问它一次，仍失败才转给其他。",
+    "{who} answered {status} · {fail}, and nobody else is left to ask — a failure that may pass, so it is tried again in {d}, before any of the reply reaches {agent}.": "{who} 返回 {status} · {fail}，且无其他可问；这可能是暂时性错误，{d} 后重试一次，此时尚未向 {agent} 发送任何回复。",
+    "{who} answered {status} · {fail}, and was to be asked again in {d}, but {agent} canceled the request before then, so nobody is asked again.": "{who} 返回 {status} · {fail}，原定 {d} 后重试，但 {agent} 在此之前取消了请求，因此不再重试。",
+    "Back to live": "回到实时",
+    "Replay them all": "全部重放",
+    "Stop replay": "停止重放",
+    "{n}× speed": "{n}× 速度",
+    "skipping a quiet stretch · clock {n}×": "跳过空闲时段 · 时钟 {n}×",
+    "request {i} of {n}": "第 {i}/{n} 个请求",
+    "sent {time}": "发出于 {time}",
+    "Replay from here": "从这里重放",
+    "{n} on {day}": "{day}的 {n} 个请求",
+    "the last {n} of {day}": "{day}最后的 {n} 个请求",
+    "How the last request was routed": "最近一个请求是怎么路由的",
+    "How the request at {time} was routed": "{time} 的请求是怎么路由的",
+    "No request yet": "还没有请求",
+    "Send one from any agent routed through magpie and it plays here as it happens: who routing put first and why, each try, and what each answered.": "经 magpie 的 Agent 发出请求后，这里实时播放：路由把谁排第一及原因、每次尝试和各自的回应。",
+    "Every request an agent sends to magpie shows up here, routed for real.": "Agent 发给 magpie 的每个请求都会在此显示，均为真实路由。",
+    "Another magpie serves the gateway; its routing plays live in that magpie's window.": "网关由另一个 magpie 提供，它的路由在那个 magpie 的窗口里实时播放。",
+    "The gateway isn't running, so nothing is routed.": "网关没有运行，因此没有任何路由。",
+    "The gateway is served by a magpie without a window (magpie serve), so its routing can't be watched. Stop it and let this magpie serve the gateway to see routing live.": "网关由无窗口的 magpie（magpie serve）提供，无法在此查看路由。停止它并由当前 magpie 提供网关，即可实时查看。",
+    "Smart: of the accounts with quota to spare, the one whose allowance renews soonest goes first — what it has left would be lost at the reset. The week decides; an account with five hours and no week goes by its five hours. One at 90% or more waits until the others can't answer; one resting after a failure goes last.": "智能：有余量的账号中额度最先重置的排第一，以免剩余额度在重置时作废。以周额度为准；只有 5 小时额度的账号按 5 小时重置。用到 90% 以上的，等其他都无法响应时才用；失败后休息中的排最后。",
+    "Smart: keys that suit the request go first — one made for the model's own API — then in their order. One resting after a failure goes last.": "智能：适合此请求的 Key（为该模型原生 API 准备的）排前，其余按顺序。失败后休息中的排最后。",
+    "In order: the first answers everything until it can't; then the next.": "按顺序：第一个处理所有请求，无法响应时再换下一个。",
+    "In turn: each conversation's next turn goes to the account after the one that answered its last, and a new conversation starts one further along; the requests within a turn stay put, keeping the prompt cache.": "轮流：会话的下一轮交给上一轮回答者的下一个账号，新会话再往后一个；一轮之内不换账号，保持提示词缓存。",
+    "Least used first: the account with the most of its allowance left goes first; a key by the tokens magpie sent it lately.": "最少使用优先：剩余额度最多的账号排第一；Key 按 magpie 最近发给它的 token 数排。",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — at its reset, or, when credits in it expire sooner, by those that expire first; an account with five hours and no week by what its five hours have left per hour. One at 90% or more waits until the others can't answer; a key by the tokens magpie sent it lately.": "到期前用完：按剩余额度 ÷ 距作废小时数排序，越高越先用——额度在重置时作废，有积分更早过期的按最先过期的那部分算；只有 5 小时额度的账号按 5 小时窗口计算。用到 90% 以上的，等其他都无法响应时才用；Key 按最近发给它的 token 数排。",
+    "Nothing could take {model}.": "没有谁能处理 {model}。",
+    "{who} is the only one, so it's tried though it is resting.": "只有 {who} 一个，虽在休息仍会尝试。",
+    "{who} is the only account on for {model} — nothing to choose between.": "{who} 是 {model} 唯一启用的账号，无需选择。",
+    "{name} has one key on — nothing to choose between.": "{name} 只启用了一个 Key，无需选择。",
+    "Every one is resting after a failure, so {who}, first in line, is tried all the same.": "所有账号都在失败后休息，仍先试排第一的 {who}。",
+    "{name} is resting, so its fallback {fb} goes first.": "{name} 正在休息，其备用 {fb} 排第一。",
+    "In order: {who} is first, and answers everything while it can.": "按顺序：{who} 排第一，能响应就由它处理。",
+    "Until used up: one answers everything until its quota is used up; then the next, which keeps them even after the one before renews.": "用完再换：一个处理所有请求，直到额度用完；再换下一个，前一个恢复后也继续用这个。",
+    "Until used up: one account or key, across the members, takes every request until it is used up; then the next in the list, which keeps them even after an earlier one renews. One rate limited or failing is passed over only while it rests.": "用完再换：所有成员的账号或密钥中，一个处理所有请求，直到它用完；再换列表里的下一个，前面的恢复后也继续用这个。被限流或出错的只在休息期间跳过。",
+    "Until used up: {who} is the one in use, and answers everything until it is used up.": "用完再换：当前用的是 {who}，用完之前由它处理所有请求。",
+    "In turn: it's {who}'s turn — each request starts one further along.": "轮流：本次轮到 {who}，每个请求从下一个开始。",
+    "Least used first: {who} has the most of its allowance left — {n} used.": "最少使用优先：{who} 剩余额度最多，已用 {n}。",
+    "Least used first: {who} served the fewest tokens lately — {n}.": "最少使用优先：{who} 最近处理的 token 最少（{n}）。",
+    "Least used first: {who} goes first.": "最少使用优先：{who} 排第一。",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} left, resets in {d}.": "到期前用完：{who} 的剩余额度 ÷ 距重置小时数最高，剩余 {n}，{d} 后重置。",
+    "Use before expiry: {who} has the most remaining allowance per hour until one of its Codex resets about to run out is used by itself — {n} left, used in {d}.": "到期前用完：{who} 的剩余额度 ÷ 距自动使用快到期 Codex 重置卡的小时数最高，剩余 {n}，{d} 后自动使用。",
+    "Use before expiry: {who} has the most credits expiring per hour until they expire — {n} of its allowance expires in {d}.": "到期前用完：{who} 快过期的积分 ÷ 距过期小时数最高，额度的 {n} 将在 {d} 后过期。",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} used.": "到期前用完：{who} 的剩余额度 ÷ 距重置小时数最高，已用 {n}。",
+    "Use before expiry: {who} served the fewest tokens lately — {n}.": "到期前用完：{who} 最近处理的 token 最少（{n}）。",
+    "Use before expiry: {who} goes first.": "到期前用完：{who} 排第一。",
+    "{who} goes first: it's made for {api}, the API {model} is at home in, so nothing is translated.": "{who} 排第一：它专为 {api} 而设，正是 {model} 的原生 API，无需转换。",
+    "{who} goes first: keys go in their order, those that suit the request first.": "{who} 排第一：Key 按顺序排，适合此请求的在前。",
+    "{who} goes first.": "{who} 排第一。",
+    "its provider is set to be used first.": "它的供应商设为优先使用。",
+    "{who} goes first: its provider is set to be used first.": "{who} 排第一：它的供应商设为优先使用。",
+    "The vendor hasn't said yet what these accounts have left, so they go in their order: {who} first.": "厂商尚未告知这些账号的剩余额度，按顺序排：{who} 第一。",
+    "Every account is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "所有账号均已用到 90% 以上，剩余最多的排第一：{who}，已用 {n}。",
+    "Every key and account here is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "这里的密钥和账号均已用到 90% 以上，剩余最多的排第一：{who}，已用 {n}。",
+    "{who} goes first: it has quota to spare, and the others are kept for last.": "{who} 排第一：它还有余量，其他账号留到最后。",
+    "{who} goes first: of those with quota to spare, its allowance starts again soonest — one of its Codex resets about to run out is used by itself in {d}, and what it has left then is lost. {other} renews later and keeps its own.": "{who} 排第一：有余量的账号中它的额度最先重新开始，{d}后将自动使用其快到期的 Codex 重置卡，届时剩余额度作废。{other} 重置较晚，额度暂留。",
+    "{who} goes first: of those with quota to spare, its allowance renews soonest — in {d} — and what it has left then is lost. {other} renews later and keeps its own.": "{who} 排第一：有余量的账号中它的额度最先重置（{d}后），届时剩余额度作废。{other} 重置较晚，额度暂留。",
+    "{who} goes first: its allowance renews in the same hour as {other}'s, and its shorter one sooner — in {d}.": "{who} 排第一：它与 {other} 的额度在同一小时重置，而它较短的窗口更早（{d}后）。",
+    "{who} and {other} renew within the same hour, so the order given stays — and the vendor's prompt cache stays warm.": "{who} 和 {other} 在同一小时内重置，保持原顺序，厂商的提示词缓存也保持命中。",
+    "{who} goes first, in the order given: when its allowance renews isn't known.": "{who} 按原有顺序排第一：不知道它的额度何时重置。",
+    "{who} goes first: of those alike, its wallet has the most left — {n}, where {other} has {m}.": "{who} 排第一：同类账号里，它的钱包剩得最多——{n}，{other} 剩 {m}。",
+    "{who} is resting — {why}, {when} — so it waits at the back.": "{who} 正在休息（{why}，{when}），排在最后。",
+    "{who} is at {n} — all but used up, it answers only when nothing else can.": "{who} 已用 {n}，几乎用尽，仅在其他都无法响应时使用。",
+    "{who} is at {n} — kept for when the others can't.": "{who} 已用 {n}，其他账号都无法响应时才用。",
+    "{member} isn't passed over for being near its limit: by weight this request was {first}'s share, and {member} takes its own share of the requests while it can answer.": "{member} 不会因为快用完而被跳过：按权重，这次请求轮到 {first}，{member} 只要还能响应，就照样按权重分到它那份请求。",
+    "{member} isn't passed over for being near its limit: it comes after {first} in {group}'s order.": "{member} 不会因为快用完而被跳过：它按 {group} 的顺序排在 {first} 之后。",
+    "{who}: what it has left isn't known yet, so it goes after those known.": "{who}：剩余额度未知，排在已知的之后。",
+    "{who}: what it has left isn't known yet, and its answer tells, so it goes before those known.": "{who}：剩余额度未知，回答一次即可得知，因此排在已知的之前。",
+    "{who} goes first: what it has left isn't known yet, and its answer tells — kept behind those known, it would never answer and never be known.": "{who} 排第一：剩余额度未知，回答一次即可得知；若排在已知的之后，就永远轮不到，也永远无法得知。",
+    "{who} is left out: its plan doesn't list {model}.": "{who} 不参与：它的套餐不包含 {model}。",
+    "{who} is left out: {name} lists {model} to its other keys, not this one.": "{who} 不参与：{name} 只为其他 key 列出了 {model}，未为此 key 列出。",
+    "{who} is answering…": "{who} 正在回答…",
+    "rerouted from {from}": "改道自 {from}",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the model of its latest chat turn, so it stays with the provider the chat is on.": "{agent} 自行选了 {model} 来发一个不带工具的短请求（比如对话标题）；magpie 让 {to} 来处理，即它最近一轮对话所用的模型，这样它留在对话所在的服务商。",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the first model it lists, as it has had no chat turn yet.": "{agent} 自行选了 {model} 来发一个不带工具的短请求（比如对话标题）；magpie 让 {to} 来处理，即它列出的第一个模型，因为它还没有过对话轮次。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model of its latest chat turn.": "{agent} 请求了 {model}，但 magpie 不提供它；magpie 让 {to} 来处理，即它最近一轮对话所用的模型。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the first model it lists.": "{agent} 请求了 {model}，但 magpie 不提供它；magpie 让 {to} 来处理，即它列出的第一个模型。",
+    "Claude Code in {agent} asked for {model}, its own id for a Claude tier; magpie served it on {to}, the model picked for that tier.": "{agent} 里的 Claude Code 用它自己的 Claude 档位 id 请求了 {model}；magpie 让 {to} 来处理，即为该档位选的模型。",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, that tier's model on the provider the chat is on.": "{agent} 里的 Claude Code 为它自己的调用请求了 {model}；magpie 让 {to} 来处理，即对话所在服务商上该档位的模型。",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, the chat's model, so it stays with the provider the chat is on.": "{agent} 里的 Claude Code 为它自己的调用请求了 {model}；magpie 让 {to} 来处理，即对话所用的模型，这样它留在对话所在的服务商。",
+    "{agent}'s auto mode classifier asked for {model}; magpie served it on {to}, the model /model moved its tier to.": "{agent} 的自动模式分类器请求了 {model}；magpie 让 {to} 来处理，即 /model 把该档位改成的模型。",
+    "{agent} asked for {model} by Claude's full id; magpie served it on {to}, the model set for that tier.": "{agent} 用 Claude 的完整 id 请求了 {model}；magpie 让 {to} 来处理，即为该档位设定的模型。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model its config names.": "{agent} 请求了 {model}，但 magpie 不提供它；magpie 让 {to} 来处理，即它配置里写的模型。",
+    "{agent} asked for {model} for a call of its own, which magpie doesn't serve; magpie served it on {to}, the model its last turn was answered on.": "{agent} 为它自己的调用请求了 {model}，但 magpie 不提供它；magpie 让 {to} 来处理，即它上一轮所用的模型。",
+    "{agent} asked for {model}, one of its own default models, for its memories, and its config names no model for them; magpie served it on {to}, the model of its conversation.": "{agent} 为它的记忆请求了它自己的默认模型 {model}，而它的配置没有为记忆指定模型；magpie 让 {to} 来处理，即它这段对话所用的模型。",
+    "Masking would have changed this request, so magpie sent it as written to {to}, the model set for that in Settings › Privacy.": "脱敏会改动这个请求，所以 magpie 把它原样发给了 {to}，即在 设置 › 隐私 里为此设定的模型。",
+    "magpie served it on {to} in place of {model}.": "magpie 让 {to} 代替 {model} 处理了它。",
+    "Stand-in": "替代",
+    "{who} answered in {ms}{tk}. {agent} got one clean reply and never saw the {n} that failed first.": "{who} 用 {ms} 完成回答{tk}。{agent} 只收到一次正常回复，看不到之前失败的 {n} 次。",
+    "{who} answered in {ms}{tk}.": "{who} 用 {ms} 完成回答{tk}。",
+    "{who} answered {status} · {fail}. {how}; the request goes on to {next} before any of the reply reaches {agent}.": "{who} 返回 {status} · {fail}。{how}；请求在回复到达 {agent} 前转给 {next}。",
+    "{who} answered {status} and nobody is left to try, so {agent} gets the error.": "{who} 返回 {status}，且无其他可试，{agent} 收到此错误。",
+    "{who} answered {status} — an error another account wouldn't fix, so {agent} gets it.": "{who} 返回 {status}，换账号也无法解决，{agent} 收到此错误。",
+    "{who} hadn't begun answering after {ms}, and nobody is left to try, so {agent} gets the error.": "{who} 超过 {ms} 未开始回答，且无其他可试，{agent} 收到此错误。",
+    "{who} answered {status} and nobody is left to try. {agent} gets the error an earlier try gave, not this used-up allowance, so it doesn't stop as if every account were out.": "{who} 返回 {status}，且无其他可试。{agent} 收到的是此前某次尝试的错误，而不是此处额度用完的错误，因此不会当作所有账号都已用完而停下。",
+    "{who} answered {status}.": "{who} 返回 {status}。",
+    "{who} answered {status}, and the request goes on to {next} before any of the reply reaches {agent}. {who} doesn't rest for it.": "{who} 返回 {status}，请求在回复到达 {agent} 前转给 {next}。{who} 不因此休息。",
+    "{who} answered {status} · {fail}. {how}; nobody is left to try, so {agent} gets the error.": "{who} 返回 {status} · {fail}。{how}；且无其他可试，{agent} 收到此错误。",
+    "{who} began answering, then broke off · {fail}. {agent} got what was said before the error; {how}, so {agent}'s next request goes to another first.": "{who} 开始回答后中断 · {fail}。{agent} 收到出错前已输出的内容；{how}，{agent} 的下一次请求会先交给其他成员。",
+    "{who} began answering, then broke off. {agent} got what was said before the error; the conversation isn't kept on {who} for its next request.": "{who} 开始回答后中断。{agent} 收到出错前已输出的内容；此会话的下一次请求不再固定交给 {who}。",
+    "It rests {d}, as the vendor's Retry-After says": "按厂商 Retry-After 的要求，它休息 {d}",
+    "It sits out half an hour, until someone tops it up": "它先休息半小时，等人充值",
+    "Its allowance is used up: it rests until that renews, at {time}": "它的额度用尽了：休息到额度在 {time} 重置",
+    "It rests until {time}, when the vendor says the limit resets": "它休息到 {time}，厂商说那时额度重置",
+    "It rests 15 minutes: out of quota, with no word of when it resets": "它休息 15 分钟：额度用尽，但没说何时重置",
+    "It has failed {n} times in a row: it rests {d}, longer each time": "它已连续失败 {n} 次：休息 {d}，每次更久",
+    "It rests {d}, longer if it fails again": "它休息 {d}，再失败就更久",
+    "It doesn't rest: its provider is set to ask it again after an error like this": "它不休息：它的提供方设为遇到这类错误后照常再问它",
+    "It rests {d}": "它休息 {d}",
+    "It cools down {d}: the vendor didn't say for how long": "它冷却 {d}：厂商没说要多久",
+    "It was rate limited again as soon as it was back ({n} times in a row): it rests {d}, longer each time until it answers": "恢复后立即再次被限流（连续 {n} 次）：休息 {d}，逐次延长，直到正常应答",
+    "With {rested} resting after a failure, {who} goes first: ": "{rested} 失败后正在休息，{who} 排第一：",
+    "the others go in their order.": "其余按顺序排。",
+    "In order: with {rested} resting after a failure, {who} is the first that can answer.": "按顺序：{rested} 失败后休息中，{who} 是第一个可响应的。",
+    "{agent} asked for {model}": "{agent} 请求 {model}",
+    "Background memory task": "后台记忆整理",
+    "Codex is organizing memories from earlier chats in the background. This can continue after a chat finishes.": "Codex 正在后台整理历史聊天中的记忆，回答结束后也可能继续运行。",
+    "Title requests were automatically matched using the prompt and the applied chat title.": "标题请求根据提问内容和实际应用的聊天标题自动关联。",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it; other providers (such as Claude) are excluded regardless of quota.": "子代理任务已加密，只能使用 ChatGPT 账号；其他供应商（如 Claude）不参与选择，无论剩余多少额度。",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it.": "子代理任务已加密，只能使用 ChatGPT 账号。",
+    "{who} goes first: it answered the parent agent and may be needed to read this encrypted task.": "{who} 回答了主代理，因此优先用它读取这条加密任务。",
+    "{who} compacted this conversation natively, and only it can read that compaction, so the conversation stays on it: other accounts aren't asked. Start a new conversation to use them.": "{who} 原生压缩了这条对话，只有它能读取这份压缩，所以对话留在它上面，不会问其他账号。开一个新对话即可使用其他账号。",
+    "{agent} requested a subagent; magpie selects its model within this routing group.": "{agent} 请求了子代理，由 magpie 在此路由组内选择模型。",
+    "{agent} requested a subagent on {model}.": "{agent} 请求了使用 {model} 的子代理。",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents are set to {to}, but {why}.": "{agent} 请求了使用 {model} 的子代理，并保留在该模型上：它的子代理设为 {to}，但{why}。",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model set for its subagents.": "{agent} 请求了使用 {model} 的子代理；magpie 将其改用 {to}，即为它的子代理设定的模型。",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model its lead is on.": "{agent} 请求了使用 {model} 的子代理；magpie 将其改用 {to}，即主代理正在用的模型。",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents follow their lead, on {to}, but {why}.": "{agent} 请求了使用 {model} 的子代理，并保留在该模型上：它的子代理跟随主代理，用 {to}，但{why}。",
+    "Background prompt suggestions": "后台提示词建议",
+    "magpie ran this web search for {agent}'s {model}, which can't search the web by itself: {searcher} searched, and {model} goes on answering once it has what was found. Not a turn of the conversation.": "magpie 代 {agent} 的 {model} 发起的联网搜索：{model} 无法自行搜索，由 {searcher} 搜索，{model} 拿到结果后继续回答。不属于对话轮次。",
+    "{agent} called magpie's web_search MCP tool: {searcher} searched for it. Not a turn of the conversation.": "{agent} 调用了 magpie 的 web_search MCP 工具：由 {searcher} 代为搜索。不属于对话轮次。",
+    "{agent} called magpie's analyze_image MCP tool: {describer} looked at the image for it. Not a turn of the conversation.": "{agent} 调用了 magpie 的 analyze_image MCP 工具：由 {describer} 代为查看图片。不属于对话轮次。",
+    "magpie ran this web search for a model that can't search the web by itself: {searcher} searched, and that model goes on answering once it has what was found. Not a turn of the conversation.": "magpie 代一个无法自行搜索的模型发起的联网搜索：由 {searcher} 搜索，该模型拿到结果后继续回答。不属于对话轮次。",
+    "Every turn starts with a request to {name}, a subscription: it counts against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "每轮开始时都会先向订阅 {name} 发一个请求：它和智能体自己的请求一样计入该订阅的额度。选免费模型或 API 密钥上的模型，订阅就只留给智能体用。",
+    "Every turn starts with two requests to {name}, a subscription: they count against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "每轮开始时都会先向订阅 {name} 发两个请求：它们和智能体自己的请求一样计入该订阅的额度。选免费模型或 API 密钥上的模型，订阅就只留给智能体用。",
+    "magpie had {describer} describe an image for {agent}'s {model}: nothing magpie knows says {model} can see images, so it is counted as text-only and given the description in the image's place. If it does see them, tick “Accepts images” for it in its provider's models. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie 让 {describer} 为 {agent} 的 {model} 描述图片：magpie 所知的信息都没有说 {model} 能看图，所以把它当作只收文本，在图片位置给它这段描述。如果它其实能看图，请在它的服务商的模型里勾选“支持图片输入”。描述图片的模型在 设置 › 模型 › 识图模型 里选。不属于对话轮次。",
+    "magpie had {describer} describe an image for {agent}'s {model}, which its provider's list or its own setting says takes text only: {model} is given the description in the image's place. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie 让 {describer} 为 {agent} 的 {model} 描述图片：它的服务商的模型列表或它自己的设置说它只收文本，{model} 在图片位置收到这段描述。描述图片的模型在 设置 › 模型 › 识图模型 里选。不属于对话轮次。",
+    "magpie had {describer} describe an image for a model that can't see images, which is given the description in the image's place. Not a turn of the conversation.": "magpie 让 {describer} 为一个无法看图的模型描述图片，该模型在图片位置收到这段描述。不属于对话轮次。",
+    "{agent} drafted the suggested prompts on its home page by itself, in the background, searching the project's files and connected apps, and checked them for safety. Not a turn of the conversation; Codex's Settings › Configuration › Suggested prompts turns it off.": "{agent} 在后台自行生成首页的提示词建议（会搜索项目文件和已连接的应用）并做安全检查，不属于对话轮次。可在 Codex 的 设置 › 配置 › 提示词建议 中关闭。",
+    "{agent} sent this turn on Luna Reserve, which it turns to once the plan's own allowance is used up; it picks the model itself.": "{agent} 用 Luna 储备发出了本轮（套餐额度用完后改用），模型由它自行选择。",
+    "{agent} made this call itself ({kind}), not as a turn of the conversation, and picks its model itself.": "{agent} 自行发起的调用（{kind}），不属于对话轮次，模型由它自行选择。",
+    "{agent} checked that magpie answers, as it does when it starts and from its Test connection. It names this check's model itself, from the names in its model list ({model}), not the model chosen in the conversation, and only reads whether an answer comes back; magpie sends it to the model chosen in {agent}'s model menu, or to its first listed model when none is. Not a turn of the conversation.": "{agent} 在检查 magpie 能否应答（启动时和在 Test connection 里都会发）。这次检查的模型由它自己按模型列表里的名字选出（{model}），不是对话里选的模型，它也只看有没有回应；magpie 会把它发给 {agent} 模型菜单里选的模型，没选时发给列表里的第一个模型。不属于对话轮次。",
+    "Nothing was tried: {error}": "没有尝试任何账号：{error}",
+    "{agent} asked for {model}: {name} serves it, and the vendor is asked for {sent}": "{agent} 请求 {model}：由 {name} 提供，向厂商请求的模型是 {sent}",
+    "the last {n} the gateway keeps": "网关保留的最近 {n} 个",
+    "Accounts and keys": "账号与密钥",
+    "over those requests": "统计自这些请求",
+    "over today's requests": "统计自今天的请求",
+    "Nothing on {day}": "{day}没有请求",
+    "No requests since magpie started": "magpie 启动以来还没有请求",
+    "Each request an agent sends through magpie shows up here: who answered it, why, and each try.": "agent 经 magpie 发出的每个请求都列在这里：由谁应答、为何选它，以及每次尝试。",
+    "Earlier ones are kept by day, in the bar above.": "更早的请求按天保存，在上面的日期里查看。",
+    "Earlier days": "更早的日期",
+    "tried {n}": "尝试 {n}",
+    "answered {n}": "应答 {n}",
+    "last answered {time}": "最近应答 {time}",
+    "as of {time}": "截至 {time}",
+    "{n} used at {time}; it has renewed since": "{time} 时已用 {n}，之后已重置",
+    "routing…": "路由中…",
+    "masking…": "脱敏中…",
+    "back in {d}": "{d}后恢复",
+    "free · costs nothing": "免费 · 不花额度",
+    "back at {time} · in {d}": "{time} 恢复 · 还有 {d}",
+    "its plan doesn't list {model}": "套餐不包含 {model}",
+    "set to serve other models, not {model}": "已设为只用于其他模型，不含 {model}",
+    "{who} is left out: it is set to serve other models, not {model}.": "{who} 不参与：它已设为只用于其他模型，不含 {model}。",
+    "held at its {cap}% usage cap": "已达 {cap}% 用量上限",
+    "request longer than its {n} window · passed over": "请求超出其 {n} 上下文 · 已跳过",
+    "{who} is left out: this request is longer than its {n} context window, so it would only refuse it. It's asked only once every one with room is out of its allowance.": "{who} 不参与：这个请求超出它 {n} 的上下文窗口，发给它只会被拒绝。只有能容下的都用完额度时才会问它。",
+    "not an account the gateway key may use": "不是该网关密钥可用的账号",
+    "{who} is left out: the gateway key asking may not use its account.": "{who} 被排除：发起请求的网关密钥不能使用它的账号。",
+    "{who} is left out: a usage window is used up, and the account is set not to spend its credits, so it counts as used up until that window renews.": "{who} 不参与：某个用量窗口已用完，且该账号设为不使用积分，窗口重置前视为已用完。",
+    "{who} is left out: a usage window is at {n}, past the {cap}% cap set on the account, so it counts as used up until that window renews.": "{who} 不参与：某个用量窗口已用 {n}，超过该账号的 {cap}% 上限，窗口重置前视为已用完。",
+    "{name}'s list for this key has no {model}": "{name} 为此 key 列出的模型中没有 {model}",
+    "answering…": "回答中…",
+    "answering another request…": "在回答另一个请求…",
+    "answered this request": "回答了这个请求",
+    "picked for “{intent}”": "按意图“{intent}”选中",
+    "answered {agent}": "回答了 {agent}",
+    "{n} agents at once": "{n} 个 Agent 同时在发",
+    "In order: member by member, the first model the group names until it can't answer, each over its own accounts or keys as its provider routes them.": "按顺序：逐个成员，先用组内第一个模型，无法响应再换下一个；各成员按其供应商的路由在自己的账号或 Key 间分配。",
+    "{agent} asked for the routing group {name}: {members}": "{agent} 请求了路由组 {name}：{members}",
+    "Kept on {who}: it answered this conversation before, and affinity keeps a session with one account.": "留在 {who}：此会话之前由它回答，亲和性使会话保持同一账号。",
+    "Kept on {who}: {agent} is handing back tool results within turn {n}, and moving now would lose what the vendor cached of it.": "留在 {who}：{agent} 正在第 {n} 轮内回传工具结果，此时换账号会丢掉厂商为它缓存的内容。",
+    "Kept on {who}: {d} ago the vendor read {r} tokens of this conversation from its cache and wrote {w} to it; anyone else would be sent them afresh and paid in full.": "留在 {who}：{d}前厂商从缓存读取了此会话的 {r} tokens，并写入了 {w} tokens；换账号需重新发送并全价计费。",
+    "Turn {n} begins: in turn, it goes to the one after {who}, which answered the last turn — {next}.": "第 {n} 轮开始：轮流交给上一轮回答者 {who} 的下一个，即 {next}。",
+    "Turn {n} begins: affinity keeps a conversation only within a turn, so routing decides afresh.": "第 {n} 轮开始：亲和性仅在一轮内保持，路由重新决定。",
+    "{who} answered this conversation last, but it is resting, so the conversation moves.": "此会话上次由 {who} 回答，但它在休息，已换账号。",
+    "{who} answered this conversation last, but its allowance is all but used up, so the conversation moves.": "此会话上次由 {who} 回答，但其额度将尽，已换账号。",
+    "Every one here has used up its allowance and goes on on its credits, set to spend them only after everything else, so {who}, first in line, goes first.": "这里每个账号额度都已用尽、改用积分，且都设为最后使用积分，所以先试排第一的 {who}。",
+    "{who} has used up its allowance and goes on on its credits, which it is set to spend only after everything else: it is tried after every other account, key and fallback.": "{who} 额度已用尽、改用积分，且设为最后使用积分：排在所有其他账号、密钥和备用之后。",
+    "{who} answered this conversation last, but it is on its credits now, set to spend them only after everything else, so the conversation moves to {first}.": "此会话上次由 {who} 回答，但它现在在用积分，且设为最后使用积分，所以会话换到 {first}。",
+    "{who} answered this conversation last, but it is no longer one to route to.": "此会话上次由 {who} 回答，但它已不可路由。",
+    "{who} answered this conversation last, but the group goes in order and {first}, ahead of it, is ready again, so turn {n} goes back to {first}.": "此会话上次由 {who} 回答，但该组按顺序路由，排在它前面的 {first} 已恢复可用，所以第 {n} 轮回到 {first}。",
+    "{who}, a fallback, answered this conversation last, but the provider's own {first} is ready again, so turn {n} goes back to it.": "此会话上次由备用 {who} 回答，但提供商自己的 {first} 已恢复可用，所以第 {n} 轮回到它。",
+    "{who} took this conversation while {first}, listed ahead of it in the group, couldn't; {first} is ready again, so turn {n} goes back to it.": "此会话由 {who} 接手，当时组里排在它前面的 {first} 无法处理；{first} 已恢复可用，所以第 {n} 轮回到它。",
+    "{who}, a fallback, answered this conversation last. The provider's own {first} is ready again, but Stays is Strict, which never moves a conversation, so it stays on the fallback; new conversations go to {first}.": "此会话上次由备用 {who} 回答。提供商自己的 {first} 已恢复可用，但会话保持设为严格，从不移动会话，所以它留在备用上；新会话会走 {first}。",
+    "{who} answered this conversation last, but the vendor then read only {r} tokens of it from its cache and wrote {w} — not worth staying for.": "此会话上次由 {who} 回答，但当时厂商只从缓存读取了 {r} tokens、写入了 {w} tokens，不值得保留。",
+    "{who} answered this conversation {d} ago, longer than the 5 minutes a vendor keeps a prompt cached — so routing decides afresh.": "此会话 {d}前由 {who} 回答，已超过厂商缓存提示词的 5 分钟，路由重新决定。",
+    "Affinity is off: each request is routed afresh, whoever answered its conversation before.": "亲和性已关闭：每个请求都重新路由，不论之前由谁回答。",
+    "{status} · {fail} · passed to {agent}": "{status} · {fail} · 已交给 {agent}",
+    "{status} · {fail} · went on to the next": "{status} · {fail} · 已转给下一个",
+    "{n} used · all but used up": "已用 {n} · 几乎用尽",
+    "{n} used · kept for last": "已用 {n} · 留到最后",
+    "{n} used · renews in {d}": "已用 {n} · {d}后重置",
+    "{n} left · all but used up": "剩余 {n} · 几乎用尽",
+    "Its allowance had just run out and it was refused, so it was asked again at once to spend its credits.": "额度刚用完被拒，于是立即重试一次，改用其 Credits。",
+    "{who} answered {status}: its allowance had just run out, but the account holds credits, which the vendor spends once the allowance is used up, so it is asked again at once, before any of the reply reaches {agent}.": "{who} 返回 {status}：额度刚刚用完，但该账号有 Credits，额度用完后供应商会改扣 Credits，因此立即重试，回复不会传到 {agent}。",
+    "It holds credits, so it rests only {d} and its usage is read again, not until its allowance renews": "它有 Credits，只休息 {d} 并重新读取用量，不必等到额度恢复",
+    "{who} is at {n} of its allowance but goes on on its credits — ahead of those used up with nothing to go on with, after those with allowance left.": "{who} 额度已用 {n}，但仍可用 Credits 继续 —— 排在额度未用完的账号之后、额度用完且无 Credits 的账号之前。",
+    "{n} used · on credits": "已用 {n} · 使用 Credits",
+    "{n} left · on credits": "剩余 {n} · 使用 Credits",
+    "{n} used · on credits · after the others": "已用 {n} · 使用积分 · 排在最后",
+    "{n} left · on credits · after the others": "剩余 {n} · 使用积分 · 排在最后",
+    "Every account is all but used up, so {who} goes first: it goes on on its credits, which the vendor spends once its allowance is used up.": "所有账号额度都几乎用尽，因此 {who} 排第一：额度用完后供应商会改扣其 Credits，可以继续使用。",
+    "{n} left · kept for last": "剩余 {n} · 留到最后",
+    "{n} left · renews in {d}": "剩余 {n} · {d}后重置",
+    "renews in {d}": "{d}后重置",
+    "{n} used · renews in {d} · one renewing sooner goes first": "已用 {n} · {d}后重置 · 先用更早重置的账号",
+    "{n} left · renews in {d} · one renewing sooner goes first": "剩余 {n} · {d}后重置 · 先用更早重置的账号",
+    "{n} used · conversation kept on another": "已用 {n} · 会话留在另一个账号",
+    "{n} left · conversation kept on another": "剩余 {n} · 会话留在另一个账号",
+    "{n} left at {time}; it has renewed since": "{time} 时剩余 {n}，之后已重置",
+    "what's left not known yet": "剩余额度未知",
+    "{n} tokens lately": "最近 {n} token",
+    "first text in {ms}": "{ms} 后出现正文",
+    "requested {sent} · served {served}": "请求 {sent} · 实际 {served}",
+    "served {served}": "实际 {served}",
+    "Upstream: {upstream}": "上游：{upstream}",
+    "The aggregator passed the request on to {upstream}, as its reply says: the provider that actually answered it.": "聚合供应商把这条请求转给了 {upstream}，由它实际作答（聚合供应商的回复里写明）。",
+    "{sent} is a routing group of the remote magpie, and it routed the request to {served}: the group picking one of its models, not the vendor swapping the model.": "{sent} 是远程 magpie 的路由组，请求被路由给 {served}：这是路由组选择了组内模型，并非服务商替换了模型。",
+    "The vendor was asked for {sent}, but its reply says {served} answered: likely another model. The same model under a dated name or spelled otherwise isn't marked.": "向服务商请求的是 {sent}，但回复说是 {served} 作答，很可能换成了别的模型。（同一模型只是带了日期或写法不同，不会这样标出。）",
+    "ClinePass route {served}": "ClinePass 路由 {served}",
+    "requested {sent} · ClinePass route {served}": "请求 {sent} · ClinePass 路由 {served}",
+    "ClinePass answered {sent} through {served}, a route it picks itself: the name is the route's, not another model's.": "ClinePass 通过它自己选的路由 {served} 回答了 {sent}：这是路由的名字，不是换成了别的模型。",
+    "Its reply says {upstream} answered.": "回复说是 {upstream} 作答。",
+    "Its reply didn't say which provider answered.": "回复没有说是哪家上游作答。",
+    "{pin} was asked for, but its reply didn't say which provider answered, so whether ClinePass kept to it is unknown.": "请求时指定了 {pin}，但回复没有说是哪家上游作答，所以无法确定 ClinePass 是否照做。",
+    "No provider was asked for, and its reply didn't say which one answered.": "请求时没有指定上游，回复也没有说是哪家作答。",
+    "{h} h {m} min": "{h} 小时 {m} 分钟",
+    "magpie saved a report of where it held this request. If it keeps happening, send the report with yours.": "magpie 保存了一份报告，记下这个请求卡在了哪里。如果反复出现，请把这份报告附在你的反馈里。",
+    "Report copied": "报告已复制",
+    "Couldn't read the report: {error}": "读不到这份报告：{error}",
+    "Open Folder": "打开文件夹",
+    "not an account {group} may use": "不是 {group} 可用的账号",
+    "{who} is left out: the routing group {group} is held to other accounts of its provider.": "{who} 被跳过：路由组 {group} 只用该服务商的其他账号。",
+    "Requests to this group's models spend only the accounts picked here. A provider left on any of its accounts uses them all.": "发到这个组里模型的请求只消耗这里选中的账号。保持“任一账号”的服务商会用它的所有账号。",
+    "{n} of its accounts": "{n} 个账号",
+    "Any of its accounts": "任一账号",
+    "This group spends only {accounts} of {provider}": "这个组只消耗 {provider} 的 {accounts}",
+    "This group may spend every account of {provider}": "这个组可以消耗 {provider} 的每个账号",
+  },
+  "zh-TW": {
+    "sign-in refused (answered since)": "登入曾被拒（之後已應答）",
+    "Free first uses it before paid ones, and Cheapest first counts it as costing nothing": "免費優先會先用它再用付費的，最便宜優先把它算作不花錢",
+    "{name}, {n} accounts: {windows}": "{name}（{n} 個帳號）：{windows}",
+    "What is left of this provider's accounts the group can use, together: amounts of one unit added up, a share the mean of the accounts on one plan. Each account is on the Usage page.": "本組可用的這家供應商帳號合起來還剩多少：同一單位的額度相加，百分比取同一方案帳號的平均值。各帳號詳情在用量頁。",
+    "Each session's context window": "各會話的上下文視窗",
+    "Show this session's newest request": "顯示這個會話最新的請求",
+    "Its plugin sent this request itself, so magpie can't split its time": "此請求由外掛自行發出，magpie 無法拆分它的耗時",
+    "Claude Code sent this request itself, so magpie can't split its time": "此請求由 Claude Code 自行發出，magpie 無法拆分它的耗時",
+    "magpie is masking this request before routing it (Settings › Privacy), so who takes it isn't picked yet.": "magpie 正在為這個請求脫敏（設定 › 隱私），脫敏完才路由，所以還沒選出由誰處理。",
+    "magpie hasn't routed this request yet, so who takes it isn't picked yet.": "magpie 還沒開始路由這個請求，所以還沒選出由誰處理。",
+    "Nothing took this request: {error}": "沒有誰處理這個請求：{error}",
+    "{n} groups · {m} on": "{n} 個組 · {m} 個開啟",
+    "Filter, or type an agent's name…": "篩選，或輸入 Agent 名稱…",
+    "the name its User-Agent begins with": "User-Agent 開頭的名稱",
+    "heard from in the last 30 days": "近 30 天有請求",
+    "The subagent effort set in magpie is {effort}; the model's supported levels and a routing group's fixed member effort still apply.": "magpie 為子代理設定的推理強度是 {effort}；仍按模型支援的等級適配，並保留路由群組成員的固定強度。",
+    "{agent} guessed your next message for its composer by itself, reading the whole conversation again. Not a turn of the conversation; Codex composer predictions, under Settings in Codex's row on the Agents page, picks its model, and Codex's Settings › General › Show predictions turns it off.": "{agent} 自行為輸入框猜測你的下一則訊息，每次都把整段對話重讀一遍。不屬於對話輪次；在 Agent 頁 Codex 那一列的設定裡，用 Codex 輸入框預測 選它用的模型，在 Codex 的 設定 › 一般 › 顯示預測內容 裡可以關掉。",
+    "{agent}'s call to magpie's web_search MCP tool": "{agent} 對 magpie 的 web_search MCP 工具的呼叫",
+    "{agent}'s call to magpie's analyze_image MCP tool": "{agent} 對 magpie 的 analyze_image MCP 工具的呼叫",
+    "a model that can't see images": "一個看不了圖片的模型",
+    "{failed}, the Image recognition model picked in Settings › Models, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "{failed} 是在 設定 › 模型 裡選的識圖模型，但它沒能為 {whom} 描述圖片：{why}。所以 magpie 改讓下一個可用的識圖模型 {describer} 來描述。不屬於對話輪次。",
+    "{failed}, the model magpie picked to describe images, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "{failed} 是 magpie 自動選的識圖模型，但它沒能為 {whom} 描述圖片：{why}。所以 magpie 改讓下一個可用的識圖模型 {describer} 來描述。不屬於對話輪次。",
+    "{agent}'s {model}": "{agent} 的 {model}",
+    "a model that can't search the web by itself": "一個自己不能聯網搜尋的模型",
+    "{failed}, the searcher picked in Settings › Models › Web search, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "{failed} 是在 設定 › 模型 › 聯網搜尋 裡選的代搜模型，但它沒能為 {whom} 搜尋：{why}。所以 magpie 改讓下一個可用的代搜模型 {searcher} 來搜。不屬於對話輪次。",
+    "{failed}, the searcher magpie picked, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "{failed} 是 magpie 自動選的代搜模型，但它沒能為 {whom} 搜尋：{why}。所以 magpie 改讓下一個可用的代搜模型 {searcher} 來搜。不屬於對話輪次。",
+    "Add a condition": "新增條件",
+    "Conversation length": "對話長度",
+    "Hours and days": "時段",
+    "Remove condition": "移除條件",
+    "Actions for rule {n}": "規則 {n} 的操作",
+    "Move rule {n}": "移動規則 {n}",
+    "Pause the model instead": "改為暫停該模型",
+    "Send to the model instead": "改為先發給該模型",
+    "Remove rule": "刪除規則",
+    "It can pick the model too: add a rule with an intent": "它也能挑模型：新增一條帶意圖的規則",
+    "This routing group will no longer be available to agents.": "此路由組將不再供 Agent 使用。",
+    "These routing groups will no longer be available to agents.": "這些路由組將不再供 Agent 使用。",
+    "By session": "按會話",
+    "By key": "按金鑰",
+    "These requests came with no gateway key: from this computer, or from before magpie noted the key.": "這些請求沒有帶閘道金鑰：來自這台電腦，或是在 magpie 記下金鑰之前的。",
+    "No session ID": "未提供會話標識",
+    "{n} in progress": "{n} 個進行中",
+    "These requests did not provide a session ID; they are not treated as one conversation.": "這些請求沒有提供會話標識，不視為同一個會話。",
+    "Estimated at effective model prices, including cache reads and writes; subscription billing may differ. Totals cover only the requests listed here.": "按模型有效價格估算，包含快取讀寫；訂閱實際計費可能不同。合計僅包含目前列表中的請求。",
+    "No known price or token counts for this request": "此請求缺少已知價格或 Token 用量",
+    "Drag to reorder — agents' model lists show the groups in this order · Alt+↑/↓ to move": "拖動排序，Agent 的模型列表按此順序列出路由組 · Alt+↑/↓ 移動",
+    "Group order saved": "路由組順序已儲存",
+    "{picked}, the Image recognition model picked in Settings, isn't set up any more, so magpie had {describer}, its automatic choice, describe an image for {agent}'s {model} in its place. Pick another in Settings › Models › Image recognition. Not a turn of the conversation.": "設定裡選的識圖模型 {picked} 已無法使用，所以 magpie 讓自動選擇的 {describer} 代為給 {agent} 的 {model} 描述圖片。請在 設定 › 模型 › 識圖模型 裡另選一個。不屬於對話輪次。",
+    "In agents’ lists": "Agent 列表裡的名稱",
+    "Names in agents’ lists": "Agent 列表裡的名稱",
+    "Whether “· routing group” follows a group’s name in the agents’ lists: one setting for every group, and for the provider after each model’s name, as on Settings.": "Agent 的模型列表裡，路由組名後面是否帶「· routing group」。這是所有路由組共用的一個設定，也決定模型名後面是否帶供應商，和「設定」裡的是同一個。",
+    "“· routing group” is set for every group, under the list": "是否帶「· routing group」在列表下方統一設定，對所有路由組生效",
+    "{name} is switched off: the group skips it until it is on again": "{name} 已關閉：開啟前這個組會跳過它",
+    "{n} switched off": "{n} 個已關閉",
+    "Off: agents aren't offered {name} and a request to it is turned away. Click to switch it on": "已關閉：Agent 列表裡沒有 {name}，發給它的請求會被拒絕。點選開啟",
+    "On: agents may pick {name}. Click to switch it off and keep it as it is": "已開啟：Agent 可以選用 {name}。點選暫時關閉，組的設定原樣保留",
+    "{name} switched on": "已開啟 {name}",
+    "{name} switched off": "已關閉 {name}",
+    "in {groups}": "已在 {groups}",
+    "By weight: it's {who}'s share — each key takes requests as its weight says.": "按權重：輪到 {who} 的份額——每個金鑰按自己的權重接請求。",
+    "By weight: it's {who}'s share \u2014 each account takes requests as its weight says.": "按權重：輪到 {who} 的份額——每個帳號按自己的權重接請求。",
+    "By weight: it's {who}'s share — each model takes requests as the weight set beside it says.": "按權重：輪到 {who} 的份額——每個模型按旁邊設定的權重接請求。",
+    "By weight: each model takes its share of the requests by the weight set beside it — one weighing 3 three for every one a model weighing 1 takes, spread out rather than in bursts. One resting after a failure leaves the round and the others share its requests; the next model is the fallback when one fails.": "按權重：每個模型按旁邊設定的權重分得請求——權重 3 的模型每接 3 個，權重 1 的接 1 個，均勻穿插而不是成批連發。失敗後休息中的模型退出這一輪，其餘模型分擔它的請求；某個模型失敗時，由下一個模型接替。",
+    "Its share of the requests: a model weighing 3 takes three for every one a model weighing 1 takes": "它在請求中的份額：權重 3 的模型每接 3 個請求，權重 1 的接 1 個",
+    "Weight of {name}": "{name} 的權重",
+    "A weight is 1 to 1000": "權重為 1 到 1000",
+    "{name}: {routing}": "{name}：{routing}",
+    "How {name} routes: click to change it": "{name} 的路由方式：點擊更改",
+    "{n} available": "{n} 個可用",
+    "{n} resting": "{n} 個休息中",
+    "{n} held": "{n} 個暫不使用",
+    "Show each key": "展開每個金鑰",
+    "Fold these keys into one row": "把這些金鑰合併成一列",
+    "Show each account": "展開每個帳號",
+    "Fold these accounts into one row": "把這些帳號合併成一列",
+    "Show what this group routes to": "展開這個組路由到的每一項",
+    "Fold this group into one row": "把這個組摺疊成一列",
+    "Sent by {agents}": "{agents} 正發往這裡",
+    "Fold this route into one row": "把這條路由摺疊成一列",
+    "Show where this route goes": "顯示這條路由發往哪裡",
+    "Its week was used up, so one of {account}'s Codex resets was used by itself first.": "本週額度已用完，已先自動使用 {account} 的一張 Codex 重置卡。",
+    "{who} answered {status}: its week is used up and nobody else could take the request, so one of {account}'s Codex resets was used by itself and the request is asked again, before any of the reply reaches {agent}.": "{who} 返回 {status}：本週額度已用完且無其他帳號可接手，已自動使用 {account} 的一張 Codex 重置卡並重發請求，{agent} 尚未收到任何回覆。",
+    "held: its allowance used up, set not to spend credits": "額度已用盡，且設為不使用積分",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. The request went to {next}.": "{who} 認證失敗。請在 magpie 中重新登入；目前登入不再重試。請求已轉給 {next}。",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. No other account could answer.": "{who} 認證失敗。請在 magpie 中重新登入；目前登入不再重試。沒有其他帳號可以回答。",
+    "Duplicated {name}": "已複製 {name}",
+    "{name} as text to paste into another magpie: its models, routing and rules, no key": "把 {name} 複製成文字，貼到另一個 magpie：帶上模型、路由和規則，不帶金鑰",
+    "{name} copied: paste it into Import on another magpie's Routing page": "已複製 {name}：在另一個 magpie 的路由頁點「匯入」貼上即可",
+    "Add a routing group someone shared from their magpie": "新增別人從他們的 magpie 分享的路由組",
+    "Paste a group copied with Copy to share": "貼上用「分享為文字」複製的路由組",
+    "Replace {name}": "取代 {name}",
+    "{name} has the same id: its models, routing and rules are replaced by this group's; its accounts and folder rules stay": "{name} 的 id 相同：它的模型、路由和規則會被這個路由組取代；帳號和依資料夾的規則保留",
+    "Replaced {name}": "已取代 {name}",
+    "A routing group shared from magpie": "從 magpie 分享的路由組",
+    "Paste a routing group someone shared from their magpie: its models, routing and rules come with it, never a key": "貼上別人從 magpie 分享的路由組：模型、路由和規則都會帶上，金鑰從不隨之分享",
+    "Not in your magpie, left out: {models}": "你的 magpie 裡沒有，已略過：{models}",
+    "The same model from your own provider: {models}": "換成你自己服務商的同一模型：{models}",
+    "1 rule left out with them": "1 條規則隨之略過",
+    "{n} rules left out with them": "{n} 條規則隨之略過",
+    "Needs models from two providers: {name} is the only one": "需要兩家供應商的模型：目前只有 {name}",
+    "Needs a model cheap beside {name}": "需要一個比 {name} 便宜的模型",
+    "Add a provider first": "請先新增供應商",
+    "Start from a template: made of your own models, added in a click": "從範本開始：用你自己的模型組成，一鍵新增",
+    "Edit first": "先編輯",
+    "A copy of {name} with its models, routing and rules, listed after it": "複製 {name}，連同其模型、路由方式與規則，排在它之後",
+    "Purpose filter": "用途",
+    "Purpose: {name}": "用途：{name}",
+    "Unmarked": "未標記",
+    "Unrecognized request purpose": "未知呼叫用途",
+    "No purpose was recorded; this may be a conversation turn or an older record.": "沒有記錄呼叫用途，可能是主對話請求或較早的記錄。",
+    "Filter routing by purpose": "按呼叫用途篩選路由",
+    "Counts for the requests in this list": "目前列表中請求的統計",
+    "Counts since the gateway started": "閘道啟動以來的統計",
+    "No failed request in this list": "目前列表中沒有失敗的請求",
+    "View usage": "檢視用量",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. To keep every request's, turn on Request archive at the top of Usage › Requests.": "magpie 只保留最近 40 個請求的請求體和回應體，且結束後不再保留。要保留每個請求的，請在「用量 › 請求」頂部開啟「請求存檔」。",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. Request archive is on, but this request isn't in it: it was made while the archive was off, or it couldn't be saved.": "magpie 只保留最近 40 個請求的請求體和回應體，且結束後不再保留。「請求存檔」已開啟，但存檔裡沒有這個請求：它是在存檔關閉時發出的，或者沒能儲存下來。",
+    "Routing history for this request is no longer available.": "此請求的路由歷史已不可用。",
+    "Token breakdown": "Token 明細",
+    "Input (uncached)": "輸入（未快取）",
+    "No token breakdown was recorded": "沒有記錄 Token 明細",
+    "Includes token usage from billable retries; the row totals show the final attempts": "包含計費重試的用量；列表總量為最終嘗試的用量",
+    "Breakdown available for {n} of {total} requests": "{total} 個請求中有 {n} 個記錄了明細",
+    "Avg. cache": "平均快取",
+    "Avg. speed": "平均速率",
+    "Metrics to show": "選擇顯示的指標",
+    "request cache hit rate {p}": "請求快取命中率 {p}",
+    "Based on {n} of {total} completed requests": "基於 {total} 個已完成請求中的 {n} 個",
+    "Total cache reads divided by total prompt tokens; larger prompts carry more weight": "快取讀取總量除以輸入 token 總量；輸入越大的請求權重越高",
+    "Total output tokens divided by total decode time; excludes waiting and replies without usable timing": "輸出 token 總量除以輸出耗時總和；不計等待時間及缺少有效計時的回覆",
+    "Read the accounts' allowances again": "重新讀取各帳號的額度",
+    "live, as the gateway decides": "即時 · 閘道正在做的決定",
+    "Add another model": "再新增一個模型",
+    "Sort by weight": "依權重排序",
+    "Heaviest first. When a model fails, the next one in this order takes over": "權重大的排在前面：某個模型失敗時依這個順序接替",
+    "Add pattern": "新增模式",
+    "e.g. openrouter/*:free or re:…": "例如 openrouter/*:free 或 re:…",
+    "Every model this pattern matches is in the group, as providers list them": "此模式匹配的模型都在組內，隨供應商模型列表變化",
+    "No model magpie serves matches this pattern now": "magpie 提供的模型中暫無匹配此模式的",
+    "Classifier failed {when}: {error}": "分類器{when}失敗：{error}",
+    "{by} couldn't say which intent or effort a turn is the last time it was asked: {error}. Until it answers, no rule with an intent matches and turns reason as the agent asked. Each request's details say what it was asked.": "{by} 上次被問到時沒能判斷出這一輪的意圖或推理強度：{error}。在它恢復回答之前，帶意圖的規則都不會匹配，每一輪按 Agent 自己要求的推理強度進行。每個請求的詳情裡有它被問了什麼。",
+    "In the group by a pattern: switch it off to send it nothing": "由模式匹配進組：關閉它即可不再發送請求",
+    "A pattern has a * in it, or starts with re:": "模式需要包含 *，或以 re: 開頭",
+    "{pattern} is not a regular expression magpie can read": "{pattern} 不是 magpie 能識別的正規表示式",
+    "Every model a pattern matches is in the group, now and as providers list new ones, after the models above: * is any run of characters in provider/model, re: starts a regular expression.": "模式匹配的模型均入組（含供應商日後新增的），排在上方模型之後：* 匹配 provider/model 中任意字元，re: 開頭表示正規表示式。",
+    "{api} only · after the others": "僅 {api} · 排在其他之後",
+    "{who} is in reserve: {n} of its provider's accounts or keys take requests at once, the first in the list, so it's tried only once they have all failed.": "{who} 是備用的：其供應商同時只用清單中前 {n} 個帳號或 Key，所以只有它們都失敗後才會試它。",
+    "{who} answered this conversation last, but it is in reserve while those before it in the list can take requests, so the conversation moves back to them.": "{who} 上次回答了這個對話，但清單中排在它前面的帳號能接請求時它只作備用，所以對話回到它們那裡。",
+    "in reserve · {n} at once": "備用 · 同時 {n} 個",
+    "key set to {api} only, no {api} URL · sent on the others": "key 只用 {api}，沒有 {api} 位址 · 改走其他位址",
+    "{who} is made for {api}, not {other} as the keys routed over are, so it isn't one of them: it's tried after them.": "{who} 用於 {api}，與參與路由的 {other} 金鑰不同，不算其中一員，排在它們之後嘗試。",
+    "{n} keys for {api}": "{n} 個 {api} 金鑰",
+    "New group": "新增組",
+    "Turn on routing groups": "開啟路由組",
+    "Routing groups are on": "路由組已開啟",
+    "Routing groups are off in Plugins › Built-in: the groups magpie finds, one model several providers serve, still route, but your own can't be made or changed here.": "路由組在「外掛 › 內建」中已關閉：magpie 自動找到的組（多個供應商提供的同一個模型）照常路由，但這裡不能新增或修改你自己的組。",
+    "Make a routing group of any models you like — agents pick it as one model": "用任意模型新增一個路由組，Agent 會把它當作一個模型來選",
+    "Filter groups and models": "篩選路由組和模型",
+    "No group or model matches “{q}”": "沒有路由組或模型匹配「{q}」",
+    "This group can't be shown: {error}": "這個路由組無法顯示：{error}",
+    "No group yet. A model two of your providers serve becomes one on its own; New group makes one of any models you like.": "還沒有路由組。兩個供應商都提供的模型會自動成組；「新增組」可組合任意模型。",
+    "1 found group removed": "已移除 1 個自動建立的組",
+    "{n} found groups removed": "已移除 {n} 個自動建立的組",
+    "magpie doesn't make them again. Click to bring one back.": "magpie 不會再自動建立它們。點選可恢復其中一個。",
+    "Pick several groups to remove together": "選出幾個組一起移除",
+    "Select every group": "全選",
+    "Pick the groups to remove": "勾選要移除的組",
+    "{n} groups removed": "已移除 {n} 個組",
+    "No group yet. New group makes one of any models you like.": "還沒有路由組。「新增組」可組合任意模型。",
+    "Find groups on their own": "自動建立路由組",
+    "Their models join no found group; the groups you made or changed keep them": "它們的模型不再自動成組；你新增或改過的組不受影響",
+    "Left out: {names}": "不參與自動成組：{names}",
+    "Leave out a provider…": "排除供應商…",
+    "Leave out of found groups": "不參與自動成組",
+    "Found groups changed": "自動路由組已更新",
+    "A model two or more of your providers serve becomes a group of them (auto/…). Switch it off to list and serve only the groups you made or changed.": "兩個及以上供應商都提供的模型會自動成組（auto/…）。關閉後只列出和提供你新增或改過的組。",
+    "Off: only the groups you made or changed are listed and served. An agent set to a found group is moved to its model from one provider, and a request still naming one goes there too.": "已關閉：只列出和提供你新增或改過的組。選了自動組的 Agent 改用其中一個供應商的該模型，仍指定自動組的請求也發往那裡。",
+    "Found groups are on": "已開啟自動建立路由組",
+    "Found groups are off: only yours are listed and served": "已關閉自動建立路由組：只保留你自己的組",
+    "Bring it back": "恢復",
+    "{name} is back": "{name} 已恢復",
+    "Manual: every request goes to the model you pick on the group's card, over its own accounts or keys; the others, and the rules, wait until you pick another — none takes over when it fails.": "手動：所有請求發給在路由組卡片上選中的模型（在其帳號或 Key 間路由）；改選前其他模型和規則不生效，失敗時也不切換。",
+    "Manual: every request goes to the model picked on the group's card, over its own accounts or keys.": "手動：所有請求發給在路由組卡片上選中的模型，在其帳號或 Key 間路由。",
+    "The rules wait while you pick the model by hand.": "手動選擇模型時，規則暫不生效。",
+    "Model every request goes to": "所有請求發往的模型",
+    "no provider serves it now": "目前沒有供應商可用",
+    "Every request goes to {name}": "所有請求都發給 {name}",
+    "Send every request to {name}": "把所有請求改發給 {name}",
+    "{name}: every request to {model}": "{name}：所有請求改發給 {model}",
+    "Click to fold it": "點選收起",
+    "Save or Cancel your changes first": "有未儲存的修改，請先儲存或取消",
+    "found by magpie — saving a change makes it yours": "由 magpie 自動發現，儲存修改後歸你管理",
+    "e.g. Opus anywhere": "例如：Opus 多家備份",
+    "Agents pick it as {id}": "Agent 裡選 {id}",
+    "an agent set to {id} needs setting again": "已選 {id} 的 agent 需重新選擇",
+    "The first answers for what the model can do. In order, they are tried top first.": "排第一的模型決定本組對外的能力；按順序模式下從上往下嘗試。",
+    "Rate limited to the back": "限流後排到最後",
+    "Its models too": "也列出成員模型",
+    "The group alone": "只列出本組",
+    "Its models unlisted": "成員模型不單獨列出",
+    "Agents' model lists and the gateway's /v1/models show the group and each of its models.": "Agent 的模型清單和閘道的 /v1/models 會列出本組，也列出組裡的每個模型。",
+    "Agents' model lists and the gateway's /v1/models show the group, not the models it names or its patterns match: they are used through it. Codex keeps its ChatGPT sign-in's own models. A request naming one is still answered.": "Agent 的模型清單和閘道的 /v1/models 只列出本組，不列出它點名的模型和模式比對到的模型：這些模型透過本組使用。Codex 仍列出它所登入的 ChatGPT 帳號自己的模型。直接點名其中一個模型的請求仍會被回應。",
+    "Slow to start": "遲遲不出字",
+    "Every member busy": "成員全都忙",
+    "When every member has failed with an error that may pass — overloaded, unavailable, rate limited for a moment — and nothing of the reply has reached the agent, each is asked again after a pause, longer each time and never shorter than the vendor asks, for up to {n} more. A streaming agent is kept waiting meanwhile.": "每個成員都因暫時性錯誤（過載、暫不可用、短暫限流）失敗，而回覆還一點都沒到智慧體時，過一會兒依序再問一遍每個成員，間隔一次比一次長，也不短於廠商要求的等待，最多再等 {n}。串流請求的智慧體在此期間會一直被保持等待。",
+    "When every member has failed, the agent gets the last one's error at once.": "每個成員都失敗時，智慧體立刻拿到最後一個的錯誤。",
+    "{who} answered {status} · {fail}, and every member had failed with an error that may pass, so after {d} the {n} of them are asked again, in turn, before any of the reply reaches {agent}. The group waits up to {p} for one to answer.": "{who} 回了 {status} · {fail}，而每個成員都因暫時性錯誤失敗，所以 {d} 後依序再問這 {n} 個，回覆還一點都沒到 {agent}。這個分組最多等 {p} 讓其中一個回答。",
+    "Largest model's": "最大模型的",
+    "Smallest model's": "最小模型的",
+    "{v} is not a number of minutes": "{v} 不是有效的分鐘數",
+    "Agents are told the group takes {n} tokens; a longer conversation still goes on to a member with room for it.": "告訴 agent 這個組的上下文是 {n} tokens；更長的對話仍會交給放得下它的成員。",
+    "Agents are told {n} tokens, its smallest model's, so they compact before any member would turn the conversation away.": "告訴 agent {n} tokens（組裡最小模型的），這樣 agent 會在任何成員拒收之前先壓縮對話。",
+    "Agents are told its smallest model's window, so they compact before any member would turn the conversation away.": "告訴 agent 組裡最小模型的上下文，這樣 agent 會在任何成員拒收之前先壓縮對話。",
+    "Agents are told {n} tokens, its largest model's; a conversation too long for one member goes on to one with room for it.": "告訴 agent {n} tokens（組裡最大模型的）；某個成員放不下的對話會交給放得下的成員。",
+    "Agents are told {n} tokens, its largest model's; a conversation longer than {m} skips {who} for a member with room for it.": "告訴 agent {n} tokens（組裡最大模型的）；超過 {m} 的對話會跳過 {who}，交給放得下的成員。",
+    "Agents are told its largest model's window; a conversation too long for one member goes on to one with room for it.": "告訴 agent 組裡最大模型的上下文；某個成員放不下的對話會交給放得下的成員。",
+    "{v} is not a length of tokens like 200k or 1m": "{v} 不是有效的 token 長度，例如 200k 或 1m",
+    "Every member is waited for, however long it takes to begin answering.": "每個成員都會一直等到它開始回答，不論多久。",
+    "A member that hasn't begun answering after {n} — no text, reasoning or tool call yet — is let go and the next one asked, before any of it reaches the agent. Let go once, it doesn't rest; let go twice in a row, its model rests on that account, a minute and longer each time, until it answers again. The last one left is always waited for. Only for streamed requests.": "成員超過 {n} 仍未開始回答（無文字、思考或工具呼叫）時，改問下一個，此時尚無內容發給 agent。偶爾一次不休息；連續兩次，該模型在這個帳號上休息，從一分鐘起每次更久，直到它再次回答。最後一個總會等到底。僅對流式請求生效。",
+    "Next after {n} without a first token": "{n} 無首字換下一個",
+    "{who} hadn't begun answering after {ms}, so the request went on to the next before any of it reached {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 超過 {ms} 未開始回答，請求在發給 {agent} 任何內容前轉給下一個。{who} 本身沒有出錯，不休息。",
+    "{who} hadn't begun answering after {ms}, {n} times in a row, so the request went on to the next before any of it reached {agent}. It rests {d} for {model} alone, longer each time it is slow again; its other models answer as before.": "{who} 連續 {n} 次超過 {ms} 未開始回答，請求在發給 {agent} 任何內容前轉給下一個。它僅就 {model} 休息 {d}，再慢則休息更久；它的其他模型照常回答。",
+    "{who} was rate limited at {time} while it had quota left, so it went to the back: it comes round again once those ahead of it are rate limited in turn.": "{who} 在 {time} 仍有額度時被限流，已排到最後：前面的帳號依次被限流後才再輪到它。",
+    "rate limited at {time} · at the back": "{time} 被限流 · 排在最後",
+    "A group needs a model in it": "組裡至少要有一個模型",
+    "Couldn't save the group: {error}": "分組沒能儲存：{error}",
+    "Add a rule": "新增規則",
+    "in {folders}": "在 {folders} 中",
+    "The agent works in {folder}.": "Agent 的工作目錄是 {folder}。",
+    "The agent works in one of these folders or a folder inside one, as it tells the model (Claude Code, Codex, OpenCode, Pi); an agent that doesn't say isn't matched": "Agent 的工作目錄是這些資料夾之一或其子資料夾（以它告訴模型的為準：Claude Code、Codex、OpenCode、Pi）；不說明工作目錄的 Agent 不符合",
+    "Rule {n}: a folder is a whole path, like ~/work or /Users/me/work": "規則 {n}：資料夾需是完整路徑，如 ~/work 或 /Users/me/work",
+    "The turn begins within these hours, in your time zone — a provider's peak-price hours sent to another, say": "本輪在此時段內（按你的時區）開始時生效，例如把某家高峰計價時段的請求轉給另一家",
+    "{hours} ({zone})": "{hours}（{zone}）",
+    "{zone} time": "{zone} 時間",
+    "server time, {offset}": "伺服器時間 {offset}",
+    "weekends": "週末",
+    "{from}–{to}": "{from}–{to}",
+    "{hours} {days}": "{days} {hours}",
+    "runs past midnight, into the next day": "跨過午夜，到第二天",
+    "Rule {n}: the hours are two times like 09:00 and 18:00": "第 {n} 條規則：時段要填兩個時間，例如 09:00 和 18:00",
+    "Rule {n}: its hours are the whole day — pick days, or other hours": "第 {n} 條規則：時段為全天，請選擇星期或其他時段",
+    "The agent summarizes the conversation to go on in less room (Claude Code's /compact, Codex, OpenCode…): a cheaper, faster model can do it": "Agent 總結對話以騰出上下文（Claude Code 的 /compact、Codex、OpenCode…）：可交給更便宜、更快的模型來做",
+    "longer conversations skip it: it takes {n} tokens": "更長的對話會跳過它：它的上下文只有 {n} tokens",
+    "The agent is compacting the conversation, so rule {n} sends the summary to {use}; the conversation stays on the model it was on.": "Agent 正在壓縮上下文，規則 {n} 將總結交給 {use}；對話仍留在原模型。",
+    "Passed over, as the conversation is longer than they take: {models}.": "對話比它們的上下文長，已跳過：{models}。",
+    "reasoning ≥ {level}": "推理 ≥ {level}",
+    "not a condition": "不作為條件",
+    "thinking or any effort level": "開了 thinking 或任意推理強度",
+    "it doesn't take images": "它不支援圖片",
+    "it takes {n} tokens": "它的上下文只有 {n} tokens",
+    "≥ {n} tokens": "≥ {n} tokens",
+    "1 rule": "1 條規則",
+    "{n} rules": "{n} 條規則",
+    "Rule {n} has no condition. Add one with its +, or remove the rule from its ⋯ menu": "第 {n} 條規則還沒有條件：用它的 + 新增一個，或在它的 ⋯ 選單裡刪除這條規則",
+    "This rule has no condition. Add one with its +, or remove the rule from its ⋯ menu": "這條規則還沒有條件：用它的 + 新增一個，或在它的 ⋯ 選單裡刪除這條規則",
+    "goes first; the others stay behind it": "先發給它；其餘的在它後面備用",
+    "left out of the group: not tried, not a fallback": "移出群組：不會被呼叫，也不做備用",
+    "left out of the group then: not tried, not a fallback": "這段時間移出群組：不會被呼叫，也不做備用",
+    "not in {folders}": "不在 {folders} 中",
+    "not in folder": "不在資料夾",
+    "The agent works in none of these folders, nor a folder inside one, as it tells the model; an agent that doesn't say counts as outside them": "Agent 的工作目錄不是這些資料夾，也不在它們之中（以它告訴模型的為準）；不說明工作目錄的 Agent 算在它們之外",
+    "The agent didn't say which folder it works in.": "Agent 沒有說明它的工作目錄。",
+    "Rule {n}: a pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "第 {n} 條規則：暫停需要設時段、星期、Agent 或資料夾。用它的 + 新增，或在它的 ⋯ 選單裡刪除這條規則",
+    "A pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "暫停需要設時段、星期、Agent 或資料夾：用它的 + 新增，或在它的 ⋯ 選單裡刪除這條規則",
+    "{model} is paused by rule {n} ({when}), so it is left out until that ends.": "{model} 被規則 {n}（{when}）暫停，在此之前不會被呼叫。",
+    "{model} is paused by rule {n} of {group} ({when}), so it is left out until that ends.": "{model} 被 {group} 的規則 {n}（{when}）暫停，在此之前不會被呼叫。",
+    "asks for “{intent}”": "意圖是「{intent}」",
+    "what it asks for, e.g. writing tests": "使用者想做什麼，例如：寫測試",
+    "Intent told by": "意圖判斷模型",
+    "choose a model": "選擇模型",
+    "As a turn begins, this model is asked which of the intents the message is — once; a small, fast one without reasoning is best. If it fails or can't say, no intent matches. Its calls show in the usage as magpie’s own.": "每輪開始時問此模型一次訊息屬於哪個意圖，建議選小而快、不帶推理的模型。出錯或無法判斷時，意圖條件均不命中。其呼叫在用量中記為 magpie 自身的呼叫。",
+    "Choose the model that tells which intent a message is": "請選擇用來判斷訊息意圖的模型",
+    "A routing group classifies as any request to it goes: if its first model fails, the next is asked.": "路由組作判斷模型時與普通請求相同：第一個模型失敗則問下一個。",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so no rule with an intent matches it.": "{by} 未能判斷第 {turn} 輪屬於 {kinds} 中的哪一個（{err}），帶意圖的規則均不命中。",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so the turn keeps “{intent}”, as turn {prev} was.": "{by} 未能判斷第 {turn} 輪屬於 {kinds} 中的哪一個（{err}），因此沿用第 {prev} 輪的「{intent}」。",
+    "{by} was asked which of {kinds} turn {turn} is, and said none ({took}).": "{by} 判斷第 {turn} 輪不屬於 {kinds} 中的任何一個（{took}）。",
+    "{by} was asked which of {kinds} turn {turn} is, and answered “{said}”, which is no rule's intent ({took}).": "{by} 被問到第 {turn} 輪屬於 {kinds} 中的哪一個，回答了「{said}」，但這不是任何規則的意圖（{took}）。",
+    "{by} was asked which of {kinds} turn {turn} is, and said “{intent}” ({took}).": "{by} 判斷第 {turn} 輪屬於 {kinds} 中的「{intent}」（{took}）。",
+    "It was told turn {prev} was “{after}”, which a message that only carries on from it is too.": "並告知它第 {prev} 輪為「{after}」，僅承接上一輪的訊息也歸為此類。",
+    "{by} was to rate how hard turn {turn} is, but couldn't — {err} — so it reasons as the agent asked.": "{by} 未能評估第 {turn} 輪的難度（{err}），按 agent 要求的推理強度。",
+    "{by} wasn't asked how hard turn {turn} is: the group above picked {level} reasoning for it.": "{by} 未被要求評估第 {turn} 輪的難度：上一層群組已為這一輪選了 {level} 推理強度。",
+    "{by} rated turn {turn} {score} of 3, so it picks {level} reasoning for the turn — each model gets the level it has nearest.": "{by} 給第 {turn} 輪難度打 {score} 分（滿分 3），選用 {level} 推理強度，各模型取最接近的檔位。",
+    ", {n} sure": "，把握 {n}",
+    "Decided by": "決策模型",
+    "at {level} reasoning": "以 {level} 推理強度",
+    "The turn's pick replaced the {asked} {agent} asked for.": "由本輪判斷選出，替代 {agent} 要求的 {asked}。",
+    "{level} is the model's nearest to the {asked} {agent} asked for.": "{level} 是模型最接近 {agent} 要求的 {asked} 的檔位。",
+    "{level} reasoning, picked for the turn; {agent} asked for {asked}": "{level} 推理強度，由本輪判斷選出；{agent} 原要求 {asked}",
+    "{level} reasoning, picked for the turn": "{level} 推理強度，這一輪判斷選的",
+    "{level} reasoning, fixed on this model in the group; {agent} asked for {asked}": "{level} 推理強度，分組為此模型固定；{agent} 原要求 {asked}",
+    "{level} reasoning, fixed on this model in the group": "{level} 推理強度，分組為此模型固定",
+    "{level} reasoning, set by the rule; {agent} asked for {asked}": "{level} 推理強度，由規則設定；{agent} 原要求 {asked}",
+    "{level} reasoning, set by the rule": "{level} 推理強度，由規則設定",
+    "The rule asks this model for {level} reasoning, in place of the {asked} {agent} asked for.": "規則要求此模型使用 {level} 推理強度，取代 {agent} 要求的 {asked}。",
+    "As the agent asks": "跟隨 Agent",
+    "the rule sets none": "規則不設定",
+    "The rule asks the model for {level} reasoning whatever the agent asks, at the model's nearest level; a model whose levels aren't known is asked as the agent asked": "無論 Agent 要求什麼，規則都讓該模型使用 {level} 推理強度（取模型最接近的檔位）；不知道檔位的模型按 Agent 的要求",
+    "Set its reasoning": "設定推理強度",
+    "Change its reasoning": "變更推理強度",
+    "The group fixes this model at {fixed} reasoning, in place of the {asked} {agent} asked for.": "分組為此模型固定 {fixed} 推理強度，取代 {agent} 要求的 {asked}。",
+    "{level} reasoning": "{level} 推理強度",
+    "Group's reasoning": "跟隨分組推理",
+    "Follows {name}": "跟隨 {name} 組",
+    "Its models reason as {name} says: set that up on {name}'s own card, not here": "它的模型按「{name}」組的檔位推理，要改請到「{name}」那張卡片上改",
+    "Sent at {level} reasoning whatever the agent asks, at the model's nearest level": "無論 Agent 要求什麼，都以 {level} 推理強度傳送（取模型最接近的檔位）",
+    "Reasons as the group's effort says": "推理強度按分組的設定",
+    "Follow the group": "跟隨分組",
+    "Several levels…": "多個強度…",
+    "Mapped reasoning": "映射推理強度",
+    "Sent {pairs}; other levels as asked": "按 {pairs} 傳送，其他強度按要求",
+    "Map levels…": "映射強度…",
+    "a level in place of the one asked": "以另一檔強度代替所要求的",
+    "As asked": "按要求",
+    "the agent picks among them": "由 Agent 從中選擇",
+    "The agent picks among {levels} reasoning, each sent at the model's nearest level": "由 Agent 在 {levels} 推理強度中選擇，各取模型最接近的檔位",
+    "{name} at that reasoning is in the group already": "{name} 以這個推理強度已經在分組裡了",
+    "Standard speed": "標準速度",
+    "Sent in its vendor's fast mode whatever the agent asks: quicker, at a higher price": "無論 Agent 要求什麼，都以服務商的快速模式傳送：更快，價格更高",
+    "Sent at its vendor's usual speed; click to send it in fast mode": "以服務商的常規速度傳送；點選改為快速模式",
+    "Asked for OpenAI's fast mode (service_tier \"priority\") whatever the agent asks: quicker, at a higher price, where your provider serves it. One that turns it away is asked without it": "無論代理怎麼請求，都向服務商請求 OpenAI 的快速模式（service_tier \"priority\"）：服務商支援時更快，價格更高。服務商拒絕這個欄位時，會拿掉它再請求一次",
+    "Sent as the agent asks; click to ask your provider for OpenAI's fast mode (service_tier \"priority\")": "依代理的請求傳送；點選向你的服務商請求 OpenAI 的快速模式（service_tier \"priority\"）",
+    "Off: kept in its place, sent nothing. Click to switch it on": "已停用：保留位置，不會收到請求。點選啟用",
+    "On: requests may go to it. Click to switch it off and keep its place": "已啟用：請求可能發給它。點選停用（保留位置）",
+    "Sent in its vendor's fast mode, as the group says": "按分組設定，以服務商的快速模式傳送",
+    "{level} reasoning: the model's nearest to the {asked} {agent} asked for": "{level} 推理強度：模型最接近 {agent} 要求的 {asked} 的檔位",
+    "{level} reasoning, as {agent} asked": "{level} 推理強度，按 {agent} 的要求",
+    "Jev is asked once as each turn begins, with the message and what it said of the turn before. Its calls show in the usage as magpie’s own.": "每輪開始時問 Jev 一次，附上訊息和它對上一輪的判斷。其呼叫在用量中記為 magpie 自身的。",
+    "Picked per turn": "每輪判斷",
+    "Choose the model that rates how hard a turn is": "請選擇判斷每輪難度的模型",
+    "Turn {turn} reasons at {level}, as the classifier picked when it began.": "第 {turn} 輪按 {level} 推理，由判斷模型在本輪開始時選定。",
+    "As a turn begins, the classifier rates how hard it is and the turn's requests ask their model for low, medium, high or xhigh reasoning — the level each model has nearest. Only where the agent asked for reasoning: a request without any (a session title) stays without.": "每輪開始時由判斷模型評估難度，本輪請求按 low、medium、high 或 xhigh 推理（取各模型最接近的檔位）。僅作用於 agent 要求推理的請求，不帶推理的請求（如會話標題）保持不變。",
+    "As a turn begins, this model is asked how hard the turn is — once; a small, fast one without reasoning is best. If it fails or can't say, the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "每輪開始時問此模型一次本輪難度，建議選小而快、不帶推理的模型。失敗或無法判斷時按 agent 要求的強度推理。其呼叫在用量中記為 magpie 自身的。",
+    "As a turn begins, this model is asked which of the intents the message is and how hard the turn is, each once; a small, fast one without reasoning is best. If it can't say, no intent matches and the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "每輪開始時分別問此模型一次訊息意圖和本輪難度，建議選小而快、不帶推理的模型。無法判斷時不匹配任何意圖，並按 agent 要求的強度推理。其呼叫在用量中記為 magpie 自身的。",
+    "Each request reasons as much as the agent asked.": "每個請求按 agent 自己要求的強度推理。",
+    "Its models' shared": "成員共有",
+    "Agents are offered the levels every model has: {levels}.": "對 Agent 提供所有模型都有的檔位：{levels}。",
+    "Agents are offered the levels every model has.": "對 Agent 提供所有模型都有的檔位。",
+    "Agents are offered these. A model without the level asked is sent the one it has nearest.": "向 Agent 提供這些檔位。模型沒有所選檔位時按最接近的傳送。",
+    "Pick a level to offer, or leave them to its models": "請至少選一個檔位，或改回成員共有",
+    "As a turn begins, Jev is asked once which of the intents the message is, and how hard the turn is when it picks the effort. An intent it isn't sure of matches no rule. Its calls show in the usage as magpie’s own.": "每輪開始時問 Jev 一次訊息意圖；若由它選推理強度，同時問本輪難度。沒把握的意圖不命中任何規則。其呼叫在用量中記為 magpie 自身的。",
+    "It was told turn {prev} reasoned at {level}, which a message that only carries on from it needs too.": "並告知它第 {prev} 輪按 {level} 推理，僅承接上一輪的訊息也需同等強度。",
+    "Add an example rule": "新增範例規則",
+    "planning, design, or a hard problem to think through": "規劃、設計，或需要深入思考的難題",
+    "With two models or more, a rule can send some turns to one of them first.": "組內有兩個及以上模型時，可用規則將某些輪次先發給其中一個。",
+    "Checked top first when you send a message: the first that matches sends that turn to its model first; the rest stay behind it if it fails. A turn under way is never moved.": "傳送訊息時從上往下檢查：第一條命中的規則將本輪先發給其指定的模型，其餘成員作為故障轉移。進行中的一輪不會換模型。",
+    "Rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "第 {turn} 輪開始時命中規則 {n}（{when}），先發給 {use}；本輪留在當時接手的模型上。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; if it fails, {then}, which the rules after it that match too name, then the group's others.": "第 {turn} 輪開始，命中規則 {n}（{when}），{use} 排第一；失敗時先換後續命中規則指定的 {then}，再換組內其他模型。",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "規則 {n} 命中，但 {use} 沒有能接這次請求的帳號或 Key；後續命中的規則指定 {instead} 優先。",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "在 {group} 中，規則 {n} 命中，但 {use} 沒有能接這次請求的帳號或 Key；後續命中的規則指定 {instead} 優先。",
+    "Remove {name} from this rule": "從這條規則移除 {name}",
+    "Add a model it goes to next": "新增下一個模型",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first.": "規則 {n} 命中，但 {use} 沒有能接這次請求的帳號或 Key，於是由這條規則的下一個模型 {instead} 排第一。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first, then {more}, which the rule names after it; the later rules' and the group's others stay behind them.": "第 {turn} 輪開始，命中規則 {n}（{when}），{use} 排第一，其次是這條規則的 {more}；之後才是後續規則和組內的其他成員。",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first there.": "在 {group} 中，規則 {n} 命中，但 {use} 沒有能接這次請求的帳號或 Key，於是由這條規則的下一個模型 {instead} 在那裡排第一。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; the group's others stay behind it if it fails.": "第 {turn} 輪開始，命中規則 {n}（{when}），{use} 排第一；失敗時由組內其他成員接手。",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so the group's order stands.": "規則 {n} 命中，但 {use} 沒有能接這次請求的帳號或 Key，按組原本的順序路由。",
+    "This turn began before magpie saw it, so the rules wait for the next one.": "本輪在 magpie 接收前已開始，規則從下一輪起判斷。",
+    "No rule matches turn {turn} (about {n} tokens{img}).": "第 {turn} 輪沒有命中規則（約 {n} tokens{img}）。",
+    "the group {name}": "路由組 {name}",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {group}'s order stands.": "在 {group} 中，規則 {n} 命中，但 {use} 沒有能接這次請求的帳號或 Key，組內順序不變。",
+    "In {group}, rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "在 {group} 中，第 {turn} 輪開始時規則 {n}（{when}）先交給 {use}，本輪留在當時接手的模型上。",
+    "In {group}, rule {n} matches — {when} — so {use} goes first there.": "在 {group} 中，規則 {n} 命中（{when}），{use} 在組內排第一。",
+    "In {group}, no rule matches.": "在 {group} 中沒有命中規則。",
+    "In {group}: {text}": "在 {group} 裡：{text}",
+    "{who} is one of {path}, a group in {name}; that group routes {mode}.": "{who} 屬於 {path}，即 {name} 中的子路由組，按「{mode}」路由。",
+    ", with an image": "，帶圖片",
+    "Within turn {turn} the conversation grew to about {tokens} tokens, more than the model it was on takes, so rule {n} ({when}) moves it to {use}.": "第 {turn} 輪中會話增至約 {tokens} tokens，超出目前模型的上限，按規則 {n}（{when}）換到 {use}。",
+    "{who} answered this conversation last, but a new turn begins and the group's rule {n} puts {use} first.": "{who} 上次回答了此會話，但新一輪命中分組規則 {n}，{use} 排第一。",
+    "Several accounts or keys": "多帳號 / 多 Key",
+    "each provider routes over its own": "各供應商在自己的帳號或 Key 間路由",
+    "Change how {name} routes": "改 {name} 的路由方式",
+    "Only one account or key is on for this, so routing has nothing to choose between. Turn on a second in the provider's editor, and how it routes is set under Several accounts or keys below.": "這裡只開了一個帳號或 Key，路由沒有可選的。在供應商的編輯頁再開一個，路由方式就在下面的「多帳號 / 多 Key」裡設定。",
+    "Smart, over the members' accounts and keys together: of the subscriptions with quota to spare, the one whose allowance renews soonest goes first — the week decides, and an account with five hours and no week (Claude Enterprise) goes by its five hours, so ahead of every week renewing later; one resting after a failure goes last.": "智慧：成員的帳號和 Key 統一排序。有餘量的訂閱中額度最先重置的排第一，以週額度為準；只有 5 小時額度的帳號（如 Claude Enterprise）按 5 小時重置，排在更晚重置的週額度之前；失敗後休息中的排最後。",
+    "In order: the first model until it can't answer, then the next — each over its own accounts or keys as its provider routes them.": "按順序：先用第一個模型，無法回應再換下一個；各成員按其供應商的路由在自己的帳號或 Key 間分配。",
+    "In turn: each conversation's next turn goes to the next member's account or key, spreading the load.": "輪流：會話的每一輪交給下一個成員的帳號或 Key，均攤負載。",
+    "Least used first: the account or key with the most of its allowance left goes first.": "最少使用優先：剩餘額度最多的帳號或 Key 排第一。",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — its week at its reset, or credits in it that expire sooner — so less of each member's allowance is lost; an account with five hours and no week (Claude Enterprise) by what its five hours have left per hour until they renew, so almost always first; a key by the tokens magpie sent it lately.": "到期前用完：按剩餘額度 ÷ 距作廢小時數排序，越高越先用——週額度在重置時作廢，更早過期的點數按過期時間算。只有 5 小時額度的帳號（如 Claude Enterprise）按 5 小時時段計算，幾乎總排第一；Key 按最近發給它的 token 數排。",
+    "A group among the models, and a model whose provider routes its accounts or keys other than Smart, keeps its own routing: this group only picks between it and the others, weighing it by the account or key it would try first, then tries it whole in its own order. A group among the models left on Smart is routed as this group is, unless this one goes In order, By weight or Manual.": "成員中的路由組，以及服務商路由不是「智慧」的模型，都保留自己的路由：本組只在它與其他成員間選擇（按它會先用的帳號或 Key 比較），選中後按其自身順序整體嘗試。成員中路由留在「智慧」的路由組，按本組的路由走，除非本組是「按順序」「按權重」或「手動」。",
+    "errors your agent saw": "Agent 收到的錯誤",
+    "It said: {error}": "原話：{error}",
+    "Copilot's Auto picked {model} ({via})": "Copilot 的 Auto 選了 {model}（{via}）",
+    "the model the account may pick by hand": "帳號可手動選的模型",
+    "not from /auto: {why}": "未取自 /auto：{why}",
+    "sent to {api}": "發往 {api}",
+    "sent to {api} with Auto's session token": "發往 {api}，帶 Auto 的會話令牌",
+    "Copilot refused it: {error}": "Copilot 拒絕了它：{error}",
+    "Show the latest request that failed": "檢視最近一個失敗的請求",
+    "another account's reasoning": "另一個帳號的推理",
+    "reply too short": "回覆長度過短",
+    "reply asked past the window left": "回覆上限超出剩餘上下文",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：服務商不接受 {agent} 的系統提示詞，換哪個帳號都一樣，已在回覆到達 {agent} 前轉給下一個。{who} 本身無問題，不休息。",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, and nobody else is left to try, so {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：服務商不接受 {agent} 的系統提示詞，換哪個帳號都一樣，且沒有其他可嘗試的，{agent} 收到該錯誤。{who} 本身無問題，不休息。",
+    "request not understood": "請求格式不被接受",
+    "images not taken": "不接受圖片",
+    "{who} answered {status}: it takes no images, so it is asked again with the images described by the image recognition model, before any of the reply reaches {agent}. Later requests to it are described first. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：它不接受圖片，已改用看圖模型描述圖片後重新詢問，回覆尚未到達 {agent}。之後發給它的請求會先描述圖片。{who} 本身無問題，不休息。",
+    "reasoning effort not in its plan": "套餐不支援該推理強度",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, so another account goes on with it before any of the reply reaches {agent}. {who} serves other efforts, so it doesn't rest.": "{who} 返回 {status}：其套餐不支援所請求的推理強度，已在回覆到達 {agent} 前轉給另一個帳號。{who} 仍支援其他強度，不休息。",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, and no account left that does could answer, so {agent} gets an error saying so.": "{who} 返回 {status}：其套餐不支援所請求的推理強度，也沒有其他支援且能應答的帳號，{agent} 收到說明原因的錯誤。",
+    "{who}: this computer had no network, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the network is back it is asked first again.": "{who}：這台電腦沒有網路，請求未到達廠商，已轉給下一個。{who} 本身無問題，不休息：網路恢復後仍最先問它。",
+    "{who}: this computer had no network, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who}：這台電腦沒有網路，請求未到達廠商，且沒有其他可嘗試的，{agent} 收到該錯誤。{who} 本身無問題，不休息。",
+    "network down": "沒有網路",
+    "servers overloaded": "伺服器過載",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the proxy is up it is asked first again.": "{who}：magpie 使用的代理未接受連線，請求未到達廠商，已轉給下一個。{who} 本身無問題，不休息：代理恢復後仍最先問它。",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Start the proxy, or change it in Settings.": "{who}：magpie 使用的代理未接受連線，請求未到達廠商，且無其他可試，{agent} 收到此錯誤。請啟動代理，或在設定中更換。",
+    "{who} answered {status}: its API couldn't read something in the request that another's may, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 返回 {status}：其 API 無法解析請求中的部分內容，其他家可能可以，已在回覆到達 {agent} 前轉給下一個。{who} 本身無問題，不休息。",
+    "{who}'s safety filter refused the request before saying anything, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} 的安全過濾在輸出任何內容前拒絕了此請求，已在回覆到達 {agent} 前轉給下一個。{who} 本身無問題，不休息。",
+    "{who}'s safety filter refused the request before saying anything, and nobody is left to try, so {agent} gets an error saying so, not an empty reply to ask again for.": "{who} 的安全過濾在輸出任何內容前拒絕了此請求，且無其他可試，{agent} 收到說明拒絕的錯誤，而非會導致反覆重試的空回覆。",
+    "The vendor wants the account verified first: it rests half an hour, or until you say it's verified": "服務商要求先驗證這個帳號：它休息半小時，或等你確認已驗證",
+    "{who} answered {status}: the vendor wants the account verified before it serves it again, and nobody is left to try, so {agent} gets the error with how to verify it. For a minute {agent}'s retries get the same answer without asking the vendor.": "{who} 返回 {status}：服務商要求先驗證帳號，且無其他可試，{agent} 收到此錯誤及驗證方法。一分鐘內 {agent} 的重試直接得到相同回覆，不再請求服務商。",
+    "Verify the account ↗": "去驗證帳號 ↗",
+    "It's verified — try it again": "已驗證，重新使用",
+    "account restricted by the vendor": "帳號被服務商限制",
+    "The vendor restricted the account: it rests {d}, as only the vendor lifting the restriction brings it back. Appeal with the vendor; once it's lifted, try it again here": "服務商限制了這個帳號：它休息 {d}，因為只有服務商解除限制才能讓它恢復。請向服務商申訴；解除後，在這裡重新使用",
+    "The restriction is lifted — try it again": "限制已解除，重新使用",
+    "{who} turned away the reasoning effort changed mid-conversation as an update that keeps its cache, so it is asked again at the new effort the usual way, before any of the reply reaches {agent}.": "{who} 不接受對話中途以保留快取的「更新」方式切換推理強度，已在回覆到達 {agent} 前按常規方式以新強度重問。",
+    "{who} takes no request for a reply as short as this one asked for, so it is asked again for the shortest it gives, before any of the reply reaches {agent}.": "{who} 不接受這麼短的回覆長度（max_tokens），已在回覆到達 {agent} 前按其允許的最小值重問。",
+    "{who} couldn't read the reasoning another account wrote earlier in this conversation, so it is asked again without it, before any of the reply reaches {agent}.": "{who} 無法讀取此會話中另一個帳號先前寫下的推理，已在回覆到達 {agent} 前去掉這部分重問。",
+    "{agent} canceled the request while {who} was answering: nobody failed, so nobody rests and nobody else is asked.": "{who} 回答時 {agent} 取消了請求：無人出錯，不休息，也不再問其他帳號。",
+    "{who} answered {status} · {fail}, a failure that may pass. The conversation is kept on {who} for what its vendor cached of it, so it is asked once more in {d} before the request moves to another.": "{who} 返回 {status} · {fail}，這可能是暫時性錯誤。會話因其供應商快取的內容而保持在 {who}，所以 {d} 後再問它一次，仍失敗才轉給其他。",
+    "{who} answered {status} · {fail}, and nobody else is left to ask — a failure that may pass, so it is tried again in {d}, before any of the reply reaches {agent}.": "{who} 返回 {status} · {fail}，且無其他可問；這可能是暫時性錯誤，{d} 後重試一次，此時尚未向 {agent} 傳送任何回覆。",
+    "{who} answered {status} · {fail}, and was to be asked again in {d}, but {agent} canceled the request before then, so nobody is asked again.": "{who} 回傳 {status} · {fail}，原定 {d} 後重試，但 {agent} 在此之前取消了請求，因此不再重試。",
+    "Back to live": "回到即時",
+    "Replay them all": "全部重放",
+    "Stop replay": "停止重放",
+    "{n}× speed": "{n}× 速度",
+    "skipping a quiet stretch · clock {n}×": "跳過空閒時段 · 時鐘 {n}×",
+    "request {i} of {n}": "第 {i}/{n} 個請求",
+    "sent {time}": "發出於 {time}",
+    "Replay from here": "從這裡重放",
+    "{n} on {day}": "{day}的 {n} 個請求",
+    "the last {n} of {day}": "{day}最後的 {n} 個請求",
+    "How the last request was routed": "最近一個請求是怎麼路由的",
+    "How the request at {time} was routed": "{time} 的請求是怎麼路由的",
+    "No request yet": "還沒有請求",
+    "Send one from any agent routed through magpie and it plays here as it happens: who routing put first and why, each try, and what each answered.": "經 magpie 的 Agent 發出請求後，這裡即時播放：路由把誰排第一及原因、每次嘗試和各自的回應。",
+    "Every request an agent sends to magpie shows up here, routed for real.": "Agent 發給 magpie 的每個請求都會在此顯示，均為真實路由。",
+    "Another magpie serves the gateway; its routing plays live in that magpie's window.": "閘道由另一個 magpie 提供，它的路由在那個 magpie 的窗口裡即時播放。",
+    "The gateway isn't running, so nothing is routed.": "閘道沒有執行，因此沒有任何路由。",
+    "The gateway is served by a magpie without a window (magpie serve), so its routing can't be watched. Stop it and let this magpie serve the gateway to see routing live.": "閘道由無視窗的 magpie（magpie serve）提供，無法在此檢視路由。停止它並由目前 magpie 提供閘道，即可即時檢視。",
+    "Smart: of the accounts with quota to spare, the one whose allowance renews soonest goes first — what it has left would be lost at the reset. The week decides; an account with five hours and no week goes by its five hours. One at 90% or more waits until the others can't answer; one resting after a failure goes last.": "智慧：有餘量的帳號中額度最先重置的排第一，以免剩餘額度在重置時作廢。以週額度為準；只有 5 小時額度的帳號按 5 小時重置。用到 90% 以上的，等其他都無法回應時才用；失敗後休息中的排最後。",
+    "Smart: keys that suit the request go first — one made for the model's own API — then in their order. One resting after a failure goes last.": "智慧：適合此請求的 Key（為該模型原生 API 準備的）排前，其餘按順序。失敗後休息中的排最後。",
+    "In order: the first answers everything until it can't; then the next.": "按順序：第一個處理所有請求，無法回應時再換下一個。",
+    "In turn: each conversation's next turn goes to the account after the one that answered its last, and a new conversation starts one further along; the requests within a turn stay put, keeping the prompt cache.": "輪流：會話的下一輪交給上一輪迴答者的下一個帳號，新會話再往後一個；一輪之內不換帳號，保持提示詞快取。",
+    "Least used first: the account with the most of its allowance left goes first; a key by the tokens magpie sent it lately.": "最少使用優先：剩餘額度最多的帳號排第一；Key 按 magpie 最近發給它的 token 數排。",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — at its reset, or, when credits in it expire sooner, by those that expire first; an account with five hours and no week by what its five hours have left per hour. One at 90% or more waits until the others can't answer; a key by the tokens magpie sent it lately.": "到期前用完：按剩餘額度 ÷ 距作廢小時數排序，越高越先用——額度在重置時作廢，有點數更早過期的按最先過期的那部分算；只有 5 小時額度的帳號按 5 小時時段計算。用到 90% 以上的，等其他都無法回應時才用；Key 按最近發給它的 token 數排。",
+    "Nothing could take {model}.": "沒有誰能處理 {model}。",
+    "{who} is the only one, so it's tried though it is resting.": "只有 {who} 一個，雖在休息仍會嘗試。",
+    "{who} is the only account on for {model} — nothing to choose between.": "{who} 是 {model} 唯一啟用的帳號，無需選擇。",
+    "{name} has one key on — nothing to choose between.": "{name} 只啟用了一個 Key，無需選擇。",
+    "Every one is resting after a failure, so {who}, first in line, is tried all the same.": "所有帳號都在失敗後休息，仍先試排第一的 {who}。",
+    "{name} is resting, so its fallback {fb} goes first.": "{name} 正在休息，其備用 {fb} 排第一。",
+    "In order: {who} is first, and answers everything while it can.": "按順序：{who} 排第一，能回應就由它處理。",
+    "Until used up: one answers everything until its quota is used up; then the next, which keeps them even after the one before renews.": "用完再換：一個處理所有請求，直到額度用完；再換下一個，前一個恢復後也繼續用這個。",
+    "Until used up: one account or key, across the members, takes every request until it is used up; then the next in the list, which keeps them even after an earlier one renews. One rate limited or failing is passed over only while it rests.": "用完再換：所有成員的帳號或金鑰中，一個處理所有請求，直到它用完；再換列表裡的下一個，前面的恢復後也繼續用這個。被限流或出錯的只在休息期間跳過。",
+    "Until used up: {who} is the one in use, and answers everything until it is used up.": "用完再換：目前用的是 {who}，用完之前由它處理所有請求。",
+    "In turn: it's {who}'s turn — each request starts one further along.": "輪流：本次輪到 {who}，每個請求從下一個開始。",
+    "Least used first: {who} has the most of its allowance left — {n} used.": "最少使用優先：{who} 剩餘額度最多，已用 {n}。",
+    "Least used first: {who} served the fewest tokens lately — {n}.": "最少使用優先：{who} 最近處理的 token 最少（{n}）。",
+    "Least used first: {who} goes first.": "最少使用優先：{who} 排第一。",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} left, resets in {d}.": "到期前用完：{who} 的剩餘額度 ÷ 距重置小時數最高，剩餘 {n}，{d} 後重置。",
+    "Use before expiry: {who} has the most remaining allowance per hour until one of its Codex resets about to run out is used by itself — {n} left, used in {d}.": "到期前用完：{who} 的剩餘額度 ÷ 距自動使用快到期 Codex 重置卡的小時數最高，剩餘 {n}，{d} 後自動使用。",
+    "Use before expiry: {who} has the most credits expiring per hour until they expire — {n} of its allowance expires in {d}.": "到期前用完：{who} 快過期的點數 ÷ 距過期小時數最高，額度的 {n} 將在 {d} 後過期。",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} used.": "到期前用完：{who} 的剩餘額度 ÷ 距重置小時數最高，已用 {n}。",
+    "Use before expiry: {who} served the fewest tokens lately — {n}.": "到期前用完：{who} 最近處理的 token 最少（{n}）。",
+    "Use before expiry: {who} goes first.": "到期前用完：{who} 排第一。",
+    "{who} goes first: it's made for {api}, the API {model} is at home in, so nothing is translated.": "{who} 排第一：它專為 {api} 而設，正是 {model} 的原生 API，無需轉換。",
+    "{who} goes first: keys go in their order, those that suit the request first.": "{who} 排第一：Key 按順序排，適合此請求的在前。",
+    "{who} goes first.": "{who} 排第一。",
+    "its provider is set to be used first.": "它的供應商設為優先使用。",
+    "{who} goes first: its provider is set to be used first.": "{who} 排第一：它的供應商設為優先使用。",
+    "The vendor hasn't said yet what these accounts have left, so they go in their order: {who} first.": "廠商尚未告知這些帳號的剩餘額度，按順序排：{who} 第一。",
+    "Every account is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "所有帳號均已用到 90% 以上，剩餘最多的排第一：{who}，已用 {n}。",
+    "Every key and account here is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "這裡的金鑰和帳號均已用到 90% 以上，剩餘最多的排第一：{who}，已用 {n}。",
+    "{who} goes first: it has quota to spare, and the others are kept for last.": "{who} 排第一：它還有餘量，其他帳號留到最後。",
+    "{who} goes first: of those with quota to spare, its allowance starts again soonest — one of its Codex resets about to run out is used by itself in {d}, and what it has left then is lost. {other} renews later and keeps its own.": "{who} 排第一：有餘量的帳號中它的額度最先重新開始，{d}後將自動使用其快到期的 Codex 重置卡，屆時剩餘額度作廢。{other} 重置較晚，額度暫留。",
+    "{who} goes first: of those with quota to spare, its allowance renews soonest — in {d} — and what it has left then is lost. {other} renews later and keeps its own.": "{who} 排第一：有餘量的帳號中它的額度最先重置（{d}後），屆時剩餘額度作廢。{other} 重置較晚，額度暫留。",
+    "{who} goes first: its allowance renews in the same hour as {other}'s, and its shorter one sooner — in {d}.": "{who} 排第一：它與 {other} 的額度在同一小時重置，而它較短的時段更早（{d}後）。",
+    "{who} and {other} renew within the same hour, so the order given stays — and the vendor's prompt cache stays warm.": "{who} 和 {other} 在同一小時內重置，保持原順序，廠商的提示詞快取也保持命中。",
+    "{who} goes first, in the order given: when its allowance renews isn't known.": "{who} 按原有順序排第一：不知道它的額度何時重置。",
+    "{who} goes first: of those alike, its wallet has the most left — {n}, where {other} has {m}.": "{who} 排第一：同類帳號裡，它的錢包剩得最多——{n}，{other} 剩 {m}。",
+    "{who} is resting — {why}, {when} — so it waits at the back.": "{who} 正在休息（{why}，{when}），排在最後。",
+    "{who} is at {n} — all but used up, it answers only when nothing else can.": "{who} 已用 {n}，幾乎用盡，僅在其他都無法回應時使用。",
+    "{who} is at {n} — kept for when the others can't.": "{who} 已用 {n}，其他帳號都無法回應時才用。",
+    "{member} isn't passed over for being near its limit: by weight this request was {first}'s share, and {member} takes its own share of the requests while it can answer.": "{member} 不會因為快用完而被跳過：按權重，這次請求輪到 {first}，{member} 只要還能回應，就照樣按權重分到它那份請求。",
+    "{member} isn't passed over for being near its limit: it comes after {first} in {group}'s order.": "{member} 不會因為快用完而被跳過：它按 {group} 的順序排在 {first} 之後。",
+    "{who}: what it has left isn't known yet, so it goes after those known.": "{who}：剩餘額度未知，排在已知的之後。",
+    "{who}: what it has left isn't known yet, and its answer tells, so it goes before those known.": "{who}：剩餘額度未知，回答一次即可得知，因此排在已知的之前。",
+    "{who} goes first: what it has left isn't known yet, and its answer tells — kept behind those known, it would never answer and never be known.": "{who} 排第一：剩餘額度未知，回答一次即可得知；若排在已知的之後，就永遠輪不到，也永遠無法得知。",
+    "{who} is left out: its plan doesn't list {model}.": "{who} 不參與：它的套餐不包含 {model}。",
+    "{who} is left out: {name} lists {model} to its other keys, not this one.": "{who} 不參與：{name} 只為其他 key 列出了 {model}，未為此 key 列出。",
+    "{who} is answering…": "{who} 正在回答…",
+    "rerouted from {from}": "改道自 {from}",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the model of its latest chat turn, so it stays with the provider the chat is on.": "{agent} 自行選了 {model} 來發一個不帶工具的短請求（例如對話標題）；magpie 讓 {to} 來處理，即它最近一輪對話所用的模型，這樣它留在對話所在的服務商。",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the first model it lists, as it has had no chat turn yet.": "{agent} 自行選了 {model} 來發一個不帶工具的短請求（例如對話標題）；magpie 讓 {to} 來處理，即它列出的第一個模型，因為它還沒有過對話輪次。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model of its latest chat turn.": "{agent} 請求了 {model}，但 magpie 不提供它；magpie 讓 {to} 來處理，即它最近一輪對話所用的模型。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the first model it lists.": "{agent} 請求了 {model}，但 magpie 不提供它；magpie 讓 {to} 來處理，即它列出的第一個模型。",
+    "Claude Code in {agent} asked for {model}, its own id for a Claude tier; magpie served it on {to}, the model picked for that tier.": "{agent} 裡的 Claude Code 用它自己的 Claude 檔位 id 請求了 {model}；magpie 讓 {to} 來處理，即為該檔位選的模型。",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, that tier's model on the provider the chat is on.": "{agent} 裡的 Claude Code 為它自己的呼叫請求了 {model}；magpie 讓 {to} 來處理，即對話所在服務商上該檔位的模型。",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, the chat's model, so it stays with the provider the chat is on.": "{agent} 裡的 Claude Code 為它自己的呼叫請求了 {model}；magpie 讓 {to} 來處理，即對話所用的模型，這樣它留在對話所在的服務商。",
+    "{agent}'s auto mode classifier asked for {model}; magpie served it on {to}, the model /model moved its tier to.": "{agent} 的自動模式分類器請求了 {model}；magpie 讓 {to} 來處理，即 /model 把該檔位改成的模型。",
+    "{agent} asked for {model} by Claude's full id; magpie served it on {to}, the model set for that tier.": "{agent} 用 Claude 的完整 id 請求了 {model}；magpie 讓 {to} 來處理，即為該檔位設定的模型。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model its config names.": "{agent} 請求了 {model}，但 magpie 不提供它；magpie 讓 {to} 來處理，即它設定裡寫的模型。",
+    "{agent} asked for {model} for a call of its own, which magpie doesn't serve; magpie served it on {to}, the model its last turn was answered on.": "{agent} 為它自己的呼叫請求了 {model}，但 magpie 不提供它；magpie 讓 {to} 來處理，即它上一輪所用的模型。",
+    "{agent} asked for {model}, one of its own default models, for its memories, and its config names no model for them; magpie served it on {to}, the model of its conversation.": "{agent} 為它的記憶請求了它自己的預設模型 {model}，而它的設定沒有為記憶指定模型；magpie 讓 {to} 來處理，即它這段對話所用的模型。",
+    "Masking would have changed this request, so magpie sent it as written to {to}, the model set for that in Settings › Privacy.": "去識別化會改動這個請求，所以 magpie 把它原樣送給了 {to}，即在 設定 › 隱私 裡為此設定的模型。",
+    "magpie served it on {to} in place of {model}.": "magpie 讓 {to} 代替 {model} 處理了它。",
+    "Stand-in": "替代",
+    "{who} answered in {ms}{tk}. {agent} got one clean reply and never saw the {n} that failed first.": "{who} 用 {ms} 完成回答{tk}。{agent} 只收到一次正常回覆，看不到之前失敗的 {n} 次。",
+    "{who} answered in {ms}{tk}.": "{who} 用 {ms} 完成回答{tk}。",
+    "{who} answered {status} · {fail}. {how}; the request goes on to {next} before any of the reply reaches {agent}.": "{who} 返回 {status} · {fail}。{how}；請求在回覆到達 {agent} 前轉給 {next}。",
+    "{who} answered {status} and nobody is left to try, so {agent} gets the error.": "{who} 返回 {status}，且無其他可試，{agent} 收到此錯誤。",
+    "{who} answered {status} — an error another account wouldn't fix, so {agent} gets it.": "{who} 返回 {status}，換帳號也無法解決，{agent} 收到此錯誤。",
+    "{who} hadn't begun answering after {ms}, and nobody is left to try, so {agent} gets the error.": "{who} 超過 {ms} 未開始回答，且無其他可試，{agent} 收到此錯誤。",
+    "{who} answered {status} and nobody is left to try. {agent} gets the error an earlier try gave, not this used-up allowance, so it doesn't stop as if every account were out.": "{who} 返回 {status}，且無其他可試。{agent} 收到的是先前某次嘗試的錯誤，而不是此處額度用完的錯誤，因此不會當作所有帳號都已用完而停下。",
+    "{who} answered {status}.": "{who} 返回 {status}。",
+    "{who} answered {status}, and the request goes on to {next} before any of the reply reaches {agent}. {who} doesn't rest for it.": "{who} 返回 {status}，請求在回覆到達 {agent} 前轉給 {next}。{who} 不因此休息。",
+    "{who} answered {status} · {fail}. {how}; nobody is left to try, so {agent} gets the error.": "{who} 返回 {status} · {fail}。{how}；且無其他可試，{agent} 收到此錯誤。",
+    "{who} began answering, then broke off · {fail}. {agent} got what was said before the error; {how}, so {agent}'s next request goes to another first.": "{who} 開始回答後中斷 · {fail}。{agent} 收到出錯前已輸出的內容；{how}，{agent} 的下一次請求會先交給其他成員。",
+    "{who} began answering, then broke off. {agent} got what was said before the error; the conversation isn't kept on {who} for its next request.": "{who} 開始回答後中斷。{agent} 收到出錯前已輸出的內容；此會話的下一次請求不再固定交給 {who}。",
+    "It rests {d}, as the vendor's Retry-After says": "按廠商 Retry-After 的要求，它休息 {d}",
+    "It sits out half an hour, until someone tops it up": "它先休息半小時，等人充值",
+    "Its allowance is used up: it rests until that renews, at {time}": "它的額度用盡了：休息到額度在 {time} 重置",
+    "It rests until {time}, when the vendor says the limit resets": "它休息到 {time}，廠商說那時額度重置",
+    "It rests 15 minutes: out of quota, with no word of when it resets": "它休息 15 分鐘：額度用盡，但沒說何時重置",
+    "It has failed {n} times in a row: it rests {d}, longer each time": "它已連續失敗 {n} 次：休息 {d}，每次更久",
+    "It rests {d}, longer if it fails again": "它休息 {d}，再失敗就更久",
+    "It doesn't rest: its provider is set to ask it again after an error like this": "它不休息：它的提供方設為遇到這類錯誤後照常再問它",
+    "It rests {d}": "它休息 {d}",
+    "It cools down {d}: the vendor didn't say for how long": "它冷卻 {d}：廠商沒說要多久",
+    "It was rate limited again as soon as it was back ({n} times in a row): it rests {d}, longer each time until it answers": "恢復後立即再次被限流（連續 {n} 次）：休息 {d}，逐次延長，直到正常應答",
+    "With {rested} resting after a failure, {who} goes first: ": "{rested} 失敗後正在休息，{who} 排第一：",
+    "the others go in their order.": "其餘按順序排。",
+    "In order: with {rested} resting after a failure, {who} is the first that can answer.": "按順序：{rested} 失敗後休息中，{who} 是第一個可回應的。",
+    "{agent} asked for {model}": "{agent} 請求 {model}",
+    "Background memory task": "後臺記憶整理",
+    "Codex is organizing memories from earlier chats in the background. This can continue after a chat finishes.": "Codex 正在後臺整理歷史聊天中的記憶，回答結束後也可能繼續執行。",
+    "Title requests were automatically matched using the prompt and the applied chat title.": "標題請求根據提問內容和實際應用的聊天標題自動關聯。",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it; other providers (such as Claude) are excluded regardless of quota.": "子代理任務已加密，只能使用 ChatGPT 帳號；其他供應商（如 Claude）不參與選擇，無論剩餘多少額度。",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it.": "子代理任務已加密，只能使用 ChatGPT 帳號。",
+    "{who} goes first: it answered the parent agent and may be needed to read this encrypted task.": "{who} 回答了主代理，因此優先用它讀取這條加密任務。",
+    "{who} compacted this conversation natively, and only it can read that compaction, so the conversation stays on it: other accounts aren't asked. Start a new conversation to use them.": "{who} 原生壓縮了這條對話，只有它能讀取這份壓縮，所以對話留在它上面，不會問其他帳號。開一個新對話即可使用其他帳號。",
+    "{agent} requested a subagent; magpie selects its model within this routing group.": "{agent} 請求了子代理，由 magpie 在此路由組內選擇模型。",
+    "{agent} requested a subagent on {model}.": "{agent} 請求了使用 {model} 的子代理。",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents are set to {to}, but {why}.": "{agent} 請求了使用 {model} 的子代理，並保留在該模型上：它的子代理設為 {to}，但{why}。",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model set for its subagents.": "{agent} 請求了使用 {model} 的子代理；magpie 將其改用 {to}，即為它的子代理設定的模型。",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model its lead is on.": "{agent} 請求了使用 {model} 的子代理；magpie 將其改用 {to}，即主代理正在用的模型。",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents follow their lead, on {to}, but {why}.": "{agent} 請求了使用 {model} 的子代理，並保留在該模型上：它的子代理跟隨主代理，用 {to}，但{why}。",
+    "Background prompt suggestions": "後臺提示詞建議",
+    "magpie ran this web search for {agent}'s {model}, which can't search the web by itself: {searcher} searched, and {model} goes on answering once it has what was found. Not a turn of the conversation.": "magpie 代 {agent} 的 {model} 發起的聯網搜尋：{model} 無法自行搜尋，由 {searcher} 搜尋，{model} 拿到結果後繼續回答。不屬於對話輪次。",
+    "{agent} called magpie's web_search MCP tool: {searcher} searched for it. Not a turn of the conversation.": "{agent} 呼叫了 magpie 的 web_search MCP 工具：由 {searcher} 代為搜尋。不屬於對話輪次。",
+    "{agent} called magpie's analyze_image MCP tool: {describer} looked at the image for it. Not a turn of the conversation.": "{agent} 呼叫了 magpie 的 analyze_image MCP 工具：由 {describer} 代為查看圖片。不屬於對話輪次。",
+    "magpie ran this web search for a model that can't search the web by itself: {searcher} searched, and that model goes on answering once it has what was found. Not a turn of the conversation.": "magpie 代一個無法自行搜尋的模型發起的聯網搜尋：由 {searcher} 搜尋，該模型拿到結果後繼續回答。不屬於對話輪次。",
+    "Every turn starts with a request to {name}, a subscription: it counts against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "每輪開始時都會先向訂閱 {name} 發一個請求：它和代理自己的請求一樣計入該訂閱的額度。選免費模型或 API 金鑰上的模型，訂閱就只留給代理使用。",
+    "Every turn starts with two requests to {name}, a subscription: they count against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "每輪開始時都會先向訂閱 {name} 發兩個請求：它們和代理自己的請求一樣計入該訂閱的額度。選免費模型或 API 金鑰上的模型，訂閱就只留給代理使用。",
+    "magpie had {describer} describe an image for {agent}'s {model}: nothing magpie knows says {model} can see images, so it is counted as text-only and given the description in the image's place. If it does see them, tick “Accepts images” for it in its provider's models. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie 讓 {describer} 為 {agent} 的 {model} 描述圖片：magpie 所知的資訊都沒有說 {model} 能看圖，所以把它當作只收文字，在圖片位置給它這段描述。如果它其實能看圖，請在它的服務商的模型裡勾選「支援圖片輸入」。描述圖片的模型在 設定 › 模型 › 識圖模型 裡選。不屬於對話輪次。",
+    "magpie had {describer} describe an image for {agent}'s {model}, which its provider's list or its own setting says takes text only: {model} is given the description in the image's place. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie 讓 {describer} 為 {agent} 的 {model} 描述圖片：它的服務商的模型清單或它自己的設定說它只收文字，{model} 在圖片位置收到這段描述。描述圖片的模型在 設定 › 模型 › 識圖模型 裡選。不屬於對話輪次。",
+    "magpie had {describer} describe an image for a model that can't see images, which is given the description in the image's place. Not a turn of the conversation.": "magpie 讓 {describer} 為一個無法看圖的模型描述圖片，該模型在圖片位置收到這段描述。不屬於對話輪次。",
+    "{agent} drafted the suggested prompts on its home page by itself, in the background, searching the project's files and connected apps, and checked them for safety. Not a turn of the conversation; Codex's Settings › Configuration › Suggested prompts turns it off.": "{agent} 在後臺自行生成首頁的提示詞建議（會搜尋專案檔案和已連線的應用）並做安全檢查，不屬於對話輪次。可在 Codex 的 設定 › 設定 › 提示詞建議 中關閉。",
+    "{agent} sent this turn on Luna Reserve, which it turns to once the plan's own allowance is used up; it picks the model itself.": "{agent} 用 Luna 儲備發出了本輪（套餐額度用完後改用），模型由它自行選擇。",
+    "{agent} made this call itself ({kind}), not as a turn of the conversation, and picks its model itself.": "{agent} 自行發起的呼叫（{kind}），不屬於對話輪次，模型由它自行選擇。",
+    "{agent} checked that magpie answers, as it does when it starts and from its Test connection. It names this check's model itself, from the names in its model list ({model}), not the model chosen in the conversation, and only reads whether an answer comes back; magpie sends it to the model chosen in {agent}'s model menu, or to its first listed model when none is. Not a turn of the conversation.": "{agent} 在檢查 magpie 能否回應（啟動時和在 Test connection 裡都會發）。這次檢查的模型由它自己依模型清單裡的名稱選出（{model}），不是對話裡選的模型，它也只看有沒有回應；magpie 會把它送給 {agent} 模型選單裡選的模型，沒選時送給清單裡的第一個模型。不屬於對話輪次。",
+    "Nothing was tried: {error}": "沒有嘗試任何帳號：{error}",
+    "{agent} asked for {model}: {name} serves it, and the vendor is asked for {sent}": "{agent} 請求 {model}：由 {name} 提供，向廠商請求的模型是 {sent}",
+    "the last {n} the gateway keeps": "閘道保留的最近 {n} 個",
+    "Accounts and keys": "帳號與金鑰",
+    "over those requests": "統計自這些請求",
+    "over today's requests": "統計自今天的請求",
+    "Nothing on {day}": "{day}沒有請求",
+    "No requests since magpie started": "magpie 啟動以來還沒有請求",
+    "Each request an agent sends through magpie shows up here: who answered it, why, and each try.": "agent 經 magpie 發出的每個請求都列在這裡：由誰應答、為何選它，以及每次嘗試。",
+    "Earlier ones are kept by day, in the bar above.": "更早的請求按天儲存，在上面的日期裡檢視。",
+    "Earlier days": "更早的日期",
+    "tried {n}": "嘗試 {n}",
+    "answered {n}": "應答 {n}",
+    "last answered {time}": "最近應答 {time}",
+    "as of {time}": "截至 {time}",
+    "{n} used at {time}; it has renewed since": "{time} 時已用 {n}，之後已重置",
+    "routing…": "路由中…",
+    "masking…": "脫敏中…",
+    "back in {d}": "{d}後恢復",
+    "free · costs nothing": "免費 · 不花額度",
+    "back at {time} · in {d}": "{time} 恢復 · 還有 {d}",
+    "its plan doesn't list {model}": "套餐不包含 {model}",
+    "set to serve other models, not {model}": "已設為只用於其他模型，不含 {model}",
+    "{who} is left out: it is set to serve other models, not {model}.": "{who} 不參與：它已設為只用於其他模型，不含 {model}。",
+    "held at its {cap}% usage cap": "已達 {cap}% 用量上限",
+    "request longer than its {n} window · passed over": "請求超出其 {n} 上下文 · 已略過",
+    "{who} is left out: this request is longer than its {n} context window, so it would only refuse it. It's asked only once every one with room is out of its allowance.": "{who} 不參與：這個請求超出它 {n} 的上下文視窗，送給它只會被拒絕。只有容得下的都用完額度時才會問它。",
+    "not an account the gateway key may use": "不是該閘道金鑰可用的帳號",
+    "{who} is left out: the gateway key asking may not use its account.": "{who} 被排除：發起請求的閘道金鑰不能使用它的帳號。",
+    "{who} is left out: a usage window is used up, and the account is set not to spend its credits, so it counts as used up until that window renews.": "{who} 不參與：某個用量時段已用完，且該帳號設為不使用積分，時段重置前視為已用完。",
+    "{who} is left out: a usage window is at {n}, past the {cap}% cap set on the account, so it counts as used up until that window renews.": "{who} 不參與：某個用量時段已用 {n}，超過該帳號的 {cap}% 上限，時段重置前視為已用完。",
+    "{name}'s list for this key has no {model}": "{name} 為此 key 列出的模型中沒有 {model}",
+    "answering…": "回答中…",
+    "answering another request…": "在回答另一個請求…",
+    "answered this request": "回答了這個請求",
+    "picked for “{intent}”": "按意圖「{intent}」選中",
+    "answered {agent}": "回答了 {agent}",
+    "{n} agents at once": "{n} 個 Agent 同時在發",
+    "In order: member by member, the first model the group names until it can't answer, each over its own accounts or keys as its provider routes them.": "按順序：逐個成員，先用組內第一個模型，無法回應再換下一個；各成員按其供應商的路由在自己的帳號或 Key 間分配。",
+    "{agent} asked for the routing group {name}: {members}": "{agent} 請求了路由組 {name}：{members}",
+    "Kept on {who}: it answered this conversation before, and affinity keeps a session with one account.": "留在 {who}：此會話之前由它回答，親和性使會話保持同一帳號。",
+    "Kept on {who}: {agent} is handing back tool results within turn {n}, and moving now would lose what the vendor cached of it.": "留在 {who}：{agent} 正在第 {n} 輪內回傳工具結果，此時換帳號會丟掉廠商為它快取的內容。",
+    "Kept on {who}: {d} ago the vendor read {r} tokens of this conversation from its cache and wrote {w} to it; anyone else would be sent them afresh and paid in full.": "留在 {who}：{d}前廠商從快取讀取了此會話的 {r} tokens，並寫入了 {w} tokens；換帳號需重新發送並全價計費。",
+    "Turn {n} begins: in turn, it goes to the one after {who}, which answered the last turn — {next}.": "第 {n} 輪開始：輪流交給上一輪迴答者 {who} 的下一個，即 {next}。",
+    "Turn {n} begins: affinity keeps a conversation only within a turn, so routing decides afresh.": "第 {n} 輪開始：親和性僅在一輪內保持，路由重新決定。",
+    "{who} answered this conversation last, but it is resting, so the conversation moves.": "此會話上次由 {who} 回答，但它在休息，已換帳號。",
+    "{who} answered this conversation last, but its allowance is all but used up, so the conversation moves.": "此會話上次由 {who} 回答，但其額度將盡，已換帳號。",
+    "Every one here has used up its allowance and goes on on its credits, set to spend them only after everything else, so {who}, first in line, goes first.": "這裡每個帳號額度都已用盡、改用積分，且都設為最後使用積分，所以先試排第一的 {who}。",
+    "{who} has used up its allowance and goes on on its credits, which it is set to spend only after everything else: it is tried after every other account, key and fallback.": "{who} 額度已用盡、改用積分，且設為最後使用積分：排在所有其他帳號、金鑰和備用之後。",
+    "{who} answered this conversation last, but it is on its credits now, set to spend them only after everything else, so the conversation moves to {first}.": "此會話上次由 {who} 回答，但它現在在用積分，且設為最後使用積分，所以會話換到 {first}。",
+    "{who} answered this conversation last, but it is no longer one to route to.": "此會話上次由 {who} 回答，但它已不可路由。",
+    "{who} answered this conversation last, but the group goes in order and {first}, ahead of it, is ready again, so turn {n} goes back to {first}.": "此會話上次由 {who} 回答，但該群組按順序路由，排在它前面的 {first} 已恢復可用，所以第 {n} 輪回到 {first}。",
+    "{who}, a fallback, answered this conversation last, but the provider's own {first} is ready again, so turn {n} goes back to it.": "此會話上次由備用 {who} 回答，但供應商自己的 {first} 已恢復可用，所以第 {n} 輪回到它。",
+    "{who} took this conversation while {first}, listed ahead of it in the group, couldn't; {first} is ready again, so turn {n} goes back to it.": "此會話由 {who} 接手，當時群組裡排在它前面的 {first} 無法處理；{first} 已恢復可用，所以第 {n} 輪回到它。",
+    "{who}, a fallback, answered this conversation last. The provider's own {first} is ready again, but Stays is Strict, which never moves a conversation, so it stays on the fallback; new conversations go to {first}.": "此會話上次由備用 {who} 回答。供應商自己的 {first} 已恢復可用，但會話保持設為嚴格，從不移動會話，所以它留在備用上；新會話會走 {first}。",
+    "{who} answered this conversation last, but the vendor then read only {r} tokens of it from its cache and wrote {w} — not worth staying for.": "此會話上次由 {who} 回答，但當時廠商只從快取讀取了 {r} tokens、寫入了 {w} tokens，不值得保留。",
+    "{who} answered this conversation {d} ago, longer than the 5 minutes a vendor keeps a prompt cached — so routing decides afresh.": "此會話 {d}前由 {who} 回答，已超過廠商快取提示詞的 5 分鐘，路由重新決定。",
+    "Affinity is off: each request is routed afresh, whoever answered its conversation before.": "親和性已關閉：每個請求都重新路由，不論之前由誰回答。",
+    "{status} · {fail} · passed to {agent}": "{status} · {fail} · 已交給 {agent}",
+    "{status} · {fail} · went on to the next": "{status} · {fail} · 已轉給下一個",
+    "{n} used · all but used up": "已用 {n} · 幾乎用盡",
+    "{n} used · kept for last": "已用 {n} · 留到最後",
+    "{n} used · renews in {d}": "已用 {n} · {d}後重置",
+    "{n} left · all but used up": "剩餘 {n} · 幾乎用盡",
+    "Its allowance had just run out and it was refused, so it was asked again at once to spend its credits.": "額度剛用完被拒，於是立即重試一次，改用其 Credits。",
+    "{who} answered {status}: its allowance had just run out, but the account holds credits, which the vendor spends once the allowance is used up, so it is asked again at once, before any of the reply reaches {agent}.": "{who} 回傳 {status}：額度剛剛用完，但該帳號有 Credits，額度用完後供應商會改扣 Credits，因此立即重試，回覆不會傳到 {agent}。",
+    "It holds credits, so it rests only {d} and its usage is read again, not until its allowance renews": "它有 Credits，只休息 {d} 並重新讀取用量，不必等到額度恢復",
+    "{who} is at {n} of its allowance but goes on on its credits — ahead of those used up with nothing to go on with, after those with allowance left.": "{who} 額度已用 {n}，但仍可用 Credits 繼續 —— 排在額度未用完的帳號之後、額度用完且無 Credits 的帳號之前。",
+    "{n} used · on credits": "已用 {n} · 使用 Credits",
+    "{n} left · on credits": "剩餘 {n} · 使用 Credits",
+    "{n} used · on credits · after the others": "已用 {n} · 使用積分 · 排在最後",
+    "{n} left · on credits · after the others": "剩餘 {n} · 使用積分 · 排在最後",
+    "Every account is all but used up, so {who} goes first: it goes on on its credits, which the vendor spends once its allowance is used up.": "所有帳號額度都幾乎用盡，因此 {who} 排第一：額度用完後供應商會改扣其 Credits，可以繼續使用。",
+    "{n} left · kept for last": "剩餘 {n} · 留到最後",
+    "{n} left · renews in {d}": "剩餘 {n} · {d}後重置",
+    "renews in {d}": "{d}後重置",
+    "{n} used · renews in {d} · one renewing sooner goes first": "已用 {n} · {d}後重置 · 先用更早重置的帳號",
+    "{n} left · renews in {d} · one renewing sooner goes first": "剩餘 {n} · {d}後重置 · 先用更早重置的帳號",
+    "{n} used · conversation kept on another": "已用 {n} · 對話留在另一個帳號",
+    "{n} left · conversation kept on another": "剩餘 {n} · 對話留在另一個帳號",
+    "{n} left at {time}; it has renewed since": "{time} 時剩餘 {n}，之後已重置",
+    "what's left not known yet": "剩餘額度未知",
+    "{n} tokens lately": "最近 {n} token",
+    "first text in {ms}": "{ms} 後出現正文",
+    "requested {sent} · served {served}": "請求 {sent} · 實際 {served}",
+    "served {served}": "實際 {served}",
+    "Upstream: {upstream}": "上游：{upstream}",
+    "The aggregator passed the request on to {upstream}, as its reply says: the provider that actually answered it.": "聚合供應商把這條請求轉給了 {upstream}，由它實際作答（聚合供應商的回覆裡寫明）。",
+    "{sent} is a routing group of the remote magpie, and it routed the request to {served}: the group picking one of its models, not the vendor swapping the model.": "{sent} 是遠端 magpie 的路由組，請求被路由給 {served}：這是路由組選擇了組內模型，並非服務商替換了模型。",
+    "The vendor was asked for {sent}, but its reply says {served} answered: likely another model. The same model under a dated name or spelled otherwise isn't marked.": "向服務商請求的是 {sent}，但回覆說是 {served} 作答，很可能換成了別的模型。（同一模型只是帶了日期或寫法不同，不會這樣標出。）",
+    "ClinePass route {served}": "ClinePass 路由 {served}",
+    "requested {sent} · ClinePass route {served}": "請求 {sent} · ClinePass 路由 {served}",
+    "ClinePass answered {sent} through {served}, a route it picks itself: the name is the route's, not another model's.": "ClinePass 透過它自己選的路由 {served} 回答了 {sent}：這是路由的名字，不是換成了別的模型。",
+    "Its reply says {upstream} answered.": "回覆說是 {upstream} 作答。",
+    "Its reply didn't say which provider answered.": "回覆沒有說是哪家上游作答。",
+    "{pin} was asked for, but its reply didn't say which provider answered, so whether ClinePass kept to it is unknown.": "請求時指定了 {pin}，但回覆沒有說是哪家上游作答，所以無法確定 ClinePass 是否照做。",
+    "No provider was asked for, and its reply didn't say which one answered.": "請求時沒有指定上游，回覆也沒有說是哪家作答。",
+    "{h} h {m} min": "{h} 小時 {m} 分鐘",
+    "magpie saved a report of where it held this request. If it keeps happening, send the report with yours.": "magpie 儲存了一份報告，記下這個請求卡在了哪裡。如果反覆出現，請把這份報告附在你的回報裡。",
+    "Report copied": "報告已複製",
+    "Couldn't read the report: {error}": "讀不到這份報告：{error}",
+    "Open Folder": "打開資料夾",
+    "not an account {group} may use": "不是 {group} 可用的帳號",
+    "{who} is left out: the routing group {group} is held to other accounts of its provider.": "{who} 被略過：路由組 {group} 只用該服務商的其他帳號。",
+    "Requests to this group's models spend only the accounts picked here. A provider left on any of its accounts uses them all.": "發到這個組裡模型的請求只消耗這裡選中的帳號。保持「任一帳號」的服務商會用它的所有帳號。",
+    "{n} of its accounts": "{n} 個帳號",
+    "Any of its accounts": "任一帳號",
+    "This group spends only {accounts} of {provider}": "這個組只消耗 {provider} 的 {accounts}",
+    "This group may spend every account of {provider}": "這個組可以消耗 {provider} 的每個帳號",
+  },
+  ja: {
+    "sign-in refused (answered since)": "サインイン拒否（その後は応答あり）",
+    "Free first uses it before paid ones, and Cheapest first counts it as costing nothing": "無料優先は有料より先にこれを使い、最安優先はこれを費用ゼロとして数えます",
+    "{name}, {n} accounts: {windows}": "{name}（{n} アカウント）：{windows}",
+    "What is left of this provider's accounts the group can use, together: amounts of one unit added up, a share the mean of the accounts on one plan. Each account is on the Usage page.": "このグループが使えるこのプロバイダーのアカウントの残りの合計：同じ単位の量は足し合わせ、割合は同じプランのアカウントの平均。各アカウントは使用量ページにあります。",
+    "Each session's context window": "セッションごとのコンテキストウィンドウ",
+    "Show this session's newest request": "このセッションの最新のリクエストを表示",
+    "Its plugin sent this request itself, so magpie can't split its time": "このリクエストはプラグインが自ら送信したため、magpie では時間の内訳を出せません",
+    "Claude Code sent this request itself, so magpie can't split its time": "このリクエストは Claude Code が自ら送信したため、magpie では時間の内訳を出せません",
+    "magpie is masking this request before routing it (Settings › Privacy), so who takes it isn't picked yet.": "magpie はルーティングの前にこのリクエストをマスクしています（設定 › プライバシー）。誰が処理するかはまだ決まっていません。",
+    "magpie hasn't routed this request yet, so who takes it isn't picked yet.": "magpie はまだこのリクエストをルーティングしていないため、誰が処理するかはまだ決まっていません。",
+    "Nothing took this request: {error}": "このリクエストを処理したものはありません: {error}",
+    "{n} groups · {m} on": "{n} 個のグループ · {m} 個がオン",
+    "Filter, or type an agent's name…": "絞り込み、またはエージェント名を入力…",
+    "the name its User-Agent begins with": "User-Agent の先頭の名前",
+    "heard from in the last 30 days": "過去 30 日にリクエストあり",
+    "The subagent effort set in magpie is {effort}; the model's supported levels and a routing group's fixed member effort still apply.": "magpie で設定したサブエージェントの推論レベルは {effort} です。モデルが対応するレベルへの調整と、ルーティンググループのメンバーに固定されたレベルは引き続き適用されます。",
+    "{agent}'s call to magpie's web_search MCP tool": "{agent} による magpie の web_search MCP ツールの呼び出し",
+    "{agent}'s call to magpie's analyze_image MCP tool": "{agent} による magpie の analyze_image MCP ツールの呼び出し",
+    "a model that can't see images": "画像を見られないモデル",
+    "{failed}, the Image recognition model picked in Settings › Models, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "設定 › モデル で選んだ画像認識モデル {failed} は {whom} のための画像を説明できませんでした：{why}。そのため magpie は次に使える画像を見られるモデル {describer} に代わりに説明させました。会話のターンではありません。",
+    "{failed}, the model magpie picked to describe images, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "magpie が自動で選んだ画像認識モデル {failed} は {whom} のための画像を説明できませんでした：{why}。そのため magpie は次に使える画像を見られるモデル {describer} に代わりに説明させました。会話のターンではありません。",
+    "{agent}'s {model}": "{agent} の {model}",
+    "a model that can't search the web by itself": "自分ではウェブ検索できないモデル",
+    "{failed}, the searcher picked in Settings › Models › Web search, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "設定 › モデル › ウェブ検索 で選んだ検索モデル {failed} は {whom} の代わりに検索できませんでした：{why}。そのため magpie は次に使える検索モデル {searcher} に代わりに検索させました。会話のターンではありません。",
+    "{failed}, the searcher magpie picked, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "magpie が自動で選んだ検索モデル {failed} は {whom} の代わりに検索できませんでした：{why}。そのため magpie は次に使える検索モデル {searcher} に代わりに検索させました。会話のターンではありません。",
+    "By session": "セッション別",
+    "By key": "キー別",
+    "These requests came with no gateway key: from this computer, or from before magpie noted the key.": "これらのリクエストはゲートウェイキーなしで届きました。このコンピューターからのもの、または magpie がキーを記録する前のものです。",
+    "No session ID": "セッション ID なし",
+    "{n} in progress": "{n} 件進行中",
+    "These requests did not provide a session ID; they are not treated as one conversation.": "これらのリクエストにはセッション ID がないため、1 つの会話としては扱われません。",
+    "Estimated at effective model prices, including cache reads and writes; subscription billing may differ. Totals cover only the requests listed here.": "キャッシュの読み書きを含め、モデルの実効価格で推定しています。サブスクリプションの実際の請求とは異なる場合があります。合計はここに表示されたリクエストのみが対象です。",
+    "No known price or token counts for this request": "このリクエストには既知の価格やトークン数がありません",
+    "Drag to reorder — agents' model lists show the groups in this order · Alt+↑/↓ to move": "ドラッグで並べ替え — エージェントのモデル一覧にもこの順番でグループが表示されます · Alt+↑/↓ で移動",
+    "Group order saved": "グループの順番を保存しました",
+    "{picked}, the Image recognition model picked in Settings, isn't set up any more, so magpie had {describer}, its automatic choice, describe an image for {agent}'s {model} in its place. Pick another in Settings › Models › Image recognition. Not a turn of the conversation.": "設定で選んだ画像認識モデル {picked} が使えなくなっているため、magpie は代わりに自動で選んだ {describer} に {agent} の {model} のための画像を説明させました。設定 › モデル › 画像認識 で別のモデルを選んでください。会話のターンではありません。",
+    "In agents’ lists": "エージェントの一覧での名前",
+    "Names in agents’ lists": "エージェントの一覧での名前",
+    "Whether “· routing group” follows a group’s name in the agents’ lists: one setting for every group, and for the provider after each model’s name, as on Settings.": "エージェントの一覧でグループ名の後に「· routing group」を付けるかどうか。すべてのグループに共通の設定で、モデル名の後のプロバイダ名にも効きます（「設定」と同じものです）。",
+    "“· routing group” is set for every group, under the list": "「· routing group」を付けるかは一覧の下で全グループ共通に設定します",
+    "{agent} guessed your next message for its composer by itself, reading the whole conversation again. Not a turn of the conversation; Codex composer predictions, under Settings in Codex's row on the Agents page, picks its model, and Codex's Settings › General › Show predictions turns it off.": "{agent} が入力欄に表示する次のメッセージの予測を自分で行い、そのたびに会話全体を読み直しました。会話のターンではありません。エージェントページの Codex の行にある設定の Codex の入力予測 でモデルを選べ、Codex の 設定 › 一般 › 予測候補を表示 でオフにできます。",
+    "{name} is switched off: the group skips it until it is on again": "{name} はオフです。オンに戻すまでグループはスキップします",
+    "{n} switched off": "{n} 件オフ",
+    "Off: agents aren't offered {name} and a request to it is turned away. Click to switch it on": "オフ：{name} はエージェントに表示されず、届いたリクエストは断られます。クリックでオン",
+    "On: agents may pick {name}. Click to switch it off and keep it as it is": "オン：エージェントは {name} を選べます。クリックで一時的にオフ（設定はそのまま）",
+    "{name} switched on": "{name} をオンにしました",
+    "{name} switched off": "{name} をオフにしました",
+    "in {groups}": "{groups} に追加済み",
+    "By weight: it's {who}'s share \u2014 each key takes requests as its weight says.": "重み付け：{who} の取り分です——各キーは重みどおりにリクエストを受けます。",
+    "By weight: it's {who}'s share \u2014 each account takes requests as its weight says.": "重み付け：{who} の取り分です——各アカウントは重みどおりにリクエストを受けます。",
+    "By weight: it's {who}'s share — each model takes requests as the weight set beside it says.": "重み付け：{who} の取り分です——各モデルは横に設定した重みどおりにリクエストを受けます。",
+    "By weight: each model takes its share of the requests by the weight set beside it — one weighing 3 three for every one a model weighing 1 takes, spread out rather than in bursts. One resting after a failure leaves the round and the others share its requests; the next model is the fallback when one fails.": "重み付け：各モデルは横に設定した重みに応じてリクエストを受けます。重み 3 のモデルは、重み 1 のモデルが 1 件受けるごとに 3 件受け、まとめてではなく分散して届きます。失敗して休止中のモデルは巡回から外れ、残りがその分を分け合います。あるモデルが失敗したときは次のモデルが引き継ぎます。",
+    "Its share of the requests: a model weighing 3 takes three for every one a model weighing 1 takes": "リクエストの取り分：重み 3 のモデルは、重み 1 のモデルが 1 件受けるごとに 3 件受けます",
+    "Weight of {name}": "{name} の重み",
+    "A weight is 1 to 1000": "重みは 1〜1000 です",
+    "{name}: {routing}": "{name}：{routing}",
+    "How {name} routes: click to change it": "{name} のルーティング方法：クリックで変更",
+    "{n} available": "{n} 個が利用可能",
+    "{n} resting": "{n} 個が休止中",
+    "{n} held": "{n} 個が停止中",
+    "Show each key": "キーを個別に表示",
+    "Fold these keys into one row": "これらのキーを 1 行にまとめる",
+    "Show each account": "アカウントを個別に表示",
+    "Fold these accounts into one row": "これらのアカウントを 1 行にまとめる",
+    "Show what this group routes to": "このグループのルーティング先を表示",
+    "Fold this group into one row": "このグループを 1 行に折りたたむ",
+    "Sent by {agents}": "{agents} が送信中",
+    "Fold this route into one row": "このルートを 1 行に折りたたむ",
+    "Show where this route goes": "このルートの送信先を表示",
+    "Its week was used up, so one of {account}'s Codex resets was used by itself first.": "週の枠を使い切ったため、先に {account} の Codex リセットを1回自動で使用しました。",
+    "{who} answered {status}: its week is used up and nobody else could take the request, so one of {account}'s Codex resets was used by itself and the request is asked again, before any of the reply reaches {agent}.": "{who} が {status} を返しました：週の枠を使い切り、他にリクエストを受けられるものがなかったため、{account} の Codex リセットを1回自動で使用し、応答が {agent} に届く前にリクエストを再送しました。",
+    "held: its allowance used up, set not to spend credits": "枠を使い切り、クレジット不使用のため停止中",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. The request went to {next}.": "{who} は認証できませんでした。magpie で再度サインインしてください。このログインは再試行されません。リクエストは {next} に送られました。",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. No other account could answer.": "{who} は認証できませんでした。magpie で再度サインインしてください。このログインは再試行されません。応答できる他のアカウントはありませんでした。",
+    "Duplicated {name}": "{name} を複製しました",
+    "{name} as text to paste into another magpie: its models, routing and rules, no key": "{name} を別の magpie に貼り付けるテキストとして：モデル、ルーティング、ルールを含み、キーは含みません",
+    "{name} copied: paste it into Import on another magpie's Routing page": "{name} をコピーしました：別の magpie のルーティングページで「インポート」に貼り付けてください",
+    "Add a routing group someone shared from their magpie": "誰かが自分の magpie から共有したルーティンググループを追加",
+    "Paste a group copied with Copy to share": "「共有用にコピー」でコピーしたグループを貼り付け",
+    "Replace {name}": "{name} を置き換える",
+    "{name} has the same id: its models, routing and rules are replaced by this group's; its accounts and folder rules stay": "{name} と ID が同じです：モデル、ルーティング、ルールはこのグループの内容に置き換わります。アカウントとフォルダ別のルールはそのまま残ります",
+    "Replaced {name}": "{name} を置き換えました",
+    "A routing group shared from magpie": "magpie から共有されたルーティンググループ",
+    "Paste a routing group someone shared from their magpie: its models, routing and rules come with it, never a key": "誰かが magpie から共有したルーティンググループを貼り付けます：モデル、ルーティング、ルールが含まれ、キーは決して含まれません",
+    "Not in your magpie, left out: {models}": "この magpie にないため除外：{models}",
+    "The same model from your own provider: {models}": "自分のプロバイダーの同じモデルを使用：{models}",
+    "1 rule left out with them": "1 件のルールも一緒に除外",
+    "{n} rules left out with them": "{n} 件のルールも一緒に除外",
+    "Needs models from two providers: {name} is the only one": "2 つのプロバイダーのモデルが必要です：今は {name} だけです",
+    "Needs a model cheap beside {name}": "{name} より安いモデルが必要です",
+    "Add a provider first": "まずプロバイダーを追加してください",
+    "Start from a template: made of your own models, added in a click": "テンプレートから：あなたのモデルで組み、ワンクリックで追加",
+    "Edit first": "先に編集",
+    "A copy of {name} with its models, routing and rules, listed after it": "{name} をモデル・ルーティング・ルールごと複製し、そのすぐ後に並べます",
+    "Purpose filter": "用途",
+    "Purpose: {name}": "用途：{name}",
+    "Unmarked": "未記録",
+    "Unrecognized request purpose": "不明な用途",
+    "No purpose was recorded; this may be a conversation turn or an older record.": "用途が記録されていません。会話のターンか、古い記録の可能性があります。",
+    "Filter routing by purpose": "用途でルーティングを絞り込む",
+    "Counts for the requests in this list": "この一覧のリクエストの集計",
+    "Counts since the gateway started": "ゲートウェイ起動以降の集計",
+    "No failed request in this list": "この一覧に失敗したリクエストはありません",
+    "View usage": "使用量を表示",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. To keep every request's, turn on Request archive at the top of Usage › Requests.": "magpie はリクエスト本文とレスポンス本文を直近 40 件のリクエストぶんだけ、終了するまで保持します。すべてのリクエストのものを残すには、「使用量 › リクエスト」の上部で「リクエストアーカイブ」をオンにしてください。",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. Request archive is on, but this request isn't in it: it was made while the archive was off, or it couldn't be saved.": "magpie はリクエスト本文とレスポンス本文を直近 40 件のリクエストぶんだけ、終了するまで保持します。「リクエストアーカイブ」はオンですが、このリクエストはアーカイブにありません。アーカイブがオフのときに送られたか、保存できませんでした。",
+    "Routing history for this request is no longer available.": "このリクエストのルーティング履歴は利用できなくなりました。",
+    "Token breakdown": "トークン内訳",
+    "Input (uncached)": "入力（非キャッシュ）",
+    "No token breakdown was recorded": "トークン内訳は記録されていません",
+    "Includes token usage from billable retries; the row totals show the final attempts": "課金対象の再試行の使用量を含みます。リストの合計は最後の試行の使用量です",
+    "Breakdown available for {n} of {total} requests": "{total} 件中 {n} 件に内訳が記録されています",
+    "Avg. cache": "平均キャッシュ",
+    "Avg. speed": "平均速度",
+    "Metrics to show": "表示する指標",
+    "request cache hit rate {p}": "リクエストのキャッシュヒット率 {p}",
+    "Based on {n} of {total} completed requests": "完了した {total} 件中 {n} 件に基づく",
+    "Total cache reads divided by total prompt tokens; larger prompts carry more weight": "キャッシュ読み取り合計を入力トークン合計で割った値。入力が多いリクエストほど重みが大きくなります",
+    "Total output tokens divided by total decode time; excludes waiting and replies without usable timing": "出力トークン合計を生成時間の合計で割った値。待ち時間と有効な計測のない応答は除きます",
+    "Read the accounts' allowances again": "アカウントの利用枠を読み直します",
+    "live, as the gateway decides": "ライブ · ゲートウェイの判断どおり",
+    "Add another model": "別のモデルを追加",
+    "Sort by weight": "重みで並べ替え",
+    "Heaviest first. When a model fails, the next one in this order takes over": "重みの大きい順に並べます：モデルが失敗したときはこの順で代わります",
+    "Add pattern": "パターンを追加",
+    "e.g. openrouter/*:free or re:…": "例：openrouter/*:free または re:…",
+    "Every model this pattern matches is in the group, as providers list them": "このパターンに一致するモデルは、プロバイダの一覧に合わせてすべてグループに入ります",
+    "No model magpie serves matches this pattern now": "magpie が提供するモデルで、現在このパターンに一致するものはありません",
+    "Classifier failed {when}: {error}": "分類器が{when}に失敗しました：{error}",
+    "{by} couldn't say which intent or effort a turn is the last time it was asked: {error}. Until it answers, no rule with an intent matches and turns reason as the agent asked. Each request's details say what it was asked.": "{by} は前回、このターンの意図や推論の強さを判断できませんでした：{error}。応答できるようになるまで、意図付きのルールは一致せず、各ターンはエージェントが求めた推論の強さで進みます。何を尋ねたかは各リクエストの詳細にあります。",
+    "In the group by a pattern: switch it off to send it nothing": "パターンでグループに入っています。オフにするとリクエストを送りません",
+    "A pattern has a * in it, or starts with re:": "パターンには * を含めるか、re: で始めてください",
+    "{pattern} is not a regular expression magpie can read": "{pattern} は magpie が読める正規表現ではありません",
+    "Every model a pattern matches is in the group, now and as providers list new ones, after the models above: * is any run of characters in provider/model, re: starts a regular expression.": "パターンに一致するモデルは、プロバイダが今後追加するものも含めてすべて、上のモデルの後にグループに入ります。* は provider/model の任意の文字列、re: で始めると正規表現です。",
+    "{api} only · after the others": "{api} のみ · 他の後",
+    "{who} is in reserve: {n} of its provider's accounts or keys take requests at once, the first in the list, so it's tried only once they have all failed.": "{who} は予備です。このプロバイダーは一覧の先頭から {n} 個のアカウントやキーだけを同時に使うので、それらがすべて失敗したときだけ試されます。",
+    "{who} answered this conversation last, but it is in reserve while those before it in the list can take requests, so the conversation moves back to them.": "{who} がこの会話に前回答えましたが、一覧でその前にあるアカウントがリクエストを受けられる間は予備なので、会話はそちらに戻ります。",
+    "in reserve · {n} at once": "予備 · 同時に {n} 個",
+    "key set to {api} only, no {api} URL · sent on the others": "キーは {api} 専用、{api} の URL なし · 他の URL で送信",
+    "{who} is made for {api}, not {other} as the keys routed over are, so it isn't one of them: it's tried after them.": "{who} は {api} 用で、ルーティング対象のキーのような {other} 用ではないため、その一員にはなりません。それらの後に試されます。",
+    "{n} keys for {api}": "{api} 用のキー {n} 個",
+    "New group": "新しいグループ",
+    "Turn on routing groups": "ルーティンググループをオンにする",
+    "Routing groups are on": "ルーティンググループをオンにしました",
+    "Routing groups are off in Plugins › Built-in: the groups magpie finds, one model several providers serve, still route, but your own can't be made or changed here.": "ルーティンググループは「プラグイン › 内蔵」でオフになっています。magpie が見つけたグループ（複数のプロバイダが提供する同じモデル）はそのままルーティングされますが、自分のグループはここで作成・変更できません。",
+    "Make a routing group of any models you like — agents pick it as one model": "好きなモデルでルーティンググループを作ります。エージェントはそれを 1 つのモデルとして選べます",
+    "Filter groups and models": "グループとモデルを絞り込む",
+    "No group or model matches “{q}”": "「{q}」に一致するグループやモデルはありません",
+    "This group can't be shown: {error}": "このグループは表示できません：{error}",
+    "No group yet. A model two of your providers serve becomes one on its own; New group makes one of any models you like.": "グループはまだありません。2 つのプロバイダが提供するモデルは自動でグループになります。「新しいグループ」で好きなモデルをまとめられます。",
+    "1 found group removed": "自動作成のグループ 1 件を削除済み",
+    "{n} found groups removed": "自動作成のグループ {n} 件を削除済み",
+    "magpie doesn't make them again. Click to bring one back.": "magpie はこれらを再び作成しません。クリックすると元に戻せます。",
+    "Pick several groups to remove together": "複数のグループを選んでまとめて削除",
+    "Select every group": "すべて選択",
+    "Pick the groups to remove": "削除するグループを選択",
+    "{n} groups removed": "{n} 件のグループを削除しました",
+    "No group yet. New group makes one of any models you like.": "グループはまだありません。「新しいグループ」で好きなモデルをまとめられます。",
+    "Find groups on their own": "グループを自動で作成",
+    "Their models join no found group; the groups you made or changed keep them": "そのモデルは自動グループに入りません。自分で作成または変更したグループはそのままです",
+    "Left out: {names}": "自動グループから除外：{names}",
+    "Leave out a provider…": "プロバイダを除外…",
+    "Leave out of found groups": "自動グループから除外",
+    "Found groups changed": "自動グループを更新しました",
+    "A model two or more of your providers serve becomes a group of them (auto/…). Switch it off to list and serve only the groups you made or changed.": "2 つ以上のプロバイダが提供するモデルは、それらのグループ（auto/…）になります。オフにすると、自分で作成または変更したグループだけを一覧・提供します。",
+    "Off: only the groups you made or changed are listed and served. An agent set to a found group is moved to its model from one provider, and a request still naming one goes there too.": "オフ：自分で作成または変更したグループだけを一覧・提供します。自動グループを選んでいるエージェントは、1 つのプロバイダのそのモデルに切り替わり、自動グループを指定したリクエストもそこへ送られます。",
+    "Found groups are on": "グループの自動作成はオンです",
+    "Found groups are off: only yours are listed and served": "グループの自動作成はオフです：自分のグループだけを一覧・提供します",
+    "Bring it back": "元に戻す",
+    "{name} is back": "{name} を元に戻しました",
+    "Manual: every request goes to the model you pick on the group's card, over its own accounts or keys; the others, and the rules, wait until you pick another — none takes over when it fails.": "手動：すべてのリクエストは、グループのカードで選んだモデルに、そのモデル自身のアカウントやキーで送られます。他のモデルとルールは、別のモデルを選ぶまで待機し、失敗しても引き継ぎません。",
+    "Manual: every request goes to the model picked on the group's card, over its own accounts or keys.": "手動：すべてのリクエストは、グループのカードで選んだモデルに、そのモデル自身のアカウントやキーで送られます。",
+    "The rules wait while you pick the model by hand.": "手動でモデルを選んでいる間、ルールは待機します。",
+    "Model every request goes to": "すべてのリクエストの送信先モデル",
+    "no provider serves it now": "現在使えるプロバイダーなし",
+    "Every request goes to {name}": "すべてのリクエストを {name} に送信中",
+    "Send every request to {name}": "すべてのリクエストを {name} に送る",
+    "{name}: every request to {model}": "{name}：すべてのリクエストを {model} へ",
+    "Click to fold it": "クリックで折りたたむ",
+    "Save or Cancel your changes first": "未保存の変更があります。先に保存かキャンセルをしてください",
+    "found by magpie — saving a change makes it yours": "magpie が自動作成 — 変更を保存すると自分のグループになります",
+    "e.g. Opus anywhere": "例：Opus をどこでも",
+    "Agents pick it as {id}": "エージェントでは {id} として選びます",
+    "an agent set to {id} needs setting again": "{id} を選んでいるエージェントは設定し直しが必要です",
+    "The first answers for what the model can do. In order, they are tried top first.": "先頭のモデルがモデルの能力を決めます。順番モードでは上から順に試されます。",
+    "Rate limited to the back": "レート制限で最後尾へ",
+    "Its models too": "メンバーのモデルも",
+    "The group alone": "グループだけ",
+    "Its models unlisted": "メンバーは一覧に出さない",
+    "Agents' model lists and the gateway's /v1/models show the group and each of its models.": "エージェントのモデル一覧とゲートウェイの /v1/models に、グループとその各モデルが並びます。",
+    "Agents' model lists and the gateway's /v1/models show the group, not the models it names or its patterns match: they are used through it. Codex keeps its ChatGPT sign-in's own models. A request naming one is still answered.": "エージェントのモデル一覧とゲートウェイの /v1/models にはグループだけが並び、指定したモデルやパターンに合うモデルは出ません。これらはグループを通して使われます。Codex にはサインインしている ChatGPT アカウント自身のモデルが残ります。モデルを名指しするリクエストには引き続き応答します。",
+    "Slow to start": "応答開始が遅いとき",
+    "Every member busy": "全メンバーが混雑",
+    "When every member has failed with an error that may pass — overloaded, unavailable, rate limited for a moment — and nothing of the reply has reached the agent, each is asked again after a pause, longer each time and never shorter than the vendor asks, for up to {n} more. A streaming agent is kept waiting meanwhile.": "すべてのメンバーが一時的なエラー（過負荷、利用不可、短時間のレート制限）で失敗し、応答がまだエージェントに何も届いていないときは、少し待ってから各メンバーに順に聞き直します。待ち時間は回ごとに長くなり、ベンダーが求める待ち時間より短くはなりません。さらに最大 {n} まで続けます。ストリーミングのエージェントはその間待たせたままにします。",
+    "When every member has failed, the agent gets the last one's error at once.": "すべてのメンバーが失敗したら、最後のメンバーのエラーをすぐエージェントに返します。",
+    "{who} answered {status} · {fail}, and every member had failed with an error that may pass, so after {d} the {n} of them are asked again, in turn, before any of the reply reaches {agent}. The group waits up to {p} for one to answer.": "{who} は {status} · {fail} を返し、すべてのメンバーが一時的なエラーで失敗したため、{d} 後にその {n} 件に順に聞き直します。応答はまだ {agent} に何も届いていません。グループはいずれかが答えるまで最大 {p} 待ちます。",
+    "Largest model's": "最大のモデル",
+    "Smallest model's": "最小のモデル",
+    "{v} is not a number of minutes": "{v} は分数として正しくありません",
+    "Agents are told the group takes {n} tokens; a longer conversation still goes on to a member with room for it.": "エージェントにはこのグループのコンテキストを {n} トークンと伝えます。より長い会話は収まるメンバーに回されます。",
+    "Agents are told {n} tokens, its smallest model's, so they compact before any member would turn the conversation away.": "エージェントには最小モデルの {n} トークンを伝えるので、どのメンバーにも断られる前に会話を圧縮します。",
+    "Agents are told its smallest model's window, so they compact before any member would turn the conversation away.": "エージェントには最小モデルのコンテキストを伝えるので、どのメンバーにも断られる前に会話を圧縮します。",
+    "Agents are told {n} tokens, its largest model's; a conversation too long for one member goes on to one with room for it.": "エージェントには最大モデルの {n} トークンを伝えます。あるメンバーに長すぎる会話は収まるメンバーに回されます。",
+    "Agents are told {n} tokens, its largest model's; a conversation longer than {m} skips {who} for a member with room for it.": "エージェントには最大モデルの {n} トークンを伝えます。{m} を超える会話は {who} を飛ばし、収まるメンバーに回されます。",
+    "Agents are told its largest model's window; a conversation too long for one member goes on to one with room for it.": "エージェントには最大モデルのコンテキストを伝えます。あるメンバーに長すぎる会話は収まるメンバーに回されます。",
+    "{v} is not a length of tokens like 200k or 1m": "{v} は 200k や 1m のようなトークン数ではありません",
+    "Every member is waited for, however long it takes to begin answering.": "どのメンバーも、応答を始めるまでどれだけかかっても待ちます。",
+    "A member that hasn't begun answering after {n} — no text, reasoning or tool call yet — is let go and the next one asked, before any of it reaches the agent. Let go once, it doesn't rest; let go twice in a row, its model rests on that account, a minute and longer each time, until it answers again. The last one left is always waited for. Only for streamed requests.": "{n} 経っても応答を始めない（テキスト、推論、ツール呼び出しがまだない）メンバーは、何もエージェントに届く前に打ち切られ、次のメンバーに問い合わせます。1 回なら休止しません。2 回続けば、そのアカウントでそのモデルが休止します。1 分から始まり、再び応答するまで毎回長くなります。最後に残ったメンバーは常に待ちます。ストリーミングリクエストのみ対象です。",
+    "Next after {n} without a first token": "最初のトークンが {n} なければ次へ",
+    "{who} hadn't begun answering after {ms}, so the request went on to the next before any of it reached {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} が {ms} 経っても応答を始めなかったため、{agent} に何も届く前にリクエストは次へ進みました。{who} に問題はないので、休止しません。",
+    "{who} hadn't begun answering after {ms}, {n} times in a row, so the request went on to the next before any of it reached {agent}. It rests {d} for {model} alone, longer each time it is slow again; its other models answer as before.": "{who} が {ms} 経っても応答を始めないことが {n} 回続いたため、{agent} に何も届く前にリクエストは次へ進みました。{model} についてだけ {d} 休止し、また遅ければ毎回長くなります。ほかのモデルはこれまでどおり応答します。",
+    "{who} was rate limited at {time} while it had quota left, so it went to the back: it comes round again once those ahead of it are rate limited in turn.": "{who} は {time} にクォータが残っているのにレート制限されたため、最後尾に回りました。前にあるものが順にレート制限されると再び回ってきます。",
+    "rate limited at {time} · at the back": "{time} にレート制限 · 最後尾",
+    "A group needs a model in it": "グループには少なくとも 1 つのモデルが必要です",
+    "Couldn't save the group: {error}": "グループを保存できませんでした：{error}",
+    "Add a rule": "ルールを追加",
+    "Add a condition": "条件を追加",
+    "Conversation length": "会話の長さ",
+    "Hours and days": "時間帯",
+    "Remove condition": "条件を削除",
+    "Actions for rule {n}": "ルール {n} の操作",
+    "Move rule {n}": "ルール {n} を移動",
+    "Pause the model instead": "代わりにモデルを一時停止",
+    "Send to the model instead": "代わりにモデルへ送信",
+    "Remove rule": "ルールを削除",
+    "It can pick the model too: add a rule with an intent": "モデルも選べます：インテント付きのルールを追加",
+    "in {folders}": "{folders} 内",
+    "The agent works in {folder}.": "エージェントの作業フォルダは {folder} です。",
+    "The agent works in one of these folders or a folder inside one, as it tells the model (Claude Code, Codex, OpenCode, Pi); an agent that doesn't say isn't matched": "エージェントがモデルに伝える作業フォルダ（Claude Code、Codex、OpenCode、Pi）がこれらのフォルダかその中にあるとき。伝えないエージェントは一致しません",
+    "Rule {n}: a folder is a whole path, like ~/work or /Users/me/work": "ルール {n}：フォルダは ~/work や /Users/me/work のような完全なパスで指定してください",
+    "The turn begins within these hours, in your time zone — a provider's peak-price hours sent to another, say": "ターンがこの時間帯（あなたのタイムゾーン）に始まったとき — たとえば、あるプロバイダのピーク料金の時間帯を別のプロバイダへ送るなど",
+    "{hours} ({zone})": "{hours}（{zone}）",
+    "{zone} time": "{zone} 時間",
+    "server time, {offset}": "サーバー時刻 {offset}",
+    "weekends": "週末",
+    "{from}–{to}": "{from}–{to}",
+    "{hours} {days}": "{days} {hours}",
+    "runs past midnight, into the next day": "深夜 0 時をまたいで翌日まで",
+    "Rule {n}: the hours are two times like 09:00 and 18:00": "ルール {n}：時間帯は 09:00 と 18:00 のように 2 つの時刻で指定してください",
+    "Rule {n}: its hours are the whole day — pick days, or other hours": "ルール {n}：時間帯が終日になっています。曜日を選ぶか、別の時間帯にしてください",
+    "The agent summarizes the conversation to go on in less room (Claude Code's /compact, Codex, OpenCode…): a cheaper, faster model can do it": "エージェントが会話を要約して使う領域を減らします（Claude Code の /compact、Codex、OpenCode…）。安くて速いモデルに任せられます",
+    "longer conversations skip it: it takes {n} tokens": "これより長い会話はスキップします：コンテキストは {n} トークンです",
+    "The agent is compacting the conversation, so rule {n} sends the summary to {use}; the conversation stays on the model it was on.": "エージェントが会話をコンパクト化しているため、ルール {n} が要約を {use} に送ります。会話自体は元のモデルのままです。",
+    "Passed over, as the conversation is longer than they take: {models}.": "会話がコンテキストより長いためスキップしました：{models}。",
+    "reasoning ≥ {level}": "推論 ≥ {level}",
+    "not a condition": "条件にしない",
+    "thinking or any effort level": "thinking または任意の推論レベル",
+    "it doesn't take images": "画像に対応していません",
+    "it takes {n} tokens": "コンテキストは {n} トークンです",
+    "≥ {n} tokens": "≥ {n} トークン",
+    "1 rule": "1 件のルール",
+    "{n} rules": "{n} 件のルール",
+    "Rule {n} has no condition. Add one with its +, or remove the rule from its ⋯ menu": "ルール {n} に条件がありません。+ で追加するか、⋯ メニューからこのルールを削除してください",
+    "This rule has no condition. Add one with its +, or remove the rule from its ⋯ menu": "このルールには条件がありません。+ で追加するか、⋯ メニューからこのルールを削除してください",
+    "goes first; the others stay behind it": "最初に送信し、ほかはその後ろで控える",
+    "left out of the group: not tried, not a fallback": "グループから外す：使われず、フォールバックにもならない",
+    "left out of the group then: not tried, not a fallback": "この間はグループから外す：使われず、フォールバックにもならない",
+    "not in {folders}": "{folders} 以外",
+    "not in folder": "除外フォルダ",
+    "The agent works in none of these folders, nor a folder inside one, as it tells the model; an agent that doesn't say counts as outside them": "エージェントがモデルに伝える作業フォルダが、これらのフォルダでもその中でもないとき。伝えないエージェントはフォルダの外として扱います",
+    "The agent didn't say which folder it works in.": "エージェントは作業フォルダを伝えていません。",
+    "Rule {n}: a pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "ルール {n}：一時停止には時間帯、曜日、エージェント、またはフォルダが必要です。+ で追加するか、⋯ メニューからこのルールを削除してください",
+    "A pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "一時停止には時間帯、曜日、エージェント、またはフォルダが必要です。+ で追加するか、⋯ メニューからこのルールを削除してください",
+    "{model} is paused by rule {n} ({when}), so it is left out until that ends.": "{model} はルール {n}（{when}）で一時停止中のため、終わるまで使われません。",
+    "{model} is paused by rule {n} of {group} ({when}), so it is left out until that ends.": "{model} は {group} のルール {n}（{when}）で一時停止中のため、終わるまで使われません。",
+    "asks for “{intent}”": "インテントが「{intent}」",
+    "what it asks for, e.g. writing tests": "何をしたいか（例：テストを書く）",
+    "Intent told by": "インテント判定",
+    "choose a model": "モデルを選択",
+    "As a turn begins, this model is asked which of the intents the message is — once; a small, fast one without reasoning is best. If it fails or can't say, no intent matches. Its calls show in the usage as magpie’s own.": "ターンの開始時に、メッセージがどのインテントに当たるかをこのモデルに 1 回尋ねます。推論なしの小さく速いモデルが最適です。失敗したり答えられなかったりした場合は、どのインテントにも一致しません。その呼び出しは使用量に magpie 自身のものとして表示されます。",
+    "Choose the model that tells which intent a message is": "メッセージのインテントを判定するモデルを選んでください",
+    "A routing group classifies as any request to it goes: if its first model fails, the next is asked.": "ルーティンググループが分類する場合も、それへのリクエストと同じく、最初のモデルが失敗すれば次のモデルに尋ねます。",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so no rule with an intent matches it.": "{by} はターン {turn} が {kinds} のどれかを判定するはずでしたが、できませんでした（{err}）。そのため、インテントを含むルールは一致しません。",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so the turn keeps “{intent}”, as turn {prev} was.": "{by} はターン {turn} が {kinds} のどれかを判定するはずでしたが、できませんでした（{err}）。そのため、ターン {prev} と同じ「{intent}」のままにします。",
+    "{by} was asked which of {kinds} turn {turn} is, and said none ({took}).": "{by} にターン {turn} が {kinds} のどれかを尋ねたところ、どれでもないと答えました（{took}）。",
+    "{by} was asked which of {kinds} turn {turn} is, and answered “{said}”, which is no rule's intent ({took}).": "{by} にターン {turn} が {kinds} のどれかを尋ねたところ「{said}」と答えましたが、これはどのルールのインテントでもありません（{took}）。",
+    "{by} was asked which of {kinds} turn {turn} is, and said “{intent}” ({took}).": "{by} にターン {turn} が {kinds} のどれかを尋ねたところ、「{intent}」と答えました（{took}）。",
+    "It was told turn {prev} was “{after}”, which a message that only carries on from it is too.": "ターン {prev} が「{after}」だったことも伝えています。それを続けるだけのメッセージも同じ扱いです。",
+    "{by} was to rate how hard turn {turn} is, but couldn't — {err} — so it reasons as the agent asked.": "{by} はターン {turn} の難しさを評価するはずでしたが、できませんでした（{err}）。そのため、エージェントの指定どおりに推論します。",
+    "{by} wasn't asked how hard turn {turn} is: the group above picked {level} reasoning for it.": "{by} にはターン {turn} の難しさを尋ねていません。上位のグループがこのターンの推論に {level} を選んだためです。",
+    "{by} rated turn {turn} {score} of 3, so it picks {level} reasoning for the turn — each model gets the level it has nearest.": "{by} がターン {turn} の難しさを 3 段階中 {score} と評価したため、このターンは {level} の推論を選びます。各モデルは最も近いレベルを使います。",
+    ", {n} sure": "、確度 {n}",
+    "Decided by": "判定モデル",
+    "at {level} reasoning": "{level} の推論で",
+    "The turn's pick replaced the {asked} {agent} asked for.": "このターンの判定で選ばれたもので、{agent} が指定した {asked} を置き換えました。",
+    "{level} is the model's nearest to the {asked} {agent} asked for.": "{level} は {agent} が指定した {asked} に最も近いモデルのレベルです。",
+    "{level} reasoning, picked for the turn; {agent} asked for {asked}": "{level} の推論、このターン用に選択。{agent} の指定は {asked}",
+    "{level} reasoning, picked for the turn": "{level} の推論、このターン用に選択",
+    "{level} reasoning, fixed on this model in the group; {agent} asked for {asked}": "{level} の推論、グループでこのモデルに固定。{agent} の指定は {asked}",
+    "{level} reasoning, fixed on this model in the group": "{level} の推論、グループでこのモデルに固定",
+    "{level} reasoning, set by the rule; {agent} asked for {asked}": "{level} の推論、ルールで指定。{agent} の指定は {asked}",
+    "{level} reasoning, set by the rule": "{level} の推論、ルールで指定",
+    "The rule asks this model for {level} reasoning, in place of the {asked} {agent} asked for.": "ルールがこのモデルに {level} の推論を指定しているため、{agent} が指定した {asked} の代わりに使います。",
+    "As the agent asks": "エージェントの指定どおり",
+    "the rule sets none": "ルールでは指定しない",
+    "The rule asks the model for {level} reasoning whatever the agent asks, at the model's nearest level; a model whose levels aren't known is asked as the agent asked": "エージェントの指定にかかわらず、ルールはこのモデルに {level} の推論を求めます（モデルの最も近いレベル）。レベルが不明なモデルはエージェントの指定どおり",
+    "Set its reasoning": "推論を指定",
+    "Change its reasoning": "推論を変更",
+    "The group fixes this model at {fixed} reasoning, in place of the {asked} {agent} asked for.": "グループがこのモデルを {fixed} の推論に固定しているため、{agent} が指定した {asked} の代わりに使います。",
+    "{level} reasoning": "{level} の推論",
+    "Group's reasoning": "グループの推論",
+    "Follows {name}": "{name} に従う",
+    "Its models reason as {name} says: set that up on {name}'s own card, not here": "そのモデルは「{name}」の推論レベルに従います。変更は「{name}」のカードで行ってください",
+    "Sent at {level} reasoning whatever the agent asks, at the model's nearest level": "エージェントの指定にかかわらず {level} の推論で送ります（モデルの最も近いレベル）",
+    "Reasons as the group's effort says": "グループの推論レベルに従います",
+    "Follow the group": "グループに従う",
+    "Several levels…": "複数のレベル…",
+    "Mapped reasoning": "推論レベルを対応付け",
+    "Sent {pairs}; other levels as asked": "{pairs} で送信し、他のレベルは要求どおり",
+    "Map levels…": "レベルを対応付け…",
+    "a level in place of the one asked": "要求されたレベルの代わりに別のレベル",
+    "As asked": "要求どおり",
+    "the agent picks among them": "エージェントがその中から選びます",
+    "The agent picks among {levels} reasoning, each sent at the model's nearest level": "エージェントが {levels} の推論から選び、それぞれモデルの最も近いレベルで送ります",
+    "{name} at that reasoning is in the group already": "この推論レベルの {name} はすでにグループにあります",
+    "Standard speed": "標準速度",
+    "Sent in its vendor's fast mode whatever the agent asks: quicker, at a higher price": "エージェントの指定にかかわらず、ベンダーの高速モードで送ります。速くなりますが、料金は高くなります",
+    "Sent at its vendor's usual speed; click to send it in fast mode": "ベンダーの通常速度で送ります。クリックすると高速モードで送ります",
+    "Asked for OpenAI's fast mode (service_tier \"priority\") whatever the agent asks: quicker, at a higher price, where your provider serves it. One that turns it away is asked without it": "エージェントの指定に関わらず、OpenAI の高速モード（service_tier \"priority\"）を求めます。プロバイダーが対応していれば速く、料金は高めです。このフィールドを拒否するプロバイダーには、外して送り直します",
+    "Sent as the agent asks; click to ask your provider for OpenAI's fast mode (service_tier \"priority\")": "エージェントの指定どおりに送ります。クリックすると、プロバイダーに OpenAI の高速モード（service_tier \"priority\"）を求めます",
+    "Off: kept in its place, sent nothing. Click to switch it on": "オフ：位置は維持し、何も送りません。クリックでオン",
+    "On: requests may go to it. Click to switch it off and keep its place": "オン：リクエストが送られることがあります。クリックで位置を維持したままオフ",
+    "Sent in its vendor's fast mode, as the group says": "グループの設定どおり、ベンダーの高速モードで送ります",
+    "{level} reasoning: the model's nearest to the {asked} {agent} asked for": "{level} の推論：{agent} が指定した {asked} に最も近いモデルのレベル",
+    "{level} reasoning, as {agent} asked": "{level} の推論（{agent} の指定どおり）",
+    "Jev is asked once as each turn begins, with the message and what it said of the turn before. Its calls show in the usage as magpie’s own.": "Jev にはターンの開始時に 1 回、メッセージと前のターンについての判定を添えて尋ねます。その呼び出しは使用量に magpie 自身のものとして表示されます。",
+    "Picked per turn": "ターンごとに選択",
+    "Choose the model that rates how hard a turn is": "ターンの難しさを評価するモデルを選んでください",
+    "Turn {turn} reasons at {level}, as the classifier picked when it began.": "ターン {turn} は {level} で推論します。ターン開始時に分類モデルが選んだものです。",
+    "As a turn begins, the classifier rates how hard it is and the turn's requests ask their model for low, medium, high or xhigh reasoning — the level each model has nearest. Only where the agent asked for reasoning: a request without any (a session title) stays without.": "ターンの開始時に分類モデルがその難しさを評価し、そのターンのリクエストはモデルに low、medium、high、xhigh のいずれかの推論（各モデルの最も近いレベル）を求めます。エージェントが推論を求めた場合のみで、推論のないリクエスト（セッションタイトルなど）はそのままです。",
+    "As a turn begins, this model is asked how hard the turn is — once; a small, fast one without reasoning is best. If it fails or can't say, the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "ターンの開始時に、そのターンの難しさをこのモデルに 1 回尋ねます。推論なしの小さく速いモデルが最適です。失敗したり答えられなかったりした場合は、エージェントの指定どおりに推論します。その呼び出しは使用量に magpie 自身のものとして表示されます。",
+    "As a turn begins, this model is asked which of the intents the message is and how hard the turn is, each once; a small, fast one without reasoning is best. If it can't say, no intent matches and the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "ターンの開始時に、メッセージがどのインテントに当たるかと、ターンの難しさを、それぞれ 1 回このモデルに尋ねます。推論なしの小さく速いモデルが最適です。答えられない場合は、どのインテントにも一致せず、エージェントの指定どおりに推論します。その呼び出しは使用量に magpie 自身のものとして表示されます。",
+    "Each request reasons as much as the agent asked.": "各リクエストはエージェントの指定どおりに推論します。",
+    "Its models' shared": "メンバー共通",
+    "Agents are offered the levels every model has: {levels}.": "エージェントには、すべてのモデルにあるレベルを提示します：{levels}。",
+    "Agents are offered the levels every model has.": "エージェントには、すべてのモデルにあるレベルを提示します。",
+    "Agents are offered these. A model without the level asked is sent the one it has nearest.": "エージェントにはこれらを提示します。指定されたレベルがないモデルには、最も近いレベルで送ります。",
+    "Pick a level to offer, or leave them to its models": "提示するレベルを選ぶか、モデルに任せてください",
+    "As a turn begins, Jev is asked once which of the intents the message is, and how hard the turn is when it picks the effort. An intent it isn't sure of matches no rule. Its calls show in the usage as magpie’s own.": "ターンの開始時に、メッセージがどのインテントに当たるかと、推論レベルを選ぶ場合はターンの難しさを、Jev に 1 回尋ねます。確信のないインテントはどのルールにも一致しません。その呼び出しは使用量に magpie 自身のものとして表示されます。",
+    "It was told turn {prev} reasoned at {level}, which a message that only carries on from it needs too.": "ターン {prev} が {level} で推論したことも伝えています。それを続けるだけのメッセージも同じだけ必要です。",
+    "Add an example rule": "例のルールを追加",
+    "planning, design, or a hard problem to think through": "計画、設計、またはじっくり考える必要がある難問",
+    "With two models or more, a rule can send some turns to one of them first.": "2 つ以上のモデルがあれば、ルールで一部のターンをそのうちの 1 つへ優先して送れます。",
+    "Checked top first when you send a message: the first that matches sends that turn to its model first; the rest stay behind it if it fails. A turn under way is never moved.": "メッセージを送るたびに上から確認します。最初に一致したルールがそのターンを指定モデルへ優先して送り、失敗した場合は残りが後に控えます。進行中のターンが移されることはありません。",
+    "Rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "ルール {n}（{when}）がターン {turn} の開始時にそれを {use} へ送りました。このターンはそのとき引き受けたモデルのままです。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; if it fails, {then}, which the rules after it that match too name, then the group's others.": "ターン {turn} が始まり、ルール {n} に一致しました（{when}）。そのため {use} が先頭です。失敗した場合は、同じく一致した後続のルールが指定する {then}、次にグループの他のメンバーに移ります。",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "ルール {n} に一致しましたが、{use} にはこのリクエストを受けられるアカウントやキーがないため、後に一致したルールが {instead} を先頭にします。",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "{group} で、ルール {n} に一致しましたが、{use} にはこのリクエストを受けられるアカウントやキーがないため、後に一致したルールが {instead} を先頭にします。",
+    "Remove {name} from this rule": "このルールから {name} を外す",
+    "Add a model it goes to next": "次に使うモデルを追加",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first.": "ルール {n} に一致しましたが、{use} にはこのリクエストを受けられるアカウントやキーがないため、このルールの次のモデル {instead} が先頭です。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first, then {more}, which the rule names after it; the later rules' and the group's others stay behind them.": "ターン {turn} が始まり、ルール {n} に一致しました（{when}）。そのため {use} が先頭で、次にこのルールの {more} が続きます。後のルールとグループの他のメンバーはその後に控えます。",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first there.": "{group} で、ルール {n} に一致しましたが、{use} にはこのリクエストを受けられるアカウントやキーがないため、このルールの次のモデル {instead} がそこで先頭です。",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; the group's others stay behind it if it fails.": "ターン {turn} が始まり、ルール {n} に一致しました（{when}）。そのため {use} が先頭です。失敗した場合はグループの他のメンバーが後に控えます。",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so the group's order stands.": "ルール {n} に一致しましたが、{use} にはこのリクエストを受けられるアカウントやキーがないため、グループの順番のままです。",
+    "This turn began before magpie saw it, so the rules wait for the next one.": "このターンは magpie が認識する前に始まったため、ルールは次のターンまで待ちます。",
+    "No rule matches turn {turn} (about {n} tokens{img}).": "ターン {turn} に一致するルールはありません（約 {n} トークン{img}）。",
+    "the group {name}": "グループ {name}",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {group}'s order stands.": "{group} で、ルール {n} に一致しましたが、{use} にはこのリクエストを受けられるアカウントやキーがないため、{group} の順番のままです。",
+    "In {group}, rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "{group} で、ルール {n}（{when}）がターン {turn} の開始時にそれを {use} へ送りました。このターンはそのとき引き受けたモデルのままです。",
+    "In {group}, rule {n} matches — {when} — so {use} goes first there.": "{group} で、ルール {n} に一致しました（{when}）。そのため、そこでは {use} が先頭です。",
+    "In {group}, no rule matches.": "{group} では、一致するルールはありません。",
+    "In {group}: {text}": "{group} で：{text}",
+    "{who} is one of {path}, a group in {name}; that group routes {mode}.": "{who} は {name} 内のグループ {path} のメンバーです。そのグループは「{mode}」でルーティングします。",
+    ", with an image": "、画像あり",
+    "Within turn {turn} the conversation grew to about {tokens} tokens, more than the model it was on takes, so rule {n} ({when}) moves it to {use}.": "ターン {turn} の中で会話が約 {tokens} トークンまで増え、使っていたモデルの上限を超えたため、ルール {n}（{when}）が {use} に移します。",
+    "{who} answered this conversation last, but a new turn begins and the group's rule {n} puts {use} first.": "この会話に前回応答したのは {who} ですが、新しいターンが始まり、グループのルール {n} が {use} を先頭にします。",
+    "Several accounts or keys": "複数のアカウントやキー",
+    "each provider routes over its own": "各プロバイダが自身のアカウントやキーでルーティング",
+    "Change how {name} routes": "{name} のルーティングを変更",
+    "Only one account or key is on for this, so routing has nothing to choose between. Turn on a second in the provider's editor, and how it routes is set under Several accounts or keys below.": "有効なアカウントやキーが 1 つだけなので、ルーティングに選択肢はありません。プロバイダの編集画面で 2 つ目を有効にすると、ルーティングは下の「複数のアカウントやキー」で設定できます。",
+    "Smart, over the members' accounts and keys together: of the subscriptions with quota to spare, the one whose allowance renews soonest goes first — the week decides, and an account with five hours and no week (Claude Enterprise) goes by its five hours, so ahead of every week renewing later; one resting after a failure goes last.": "スマート（メンバーのアカウントとキーをまとめて扱う）：クォータに余裕のあるサブスクリプションのうち、利用枠のリセットが最も早いものが先頭です。週の枠で判断し、5 時間枠のみで週の枠がないアカウント（Claude Enterprise）は 5 時間枠で判断するため、それより後にリセットされるどの週の枠よりも前になります。失敗後に休止中のものは最後です。",
+    "In order: the first model until it can't answer, then the next — each over its own accounts or keys as its provider routes them.": "順番：先頭のモデルが応答できなくなるまで使い、その後次へ。各モデルはそのプロバイダのルーティングに従って自身のアカウントやキーを使います。",
+    "In turn: each conversation's next turn goes to the next member's account or key, spreading the load.": "交互：各会話の次のターンを次のメンバーのアカウントやキーに送り、負荷を分散します。",
+    "Least used first: the account or key with the most of its allowance left goes first.": "使用量が最少を優先：利用枠の残りが最も多いアカウントやキーが先頭です。",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — its week at its reset, or credits in it that expire sooner — so less of each member's allowance is lost; an account with five hours and no week (Claude Enterprise) by what its five hours have left per hour until they renew, so almost always first; a key by the tokens magpie sent it lately.": "期限前に使い切る：失われるまでの 1 時間あたりの残りが最も多いアカウントが先頭になり、各メンバーの枠が失われる分が減ります — 週の枠はリセットで、それより早く期限切れになるクレジットはその期限で失われます。5 時間枠のみで週の枠がないアカウント（Claude Enterprise）は、リセットまでの 1 時間あたりの 5 時間枠の残りで判断するため、ほぼ常に先頭です。キーは magpie が最近送ったトークン数で判断します。",
+    "A group among the models, and a model whose provider routes its accounts or keys other than Smart, keeps its own routing: this group only picks between it and the others, weighing it by the account or key it would try first, then tries it whole in its own order. A group among the models left on Smart is routed as this group is, unless this one goes In order, By weight or Manual.": "モデルの中のグループと、プロバイダーのルーティングがスマート以外のモデルは、独自のルーティングを保ちます。このグループはそれと他のメンバーの間で選ぶだけで、そのグループが最初に試すアカウントやキーで比較し、選ばれたらそのグループ全体を独自の順番で試します。ルーティングをスマートのままにしたモデルの中のグループは、このグループのルーティングに従います。ただし、このグループが順番、重み付け、手動の場合を除きます。",
+    "errors your agent saw": "エージェントが受けたエラー",
+    "It said: {error}": "メッセージ：{error}",
+    "Copilot's Auto picked {model} ({via})": "Copilot の Auto が {model} を選択（{via}）",
+    "the model the account may pick by hand": "アカウントが手動で選べるモデル",
+    "not from /auto: {why}": "/auto からではない：{why}",
+    "sent to {api}": "{api} に送信",
+    "sent to {api} with Auto's session token": "{api} に送信（Auto のセッショントークン付き）",
+    "Copilot refused it: {error}": "Copilot に拒否されました：{error}",
+    "Show the latest request that failed": "最後に失敗したリクエストを表示",
+    "another account's reasoning": "別のアカウントの推論",
+    "reply too short": "応答が短すぎる",
+    "reply asked past the window left": "応答上限が残りのコンテキストを超過",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} が {status} を返しました：ベンダーはどのアカウントでも {agent} のシステムプロンプトを拒否するため、応答が {agent} に届く前に次へ進みます。{who} に問題はないので休止しません。",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, and nobody else is left to try, so {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who} が {status} を返しました：ベンダーはどのアカウントでも {agent} のシステムプロンプトを拒否し、他に試せる相手もいないため、{agent} にエラーを返します。{who} に問題はないので休止しません。",
+    "request not understood": "リクエストを理解できない",
+    "images not taken": "画像を受け付けない",
+    "{who} answered {status}: it takes no images, so it is asked again with the images described by the image recognition model, before any of the reply reaches {agent}. Later requests to it are described first. Nothing is wrong with {who}, so it doesn't rest.": "{who} が {status} を返しました：画像を受け付けないため、画像認識モデルが画像を説明したうえで、応答が {agent} に届く前にもう一度尋ねます。以後のリクエストは先に画像を説明します。{who} に問題はないので休止しません。",
+    "reasoning effort not in its plan": "プランにない推論レベル",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, so another account goes on with it before any of the reply reaches {agent}. {who} serves other efforts, so it doesn't rest.": "{who} が {status} を返しました：そのプランは指定された推論レベルに対応していないため、応答が {agent} に届く前に別のアカウントが引き継ぎます。{who} は他の推論レベルには対応しているので、休止しません。",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, and no account left that does could answer, so {agent} gets an error saying so.": "{who} が {status} を返しました：そのプランは指定された推論レベルに対応しておらず、対応していて応答できるアカウントも残っていないため、{agent} にはその旨のエラーが返ります。",
+    "{who}: this computer had no network, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the network is back it is asked first again.": "{who}：このコンピュータがネットワークにつながっていなかったため、リクエストはベンダーに届かず次へ進みます。{who} に問題はないので休止しません。ネットワークが戻れば、再び最初に問い合わせます。",
+    "{who}: this computer had no network, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who}：このコンピュータがネットワークにつながっていなかったため、リクエストはベンダーに届かず、ほかに試せる相手もいないので {agent} にエラーが返ります。{who} に問題はないので休止しません。",
+    "network down": "ネットワークなし",
+    "servers overloaded": "サーバー過負荷",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the proxy is up it is asked first again.": "{who}：magpie が経由するプロキシが接続を受け付けなかったため、リクエストはベンダーに届かず次へ進みます。{who} に問題はないので休止しません。プロキシが復旧すれば、再び最初に問い合わせます。",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Start the proxy, or change it in Settings.": "{who}：magpie が経由するプロキシが接続を受け付けなかったため、リクエストはベンダーに届かず、他に試せるものも残っていないため {agent} にエラーが返ります。プロキシを起動するか、設定で変更してください。",
+    "{who} answered {status}: its API couldn't read something in the request that another's may, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} が {status} を返しました：その API はリクエストの一部を読めませんでしたが、他の API なら読める可能性があるため、応答が {agent} に届く前に次へ進みます。{who} に問題はないので休止しません。",
+    "{who}'s safety filter refused the request before saying anything, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} の安全フィルターが何も出力する前にリクエストを拒否したため、応答が {agent} に届く前に次へ進みます。{who} に問題はないので休止しません。",
+    "{who}'s safety filter refused the request before saying anything, and nobody is left to try, so {agent} gets an error saying so, not an empty reply to ask again for.": "{who} の安全フィルターが何も出力する前にリクエストを拒否し、他に試せるものも残っていないため、{agent} には再試行を招く空の応答ではなく、その旨のエラーが返ります。",
+    "The vendor wants the account verified first: it rests half an hour, or until you say it's verified": "ベンダーがまずアカウントの認証を求めています：30 分間、または認証済みと伝えるまで休止します",
+    "{who} answered {status}: the vendor wants the account verified before it serves it again, and nobody is left to try, so {agent} gets the error with how to verify it. For a minute {agent}'s retries get the same answer without asking the vendor.": "{who} が {status} を返しました。ベンダーは再び応答する前にアカウントの確認を求めており、他に試せる相手もいないため、{agent} には確認方法付きでこのエラーが届きます。1 分間、{agent} の再試行にはベンダーに問い合わせず同じ応答が返ります。",
+    "Verify the account ↗": "アカウントを確認 ↗",
+    "It's verified — try it again": "確認済み — もう一度試す",
+    "account restricted by the vendor": "ベンダーがアカウントを制限",
+    "The vendor restricted the account: it rests {d}, as only the vendor lifting the restriction brings it back. Appeal with the vendor; once it's lifted, try it again here": "ベンダーがこのアカウントを制限しました：制限を解除できるのはベンダーだけなので、{d} 休止します。ベンダーに異議を申し立て、解除されたらここでもう一度試してください",
+    "The restriction is lifted — try it again": "制限が解除された — もう一度試す",
+    "{who} turned away the reasoning effort changed mid-conversation as an update that keeps its cache, so it is asked again at the new effort the usual way, before any of the reply reaches {agent}.": "{who} は会話の途中で推理レベルをキャッシュを保つ「更新」として変更することを受け付けなかったため、通常の方法で新しい推理レベルで再度リクエストします。応答が {agent} に届く前に処理されます。",
+    "{who} takes no request for a reply as short as this one asked for, so it is asked again for the shortest it gives, before any of the reply reaches {agent}.": "{who} はこのリクエストほど短い応答長を受け付けないため、許容される最短の長さで再度リクエストします。応答が {agent} に届く前に処理されます。",
+    "{who} couldn't read the reasoning another account wrote earlier in this conversation, so it is asked again without it, before any of the reply reaches {agent}.": "{who} はこの会話で以前に別のアカウントが書いた推論を読めなかったため、それを除いて再度リクエストします。応答が {agent} に届く前に処理されます。",
+    "{agent} canceled the request while {who} was answering: nobody failed, so nobody rests and nobody else is asked.": "{who} の応答中に {agent} がリクエストをキャンセルしました。誰も失敗していないため、休止する相手も、他に問い合わせる相手もいません。",
+    "{who} answered {status} · {fail}, a failure that may pass. The conversation is kept on {who} for what its vendor cached of it, so it is asked once more in {d} before the request moves to another.": "{who} が {status} · {fail} を返しました。一時的な失敗の可能性があります。ベンダーがキャッシュした内容のため会話は {who} に保たれているので、{d} 後にもう一度問い合わせ、それでも失敗したら別の相手に移ります。",
+    "{who} answered {status} · {fail}, and nobody else is left to ask — a failure that may pass, so it is tried again in {d}, before any of the reply reaches {agent}.": "{who} が {status} · {fail} を返し、他に問い合わせる相手もいません。一時的な失敗の可能性があるため、{d} 後にもう一度試します。応答はまだ {agent} に届いていません。",
+    "{who} answered {status} · {fail}, and was to be asked again in {d}, but {agent} canceled the request before then, so nobody is asked again.": "{who} が {status} · {fail} を返し、{d} 後に再試行する予定でしたが、その前に {agent} がリクエストをキャンセルしたため、再試行しません。",
+    "Back to live": "ライブに戻る",
+    "Replay them all": "すべてリプレイ",
+    "Stop replay": "リプレイを停止",
+    "{n}× speed": "{n}× 速度",
+    "skipping a quiet stretch · clock {n}×": "静かな区間をスキップ · 時計 {n}×",
+    "request {i} of {n}": "リクエスト {i}/{n}",
+    "sent {time}": "送信 {time}",
+    "Replay from here": "ここからリプレイ",
+    "{n} on {day}": "{day}の {n} 件",
+    "the last {n} of {day}": "{day}の最後の {n} 件",
+    "How the last request was routed": "直近のリクエストのルーティング",
+    "How the request at {time} was routed": "{time} のリクエストのルーティング",
+    "No request yet": "まだリクエストがありません",
+    "Send one from any agent routed through magpie and it plays here as it happens: who routing put first and why, each try, and what each answered.": "magpie 経由でルーティングされる任意のエージェントからリクエストを送ると、ここでリアルタイムに再生されます。ルーティングが誰を最初にしたかとその理由、各試行、それぞれの応答。",
+    "Every request an agent sends to magpie shows up here, routed for real.": "エージェントが magpie に送るすべてのリクエストが、実際にルーティングされてここに表示されます。",
+    "Another magpie serves the gateway; its routing plays live in that magpie's window.": "ゲートウェイは別の magpie が提供しています。そのルーティングはその magpie のウィンドウでライブ再生されます。",
+    "The gateway isn't running, so nothing is routed.": "ゲートウェイが実行されていないため、何もルーティングされません。",
+    "The gateway is served by a magpie without a window (magpie serve), so its routing can't be watched. Stop it and let this magpie serve the gateway to see routing live.": "ゲートウェイはウィンドウのない magpie（magpie serve）が提供しているため、ルーティングを見ることができません。それを停止し、この magpie にゲートウェイを提供させるとルーティングをライブで見られます。",
+    "Smart: of the accounts with quota to spare, the one whose allowance renews soonest goes first — what it has left would be lost at the reset. The week decides; an account with five hours and no week goes by its five hours. One at 90% or more waits until the others can't answer; one resting after a failure goes last.": "スマート：クォータに余裕のあるアカウントのうち、利用枠が最も早く更新されるものが先です — 残りはリセット時に失われるためです。週の枠で決まり、5 時間枠だけで週の枠がないアカウントは 5 時間枠で決まります。90% 以上使ったアカウントは他が応答できなくなるまで待ち、失敗後に休止中のアカウントは最後になります。",
+    "Smart: keys that suit the request go first — one made for the model's own API — then in their order. One resting after a failure goes last.": "スマート：リクエストに合うキー — モデル本来の API 用のキー — が先で、その後は設定順です。失敗後に休止中のキーは最後になります。",
+    "In order: the first answers everything until it can't; then the next.": "順番：最初の 1 つが応答できなくなるまですべてに応答し、その後は次へ。",
+    "In turn: each conversation's next turn goes to the account after the one that answered its last, and a new conversation starts one further along; the requests within a turn stay put, keeping the prompt cache.": "交互：各会話の次のターンは前回応答したアカウントの次のアカウントへ、新しい会話はさらにその次から始まります。ターン内のリクエストは同じアカウントのままで、プロンプトキャッシュを保ちます。",
+    "Least used first: the account with the most of its allowance left goes first; a key by the tokens magpie sent it lately.": "使用量が最少：利用枠の残りが最も多いアカウントが先です。キーは magpie が最近送ったトークン数で決まります。",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — at its reset, or, when credits in it expire sooner, by those that expire first; an account with five hours and no week by what its five hours have left per hour. One at 90% or more waits until the others can't answer; a key by the tokens magpie sent it lately.": "期限前に使い切る：失われるまでの 1 時間あたりの残りが最も多いアカウントが先です — 残りはリセットで失われ、それより早く期限切れになるクレジットがあれば最初に期限切れになる分で決まります。5 時間枠だけで週の枠がないアカウントは 5 時間枠の 1 時間あたりの残りで決まります。90% 以上使ったアカウントは他が応答できなくなるまで待ち、キーは magpie が最近送ったトークン数で決まります。",
+    "Nothing could take {model}.": "{model} を処理できる相手がいませんでした。",
+    "{who} is the only one, so it's tried though it is resting.": "{who} しかいないため、休止中ですが試します。",
+    "{who} is the only account on for {model} — nothing to choose between.": "{model} で有効なアカウントは {who} だけです — 選ぶ余地はありません。",
+    "{name} has one key on — nothing to choose between.": "{name} で有効なキーは 1 つだけです — 選ぶ余地はありません。",
+    "Every one is resting after a failure, so {who}, first in line, is tried all the same.": "すべて失敗後の休止中のため、先頭の {who} をそのまま試します。",
+    "{name} is resting, so its fallback {fb} goes first.": "{name} は休止中のため、フォールバックの {fb} が先です。",
+    "In order: {who} is first, and answers everything while it can.": "順番：{who} が先頭で、応答できる限りすべてに応答します。",
+    "Until used up: one answers everything until its quota is used up; then the next, which keeps them even after the one before renews.": "使い切ってから次へ：1 つがクォータを使い切るまですべてに応答し、その後は次へ。前のものが回復しても次のものが続けます。",
+    "Until used up: one account or key, across the members, takes every request until it is used up; then the next in the list, which keeps them even after an earlier one renews. One rate limited or failing is passed over only while it rests.": "使い切ってから次へ：メンバー全体のアカウントやキーのうち 1 つが、使い切るまですべてのリクエストを受けます。その後はリストの次へ移り、前のものが回復してもそのまま続けます。レート制限やエラーのものは休止中だけ飛ばします。",
+    "Until used up: {who} is the one in use, and answers everything until it is used up.": "使い切ってから次へ：今使っているのは {who} で、使い切るまですべてに応答します。",
+    "In turn: it's {who}'s turn — each request starts one further along.": "交互：{who} の番です — 各リクエストは 1 つ先から始まります。",
+    "Least used first: {who} has the most of its allowance left — {n} used.": "使用量が最少：{who} は利用枠の残りが最も多いです — 使用済み {n}。",
+    "Least used first: {who} served the fewest tokens lately — {n}.": "使用量が最少：{who} は最近処理したトークンが最も少ないです — {n}。",
+    "Least used first: {who} goes first.": "使用量が最少：{who} が先です。",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} left, resets in {d}.": "期限前に使い切る：{who} はリセットまでの 1 時間あたりの残り利用枠が最も多いです — 残り {n}、{d} 後にリセット。",
+    "Use before expiry: {who} has the most remaining allowance per hour until one of its Codex resets about to run out is used by itself — {n} left, used in {d}.": "期限前に使い切る：{who} は、期限切れ間近の Codex リセットが自動で使われるまでの 1 時間あたりの残り利用枠が最も多いです — 残り {n}、{d} 後に使用。",
+    "Use before expiry: {who} has the most credits expiring per hour until they expire — {n} of its allowance expires in {d}.": "期限前に使い切る：{who} は期限切れまでの 1 時間あたりの期限切れ間近のクレジットが最も多いです — 枠の {n} が {d} 後に期限切れ。",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} used.": "期限前に使い切る：{who} はリセットまでの 1 時間あたりの残り利用枠が最も多いです — 使用済み {n}。",
+    "Use before expiry: {who} served the fewest tokens lately — {n}.": "期限前に使い切る：{who} は最近処理したトークンが最も少ないです — {n}。",
+    "Use before expiry: {who} goes first.": "期限前に使い切る：{who} が先です。",
+    "{who} goes first: it's made for {api}, the API {model} is at home in, so nothing is translated.": "{who} が先です：{model} 本来の API である {api} 用なので、変換は不要です。",
+    "{who} goes first: keys go in their order, those that suit the request first.": "{who} が先です：キーは設定順で、リクエストに合うものが先です。",
+    "{who} goes first.": "{who} が先です。",
+    "its provider is set to be used first.": "そのプロバイダが優先して使う設定です。",
+    "{who} goes first: its provider is set to be used first.": "{who} が先です：そのプロバイダが優先して使う設定です。",
+    "The vendor hasn't said yet what these accounts have left, so they go in their order: {who} first.": "ベンダーはこれらのアカウントの残りをまだ知らせていないため、設定順です：{who} が先頭。",
+    "Every account is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "すべてのアカウントが利用枠の 90% 以上を使っているため、残りが最も多いものが先です：{who}（{n}）。",
+    "Every key and account here is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "ここのキーとアカウントはすべて利用枠の 90% 以上を使っているため、残りが最も多いものが先です：{who}（{n}）。",
+    "{who} goes first: it has quota to spare, and the others are kept for last.": "{who} が先です：クォータに余裕があり、他のアカウントは最後に回します。",
+    "{who} goes first: of those with quota to spare, its allowance starts again soonest — one of its Codex resets about to run out is used by itself in {d}, and what it has left then is lost. {other} renews later and keeps its own.": "{who} が先です：クォータに余裕のあるアカウントのうち、利用枠が最も早く再開します — 期限切れ間近の Codex リセットの 1 つが {d} 後に自動で使われ、その時点の残りは失われます。{other} は更新が遅いので、自分の残りを保ちます。",
+    "{who} goes first: of those with quota to spare, its allowance renews soonest — in {d} — and what it has left then is lost. {other} renews later and keeps its own.": "{who} が先です：クォータに余裕のあるアカウントのうち、利用枠が最も早く — {d} 後に — 更新され、その時点の残りは失われます。{other} は更新が遅いので、自分の残りを保ちます。",
+    "{who} goes first: its allowance renews in the same hour as {other}'s, and its shorter one sooner — in {d}.": "{who} が先です：利用枠が {other} と同じ時間帯に更新され、短いほうの枠がより早く — {d} 後に — 更新されます。",
+    "{who} and {other} renew within the same hour, so the order given stays — and the vendor's prompt cache stays warm.": "{who} と {other} は同じ時間帯に更新されるため、設定順のままです — ベンダーのプロンプトキャッシュも温かいままです。",
+    "{who} goes first, in the order given: when its allowance renews isn't known.": "{who} が設定順で先です：利用枠がいつ更新されるか不明です。",
+    "{who} goes first: of those alike, its wallet has the most left — {n}, where {other} has {m}.": "{who} が先です：同じ種類のうち、ウォレットの残りが最も多いため — {n}、{other} は {m}。",
+    "{who} is resting — {why}, {when} — so it waits at the back.": "{who} は休止中です — {why}、{when} — そのため最後尾で待ちます。",
+    "{who} is at {n} — all but used up, it answers only when nothing else can.": "{who} は {n} — ほぼ使い切っており、他に応答できる相手がいないときだけ応答します。",
+    "{who} is at {n} — kept for when the others can't.": "{who} は {n} — 他が応答できないときのために取っておきます。",
+    "{member} isn't passed over for being near its limit: by weight this request was {first}'s share, and {member} takes its own share of the requests while it can answer.": "{member} は上限に近いからといって飛ばされません。重みにより今回のリクエストは {first} の番で、{member} も応答できる限り重みどおりの分を受け持ちます。",
+    "{member} isn't passed over for being near its limit: it comes after {first} in {group}'s order.": "{member} は上限に近いからといって飛ばされません。{group} の順番で {first} の後にあるだけです。",
+    "{who}: what it has left isn't known yet, so it goes after those known.": "{who}：残りがまだ不明なため、判明しているものの後になります。",
+    "{who}: what it has left isn't known yet, and its answer tells, so it goes before those known.": "{who}：残りがまだ不明で、応答すれば判明するため、判明しているものの前になります。",
+    "{who} goes first: what it has left isn't known yet, and its answer tells — kept behind those known, it would never answer and never be known.": "{who} が先です：残りがまだ不明で、応答すれば判明します — 判明しているものの後ろに置くと、応答する機会も判明する機会もありません。",
+    "{who} is left out: its plan doesn't list {model}.": "{who} は除外：そのプランは {model} を含みません。",
+    "{who} is left out: {name} lists {model} to its other keys, not this one.": "{who} は除外：{name} は {model} をこのキーではなく他のキーに割り当てています。",
+    "{who} is answering…": "{who} が応答中…",
+    "rerouted from {from}": "{from} から迂回",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the model of its latest chat turn, so it stays with the provider the chat is on.": "{agent} はツールなしの短いリクエスト（チャットのタイトルなど）に {model} を自分で選びました。magpie は {to}（直近のチャットのターンのモデル）で応答し、チャットと同じプロバイダーに留めました。",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the first model it lists, as it has had no chat turn yet.": "{agent} はツールなしの短いリクエスト（チャットのタイトルなど）に {model} を自分で選びました。まだチャットのターンがないため、magpie は {to}（一覧の最初のモデル）で応答しました。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model of its latest chat turn.": "{agent} は magpie が提供していない {model} をリクエストしました。magpie は {to}（直近のチャットのターンのモデル）で応答しました。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the first model it lists.": "{agent} は magpie が提供していない {model} をリクエストしました。magpie は {to}（一覧の最初のモデル）で応答しました。",
+    "Claude Code in {agent} asked for {model}, its own id for a Claude tier; magpie served it on {to}, the model picked for that tier.": "{agent} の Claude Code が Claude のティアの独自 id で {model} をリクエストしました。magpie は {to}（そのティアに選ばれたモデル）で応答しました。",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, that tier's model on the provider the chat is on.": "{agent} の Claude Code が自身の呼び出しに {model} をリクエストしました。magpie は {to}（チャットのプロバイダーにあるそのティアのモデル）で応答しました。",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, the chat's model, so it stays with the provider the chat is on.": "{agent} の Claude Code が自身の呼び出しに {model} をリクエストしました。magpie は {to}（チャットのモデル）で応答し、チャットと同じプロバイダーに留めました。",
+    "{agent}'s auto mode classifier asked for {model}; magpie served it on {to}, the model /model moved its tier to.": "{agent} の自動モードの分類器が {model} をリクエストしました。magpie は {to}（/model がそのティアを移したモデル）で応答しました。",
+    "{agent} asked for {model} by Claude's full id; magpie served it on {to}, the model set for that tier.": "{agent} が Claude の完全な id で {model} をリクエストしました。magpie は {to}（そのティアに設定されたモデル）で応答しました。",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model its config names.": "{agent} は magpie が提供していない {model} をリクエストしました。magpie は {to}（設定に書かれたモデル）で応答しました。",
+    "{agent} asked for {model} for a call of its own, which magpie doesn't serve; magpie served it on {to}, the model its last turn was answered on.": "{agent} は自身の呼び出しに magpie が提供していない {model} をリクエストしました。magpie は {to}（直前のターンに応答したモデル）で応答しました。",
+    "{agent} asked for {model}, one of its own default models, for its memories, and its config names no model for them; magpie served it on {to}, the model of its conversation.": "{agent} はメモリのために自身のデフォルトモデル {model} をリクエストしましたが、設定でメモリ用のモデルが指定されていません。magpie は {to}（会話のモデル）で応答しました。",
+    "Masking would have changed this request, so magpie sent it as written to {to}, the model set for that in Settings › Privacy.": "マスキングでこのリクエストが変わるため、magpie はそのまま {to}（設定 › プライバシーで指定されたモデル）に送りました。",
+    "magpie served it on {to} in place of {model}.": "magpie は {model} の代わりに {to} で応答しました。",
+    "Stand-in": "代替",
+    "{who} answered in {ms}{tk}. {agent} got one clean reply and never saw the {n} that failed first.": "{who} が {ms}{tk} で応答しました。{agent} にはクリーンな応答が 1 つ届き、先に失敗した {n} 件は見えていません。",
+    "{who} answered in {ms}{tk}.": "{who} が {ms}{tk} で応答しました。",
+    "{who} answered {status} · {fail}. {how}; the request goes on to {next} before any of the reply reaches {agent}.": "{who} が {status} · {fail} を返しました。{how}。応答が {agent} に届く前に、リクエストは {next} に回ります。",
+    "{who} answered {status} and nobody is left to try, so {agent} gets the error.": "{who} が {status} を返し、他に試せる相手がいないため、{agent} にエラーが届きます。",
+    "{who} answered {status} — an error another account wouldn't fix, so {agent} gets it.": "{who} が {status} を返しました — 別のアカウントでも解決しないエラーのため、{agent} に届きます。",
+    "{who} hadn't begun answering after {ms}, and nobody is left to try, so {agent} gets the error.": "{who} が {ms} 経っても応答を始めず、他に試せる相手がいないため、{agent} にエラーが届きます。",
+    "{who} answered {status} and nobody is left to try. {agent} gets the error an earlier try gave, not this used-up allowance, so it doesn't stop as if every account were out.": "{who} が {status} を返し、他に試せる相手がいません。{agent} に届くのはこの使い切った枠ではなく、それより前の試行のエラーなので、すべてのアカウントが尽きたかのように止まることはありません。",
+    "{who} answered {status}.": "{who} が {status} を返しました。",
+    "{who} answered {status}, and the request goes on to {next} before any of the reply reaches {agent}. {who} doesn't rest for it.": "{who} が {status} を返し、応答が {agent} に届く前に、リクエストは {next} に回ります。{who} はこれで休止しません。",
+    "{who} answered {status} · {fail}. {how}; nobody is left to try, so {agent} gets the error.": "{who} が {status} · {fail} を返しました。{how}。他に試せる相手がいないため、{agent} にエラーが届きます。",
+    "{who} began answering, then broke off · {fail}. {agent} got what was said before the error; {how}, so {agent}'s next request goes to another first.": "{who} は応答を始めましたが途中で切れました · {fail}。{agent} はエラー前の内容を受け取りました。{how}ため、{agent} の次のリクエストはまず別の相手に回ります。",
+    "{who} began answering, then broke off. {agent} got what was said before the error; the conversation isn't kept on {who} for its next request.": "{who} は応答を始めましたが途中で切れました。{agent} はエラー前の内容を受け取りました。この会話の次のリクエストは {who} に固定されません。",
+    "It rests {d}, as the vendor's Retry-After says": "ベンダーの Retry-After に従い {d} 休止します",
+    "It sits out half an hour, until someone tops it up": "誰かがチャージするまで 30 分休止します",
+    "Its allowance is used up: it rests until that renews, at {time}": "利用枠を使い切りました：{time} の更新まで休止します",
+    "It rests until {time}, when the vendor says the limit resets": "ベンダーが上限のリセットとする {time} まで休止します",
+    "It rests 15 minutes: out of quota, with no word of when it resets": "15 分休止します：クォータ切れで、リセット時刻の知らせがありません",
+    "It has failed {n} times in a row: it rests {d}, longer each time": "{n} 回連続で失敗しました：{d} 休止し、毎回長くなります",
+    "It rests {d}, longer if it fails again": "{d} 休止します。再び失敗するとさらに長くなります",
+    "It doesn't rest: its provider is set to ask it again after an error like this": "休止しません：このプロバイダーは、この種のエラーの後も次にそのまま尋ねる設定です",
+    "It rests {d}": "{d} 休止します",
+    "It cools down {d}: the vendor didn't say for how long": "{d} クールダウンします：ベンダーが期間を示しませんでした",
+    "It was rate limited again as soon as it was back ({n} times in a row): it rests {d}, longer each time until it answers": "復帰直後に再びレート制限されました（{n} 回連続）：{d} 休止し、応答するまで毎回長くなります",
+    "With {rested} resting after a failure, {who} goes first: ": "{rested} が失敗後に休止中のため、{who} が先です：",
+    "the others go in their order.": "他は設定順です。",
+    "In order: with {rested} resting after a failure, {who} is the first that can answer.": "順番：{rested} が失敗後に休止中のため、{who} が応答できる最初の相手です。",
+    "{agent} asked for {model}": "{agent} が {model} をリクエスト",
+    "Background memory task": "バックグラウンドのメモリタスク",
+    "Codex is organizing memories from earlier chats in the background. This can continue after a chat finishes.": "Codex がバックグラウンドで以前のチャットからメモリを整理しています。チャット終了後も続くことがあります。",
+    "Title requests were automatically matched using the prompt and the applied chat title.": "タイトルのリクエストは、プロンプトと適用されたチャットタイトルから自動で関連付けられました。",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it; other providers (such as Claude) are excluded regardless of quota.": "このサブエージェントのタスクは暗号化されています。読めるのは ChatGPT アカウントだけで、他のプロバイダ（Claude など）はクォータに関係なく除外されます。",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it.": "このサブエージェントのタスクは暗号化されています。読めるのは ChatGPT アカウントだけです。",
+    "{who} goes first: it answered the parent agent and may be needed to read this encrypted task.": "{who} が先です：親エージェントに応答しており、この暗号化されたタスクを読むのに必要な可能性があります。",
+    "{who} compacted this conversation natively, and only it can read that compaction, so the conversation stays on it: other accounts aren't asked. Start a new conversation to use them.": "{who} がこの会話をネイティブに圧縮しており、その圧縮を読めるのはこのアカウントだけなので、会話はここに留まり、他のアカウントには送られません。他のアカウントを使うには新しい会話を始めてください。",
+    "{agent} requested a subagent; magpie selects its model within this routing group.": "{agent} がサブエージェントをリクエストしました。モデルは magpie がこのルーティンググループ内で選びます。",
+    "{agent} requested a subagent on {model}.": "{agent} が {model} のサブエージェントをリクエストしました。",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents are set to {to}, but {why}.": "{agent} が {model} のサブエージェントをリクエストし、そのモデルのままになりました。サブエージェントは {to} に設定されていますが、{why}。",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model set for its subagents.": "{agent} が {model} のサブエージェントをリクエストしました。magpie はサブエージェント用に設定された {to} に切り替えました。",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model its lead is on.": "{agent} が {model} のサブエージェントをリクエストしました。magpie はリードが使っている {to} に切り替えました。",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents follow their lead, on {to}, but {why}.": "{agent} が {model} のサブエージェントをリクエストし、そのモデルのままになりました。サブエージェントはリードに合わせて {to} を使う設定ですが、{why}。",
+    "Background prompt suggestions": "バックグラウンドのプロンプト候補",
+    "magpie ran this web search for {agent}'s {model}, which can't search the web by itself: {searcher} searched, and {model} goes on answering once it has what was found. Not a turn of the conversation.": "magpie が、自分でウェブ検索できない {agent} の {model} のためにこのウェブ検索を実行しました。{searcher} が検索し、{model} は結果を受け取ってから応答を続けます。会話のターンではありません。",
+    "{agent} called magpie's web_search MCP tool: {searcher} searched for it. Not a turn of the conversation.": "{agent} が magpie の web_search MCP ツールを呼び出しました。{searcher} が代わりに検索しました。会話のターンではありません。",
+    "{agent} called magpie's analyze_image MCP tool: {describer} looked at the image for it. Not a turn of the conversation.": "{agent} が magpie の analyze_image MCP ツールを呼び出しました。{describer} が代わりに画像を見ました。会話のターンではありません。",
+    "magpie ran this web search for a model that can't search the web by itself: {searcher} searched, and that model goes on answering once it has what was found. Not a turn of the conversation.": "magpie が自分でウェブ検索できないモデルのためにこのウェブ検索を実行しました。{searcher} が検索し、そのモデルは結果を受け取ってから応答を続けます。会話のターンではありません。",
+    "Every turn starts with a request to {name}, a subscription: it counts against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "各ターンはサブスクリプション {name} へのリクエスト 1 件から始まります。エージェント自身のリクエストと同じくその枠に数えられます。無料のモデルか API キーのモデルにすると、サブスクリプションはエージェントだけが使います。",
+    "Every turn starts with two requests to {name}, a subscription: they count against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "各ターンはサブスクリプション {name} へのリクエスト 2 件から始まります。エージェント自身のリクエストと同じくその枠に数えられます。無料のモデルか API キーのモデルにすると、サブスクリプションはエージェントだけが使います。",
+    "magpie had {describer} describe an image for {agent}'s {model}: nothing magpie knows says {model} can see images, so it is counted as text-only and given the description in the image's place. If it does see them, tick “Accepts images” for it in its provider's models. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie は {agent} の {model} のために {describer} に画像を説明させました。{model} が画像を見られると示す情報を magpie は持っていないため、テキストのみのモデルとして扱い、画像の代わりにその説明を渡しています。実際に画像を見られる場合は、プロバイダーのモデルで「画像入力に対応」をオンにしてください。説明するモデルは 設定 › モデル › 画像認識 で選べます。会話のターンではありません。",
+    "magpie had {describer} describe an image for {agent}'s {model}, which its provider's list or its own setting says takes text only: {model} is given the description in the image's place. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie は {agent} の {model} のために {describer} に画像を説明させました。プロバイダーのモデル一覧またはこのモデル自身の設定でテキストのみとされているため、{model} には画像の代わりにその説明が渡されます。説明するモデルは 設定 › モデル › 画像認識 で選べます。会話のターンではありません。",
+    "magpie had {describer} describe an image for a model that can't see images, which is given the description in the image's place. Not a turn of the conversation.": "magpie が画像を見られないモデルのために {describer} に画像を説明させ、そのモデルには画像の代わりにその説明が渡されます。会話のターンではありません。",
+    "{agent} drafted the suggested prompts on its home page by itself, in the background, searching the project's files and connected apps, and checked them for safety. Not a turn of the conversation; Codex's Settings › Configuration › Suggested prompts turns it off.": "{agent} がホーム画面のプロンプト候補をバックグラウンドで自ら作成し（プロジェクトのファイルや接続済みアプリを検索）、安全性をチェックしました。会話のターンではありません。Codex の 設定 › 構成 › Suggested prompts でオフにできます。",
+    "{agent} sent this turn on Luna Reserve, which it turns to once the plan's own allowance is used up; it picks the model itself.": "{agent} はこのターンを Luna Reserve で送信しました。プラン本来の利用枠を使い切ると Luna Reserve に切り替わり、モデルは自ら選びます。",
+    "{agent} made this call itself ({kind}), not as a turn of the conversation, and picks its model itself.": "これは {agent} 自身による呼び出し（{kind}）で、会話のターンではなく、モデルも自ら選びます。",
+    "{agent} checked that magpie answers, as it does when it starts and from its Test connection. It names this check's model itself, from the names in its model list ({model}), not the model chosen in the conversation, and only reads whether an answer comes back; magpie sends it to the model chosen in {agent}'s model menu, or to its first listed model when none is. Not a turn of the conversation.": "{agent} が magpie の応答を確かめるチェックです（起動時と Test connection で送られます）。このチェックのモデルはモデル一覧の名前から自分で選んだもの（{model}）で、会話で選んだモデルではなく、応答があるかだけを見ます。magpie はこれを {agent} のモデルメニューで選ばれたモデルへ、未選択なら一覧の先頭のモデルへ送ります。会話のターンではありません。",
+    "Nothing was tried: {error}": "何も試行されませんでした：{error}",
+    "{agent} asked for {model}: {name} serves it, and the vendor is asked for {sent}": "{agent} が {model} をリクエスト：{name} が提供し、ベンダーには {sent} をリクエスト",
+    "the last {n} the gateway keeps": "ゲートウェイが保持する直近 {n} 件",
+    "Accounts and keys": "アカウントとキー",
+    "over those requests": "これらのリクエストの集計",
+    "over today's requests": "今日のリクエストの集計",
+    "Nothing on {day}": "{day}はリクエストなし",
+    "No requests since magpie started": "magpie の起動以降リクエストはありません",
+    "Each request an agent sends through magpie shows up here: who answered it, why, and each try.": "エージェントが magpie 経由で送る各リクエストがここに表示されます：誰が応答したか、その理由、各試行。",
+    "Earlier ones are kept by day, in the bar above.": "それ以前のものは日ごとに保存され、上のバーから見られます。",
+    "Earlier days": "それ以前の日",
+    "tried {n}": "試行 {n}",
+    "answered {n}": "応答 {n}",
+    "last answered {time}": "最終応答 {time}",
+    "as of {time}": "{time} 時点",
+    "{n} used at {time}; it has renewed since": "{time} に {n} 使用済み。その後更新されました",
+    "routing…": "ルーティング中…",
+    "masking…": "マスク中…",
+    "back in {d}": "{d} 後に復帰",
+    "free · costs nothing": "無料 · 枠を消費しない",
+    "back at {time} · in {d}": "{time} に復帰 · あと {d}",
+    "its plan doesn't list {model}": "プランに {model} が含まれていません",
+    "set to serve other models, not {model}": "{model} ではなく他のモデル用に設定",
+    "{who} is left out: it is set to serve other models, not {model}.": "{who} は除外：{model} ではなく他のモデル用に設定されています。",
+    "held at its {cap}% usage cap": "使用量上限 {cap}% で停止中",
+    "request longer than its {n} window · passed over": "リクエストが {n} のコンテキストを超過 · スキップ",
+    "{who} is left out: this request is longer than its {n} context window, so it would only refuse it. It's asked only once every one with room is out of its allowance.": "{who} は除外：このリクエストは {n} のコンテキストウィンドウを超えており、送っても拒否されるだけです。余裕のあるものがすべて枠を使い切ったときだけ使われます。",
+    "not an account the gateway key may use": "ゲートウェイキーが使えるアカウントではありません",
+    "{who} is left out: the gateway key asking may not use its account.": "{who} は外されています：リクエストしたゲートウェイキーはそのアカウントを使えません。",
+    "{who} is left out: a usage window is used up, and the account is set not to spend its credits, so it counts as used up until that window renews.": "{who} は除外：使用量ウィンドウの 1 つを使い切り、アカウントはクレジットを使用しない設定のため、そのウィンドウが更新されるまで使い切ったものとみなします。",
+    "{who} is left out: a usage window is at {n}, past the {cap}% cap set on the account, so it counts as used up until that window renews.": "{who} は除外：使用量ウィンドウの 1 つが {n} で、アカウントに設定された上限 {cap}% を超えているため、そのウィンドウが更新されるまで使い切ったものとみなします。",
+    "{name}'s list for this key has no {model}": "{name} のこのキー用リストに {model} がありません",
+    "answering…": "応答中…",
+    "answering another request…": "別のリクエストに応答中…",
+    "answered this request": "このリクエストに応答",
+    "picked for “{intent}”": "インテント「{intent}」で選択",
+    "answered {agent}": "{agent} に応答",
+    "{n} agents at once": "{n} 個のエージェントが同時に送信中",
+    "In order: member by member, the first model the group names until it can't answer, each over its own accounts or keys as its provider routes them.": "順番：メンバーを 1 つずつ、グループが最初に挙げるモデルから、応答できなくなるまで使います。各メンバーはそのプロバイダのルーティングに従って自分のアカウントやキーに振り分けます。",
+    "{agent} asked for the routing group {name}: {members}": "{agent} がルーティンググループ {name} をリクエスト：{members}",
+    "Kept on {who}: it answered this conversation before, and affinity keeps a session with one account.": "{who} に固定：以前この会話に応答しており、アフィニティによってセッションは 1 つのアカウントに保たれます。",
+    "Kept on {who}: {agent} is handing back tool results within turn {n}, and moving now would lose what the vendor cached of it.": "{who} に固定：{agent} はターン {n} の中でツール結果を返しており、今切り替えるとベンダーがキャッシュした内容が失われます。",
+    "Kept on {who}: {d} ago the vendor read {r} tokens of this conversation from its cache and wrote {w} to it; anyone else would be sent them afresh and paid in full.": "{who} に固定：{d} 前にベンダーがこの会話の {r} トークンをキャッシュから読み、{w} トークンを書き込みました。他の相手に送ると新たに送信され、全額請求されます。",
+    "Turn {n} begins: in turn, it goes to the one after {who}, which answered the last turn — {next}.": "ターン {n} の開始：交互モードでは、前のターンに応答した {who} の次 — {next} に回ります。",
+    "Turn {n} begins: affinity keeps a conversation only within a turn, so routing decides afresh.": "ターン {n} の開始：アフィニティは 1 ターン内でのみ会話を保つため、ルーティングを新たに決めます。",
+    "{who} answered this conversation last, but it is resting, so the conversation moves.": "この会話に前回応答したのは {who} ですが、休止中のため会話は移ります。",
+    "{who} answered this conversation last, but its allowance is all but used up, so the conversation moves.": "この会話に前回応答したのは {who} ですが、利用枠をほぼ使い切っているため会話は移ります。",
+    "Every one here has used up its allowance and goes on on its credits, set to spend them only after everything else, so {who}, first in line, goes first.": "ここはすべて利用枠を使い切ってクレジットで続行中で、クレジットは最後に使う設定のため、先頭の {who} を先に試します。",
+    "{who} has used up its allowance and goes on on its credits, which it is set to spend only after everything else: it is tried after every other account, key and fallback.": "{who} は利用枠を使い切りクレジットで続行中ですが、クレジットは最後に使う設定のため、他のアカウント・キー・フォールバックのすべての後に試します。",
+    "{who} answered this conversation last, but it is on its credits now, set to spend them only after everything else, so the conversation moves to {first}.": "この会話に前回応答したのは {who} ですが、今はクレジットで続行中で、クレジットは最後に使う設定のため、会話は {first} に移ります。",
+    "{who} answered this conversation last, but it is no longer one to route to.": "この会話に前回応答したのは {who} ですが、もうルーティング対象ではありません。",
+    "{who} answered this conversation last, but the group goes in order and {first}, ahead of it, is ready again, so turn {n} goes back to {first}.": "この会話に前回応答したのは {who} ですが、このグループは順番どおりにルーティングし、その前にある {first} が再び使えるため、ターン {n} は {first} に戻ります。",
+    "{who}, a fallback, answered this conversation last, but the provider's own {first} is ready again, so turn {n} goes back to it.": "この会話に前回応答したのは代替の {who} ですが、プロバイダー自身の {first} が再び使えるため、ターン {n} はそちらに戻ります。",
+    "{who} took this conversation while {first}, listed ahead of it in the group, couldn't; {first} is ready again, so turn {n} goes back to it.": "この会話は、グループでその前にある {first} が受けられなかったため {who} が引き継ぎました。{first} が再び使えるため、ターン {n} はそちらに戻ります。",
+    "{who}, a fallback, answered this conversation last. The provider's own {first} is ready again, but Stays is Strict, which never moves a conversation, so it stays on the fallback; new conversations go to {first}.": "この会話に前回応答したのは代替の {who} です。プロバイダー自身の {first} は再び使えますが、維持が「厳格」で会話を移さないため、代替のままです。新しい会話は {first} に行きます。",
+    "{who} answered this conversation last, but the vendor then read only {r} tokens of it from its cache and wrote {w} — not worth staying for.": "この会話に前回応答したのは {who} ですが、そのときベンダーがキャッシュから読んだのは {r} トークン、書き込んだのは {w} トークンだけでした — 留まる価値はありません。",
+    "{who} answered this conversation {d} ago, longer than the 5 minutes a vendor keeps a prompt cached — so routing decides afresh.": "この会話に {who} が応答したのは {d} 前で、ベンダーがプロンプトをキャッシュする 5 分を超えています — そのためルーティングを新たに決めます。",
+    "Affinity is off: each request is routed afresh, whoever answered its conversation before.": "アフィニティはオフです：以前誰が会話に応答したかに関係なく、各リクエストを新たにルーティングします。",
+    "{status} · {fail} · passed to {agent}": "{status} · {fail} · {agent} に渡しました",
+    "{status} · {fail} · went on to the next": "{status} · {fail} · 次に回しました",
+    "{n} used · all but used up": "使用済み {n} · ほぼ使い切り",
+    "{n} used · kept for last": "使用済み {n} · 最後に回す",
+    "{n} used · renews in {d}": "使用済み {n} · {d} 後に更新",
+    "{n} left · all but used up": "残り {n} · ほぼ使い切り",
+    "Its allowance had just run out and it was refused, so it was asked again at once to spend its credits.": "利用枠を使い切った直後に拒否されたため、クレジットを使うようすぐにもう一度依頼しました。",
+    "{who} answered {status}: its allowance had just run out, but the account holds credits, which the vendor spends once the allowance is used up, so it is asked again at once, before any of the reply reaches {agent}.": "{who} は {status} を返しました。利用枠を使い切ったところですが、このアカウントにはクレジットがあり、利用枠を使い切るとベンダーはクレジットを使うため、応答が {agent} に届く前にすぐもう一度依頼します。",
+    "It holds credits, so it rests only {d} and its usage is read again, not until its allowance renews": "クレジットがあるため {d} だけ休み、使用量を読み直します。利用枠の回復までは待ちません",
+    "{who} is at {n} of its allowance but goes on on its credits — ahead of those used up with nothing to go on with, after those with allowance left.": "{who} は利用枠の {n} を使っていますが、クレジットで続けられます — 利用枠が残っているアカウントの後、使い切ってクレジットもないアカウントの前です。",
+    "{n} used · on credits": "{n} 使用 · クレジット利用",
+    "{n} left · on credits": "残り {n} · クレジット利用",
+    "{n} used · on credits · after the others": "{n} 使用 · クレジット利用 · 最後に試す",
+    "{n} left · on credits · after the others": "残り {n} · クレジット利用 · 最後に試す",
+    "Every account is all but used up, so {who} goes first: it goes on on its credits, which the vendor spends once its allowance is used up.": "どのアカウントも利用枠をほぼ使い切っているため、{who} が先頭です。利用枠を使い切るとベンダーがクレジットを使うので、続けられます。",
+    "{n} left · kept for last": "残り {n} · 最後に回す",
+    "{n} left · renews in {d}": "残り {n} · {d} 後に更新",
+    "renews in {d}": "{d} 後に更新",
+    "{n} used · renews in {d} · one renewing sooner goes first": "使用済み {n} · {d} 後に更新 · 先に更新されるアカウントを優先",
+    "{n} left · renews in {d} · one renewing sooner goes first": "残り {n} · {d} 後に更新 · 先に更新されるアカウントを優先",
+    "{n} used · conversation kept on another": "使用済み {n} · 会話は別のアカウントに固定",
+    "{n} left · conversation kept on another": "残り {n} · 会話は別のアカウントに固定",
+    "{n} left at {time}; it has renewed since": "{time} 時点で残り {n}。その後更新されました",
+    "what's left not known yet": "残りはまだ不明",
+    "{n} tokens lately": "最近 {n} トークン",
+    "first text in {ms}": "最初のテキストまで {ms}",
+    "requested {sent} · served {served}": "リクエスト {sent} · 応答 {served}",
+    "served {served}": "応答 {served}",
+    "Upstream: {upstream}": "上流：{upstream}",
+    "The aggregator passed the request on to {upstream}, as its reply says: the provider that actually answered it.": "アグリゲーターはこのリクエストを {upstream} に回したと応答に書いています。実際に応答したプロバイダーです。",
+    "{sent} is a routing group of the remote magpie, and it routed the request to {served}: the group picking one of its models, not the vendor swapping the model.": "{sent} はリモート magpie のルーティンググループで、リクエストを {served} にルーティングしました。グループがモデルを選んだもので、ベンダーがモデルを差し替えたのではありません。",
+    "The vendor was asked for {sent}, but its reply says {served} answered: likely another model. The same model under a dated name or spelled otherwise isn't marked.": "ベンダーには {sent} をリクエストしましたが、応答では {served} が答えたとあり、別のモデルに替えられた可能性があります。（同じモデルに日付が付いただけ、または表記が違うだけなら表示しません。）",
+    "ClinePass route {served}": "ClinePass ルート {served}",
+    "requested {sent} · ClinePass route {served}": "リクエスト {sent} · ClinePass ルート {served}",
+    "ClinePass answered {sent} through {served}, a route it picks itself: the name is the route's, not another model's.": "ClinePass は自ら選んだルート {served} で {sent} に応答しました。これはルートの名前で、別のモデルに替えられたわけではありません。",
+    "Its reply says {upstream} answered.": "応答では {upstream} が答えたとあります。",
+    "Its reply didn't say which provider answered.": "応答にはどのプロバイダーが答えたか書かれていません。",
+    "{pin} was asked for, but its reply didn't say which provider answered, so whether ClinePass kept to it is unknown.": "{pin} を指定しましたが、応答にはどのプロバイダーが答えたか書かれておらず、ClinePass がそれに従ったかは分かりません。",
+    "No provider was asked for, and its reply didn't say which one answered.": "プロバイダーは指定されておらず、応答にもどこが答えたか書かれていません。",
+    "{h} h {m} min": "{h} 時間 {m} 分",
+    "This routing group will no longer be available to agents.": "このルーティンググループはエージェントから利用できなくなります。",
+    "These routing groups will no longer be available to agents.": "これらのルーティンググループはエージェントから利用できなくなります。",
+    "magpie saved a report of where it held this request. If it keeps happening, send the report with yours.": "magpie はこのリクエストがどこで止まっていたかをレポートに保存しました。繰り返し起きる場合は、報告にこのレポートを添えてください。",
+    "Report copied": "レポートをコピーしました",
+    "Couldn't read the report: {error}": "レポートを読み込めませんでした：{error}",
+    "Open Folder": "フォルダを開く",
+    "not an account {group} may use": "{group} が使えるアカウントではありません",
+    "{who} is left out: the routing group {group} is held to other accounts of its provider.": "{who} は外されました：ルーティンググループ {group} はこのプロバイダーの別のアカウントだけを使います。",
+    "Requests to this group's models spend only the accounts picked here. A provider left on any of its accounts uses them all.": "このグループのモデルへのリクエストは、ここで選んだアカウントだけを使います。「どのアカウントでも」のままのプロバイダーは、すべてのアカウントを使います。",
+    "{n} of its accounts": "{n} 個のアカウント",
+    "Any of its accounts": "どのアカウントでも",
+    "This group spends only {accounts} of {provider}": "このグループは {provider} の {accounts} だけを使います",
+    "This group may spend every account of {provider}": "このグループは {provider} のすべてのアカウントを使えます",
+  },
+  de: {
+    "sign-in refused (answered since)": "Anmeldung abgelehnt (seitdem beantwortet)",
+    "Free first uses it before paid ones, and Cheapest first counts it as costing nothing": "„Kostenlos zuerst“ nutzt es vor bezahlten, „Günstigste zuerst“ zählt es als kostenlos",
+    "{name}, {n} accounts: {windows}": "{name}, {n} Konten: {windows}",
+    "What is left of this provider's accounts the group can use, together: amounts of one unit added up, a share the mean of the accounts on one plan. Each account is on the Usage page.": "Was von den Konten dieses Anbieters, die die Gruppe nutzen kann, zusammen übrig ist: Mengen derselben Einheit addiert, ein Anteil als Mittelwert der Konten mit demselben Tarif. Die einzelnen Konten stehen auf der Seite Nutzung.",
+    "Each session's context window": "Kontextfenster jeder Sitzung",
+    "Show this session's newest request": "Die neueste Anfrage dieser Sitzung zeigen",
+    "Its plugin sent this request itself, so magpie can't split its time": "Diese Anfrage hat die Erweiterung selbst gesendet, daher kann magpie ihre Zeit nicht aufschlüsseln",
+    "Claude Code sent this request itself, so magpie can't split its time": "Diese Anfrage hat Claude Code selbst gesendet, daher kann magpie ihre Zeit nicht aufschlüsseln",
+    "magpie is masking this request before routing it (Settings › Privacy), so who takes it isn't picked yet.": "magpie maskiert diese Anfrage vor der Weiterleitung (Einstellungen › Datenschutz), daher steht noch nicht fest, wer sie übernimmt.",
+    "magpie hasn't routed this request yet, so who takes it isn't picked yet.": "magpie hat diese Anfrage noch nicht weitergeleitet, daher steht noch nicht fest, wer sie übernimmt.",
+    "Nothing took this request: {error}": "Niemand hat diese Anfrage übernommen: {error}",
+    "{n} groups · {m} on": "{n} Gruppen · {m} an",
+    "Filter, or type an agent's name…": "Filtern oder Namen eines Agenten eingeben…",
+    "the name its User-Agent begins with": "der Name, mit dem sein User-Agent beginnt",
+    "heard from in the last 30 days": "in den letzten 30 Tagen gesehen",
+    "The subagent effort set in magpie is {effort}; the model's supported levels and a routing group's fixed member effort still apply.": "Der in magpie gesetzte Reasoning-Effort der Subagenten ist {effort}; die unterstützten Stufen des Modells und die feste Stufe eines Mitglieds der Routing-Gruppe gelten weiterhin.",
+    "{agent}'s call to magpie's web_search MCP tool": "den Aufruf von {agent} an magpies MCP-Werkzeug web_search",
+    "{agent}'s call to magpie's analyze_image MCP tool": "den Aufruf von {agent} an magpies MCP-Werkzeug analyze_image",
+    "a model that can't see images": "ein Modell, das keine Bilder sehen kann",
+    "{failed}, the Image recognition model picked in Settings › Models, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "{failed}, das unter Einstellungen › Modelle gewählte Bilderkennungsmodell, konnte kein Bild für {whom} beschreiben: {why}. Daher ließ magpie {describer}, das nächste nutzbare Modell, das Bilder sieht, es an seiner Stelle beschreiben. Keine Runde des Gesprächs.",
+    "{failed}, the model magpie picked to describe images, couldn't describe an image for {whom}: {why}. So magpie had {describer}, the next model it can use that sees, describe it in its place. Not a turn of the conversation.": "{failed}, das von magpie gewählte Modell zum Beschreiben von Bildern, konnte kein Bild für {whom} beschreiben: {why}. Daher ließ magpie {describer}, das nächste nutzbare Modell, das Bilder sieht, es an seiner Stelle beschreiben. Keine Runde des Gesprächs.",
+    "{agent}'s {model}": "{model} von {agent}",
+    "a model that can't search the web by itself": "ein Modell, das nicht selbst im Web suchen kann",
+    "{failed}, the searcher picked in Settings › Models › Web search, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "{failed}, der unter Einstellungen › Modelle › Websuche gewählte Sucher, hat nicht für {whom} gesucht: {why}. Daher ließ magpie {searcher}, den nächsten nutzbaren Sucher, an seiner Stelle suchen. Keine Runde des Gesprächs.",
+    "{failed}, the searcher magpie picked, didn't search for {whom}: {why}. So magpie had {searcher}, the next searcher it can use, search in its place. Not a turn of the conversation.": "{failed}, der von magpie gewählte Sucher, hat nicht für {whom} gesucht: {why}. Daher ließ magpie {searcher}, den nächsten nutzbaren Sucher, an seiner Stelle suchen. Keine Runde des Gesprächs.",
+    "By session": "Nach Sitzung",
+    "By key": "Nach Schlüssel",
+    "These requests came with no gateway key: from this computer, or from before magpie noted the key.": "Diese Anfragen kamen ohne Zugangsschlüssel: von diesem Computer oder von bevor magpie den Schlüssel vermerkte.",
+    "No session ID": "Keine Sitzungs-ID",
+    "{n} in progress": "{n} laufend",
+    "These requests did not provide a session ID; they are not treated as one conversation.": "Diese Anfragen enthielten keine Sitzungs-ID; sie werden nicht als eine Unterhaltung behandelt.",
+    "Estimated at effective model prices, including cache reads and writes; subscription billing may differ. Totals cover only the requests listed here.": "Geschätzt zu effektiven Modellpreisen, einschließlich Cache-Lesen und Cache-Schreiben; die Abrechnung im Abo kann abweichen. Summen umfassen nur die hier aufgeführten Anfragen.",
+    "No known price or token counts for this request": "Für diese Anfrage sind weder Preis noch Token-Zahlen bekannt",
+    "Drag to reorder — agents' model lists show the groups in this order · Alt+↑/↓ to move": "Ziehen zum Umsortieren — die Modelllisten der Agenten zeigen die Gruppen in dieser Reihenfolge · Alt+↑/↓ zum Verschieben",
+    "Group order saved": "Gruppenreihenfolge gespeichert",
+    "{picked}, the Image recognition model picked in Settings, isn't set up any more, so magpie had {describer}, its automatic choice, describe an image for {agent}'s {model} in its place. Pick another in Settings › Models › Image recognition. Not a turn of the conversation.": "{picked}, das in den Einstellungen gewählte Bilderkennungsmodell, ist nicht mehr eingerichtet, daher ließ magpie an seiner Stelle {describer}, seine automatische Wahl, ein Bild für {model} von {agent} beschreiben. Wähle ein anderes unter Einstellungen › Modelle › Bilderkennung. Keine Runde des Gesprächs.",
+    "In agents’ lists": "In den Listen der Agenten",
+    "Names in agents’ lists": "Namen in den Listen der Agenten",
+    "Whether “· routing group” follows a group’s name in the agents’ lists: one setting for every group, and for the provider after each model’s name, as on Settings.": "Ob in den Listen der Agenten „· routing group“ auf den Namen einer Gruppe folgt: eine Einstellung für alle Gruppen, und für den Anbieter nach jedem Modellnamen, wie in den Einstellungen.",
+    "“· routing group” is set for every group, under the list": "„· routing group“ wird unter der Liste für alle Gruppen eingestellt",
+    "{agent} guessed your next message for its composer by itself, reading the whole conversation again. Not a turn of the conversation; Codex composer predictions, under Settings in Codex's row on the Agents page, picks its model, and Codex's Settings › General › Show predictions turns it off.": "{agent} hat deine nächste Nachricht für sein Eingabefeld selbst vorhergesagt und dafür das ganze Gespräch erneut gelesen. Kein Zug des Gesprächs; das Modell wählst du mit Codex-Eingabevorhersagen unter Einstellungen in der Zeile von Codex auf der Seite Agenten, und in Codex unter Einstellungen › Allgemein › Textvorschläge anzeigen schaltest du es ab.",
+    "{name} is switched off: the group skips it until it is on again": "{name} ist ausgeschaltet: Die Gruppe überspringt es, bis es wieder eingeschaltet ist",
+    "{n} switched off": "{n} ausgeschaltet",
+    "Off: agents aren't offered {name} and a request to it is turned away. Click to switch it on": "Aus: Agents wird {name} nicht angeboten, eine Anfrage daran wird abgewiesen. Klicken zum Einschalten",
+    "On: agents may pick {name}. Click to switch it off and keep it as it is": "An: Agents können {name} wählen. Klicken zum Ausschalten – die Gruppe bleibt, wie sie ist",
+    "{name} switched on": "{name} eingeschaltet",
+    "{name} switched off": "{name} ausgeschaltet",
+    "in {groups}": "in {groups}",
+    "By weight: it's {who}'s share \u2014 each key takes requests as its weight says.": "Nach Gewicht: {who} ist mit seinem Anteil dran — jeder Schlüssel bekommt Anfragen nach seinem Gewicht.",
+    "By weight: it's {who}'s share \u2014 each account takes requests as its weight says.": "Nach Gewicht: {who} ist mit seinem Anteil dran — jedes Konto bekommt Anfragen nach seinem Gewicht.",
+    "By weight: it's {who}'s share — each model takes requests as the weight set beside it says.": "Nach Gewicht: {who} ist mit seinem Anteil dran — jedes Modell bekommt Anfragen nach dem Gewicht, das daneben eingestellt ist.",
+    "By weight: each model takes its share of the requests by the weight set beside it — one weighing 3 three for every one a model weighing 1 takes, spread out rather than in bursts. One resting after a failure leaves the round and the others share its requests; the next model is the fallback when one fails.": "Nach Gewicht: Jedes Modell bekommt seinen Anteil an den Anfragen nach dem Gewicht daneben – eines mit Gewicht 3 drei für jede, die ein Modell mit Gewicht 1 bekommt, verteilt statt in Schüben. Eines, das nach einem Fehler pausiert, setzt aus, und die anderen teilen sich seine Anfragen; scheitert eines, springt das nächste Modell ein.",
+    "Its share of the requests: a model weighing 3 takes three for every one a model weighing 1 takes": "Sein Anteil an den Anfragen: Ein Modell mit Gewicht 3 bekommt drei für jede, die eines mit Gewicht 1 bekommt",
+    "Weight of {name}": "Gewicht von {name}",
+    "A weight is 1 to 1000": "Ein Gewicht ist 1 bis 1000",
+    "{name}: {routing}": "{name}: {routing}",
+    "How {name} routes: click to change it": "Wie {name} weiterleitet: zum Ändern klicken",
+    "{n} available": "{n} verfügbar",
+    "{n} resting": "{n} pausiert",
+    "{n} held": "{n} angehalten",
+    "Show each key": "Jeden Schlüssel zeigen",
+    "Fold these keys into one row": "Diese Schlüssel in einer Zeile zusammenfassen",
+    "Show each account": "Jedes Konto zeigen",
+    "Fold these accounts into one row": "Diese Konten in einer Zeile zusammenfassen",
+    "Show what this group routes to": "Zeigen, wohin diese Gruppe leitet",
+    "Fold this group into one row": "Diese Gruppe in einer Zeile zusammenfassen",
+    "Sent by {agents}": "Gesendet von {agents}",
+    "Fold this route into one row": "Diese Route in einer Zeile zusammenfassen",
+    "Show where this route goes": "Zeigen, wohin diese Route geht",
+    "Its week was used up, so one of {account}'s Codex resets was used by itself first.": "Die Woche war aufgebraucht, daher wurde zuerst automatisch einer der Codex-Resets von {account} eingelöst.",
+    "{who} answered {status}: its week is used up and nobody else could take the request, so one of {account}'s Codex resets was used by itself and the request is asked again, before any of the reply reaches {agent}.": "{who} antwortete {status}: Die Woche ist aufgebraucht und kein anderes Konto konnte die Anfrage übernehmen, daher wurde automatisch einer der Codex-Resets von {account} eingelöst und die Anfrage erneut gestellt, bevor ein Teil der Antwort {agent} erreicht.",
+    "held: its allowance used up, set not to spend credits": "angehalten: Kontingent aufgebraucht, keine Credits freigegeben",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. The request went to {next}.": "{who} konnte sich nicht authentifizieren. Melden Sie sich in magpie erneut an; diese Anmeldung wird nicht erneut versucht. Die Anfrage ging an {next}.",
+    "{who} could not authenticate. Sign in again in magpie; this login is not retried. No other account could answer.": "{who} konnte sich nicht authentifizieren. Melden Sie sich in magpie erneut an; diese Anmeldung wird nicht erneut versucht. Kein anderes Konto konnte antworten.",
+    "Duplicated {name}": "{name} dupliziert",
+    "{name} as text to paste into another magpie: its models, routing and rules, no key": "{name} als Text zum Einfügen in ein anderes magpie: Modelle, Routing und Regeln, kein Schlüssel",
+    "{name} copied: paste it into Import on another magpie's Routing page": "{name} kopiert: auf der Routing-Seite eines anderen magpie unter Importieren einfügen",
+    "Add a routing group someone shared from their magpie": "Eine Routing-Gruppe hinzufügen, die jemand aus seinem magpie geteilt hat",
+    "Paste a group copied with Copy to share": "Eine mit „Zum Teilen kopieren“ kopierte Gruppe einfügen",
+    "Replace {name}": "{name} ersetzen",
+    "{name} has the same id: its models, routing and rules are replaced by this group's; its accounts and folder rules stay": "{name} hat dieselbe ID: Modelle, Routing und Regeln werden durch die dieser Gruppe ersetzt; Konten und Ordnerregeln bleiben",
+    "Replaced {name}": "{name} ersetzt",
+    "A routing group shared from magpie": "Eine aus magpie geteilte Routing-Gruppe",
+    "Paste a routing group someone shared from their magpie: its models, routing and rules come with it, never a key": "Eine Routing-Gruppe einfügen, die jemand aus magpie geteilt hat: Modelle, Routing und Regeln kommen mit, nie ein Schlüssel",
+    "Not in your magpie, left out: {models}": "Nicht in deinem magpie, weggelassen: {models}",
+    "The same model from your own provider: {models}": "Dasselbe Modell von deinem eigenen Anbieter: {models}",
+    "1 rule left out with them": "1 Regel mit ihnen weggelassen",
+    "{n} rules left out with them": "{n} Regeln mit ihnen weggelassen",
+    "Needs models from two providers: {name} is the only one": "Braucht Modelle von zwei Anbietern: {name} ist der einzige",
+    "Needs a model cheap beside {name}": "Braucht ein Modell, das günstiger ist als {name}",
+    "Add a provider first": "Füge zuerst einen Anbieter hinzu",
+    "Start from a template: made of your own models, added in a click": "Mit einer Vorlage beginnen: aus deinen eigenen Modellen, mit einem Klick hinzugefügt",
+    "Edit first": "Erst bearbeiten",
+    "A copy of {name} with its models, routing and rules, listed after it": "Eine Kopie von {name} mit ihren Modellen, ihrem Routing und ihren Regeln, direkt darunter",
+    "Purpose filter": "Zweckfilter",
+    "Purpose: {name}": "Zweck: {name}",
+    "Unmarked": "Ohne Markierung",
+    "Unrecognized request purpose": "Unbekannter Anfragezweck",
+    "No purpose was recorded; this may be a conversation turn or an older record.": "Kein Zweck erfasst; dies kann eine Runde der Unterhaltung oder ein älterer Eintrag sein.",
+    "Filter routing by purpose": "Weiterleitung nach Zweck filtern",
+    "Counts for the requests in this list": "Zähler für die Anfragen in dieser Liste",
+    "Counts since the gateway started": "Zähler seit dem Start des Zugangspunkts",
+    "No failed request in this list": "Keine fehlgeschlagene Anfrage in dieser Liste",
+    "View usage": "Nutzung anzeigen",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. To keep every request's, turn on Request archive at the top of Usage › Requests.": "magpie behält Anfrage und Antwort nur der letzten 40 Anfragen, bis es beendet wird. Um sie für jede Anfrage zu behalten, schalte oben unter Nutzung › Anfragen das Anfragearchiv ein.",
+    "magpie keeps the request and response of only the last 40 requests, until it quits. Request archive is on, but this request isn't in it: it was made while the archive was off, or it couldn't be saved.": "magpie behält Anfrage und Antwort nur der letzten 40 Anfragen, bis es beendet wird. Das Anfragearchiv ist an, aber diese Anfrage ist nicht darin: Sie kam, während das Archiv aus war, oder konnte nicht gespeichert werden.",
+    "Routing history for this request is no longer available.": "Der Weiterleitungsverlauf dieser Anfrage ist nicht mehr verfügbar.",
+    "Token breakdown": "Token-Aufschlüsselung",
+    "Input (uncached)": "Eingabe (nicht gecacht)",
+    "No token breakdown was recorded": "Keine Token-Aufschlüsselung aufgezeichnet",
+    "Includes token usage from billable retries; the row totals show the final attempts": "Enthält die Nutzung abrechenbarer Wiederholungen; die Listensummen zeigen die letzten Versuche",
+    "Breakdown available for {n} of {total} requests": "Aufschlüsselung für {n} von {total} Anfragen verfügbar",
+    "Avg. cache": "Ø Cache",
+    "Avg. speed": "Ø Tempo",
+    "Metrics to show": "Angezeigte Kennzahlen",
+    "request cache hit rate {p}": "Cache-Trefferquote der Anfrage {p}",
+    "Based on {n} of {total} completed requests": "Basierend auf {n} von {total} abgeschlossenen Anfragen",
+    "Total cache reads divided by total prompt tokens; larger prompts carry more weight": "Gesamte Cache-Lese-Token geteilt durch gesamte Eingabe-Token; größere Eingaben erhalten mehr Gewicht",
+    "Total output tokens divided by total decode time; excludes waiting and replies without usable timing": "Gesamte Ausgabe-Token geteilt durch gesamte Generierungszeit; ohne Wartezeit und Antworten ohne brauchbare Zeitmessung",
+    "Read the accounts' allowances again": "Kontingente der Konten neu lesen",
+    "live, as the gateway decides": "live, während der Zugangspunkt entscheidet",
+    "Add another model": "Weiteres Modell hinzufügen",
+    "Sort by weight": "Nach Gewicht sortieren",
+    "Heaviest first. When a model fails, the next one in this order takes over": "Schwerstes zuerst: In dieser Reihenfolge springt das nächste Modell ein, wenn eines ausfällt",
+    "Add pattern": "Muster hinzufügen",
+    "e.g. openrouter/*:free or re:…": "z. B. openrouter/*:free oder re:…",
+    "Every model this pattern matches is in the group, as providers list them": "Jedes Modell, auf das dieses Muster passt, ist in der Gruppe, so wie die Anbieter es auflisten",
+    "No model magpie serves matches this pattern now": "Derzeit passt kein Modell von magpie auf dieses Muster",
+    "Classifier failed {when}: {error}": "Klassifizierer fehlgeschlagen {when}: {error}",
+    "{by} couldn't say which intent or effort a turn is the last time it was asked: {error}. Until it answers, no rule with an intent matches and turns reason as the agent asked. Each request's details say what it was asked.": "{by} konnte beim letzten Mal nicht sagen, welche Absicht oder welcher Denkaufwand ein Zug ist: {error}. Bis er antwortet, greift keine Regel mit Absicht, und Züge denken so viel, wie der Agent verlangt hat. Was er gefragt wurde, steht in den Details jeder Anfrage.",
+    "In the group by a pattern: switch it off to send it nothing": "Über ein Muster in der Gruppe: ausschalten, um ihm nichts zu senden",
+    "A pattern has a * in it, or starts with re:": "Ein Muster enthält ein * oder beginnt mit re:",
+    "{pattern} is not a regular expression magpie can read": "{pattern} ist kein regulärer Ausdruck, den magpie lesen kann",
+    "Every model a pattern matches is in the group, now and as providers list new ones, after the models above: * is any run of characters in provider/model, re: starts a regular expression.": "Jedes Modell, auf das ein Muster passt, ist in der Gruppe, jetzt und sobald Anbieter neue auflisten, nach den Modellen oben: * steht für beliebige Zeichen in provider/model, re: leitet einen regulären Ausdruck ein.",
+    "{api} only · after the others": "nur {api} · nach den anderen",
+    "{who} is in reserve: {n} of its provider's accounts or keys take requests at once, the first in the list, so it's tried only once they have all failed.": "{who} ist in Reserve: Von seinem Anbieter nehmen nur die ersten {n} Konten oder Schlüssel der Liste gleichzeitig Anfragen an, also wird es erst versucht, wenn sie alle fehlgeschlagen sind.",
+    "{who} answered this conversation last, but it is in reserve while those before it in the list can take requests, so the conversation moves back to them.": "{who} hat diese Unterhaltung zuletzt beantwortet, ist aber in Reserve, solange die Konten davor in der Liste Anfragen annehmen können, also geht die Unterhaltung zu ihnen zurück.",
+    "in reserve · {n} at once": "in Reserve · {n} gleichzeitig",
+    "key set to {api} only, no {api} URL · sent on the others": "Schlüssel nur für {api}, keine {api}-URL · über die anderen gesendet",
+    "{who} is made for {api}, not {other} as the keys routed over are, so it isn't one of them: it's tried after them.": "{who} ist für {api} gedacht, nicht für {other} wie die Schlüssel der Weiterleitung, und gehört daher nicht zu ihnen: Es wird nach ihnen versucht.",
+    "{n} keys for {api}": "{n} Schlüssel für {api}",
+    "New group": "Neue Gruppe",
+    "Turn on routing groups": "Weiterleitungsgruppen einschalten",
+    "Routing groups are on": "Weiterleitungsgruppen sind an",
+    "Routing groups are off in Plugins › Built-in: the groups magpie finds, one model several providers serve, still route, but your own can't be made or changed here.": "Weiterleitungsgruppen sind unter Erweiterungen › Eingebaut ausgeschaltet: Die Gruppen, die magpie findet (ein Modell, das mehrere Anbieter bereitstellen), leiten weiter, aber eigene lassen sich hier nicht anlegen oder ändern.",
+    "Make a routing group of any models you like — agents pick it as one model": "Eine Routing-Gruppe aus beliebigen Modellen erstellen – Agenten wählen sie als ein Modell",
+    "Filter groups and models": "Gruppen und Modelle filtern",
+    "No group or model matches “{q}”": "Keine Gruppe und kein Modell passt zu „{q}“",
+    "This group can't be shown: {error}": "Diese Gruppe kann nicht angezeigt werden: {error}",
+    "No group yet. A model two of your providers serve becomes one on its own; New group makes one of any models you like.": "Noch keine Gruppe. Ein Modell, das zwei Ihrer Anbieter bereitstellen, wird automatisch zu einer; „Neue Gruppe“ fasst beliebige Modelle zusammen.",
+    "1 found group removed": "1 gefundene Gruppe entfernt",
+    "{n} found groups removed": "{n} gefundene Gruppen entfernt",
+    "magpie doesn't make them again. Click to bring one back.": "magpie legt sie nicht wieder an. Klicken, um eine zurückzuholen.",
+    "Pick several groups to remove together": "Mehrere Gruppen auswählen und zusammen entfernen",
+    "Select every group": "Alle Gruppen auswählen",
+    "Pick the groups to remove": "Zu entfernende Gruppen auswählen",
+    "{n} groups removed": "{n} Gruppen entfernt",
+    "No group yet. New group makes one of any models you like.": "Noch keine Gruppe. „Neue Gruppe“ fasst beliebige Modelle zusammen.",
+    "Find groups on their own": "Gruppen automatisch finden",
+    "Their models join no found group; the groups you made or changed keep them": "Ihre Modelle kommen in keine automatisch gefundene Gruppe; selbst erstellte oder geänderte Gruppen behalten sie",
+    "Left out: {names}": "Ausgenommen: {names}",
+    "Leave out a provider…": "Anbieter ausnehmen…",
+    "Leave out of found groups": "Aus automatischen Gruppen ausnehmen",
+    "Found groups changed": "Automatische Gruppen geändert",
+    "A model two or more of your providers serve becomes a group of them (auto/…). Switch it off to list and serve only the groups you made or changed.": "Ein Modell, das zwei oder mehr Ihrer Anbieter bereitstellen, wird zu einer Gruppe aus ihnen (auto/…). Ausschalten, um nur selbst erstellte oder geänderte Gruppen aufzulisten und bereitzustellen.",
+    "Off: only the groups you made or changed are listed and served. An agent set to a found group is moved to its model from one provider, and a request still naming one goes there too.": "Aus: Nur selbst erstellte oder geänderte Gruppen werden aufgelistet und bereitgestellt. Ein Agent, der auf eine gefundene Gruppe eingestellt ist, wechselt zu deren Modell bei einem Anbieter, und eine Anfrage, die sie noch nennt, geht ebenfalls dorthin.",
+    "Found groups are on": "Gefundene Gruppen sind eingeschaltet",
+    "Found groups are off: only yours are listed and served": "Gefundene Gruppen sind ausgeschaltet: nur Ihre werden aufgelistet und bereitgestellt",
+    "Bring it back": "Wiederherstellen",
+    "{name} is back": "{name} ist wieder da",
+    "Manual: every request goes to the model you pick on the group's card, over its own accounts or keys; the others, and the rules, wait until you pick another — none takes over when it fails.": "Manuell: Jede Anfrage geht an das Modell, das Sie auf der Karte der Gruppe wählen, über dessen eigene Konten oder Schlüssel; die anderen und die Regeln warten, bis Sie ein anderes wählen – keines übernimmt, wenn es fehlschlägt.",
+    "Manual: every request goes to the model picked on the group's card, over its own accounts or keys.": "Manuell: Jede Anfrage geht an das auf der Karte der Gruppe gewählte Modell, über dessen eigene Konten oder Schlüssel.",
+    "The rules wait while you pick the model by hand.": "Die Regeln ruhen, solange Sie das Modell von Hand wählen.",
+    "Model every request goes to": "Modell, an das jede Anfrage geht",
+    "no provider serves it now": "derzeit von keinem Anbieter bedient",
+    "Every request goes to {name}": "Jede Anfrage geht an {name}",
+    "Send every request to {name}": "Jede Anfrage an {name} senden",
+    "{name}: every request to {model}": "{name}: jede Anfrage an {model}",
+    "Click to fold it": "Zum Einklappen klicken",
+    "Save or Cancel your changes first": "Klicken Sie zuerst auf „Speichern“ oder „Abbrechen“",
+    "found by magpie — saving a change makes it yours": "von magpie gefunden – nach dem Speichern einer Änderung gehört sie Ihnen",
+    "e.g. Opus anywhere": "z. B. Opus überall",
+    "Agents pick it as {id}": "Agenten wählen sie als {id}",
+    "an agent set to {id} needs setting again": "ein auf {id} eingestellter Agent muss neu eingestellt werden",
+    "The first answers for what the model can do. In order, they are tried top first.": "Das erste bestimmt, was das Modell kann. Der Reihe nach werden sie von oben versucht.",
+    "Rate limited to the back": "Bei Rate-Limit nach hinten",
+    "Its models too": "Auch seine Modelle",
+    "The group alone": "Nur die Gruppe",
+    "Its models unlisted": "Modelle nicht gelistet",
+    "Agents' model lists and the gateway's /v1/models show the group and each of its models.": "Die Modelllisten der Agenten und /v1/models des Gateways zeigen die Gruppe und jedes ihrer Modelle.",
+    "Agents' model lists and the gateway's /v1/models show the group, not the models it names or its patterns match: they are used through it. Codex keeps its ChatGPT sign-in's own models. A request naming one is still answered.": "Die Modelllisten der Agenten und /v1/models des Gateways zeigen die Gruppe, nicht die Modelle, die sie nennt oder deren Muster passen: Sie werden über die Gruppe genutzt. Codex behält die eigenen Modelle seiner ChatGPT-Anmeldung. Eine Anfrage, die eines davon nennt, wird weiter beantwortet.",
+    "Slow to start": "Langsamer Start",
+    "Every member busy": "Alle Mitglieder ausgelastet",
+    "When every member has failed with an error that may pass — overloaded, unavailable, rate limited for a moment — and nothing of the reply has reached the agent, each is asked again after a pause, longer each time and never shorter than the vendor asks, for up to {n} more. A streaming agent is kept waiting meanwhile.": "Sind alle Mitglieder mit einem vorübergehenden Fehler gescheitert – überlastet, nicht verfügbar, kurz ratenbegrenzt – und hat den Agenten noch nichts von der Antwort erreicht, wird jedes nach einer Pause erneut gefragt, jedes Mal länger und nie kürzer, als der Anbieter verlangt, bis zu {n} lang. Ein streamender Agent wird so lange hingehalten.",
+    "When every member has failed, the agent gets the last one's error at once.": "Sind alle Mitglieder gescheitert, bekommt der Agent sofort den Fehler des letzten.",
+    "{who} answered {status} · {fail}, and every member had failed with an error that may pass, so after {d} the {n} of them are asked again, in turn, before any of the reply reaches {agent}. The group waits up to {p} for one to answer.": "{who} antwortete {status} · {fail}, und alle Mitglieder waren mit einem vorübergehenden Fehler gescheitert, daher werden die {n} nach {d} der Reihe nach erneut gefragt, bevor etwas von der Antwort {agent} erreicht. Die Gruppe wartet bis zu {p}, dass eines antwortet.",
+    "Largest model's": "Größtes Modell",
+    "Smallest model's": "Kleinstes Modell",
+    "{v} is not a number of minutes": "{v} ist keine Anzahl Minuten",
+    "Agents are told the group takes {n} tokens; a longer conversation still goes on to a member with room for it.": "Agenten wird gesagt, die Gruppe fasst {n} Tokens; ein längeres Gespräch geht weiter an ein Mitglied mit Platz dafür.",
+    "Agents are told {n} tokens, its smallest model's, so they compact before any member would turn the conversation away.": "Agenten wird {n} Tokens gesagt, das kleinste Modell, sodass sie verdichten, bevor ein Mitglied das Gespräch ablehnt.",
+    "Agents are told its smallest model's window, so they compact before any member would turn the conversation away.": "Agenten wird das Fenster des kleinsten Modells gesagt, sodass sie verdichten, bevor ein Mitglied das Gespräch ablehnt.",
+    "Agents are told {n} tokens, its largest model's; a conversation too long for one member goes on to one with room for it.": "Agenten wird {n} Tokens gesagt, das größte Modell; ein für ein Mitglied zu langes Gespräch geht an eines mit Platz dafür.",
+    "Agents are told {n} tokens, its largest model's; a conversation longer than {m} skips {who} for a member with room for it.": "Agenten wird {n} Tokens gesagt, das größte Modell; ein Gespräch über {m} überspringt {who} und geht an ein Mitglied mit Platz dafür.",
+    "Agents are told its largest model's window; a conversation too long for one member goes on to one with room for it.": "Agenten wird das Fenster des größten Modells gesagt; ein für ein Mitglied zu langes Gespräch geht an eines mit Platz dafür.",
+    "{v} is not a length of tokens like 200k or 1m": "{v} ist keine Tokenlänge wie 200k oder 1m",
+    "Every member is waited for, however long it takes to begin answering.": "Auf jedes Mitglied wird gewartet, egal wie lange es bis zum Antwortbeginn braucht.",
+    "A member that hasn't begun answering after {n} — no text, reasoning or tool call yet — is let go and the next one asked, before any of it reaches the agent. Let go once, it doesn't rest; let go twice in a row, its model rests on that account, a minute and longer each time, until it answers again. The last one left is always waited for. Only for streamed requests.": "Ein Mitglied, das nach {n} noch nicht zu antworten begonnen hat — noch kein Text, kein Reasoning, kein Tool-Aufruf —, wird aufgegeben und das nächste gefragt, bevor etwas davon den Agenten erreicht. Einmal aufgegeben, pausiert es nicht; zweimal hintereinander, pausiert sein Modell auf diesem Konto, eine Minute und jedes Mal länger, bis es wieder antwortet. Auf das letzte verbleibende wird immer gewartet. Nur für gestreamte Anfragen.",
+    "Next after {n} without a first token": "Nächstes nach {n} ohne erstes Token",
+    "{who} hadn't begun answering after {ms}, so the request went on to the next before any of it reached {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} hatte nach {ms} noch nicht zu antworten begonnen, daher ging die Anfrage an das nächste, bevor etwas davon {agent} erreichte. Mit {who} ist alles in Ordnung, daher pausiert es nicht.",
+    "{who} hadn't begun answering after {ms}, {n} times in a row, so the request went on to the next before any of it reached {agent}. It rests {d} for {model} alone, longer each time it is slow again; its other models answer as before.": "{who} hatte {n}-mal hintereinander nach {ms} noch nicht zu antworten begonnen, daher ging die Anfrage an das nächste, bevor etwas davon {agent} erreichte. Es pausiert {d} nur für {model}, jedes Mal länger, wenn es wieder langsam ist; seine anderen Modelle antworten wie bisher.",
+    "{who} was rate limited at {time} while it had quota left, so it went to the back: it comes round again once those ahead of it are rate limited in turn.": "{who} erhielt um {time} trotz verbleibendem Kontingent ein Rate-Limit und wanderte daher nach hinten: Es kommt wieder an die Reihe, sobald auch die vor ihm ein Rate-Limit erhalten.",
+    "rate limited at {time} · at the back": "Rate-Limit um {time} · hinten",
+    "A group needs a model in it": "Eine Gruppe braucht mindestens ein Modell",
+    "Couldn't save the group: {error}": "Gruppe konnte nicht gespeichert werden: {error}",
+    "Add a rule": "Regel hinzufügen",
+    "Add a condition": "Bedingung hinzufügen",
+    "Conversation length": "Gesprächslänge",
+    "Hours and days": "Uhrzeit und Tage",
+    "Remove condition": "Bedingung entfernen",
+    "Actions for rule {n}": "Aktionen für Regel {n}",
+    "Move rule {n}": "Regel {n} verschieben",
+    "Pause the model instead": "Stattdessen Modell pausieren",
+    "Send to the model instead": "Stattdessen an das Modell senden",
+    "Remove rule": "Regel entfernen",
+    "It can pick the model too: add a rule with an intent": "Es kann auch das Modell wählen: Regel mit Absicht hinzufügen",
+    "in {folders}": "in {folders}",
+    "The agent works in {folder}.": "Der Agent arbeitet in {folder}.",
+    "The agent works in one of these folders or a folder inside one, as it tells the model (Claude Code, Codex, OpenCode, Pi); an agent that doesn't say isn't matched": "Der Agent arbeitet in einem dieser Ordner oder einem Ordner darin, wie er es dem Modell sagt (Claude Code, Codex, OpenCode, Pi); ein Agent, der es nicht sagt, passt nicht",
+    "Rule {n}: a folder is a whole path, like ~/work or /Users/me/work": "Regel {n}: Ein Ordner ist ein ganzer Pfad, etwa ~/work oder /Users/me/work",
+    "The turn begins within these hours, in your time zone — a provider's peak-price hours sent to another, say": "Die Runde beginnt in diesen Stunden, in deiner Zeitzone – etwa um die Spitzenpreis-Stunden eines Anbieters an einen anderen zu senden",
+    "{hours} ({zone})": "{hours} ({zone})",
+    "{zone} time": "{zone}-Zeit",
+    "server time, {offset}": "Serverzeit, {offset}",
+    "weekends": "am Wochenende",
+    "{from}–{to}": "{from}–{to}",
+    "{hours} {days}": "{hours} {days}",
+    "runs past midnight, into the next day": "geht über Mitternacht in den nächsten Tag",
+    "Rule {n}: the hours are two times like 09:00 and 18:00": "Regel {n}: Die Stunden sind zwei Uhrzeiten wie 09:00 und 18:00",
+    "Rule {n}: its hours are the whole day — pick days, or other hours": "Regel {n}: Die Stunden umfassen den ganzen Tag – wählen Sie Tage oder andere Stunden",
+    "The agent summarizes the conversation to go on in less room (Claude Code's /compact, Codex, OpenCode…): a cheaper, faster model can do it": "Der Agent fasst die Unterhaltung zusammen, um mit weniger Platz weiterzumachen (/compact von Claude Code, Codex, OpenCode…): Das kann ein günstigeres, schnelleres Modell erledigen",
+    "longer conversations skip it: it takes {n} tokens": "längere Unterhaltungen überspringen es: es fasst {n} Token",
+    "The agent is compacting the conversation, so rule {n} sends the summary to {use}; the conversation stays on the model it was on.": "Der Agent kompaktiert die Unterhaltung, daher sendet Regel {n} die Zusammenfassung an {use}; die Unterhaltung bleibt beim bisherigen Modell.",
+    "Passed over, as the conversation is longer than they take: {models}.": "Übergangen, da die Unterhaltung länger ist, als sie fassen: {models}.",
+    "reasoning ≥ {level}": "Reasoning ≥ {level}",
+    "not a condition": "keine Bedingung",
+    "thinking or any effort level": "Thinking oder beliebige Effort-Stufe",
+    "it doesn't take images": "es nimmt keine Bilder an",
+    "it takes {n} tokens": "es fasst {n} Token",
+    "≥ {n} tokens": "≥ {n} Token",
+    "1 rule": "1 Regel",
+    "{n} rules": "{n} Regeln",
+    "Rule {n} has no condition. Add one with its +, or remove the rule from its ⋯ menu": "Regel {n} hat keine Bedingung. Füge mit ihrem + eine hinzu oder entferne die Regel über ihr ⋯-Menü",
+    "This rule has no condition. Add one with its +, or remove the rule from its ⋯ menu": "Diese Regel hat keine Bedingung. Füge mit ihrem + eine hinzu oder entferne die Regel über ihr ⋯-Menü",
+    "goes first; the others stay behind it": "kommt zuerst; die anderen bleiben dahinter",
+    "left out of the group: not tried, not a fallback": "aus der Gruppe genommen: nicht versucht, kein Ausweichmodell",
+    "left out of the group then: not tried, not a fallback": "in dieser Zeit aus der Gruppe genommen: nicht versucht, kein Ausweichmodell",
+    "not in {folders}": "nicht in {folders}",
+    "not in folder": "nicht im Ordner",
+    "The agent works in none of these folders, nor a folder inside one, as it tells the model; an agent that doesn't say counts as outside them": "Der Agent arbeitet in keinem dieser Ordner und keinem Ordner darin, wie er es dem Modell sagt; ein Agent, der es nicht sagt, zählt als außerhalb",
+    "The agent didn't say which folder it works in.": "Der Agent hat nicht gesagt, in welchem Ordner er arbeitet.",
+    "Rule {n}: a pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "Regel {n}: eine Pause braucht Uhrzeiten, Tage, Agenten oder Ordner. Füge mit ihrem + etwas hinzu oder entferne die Regel über ihr ⋯-Menü",
+    "A pause needs hours, days, agents or folders. Add one with its +, or remove the rule from its ⋯ menu": "Eine Pause braucht Uhrzeiten, Tage, Agenten oder Ordner. Füge mit ihrem + etwas hinzu oder entferne die Regel über ihr ⋯-Menü",
+    "{model} is paused by rule {n} ({when}), so it is left out until that ends.": "{model} ist durch Regel {n} ({when}) pausiert und wird bis dahin ausgelassen.",
+    "{model} is paused by rule {n} of {group} ({when}), so it is left out until that ends.": "{model} ist durch Regel {n} von {group} ({when}) pausiert und wird bis dahin ausgelassen.",
+    "asks for “{intent}”": "verlangt „{intent}“",
+    "what it asks for, e.g. writing tests": "was verlangt wird, z. B. Tests schreiben",
+    "Intent told by": "Absicht bestimmt durch",
+    "choose a model": "Modell wählen",
+    "As a turn begins, this model is asked which of the intents the message is — once; a small, fast one without reasoning is best. If it fails or can't say, no intent matches. Its calls show in the usage as magpie’s own.": "Zu Beginn einer Runde wird dieses Modell einmal gefragt, welcher Absicht die Nachricht entspricht; am besten ein kleines, schnelles ohne Reasoning. Schlägt es fehl oder weiß es keine Antwort, trifft keine Absicht zu. Seine Aufrufe erscheinen in der Nutzung als eigene von magpie.",
+    "Choose the model that tells which intent a message is": "Wählen Sie das Modell, das die Absicht einer Nachricht bestimmt",
+    "A routing group classifies as any request to it goes: if its first model fails, the next is asked.": "Eine Weiterleitungsgruppe klassifiziert wie bei jeder Anfrage an sie: Schlägt ihr erstes Modell fehl, wird das nächste gefragt.",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so no rule with an intent matches it.": "{by} sollte bestimmen, welche von {kinds} Runde {turn} ist, konnte es aber nicht – {err} –, daher trifft keine Regel mit Absicht zu.",
+    "{by} was to tell which of {kinds} turn {turn} is, but couldn't — {err} — so the turn keeps “{intent}”, as turn {prev} was.": "{by} sollte bestimmen, welche von {kinds} Runde {turn} ist, konnte es aber nicht – {err} –, daher bleibt die Runde bei „{intent}“ wie Runde {prev}.",
+    "{by} was asked which of {kinds} turn {turn} is, and said none ({took}).": "{by} wurde gefragt, welche von {kinds} Runde {turn} ist, und sagte: keine ({took}).",
+    "{by} was asked which of {kinds} turn {turn} is, and answered “{said}”, which is no rule's intent ({took}).": "{by} wurde gefragt, welche von {kinds} Runde {turn} ist, und antwortete „{said}“, was die Absicht keiner Regel ist ({took}).",
+    "{by} was asked which of {kinds} turn {turn} is, and said “{intent}” ({took}).": "{by} wurde gefragt, welche von {kinds} Runde {turn} ist, und sagte „{intent}“ ({took}).",
+    "It was told turn {prev} was “{after}”, which a message that only carries on from it is too.": "Ihm wurde mitgeteilt, dass Runde {prev} „{after}“ war; eine Nachricht, die nur daran anknüpft, gilt ebenso.",
+    "{by} was to rate how hard turn {turn} is, but couldn't — {err} — so it reasons as the agent asked.": "{by} sollte einschätzen, wie schwer Runde {turn} ist, konnte es aber nicht – {err} –, daher gilt das vom Agenten verlangte Reasoning.",
+    "{by} wasn't asked how hard turn {turn} is: the group above picked {level} reasoning for it.": "{by} wurde nicht gefragt, wie schwer Runde {turn} ist: Die Gruppe darüber hat für sie {level} als Reasoning gewählt.",
+    "{by} rated turn {turn} {score} of 3, so it picks {level} reasoning for the turn — each model gets the level it has nearest.": "{by} bewertete Runde {turn} mit {score} von 3 und wählt daher {level} Reasoning für die Runde – jedes Modell erhält seine nächstgelegene Stufe.",
+    ", {n} sure": ", {n} sicher",
+    "Decided by": "Entschieden durch",
+    "at {level} reasoning": "mit {level} Reasoning",
+    "The turn's pick replaced the {asked} {agent} asked for.": "Die Wahl für die Runde ersetzte das von {agent} verlangte {asked}.",
+    "{level} is the model's nearest to the {asked} {agent} asked for.": "{level} ist die Stufe des Modells, die dem von {agent} verlangten {asked} am nächsten liegt.",
+    "{level} reasoning, picked for the turn; {agent} asked for {asked}": "{level} Reasoning, für die Runde gewählt; {agent} verlangte {asked}",
+    "{level} reasoning, picked for the turn": "{level} Reasoning, für die Runde gewählt",
+    "{level} reasoning, fixed on this model in the group; {agent} asked for {asked}": "{level} Reasoning, in der Gruppe für dieses Modell festgelegt; {agent} verlangte {asked}",
+    "{level} reasoning, fixed on this model in the group": "{level} Reasoning, in der Gruppe für dieses Modell festgelegt",
+    "{level} reasoning, set by the rule; {agent} asked for {asked}": "{level} Reasoning, von der Regel festgelegt; {agent} verlangte {asked}",
+    "{level} reasoning, set by the rule": "{level} Reasoning, von der Regel festgelegt",
+    "The rule asks this model for {level} reasoning, in place of the {asked} {agent} asked for.": "Die Regel verlangt von diesem Modell {level} Reasoning, statt des von {agent} verlangten {asked}.",
+    "As the agent asks": "Wie der Agent verlangt",
+    "the rule sets none": "die Regel legt keines fest",
+    "The rule asks the model for {level} reasoning whatever the agent asks, at the model's nearest level; a model whose levels aren't known is asked as the agent asked": "Die Regel verlangt von dem Modell {level} Reasoning, was auch immer der Agent verlangt, auf der nächstliegenden Stufe des Modells; ein Modell ohne bekannte Stufen bekommt, was der Agent verlangt",
+    "Set its reasoning": "Reasoning festlegen",
+    "Change its reasoning": "Reasoning ändern",
+    "The group fixes this model at {fixed} reasoning, in place of the {asked} {agent} asked for.": "Die Gruppe legt dieses Modell auf {fixed} Reasoning fest, statt des von {agent} verlangten {asked}.",
+    "{level} reasoning": "{level} Reasoning",
+    "Group's reasoning": "Reasoning der Gruppe",
+    "Follows {name}": "Folgt {name}",
+    "Its models reason as {name} says: set that up on {name}'s own card, not here": "Seine Modelle richten sich nach {name}: die Stufen setzt man auf der Karte von {name}, nicht hier",
+    "Sent at {level} reasoning whatever the agent asks, at the model's nearest level": "Mit {level} Reasoning gesendet, egal was der Agent verlangt, auf der nächstgelegenen Stufe des Modells",
+    "Reasons as the group's effort says": "Reasoning gemäß Effort der Gruppe",
+    "Follow the group": "Der Gruppe folgen",
+    "Several levels…": "Mehrere Stufen…",
+    "Mapped reasoning": "Zugeordnetes Reasoning",
+    "Sent {pairs}; other levels as asked": "Gesendet {pairs}; andere Stufen wie angefragt",
+    "Map levels…": "Stufen zuordnen…",
+    "a level in place of the one asked": "eine Stufe statt der angefragten",
+    "As asked": "Wie angefragt",
+    "the agent picks among them": "der Agent wählt daraus",
+    "The agent picks among {levels} reasoning, each sent at the model's nearest level": "Der Agent wählt unter {levels} Reasoning, jeweils auf der nächstgelegenen Stufe des Modells gesendet",
+    "{name} at that reasoning is in the group already": "{name} mit diesem Reasoning ist bereits in der Gruppe",
+    "Standard speed": "Standardgeschwindigkeit",
+    "Sent in its vendor's fast mode whatever the agent asks: quicker, at a higher price": "Im Schnellmodus des Anbieters gesendet, egal was der Agent verlangt: schneller, zu höherem Preis",
+    "Sent at its vendor's usual speed; click to send it in fast mode": "Mit der üblichen Geschwindigkeit des Anbieters gesendet; klicken, um im Schnellmodus zu senden",
+    "Asked for OpenAI's fast mode (service_tier \"priority\") whatever the agent asks: quicker, at a higher price, where your provider serves it. One that turns it away is asked without it": "Fragt unabhängig vom Agenten nach OpenAIs Schnellmodus (service_tier \"priority\"): schneller, zu einem höheren Preis, wo dein Anbieter ihn anbietet. Lehnt er das Feld ab, wird ohne es erneut gefragt",
+    "Sent as the agent asks; click to ask your provider for OpenAI's fast mode (service_tier \"priority\")": "Gesendet, wie der Agent fragt; klicken, um deinen Anbieter nach OpenAIs Schnellmodus (service_tier \"priority\") zu fragen",
+    "Off: kept in its place, sent nothing. Click to switch it on": "Aus: behält seinen Platz, erhält nichts. Zum Einschalten klicken",
+    "On: requests may go to it. Click to switch it off and keep its place": "An: Anfragen können dorthin gehen. Klicken, um es auszuschalten und den Platz zu behalten",
+    "Sent in its vendor's fast mode, as the group says": "Im Schnellmodus des Anbieters gesendet, gemäß Gruppe",
+    "{level} reasoning: the model's nearest to the {asked} {agent} asked for": "{level} Reasoning: die Stufe des Modells, die dem von {agent} verlangten {asked} am nächsten liegt",
+    "{level} reasoning, as {agent} asked": "{level} Reasoning, wie von {agent} verlangt",
+    "Jev is asked once as each turn begins, with the message and what it said of the turn before. Its calls show in the usage as magpie’s own.": "Jev wird zu Beginn jeder Runde einmal gefragt, mit der Nachricht und seiner Einschätzung der vorigen Runde. Seine Aufrufe erscheinen in der Nutzung als eigene von magpie.",
+    "Picked per turn": "Je Runde gewählt",
+    "Choose the model that rates how hard a turn is": "Wählen Sie das Modell, das die Schwierigkeit einer Runde einschätzt",
+    "Turn {turn} reasons at {level}, as the classifier picked when it began.": "Runde {turn} nutzt {level} Reasoning, wie vom Klassifikator zu ihrem Beginn gewählt.",
+    "As a turn begins, the classifier rates how hard it is and the turn's requests ask their model for low, medium, high or xhigh reasoning — the level each model has nearest. Only where the agent asked for reasoning: a request without any (a session title) stays without.": "Zu Beginn einer Runde schätzt der Klassifikator ihre Schwierigkeit ein, und die Anfragen der Runde verlangen von ihrem Modell low, medium, high oder xhigh Reasoning – die jeweils nächstgelegene Stufe. Nur wo der Agent Reasoning verlangt hat: Eine Anfrage ohne (etwa ein Sitzungstitel) bleibt ohne.",
+    "As a turn begins, this model is asked how hard the turn is — once; a small, fast one without reasoning is best. If it fails or can't say, the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "Zu Beginn einer Runde wird dieses Modell einmal gefragt, wie schwer die Runde ist; am besten ein kleines, schnelles ohne Reasoning. Schlägt es fehl oder weiß es keine Antwort, gilt das vom Agenten verlangte Reasoning. Seine Aufrufe erscheinen in der Nutzung als eigene von magpie.",
+    "As a turn begins, this model is asked which of the intents the message is and how hard the turn is, each once; a small, fast one without reasoning is best. If it can't say, no intent matches and the turn reasons as the agent asked. Its calls show in the usage as magpie’s own.": "Zu Beginn einer Runde wird dieses Modell je einmal gefragt, welcher Absicht die Nachricht entspricht und wie schwer die Runde ist; am besten ein kleines, schnelles ohne Reasoning. Weiß es keine Antwort, trifft keine Absicht zu und es gilt das vom Agenten verlangte Reasoning. Seine Aufrufe erscheinen in der Nutzung als eigene von magpie.",
+    "Each request reasons as much as the agent asked.": "Jede Anfrage nutzt so viel Reasoning, wie der Agent verlangt hat.",
+    "Its models' shared": "Gemeinsame der Modelle",
+    "Agents are offered the levels every model has: {levels}.": "Agenten werden die Stufen angeboten, die jedes Modell hat: {levels}.",
+    "Agents are offered the levels every model has.": "Agenten werden die Stufen angeboten, die jedes Modell hat.",
+    "Agents are offered these. A model without the level asked is sent the one it has nearest.": "Agenten werden diese angeboten. Ein Modell ohne die verlangte Stufe erhält seine nächstgelegene.",
+    "Pick a level to offer, or leave them to its models": "Wählen Sie eine anzubietende Stufe oder überlassen Sie sie den Modellen",
+    "As a turn begins, Jev is asked once which of the intents the message is, and how hard the turn is when it picks the effort. An intent it isn't sure of matches no rule. Its calls show in the usage as magpie’s own.": "Zu Beginn einer Runde wird Jev einmal gefragt, welcher Absicht die Nachricht entspricht und, wenn es den Effort wählt, wie schwer die Runde ist. Eine Absicht, bei der es unsicher ist, trifft auf keine Regel zu. Seine Aufrufe erscheinen in der Nutzung als eigene von magpie.",
+    "It was told turn {prev} reasoned at {level}, which a message that only carries on from it needs too.": "Ihm wurde mitgeteilt, dass Runde {prev} {level} Reasoning nutzte; eine Nachricht, die nur daran anknüpft, braucht das ebenso.",
+    "Add an example rule": "Beispielregel hinzufügen",
+    "planning, design, or a hard problem to think through": "Planung, Entwurf oder ein schwieriges Problem zum Durchdenken",
+    "With two models or more, a rule can send some turns to one of them first.": "Ab zwei Modellen kann eine Regel bestimmte Runden zuerst an eines davon senden.",
+    "Checked top first when you send a message: the first that matches sends that turn to its model first; the rest stay behind it if it fails. A turn under way is never moved.": "Beim Senden einer Nachricht von oben geprüft: Die erste zutreffende Regel sendet diese Runde zuerst an ihr Modell; die übrigen folgen dahinter, falls es fehlschlägt. Eine laufende Runde wird nie verschoben.",
+    "Rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "Regel {n} ({when}) sendete Runde {turn} zu Beginn an {use}; die Runde bleibt bei dem, der sie damals übernommen hat.",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; if it fails, {then}, which the rules after it that match too name, then the group's others.": "Runde {turn} beginnt und Regel {n} trifft zu – {when} –, daher kommt {use} zuerst; schlägt es fehl, {then}, die von nachfolgenden ebenfalls zutreffenden Regeln genannt werden, dann die übrigen der Gruppe.",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "Regel {n} trifft zu, aber {use} hat kein Konto und keinen Schlüssel, der diese Anfrage annehmen kann, daher setzt eine spätere zutreffende Regel {instead} an die Spitze.",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so a later matching rule puts {instead} first.": "In {group} trifft Regel {n} zu, aber {use} hat kein Konto und keinen Schlüssel, der diese Anfrage annehmen kann, daher setzt eine spätere zutreffende Regel {instead} an die Spitze.",
+    "Remove {name} from this rule": "{name} aus dieser Regel entfernen",
+    "Add a model it goes to next": "Ein Modell für danach hinzufügen",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first.": "Regel {n} trifft zu, aber {use} hat kein Konto und keinen Schlüssel, der diese Anfrage annehmen kann, daher kommt {instead}, das die Regel danach nennt, zuerst.",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first, then {more}, which the rule names after it; the later rules' and the group's others stay behind them.": "Runde {turn} beginnt und Regel {n} trifft zu – {when} –, daher kommt {use} zuerst, dann {more}, das die Regel danach nennt; die späteren Regeln und die übrigen der Gruppe folgen dahinter.",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {instead}, which the rule names after it, goes first there.": "In {group} trifft Regel {n} zu, aber {use} hat kein Konto und keinen Schlüssel, der diese Anfrage annehmen kann, daher kommt dort {instead}, das die Regel danach nennt, zuerst.",
+    "Turn {turn} begins and rule {n} matches — {when} — so {use} goes first; the group's others stay behind it if it fails.": "Runde {turn} beginnt und Regel {n} trifft zu – {when} –, daher kommt {use} zuerst; die übrigen der Gruppe folgen dahinter, falls es fehlschlägt.",
+    "Rule {n} matches, but {use} has no account or key that can take this request, so the group's order stands.": "Regel {n} trifft zu, aber {use} hat kein Konto und keinen Schlüssel, der diese Anfrage annehmen kann, daher bleibt die Reihenfolge der Gruppe bestehen.",
+    "This turn began before magpie saw it, so the rules wait for the next one.": "Diese Runde begann, bevor magpie sie sah, daher warten die Regeln auf die nächste.",
+    "No rule matches turn {turn} (about {n} tokens{img}).": "Keine Regel trifft auf Runde {turn} zu (etwa {n} Token{img}).",
+    "the group {name}": "die Gruppe {name}",
+    "In {group}, rule {n} matches, but {use} has no account or key that can take this request, so {group}'s order stands.": "In {group} trifft Regel {n} zu, aber {use} hat kein Konto und keinen Schlüssel, der diese Anfrage annehmen kann, daher bleibt die Reihenfolge von {group} bestehen.",
+    "In {group}, rule {n} ({when}) sent turn {turn} to {use} as it began; the turn stays with whoever took it then.": "In {group} sendete Regel {n} ({when}) Runde {turn} zu Beginn an {use}; die Runde bleibt bei dem, der sie damals übernommen hat.",
+    "In {group}, rule {n} matches — {when} — so {use} goes first there.": "In {group} trifft Regel {n} zu – {when} –, daher kommt {use} dort zuerst.",
+    "In {group}, no rule matches.": "In {group} trifft keine Regel zu.",
+    "In {group}: {text}": "In {group}: {text}",
+    "{who} is one of {path}, a group in {name}; that group routes {mode}.": "{who} gehört zu {path}, einer Gruppe in {name}; diese Gruppe leitet {mode} weiter.",
+    ", with an image": ", mit Bild",
+    "Within turn {turn} the conversation grew to about {tokens} tokens, more than the model it was on takes, so rule {n} ({when}) moves it to {use}.": "In Runde {turn} wuchs die Unterhaltung auf etwa {tokens} Token, mehr als das bisherige Modell fasst, daher verschiebt Regel {n} ({when}) sie zu {use}.",
+    "{who} answered this conversation last, but a new turn begins and the group's rule {n} puts {use} first.": "{who} hat zuletzt in dieser Unterhaltung geantwortet, aber eine neue Runde beginnt und Regel {n} der Gruppe setzt {use} an die Spitze.",
+    "Several accounts or keys": "Mehrere Konten oder Schlüssel",
+    "each provider routes over its own": "jeder Anbieter leitet über seine eigenen weiter",
+    "Change how {name} routes": "Ändern, wie {name} weiterleitet",
+    "Only one account or key is on for this, so routing has nothing to choose between. Turn on a second in the provider's editor, and how it routes is set under Several accounts or keys below.": "Hier ist nur ein Konto oder Schlüssel aktiv, also hat die Weiterleitung keine Wahl. Aktiviere im Editor des Anbieters ein zweites; wie weitergeleitet wird, legst du dann unten unter „Mehrere Konten oder Schlüssel“ fest.",
+    "Smart, over the members' accounts and keys together: of the subscriptions with quota to spare, the one whose allowance renews soonest goes first — the week decides, and an account with five hours and no week (Claude Enterprise) goes by its five hours, so ahead of every week renewing later; one resting after a failure goes last.": "Intelligent, über Konten und Schlüssel aller Mitglieder zusammen: Von den Abos mit freiem Kontingent kommt das zuerst, dessen Kontingent sich am frühesten erneuert – die Woche entscheidet, und ein Konto mit fünf Stunden und ohne Woche (Claude Enterprise) richtet sich nach seinen fünf Stunden, also vor jeder später erneuerten Woche; eines, das nach einem Fehler pausiert, kommt zuletzt.",
+    "In order: the first model until it can't answer, then the next — each over its own accounts or keys as its provider routes them.": "Der Reihe nach: das erste Modell, bis es nicht mehr antworten kann, dann das nächste – jedes über seine eigenen Konten oder Schlüssel, wie sein Anbieter sie weiterleitet.",
+    "In turn: each conversation's next turn goes to the next member's account or key, spreading the load.": "Abwechselnd: Die nächste Runde jeder Unterhaltung geht an Konto oder Schlüssel des nächsten Mitglieds und verteilt so die Last.",
+    "Least used first: the account or key with the most of its allowance left goes first.": "Am wenigsten genutzt zuerst: Das Konto oder der Schlüssel mit dem größten Restkontingent kommt zuerst.",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — its week at its reset, or credits in it that expire sooner — so less of each member's allowance is lost; an account with five hours and no week (Claude Enterprise) by what its five hours have left per hour until they renew, so almost always first; a key by the tokens magpie sent it lately.": "Vor Ablauf aufbrauchen: Das Konto mit dem meisten Rest pro Stunde, bis er verfällt, kommt zuerst – seine Woche beim Zurücksetzen oder Guthaben darin, das früher abläuft –, damit von jedem Mitglied weniger verfällt; ein Konto mit fünf Stunden und ohne Woche (Claude Enterprise) nach dem Rest seiner fünf Stunden pro Stunde bis zur Erneuerung, also fast immer zuerst; ein Schlüssel nach den Token, die magpie ihm zuletzt gesendet hat.",
+    "A group among the models, and a model whose provider routes its accounts or keys other than Smart, keeps its own routing: this group only picks between it and the others, weighing it by the account or key it would try first, then tries it whole in its own order. A group among the models left on Smart is routed as this group is, unless this one goes In order, By weight or Manual.": "Eine Gruppe unter den Modellen und ein Modell, dessen Anbieter seine Konten oder Schlüssel anders als „Intelligent“ weiterleitet, behalten ihre eigene Weiterleitung: Diese Gruppe wählt nur zwischen ihr und den anderen, gewichtet nach dem Konto oder Schlüssel, den sie zuerst versuchen würde, und versucht sie dann als Ganzes in ihrer eigenen Reihenfolge. Eine Gruppe unter den Modellen, deren Weiterleitung auf „Intelligent“ steht, wird wie diese Gruppe weitergeleitet, außer diese geht „Der Reihe nach“, „Nach Gewicht“ oder „Manuell“.",
+    "errors your agent saw": "Fehler, die Ihr Agent sah",
+    "It said: {error}": "Meldung: {error}",
+    "Copilot's Auto picked {model} ({via})": "Copilots Auto wählte {model} ({via})",
+    "the model the account may pick by hand": "das Modell, das das Konto selbst wählen darf",
+    "not from /auto: {why}": "nicht über /auto: {why}",
+    "sent to {api}": "an {api} gesendet",
+    "sent to {api} with Auto's session token": "an {api} gesendet, mit Autos Sitzungstoken",
+    "Copilot refused it: {error}": "Copilot lehnte es ab: {error}",
+    "Show the latest request that failed": "Letzte fehlgeschlagene Anfrage anzeigen",
+    "another account's reasoning": "Reasoning eines anderen Kontos",
+    "reply too short": "Antwort zu kurz",
+    "reply asked past the window left": "Antwortlimit über dem freien Kontext",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} antwortete mit {status}: Der Anbieter lehnt den Systemprompt von {agent} bei jedem Konto ab, daher geht sie an den nächsten, bevor etwas von der Antwort {agent} erreicht. Mit {who} ist alles in Ordnung, daher pausiert es nicht.",
+    "{who} answered {status}: the vendor turns away {agent}'s system prompt whichever account it goes to, and nobody else is left to try, so {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who} antwortete mit {status}: Der Anbieter lehnt den Systemprompt von {agent} bei jedem Konto ab, und niemand sonst ist übrig, daher bekommt {agent} den Fehler. Mit {who} ist alles in Ordnung, daher pausiert es nicht.",
+    "request not understood": "Anfrage nicht verstanden",
+    "images not taken": "nimmt keine Bilder",
+    "{who} answered {status}: it takes no images, so it is asked again with the images described by the image recognition model, before any of the reply reaches {agent}. Later requests to it are described first. Nothing is wrong with {who}, so it doesn't rest.": "{who} antwortete mit {status}: Es nimmt keine Bilder, daher wird es erneut gefragt, mit den Bildern vom Bilderkennungsmodell beschrieben, bevor etwas von der Antwort {agent} erreicht. Spätere Anfragen werden zuerst beschrieben. Mit {who} ist alles in Ordnung, daher pausiert es nicht.",
+    "reasoning effort not in its plan": "Reasoning-Effort nicht im Plan",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, so another account goes on with it before any of the reply reaches {agent}. {who} serves other efforts, so it doesn't rest.": "{who} antwortete mit {status}: Sein Plan unterstützt den verlangten Reasoning-Effort nicht, daher übernimmt ein anderes Konto, bevor etwas von der Antwort {agent} erreicht. {who} bedient andere Effort-Stufen und pausiert daher nicht.",
+    "{who} answered {status}: its plan doesn't take the reasoning effort asked for, and no account left that does could answer, so {agent} gets an error saying so.": "{who} antwortete mit {status}: Sein Plan unterstützt den verlangten Reasoning-Effort nicht, und kein verbleibendes Konto, das ihn unterstützt, konnte antworten, daher erhält {agent} einen entsprechenden Fehler.",
+    "{who}: this computer had no network, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the network is back it is asked first again.": "{who}: Dieser Computer hatte kein Netzwerk, daher erreichte die Anfrage den Anbieter nie und geht an den nächsten. Mit {who} ist alles in Ordnung, daher pausiert es nicht: Sobald das Netzwerk zurück ist, wird es wieder zuerst gefragt.",
+    "{who}: this computer had no network, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Nothing is wrong with {who}, so it doesn't rest.": "{who}: Dieser Computer hatte kein Netzwerk, daher erreichte die Anfrage den Anbieter nie, und niemand sonst ist übrig: {agent} erhält den Fehler. Mit {who} ist alles in Ordnung, daher pausiert es nicht.",
+    "network down": "kein Netzwerk",
+    "servers overloaded": "Server überlastet",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor and goes on to the next. Nothing is wrong with {who}, so it doesn't rest: once the proxy is up it is asked first again.": "{who}: Der Proxy, über den magpie geht, hat die Verbindung nicht angenommen, daher erreichte die Anfrage den Anbieter nie und geht an den nächsten. Mit {who} ist alles in Ordnung, daher pausiert es nicht: Sobald der Proxy läuft, wird es wieder zuerst gefragt.",
+    "{who}: the proxy magpie goes through didn't take the connection, so the request never reached the vendor, and nobody is left to try: {agent} gets the error. Start the proxy, or change it in Settings.": "{who}: Der Proxy, über den magpie geht, hat die Verbindung nicht angenommen, daher erreichte die Anfrage den Anbieter nie, und es bleibt niemand zum Versuchen: {agent} erhält den Fehler. Starten Sie den Proxy oder ändern Sie ihn in den Einstellungen.",
+    "{who} answered {status}: its API couldn't read something in the request that another's may, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "{who} antwortete mit {status}: Seine API konnte etwas in der Anfrage nicht lesen, das eine andere vielleicht kann, daher geht sie an den nächsten, bevor etwas von der Antwort {agent} erreicht. Mit {who} ist alles in Ordnung, daher pausiert es nicht.",
+    "{who}'s safety filter refused the request before saying anything, so it goes on to the next before any of the reply reaches {agent}. Nothing is wrong with {who}, so it doesn't rest.": "Der Sicherheitsfilter von {who} hat die Anfrage abgelehnt, bevor etwas gesagt wurde, daher geht sie an den nächsten, bevor etwas von der Antwort {agent} erreicht. Mit {who} ist alles in Ordnung, daher pausiert es nicht.",
+    "{who}'s safety filter refused the request before saying anything, and nobody is left to try, so {agent} gets an error saying so, not an empty reply to ask again for.": "Der Sicherheitsfilter von {who} hat die Anfrage abgelehnt, bevor etwas gesagt wurde, und es bleibt niemand zum Versuchen, daher erhält {agent} einen entsprechenden Fehler statt einer leeren Antwort, die erneut angefragt würde.",
+    "The vendor wants the account verified first: it rests half an hour, or until you say it's verified": "Der Anbieter verlangt zuerst eine Verifizierung des Kontos: Es pausiert eine halbe Stunde oder bis Sie die Verifizierung bestätigen",
+    "{who} answered {status}: the vendor wants the account verified before it serves it again, and nobody is left to try, so {agent} gets the error with how to verify it. For a minute {agent}'s retries get the same answer without asking the vendor.": "{who} antwortete mit {status}: Der Anbieter verlangt eine Verifizierung des Kontos, bevor er es wieder bedient, und es bleibt niemand zum Versuchen, daher erhält {agent} den Fehler samt Anleitung zur Verifizierung. Eine Minute lang erhalten Wiederholungen von {agent} dieselbe Antwort, ohne den Anbieter zu fragen.",
+    "Verify the account ↗": "Konto verifizieren ↗",
+    "It's verified — try it again": "Verifiziert – erneut versuchen",
+    "account restricted by the vendor": "Konto vom Anbieter gesperrt",
+    "The vendor restricted the account: it rests {d}, as only the vendor lifting the restriction brings it back. Appeal with the vendor; once it's lifted, try it again here": "Der Anbieter hat das Konto gesperrt: Es pausiert {d}, denn nur die Aufhebung der Sperre durch den Anbieter bringt es zurück. Legen Sie beim Anbieter Einspruch ein; sobald sie aufgehoben ist, versuchen Sie es hier erneut",
+    "The restriction is lifted — try it again": "Die Sperre ist aufgehoben – erneut versuchen",
+    "{who} turned away the reasoning effort changed mid-conversation as an update that keeps its cache, so it is asked again at the new effort the usual way, before any of the reply reaches {agent}.": "{who} hat den mitten in der Unterhaltung als cache-erhaltendes Update geänderten Reasoning-Effort abgelehnt, daher wird es auf normalem Weg mit dem neuen Effort erneut gefragt, bevor etwas von der Antwort {agent} erreicht.",
+    "{who} takes no request for a reply as short as this one asked for, so it is asked again for the shortest it gives, before any of the reply reaches {agent}.": "{who} nimmt keine Anfrage nach einer so kurzen Antwort wie verlangt an, daher wird es erneut nach der kürzesten möglichen gefragt, bevor etwas von der Antwort {agent} erreicht.",
+    "{who} couldn't read the reasoning another account wrote earlier in this conversation, so it is asked again without it, before any of the reply reaches {agent}.": "{who} konnte das Reasoning nicht lesen, das ein anderes Konto zuvor in dieser Unterhaltung geschrieben hat, daher wird es ohne dieses erneut gefragt, bevor etwas von der Antwort {agent} erreicht.",
+    "{agent} canceled the request while {who} was answering: nobody failed, so nobody rests and nobody else is asked.": "{agent} hat die Anfrage abgebrochen, während {who} antwortete: Niemand ist fehlgeschlagen, daher pausiert niemand und kein anderer wird gefragt.",
+    "{who} answered {status} · {fail}, a failure that may pass. The conversation is kept on {who} for what its vendor cached of it, so it is asked once more in {d} before the request moves to another.": "{who} antwortete mit {status} · {fail}, möglicherweise ein vorübergehender Fehler. Das Gespräch bleibt bei {who}, wegen dem, was sein Anbieter davon zwischengespeichert hat, daher wird es in {d} noch einmal gefragt, bevor die Anfrage zu einem anderen wechselt.",
+    "{who} answered {status} · {fail}, and nobody else is left to ask — a failure that may pass, so it is tried again in {d}, before any of the reply reaches {agent}.": "{who} antwortete mit {status} · {fail}, und es bleibt niemand sonst zum Fragen – möglicherweise ein vorübergehender Fehler, daher wird es in {d} erneut versucht, bevor etwas von der Antwort {agent} erreicht.",
+    "{who} answered {status} · {fail}, and was to be asked again in {d}, but {agent} canceled the request before then, so nobody is asked again.": "{who} antwortete {status} · {fail} und sollte in {d} erneut gefragt werden, doch {agent} hat die Anfrage vorher abgebrochen, daher wird niemand erneut gefragt.",
+    "Back to live": "Zurück zu live",
+    "Replay them all": "Alle wiedergeben",
+    "Stop replay": "Wiedergabe stoppen",
+    "{n}× speed": "{n}× Geschwindigkeit",
+    "skipping a quiet stretch · clock {n}×": "ruhige Phase wird übersprungen · Uhr {n}×",
+    "request {i} of {n}": "Anfrage {i} von {n}",
+    "sent {time}": "gesendet {time}",
+    "Replay from here": "Ab hier wiedergeben",
+    "{n} on {day}": "{n} am {day}",
+    "the last {n} of {day}": "die letzten {n} vom {day}",
+    "How the last request was routed": "Wie die letzte Anfrage weitergeleitet wurde",
+    "How the request at {time} was routed": "Wie die Anfrage um {time} weitergeleitet wurde",
+    "No request yet": "Noch keine Anfrage",
+    "Send one from any agent routed through magpie and it plays here as it happens: who routing put first and why, each try, and what each answered.": "Senden Sie eine von einem beliebigen über magpie weitergeleiteten Agenten, und sie wird hier live abgespielt: wen die Weiterleitung an die Spitze gesetzt hat und warum, jeder Versuch und was jeweils geantwortet wurde.",
+    "Every request an agent sends to magpie shows up here, routed for real.": "Jede Anfrage, die ein Agent an magpie sendet, erscheint hier, tatsächlich weitergeleitet.",
+    "Another magpie serves the gateway; its routing plays live in that magpie's window.": "Ein anderes magpie stellt den Zugangspunkt bereit; seine Weiterleitung wird live in dessen Fenster abgespielt.",
+    "The gateway isn't running, so nothing is routed.": "Der Zugangspunkt läuft nicht, daher wird nichts weitergeleitet.",
+    "The gateway is served by a magpie without a window (magpie serve), so its routing can't be watched. Stop it and let this magpie serve the gateway to see routing live.": "Der Zugangspunkt wird von einem magpie ohne Fenster (magpie serve) bereitgestellt, daher lässt sich seine Weiterleitung nicht beobachten. Beenden Sie es und lassen Sie dieses magpie den Zugangspunkt bereitstellen, um die Weiterleitung live zu sehen.",
+    "Smart: of the accounts with quota to spare, the one whose allowance renews soonest goes first — what it has left would be lost at the reset. The week decides; an account with five hours and no week goes by its five hours. One at 90% or more waits until the others can't answer; one resting after a failure goes last.": "Intelligent: Von den Konten mit freiem Kontingent kommt das zuerst, dessen Kontingent sich am frühesten erneuert – sein Rest würde beim Zurücksetzen verfallen. Die Woche entscheidet; ein Konto mit fünf Stunden und ohne Woche richtet sich nach seinen fünf Stunden. Eines ab 90 % wartet, bis die anderen nicht antworten können; eines, das nach einem Fehler pausiert, kommt zuletzt.",
+    "Smart: keys that suit the request go first — one made for the model's own API — then in their order. One resting after a failure goes last.": "Intelligent: Schlüssel, die zur Anfrage passen, kommen zuerst – einer für die eigene API des Modells –, dann in ihrer Reihenfolge. Einer, der nach einem Fehler pausiert, kommt zuletzt.",
+    "In order: the first answers everything until it can't; then the next.": "Der Reihe nach: Der erste beantwortet alles, bis er nicht mehr kann; dann der nächste.",
+    "In turn: each conversation's next turn goes to the account after the one that answered its last, and a new conversation starts one further along; the requests within a turn stay put, keeping the prompt cache.": "Abwechselnd: Die nächste Runde jeder Unterhaltung geht an das Konto nach dem, das die letzte beantwortet hat, und eine neue Unterhaltung beginnt eines weiter; die Anfragen innerhalb einer Runde bleiben, sodass der Prompt-Cache erhalten bleibt.",
+    "Least used first: the account with the most of its allowance left goes first; a key by the tokens magpie sent it lately.": "Am wenigsten genutzt zuerst: Das Konto mit dem größten Restkontingent kommt zuerst; ein Schlüssel nach den Token, die magpie ihm zuletzt gesendet hat.",
+    "Use before expiry: the account with the most left per hour until it is lost goes first — at its reset, or, when credits in it expire sooner, by those that expire first; an account with five hours and no week by what its five hours have left per hour. One at 90% or more waits until the others can't answer; a key by the tokens magpie sent it lately.": "Vor Ablauf aufbrauchen: Das Konto mit dem meisten Rest pro Stunde, bis er verfällt, kommt zuerst – beim Zurücksetzen oder, wenn Guthaben darin früher abläuft, nach dem, das zuerst abläuft; ein Konto mit fünf Stunden und ohne Woche nach dem Rest seiner fünf Stunden pro Stunde. Eines ab 90 % wartet, bis die anderen nicht antworten können; ein Schlüssel nach den Token, die magpie ihm zuletzt gesendet hat.",
+    "Nothing could take {model}.": "Nichts konnte {model} übernehmen.",
+    "{who} is the only one, so it's tried though it is resting.": "{who} ist das einzige und wird daher versucht, obwohl es pausiert.",
+    "{who} is the only account on for {model} — nothing to choose between.": "{who} ist das einzige aktive Konto für {model} – nichts zu wählen.",
+    "{name} has one key on — nothing to choose between.": "{name} hat einen aktiven Schlüssel – nichts zu wählen.",
+    "Every one is resting after a failure, so {who}, first in line, is tried all the same.": "Alle pausieren nach einem Fehler, daher wird {who} als Erstes in der Reihe trotzdem versucht.",
+    "{name} is resting, so its fallback {fb} goes first.": "{name} pausiert, daher kommt sein Ausweich {fb} zuerst.",
+    "In order: {who} is first, and answers everything while it can.": "Der Reihe nach: {who} ist zuerst dran und beantwortet alles, solange es kann.",
+    "Until used up: one answers everything until its quota is used up; then the next, which keeps them even after the one before renews.": "Bis aufgebraucht: Eines beantwortet alles, bis sein Kontingent aufgebraucht ist; dann das nächste, das sie behält, auch wenn sich das vorherige erneuert.",
+    "Until used up: one account or key, across the members, takes every request until it is used up; then the next in the list, which keeps them even after an earlier one renews. One rate limited or failing is passed over only while it rests.": "Bis aufgebraucht: Ein Konto oder Schlüssel über alle Mitglieder nimmt jede Anfrage, bis es aufgebraucht ist; dann das nächste in der Liste, das sie behält, auch wenn sich ein früheres erneuert. Eines, das rate-limitiert ist oder fehlschlägt, wird nur übergangen, solange es ruht.",
+    "Until used up: {who} is the one in use, and answers everything until it is used up.": "Bis aufgebraucht: {who} ist das aktuelle und beantwortet alles, bis es aufgebraucht ist.",
+    "In turn: it's {who}'s turn — each request starts one further along.": "Abwechselnd: {who} ist an der Reihe – jede Anfrage beginnt eines weiter.",
+    "Least used first: {who} has the most of its allowance left — {n} used.": "Am wenigsten genutzt zuerst: {who} hat das größte Restkontingent – {n} verbraucht.",
+    "Least used first: {who} served the fewest tokens lately — {n}.": "Am wenigsten genutzt zuerst: {who} hat zuletzt die wenigsten Token verarbeitet – {n}.",
+    "Least used first: {who} goes first.": "Am wenigsten genutzt zuerst: {who} kommt zuerst.",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} left, resets in {d}.": "Vor Ablauf aufbrauchen: {who} hat das meiste Restkontingent pro Stunde bis zum Zurücksetzen – {n} übrig, Zurücksetzen in {d}.",
+    "Use before expiry: {who} has the most remaining allowance per hour until one of its Codex resets about to run out is used by itself — {n} left, used in {d}.": "Vor Ablauf aufbrauchen: {who} hat das meiste Restkontingent pro Stunde, bis einer seiner bald verfallenden Codex-Resets von selbst eingelöst wird – {n} übrig, eingelöst in {d}.",
+    "Use before expiry: {who} has the most credits expiring per hour until they expire — {n} of its allowance expires in {d}.": "Vor Ablauf aufbrauchen: {who} hat pro Stunde bis zum Ablauf das meiste ablaufende Guthaben – {n} seines Kontingents läuft in {d} ab.",
+    "Use before expiry: {who} has the most remaining allowance per hour until reset — {n} used.": "Vor Ablauf aufbrauchen: {who} hat das meiste Restkontingent pro Stunde bis zum Zurücksetzen – {n} verbraucht.",
+    "Use before expiry: {who} served the fewest tokens lately — {n}.": "Vor Ablauf aufbrauchen: {who} hat zuletzt die wenigsten Token verarbeitet – {n}.",
+    "Use before expiry: {who} goes first.": "Vor Ablauf aufbrauchen: {who} kommt zuerst.",
+    "{who} goes first: it's made for {api}, the API {model} is at home in, so nothing is translated.": "{who} kommt zuerst: Es ist für {api} gedacht, die native API von {model}, daher wird nichts übersetzt.",
+    "{who} goes first: keys go in their order, those that suit the request first.": "{who} kommt zuerst: Schlüssel gehen in ihrer Reihenfolge, die zur Anfrage passenden zuerst.",
+    "{who} goes first.": "{who} kommt zuerst.",
+    "its provider is set to be used first.": "sein Anbieter ist auf „Zuerst verwenden“ gestellt.",
+    "{who} goes first: its provider is set to be used first.": "{who} kommt zuerst: sein Anbieter ist auf „Zuerst verwenden“ gestellt.",
+    "The vendor hasn't said yet what these accounts have left, so they go in their order: {who} first.": "Der Anbieter hat noch nicht mitgeteilt, was diese Konten übrig haben, daher gehen sie in ihrer Reihenfolge: {who} zuerst.",
+    "Every account is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "Jedes Konto liegt bei 90 % oder mehr seines Kontingents, daher kommt das mit dem größten Rest zuerst: {who}, bei {n}.",
+    "Every key and account here is at 90% or more of its allowance, so the one with the most left goes first: {who}, at {n}.": "Jeder Schlüssel und jedes Konto hier liegt bei 90 % oder mehr seines Kontingents, daher kommt das mit dem größten Rest zuerst: {who}, bei {n}.",
+    "{who} goes first: it has quota to spare, and the others are kept for last.": "{who} kommt zuerst: Es hat freies Kontingent, die anderen werden für zuletzt aufgehoben.",
+    "{who} goes first: of those with quota to spare, its allowance starts again soonest — one of its Codex resets about to run out is used by itself in {d}, and what it has left then is lost. {other} renews later and keeps its own.": "{who} kommt zuerst: Von denen mit freiem Kontingent beginnt seines am frühesten neu – einer seiner bald verfallenden Codex-Resets wird in {d} von selbst eingelöst, und der Rest verfällt dann. {other} erneuert sich später und behält seines.",
+    "{who} goes first: of those with quota to spare, its allowance renews soonest — in {d} — and what it has left then is lost. {other} renews later and keeps its own.": "{who} kommt zuerst: Von denen mit freiem Kontingent erneuert sich seines am frühesten – in {d} –, und der Rest verfällt dann. {other} erneuert sich später und behält seines.",
+    "{who} goes first: its allowance renews in the same hour as {other}'s, and its shorter one sooner — in {d}.": "{who} kommt zuerst: Sein Kontingent erneuert sich in derselben Stunde wie das von {other}, sein kürzeres aber früher – in {d}.",
+    "{who} and {other} renew within the same hour, so the order given stays — and the vendor's prompt cache stays warm.": "{who} und {other} erneuern sich in derselben Stunde, daher bleibt die vorgegebene Reihenfolge – und der Prompt-Cache des Anbieters bleibt warm.",
+    "{who} goes first, in the order given: when its allowance renews isn't known.": "{who} kommt gemäß vorgegebener Reihenfolge zuerst: Wann sich sein Kontingent erneuert, ist unbekannt.",
+    "{who} goes first: of those alike, its wallet has the most left — {n}, where {other} has {m}.": "{who} kommt zuerst: Unter den gleichartigen hat sein Guthaben am meisten übrig — {n}, {other} hat {m}.",
+    "{who} is resting — {why}, {when} — so it waits at the back.": "{who} pausiert – {why}, {when} – und wartet daher hinten.",
+    "{who} is at {n} — all but used up, it answers only when nothing else can.": "{who} liegt bei {n} – fast aufgebraucht, es antwortet nur, wenn nichts anderes kann.",
+    "{who} is at {n} — kept for when the others can't.": "{who} liegt bei {n} – aufgehoben für den Fall, dass die anderen nicht können.",
+    "{member} isn't passed over for being near its limit: by weight this request was {first}'s share, and {member} takes its own share of the requests while it can answer.": "{member} wird nicht übergangen, weil es fast am Limit ist: nach Gewicht war diese Anfrage der Anteil von {first}, und {member} bekommt seinen eigenen Anteil der Anfragen, solange es antworten kann.",
+    "{member} isn't passed over for being near its limit: it comes after {first} in {group}'s order.": "{member} wird nicht übergangen, weil es fast am Limit ist: es kommt in der Reihenfolge von {group} nach {first}.",
+    "{who}: what it has left isn't known yet, so it goes after those known.": "{who}: Sein Rest ist noch unbekannt, daher kommt es nach den bekannten.",
+    "{who}: what it has left isn't known yet, and its answer tells, so it goes before those known.": "{who}: Sein Rest ist noch unbekannt, und seine Antwort verrät ihn, daher kommt es vor den bekannten.",
+    "{who} goes first: what it has left isn't known yet, and its answer tells — kept behind those known, it would never answer and never be known.": "{who} kommt zuerst: Sein Rest ist noch unbekannt, und seine Antwort verrät ihn – hinter den bekannten würde es nie antworten und nie bekannt werden.",
+    "{who} is left out: its plan doesn't list {model}.": "{who} bleibt außen vor: Sein Plan enthält {model} nicht.",
+    "{who} is left out: {name} lists {model} to its other keys, not this one.": "{who} bleibt außen vor: {name} listet {model} für seine anderen Schlüssel, nicht für diesen.",
+    "{who} is answering…": "{who} antwortet…",
+    "rerouted from {from}": "umgeleitet von {from}",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the model of its latest chat turn, so it stays with the provider the chat is on.": "{agent} hat {model} selbst für eine kurze Anfrage ohne Werkzeuge gewählt, etwa den Titel eines Chats; magpie hat sie mit {to} beantwortet, dem Modell seines letzten Chat-Zugs, damit sie beim Anbieter des Chats bleibt.",
+    "{agent} picked {model} by itself for a short request without tools, such as a chat's title; magpie served it on {to}, the first model it lists, as it has had no chat turn yet.": "{agent} hat {model} selbst für eine kurze Anfrage ohne Werkzeuge gewählt, etwa den Titel eines Chats; magpie hat sie mit {to} beantwortet, dem ersten Modell seiner Liste, da es noch keinen Chat-Zug gab.",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model of its latest chat turn.": "{agent} hat {model} angefordert, das magpie nicht anbietet; magpie hat sie mit {to} beantwortet, dem Modell seines letzten Chat-Zugs.",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the first model it lists.": "{agent} hat {model} angefordert, das magpie nicht anbietet; magpie hat sie mit {to} beantwortet, dem ersten Modell seiner Liste.",
+    "Claude Code in {agent} asked for {model}, its own id for a Claude tier; magpie served it on {to}, the model picked for that tier.": "Claude Code in {agent} hat {model} mit seiner eigenen ID für eine Claude-Stufe angefordert; magpie hat sie mit {to} beantwortet, dem für diese Stufe gewählten Modell.",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, that tier's model on the provider the chat is on.": "Claude Code in {agent} hat {model} für einen eigenen Aufruf angefordert; magpie hat ihn mit {to} beantwortet, dem Modell dieser Stufe beim Anbieter des Chats.",
+    "Claude Code in {agent} asked for {model} for a call of its own; magpie served it on {to}, the chat's model, so it stays with the provider the chat is on.": "Claude Code in {agent} hat {model} für einen eigenen Aufruf angefordert; magpie hat ihn mit {to} beantwortet, dem Modell des Chats, damit er beim Anbieter des Chats bleibt.",
+    "{agent}'s auto mode classifier asked for {model}; magpie served it on {to}, the model /model moved its tier to.": "Der Klassifikator des Automodus von {agent} hat {model} angefordert; magpie hat ihn mit {to} beantwortet, dem Modell, auf das /model seine Stufe gesetzt hat.",
+    "{agent} asked for {model} by Claude's full id; magpie served it on {to}, the model set for that tier.": "{agent} hat {model} mit Claudes voller ID angefordert; magpie hat sie mit {to} beantwortet, dem für diese Stufe festgelegten Modell.",
+    "{agent} asked for {model}, which magpie doesn't serve; magpie served it on {to}, the model its config names.": "{agent} hat {model} angefordert, das magpie nicht anbietet; magpie hat sie mit {to} beantwortet, dem Modell aus seiner Konfiguration.",
+    "{agent} asked for {model} for a call of its own, which magpie doesn't serve; magpie served it on {to}, the model its last turn was answered on.": "{agent} hat für einen eigenen Aufruf {model} angefordert, das magpie nicht anbietet; magpie hat ihn mit {to} beantwortet, dem Modell, das seinen letzten Zug beantwortet hat.",
+    "{agent} asked for {model}, one of its own default models, for its memories, and its config names no model for them; magpie served it on {to}, the model of its conversation.": "{agent} hat für seine Erinnerungen {model} angefordert, eines seiner eigenen Standardmodelle, und seine Konfiguration legt dafür kein Modell fest; magpie hat sie mit {to} beantwortet, dem Modell seiner Unterhaltung.",
+    "Masking would have changed this request, so magpie sent it as written to {to}, the model set for that in Settings › Privacy.": "Die Maskierung hätte diese Anfrage verändert, daher hat magpie sie unverändert an {to} gesendet, das dafür unter Einstellungen › Datenschutz festgelegte Modell.",
+    "magpie served it on {to} in place of {model}.": "magpie hat sie mit {to} statt {model} beantwortet.",
+    "Stand-in": "Ersatz",
+    "{who} answered in {ms}{tk}. {agent} got one clean reply and never saw the {n} that failed first.": "{who} antwortete in {ms}{tk}. {agent} erhielt eine saubere Antwort und sah die {n} vorherigen Fehlschläge nie.",
+    "{who} answered in {ms}{tk}.": "{who} antwortete in {ms}{tk}.",
+    "{who} answered {status} · {fail}. {how}; the request goes on to {next} before any of the reply reaches {agent}.": "{who} antwortete mit {status} · {fail}. {how}; die Anfrage geht an {next}, bevor etwas von der Antwort {agent} erreicht.",
+    "{who} answered {status} and nobody is left to try, so {agent} gets the error.": "{who} antwortete mit {status}, und es bleibt niemand zum Versuchen, daher erhält {agent} den Fehler.",
+    "{who} answered {status} — an error another account wouldn't fix, so {agent} gets it.": "{who} antwortete mit {status} – ein Fehler, den ein anderes Konto nicht beheben würde, daher erhält {agent} ihn.",
+    "{who} hadn't begun answering after {ms}, and nobody is left to try, so {agent} gets the error.": "{who} hatte nach {ms} noch nicht zu antworten begonnen, und es bleibt niemand zum Versuchen, daher erhält {agent} den Fehler.",
+    "{who} answered {status} and nobody is left to try. {agent} gets the error an earlier try gave, not this used-up allowance, so it doesn't stop as if every account were out.": "{who} antwortete mit {status}, und es bleibt niemand zum Versuchen. {agent} erhält den Fehler eines früheren Versuchs, nicht dieses aufgebrauchte Kontingent, und hält daher nicht an, als wären alle Konten erschöpft.",
+    "{who} answered {status}.": "{who} antwortete mit {status}.",
+    "{who} answered {status}, and the request goes on to {next} before any of the reply reaches {agent}. {who} doesn't rest for it.": "{who} antwortete mit {status}, und die Anfrage geht an {next}, bevor etwas von der Antwort {agent} erreicht. {who} pausiert deswegen nicht.",
+    "{who} answered {status} · {fail}. {how}; nobody is left to try, so {agent} gets the error.": "{who} antwortete mit {status} · {fail}. {how}; es bleibt niemand zum Versuchen, daher erhält {agent} den Fehler.",
+    "{who} began answering, then broke off · {fail}. {agent} got what was said before the error; {how}, so {agent}'s next request goes to another first.": "{who} begann zu antworten und brach dann ab · {fail}. {agent} erhielt, was vor dem Fehler gesagt wurde; {how}, daher geht die nächste Anfrage von {agent} zuerst an ein anderes.",
+    "{who} began answering, then broke off. {agent} got what was said before the error; the conversation isn't kept on {who} for its next request.": "{who} begann zu antworten und brach dann ab. {agent} erhielt, was vor dem Fehler gesagt wurde; die Unterhaltung bleibt für die nächste Anfrage nicht bei {who}.",
+    "It rests {d}, as the vendor's Retry-After says": "Es pausiert {d}, laut Retry-After des Anbieters",
+    "It sits out half an hour, until someone tops it up": "Es setzt eine halbe Stunde aus, bis jemand Guthaben auflädt",
+    "Its allowance is used up: it rests until that renews, at {time}": "Sein Kontingent ist aufgebraucht: Es pausiert bis zur Erneuerung um {time}",
+    "It rests until {time}, when the vendor says the limit resets": "Es pausiert bis {time}, wenn laut Anbieter das Limit zurückgesetzt wird",
+    "It rests 15 minutes: out of quota, with no word of when it resets": "Es pausiert 15 Minuten: Kontingent aufgebraucht, ohne Angabe zum Zurücksetzen",
+    "It has failed {n} times in a row: it rests {d}, longer each time": "Es ist {n}-mal in Folge fehlgeschlagen: Es pausiert {d}, jedes Mal länger",
+    "It rests {d}, longer if it fails again": "Es pausiert {d}, länger bei erneutem Fehler",
+    "It doesn't rest: its provider is set to ask it again after an error like this": "Es pausiert nicht: Sein Anbieter ist so eingestellt, dass es nach einem solchen Fehler wieder gefragt wird",
+    "It rests {d}": "Es pausiert {d}",
+    "It cools down {d}: the vendor didn't say for how long": "Es kühlt {d} ab: Der Anbieter hat keine Dauer genannt",
+    "It was rate limited again as soon as it was back ({n} times in a row): it rests {d}, longer each time until it answers": "Es erhielt gleich nach der Rückkehr erneut ein Rate-Limit ({n}-mal in Folge): Es pausiert {d}, jedes Mal länger, bis es antwortet",
+    "With {rested} resting after a failure, {who} goes first: ": "Da {rested} nach einem Fehler pausiert, kommt {who} zuerst: ",
+    "the others go in their order.": "die anderen gehen in ihrer Reihenfolge.",
+    "In order: with {rested} resting after a failure, {who} is the first that can answer.": "Der Reihe nach: Da {rested} nach einem Fehler pausiert, ist {who} das erste, das antworten kann.",
+    "{agent} asked for {model}": "{agent} verlangte {model}",
+    "Background memory task": "Memory-Aufgabe im Hintergrund",
+    "Codex is organizing memories from earlier chats in the background. This can continue after a chat finishes.": "Codex ordnet im Hintergrund Erinnerungen aus früheren Chats. Das kann nach dem Ende eines Chats weiterlaufen.",
+    "Title requests were automatically matched using the prompt and the applied chat title.": "Titelanfragen wurden anhand des Prompts und des übernommenen Chat-Titels automatisch zugeordnet.",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it; other providers (such as Claude) are excluded regardless of quota.": "Diese Subagenten-Aufgabe ist verschlüsselt. Nur ChatGPT-Konten können sie lesen; andere Anbieter (etwa Claude) sind unabhängig vom Kontingent ausgeschlossen.",
+    "This subagent task is encrypted. Only ChatGPT accounts can read it.": "Diese Subagent-Aufgabe ist verschlüsselt. Nur ChatGPT-Konten können sie lesen.",
+    "{who} goes first: it answered the parent agent and may be needed to read this encrypted task.": "{who} kommt zuerst: Es hat dem übergeordneten Agenten geantwortet und wird eventuell zum Lesen dieser verschlüsselten Aufgabe gebraucht.",
+    "{who} compacted this conversation natively, and only it can read that compaction, so the conversation stays on it: other accounts aren't asked. Start a new conversation to use them.": "{who} hat diese Unterhaltung nativ komprimiert, und nur es kann diese Komprimierung lesen, also bleibt die Unterhaltung dort: andere Konten werden nicht gefragt. Starte eine neue Unterhaltung, um sie zu nutzen.",
+    "{agent} requested a subagent; magpie selects its model within this routing group.": "{agent} hat einen Subagenten angefordert; magpie wählt sein Modell innerhalb dieser Weiterleitungsgruppe.",
+    "{agent} requested a subagent on {model}.": "{agent} hat einen Subagent mit {model} angefordert.",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents are set to {to}, but {why}.": "{agent} hat einen Subagent mit {model} angefordert, und er blieb dort: Seine Subagenten sind auf {to} gesetzt, aber {why}.",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model set for its subagents.": "{agent} hat einen Subagent mit {model} angefordert; magpie hat ihn auf {to} gesetzt, das für seine Subagenten festgelegte Modell.",
+    "{agent} requested a subagent on {model}; magpie put it on {to}, the model its lead is on.": "{agent} hat einen Subagent mit {model} angefordert; magpie hat ihn auf {to} gesetzt, das Modell seines Haupt-Agenten.",
+    "{agent} requested a subagent on {model} and it stayed there: its subagents follow their lead, on {to}, but {why}.": "{agent} hat einen Subagent mit {model} angefordert, und er blieb dort: Seine Subagenten folgen dem Haupt-Agenten auf {to}, aber {why}.",
+    "Background prompt suggestions": "Prompt-Vorschläge im Hintergrund",
+    "magpie ran this web search for {agent}'s {model}, which can't search the web by itself: {searcher} searched, and {model} goes on answering once it has what was found. Not a turn of the conversation.": "magpie hat diese Websuche für {model} von {agent} ausgeführt, das selbst nicht im Web suchen kann: {searcher} hat gesucht, und {model} antwortet weiter, sobald es die Ergebnisse hat. Keine Runde der Unterhaltung.",
+    "{agent} called magpie's web_search MCP tool: {searcher} searched for it. Not a turn of the conversation.": "{agent} hat das web_search-MCP-Tool von magpie aufgerufen: {searcher} hat dafür gesucht. Keine Runde der Unterhaltung.",
+    "{agent} called magpie's analyze_image MCP tool: {describer} looked at the image for it. Not a turn of the conversation.": "{agent} hat das analyze_image-MCP-Tool von magpie aufgerufen: {describer} hat sich das Bild dafür angesehen. Keine Runde der Unterhaltung.",
+    "magpie ran this web search for a model that can't search the web by itself: {searcher} searched, and that model goes on answering once it has what was found. Not a turn of the conversation.": "magpie hat diese Websuche für ein Modell ausgeführt, das selbst nicht im Web suchen kann: {searcher} hat gesucht, und dieses Modell antwortet weiter, sobald es die Ergebnisse hat. Keine Runde der Unterhaltung.",
+    "Every turn starts with a request to {name}, a subscription: it counts against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "Jede Runde beginnt mit einer Anfrage an {name}, ein Abo: Sie zählt wie die eigenen Anfragen des Agenten gegen dessen Kontingent. Ein kostenloses Modell oder eines mit API-Schlüssel lässt das Abo den Agenten.",
+    "Every turn starts with two requests to {name}, a subscription: they count against its allowance as the agent's own do. A free model or one on an API key leaves the subscription to the agents.": "Jede Runde beginnt mit zwei Anfragen an {name}, ein Abo: Sie zählen wie die eigenen Anfragen des Agenten gegen dessen Kontingent. Ein kostenloses Modell oder eines mit API-Schlüssel lässt das Abo den Agenten.",
+    "magpie had {describer} describe an image for {agent}'s {model}: nothing magpie knows says {model} can see images, so it is counted as text-only and given the description in the image's place. If it does see them, tick “Accepts images” for it in its provider's models. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie ließ {describer} ein Bild für {model} von {agent} beschreiben: Nichts, was magpie weiß, sagt, dass {model} Bilder sehen kann, daher gilt es als reines Textmodell und erhält die Beschreibung anstelle des Bildes. Wenn es doch Bilder sieht, aktiviere „Akzeptiert Bilder“ dafür bei den Modellen seines Anbieters. Unter Einstellungen › Modelle › Bilderkennung wählst du das Modell, das beschreibt. Keine Runde der Unterhaltung.",
+    "magpie had {describer} describe an image for {agent}'s {model}, which its provider's list or its own setting says takes text only: {model} is given the description in the image's place. Settings › Models › Image recognition picks the model that describes. Not a turn of the conversation.": "magpie ließ {describer} ein Bild für {model} von {agent} beschreiben, das laut der Modellliste seines Anbieters oder seiner eigenen Einstellung nur Text annimmt: {model} erhält die Beschreibung anstelle des Bildes. Unter Einstellungen › Modelle › Bilderkennung wählst du das Modell, das beschreibt. Keine Runde der Unterhaltung.",
+    "magpie had {describer} describe an image for a model that can't see images, which is given the description in the image's place. Not a turn of the conversation.": "magpie ließ {describer} ein Bild für ein Modell beschreiben, das keine Bilder sehen kann und die Beschreibung anstelle des Bildes erhält. Keine Runde der Unterhaltung.",
+    "{agent} drafted the suggested prompts on its home page by itself, in the background, searching the project's files and connected apps, and checked them for safety. Not a turn of the conversation; Codex's Settings › Configuration › Suggested prompts turns it off.": "{agent} hat die vorgeschlagenen Prompts auf seiner Startseite selbst im Hintergrund entworfen, dabei die Projektdateien und verbundene Apps durchsucht und sie auf Sicherheit geprüft. Keine Runde der Unterhaltung; abschalten lässt es sich in Codex unter Einstellungen › Konfiguration › Prompt-Vorschläge.",
+    "{agent} sent this turn on Luna Reserve, which it turns to once the plan's own allowance is used up; it picks the model itself.": "{agent} hat diese Runde über Luna Reserve gesendet, worauf es zurückgreift, sobald das eigene Kontingent des Plans aufgebraucht ist; das Modell wählt es selbst.",
+    "{agent} made this call itself ({kind}), not as a turn of the conversation, and picks its model itself.": "{agent} hat diesen Aufruf selbst ausgeführt ({kind}), nicht als Runde der Unterhaltung, und wählt sein Modell selbst.",
+    "{agent} checked that magpie answers, as it does when it starts and from its Test connection. It names this check's model itself, from the names in its model list ({model}), not the model chosen in the conversation, and only reads whether an answer comes back; magpie sends it to the model chosen in {agent}'s model menu, or to its first listed model when none is. Not a turn of the conversation.": "{agent} prüft, ob magpie antwortet, beim Start und über „Test connection“. Das Modell dieser Prüfung wählt es selbst nach den Namen in seiner Modellliste ({model}), nicht das im Gespräch gewählte, und liest nur, ob eine Antwort kommt; magpie schickt sie an das in {agent}s Modellmenü gewählte Modell oder, wenn keins gewählt ist, an das erste der Liste. Kein Zug des Gesprächs.",
+    "Nothing was tried: {error}": "Nichts wurde versucht: {error}",
+    "{agent} asked for {model}: {name} serves it, and the vendor is asked for {sent}": "{agent} verlangte {model}: {name} stellt es bereit, beim Anbieter wird {sent} angefragt",
+    "the last {n} the gateway keeps": "die letzten {n}, die der Zugangspunkt aufbewahrt",
+    "Accounts and keys": "Konten und Schlüssel",
+    "over those requests": "über diese Anfragen",
+    "over today's requests": "über die heutigen Anfragen",
+    "Nothing on {day}": "Nichts am {day}",
+    "No requests since magpie started": "Keine Anfragen seit dem Start von magpie",
+    "Each request an agent sends through magpie shows up here: who answered it, why, and each try.": "Jede Anfrage, die ein Agent über magpie sendet, erscheint hier: wer sie beantwortet hat, warum und jeder Versuch.",
+    "Earlier ones are kept by day, in the bar above.": "Frühere werden nach Tagen in der Leiste oben aufbewahrt.",
+    "Earlier days": "Frühere Tage",
+    "tried {n}": "{n} versucht",
+    "answered {n}": "{n} beantwortet",
+    "last answered {time}": "zuletzt beantwortet {time}",
+    "as of {time}": "Stand {time}",
+    "{n} used at {time}; it has renewed since": "{n} verbraucht um {time}; seitdem erneuert",
+    "routing…": "leitet weiter…",
+    "masking…": "maskiert…",
+    "back in {d}": "zurück in {d}",
+    "free · costs nothing": "kostenlos · zählt nicht zum Kontingent",
+    "back at {time} · in {d}": "zurück um {time} · in {d}",
+    "its plan doesn't list {model}": "sein Tarif enthält {model} nicht",
+    "set to serve other models, not {model}": "nur für andere Modelle eingestellt, nicht für {model}",
+    "{who} is left out: it is set to serve other models, not {model}.": "{who} wird übergangen: nur für andere Modelle eingestellt, nicht für {model}.",
+    "held at its {cap}% usage cap": "am Nutzungslimit von {cap} % angehalten",
+    "request longer than its {n} window · passed over": "Anfrage länger als sein {n}-Fenster · übergangen",
+    "{who} is left out: this request is longer than its {n} context window, so it would only refuse it. It's asked only once every one with room is out of its allowance.": "{who} wird übergangen: Diese Anfrage ist länger als sein Kontextfenster von {n}, es würde sie nur ablehnen. Es wird erst gefragt, wenn alle mit genug Platz ihr Kontingent aufgebraucht haben.",
+    "not an account the gateway key may use": "kein Konto, das dieser Zugangsschlüssel nutzen darf",
+    "{who} is left out: the gateway key asking may not use its account.": "{who} wird übergangen: der fragende Zugangsschlüssel darf sein Konto nicht nutzen.",
+    "{who} is left out: a usage window is used up, and the account is set not to spend its credits, so it counts as used up until that window renews.": "{who} wird übergangen: Ein Zeitfenster ist aufgebraucht, und das Konto soll keine Credits verbrauchen, daher gilt es bis zur Erneuerung des Zeitfensters als aufgebraucht.",
+    "{who} is left out: a usage window is at {n}, past the {cap}% cap set on the account, so it counts as used up until that window renews.": "{who} wird übergangen: Ein Zeitfenster steht bei {n}, über dem für das Konto gesetzten Limit von {cap} %, und gilt daher bis zu seiner Erneuerung als aufgebraucht.",
+    "{name}'s list for this key has no {model}": "Die Liste von {name} für diesen Schlüssel enthält {model} nicht",
+    "answering…": "antwortet…",
+    "answering another request…": "beantwortet eine andere Anfrage…",
+    "answered this request": "hat diese Anfrage beantwortet",
+    "picked for “{intent}”": "für „{intent}“ gewählt",
+    "answered {agent}": "hat {agent} geantwortet",
+    "{n} agents at once": "{n} Agenten gleichzeitig",
+    "In order: member by member, the first model the group names until it can't answer, each over its own accounts or keys as its provider routes them.": "Der Reihe nach: Mitglied für Mitglied, zuerst das erste Modell der Gruppe, bis es nicht mehr antworten kann; jedes über seine eigenen Konten oder Schlüssel, so wie sein Anbieter sie weiterleitet.",
+    "{agent} asked for the routing group {name}: {members}": "{agent} hat die Weiterleitungsgruppe {name} angefragt: {members}",
+    "Kept on {who}: it answered this conversation before, and affinity keeps a session with one account.": "Bei {who} belassen: Es hat diese Unterhaltung bereits beantwortet, und die Affinität hält eine Sitzung bei einem Konto.",
+    "Kept on {who}: {agent} is handing back tool results within turn {n}, and moving now would lose what the vendor cached of it.": "Bei {who} belassen: {agent} gibt innerhalb von Runde {n} Tool-Ergebnisse zurück, und ein Wechsel würde jetzt verlieren, was der Anbieter davon im Cache hat.",
+    "Kept on {who}: {d} ago the vendor read {r} tokens of this conversation from its cache and wrote {w} to it; anyone else would be sent them afresh and paid in full.": "Bei {who} belassen: Der Anbieter hat vor {d} {r} Token dieser Unterhaltung aus seinem Cache gelesen und {w} hineingeschrieben; jedes andere Konto bekäme sie neu gesendet und voll berechnet.",
+    "Turn {n} begins: in turn, it goes to the one after {who}, which answered the last turn — {next}.": "Runde {n} beginnt: Reihum geht sie an das Konto nach {who}, das die letzte Runde beantwortet hat – {next}.",
+    "Turn {n} begins: affinity keeps a conversation only within a turn, so routing decides afresh.": "Runde {n} beginnt: Die Affinität hält eine Unterhaltung nur innerhalb einer Runde, daher entscheidet die Weiterleitung neu.",
+    "{who} answered this conversation last, but it is resting, so the conversation moves.": "{who} hat diese Unterhaltung zuletzt beantwortet, pausiert aber, daher wechselt die Unterhaltung.",
+    "{who} answered this conversation last, but its allowance is all but used up, so the conversation moves.": "{who} hat diese Unterhaltung zuletzt beantwortet, aber sein Kontingent ist fast aufgebraucht, daher wechselt die Unterhaltung.",
+    "Every one here has used up its allowance and goes on on its credits, set to spend them only after everything else, so {who}, first in line, goes first.": "Alle hier haben ihr Kontingent aufgebraucht und laufen mit Credits weiter, die sie erst zuletzt verbrauchen sollen, daher geht {who} als Erstes in der Reihe vor.",
+    "{who} has used up its allowance and goes on on its credits, which it is set to spend only after everything else: it is tried after every other account, key and fallback.": "{who} hat sein Kontingent aufgebraucht und läuft mit Credits weiter, die es erst zuletzt verbrauchen soll: Es wird nach allen anderen Konten, Schlüsseln und Fallbacks versucht.",
+    "{who} answered this conversation last, but it is on its credits now, set to spend them only after everything else, so the conversation moves to {first}.": "{who} hat diese Unterhaltung zuletzt beantwortet, läuft aber jetzt mit Credits, die es erst zuletzt verbrauchen soll, daher wechselt die Unterhaltung zu {first}.",
+    "{who} answered this conversation last, but it is no longer one to route to.": "{who} hat diese Unterhaltung zuletzt beantwortet, kommt aber für die Weiterleitung nicht mehr in Frage.",
+    "{who} answered this conversation last, but the group goes in order and {first}, ahead of it, is ready again, so turn {n} goes back to {first}.": "{who} hat diese Unterhaltung zuletzt beantwortet, aber die Gruppe geht der Reihe nach vor und {first}, das davor steht, ist wieder bereit, daher geht Runde {n} zurück an {first}.",
+    "{who}, a fallback, answered this conversation last, but the provider's own {first} is ready again, so turn {n} goes back to it.": "{who}, ein Ersatz, hat diese Unterhaltung zuletzt beantwortet, aber {first} des Anbieters selbst ist wieder bereit, daher geht Runde {n} dorthin zurück.",
+    "{who} took this conversation while {first}, listed ahead of it in the group, couldn't; {first} is ready again, so turn {n} goes back to it.": "{who} hat diese Unterhaltung übernommen, als {first}, in der Gruppe davor, sie nicht annehmen konnte; {first} ist wieder bereit, daher geht Runde {n} dorthin zurück.",
+    "{who}, a fallback, answered this conversation last. The provider's own {first} is ready again, but Stays is Strict, which never moves a conversation, so it stays on the fallback; new conversations go to {first}.": "{who}, ein Ersatz, hat diese Unterhaltung zuletzt beantwortet. {first} des Anbieters selbst ist wieder bereit, aber Bleibt steht auf Strikt, das eine Unterhaltung nie verschiebt, daher bleibt sie beim Ersatz; neue Unterhaltungen gehen an {first}.",
+    "{who} answered this conversation last, but the vendor then read only {r} tokens of it from its cache and wrote {w} — not worth staying for.": "{who} hat diese Unterhaltung zuletzt beantwortet, aber der Anbieter hat damals nur {r} Token davon aus seinem Cache gelesen und {w} hineingeschrieben – das lohnt das Bleiben nicht.",
+    "{who} answered this conversation {d} ago, longer than the 5 minutes a vendor keeps a prompt cached — so routing decides afresh.": "{who} hat diese Unterhaltung vor {d} beantwortet, länger als die 5 Minuten, die ein Anbieter einen Prompt im Cache hält – daher entscheidet die Weiterleitung neu.",
+    "Affinity is off: each request is routed afresh, whoever answered its conversation before.": "Affinität ist aus: Jede Anfrage wird neu weitergeleitet, egal wer ihre Unterhaltung vorher beantwortet hat.",
+    "{status} · {fail} · passed to {agent}": "{status} · {fail} · an {agent} übergeben",
+    "{status} · {fail} · went on to the next": "{status} · {fail} · an den nächsten weitergegeben",
+    "{n} used · all but used up": "{n} verbraucht · fast aufgebraucht",
+    "{n} used · kept for last": "{n} verbraucht · für zuletzt aufgespart",
+    "{n} used · renews in {d}": "{n} verbraucht · erneuert sich in {d}",
+    "{n} left · all but used up": "{n} übrig · fast aufgebraucht",
+    "Its allowance had just run out and it was refused, so it was asked again at once to spend its credits.": "Sein Kontingent war gerade aufgebraucht und es wurde abgewiesen, also wurde es sofort erneut gefragt, um seine Credits zu nutzen.",
+    "{who} answered {status}: its allowance had just run out, but the account holds credits, which the vendor spends once the allowance is used up, so it is asked again at once, before any of the reply reaches {agent}.": "{who} antwortete {status}: sein Kontingent war gerade aufgebraucht, aber das Konto hat Credits, die der Anbieter nach dem Kontingent verbraucht, also wird es sofort erneut gefragt, bevor etwas von der Antwort {agent} erreicht.",
+    "It holds credits, so it rests only {d} and its usage is read again, not until its allowance renews": "Es hat Credits, ruht also nur {d} und seine Nutzung wird neu gelesen, nicht bis sein Kontingent erneuert wird",
+    "{who} is at {n} of its allowance but goes on on its credits — ahead of those used up with nothing to go on with, after those with allowance left.": "{who} hat {n} seines Kontingents genutzt, macht aber mit seinen Credits weiter — vor denen, die aufgebraucht sind und nichts mehr haben, nach denen mit verbleibendem Kontingent.",
+    "{n} used · on credits": "{n} genutzt · auf Credits",
+    "{n} left · on credits": "{n} übrig · auf Credits",
+    "{n} used · on credits · after the others": "{n} genutzt · auf Credits · nach den anderen",
+    "{n} left · on credits · after the others": "{n} übrig · auf Credits · nach den anderen",
+    "Every account is all but used up, so {who} goes first: it goes on on its credits, which the vendor spends once its allowance is used up.": "Alle Konten sind fast aufgebraucht, also kommt {who} zuerst: es macht mit seinen Credits weiter, die der Anbieter verbraucht, sobald sein Kontingent aufgebraucht ist.",
+    "{n} left · kept for last": "{n} übrig · für zuletzt aufgespart",
+    "{n} left · renews in {d}": "{n} übrig · erneuert sich in {d}",
+    "renews in {d}": "erneuert sich in {d}",
+    "{n} used · renews in {d} · one renewing sooner goes first": "{n} verbraucht · erneuert sich in {d} · eines, das sich früher erneuert, geht vor",
+    "{n} left · renews in {d} · one renewing sooner goes first": "{n} übrig · erneuert sich in {d} · eines, das sich früher erneuert, geht vor",
+    "{n} used · conversation kept on another": "{n} verbraucht · Unterhaltung bleibt bei einem anderen",
+    "{n} left · conversation kept on another": "{n} übrig · Unterhaltung bleibt bei einem anderen",
+    "{n} left at {time}; it has renewed since": "{n} übrig um {time}; seitdem erneuert",
+    "what's left not known yet": "Rest noch unbekannt",
+    "{n} tokens lately": "zuletzt {n} Token",
+    "first text in {ms}": "erster Text nach {ms}",
+    "requested {sent} · served {served}": "angefragt {sent} · geliefert {served}",
+    "served {served}": "geliefert {served}",
+    "Upstream: {upstream}": "Upstream: {upstream}",
+    "The aggregator passed the request on to {upstream}, as its reply says: the provider that actually answered it.": "Der Aggregator hat die Anfrage laut seiner Antwort an {upstream} weitergegeben: der Anbieter, der sie tatsächlich beantwortet hat.",
+    "{sent} is a routing group of the remote magpie, and it routed the request to {served}: the group picking one of its models, not the vendor swapping the model.": "{sent} ist eine Weiterleitungsgruppe des entfernten magpie und hat die Anfrage an {served} weitergeleitet: Die Gruppe wählt eines ihrer Modelle, nicht der Anbieter tauscht das Modell.",
+    "The vendor was asked for {sent}, but its reply says {served} answered: likely another model. The same model under a dated name or spelled otherwise isn't marked.": "Beim Anbieter wurde {sent} angefragt, laut Antwort hat aber {served} geantwortet – wahrscheinlich ein anderes Modell. (Dasselbe Modell mit Datum oder anderer Schreibweise wird nicht markiert.)",
+    "ClinePass route {served}": "ClinePass-Route {served}",
+    "requested {sent} · ClinePass route {served}": "angefragt {sent} · ClinePass-Route {served}",
+    "ClinePass answered {sent} through {served}, a route it picks itself: the name is the route's, not another model's.": "ClinePass hat {sent} über {served} beantwortet, eine Route, die es selbst wählt: Der Name gehört zur Route, nicht zu einem anderen Modell.",
+    "Its reply says {upstream} answered.": "Laut Antwort hat {upstream} geantwortet.",
+    "Its reply didn't say which provider answered.": "Die Antwort sagt nicht, welcher Anbieter geantwortet hat.",
+    "{pin} was asked for, but its reply didn't say which provider answered, so whether ClinePass kept to it is unknown.": "{pin} wurde angefragt, aber die Antwort sagt nicht, welcher Anbieter geantwortet hat; ob ClinePass sich daran gehalten hat, ist unbekannt.",
+    "No provider was asked for, and its reply didn't say which one answered.": "Es wurde kein Anbieter angefragt, und die Antwort sagt nicht, wer geantwortet hat.",
+    "{h} h {m} min": "{h} h {m} min",
+    "This routing group will no longer be available to agents.": "Diese Weiterleitungsgruppe steht Agenten nicht mehr zur Verfügung.",
+    "These routing groups will no longer be available to agents.": "Diese Weiterleitungsgruppen stehen Agenten nicht mehr zur Verfügung.",
+    "magpie saved a report of where it held this request. If it keeps happening, send the report with yours.": "magpie hat in einem Bericht festgehalten, wo diese Anfrage hängen blieb. Passiert es wieder, senden Sie den Bericht mit Ihrer Meldung mit.",
+    "Report copied": "Bericht kopiert",
+    "Couldn't read the report: {error}": "Der Bericht konnte nicht gelesen werden: {error}",
+    "Open Folder": "Ordner öffnen",
+    "not an account {group} may use": "kein Konto, das {group} nutzen darf",
+    "{who} is left out: the routing group {group} is held to other accounts of its provider.": "{who} wird ausgelassen: Die Routing-Gruppe {group} nutzt nur andere Konten dieses Anbieters.",
+    "Requests to this group's models spend only the accounts picked here. A provider left on any of its accounts uses them all.": "Anfragen an die Modelle dieser Gruppe verbrauchen nur die hier gewählten Konten. Ein Anbieter auf „Jedes seiner Konten“ nutzt alle.",
+    "{n} of its accounts": "{n} seiner Konten",
+    "Any of its accounts": "Jedes seiner Konten",
+    "This group spends only {accounts} of {provider}": "Diese Gruppe verbraucht nur {accounts} von {provider}",
+    "This group may spend every account of {provider}": "Diese Gruppe darf jedes Konto von {provider} verbrauchen",
+  },
+});