Skip to content

World's first open-source enterprise world model.

105 KB
Raw Blame
// 中文语言包。结构由 en.ts 定死(`Strings = typeof en`)——漏一条、多一条、
// 函数签名对不上,都是编译错误。这是唯一靠得住的同步办法:512 条字符串靠人眼对不齐。
//
// 术语约定:知识库 / 工作区 / 本体 / 类 / 实体 / 关系 / 属性 / 事实 / 证据 /
// 抽取 / 摄入 / 来源 / 文本块 / 图谱 / 审阅 / 冲突 / 合并 / 置信度 / 时态 /
// 函数性 / 提示词 / 三元组。
//
// **不译的东西**:品牌字标(Utopia / Persona / Charter)、标识符(key、IRI)、
// 产品名(DeepSeek、Ollama…)、URL。字标不译是因为它们是标记不是词。
import type { Strings } from "./en";

export const zh: Strings = {
  expressionDraft: {
    title: "表达式草稿探索",
    unsaved: "仅为未保存的草稿,不会写入知识库,也不检查单位兼容性。",
    undeclared: "未声明",
    attribute: "属性",
    constant: "数字",
    add: "加 (+)",
    sub: "减 (−)",
    mul: "乘 (×)",
    div: "除 (÷)",
    expression: "表达式",
    left: "左操作数",
    right: "右操作数",
    kind: "节点类型",
    depthLimit: "已达嵌套深度上限,请选择属性或数字。",
    choose: "搜索并选择…",
    missing: "属性已不可用",
    loading: "正在读取属性和规则…",
    loadError: "无法读取此知识库,请检查访问权限后重试。",
    retry: "重试",
    empty: "此知识库尚无属性。",
    conclusion: "结论",
    condition: "条件",
    existing: "探索已有表达式",
    unsupported: "此表达式结构尚不支持,未对其进行转换。名称和说明仍可在原规则编辑器中修改。",
    preview: "草稿预览(未保存)",
    incomplete: "请为每个操作数选择可用属性或填写有限数字以预览。",
    reset: "新建草稿",
    count: (n: number) => `已读取此知识库的 ${n} 个属性`,
  },
  app: {
    name: "Utopia",
    /* 标语与出处都与 Utopia / Persona / Charter 同类:品牌的一部分,两种语言同值 */
    tagline: "We rather wish than hope to see.",
    taglineSource: "— Thomas More, 1516",
    siteUrl: "https://utopia.bi",
    docsUrl: "https://utopia.bi/docs",
  },
  err: {
    bad_email: "这看起来不像一个邮箱地址。",
    password_too_short: "密码至少 8 位。",
    bad_display_name: "显示名需要 1–64 个字符。",
    wrong_password: "当前密码不对。",
    registration_closed: "本部署已关闭自助注册——请找管理员开通账户。",
    password_login_disabled: "本部署已关闭密码登录,请用单点登录。",
    no_chat_model: "还没有配置对话模型。到「管理 → 模型」里配一个。",
    // 对话流里没答成的那一轮:`error` 帧带的 code(服务端的英文原句只给日志)
    answer_empty: "模型没有给出回答,请再问一次。",
    answer_tool_text: "模型把工具调用写成了正文,没有作答,请再问一次。",
    answer_tool_call: "查证次数用完后模型仍在调用工具,请再问一次。",
    answer_too_long: "回答超出了长度上限,没有保留。",
    answer_failed: "这次没能答完,请再问一次。",
    answer_not_saved: "回答没能保存,请稍后再试。",
    search_failed: "没能检索文档。",
    mapping_search_failed: "没能检索相关数据映射。",
    stream_ended: "回答的连接意外中断了。重新打开这个对话,看看结果如何。",
    stream_lagged: "这个页面跟不上回答的速度,请重新打开这个对话。",
    model_out_of_credit: "模型账号付不起这次请求。去给账号充值,或者在「管理 → 模型」里换一个能用的端点。",
    model_rate_limited: "模型端点在限流,稍等一会儿再问。",
    model_unavailable: "模型端点暂时不可用,请稍后再试。",
    model_unreachable: "模型端点没有给出可用的回答。去「管理 → 模型」里检查端点地址。",
    context_too_long: "这场对话超出了模型的上下文长度。请新建一场对话。",
    model_rejected: "模型端点拒绝了这次请求。去「管理 → 模型」里检查模型设置。",
    answer_running: "这个对话里还有一个回答正在生成,等它写完再试。",
    retry_answered: "这个问题已经有回答了,或者后面已经接着问了别的。",
    retry_not_question: "只有问题可以重答。",
    retry_needs_conversation: "重答要指明问题所在的对话。",
    bad_upload: "这次上传读不出来。",
    upload_read_failed: "文件没能读完。",
    no_files: "没有附带文件。",
    upload_needs_folder: "文件只能上传到「文件夹」类型的来源里。",
    empty_file: "这个文件是空的。",
    file_too_large: "文件太大了——上限是 8 MB。",
    bad_ontology_file: "这不是一个能读的 OWL 或 RDFS 文件。",
    bad_name: "名称需要 1–64 个字符。",
    default_kb_open: "默认知识库对所有人开放——需要私密空间就另建一个。",
    default_kb_undeletable: "默认知识库不能删除。",
    last_owner_demote: "这是最后一位所有者——先把另一个人提上来。",
    last_owner_remove: "这是最后一位所有者——先把所有权交出去。",
    key_required: "需要填 key。",
    forms_required: "至少选一个这个关系涵盖的说法。",
    bad_key: "key 只能用小写字母、数字和下划线,最长 40 个字符。",
    self_parent: "一个类不能是自己的父类。",
    parent_cycle: "那个类已经在这个类下面了——层级会成环。",
    bad_lang: "选一个支持的语言。",
    attr_needs_class: "属性必须挂在某个类上。",
    builtin_name_attribute: "名字属性是内建的,不能修改。",
    attr_has_no_link:
      "属性没有逆,也没有父属性——它的宾语是字面值,谈不上反过来指回来。",
    link_target_is_attr: "要选一条关系,不是属性——属性的值是字面量。",
    sub_property_self: "一条关系不能是自己的父属性。",
    unknown_relation: "这个知识库里没有这条关系。",
    entity_name_required: "名称不能为空。",
    entity_name_too_long: "名称太长了——最多 100 个字符。",
    unknown_entity_type: "这个类不在当前本体里。",
    nothing_to_update: "没有要改的内容。",
    self_merge: "实体不能合并到自己身上。",
    close_at_required: "选一个这条事实结束的日期——新的那条没说自己何时开始。",
    empty_query: "输入点什么再检索。",
    no_data_sources: "这个知识库没有挂载任何数据库。",
    // 授权是逐工作区的(0014):源没授权给本库所属的工作区
    source_not_granted:
      "这个数据源没有授权给本工作区。请部署管理员在「管理 → 数据源」里授权。",
    memory_source_permanent: "「记忆」是知识库自带的来源,会一直在。",
    source_name_required: "给这个来源起个名字。",
    bad_cron: "这个 cron 表达式解析不了。",
    bad_cron_fields: "cron 表达式有五段:分 时 日 月 周。",
    ds_name_required: "给这个数据源起个名字。",
    only_postgres: "目前只支持 PostgreSQL。",
    bad_conn_string: "连接串要以 postgres:// 开头",
    // 刷新结构失败;引擎的原话走 detail(括号里那句)
    schema_sync_failed:
      "库表结构没能读出来——引擎的原话在括号里。确认连接串里的库、schema 与账号权限," +
      "再点「刷新结构」试试。",
    concurrency_range: "填一个 1 到 256 之间的数。",
    inference_off: "这个库没有打开物化推理。到设置里开。",
    bad_resolution: "这不是一个有效的裁决。",
    interval_inverted: "终点早于起点。请给一个晚于起点的终点。",
    empty_state_span: "起止相同的状态任何时刻都不成立。给一个晚于起点的终点,或者让它开着。",
    unknown_marks: "单个日期标的是开始、结束,或者都不是。",
    marks_needs_state: "只有状态属性才说单个日期标的是什么,事件与恒常属性不说。",
    // 采纳提案(0061 决定 3):撞上别的写、整次回滚了;复用要写的都已由人另定
    alignment_busy: "另一项操作正在改同样的内容,这次什么都没保存,请稍后再试。",
    proposal_stale:
      "这条提案已经没有可采纳的了:它的每个短语或类别词要么已由人另行判定,要么已不在任何陈述里。拒绝它就能清掉。",
  },
  errDetail: (msg: string, detail: string) => `${msg}(${detail})`,
  toast: {
    saved: "已保存",
    created: "已创建",
    deleted: "已删除",
    added: "已加入本体",
    copyFailed: "无法复制,请选中文字后手动复制。",
  },
  account: {
    brand: "Utopia Persona",
    titleTag: "Persona",
    profile: "个人资料",
    cancel: "取消",
    colLastUsed: "上次使用",
    colCreated: "创建于",
    pickBases: "搜索知识库…",
    administration: "管理",
    adminChip: "管理员",
    backToApp: "← 返回",
    profileTitle: "个人资料",
    displayName: "显示名称",
    email: "邮箱",
    save: "保存",
    passwordTitle: "修改密码",
    currentPassword: "当前密码",
    newPassword: "新密码(至少 8 位)",
    changePassword: "更新密码",
    passwordChanged: "密码已更新",
    sso: {
      title: "单点登录",
      hint: "绑定你在身份提供方的账号,之后可以用单点登录。会跳到身份提供方那边确认是你本人。",
      linkedAs: (subject: string) => `已绑定:${subject}`,
      notLinked: "尚未绑定。",
      link: "绑定身份",
      unlink: "解绑",
      unlinkTitle: "解绑单点登录?",
      unlinkHint: "重新绑定之前,没法再用单点登录。已经打开的会话仍保持登录。",
      linked: "身份已绑定,可以用单点登录了。",
      unlinked: "身份已解绑。",
    },
    avatarHint: "头像目前由你的名字生成。",
    language: "语言",
    theme: "主题",
    themeNames: { dark: "深色", light: "浅色", system: "跟随系统" } as Record<"dark" | "light" | "system", string>,
    kbsNav: "知识库",
    kbsTitle: "知识库",
    kbsFilter: "按名字筛选…",
    kbOpen: "公开",
    kbRestricted: "受限",
    kbNameLabel: "知识库",
    kbRoleLabel: "我的身份",
    kbDocsLabel: "文档",
    kbMembersLabel: "成员",
    kbAccessLabel: "权限来源",
    addedBy: (name: string, date: string) => `由 ${name} 加入 · ${date}`,
    joinedOn: (date: string) => `${date} 加入`,
    openToEveryone: "对所有人开放",
    deploymentAdmin: "部署管理员",
    openKb: "打开",
    kbSettingsBtn: "设置",
    tokensNav: "Agent 与令牌",
    tokensTitle: "个人访问令牌",
    tokensHint: "令牌让 agent 以你的身份通过 MCP 访问 Utopia,权限不超过你自己。默认只读,限定在你选的库,可随时在这里撤销。",
    newToken: "新令牌",
    tokenName: "名字",
    tokenNamePlaceholder: "我的笔记本",
    tokenScope: "范围",
    scopeRead: "只读",
    scopeWrite: "可写",
    scopeHint: "是上限,不是授权——令牌永远不会比你自己能做的更多。",
    tokenKbs: "知识库",
    kbsAllHint: "一个都不选 = 你能进的全部库。",
    tokenExpires: "过期",
    expiresDays: (n: number) => `${n} 天`,
    expiresNever: "不过期",
    issueToken: "创建令牌",
    issuedTitle: "现在就复制,之后不会再显示。",
    issuedHint: "Utopia 只保存它的哈希。丢了就在这里撤销,再建一枚。",
    copy: "复制",
    copied: "已复制",
    mcpTitle: "MCP 客户端配置",
    mcpHint:
      "适用于 Claude Code、Claude Desktop 及其它 Streamable HTTP 客户端。每个库有自己的端点,选 agent 要对话的那个库。别的客户端键名可能不同。",
    mcpBase: "库",
    yourTokens: "你的令牌",
    noTokens: "还没有令牌。",
    allBases: "全部库",
    nBases: (n: number) => `${n} 个库`,
    lastUsed: (d: string) => `最近使用 ${d}`,
    neverUsed: "从未使用",
    expiresOn: (d: string) => `${d} 过期`,
    noExpiry: "不过期",
    createdOn: (d: string) => `${d} 创建`,
    revoke: "撤销",
    revokeConfirm: "确认撤销?",
    revokedOn: (d: string) => `${d} 已撤销`,
    tokenDone: "完成",
    roleNames: {
      owner: "所有者",
      admin: "管理员",
      editor: "编辑者",
      viewer: "只读",
    },
  },
  docs: {
    brand: "Utopia Charter",
    backTitle: "返回 Utopia",
    searchPlaceholder: "搜索文档…",
    noResults: "没有匹配。",
  },
  alerts: {
    title: "告警",
    badgeLabel: "告警",
    empty: "没有需要处理的",
    emptyHint: "摄入、同步、模型端点出问题时会出现在这里,而不是只留在日志里。",
    markAllRead: "全部标为已读",
    close: "关闭",
    searchPlaceholder: "搜索来源、知识库、报错",
    noMatch: "没有匹配的",
    andMore: (n: number) => `还有 ${n} 条`,
    system: "系统",
    partialRows: (sheet: string, read: number, total: number) =>
      `${sheet}:只读了 ${read}/${total} 行`,
    partialRecords: (read: number, total: number) =>
      `只读了 ${read}/${total} 条记录`,
    kinds: {
      "source.sync_failed": {
        title: "来源同步失败",
        hint: "它没有带进新内容。去来源设置里看一下。",
      },
      "data_source.schema_sync_failed": {
        title: "数据源挂上了,库表结构没进来",
        hint: "问数看不见有哪些表,只能猜列名。检查连接串,然后点「刷新结构」。",
      },
      "mapping.exploration_empty": {
        title: "映射探索没有提出任何口径",
        hint: "模型读了挂载的库表结构,但没找到可提的指标或维度。到「数据映射 > 数据源」刷新结构、给列加注释,再探索一次。",
      },
      "document.needs_reader": {
        title: "有文件要靠模型才读得出来",
        hint: "扫描件和图片要配文档识别服务,录音要配能分出说话人的转写模型;每一行写着缺的是什么。文件已经留着,还没读出任何内容;到「管理 > 模型」存好读取模型,就会自动读。",
      },
      "document.contents_truncated": {
        title: "文件只读了一部分",
        hint: "解析器到了安全上限。提示行会写明漏掉的是哪个工作表或记录范围;检索和回答不包含被省略的部分。",
      },
      "governance.tripped": {
        title: "agent 停止自动裁决了",
        hint: "七天内它的合并被撤回了两次,开关已自动关掉。到「审核 > Agent」看看它做了什么,想让它接着跑就在库设置里再打开。",
      },
      "llm.unreachable": {
        title: "模型端点没有给出可用的回答",
        hint: "抽取与向量化已停摆。去「管理 → 模型」里检查端点地址。",
      },
      "llm.rate_limited": {
        title: "模型端点在限流",
        hint: "退避重试之后仍然被挡回来,有文档因此缺了事实。去「管理」里降低模型并发,或者把账号配额升一档。",
      },
      "llm.out_of_credit": {
        title: "模型账号付不起请求",
        hint: "抽取与向量化已停摆,而且不会自己恢复。去给账号充值,或者在「管理 → 模型」里换一个能用的端点。",
      },
    } as Record<string, { title: string; hint: string } | undefined>,
    unknownKind: (kind: string) => kind,
    runAgain: "再跑一遍",
    requeued: (n: number) => `${n} 个任务回到队列`,
  },

  kbScope: {
    deniedTitle: "你没有这个知识库的权限",
    deniedBody:
      "链接指向的库你打不开。找分享给你的人开通权限,或者回到自己的库。",
    missingTitle: "这个知识库不在了",
    missingBody: "它已被删除,或者链接抄错了。下面是你自己的库。",
    myKbs: "我的知识库",
  },
  nav: {
    workspaceLabel: "工作区",
    kbLabel: "知识库",
    findKb: "查找知识库…",
    noKbMatch: "没有匹配的知识库",
    ask: "对话",
    askHint: "与你的知识库对话——它会记住",
    search: "检索",
    searchHint: "混合检索",
    graph: "图谱",
    graphHint: "实体与时间线",
    library: "文库",
    libraryHint: "文档与摄入",
    settings: "设置",
    settingsHint: "模型与成员",
    signOut: "退出登录",
    docs: "文档",
    loading: "加载中…",
    serverUnreachable: "罚则 500:Utopia 沉默了——它没有回应。",
    notFound: "罚则 404:你在 Utopia 里迷了路。",
    returnHome: "回到首页",
    reportIssue: "反馈问题",
    refresh: "刷新",
  },
  /* 空状态的共用文案(#313):状态一句话,动作在按钮上,不解释原理 */
  steps: {
    noModel: "还没配置对话模型。",
    noModelAsk: "还没配置对话模型,请联系管理员。",
    configureModel: "配置模型",
    noDocs: "还没有文档。",
    upload: "上传文档",
    processing: (n: number) => `正在读取 ${n} 份文档…`,
    viewProgress: "查看进度",
    someFailed: (n: number) => `${n} 份文档处理失败。`,
    nothingExtracted: "还没抽取出内容。",
    openLibrary: "打开文库",
  },
  login: {
    signIn: "登录",
    signUp: "注册",
    displayName: "显示名称",
    email: "邮箱",
    password: "密码(至少 8 位)",
    submitting: "稍候…",
    createAccount: "创建账户",
    networkError: "网络异常,请重试",
    orDivider: "或",
    ssoButton: "使用单点登录",
    ssoErrors: {
      unlinked: "这个身份还没绑定任何账号。先用密码登录,再到账户页绑定。",
      unlinked_sso_only: "这个身份登不进本部署,请找管理员开通。",
      cancelled: "单点登录已取消。",
      denied: "身份提供方的应答没能通过校验。",
      session: "这次登录是在另一个浏览器会话里开始的,请重试。",
      expired: "登录耗时太久,请重试。",
      busy: "同时进行的登录太多,请稍后再试。",
      unavailable: "单点登录暂时不可用。",
      invalid: "登录请求不完整,请重试。",
      taken: "这个身份已经绑定到另一个账号。",
      already_linked: "你的账号已经绑定了一个身份,请先解绑。",
    } as Record<string, string>,
    ssoErrorOther: "单点登录失败,请重试。",
    agreePrefix: "继续即表示你同意",
    agreeAnd: ",并已知悉",
    agreeSuffix: "。",
    githubUrl: "https://github.com/deeplethe/utopia",
  },
  legal: {
    privacyTitle: "隐私政策",
    termsTitle: "使用条款",
    backToSignIn: "← 返回登录",
    privacy: {
      title: "隐私政策",
      note: "Utopia 自带的默认文本。运营本部署的组织可以替换成自己的政策。",
      sections: [
        {
          h: "一个自部署的平台",
          body: [
            "Utopia 完全运行在部署方(运营者)自行选择的基础设施上。Utopia 项目本身接触不到这个部署:软件不向任何人发送遥测、分析或崩溃报告。",
          ],
        },
        {
          h: "本实例存了什么",
          body: ["以下全部存放在运营者自己的服务器上:"],
          bullets: [
            "账户信息——你的邮箱、显示名,以及密码的哈希值。",
            "内容——上传的文档、从中抽取的文本、检索索引与向量,以及据此构建的知识图谱(实体、关系及其出处)。",
            "活动记录——你与助手的对话、审阅决定与摄入日志,保留它们是为了让依赖它们的功能能够工作。",
          ],
        },
        {
          h: "数据在什么情况下会离开这台服务器",
          body: [
            "若运营者为对话或向量化配置了外部模型服务商,文档片段与你的消息会被发送给该服务商,用于回答问题与索引内容。用哪家服务商——或是否使用完全本地的模型——是一项部署设置。除此之外不向任何地方发送任何内容。",
          ],
        },
        {
          h: "谁能看到什么",
          body: [
            "访问权限按知识库角色划分:只读成员能看到被授权的知识库,编辑者可以修改内容,管理员管理成员与设置。部署管理员可以创建账户并查看用户列表。",
          ],
        },
        {
          h: "留存与删除",
          body: [
            "删除一篇文档会把它移出知识库,并让只以它为出处的事实一并失效;另有出处的事实保留,出处照旧。内容会留着以便撤销:删除可以恢复,重新上传同一份文件也会恢复它。知识库管理员可以清除已删除的文档,其存储内容将被彻底移除。删除一个知识库会永久移除它的文档、图谱与来源。",
          ],
        },
        {
          h: "有疑问",
          body: [
            "本部署由你所在的组织运营。关于数据在此如何被处理的问题,请联系该组织的管理员。",
          ],
        },
      ],
    },
    terms: {
      title: "使用条款",
      note: "Utopia 自带的默认文本。运营本部署的组织可以替换成自己的条款。",
      sections: [
        {
          h: "关于这份条款",
          body: [
            "这个 Utopia 实例由部署它的组织运营,而非 Utopia 项目。你对它的使用受该组织自身政策约束;在运营者替换之前,这份默认条款覆盖基本事项。",
          ],
        },
        {
          h: "你的账户",
          body: [
            "请勿将凭据交给他人。管理员可依据运营者的政策创建、停用或移除账户。",
          ],
        },
        {
          h: "可接受的使用",
          body: [],
          bullets: [
            "只上传你有权在组织内存储与共享的内容。",
            "尊重访问级别:不要试图查看或修改超出你所获角色的知识库。",
            "不得利用本平台存储或传播违法内容。",
          ],
        },
        {
          h: "AI 生成的回答",
          body: [
            "助手的回答由语言模型基于你所在组织的文档生成,并附引用。它们可能出错或不完整——在依赖之前,请对照被引用的原文核实。",
          ],
        },
        {
          h: "关于本软件",
          body: [
            "Utopia 是开源软件,按「原样」提供,不附带任何形式的担保。运营本部署的责任——包括备份、可用性与合规——由运营者承担。",
          ],
        },
      ],
    },
  },
  library: {
    deletedWithFacts: (n: number) =>
      n === 0 ? "文档已删除" : `文档已删除 · 随之失效 ${n} 条事实`,
    undo: "撤销",
    restored: "文档已恢复",
    deleted: "已删除",
    colDeleted: "删除时间",
    restore: "恢复",
    purge: "清除",
    purgeTitle: "清除这篇文档?",
    purgeHint: (name: string) =>
      `「${name}」已删除,内容还留着以便撤销。清除会把原文、分块与证据引文彻底移除;` +
      "随它失效的事实保持失效,删除记录保留。此操作不可撤销。",
    purgeConfirm: "清除",
    purged: "内容已清除",
    deletedEmpty: "没有已删除的文档。删掉的文档会在这里等着被恢复或清除。",
    title: "文库",
    upload: "上传文件",
    uploading: "上传中…",
    uploadFailed: "上传失败",
    dropHint: "把文件拖到这里,或点击「上传文件」",
    formats: "PDF · Word · Excel · PowerPoint · Markdown · HTML · TXT · CSV 等",
    emptyPull: "还没有文档——这个来源同步时它们会出现。",
    filterPlaceholder: "按名称筛选",
    filterNoMatch: "没有文档匹配当前筛选。",
    anyStatus: "全部抽取状态",
    statusFailed: "失败",
    statusDone: "已抽取",
    statusQueued: "排队中",
    statusExtracting: "抽取中",
    statusNone: "未抽取",
    retryFailed: (n: number) => `重试 ${n} 篇失败`,
    retryQueued: (n: number) => `${n} 篇已排队`,
    colFile: "文件",
    colStatus: "状态",
    colGraph: "图谱",
    colChunks: "文本块",
    colSize: "大小",
    colSource: "来源",
    delete: "删除",
    extract: "抽取",
    reExtract: "重新抽取",
    reprocess: "重新处理",
    extractProgress: (done: number, total: number) =>
      `抽取中 · ${done} / ${total}`,
    errorTitle: "失败详情",
    errorParse: "摄入管道",
    errorGraph: "图谱抽取",
    copyError: "复制",
    errorCopied: "错误信息已复制",
    dropsChip: (n: number) => `丢弃 ${n} 条`,
    dropsTitle: "没能落地的事实",
    dropsNote:
      "这些是从文档里抽出来的,但在写入途中被挡下了。每行说明原因与条数。",
    dropsExample: "例如",
    dropReason: {
      object_missing: "关系缺少宾语",
      malformed_item: "模型给的这一条结构不合",
      truncated_reply: "模型的输出被截断",
      quote_not_in_chunk: "已保留,但引文不是原文原样",
      time_not_in_quote: "时间词不在原文里",
      unknown_ref: "这一条指向的东西不在回复里",
      chunk_unextracted: "这一段端点没能答上,没有进图",
      phrase_is_value: "已保留,但短语就是那个值",
      phrase_is_subject: "已保留,但短语就是主语的名字",
      object_is_value: "已保留,宾语按值记下",
    },
    reExtractSource: "重新抽取",
    reExtractTitle: "重新抽取这个来源?",
    reExtractHint: (n: number, name: string) =>
      `「${name}」中全部 ${n} 篇已就绪的文档会再走一遍抽取模型。` +
      `已有的合并、审阅决定与已确认的事实都会保留。`,
    reExtractConfirm: "重新抽取",
    queuedDocs: (n: number) => `已排队 ${n} 篇文档`,
    rebuild: "重建图谱",
    rebuildTitle: "重建知识图谱?",
    rebuildHint: (docs: number, name: string) =>
      `输入「${name}」确认。本知识库中的每一个实体、事实、合并与待审阅项都会被永久移除,` +
      `随后全部 ${docs} 篇文档从头重新抽取。` +
      `文档、检索索引与本体不受影响;决策台账保留。`,
    rebuildConfirm: "永久重建",
    rebuildDone: (e: number, f: number, q: number) =>
      `已清除 ${e} 个实体与 ${f} 条事实 · ${q} 篇文档已排队`,
    status: {
      pending: "排队中",
      parsing: "解析中",
      indexing: "索引中",
      embedding: "向量化",
      ready: "就绪",
      failed: "失败",
    },
    graphStatus: {
      none: "—",
      queued: "排队中",
      extracting: "抽取中",
      done: "完成",
      failed: "失败",
      skipped: "不抽取",
    },
    sources: "来源",
    allDocs: "全部文档",
    uploads: "上传",
    sourceType: "类型",
    sourceKinds: {
      folder: "文件夹",
      url: "网页",
      rss: "RSS 订阅",
      api: "API",
      statements: "陈述",
      custom: "自定义",
      github_issues: "GitHub 工单",
      github_repo: "GitHub 仓库文件",
      jira_issues: "Jira 工单",
      s3: "S3 / MinIO",
      azure_blob: "Azure Blob",
      gcs: "Google Cloud Storage",
      webdav: "WebDAV",
      notion: "Notion",
    },
    sourceKindHints: {
      folder: "可在文件夹中管理上传的文件:上传、拖入、删除都在这里。",
      url: "抓取所列的网页;内容变化时更新同一篇文档。",
      rss: "订阅一个源;每条目成为一篇文档,日期取其发布时间。",
      jira_issues:
        "同步一个 Jira 项目的工单。**每张工单连同它的字段级变更史**成为一篇文档——" +
        "状态、负责人、优先级何时从什么变成什么,都带着日期。一次调用取全,不逐张翻。",
      github_issues:
        "同步一个仓库的工单。**每张工单连同它的状态变更史**成为一篇文档——" +
        "何时开出、何时关闭、标签与负责人怎么变的,都带着日期。未配令牌时" +
        "每小时只有 60 次请求配额。",
      github_repo:
        "读取一个仓库默认分支上的 markdown 文件。每个文件成为一篇文档," +
        "日期取最后一次改动它的提交;没变的文件不会重抓。",
      s3:
        "从 S3 桶里读文档,或者任何说同一套协议的东西(MinIO、Ceph、R2)。" +
        "**端点留空就是 AWS**,填了就是自建。每个对象成为一篇文档," +
        "日期取它最后一次修改的时刻。",
      azure_blob:
        "从 Azure Blob 容器里读文档。用 Azure 本身就把端点留空," +
        "填了是指向 Azurite 或某个网关。",
      gcs:
        "从 Google Cloud Storage 桶里读文档。服务账号 JSON 整份贴进来——" +
        "服务器上没有那个文件可以指。",
      webdav:
        "从 WebDAV 网盘读文档——Nextcloud、ownCloud、群晖,以及一切说这套协议的。" +
        "逐层走目录,每个文件成为一篇文档,日期取它最后一次修改的时刻。",
      notion:
        "同步一个 Notion 集成能看见的页面——把页面分享给集成,它就会出现在这里。" +
        "日期取页面最后一次编辑的时刻,那是页面自己的时钟,不是我们抓它的时刻。",
      api: "外部系统把 JSON 文档推送到这里,用这个来源自己的令牌认证。",
      statements:
        "外部系统把已经是抽取契约形状的陈述推送到这里,不经模型;发事件,别发整张表的状态。",
      custom:
        "按计划轮询一个你控制的 URL——你的服务返回 JSON 条目,Utopia 保持同步。",
      memory:
        "从「对话」中记下的片段。只追加:被推翻的记忆是闭合有效区间,而不是删除——" +
        "时间线保留完整的来龙去脉。",
    },
    ingestGuide: "阅读摄入接口指南 →",
    ingestGuideTitle: "摄入接口指南",
    endpointField: "接口地址",
    feedPlaceholder: "https://your-service/utopia-feed",
    endpointCopied: "接口地址已复制",
    copyEndpoint: "点击复制完整地址",
    pushStatus: {
      never: "尚未推送",
      queued: "—",
      running: "—",
      ok: "已收到推送",
      failed: "推送失败",
    },
    tokenTitle: "来源令牌",
    tokenWarning:
      "持有这个令牌的任何人都能往这个来源推送文档。一旦泄露就轮换——旧令牌立即失效。",
    tokenUsage: "每次推送时这样带上:",
    tokenCopied: "令牌已复制",
    viewToken: "令牌",
    rotateToken: "轮换",
    noToken: "这个来源还没有令牌——生成一个即可开始推送。",
    generateToken: "生成令牌",
    close: "关闭",
    authHeaderField: "Authorization 头(可选,不再显示)",
    syncNow: "立即同步",
    syncStatus: {
      never: "从未同步",
      queued: "排队中",
      running: "同步中…",
      ok: "已同步",
      failed: "同步失败",
    },
    lastSyncAdded: (n: number) => `上次同步 +${n}`,
    sourceName: "名称",
    urlsField: "网页地址(每行一个)",
    feedUrl: "订阅地址",
    rssContentMode: "RSS 内容模式",
    rssModeFeed: "仅使用订阅内容",
    rssModeFull: "新条目获取完整文章",
    rssModeFeedShort: "仅订阅",
    rssModeFullShort: "完整文章",
    rssContentModeHint: "只为开启之后新出现的条目抓取全文。",
    rssFullModeHint:
      "第一次同步只记下订阅当前有哪些条目,不导入。之后新出现的条目,订阅自带的正文够长就用它,不够就去抓链接的文章;两者都没有的条目记为跳过。",
    rssFeedModeHint: "只存订阅自带的内容——正文或摘要——不去打开链接的文章。",
    rssHydrationCounts: (c: { pending: number; queued: number; retrying: number; complete: number; terminal: number }) =>
      `待处理 ${c.pending} · 排队 ${c.queued} · 重试 ${c.retrying} · 完成 ${c.complete} · 终止 ${c.terminal}`,
    repoField: "仓库(owner/name)",
    jiraUrlField: "Jira 地址",
    jiraProjectField: "项目 key",
    s3BucketField: "桶名",
    s3PrefixField: "前缀(可选——不填则读整个桶)",
    s3EndpointField: "端点(用 AWS S3 就留空)",
    s3RegionField: "区域",
    s3KeyField: "Access Key ID",
    s3SecretField: "Secret Access Key",
    azAccountField: "存储账号名",
    azKeyField: "账号密钥",
    gcsKeyField: "服务账号 JSON(整个文件贴进来)",
    davUrlField: "服务器地址",
    davPathField: "目录(可选——默认从根开始)",
    davUserField: "用户名",
    davPassField: "密码",
    notionTokenField: "内部集成令牌",
    notionQueryField: "搜索词(可选——留空则取全部已分享页面)",
    tokenField: "GitHub 令牌(可选,不再显示)",
    includePullRequests: "把 PR 也当工单收进来",
    includeGlobsField: "包含的 glob(逗号分隔,可选)",
    excludeGlobsField: "排除的 glob(逗号分隔,可选)",
    interval: "同步计划",
    intervalManual: "仅手动",
    intervalEvery: (m: number) =>
      m < 60 ? `每 ${m} 分钟` : `每 ${m / 60} 小时`,
    schedule: {
      manual: "手动",
      interval: "间隔",
      daily: "每天",
      weekly: "每周",
      advanced: "高级",
      every: "每",
      minutes: "分钟",
      hours: "小时",
      at: "于",
      cronPlaceholder: "输入 cron 表达式",
      whatIsCron: "什么是 cron?",
      cronDocsUrl: "https://crontab.guru",
      daysShort: ["周一", "周二", "周三", "周四", "周五", "周六", "周日"],
      dailyAt: (t: string) => `每天 ${t}`,
    },
    createSource: "创建",
    cancel: "取消",
    deleteSource: "删除来源",
    deleteSourceHint: "文档会保留,并移入「上传」。",
    newSourceTitle: "新建来源",
    iconLabel: "图标",
    pageOf: (from: number, to: number, total: number) =>
      `${from}–${to} / 共 ${total}`,
    syncHistory: "历史",
    runNew: (n: number) => `新增 ${n}`,
    runUpdated: (n: number) => `更新 ${n}`,
    runNothing: "无变化",
    noRuns: "还没有同步记录。",
    sourceSettings: "来源设置",
    editSourceTitle: "来源设置",
    saveChanges: "保存修改",
    authHeaderEditField: "Authorization 头",
    authKeepHint: "留空则保持当前值。",
    editKeepNote:
      "改变这个来源抓取什么,绝不会删除已有文档。新配置不再返回的条目会在下次同步后" +
      "标记为「已不在来源中」。要整个换成另一个服务?那就新建一个来源。",
    notInSource: "已不在来源中",
    cleanupMissing: (n: number) => `清理 ${n} 篇缺失`,
    cleanupTitle: "删除缺失的文档",
    cleanupHint: (n: number, name: string) =>
      `「${name}」中有 ${n} 篇文档已不在来源里。` +
      "删除会把它们移出知识库,只以它们为出处的事实随之失效;" +
      "内容会留着,删掉的文档可以恢复。",
    cleanupConfirm: "删除它们",
    deleteSourceTitle: "删除这个来源",
    deleteSourceBody: (name: string) =>
      `输入「${name}」确认。文档会保留并移入「上传」;定时同步停止。`,
    dangerZone: "危险操作",
  },
  search: {
    placeholder: "检索知识库…(关键词 + 语义)",
    button: "检索",
    searching: "检索中…",
    noResults: "没有结果",
    chunkOf: (filename: string, seq: number) => `${filename} · 第 ${seq} 段`,
  },
  ask: {
    streamInterrupted: "回答连接已中断,请重新打开会话查看状态。",
    noActiveAnswer: "最后一个问题没有回答。可以重试,或发送新消息。",
    historyLoadFailed: "无法读取此会话。",
    retryHistory: "重试",
    retryQuestion: "重试",
    loadingHistory: "正在读取会话…",
    loadEarlierConversations: "加载更早的会话",
    conversationsLoadFailed: "无法读取会话列表。",
    retryConversations: "重试",
    greeting: "问问 Utopia 都记住了什么",
    emptyTitle: "对话",
    emptyBody:
      "与你的知识库对话——带引用的回答、关于时间的提问,而且它会记住。\n请先在「文库」上传文档,并在「管理 → 模型」里配置模型。",
    placeholder: "问点什么…",
    composerHint: "回车发送 · Shift+回车 换行",
    scopeLabel: "知识库",
    send: "发送",
    stop: "停止",
    stopping: "正在停止…",
    stopped: "已停止",
    thinking: "思考中…",
    step: {
      failed: "失败",
      documentNotFound: "未找到文档",
      entityNotFound: "未找到实体",
      sourceNotFound: "没有这个数据源",
      unknownTool: "未知工具",
      unparsed: "参数不完整",
      missing: (param: string) => `缺少 ${param}`,
      invalid: (param: string) => `${param} 无效`,
      sources: (n: number) => `${n} 个来源`,
      sections: (n: number) => `${n} 段`,
      matches: (n: number, total?: number) =>
        total === undefined ? `${n} 个匹配` : `${n} 个匹配(共 ${total} 个)`,
      facts: (n: number, at: string | null, recorded: string | null) =>
        `${at ? `${at} 时的 ` : ""}${n} 条事实${recorded ? `,${recorded}` : ""}`,
      recordedBy: (t: string) => `按 ${t} 时的记录`,
      recordedBefore: (t: string) => `按 ${t} 之前的记录`,
      linked: (n: number, total: number) =>
        n === total ? `关联 ${n} 个` : `关联 ${total} 个,列出 ${n} 个`,
      dated: (n: number, total: number) =>
        n === total ? `${n} 条有日期的事实` : `${total} 条有日期的事实,列出 ${n} 条`,
      paths: (n: number, more: boolean, hops: number) =>
        n === 0 ? "没有路径" : `${n}${more ? "+" : ""} 条路径,最短 ${hops} 跳`,
      changes: (n: number, more: boolean) =>
        n === 0 ? "没有变更" : `${n}${more ? "+" : ""} 处变更`,
      now: "现在",
      rows: (n: number, more: boolean) => `${n}${more ? "+" : ""} 行`,
      rules: (n: number) => (n === 0 ? "无" : `${n} 条规则`),
      marked: (n: number) => `标出 ${n} 处`,
      sql: "SQL",
    },
    newChat: "新对话",
    recent: "最近",
    untitled: "未命名",
    noConversations: "还没有对话。",
    deleteConversation: "删除对话",
    searchConversations: "搜索会话",
    moreActions: "更多",
    rename: "重命名",
    copyTitle: "复制标题",
    deleteTitle: "删除这个对话?",
    deleteHint: (name: string) => `「${name}」及其消息将被永久移除。`,
    deleteBtn: "删除",
    cancel: "取消",
    noSources: "未引用任何来源",
    openOriginal: "打开原文",
    copyAnswer: "复制回答",
    copyCode: "复制代码",
    copied: "已复制",
  },
  graph: {
    untyped: "未分类",
    legendMore: (n: number) => `全部 ${n} 个类`,
    nodeBudget: "画多少个实体",
    nodeBudgetMore: "多画一些",
    nodeBudgetLess: "少画一些",
    legendSearch: "筛选类",
    legendNone: "没有匹配的类",
    legendOnly: "只看",
    legendShowAll: (n: number) => `显示全部(隐藏了 ${n} 个)`,
    legendHideAll: "全部隐藏",
    legendAllHint: "画面上的全部类,按出现次数排。点一下显示或隐藏。",
    searchMore: (n: number) => `还有 ${n} 个——再加载 20`,
    zoomIn: "放大",
    zoomOut: "缩小",
    fitView: "适应视图",
    layoutForce: "力导布局",
    layoutCircular: "环形布局",
    layoutPack: "按类型聚簇",
    searchEntity: "搜索实体…",
    searchInSubgraph: "在子图中搜索…",
    backToOverview: "← 全图",
    facts: "条事实",
    noFacts: "这个实体还没有事实",
    confidence: "置信度",
    evidence: "证据",
    noEvidence: "没有记录证据",
    noQuote: "(无引文)",
    openInDoc: "在文档里看这一段",
    proposedPredicate: (p: string) => `从原文读作「${p}」`,
    /* 本体没认下这条关系:显示的词来自原文,不是词表里的关系 */
    saidAs: (words: string) => `原文的说法:“${words}”`,
    inferredPredicate: "本体里没有这个关系,这是原文的说法",
    /* 连原文说法都没留下的老数据(0052 之前)。不编一个「有关联」出来 */
    unknownPredicate: "说不出是什么关系",
    sectionRef: (filename: string, seq: number) =>
      `${filename} · 第 ${seq} 段 →`,
    fromVersion: (v: number) => `v${v}`,
    sourceDeleted: "出处已删",
    sourceDeletedHint: "这句引文所在的文档已被删除。事实还在,因为它另有出处。",
    staleEvidenceHint:
      "这条证据来自文档的较早版本。文档此后已更新;事实本身不受影响。",
    staleFactChip: "未确认",
    staleFactHint:
      "这条事实的全部证据都来自来源文档的较早版本——现行内容不再这么说。" +
      "它可能仍然成立;请到「审阅」里核对。",
    edit: "编辑",
    editName: "名称",
    editType: "类型",
    editSave: "保存",
    editCancel: "取消",
    editSaved: "实体已更新",
    editEmptyName: "名称不能为空",
    viewRelations: "关系",
    viewTimeline: "时间线",
    viewHistory: "记录历史",
    viewDerived: "推出来的",
    derivedEdges: (n: number) => `推出来的 ${n}`,
    derivedHint:
      "这里没有一条是谁断言的——都是引擎推出来的:或按本体声明的公理,或按有人写下的规则。每一条都附着它用到的前提。",
    derivedNoProof: "前提已经不在了。",
    contestedChip: "有争议",
    contestedHint: (kind: string, derived: string | null) =>
      kind === "derived_contradiction"
        ? `有一条推出来的事实与它抵触${derived ? `:${derived}` : ""}。去 Review 看。`
        : kind === "temporal_conflict"
          ? "有一条更新的断言在时间上与它冲突。去 Review 看。"
          : "这条断言违反了本体声明的公理。去 Review 看。",
    blockedTitle: "没落地的",
    blockedHint: "引擎本可以画出这些边,被一条断言挡住了。图上画成幽灵边。",
    blockedBy: (t: string) => `挡住它的:${t}`,
    blockedReview: "去 Review",
    proofStep: (n: number) => `第 ${n} 步`,
    proofRetracted: "后来撤了",
    proofLoading: "正在展开证明…",
    derivedPanel: "推理",
    derivedRunAsk: "对整个库重跑一遍推理?",
    derivedRunGo: "跑",
    derivedRunCancel: "取消",
    derivedCountLabel: "推出来的边",
    derivedStateLabel: "定时",
    derivedLastLabel: "上次推理",
    derivedOn: (mins: number) => `每 ${mins} 分钟`,
    derivedOff: "已关闭",
    derivedNever: "从未",
    derivedAgo: (mins: number) =>
      mins < 1
        ? "刚刚"
        : mins < 60
          ? `${mins} 分钟前`
          : `${Math.round(mins / 60)} 小时前`,
    derivedRun: "现在跑一遍",
    derivedRunning: "推理中…",
    derivedNoChange: "没有变化。",
    derivedChanged: (added: number, gone: number) =>
      `新增 ${added} · 作废 ${gone}`,
    derivedCapped: (n: number) => `${n} 个谓词没推完`,
    close: "关闭",
    ruleNames: {
      transitive: "传递",
      symmetric: "对称",
      inverse: "互逆",
      sub_property: "子属性",
    } as Record<string, string | undefined>,
    historyHint: "这个实体的记录如何变化——以及是谁改的。",
    historyEmpty: "这个实体还没有记录。",
    historyKind: {
      asserted: "记入",
      corrected: "区间被修正",
      rejected: "已撤回",
      merged: "并入了已有事实",
      merged_in: "有实体并了进来",
      merged_away: "并进了另一个实体",
      merge_reverted: "合并已撤销",
      retyped: "改了类",
      retype_reverted: "改类被撤销",
    },
    historyGoneEntity: "一个已不存在的实体",
    historyEngine: "引擎",
    historyClosedAt: (t: string) => `闭合于 ${t}`,
    historyFrom: (t: string) => `自 ${t} 起`,
    historyOngoing: "未闭合",
    historicalNote: (n: number) => `另有 ${n} 条历史事实未显示——见时间线 →`,
    undated: "无日期",
    asOf: (date: string, by: string | null) =>
      by ? `截至 ${date}(${by})` : `截至 ${date}`,
    fromEntity: (name) => `从 ${name} 出发`,
    toEntity: (name) => `指向 ${name}`,
    openEntity: (name) => `打开 ${name}`,
    past: (n) => `${n} 条已结束`,
    sources: (n) => `${n} 处来源`,
    names: "名字",
    shownName: "显示名",
    nameUntil: (d) => `至 ${d}`,
    removeName: "移除",
    removeNameAsk: "移除这个名字?",
    removeNameCancel: "留着",
    removeNameGo: "移除",
    nameRemoved: "已移除这个名字",
    timelineEmpty: "还没有带日期的事实。",
    lastConfirmed: (d: string) => `${d} 确认`,
    correctedHint:
      "这个区间来自一次修正,并非文档里逐字这么写:自动接续、审阅决定,或有人手工改过。" +
      "被取代的那条断言仍留在台账里——谁改的、何时改的见「变更」。",
    editTime: "修正区间",
    editTitle: "编辑实体",
    timeStart: "起点",
    timeEnd: "终点",
    timeEndOpen: "仍在持续",
    timeEndUnknown: "已结束,日期不详",
    timeEndDate: "结束于",
    timeFormat: "2023 · 2023-06 · 2023-06-15 · 2023-06-15T14:32Z",
    timeBadDate:
      "写成 2023、2023-06、2023-06-15,或带时区的钟点如 2023-06-15T14:32Z——没有时区的钟点不是一个时刻。",
    timeNote: "原因(选填)",
    timeNotePlaceholder: "文档说的是 2023 年上半年",
    timeSave: "保存",
    timeCancel: "取消",
    timeSaved: "区间已修正",
    timeSavedClosed: (n: number) => `区间已修正——顺带闭合了 ${n} 条现行事实`,
    timeSavedConflicts: (n: number) =>
      `区间已修正——${n} 条冲突待在审阅里裁决`,
    ongoing: "至今",
    endedUnknown: "已结束(时间不详)",
    stats: (n: number, e: number, active: number | null) =>
      `${n} 个实体 · ${e} 条事实${active === null ? "" : ` · ${active} 条现行`}`,
    statsCapped: (
      shown: number,
      total: number,
      shownE: number,
      totalE: number,
      active: number | null,
    ) =>
      `已画 ${shown} / 共 ${total} 个实体 · ${shownE} / 共 ${totalE} 条事实${active === null ? "" : ` · ${active} 条现行`}`,
    cappedHint: (shown: number, total: number) =>
      `画布只画连接最密的 ${shown} 个,库里共 ${total} 个。其余的用搜索找。`,
    stabilizing: "布局收敛中",
    scrubUnitHint: "播放的步长,也是每根柱子的跨度",
    scrubUnitYear: "年",
    scrubUnitMonth: "月",
    scrubUnitDay: "日",
    scrubBarMerged: (n: number) => `每根柱子含 ${n} 步`,
    allTime: "全部时间",
    nowBtn: "现在",
    play: "播放时间线",
    pause: "暂停",
  },
  origin: {
    ocr: (page: number | null) => (page === null ? "OCR 识别" : `OCR 识别 · 第 ${page} 页`),
    transcribed: (span: string | null, speakers: string[]) =>
      ["转写", span, speakers.length > 0 ? speakers.join("、") : null]
        .filter(Boolean)
        .join(" · "),
    described: "模型描述",
    ocrHint: "从扫描件或图片上识别出来的文字,个别字或数字可能认错。",
    transcribedHint: "从录音转写出来的文字,人名可能听错。",
    describedHint: "模型对一张图的描述,没有人这样写过或说过。",
    readBy: (model: string) => `读取模型:${model}。`,
  },
  doc: {
    backToLibrary: "← 返回文库",
    sections: "段",
    section: "第",
    citedHere: "← 此处被引用",
    loading: "加载中…",
    extracted: "已抽取",
    ongoing: "至今",
    /** `#610`:`doc_time` 是从文件里读出来的日期;与上传时刻是两件事 */
    docDate: "文档日期",
    docDateFromContent: "从文件名或正文首行认出来的",
    uploadedAt: "上传于",
  },
  settings: {
    title: "管理",
    tabModels: "模型",
    tabMembers: "用户",
    tabKbs: "知识库",
    tabDeployment: "部署",
    tabSso: "单点登录",
    cardAccounts: "账号",
    newUser: "创建用户",
    initialPassword: "初始密码(至少 8 位)",
    createUserBtn: "创建",
    searchUsers: "按名称或邮箱筛选…",
    deployment: {
      openReg: "允许自助注册",
      openRegHint: "关闭后注册表单不再开放,只有管理员能在此创建账户。",
      workers: "后台工作线程",
      workersHint:
        "同时运行的任务数的外层上限(1–256),作用是防止工作无限堆积。" +
        "真正的节流是下面的按模型上限,所以这个数留得比它们之和宽裕些。即时生效。",
      workersApply: "应用",
      modelConcurrency: "模型并发",
      modelConcurrencyHint:
        "一个模型同时接多少个调用。真正起作用的上限属于服务商,而且是按模型算的——" +
        "本地 Ollama 也许只扛得住两个,托管 API 能到五十。" +
        "后台工作(抽取、消解、索引)会等空位;对话与检索永远不等。即时生效。",
      ontologyLang: "默认本体语言",
      ontologyLangHint:
        "新建知识库时本体从哪种语言开始——类描述会进抽取提示词," +
        "所以它跟你预期的文档走,不跟界面走。每个知识库之后可以自己改。" +
        "界面语言是每个人自己的选择,在账户菜单里。",
      modelDefault: "默认",
      modelReset: "重置",
      modelResetHint: "去掉这个模型自己的上限,回落到默认值。",
    },
    datasources: {
      tab: "数据源",
      title: "数据源",
      hint:
        "只读的数据库连接,用于在「对话」里就你的数据提问。" +
        "在这里登记连接;每个知识库各自挂载允许查询的那些。",
      name: "名称",
      connString: "连接串,前缀决定引擎",
      connSchemes:
        "postgres://user:pass@host:5432/db\n" +
        "mysql://user:pass@host:3306/db   (MariaDB、TiDB、OceanBase、Doris、StarRocks)\n" +
        "trino://user[:pass]@host:8080/catalog[/schema]   (Iceberg、Delta Lake、Hive)\n" +
        "databricks://:TOKEN@host/sql/1.0/warehouses/ID?catalog=main\n" +
        "snowflake://:[email protected]/DB/SCHEMA?warehouse=WH\n" +
        "clickhouse://user:pass@host:8123/db   (?ssl=true 走 https,8443)",
      add: "添加数据源",
      newTitle: "登记数据源",
      engine: "引擎",
      engineRaw: "连接串",
      optional: "(可不填)",
      testConn: "测试连接",
      testing: "连接中…",
      colConn: "连接",
      colStatus: "状态",
      grantsNoneShort: "未授权",
      grantsCount: (n: number) => `${n} 个工作区`,
      fHost: "主机",
      fPort: "端口",
      fDatabase: "库",
      fUser: "用户",
      fPassword: "密码",
      fCatalog: "Catalog",
      fSchema: "Schema",
      fToken: "令牌",
      fWarehouse: "Warehouse",
      fWarehouseId: "Warehouse ID",
      fAccount: "账号主机",
      test: "测试",
      testOk: "已连接",
      testFail: "失败",
      neverTested: "未测试",
      remove: "移除",
      empty: "还没有注册数据源。在下面注册一个。",
      grants: "可用于",
      grantsHint:
        "授权哪些工作区可以用这个源。授权之后,那些工作区的知识库管理员自己挑挂不挂——" +
        "这里管的是「能不能拿到」,不是「挂没挂」。",
      grantsNone: "还没授权给任何工作区——现在没有知识库挂得上它。",
      grantAdd: "授权工作区…",
      grantRevoke: "收回",
      grantRevoked: (n: number) =>
        n === 0 ? "已收回。" : `已收回,顺带卸掉了 ${n} 个知识库上的挂载。`,
    },
    sso: {
      title: "单点登录",
      hint:
        "通过身份提供方(OIDC)登录,用环境变量配置(见 .env.example)。每个人在自己的账户页" +
        "绑定自己的身份;管理员能看到、能解绑,但不能替别人绑定。",
      disabled:
        "这个部署还没配置。设置 UTOPIA_OIDC_ISSUER、UTOPIA_OIDC_CLIENT_ID、" +
        "UTOPIA_OIDC_REDIRECT_URI(身份提供方要求的话还有 UTOPIA_OIDC_CLIENT_SECRET)后重启。",
      issuer: "Issuer",
      clientId: "Client ID",
      redirectUri: "Redirect URI",
      colUser: "用户",
      colSubject: "Subject",
      empty: "还没有人绑定身份。",
      unlink: "解绑",
      unlinkTitle: (email: string) => `解绑 ${email}?`,
      unlinkHint:
        "重新绑定之前,这个人没法再用单点登录。已经打开的会话仍保持登录;要立刻切断访问请停用账号。",
    },
    kbs: {
      hint:
        "本部署中的全部知识库。公开的对所有成员可读;受限的仅限受邀者。" +
        "创建知识库是管理员动作——成员在顶栏切换。",
      defaultChip: "默认",
      newKb: "新建知识库",
      packsLabel: "预置本体",
      packsHint: "可不选,之后还能再导入。",
      packsPick: "搜索本体包…",
      packsNone: "不选 —— 本体从文档里长出来",
      packsCount: (c: number, p: number) => `${c} 个类 · ${p} 个属性`,
      name: "名称",
      description: "描述",
      visibility: "可见性",
      visOpen: "公开——本部署内所有人",
      visRestricted: "仅受邀者",
      create: "创建",
      openSettings: "设置",
      empty: "还没有知识库。在上面建第一个。",
      docs: (n: number) => `${n} 篇文档`,
    },
    modelsIntro:
      "OpenAI 兼容协议——DeepSeek、Qwen、GLM、Ollama、vLLM 都可用。完全内网友好。",
    chatModel: "对话模型",
    reasoningEffort: "推理强度",
    reasoningDefault: "端点默认",
    reasoningHint: "推理模型先想再答,输出的大半是思考。每一种调用都用这一个值;哪个值关得掉思考看端点:有的认 minimal,有的(DeepSeek)只认 none。",
    embedModel: "向量模型(可选,启用语义检索)",
    baseUrl: "接口地址",
    model: "模型",
    apiKey: "API 密钥",
    keyConfigured: "(已配置——留空即保持不变)",
    save: "保存",
    saving: "保存中…",
    saved: "已保存",
    test: "测试连接",
    testing: "测试中…",
    chatLabel: "对话",
    embedLabel: "向量",
    ok: (reply: string) => `已连通,认证通过(${reply})`,
    okDim: (dim: number) => `已连通,认证通过(维度 ${dim})`,
    unsaved: "有未保存的修改。先保存这张卡,再测试。",
    readersTitle: "读扫描件与录音",
    readersIntro:
      "扫描件、图片和录音没有可以直接解析的文字,各要一个读取模型。它们和对话模型分开配置,敏感文件可以留在自己的服务器上。读取模型配好之前传上来的文件会先等着,消息中心会提示;存好之后自动读。",
    ocrService: "文档识别(OCR)",
    ocrHint: "MinerU 服务(mineru-api)。先识别每页版面再认字,每段文字都记着所在的页和位置。",
    ocrHintArk: "火山方舟的视觉模型逐页读,只返回页上写着的字。每段文字记着所在的页,没有位置。每一页都是一次付费的模型调用。",
    readerProvider: "供应商",
    arkProvider: "火山方舟",
    serviceUrl: "服务地址",
    backend: "后端(可选)",
    transcribeModel: "录音转写",
    transcribeHint:
      "会标注说话人的 OpenAI 兼容转写接口(diarized_json),例如 gpt-4o-transcribe-diarize。分不出谁说的转写不会采用。",
    okVersion: (version: string) => `已连通(${version})`,
    okReachable: "已连通,认证通过",
    savedRequeued: (n: number) => `已保存。${n} 个等待中的文件开始读取。`,
  },
  ontology: {
    casesShort: "回归案例",
    casesTitle: "属性回归案例",
    casesHint: "显示最近记录的预期属性与对齐决定的对比结果。刷新只读取这些结果;修改属性后由现有对齐流程更新。",
    casesEmpty: "还没有案例。采纳属性提案,或从文档中添加一条开放陈述。",
    caseStatement: "陈述",
    caseExpected: "预期",
    caseActual: "实际",
    caseResult: "结果",
    caseChecked: "最近检查",
    caseOrigin: "添加来源",
    casePassed: "一致",
    caseMismatch: "不一致",
    caseNotChecked: "未检查",
    caseUnbound: "未绑定属性",
    caseUndecided: "未决定",
    caseUnavailableProperty: "原绑定属性已不可用",
    caseDecidedAt: "决定时间",
    caseNoProperties: "请先在本体中创建适合的属性,再添加此案例。",
    caseHumanBound: "保留人工决定",
    caseHumanHint: "人工绑定予以保留,并按通过计入。这不代表一次独立的模型检查。",
    caseAdoption: "采纳提案",
    casePerson: "手动添加",
    caseUnknownCreator: "已离开的成员",
    caseEvidence: "展开原文证据",
    caseHideEvidence: "收起原文证据",
    caseMake: "添加回归案例",
    caseAddTitle: "添加属性回归案例",
    caseAddHint: "保存这条开放陈述应绑定的属性及方向,再将已有的对齐决定与此预期比较。",
    caseExpectedProperty: "预期属性",
    caseDirection: "方向",
    caseForward: "主语 → 宾语",
    caseReverse: "宾语 → 主语",
    caseAdded: "回归案例已添加",
    caseAdd: "添加案例",
    title: "本体",
    hint: "类与属性",
    tabClasses: "类",
    colName: "名称",
    multiParentHint: "这个类有不止一个父类;缩进挂在其中一个,父类那一列把它们都列着",
    colSignature: "主语 → 宾语",
    colInstances: "实例",
    colFacts: "事实",
    colOnClass: "挂在",
    colDatatype: "类型",
    colUnit: "单位",
    colSingleValued: "单值",
    yes: "是",
    rowsShown: (n: number) => `${n} 行`,
    viewTable: "表格",
    switchToTable: "切换到表格视图",
    switchToGraph: "切换到图视图",
    viewDiagram: "图",
    axiomTransitive: "传递",
    axiomSymmetric: "对称",
    axiomAsymmetric: "反对称",
    axiomIrreflexive: "非自反",
    tabProperties: "关系",
    newClass: "新建类",
    newSubClass: "新建子类",
    newProperty: "新建关系",
    filter: "筛选…",
    missesShort: "未匹配",
    uniquenessShort: "并存",
    refineShort: "类型消解",
    rulesShort: "业务规则",
    ruleExpressionReadOnly: "此表单只读展示这条规则的定义。可修改名称和说明,表达式和条件保持原样。",
    ruleUnknownExpression: "暂不支持的表达式(只读)",
    ruleDependencies: "潜在依赖",
    ruleDependenciesHint: "根据规则定义列出的候选关系,不代表实际执行。读数、条件和时间决定哪些规则成立;这里也包括已停用的定义。",
    ruleDependenciesIncomplete: "部分定义或类信息无法完整读取,此列表可能不完整。",
    rulePotentialProducers: "可能从这些规则获得输入",
    rulePotentialConsumers: "可能为这些规则提供输入",
    ruleDependenciesEmpty: "在可读取的定义中未找到候选关系。",
    rulesTitle: "业务规则",
    rulesHint: "按实体自己的属性判定类别、或算出取值的规则。结论是派生的,依据没了就自动失效。",
    rulesEmpty: "还没有规则。",
    rulesNoMatch: "没有规则匹配。",
    ruleSearch: "搜索规则、属性、取值",
    ruleNew: "新建规则",
    ruleNeedsAttribute:
      "规则判的是属性的值,而这个本体还没有属性。先打开一个类,在「属性」里加一个。",
    ruleNeedsClass: "先建一个类——规则得出的就是一个类。",
    ruleColRule: "规则",
    ruleColDerived: "推出",
    ruleColStatus: "状态",
    ruleAnd: "并且",
    ruleOr: "或者",
    ruleWhere: "满足",
    ruleDropCondition: "删掉这个条件",
    ruleOperandPlaceholder: (kind: string) =>
      kind === "set" ? "气测异常, 效应后气测异常" : kind === "range" ? "8 - 12" : "12.0",
    ruleName: "名称",
    ruleNamePlaceholder: "含气井",
    ruleDescription: "它是什么意思(选填)",
    ruleSubject: "适用于",
    ruleSubjectHint: "及其子类",
    ruleConcludes: "得出",
    ruleConcludesTyping: "这个类",
    ruleConcludesAttribute: "这个属性",
    ruleConcludesRelation: "这条关系",
    ruleConcludesRelationText: (join: string, conclude: string): string =>
      `经「${join}」从 X 到「${conclude}」`,
    ruleSideX: "X",
    ruleSideY: "Y",
    ruleConditions: "当满足",
    ruleConditionsHint: "一块里的条件要同时成立;再加一块就是另一种情况,任意一块成立即可。",
    ruleAddCondition: "加一个条件",
    ruleAddGroup: "另一种情况",
    ruleOpGt: "大于",
    ruleOpGte: "不小于",
    ruleOpLt: "小于",
    ruleOpLte: "不大于",
    ruleOpBetween: "介于",
    ruleOpIn: "属于",
    ruleOpNotIn: "不属于",
    ruleOpPresent: "有记录",
    ruleOperandNumber: "12.0",
    ruleOperandSet: "气测异常, 气测异常后效",
    ruleOperandSetHint: "逗号分隔",
    ruleSave: "保存规则",
    ruleSaved: "规则已保存",
    ruleDeleted: "规则已删除",
    ruleDelete: "删除",
    ruleDeleteConfirm: (n: string) => `删除「${n}」?凭它得出的结论一并消失。`,
    ruleEnabled: "启用",
    ruleDisabled: "停用",
    ruleDerivedCount: (n: number) => `${n} 个实体`,
    ruleRun: "立刻跑一遍",
    ruleRunning: "正在跑…",
    ruleRunDone: (hits: number, inserted: number, invalidated: number) =>
      `命中 ${hits} · 新增 ${inserted} · 退场 ${invalidated}`,
    ruleRunCapped: (n: number) =>
      `${n} 对(规则,实体)的读数组合太多没有展开完,它们的结论不完整`,
    ruleRunRoundsCapped: (n: number) =>
      `跑满 ${n} 轮还在往下推,链再往后的那几环没有接上`,
    ruleNeedsCondition: "一条规则至少要有一个条件。",
    ruleEdit: "编辑",
    ruleEditing: "正在编辑",
    ruleMatchesTitle: "它标住了谁",
    ruleMatchesEmpty: "此刻一个也没有。",
    ruleVersion: (n: number) => `v${n}`,
    ruleHistoryTitle: "这条规则改过几次、每一版怎么说",
    ruleHistoryEmpty: "还没有历史。",
    ruleVersionCurrent: "当前",
    ruleVersionSince: (from: string, to: string | null) => (to ? `${from} 至 ${to}` : `自 ${from}`),
    ruleVersionStanding: (n: number) => `此刻凭它成立 ${n} 条`,
    ruleMatchBecause: (premises: string) => `凭 ${premises}`,
    ruleMatchSpan: (from: string, to: string | null) =>
      to ? `${from} 至 ${to}` : `${from} 起`,
    ruleMatchesMore: (shown: number, total: number) =>
      `显示 ${shown} / ${total}`,
    ruleCappedChip: "不完整",
    ruleCappedHint:
      "有些实体同一属性的读数太多,组合展不完,这条规则在它们身上的结论是不完整的。",
    refineTitle: "类型消解",
    refineHint: "人工收窄定得过宽的实体类型。",
    refinePreview: "先看一遍",
    refineLooking: "计算中…",
    refineRun: "跑一遍并落库",
    refineRunning: "运行中…",
    refineNothing: "没有可精化的。",
    refineCandidates: (n: number) => `会考虑 ${n} 个实体`,
    refineNoCandidates: "检索没给它找到任何类。",
    refineModelSays: (t: string) => `模型说它是「${t}」`,
    refineRetyped: (n: number) => `自动改了 ${n} 个`,
    refineUndo: "撤销这一批",
    refineUndone: (n: number) => `已放回 ${n} 个`,
    refineForReview: (n: number) => `${n} 个要你拍板`,
    refineCrossesAxis: "换了分类轴",
    refineApprovePair: "认可这一对类",
    refineLeftAlone: (n: number) => `${n} 个原样不动`,
    refineTopCandidate: (c: string) => `最近的候选是 ${c}`,
    instances: "实例",
    instanceFacts: (n: number) => `${n} 条事实`,
    description: "描述",
    descriptionHint:
      "指导抽取器:什么属于这里,配上几个例子。它会被原样送进抽取提示词。",
    attributes: "属性",
    attributesHint:
      "这个类的字面值字段(一个人的薪资、一份合同的金额)。和任何事实一样带证据与历史。",
    newAttribute: "新建属性",
    edit: "编辑",
    editClass: "编辑类",
    editProperty: "编辑关系",
    editAttribute: "编辑属性",
    attributeHost: "挂在哪个类",
    connectTitle: "连接一个关系",
    connectOpen: "用已有的关系连接…",
    noDescription: "还没有描述。",
    axiomsNone: "没有声明。",
    attrDatatype: "值类型",
    attrUnit: "单位",
    attrUnitHint: "可选——如 CNY、%",
    attrSingle: "单值——新值会闭合上一个",
    datatypeNames: {
      text: "文本",
      number: "数字",
      date: "日期",
      bool: "布尔",
    },
    cancel: "取消",
    key: "Key",
    label: "标签",
    color: "颜色",
    shapeColor: "形状与颜色",
    parent: "父类",
    noParent: "(顶层)",
    subclasses: "子类",
    qualifiers: "边上的属性",
    noQualifiers: "无",
    qualifiersHint: "这条关系的边能带的属性,例如 invested_in 上的金额",
    noSubclasses: "无",
    disjoint: "不可能同时是",
    disjointHint:
      "任何东西不可能同时属于的类。人不是组织。一致性检查据此找出永远不可能有实例的类。",
    noDisjoint: "尚未声明",
    disjointWithParent:
      "这个类继承自一个它声明不可能是的类——没有任何东西能满足它。",
    primaryParentHint: "左栏的树里挂在第一个下面。",
    signature: "类型签名",
    signatureHint:
      "这个关系连接哪些类。它作为提示进抽取提示词,不是闸门——" +
      "它在模型落笔那一刻引导,而本体写错时原文仍然说了算。",
    domainLabel: "主语",
    rangeLabel: "宾语",
    anyType: "不限类型",
    searchTypes: "搜索类…",
    temporal: "时态语义",
    temporalState: "状态(有区间)",
    temporalEvent: "事件(时间点)",
    temporalEternal: "恒常(无时间)",
    functional: "函数性(同一时刻只有一个值)",
    inverseFunctional: "反函数性(同一时刻一个宾语只对一个主语)",
    axioms: "公理",
    axiomsHint:
      "这条关系保证什么。**它们不是描述,是会改变系统行为的声明**:时态引擎据此闭合旧值,推理机据此往图里加边。",
    functionalHint: "同一主语同一时刻只有一个值。新值会闭合旧值。",
    inverseFunctionalHint: "同一宾语只有一个主语。一个项目一个负责人。",
    transitive: "传递",
    transitiveHint: "A→B 且 B→C 就有 A→C。引擎会把那些边推出来。",
    symmetric: "对称",
    symmetricHint: "A→B 就有 B→A。引擎会把反方向补上。",
    asymmetric: "反对称",
    asymmetricHint: "有 A→B 就不该有 B→A。两个方向并存会被报成矛盾。",
    irreflexive: "自反禁止",
    irreflexiveHint: "任何东西不能通过这条关系指向自己。",
    axiomConflict:
      "对称与反对称同时成立,只对一条事实都没有的关系为真——两者必有一个写错了。",
    noLink: "无",
    inverseOf: "逆关系",
    inverseOfHint:
      "反过来说同一件事的那条关系。只需在一侧声明,另一个方向自动成立。",
    subPropertyOf: "父属性",
    subPropertyOfHint: "这条关系是谁的特例。说了具体的那条,宽泛的那条也成立。",
    linkMeansInverse: (p: string, q: string) =>
      `A ${p} B 同时也是 B ${q} A。`,
    linkMeansSuper: (p: string, q: string) => `A ${p} B 同时也是 A ${q} B。`,
    usage: (n: number) => `${n} 处在用`,
    builtin: "内置",
    save: "保存",
    delete: "删除",
    deleteBlocked: "在用中——无法删除",
    importShort: "导入",
    importTitle: "导入本体",
    importHint: "导入 OWL 或 RDFS 文件(.owl、.rdf、.ttl)。类与属性按 IRI 匹配,导入同一份词汇表的新版本会更新已有的,不会再进一份。",
    importPick: "选择文件",
    importChange: "换一个",
    importReading: "读取中…",
    importApplying: "导入中…",
    importApply: "导入",
    importCancel: "取消",
    importParsed: (fmt: string, triples: number) =>
      `${fmt === "rdfxml" ? "RDF/XML" : "Turtle"} · ${triples.toLocaleString()} 个三元组`,
    importNothing: "没有可导入的内容——这个文件里没有找到类或属性。",
    importWillCreate: (n: number) => `新建 ${n}`,
    importWillUpdate: (n: number) => `更新 ${n}`,
    importKeyTaken: (n: number) => `跳过 ${n}`,
    importClasses: "类",
    importRelations: "关系",
    importAttributes: "属性",
    importAttributesLater:
      "已解析,但尚未建立——属性需要挂在某个类上,那一步在下一版落地。",
    warnFunctional: (n: number) => `${n} 个关系自称是函数性的`,
    warnFunctionalBody:
      "函数性关系同一时刻只能有一个值,所以一条新事实会自动闭合上一条。当词汇表声称的唯一性你的数据并不遵守时,结果就是一队冲突。导入后请去核对它们。",
    warnNoDescription: (n: number) => `${n} 个类没有描述`,
    warnNoDescriptionBody:
      "类的描述会被原样送进抽取提示词——它是唯一告诉模型「什么算这个类」的东西。给它们补上,否则它们会悄悄少抽。",
    warnKeyTaken: (n: number) => `${n} 个 key 已被占用`,
    warnKeyTakenBody:
      "已经有另一个身份占着这个 key。它们被原样留下——如果你想要导入的那一份,先把现有的改名。",
    importTakenBy: (iri: string | null) =>
      iri ? `被 ${iri} 占用` : "被这个知识库里已有的条目占用",
    importUnprojected: "暂未投影",
    importUnprojectedBody:
      "这个文件用到、而 Utopia 目前还不消费的公理。什么都没丢:原文按上传时的样子存着,将来的版本可以投影它们。",
    importDone: (created: number, updated: number) =>
      `导入完成——新建 ${created} 个类,更新 ${updated} 个。`,
    importHistory: "历次导入",
    importColFile: "文件",
    importColFormat: "格式",
    importColSize: "大小",
    importColTriples: "三元组",
    importColWhen: "导入",
    importDetail: "详情",
    importCreatedN: (n: number) => `新增 ${n}`,
    importUpdatedN: (n: number) => `更新 ${n}`,
    importSkippedN: (n: number) => `跳过 ${n}`,
    importTakenN: (n: number) => `键被占 ${n}`,
    statClassesCreated: "新建的类",
    statClassesUpdated: "更新的类",
    statClassesTaken: "键被占住的类",
    statClassesNoDesc: "没有描述的类",
    statTriples: "读到的三元组",
    statRelationsSeen: "文件里的关系",
    statRelationsCreated: "新建的关系",
    statRelationsUpdated: "更新的关系",
    statFunctional: "声明为函数式的关系",
    statInverseLinked: "连上的逆属性",
    statSubPropertyLinked: "连上的父属性",
    statAttributesSeen: "文件里的属性",
    statAttributesCreated: "新建的属性",
    statAttributesSkipped: "跳过的属性",
    skipReason: {
      key_taken: "键已被占用",
      unusable_range: "值域不能当数据类型",
      no_domain: "没有域——没说它属于哪个类",
      domain_skipped: "它的域类也被跳过了",
      unknown_domain: "域类不在这个库里",
    } as Record<string, string | undefined>,
    importNoHistory: "还没有导入过。",
    importBy: (who: string, when: string) => `${who} · ${when}`,
    importSize: (bytes: number) =>
      bytes < 1024 ? `${bytes} B` : `${(bytes / 1024).toFixed(0)} KB`,
    misses: "本体里还没有的",
    missesHint: "文档说到了、本体还放不下的东西,以及代理为它们提的建议。",
    /* 一端挂着两个以上开放值的谓词(#341):状态一句话,后果一句话,动作在按钮上 */
    uniqueness: "并存的取值",
    uniquenessHint: "标明哪些关系同时只能有一个值,之后新值会自动结束旧值。",
    uniquenessEmpty: "没有并存:每个持有者至多一个开放取值。",
    uniquenessSubject: (n: number) => `${n} 个主语挂着两个以上开放取值`,
    uniquenessObject: (n: number) => `${n} 个取值被两个以上主语挂着`,
    uniquenessEffect: (close: number, review: number) =>
      review > 0 ? `闭合 ${close} 条,${review} 条进人审` : `闭合 ${close} 条`,
    uniquenessDeclare: "声明并闭合",
    uniquenessReconcile: "闭合它们",
    uniquenessDeclared: "已声明",
    uniquenessBusy: "闭合中…",
    uniquenessDone: (close: number, review: number) =>
      review > 0 ? `已闭合 ${close} 条 · ${review} 条待审` : `已闭合 ${close} 条`,
    uniquenessSince: (d: string) => `自 ${d}`,
    noMisses: "文档说到的东西里,没有在等本体给位置的。",
    uncovered: (kindWords: number, phrases: number) => {
      const what = [
        kindWords > 0 ? `${kindWords} 种东西` : "",
        phrases > 0 ? `${phrases} 种关系说法` : "",
      ]
        .filter(Boolean)
        .join("、");
      return `文档里有 ${what},本体里还没有位置。可以让代理为它们提出类和属性;你采纳之前什么都不会加进本体。`;
    },
    approve: "加入",
    mapOver: "用已有的",
    proposals: "AI 提案",
    keyHint: "小写下划线命名",
    /* ---- 0061:本体代理与能力问题 ---- */
    askAgent: "请代理提案",
    askAgentHint:
      "从本体还没覆盖的短语和类别词里提出该建的类与属性,对着能力问题判断。",
    agentQueued: "代理在看——看完了提案会出现在这里。",
    agentWaiting: "代理在看…",
    agentChip: "代理",
    servesQuestions: (n: number) => `服务 ${n} 个问题`,
    bindsShapes: (n: number) => `会绑 ${n} 种短语形状`,
    bindsKindWords: (n: number) => `${n} 个类别词`,
    closestExisting: (key: string, label: string) => `最近的已有:${key} ${label}`,
    rejectProposal: "拒绝",
    rejectReasonPrompt: "为什么不要?(可不填——代理下次提案前会读)",
    rejectedProposal: "已拒绝",
    adoptKept: (n: number) => `已保存。其中 ${n} 条已由人另行判定,按人的判定保留。`,
    questions: "能力问题",
    questionsHint:
      "这个知识库应该答得上来的问题。代理提的类与属性要服务它们;它们就是本体的验收标准。",
    questionPlaceholder: "例:每位创始人创办了哪些公司、什么时候?",
    addQuestion: "添加",
    noQuestions: "还没有问题。没有它们,代理只能按文档里的说法判断提案。",
    retireQuestion: "退役",
    deleteQuestion: "删除",
    questionAdded: "已添加问题",
    questionRetired: "问题已退役",
    askQuestions: "请代理提问题",
    askQuestionsHint: "从文档说得最多的东西里提问题,等你接受了才算数。",
    questionsQueued: "代理在写问题——写完了会出现在这里。",
    acceptQuestion: "接受",
    questionAnswered: "答上了",
    questionUnanswered: "没答上",
    questionVia: { graph: "来自图谱", text: "来自正文", both: "图谱与正文" },
    questionsScore: (answered: number, checked: number) =>
      `${checked} 条问过,${answered} 条答上`,
    questionsScoreHint: "competency bench 对图谱问过的已接受问题,答上了几条。",
    viaGraph: (withGraph: number, graphOnly: number) =>
      `${withGraph} 条经过图谱 · ${graphOnly} 条只靠图谱`,
    viaGraphHint:
      "答上的问题里,几条途中从图谱拿到过事实,几条根本没读正文。只靠正文答上的不需要本体。",
    proposalsChanged: (changed: number, decided: number) =>
      `${decided} 条提案表过态,${changed} 条被改或被拒`,
    proposalsChangedHint: "代理的提案里人表过态的,有几条被拒或改过再采纳。",
    /* ---- 模式图 ---- */
    schemaDiagram: "模式图",
    schemaEmpty:
      "还没有类。没有类文档也照常读;类和属性是把读到的内容变成类型化事实的那一步。可以让代理按你的文档提出来、导入一份本体,或者自己加一个类。",
    schemaEmptyAction: "看看文档需要什么",
    schemaFitView: "归位",
    schemaZoomIn: "放大",
    schemaZoomOut: "缩小",
    schemaLegendInheritance: "继承",
    schemaLegendRelation: "关系",
    schemaLegendDisjoint: "互斥",
    schemaLegendRule: "业务规则",
    schemaUnscoped: (n: number) => `未限定的属性(${n})`,
    schemaUnscopedHint: "没有限定在具体的类上,画到画布上的连线会是本体没说过的话。选一个来查看或编辑。",
    schemaMoreClasses: (n) => `+${n} 个类`,
    schemaScopeInUseHint: "画的是有实例的类及其祖先。想看别的类,在左栏点它。",
    schemaScopeTopHint: "还没有类有实例,画的是层级最上面两层。想看别的类,在左栏点它。",
    schemaClosePanel: "关闭",
    schemaTabDefinition: "定义",
    schemaTabRelations: "关系",
    schemaTabAttributes: "属性",
    schemaTabInstances: "实例",
    schemaAddRelationship: "新建关系…",
    schemaCheckDefects: (n) =>
      n === 1 ? "这次改动带来 1 个新的本体问题" : `这次改动带来 ${n} 个新的本体问题`,
    schemaCheckReview: "去审阅",
    schemaBundle: (n) => `${n} 条关系`,
    schemaOutgoing: "从这个类出发",
    schemaIncoming: "指向这个类",
    schemaNoRelationships: "这个类没有参与任何关系。继承信息显示在“定义”中。",
    schemaNoInstances: "还没有实例。",
    schemaConnectHint: "用一个已有的关系连接",
    schemaConnectPlaceholder: "搜索关系…",
    schemaConnectAs: "作为",
    schemaConnect: "连接",
    schemaConnected: (label) => `已通过 ${label} 连接。`,
  },
  mapping: {
    title: "数据映射",
    hint: "每个业务概念对应库里的哪张表、哪一列,以及怎么算。对话只用已确认的定义作答。",
    tabDefinitions: "口径",
    tabSources: "数据源",
    filterAll: "全部",
    filterProposed: "待审批",
    filterConfirmed: "已确认",
    filterRejected: "已拒绝",
    searchPlaceholder: "搜概念、数据源或表名…",
    total: (n: number) => `共 ${n} 条`,
    range: (from: number, to: number, total: number) =>
      `第 ${from}–${to} 条,共 ${total} 条`,
    prev: "上一页",
    next: "下一页",
    empty: "还没有口径。挂上数据源后点「探查映射」,让智能体先提一批。",
    emptyFiltered: "没有符合条件的口径。",
    rejectedHint:
      "拒绝过的也列在这里——否则「这个概念为什么没被映射」永远答不上来。",
    colConcept: "概念",
    colSource: "数据源",
    colDefinition: "怎么算",
    colStatus: "状态",
    derivedBadge: "派生",
    noDefinition: "(未填)",
    approve: "确认",
    reject: "拒绝",
    selectPage: "全选本页",
    selectMapping: (name, source) => `选择 ${source} 中的 ${name}`,
    selected: (n) => `已选 ${n} 条`,
    edit: "编辑",
    editTitle: "改口径",
    fieldTable: "表",
    fieldExpr: "表达式",
    fieldSql: "SQL",
    fieldUnit: "单位",
    fieldSummary: "说明",
    fieldDerived: "派生指标(算出来的,不是表里的列)",
    save: "保存",
    cancel: "取消",
    needOne: "表、表达式、SQL 至少填一个。",
    history: "改版历史",
    historyHint:
      "改之前那一版的整版快照。留着是为了答得出「上季度这个数是怎么算的」。",
    historyEmpty: "还没有改过。",
    historyBy: (who: string) => `由 ${who} 修改`,
    historyUnknown: "一位已移除的用户",
    sourcesHint:
      "已挂载的只读数据库。挂载会摄入库表结构,问数写 SQL 前才知道有哪些表。",
    mount: "挂载",
    unmount: "卸载",
    syncSchema: "刷新结构",
    schemaSynced: (n: number) => `结构已摄入(${n} 张表)`,
    // 挂载成了、结构没成。**别说成失败**——源是真挂上的
    schemaFailed:
      "数据源已挂载,但库表结构没能摄入——问数看不见有哪些表。已报进告警中心;" +
      "检查连接串后点「刷新结构」重试。",
    explore: "探查映射",
    exploreHint:
      "一个智能体读这些库表结构,提出指标/维度的口径。提出来的落在「待审批」,确认之后问数才会用。",
    exploreQueued: "探索已排队,提议会出现在「待确认」里;一条都提不出来时,铃铛会告诉你。",
    // **最近一轮探索的账**——光看列表答不了「漏了多少」(#503):
    // 十二条提议对着八十列的宽表与刚好覆盖完一个小库长得一样。这条贴出来人
    // 才能从「等量提议」里看出覆盖范围。
    lastRun: (r: {
      tables: number;
      columns: number;
      returned: number;
      accepted: number;
      truncated: boolean;
    }) => {
      const parts = [
        `${r.tables} 张表`,
        `${r.columns} 列`,
        `返回 ${r.returned}`,
        `落库 ${r.accepted}`,
      ];
      if (r.truncated) parts.push("(结构被截)");
      return `上一轮探索:${parts.join(" / ")}`;
    },
    lastRunMissing: "还没有跑过探索。",
    sourcesEmpty: "没有挂载任何数据源。",
    sourcesNoneAvailable: "还没有登记数据源——请部署管理员登记一个。",
    newConn: "登记新连接",
  },
  review: {
    title: "审阅",
    hint: "重复项与低置信度事实",
    tabHistory: "历史",
    empty: "没有待审阅的——图谱是干净的。",
    historyEmpty: "还没有合并记录。",
    railOverview: "总览",
    railPending: "等你点头",
    railDuplicates: "重复项",
    railConflicts: "冲突",
    railUnconfirmed: "未确认",
    railLowConfidence: "低置信度",
    railMappings: "数据映射",
    railViolations: "公理",
    railDefects: "本体",
    railAlignment: "对齐",
    railErrata: "勘误",
    railDecisions: "决定",
    railMerges: "合并",
    railAgent: "Agent",
    categoryEmpty: "这个队列是空的。",
    agentTitle: "Agent",
    agentHint:
      "agent 依据这个库里人以前的决定,提议或裁决了什么。在这里回答就是你的决定,也会成为它下一次的先例。",
    agentEmpty: "agent 还没看过任何一对。",
    agentActions: { merge: "合并", keep: "分开", unsure: "说不准" } as Record<string, string>,
    agentStatus: {
      proposed: "建议",
      applied: "已裁",
      accepted: "已接受",
      overridden: "已改判",
      reverted: "已撤回",
      superseded: "已过时",
    } as Record<string, string>,
    agentSuggests: (action, pct) => `agent 建议${action} · ${pct}%`,
    agentPrecedents: (n) => `${n} 条先例`,
    agentPrecedentMerged: "人合过",
    agentPrecedentKept: "人分开过",
    agentPrecedentReverted: "人撤回过合并",
    agentPrecedentHabit: (merged, kept, reverted) =>
      `这种类型对在本库:合 ${merged}、分 ${kept}、撤回 ${reverted}`,
    agentAnsweredBy: (name, date) => `${name} · ${date}`,
    agentAsks: "问:",
    agentLookups: (n) => `查了 ${n} 次`,
    agentLookedAt: "看了",
    overviewAgent: "Agent",
    overviewAgentOff: "这个库的治理没有打开。",
    overviewAgentSettings: "去设置里打开",
    overviewAgentOpen: "等你回答",
    overviewAgentApplied: "自己裁的",
    overviewAgentAccepted: "你接受的建议",
    overviewAgentOverridden: (n) => `改判 ${n},近 30 天`,
    overviewAgentReverted: "你撤回的",
    overviewAgentRunning: (n) => (n === 0 ? "agent 在处理最后一簇" : `agent 处理中 · 还有 ${n} 对没看`),
    overviewAgentQueue: (n) => `${n} 对等 agent 看`,
    agentDeciding: "agent 正在裁这一对",
    overviewTitle: "总览",
    overviewHint: "这个库要你做什么:有多少在等、等了多久、办过什么、还有多少是暂定的。",
    overviewWaiting: "等着办的",
    overviewAllClear: "没有在等的——库是干净的。",
    overviewOldest: (days) => (days === 0 ? "最老的今天进来" : days === 1 ? "最老的昨天进来" : `最老的等了 ${days} 天`),
    overviewOpen: "去处理",
    overviewDecided: "办过的",
    overviewLast7: "近 7 天",
    overviewLast30: "近 30 天",
    overviewAutomatic: (n) => `其中裁决器自裁 ${n} 条`,
    overviewDaily: "近 14 天每天的决定",
    overviewByAction: "按类型",
    overviewByActor: "谁办的",
    overviewNoDecisions: "近 30 天没有决定。",
    overviewHealth: "库的成色",
    overviewFacts: (n) => `现在持有 ${n} 条事实。其中:`,
    overviewContested: "有争议",
    decisionsTitle: "决定",
    decisionsHint:
      "每一次审阅决定、由谁在何时做出——快照在决定当时留存,即使底下的事实已经不在了也保留。",
    decisionsEmpty: "还没有决定记录。",
    aiActor: "AI 裁决",
    decisionActions: {
      "review.merge": "已合并",
      "review.keep": "保持分开",
      "fact.confirm": "已确认",
      "fact.reject": "已驳回",
      "fact.nod_confirmed": "已确认一条记忆事实",
      "fact.nod_rejected": "已驳回一条记忆事实",
      "fact.close": "已闭合",
      "conflict.close_old": "闭合旧的",
      "conflict.keep_both": "两条都留",
      "conflict.reject_new": "驳回新的",
      "merge.revert": "撤销合并",
      "merge.manual": "手动合并",
      "fact.time_corrected": "改了时间",
    },
    escalated: {
      escalate_no_model: "没有对话模型——裁决跑不起来",
      escalate_no_verdict: "裁决没有给出结论",
      escalate_entity_changed: "裁决过程中实体发生了变化",
      escalate_unsure: "裁决的把握不够",
      escalate_sample: "抽给人看的一份;裁决器本有把握",
      escalate_impact: "留给人;这次合并不会只留在图里",
      proposed: "agent 看过了,留了一条建议",
      governed: "agent 按先例裁的",
      namesake: "同一篇文档里有两个同名实体",
      namesake_tie: "同名,画像分不出谁是谁",
      shared_name: "另一个实体已经叫这个名字",
      name_vector: "名字相近(向量召回),等裁决",
      contains: "一个名字包含另一个",
      ambiguous_name: "同名,但上下文没能定夺",
      type_drift: "同名,但类型不同",
      auto_merged: "AI 裁决已自动合并",
      kept_apart: "AI 裁决认为不是同一个",
    } as Record<string, string>,
    impact: {
      contradiction: (p) => `合了会让一个实体有两条“${p}”`,
      derived: (n) => `有 ${n} 条派生事实靠着一边`,
      answered: (n) => `有一边在 ${n} 个回答里被点过名`,
    } as Record<string, (v: string) => string>,
    duplicates: "可能重复",
    duplicatesHint:
      "同名,但上下文不同。AI 在后台裁决明确的情形;其余等你。合并永远可撤销。",
    stageAdjudicating: "AI 裁决中",
    stageHuman: "需要你来定",
    similarity: (pct: number) => `上下文相似度 ${pct}%`,
    factsCount: (n: number) => `${n} 条事实`,
    noFacts: "没有记录的事实",
    merge: "合并",
    keep: "保持分开",
    rationalePlaceholder: "什么让你这么定?可不写",
    typesAny: "全部",
    typesSame: "同类型",
    typesConflict: "类型不同",
    typesEmpty: "这一档没有东西。",
    typesDiffer: (a, b) => `${a} / ${b}`,
    typesDifferHint: "两边不是一种东西,合了等于把一个意思并进另一个。",
    pickPair: "选中这一对",
    selectPage: "全选本页",
    selected: (n) => `已选 ${n} 对`,
    mergeSelected: "合并所选",
    keepSelected: "所选保持分开",
    batchDone: (ok, failed) =>
      failed === 0 ? `已裁 ${ok} 对` : `已裁 ${ok} 对,${failed} 对没成,留在队列里`,
    lowConfidence: "低置信度事实",
    // 对齐队列(#725)
    alignment: "对齐器拿不定的",
    alignmentHint:
      "两类东西之间的一个说法,或一个类别词,对齐器的两票不一致。选出文档这个说法对应本体的哪个属性或类,或者说没有对得上的:那些陈述就留在开放图谱里。你定了就算数,对齐器不会改人的判定。",
    alignmentValue: "一个值",
    alignmentNone: "没有对得上的",
    alignmentForward: "照原文方向",
    alignmentReverse: "反过来",
    alignmentBind: "绑定",
    alignmentLeaveOpen: "留在开放图谱",
    alignmentStatements: (n: number) => `${n} 条陈述`,
    alignmentEntities: (n: number) => `${n} 样东西`,
    alignmentVotes: (first: string, second: string) => `两票:${first} · ${second}`,
    // 状态属性下,单个日期标的是什么(#966)
    alignmentMarks: "单个日期",
    alignmentMarksStart: "是开始",
    alignmentMarksEnd: "是结束",
    alignmentMarksNone: "都不是",
    alignmentMarksStartHint: "加入、被任命、接手:从那天起成立",
    alignmentMarksEndHint: "离开、辞去、卸任:到那天为止",
    alignmentMarksNoneHint: "只是那时看到它成立:只带一个日期的陈述留在开放图谱",
    alignmentMarksRequired: "先说单个日期标的是什么。",
    alignmentAwaitsMarks: (property: string) =>
      `已绑到 ${property},单个日期标的是什么还没定。你说之前,只带一个日期的陈述留在开放图谱。`,
    alignmentRuleImplies: (property: string) => `同时蕴含 ${property}`,
    alignmentRuleObjectIsStatement: "宾语:陈述自己的宾语",
    alignmentRuleReading: (reading: string) => `宾语:按「${reading.replace(/_/g, " ")}」从字里读出`,
    alignmentRuleKindWord: (word: string) => `叫作「${word}」的东西`,
    alignmentApprove: "批准规则",
    alignmentReject: "驳回",
    alignmentRuleAccepted: "已保存,隐含事实正在后台计算。",
    // 勘误队列(0044 决定 7)
    errata: "勘误 agent 留给你的",
    errataHint:
      "抽取之后,一个 agent 按文档复读类型化事实,结构报了的先看,撤、改、加都以文档原话为证据。会牵动图外东西的动作(有派生靠着它、有人问过它、会让只许一个值的属性有两个值)留在这里等人。",
    errataRetract: "想撤掉",
    errataRevise: "想改成",
    errataAdd: "想加上",
    errataFlag: (flag: string) =>
      ({
        domain: "结构报的:主语不在属性允许的类里",
        range: "结构报的:宾语不在属性允许的类里",
        name_absent: "结构报的:名字不在文档里",
        no_date: "结构报的:日期属性没有日期",
      })[flag] ?? flag,
    errataHeld: (detail: string) => {
      const [kind, ...rest] = detail.split(" ");
      const value = rest.join(" ");
      if (kind === "derived") return `留下的原因:有 ${value} 条派生靠着它`;
      if (kind === "answered") return `留下的原因:它在 ${value} 次回答里被提到`;
      if (kind === "contradiction") return `留下的原因:「${value}」只许一个值,这样会有两个`;
      if (kind === "unflagged") return "留下的原因:结构没报过这条,撤或改要人确认";
      return `留下的原因:${detail}`;
    },
    errataQuote: "文档原话:",
    errataApprove: "执行",
    errataReject: "否",
    errataDecided: "已保存。",
    alignmentTooMany: (n: number) => `有 ${n} 条属性都可能对得上,多到没法问模型。请选一条或留在开放图谱。`,
    alignmentConflict: "此决定与当前状态冲突。请刷新并核对后再试。",
    alignmentKindWordBusy: "这个类别词正在被其他操作更新,请稍后重试。",
    alignmentAccepted: "已保存。类型化图谱正在后台重算,算完会在这里自动刷新。",
    defects: "本体自相矛盾",
    defectsHint:
      "定义本身的问题,没有牵涉任何事实。这一档排在前面:定义站不住的时候,据它报出来的每一条事实级结论都可疑。",
    defectSymAsym: "同时声明了对称与反对称",
    defectTransFunc: "传递与函数性并存",
    defectCycle: "subClassOf 绕成了环",
    defectDisjointAncestor: "与自己的祖先互斥",
    defectInheritsDisjoint: "继承了两个互斥的类",
    defectInverseSelf: "自己是自己的逆——写成「对称」更直白",
    defectInverseNotMutual: "逆关系没有指回来",
    defectSubPropertyCycle: "子属性绕成了环",
    defectRulesDisagree: "两条规则推出互相抵触的结论",
    rulesDisagreeCount: (n: number) => `${n} 对派生等这里定了再落地`,
    rulesDisagreeRule: (
      a: string,
      va: string,
      b: string,
      vb: string,
      axiom: string,
    ) => `${va} 上的 ${a} 与 ${vb} 上的 ${b},撞在 ${axiom} 上`,
    defectNeverInstantiable: "这个类永远不可能有实例",
    defectFixed: "已去本体里改了",
    defectAccepted: "先放着",
    runInference: "跑一遍推理",
    inferring: "推理中…",
    inferenceNoRules: "本体没有声明传递或对称属性,编不出规则。",
    inferenceAdded: (n: number) => `推出 ${n} 条`,
    inferenceRetracted: (n: number) => `作废 ${n} 条`,
    inferenceNothing: "没有新的可推",
    inferenceCapped: (n: number) => `${n} 个谓词撞上单谓词上限,没有推完`,
    violations: "公理违规",
    violationsHint:
      "与本体自己声明的公理相抵触的事实。这里没有猜测——谓词没声明公理就不查。",
    violationSelfLoop: "指向了自己",
    violationAsymmetry: "两个方向同时成立",
    violationCycle: "传递链绕成了环",
    violationFunctional: "同一时间有不止一个值",
    violationInverseFunctional: "同一时间有不止一个持有者",
    violationSignature: "主语或宾语不在关系声明的类型里",
    violationDerived: "推出来的与断言相抵触",
    derivedLine: (s: string, p: string, o: string) =>
      `推出:${s} · ${p} · ${o}`,
    derivedBy: (rule: string, via: string) => `由 ${via} 上的 ${rule}`,
    assertedLine: (t: string) => `断言:${t}`,
    hintStale: "这条断言没写结束日期,而推出来的那条起得更晚——它可能只是结束了。",
    hintDuplicate: "有两个同名实体,它们可能是同一个。",
    hintUnsure: "这条断言抽取时把握不大,去读一下原句。",
    hintReadBoth: "读一下两边的原句,判断哪条错了。",
    closeAssertion: "给断言一个结束日期",
    retractAssertion: "撤掉断言",
    seeDuplicates: "去看重复实体",
    openOntology: "去本体页",
    letBothStand: "两边都成立",
    violationVia: (p: string) => `依据 ${p}`,
    violationPath: (n: number) => `环上 ${n} 条事实`,
    retractFact: "数据错了",
    retractThis: "撤这条",
    retractThisHint: "把这条事实撤出图谱,其余的不动。",
    relaxAxiom: "公理错了",
    acceptBoth: (n: number) => (n > 2 ? "都对" : "两边都对"),
    runCheck: "跑一遍检查",
    checkNeverRun:
      "还没查过。矛盾是拿本体自己声明的公理量出来的——跑一遍只会报公理确实说了的那些。",
    checking: "检查中…",
    checkNoAxioms: "本体没有声明任何公理,无从判起。先导一份带公理的本体。",
    checkFound: (n: number) => `新增 ${n} 处`,
    /** 算出来了,但都是已经在队列里或已被裁决过的——说「3 处矛盾」而列表只有
     *  一条会让人以为界面漏了东西 */
    checkNothingNew: "没有新的",
    checkClean: (n: number) => `查了 ${n} 条事实,没有矛盾`,
    mappings: "数据映射",
    mappingsHint:
      "从业务概念到「这个数怎么算」的提议。确认之后问数直接用这个口径,而不是每次从 schema 猜。",
    mappingDerived: "派生",
    // 记忆抽出、等人点头的事实(0015)
    pending: "等你确认",
    pendingHint:
      "从你让助手记住的话里抽出的事实。这里的东西都还没进图:那句话已经存下,事实等你点头。" +
      "确认后以那句话为证据进账本;驳回后不会再被提议。",
    pendingNoPredicate: "本体里没有这个关系,这个词是模型自己的说法。",
    pendingOwnWords: "文档自己的话;对到本体上是对齐那一步的事。",
    pendingNoPredicateChip: "本体里没有这个关系",
    pendingSaidBy: (name: string) => `${name} 说的`,
    pendingSaidVia: (name: string, agent: string) => `${name} 说的 · 经 ${agent}`,
    nodCardTitle: (n: number) =>
      n === 1 ? "从这句话里抽出 1 条事实。确认进图,或驳回。" : `从这句话里抽出 ${n} 条事实。确认进图,或驳回。`,
    lowConfidenceHint:
      "抽取时置信度低于 75%。确认表示采信,驳回表示从图谱移除(台账仍留有记录)。",
    confirm: "确认",
    reject: "驳回",
    confidence: (pct: number) => `${pct}%`,
    mergeHistory: "合并历史",
    mergedBy: (name: string) => `由 ${name}`,
    mergedByAi: "由 AI 裁决",
    revert: "撤销",
    reverted: "已撤销",
    ongoing: "至今",
    conflicts: "时态冲突",
    conflictsHint:
      "两条事实主张同一个单值关系。明确的接续会自动闭合;" +
      "这些需要人来定。闭合可通过台账撤销。",
    conflictReason: {
      no_time: "新事实没有日期",
      simultaneous: "起始日期相同",
      described_evidence: "新的那条是看图读出来的",
      low_confidence: "新的那条不够确信",
    },
    conflictVs: "对",
    conflictSince: (d: string) => `自 ${d} 起`,
    closeOld: "闭合旧的",
    closeOldAt: (d: string) => `在 ${d} 闭合旧的`,
    keepBoth: "两条都留",
    rejectNew: "驳回新的",
    closeAtPlaceholder: "2024-06-15 · 2024-06 · 2024 · 2024-06-15T14:32Z",
    unconfirmed: "已不再被陈述",
    unconfirmedHint:
      "曾经陈述这些事实的每一个来源,此后都更新过且不再包含它们。" +
      "系统不会自动删除任何东西——没提到不等于否定。抽取错误就驳回," +
      "真正结束了的就闭合(选它结束的日期)。",
    closeFact: "闭合",
    closeFactAt: (d: string) => `在 ${d} 闭合`,
  },
  ui: {
    close: "关闭",
    noMatches: "没有匹配",
    keepTyping: (n: number) => `还有 ${n} 项——继续输入以缩小范围`,
  },
  kbset: {
    title: "知识库设置",
    general: "常规",
    members: "成员",
    materialize: "物化推理",
    materializeNote:
      "把本体蕴含的事实写进账本——传递链与对称对。它们带派生标记、单列一段,背后的声明要是错了,撤掉只要一下。",
    autoResolveTypes: "抽取后自动消解实体类型",
    autoResolveTypesNote:
      "每篇文档抽完,对引擎还没看过的实体跑一轮类型消解。只有在现类子树里精化的才自动落地,跨轴的改判仍留在本体页等你。每一批都列在本体页,随时可以撤回。",
    governance: "让 agent 处理重复项队列",
    governanceNote:
      "先进先出。裁一对之前,agent 先读这个库里的人对同样的名字、同样的类型对做过什么决定:有先例撑着才合并,有把握就分开,其余的写成建议留给你。每一笔都列在审核页的 Agent 里,可以撤回。关掉,队列就停。",
    inferEvery: "每隔",
    minutes: "分钟重推",
    lastInference: (when: string) => `上次 ${when}`,
    failedJobs: (n: number) => `${n} 个失败的任务`,
    requeue: "再跑一遍",
    requeued: (n: number) => `${n} 个任务回到队列`,
    exportKb: "导出整个知识库(RDF)",
    exportKbNote: "把所有事实及其出处下载为 Turtle 文件。",
    exportKbAction: "导出",
    cardIdentity: "名字与描述",
    cardIdentityNote: "最长 64 个字符。切换器和这个库每一页的顶上用的都是它。",
    cardVisibilityNote:
      "Open 是部署里的所有人都读得到;Restricted 只有成员名单上的人读得到。",
    cardVisibilityFoot: "改完立刻生效。成员名单上授过的角色两种情况下都留着。",
    cardAutomation: "自动跑的那几件事",
    cardAutomationNote: "从下一次抽取起生效。它们做的每一步都记着,可以撤回。",
    cardJobs: "后台任务",
    ontologyLang: "本体的语言",
    ontologyLangNote:
      "类与关系的描述用哪种语言写。它们会被原样送进抽取提示词," +
      "所以读者是正在读你文档的模型——跟你的文档一致,而不是跟界面一致。" +
      "改这一项不会重写已经写好的;它决定的是此后新写的描述用什么语言。",
    defaultOpenLabel: "对所有人开放",
    defaultOpenNote:
      "这是本部署的默认知识库,所以可见性被锁定:每位成员在这里至少有只读权限," +
      "这保证了没有人登录后面对一片空白。出于同样的原因它也不能被删除。" +
      "要给某人超出只读的权限,在「成员」里授予角色;需要私密空间的话," +
      "另建一个知识库并设为受限。",
    data: "数据",
    dataHint:
      "已挂载的只读数据库,本知识库可以在「对话」里查询它们。" +
      "挂载会摄入数据库模式,好让助手知道有哪些表。",
    dataMount: "挂载",
    dataUnmount: "卸载",
    dataSyncSchema: "刷新模式",
    dataSchemaSynced: (n: number) => `模式已摄入(${n} 张表)`,
    dataExplore: "探查映射",
    dataExploreHint:
      "一个智能体读取这些模式并提出指标/维度定义——在「对话」用上它们之前,先到「审阅」里过一遍。",
    dataExploreQueued: "探查已排队——提案稍后会出现在「审阅」中。",
    dataNone: "没有挂载任何数据源。",
    dataNoneAvailable: "还没有登记数据源——请部署管理员登记一个。",
    dataNewConn: "登记新连接",
    activity: "活动",
    activityHint: "谁在这个知识库里改了什么。纯审计——记录只追加。",
    auditAllActions: "全部动作",
    auditSince: "起始日期",
    auditUntil: "截止日期",
    auditClear: "清除筛选",
    auditTotal: (n: number) => `共 ${n} 条`,
    activityEmpty: "还没有记录。",
    deletedUser: "一位已移除的用户",
    adjudicator: "AI 裁决器",
    engine: "引擎",
    auditActions: {
      "entity_type.created": "创建了实体类型",
      "entity_type.updated": "更新了实体类型",
      "entity_type.deleted": "删除了一个实体类型",
      "relation_type.created": "创建了关系类型",
      "relation_type.updated": "更新了关系类型",
      "relation_type.deleted": "删除了一个关系类型",
      "kb.updated": "更新了知识库设置",
      "kb.member_set": "设置了成员角色",
      "kb.member_removed": "移除了成员",
      "source.created": "创建了来源",
      "source.updated": "更新了来源",
      "source.deleted": "删除了一个来源",
      "document.deleted": "删除了文档",
      "ontology.imported": "导入了一份本体",
    },
    membersHintOpen:
      "本部署内的所有人已经能读这个知识库,所以没有「查看者」可授——" +
      "在这里列出某个人,只是为了给他写权限。部署管理员始终拥有。",
    membersHintRestricted:
      "只有这里列出的人能看到这个知识库,角色决定他能改什么。" +
      "部署管理员始终有访问权。",
    addMember: "添加…",
    addMemberTitle: "添加成员",
    roles: { viewer: "只读", editor: "编辑者", admin: "管理员" },
    remove: "移除",
    noMembers: "没有设置任何库内角色。",
    noWriters: "还没有给任何人写权限。",
    save: "保存",
    saved: "已保存",
    danger: "危险操作",
    deleteKb: "删除这个知识库",
    deleteHint: (name: string) =>
      `输入「${name}」确认。文档、图谱与来源都将被永久移除。`,
    deleteBtn: "永久删除",
    deleteRowTitle: "删除这个知识库",
    deleteRowHint: "文档、图谱与来源都将被永久移除。",
    deleteRowBtn: "删除",
  },
  members: {
    title: "部署用户",
    systemAdmin: "系统管理员",
    systemAdminHint: "可进入系统管理:部署配置、账号、数据源。不能收回自己的。",
    remove: "移除",
    deactivate: "停用账号",
    cancel: "取消",
    deactivateHint:
      "断掉整个系统的访问——登录与已签发的 token 都失效。他做过的事仍然记在他名下。",
    deactivatedTitle: "已停用的账号",
    deactivatedHint:
      "他们登不进来,也不出现在任何成员列表里。做过的事仍然算在他们名下——账号被保留而不是删除,正是为了这个。",
    editMember: "编辑成员",
    close: "关闭",
    save: "保存",
    reactivate: "恢复",
    roleLabel: "角色",
    filterAll: "全部用户",
    filterAllRoles: "全部角色",
    statusLabel: "状态",
    filterActive: "在用",
    filterDeactivated: "已停用",
    deactivateConfirm: (name: string) =>
      `停用 ${name}?他将无法再登录任何地方,但过往的决定仍然留痕。`,
    addExisting: "添加已有用户",
    userLabel: "用户",
    pickUser: "选择要添加的用户…",
    add: "添加",
    roles: {
      owner: "所有者",
      admin: "管理员",
      editor: "编辑者",
      viewer: "只读",
    },
  },
};