feat(dataset): add document detail (#39361)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

web/app/(commonLayout)/datasets/new/[knowledgeSpaceId]/documents/[documentId]/page.tsx

@@ -0,0 +1,11 @@
+import { DocumentDetailPage } from '@/features/new-rag/document-detail-page'
+
+export default async function Page({
+  params,
+}: {
+  params: Promise<{ documentId: string; knowledgeSpaceId: string }>
+}) {
+  const { documentId, knowledgeSpaceId } = await params
+
+  return <DocumentDetailPage documentId={documentId} knowledgeSpaceId={knowledgeSpaceId} />
+}

web/features/new-rag/README.md

@@ -16,6 +16,14 @@ tasks.
 - `create-upload-queue`
 - `create-knowledge-workflow`
 - `document-list`
+- `document-chunk-detail`
+- `document-chunk-tree`
+- `document-detail-header`
+- `document-detail-model`
+- `document-detail-queries`
+- `document-detail-page`
+- `document-detail-status`
+- `document-revision-content`
 - `document-model`
 - `document-upload-policy`
 - `documents-page`
@@ -28,6 +36,8 @@ tasks.
 - `sources-page`
 - `storage`
 - `task-event-observer`
+- `use-document-task-status`
+- `use-document-reindex`
 - `website-crawl-preview`
 
 ## External Modules

web/features/new-rag/__tests__/document-detail-model.spec.ts

@@ -0,0 +1,187 @@
+import type {
+  DocumentRevisionChunk,
+  LogicalDocument,
+  LogicalDocumentRevision,
+} from '@dify/contracts/knowledge-fs/types.gen'
+import {
+  buildDocumentChunkTree,
+  chunkCharacterCount,
+  chunkContentParts,
+  chunkMetadataEntries,
+  chunkTreeLabel,
+  initialDocumentRevision,
+  visibleDocumentChunkNodes,
+} from '../document-detail-model'
+
+const chunk = (overrides: Partial<DocumentRevisionChunk>): DocumentRevisionChunk => ({
+  createdAt: '2026-07-21T10:00:00Z',
+  documentId: 'document-1',
+  documentRevision: 3,
+  enabled: true,
+  id: 'chunk-1',
+  knowledgeSpaceId: 'space-1',
+  ordinal: 1,
+  text: 'Chunk content',
+  tokenCount: 2,
+  userMetadata: {},
+  ...overrides,
+})
+
+const document = (overrides: Partial<LogicalDocument> = {}): LogicalDocument => ({
+  active: {
+    contentHash: 'hash-3',
+    createdAt: '2026-07-21T10:00:00Z',
+    documentAssetId: 'asset-1',
+    documentAssetVersion: 1,
+    documentId: 'document-1',
+    knowledgeSpaceId: 'space-1',
+    mimeType: 'text/markdown',
+    revision: 3,
+    sizeBytes: 1200,
+    state: 'active',
+  },
+  activeRevision: 3,
+  createdAt: '2026-07-21T09:00:00Z',
+  id: 'document-1',
+  knowledgeSpaceId: 'space-1',
+  rowVersion: 2,
+  status: 'ready',
+  title: 'SSO enterprise',
+  updatedAt: '2026-07-21T10:00:00Z',
+  userMetadata: {},
+  ...overrides,
+})
+
+const revision = (value: number): Exclude<LogicalDocumentRevision, null> => ({
+  contentHash: `hash-${value}`,
+  createdAt: `2026-07-21T0${value}:00:00Z`,
+  documentAssetId: 'asset-1',
+  documentAssetVersion: value,
+  documentId: 'document-1',
+  knowledgeSpaceId: 'space-1',
+  mimeType: 'text/markdown',
+  revision: value,
+  sizeBytes: value * 100,
+  state: value === 3 ? 'active' : 'superseded',
+})
+
+describe('document detail model', () => {
+  it('builds a deterministic parent-child tree and keeps orphans visible', () => {
+    const tree = buildDocumentChunkTree([
+      chunk({ id: 'child-b', ordinal: 3, parentChunkId: 'parent' }),
+      chunk({ id: 'parent', ordinal: 1 }),
+      chunk({ id: 'orphan', ordinal: 2, parentChunkId: 'missing' }),
+      chunk({ id: 'child-a', ordinal: 2, parentChunkId: 'parent' }),
+    ])
+
+    expect(tree.roots.map((node) => node.chunk.id)).toEqual(['parent', 'orphan'])
+    expect(tree.byId.get('parent')?.children.map((node) => node.chunk.id)).toEqual([
+      'child-a',
+      'child-b',
+    ])
+  })
+
+  it('breaks cyclic parent links instead of losing every node', () => {
+    const tree = buildDocumentChunkTree([
+      chunk({ id: 'cycle-a', ordinal: 1, parentChunkId: 'cycle-b' }),
+      chunk({ id: 'cycle-b', ordinal: 2, parentChunkId: 'cycle-a' }),
+      chunk({ id: 'self', ordinal: 3, parentChunkId: 'self' }),
+    ])
+
+    expect(tree.roots.map((node) => node.chunk.id)).toEqual(['cycle-a', 'cycle-b', 'self'])
+  })
+
+  it('builds a long parent chain without repeated ancestor walks', () => {
+    const chunks = Array.from({ length: 5000 }, (_, index) =>
+      chunk({
+        id: `chunk-${index}`,
+        ordinal: index,
+        parentChunkId: index ? `chunk-${index - 1}` : undefined,
+      }),
+    )
+
+    const tree = buildDocumentChunkTree(chunks)
+    const visible = visibleDocumentChunkNodes(tree.roots, new Set(tree.byId.keys()))
+
+    expect(tree.byId).toHaveLength(5000)
+    expect(tree.roots.map((node) => node.chunk.id)).toEqual(['chunk-0'])
+    expect(visible).toHaveLength(5000)
+    expect(visible.at(-1)).toMatchObject({ depth: 4999 })
+  })
+
+  it('flattens only expanded descendants in tree order', () => {
+    const tree = buildDocumentChunkTree([
+      chunk({ id: 'parent', ordinal: 1 }),
+      chunk({ id: 'child', ordinal: 2, parentChunkId: 'parent' }),
+      chunk({ id: 'grandchild', ordinal: 3, parentChunkId: 'child' }),
+    ])
+
+    expect(
+      visibleDocumentChunkNodes(tree.roots, new Set()).map(({ node }) => node.chunk.id),
+    ).toEqual(['parent'])
+    expect(
+      visibleDocumentChunkNodes(tree.roots, new Set(['parent', 'child'])).map(
+        ({ depth, node }) => `${depth}:${node.chunk.id}`,
+      ),
+    ).toEqual(['0:parent', '1:child', '2:grandchild'])
+  })
+
+  it('selects the active revision and falls back to the newest available revision', () => {
+    expect(initialDocumentRevision(document(), [revision(1), revision(2), revision(3)])).toBe(3)
+    expect(
+      initialDocumentRevision(document({ active: null, activeRevision: undefined }), [
+        revision(1),
+        revision(2),
+      ]),
+    ).toBe(2)
+    expect(initialDocumentRevision(document({ active: null, activeRevision: undefined }), [])).toBe(
+      undefined,
+    )
+    expect(
+      initialDocumentRevision(document({ active: null, activeRevision: undefined }), [
+        { ...revision(4), state: 'failed' },
+        { ...revision(5), state: 'candidate' },
+      ]),
+    ).toBeUndefined()
+    expect(
+      initialDocumentRevision(document({ active: null, activeRevision: undefined }), [
+        revision(2),
+        { ...revision(4), state: 'failed' },
+      ]),
+    ).toBe(2)
+  })
+
+  it('counts unicode characters and formats metadata deterministically', () => {
+    expect(chunkCharacterCount('A📙B')).toBe(3)
+    expect(chunkCharacterCount('👨‍👩‍👧‍👦')).toBe(1)
+    expect(
+      chunkMetadataEntries({
+        page: 2,
+        section: 'Security',
+        tags: ['sso', 'saml'],
+      }),
+    ).toEqual([
+      ['page', '2'],
+      ['section', 'Security'],
+      ['tags', '["sso","saml"]'],
+    ])
+  })
+
+  it('bounds tree labels to a single readable summary', () => {
+    expect(chunkTreeLabel('First line\nfull body', 3)).toBe('First line')
+    expect(chunkTreeLabel('  ', 3)).toBe('#3')
+    expect(chunkTreeLabel('x'.repeat(121), 3)).toBe(`${'x'.repeat(119)}…`)
+    expect(chunkTreeLabel(`${'x'.repeat(118)}👨‍👩‍👧‍👦yz`, 3)).toBe(`${'x'.repeat(118)}👨‍👩‍👧‍👦…`)
+  })
+
+  it('separates multiline chunk headings without duplicating standalone content', () => {
+    expect(chunkContentParts('Setup requirements\n\nWorkspace contract details')).toEqual({
+      body: 'Workspace contract details',
+      heading: 'Setup requirements',
+    })
+    expect(chunkContentParts('Standalone content')).toEqual({
+      body: '',
+      heading: 'Standalone content',
+    })
+  })
+})

web/features/new-rag/__tests__/documents-page.spec.tsx

@@ -539,6 +539,10 @@ describe('DocumentsPage', () => {
 
     const rows = screen.getAllByRole('row').slice(1)
     expect(within(rows[0]!).getByText('Ready.pdf')).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: 'Ready.pdf' })).toHaveAttribute(
+      'href',
+      '/datasets/new/space-1/documents/ready',
+    )
     expect(screen.getAllByText('Notion support SOP').length).toBeGreaterThan(0)
     expect(screen.getAllByText('v2').length).toBeGreaterThan(0)
     for (const status of ['ready', 'queued', 'processing', 'failed', 'disabled'])

web/features/new-rag/__tests__/routes.spec.ts

@@ -0,0 +1,65 @@
+import {
+  newKnowledgeAddSourcePath,
+  normalizeWebsiteSourceUrl,
+  parseNewKnowledgeSourceDraft,
+  singleSearchParam,
+} from '../routes'
+
+describe('New RAG routes', () => {
+  it('keeps source details out of the add-source URL', () => {
+    expect(newKnowledgeAddSourcePath('space-1', 'websiteCrawl', 'opaque-draft-key')).toBe(
+      '/datasets/new/space-1/sources/new?type=websiteCrawl&draft=opaque-draft-key',
+    )
+  })
+
+  it('rejects repeated search parameters instead of selecting an ambiguous value', () => {
+    expect(singleSearchParam(['websiteCrawl', 'onlineDrive'])).toBeUndefined()
+    expect(singleSearchParam('websiteCrawl')).toBe('websiteCrawl')
+  })
+
+  it('rejects credentials embedded in website URLs', () => {
+    expect(normalizeWebsiteSourceUrl('https://user:secret@docs.dify.ai')).toBeUndefined()
+    expect(normalizeWebsiteSourceUrl('https://docs.dify.ai/docs#intro')?.toString()).toBe(
+      'https://docs.dify.ai/docs',
+    )
+  })
+
+  it('rejects malformed session drafts', () => {
+    expect(parseNewKnowledgeSourceDraft('{')).toBeUndefined()
+    expect(
+      parseNewKnowledgeSourceDraft(
+        JSON.stringify({
+          includeSubpages: true,
+          maxPages: 201,
+          provider: 'Firecrawl',
+          rootUrl: 'https://docs.dify.ai',
+          sourceName: 'Dify docs',
+          sourceType: 'websiteCrawl',
+          syncPolicy: 'provider',
+        }),
+      ),
+    ).toBeUndefined()
+  })
+
+  it('migrates a valid website draft saved before source discriminators were added', () => {
+    expect(
+      parseNewKnowledgeSourceDraft(
+        JSON.stringify({
+          includeSubpages: false,
+          maxPages: 25,
+          provider: 'Firecrawl',
+          rootUrl: 'https://docs.dify.ai',
+          sourceName: 'Dify docs',
+        }),
+      ),
+    ).toEqual({
+      includeSubpages: false,
+      maxPages: 25,
+      provider: 'Firecrawl',
+      rootUrl: 'https://docs.dify.ai',
+      sourceName: 'Dify docs',
+      sourceType: 'websiteCrawl',
+      syncPolicy: 'provider',
+    })
+  })
+})

web/features/new-rag/document-chunk-detail.tsx

@@ -0,0 +1,291 @@
+import type {
+  DocumentRevisionChunk,
+  LogicalDocument,
+  LogicalDocumentRevision,
+} from '@dify/contracts/knowledge-fs/types.gen'
+import { Button } from '@langgenius/dify-ui/button'
+import { toast } from '@langgenius/dify-ui/toast'
+import copy from 'copy-to-clipboard'
+import { useEffect, useMemo } from 'react'
+import { useTranslation } from 'react-i18next'
+import {
+  chunkCharacterCount,
+  chunkContentParts,
+  chunkMetadataEntries,
+} from './document-detail-model'
+
+function formatBytes(bytes: number, locale: string) {
+  const numberFormat = new Intl.NumberFormat(locale, { maximumFractionDigits: 1 })
+  if (bytes < 1024) return `${numberFormat.format(bytes)} B`
+  const units = ['KB', 'MB', 'GB']
+  let value = bytes / 1024
+  let unit = units[0]
+  for (let index = 1; index < units.length && value >= 1024; index++) {
+    value /= 1024
+    unit = units[index]
+  }
+  return `${new Intl.NumberFormat(locale, {
+    maximumFractionDigits: value >= 10 ? 0 : 1,
+  }).format(value)} ${unit}`
+}
+
+function formatDate(value: string | undefined, locale: string) {
+  if (!value) return '—'
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return value
+  return new Intl.DateTimeFormat(locale, {
+    dateStyle: 'medium',
+    timeStyle: 'short',
+  }).format(date)
+}
+
+export function DocumentChunkDetail({
+  document,
+  chunks,
+  chunksComplete,
+  locale,
+  revision,
+  selectedChunkId,
+}: {
+  document: LogicalDocument
+  chunks: DocumentRevisionChunk[]
+  chunksComplete: boolean
+  locale: string
+  revision?: Exclude<LogicalDocumentRevision, null>
+  selectedChunkId?: string
+}) {
+  const { t } = useTranslation('dataset')
+  const { t: tCommon } = useTranslation('common')
+  const selectedChunk = useMemo(
+    () => chunks.find((chunk) => chunk.id === selectedChunkId) ?? chunks[0],
+    [chunks, selectedChunkId],
+  )
+  const characterCount = useMemo(
+    () => chunks.reduce((total, chunk) => total + chunkCharacterCount(chunk.text), 0),
+    [chunks],
+  )
+  const averageChunkLength = chunks.length ? Math.round(characterCount / chunks.length) : 0
+  const sizeBytes = revision?.sizeBytes ?? document.active?.sizeBytes
+  const sourceName =
+    typeof document.userMetadata.sourceName === 'string'
+      ? document.userMetadata.sourceName
+      : undefined
+  const retrievalCount =
+    typeof document.userMetadata.retrievalCount === 'number'
+      ? document.userMetadata.retrievalCount
+      : undefined
+
+  useEffect(() => {
+    if (!selectedChunkId) return
+    globalThis.document
+      ?.getElementById(`document-chunk-${selectedChunkId}`)
+      ?.scrollIntoView({ block: 'nearest' })
+  }, [selectedChunkId])
+
+  return (
+    <>
+      <article
+        aria-busy={!chunksComplete}
+        className="min-h-72 min-w-0 overflow-hidden bg-background-default xl:px-7"
+      >
+        {!chunksComplete && (
+          <p
+            className="border-b border-divider-subtle bg-state-accent-hover px-5 py-2 system-xs-regular text-text-accent"
+            role="status"
+          >
+            {t(($) => $['newKnowledge.documentContentIncomplete'])}
+          </p>
+        )}
+        {chunks.length ? (
+          <div
+            className="max-h-[70vh] space-y-6 overflow-auto px-2 py-1 xl:px-0"
+            data-testid="chunk-content-scroll"
+          >
+            {chunks.map((chunk) => {
+              const content = chunkContentParts(chunk.text)
+              return (
+                <section
+                  key={chunk.id}
+                  id={`document-chunk-${chunk.id}`}
+                  className="group scroll-mt-4 rounded-lg px-3 py-4 [contain-intrinsic-size:auto_160px] [content-visibility:auto] xl:px-0"
+                >
+                  <div className="flex items-start justify-between gap-2">
+                    <div className="min-w-0">
+                      <h3 className="system-sm-semibold break-words text-text-primary">
+                        {content.heading ||
+                          t(($) => $['newKnowledge.chunkHeading'], { position: chunk.ordinal })}
+                      </h3>
+                      <p className="mt-1 system-2xs-regular text-text-tertiary">
+                        {t(($) => $['newKnowledge.chunkLocation'], { position: chunk.ordinal })}
+                      </p>
+                    </div>
+                    <Button
+                      aria-label={tCommon(($) => $['operation.copy'])}
+                      className="opacity-0 transition-opacity group-focus-within:opacity-100 group-hover:opacity-100 motion-reduce:transition-none"
+                      onClick={() => {
+                        copy(chunk.text)
+                        toast.success(tCommon(($) => $['actionMsg.copySuccessfully']))
+                      }}
+                      size="small"
+                      variant="ghost"
+                    >
+                      <span aria-hidden className="i-ri-file-copy-line size-4" />
+                    </Button>
+                  </div>
+                  {content.body && (
+                    <p className="mt-3 body-md-regular break-words whitespace-pre-wrap text-text-primary">
+                      {content.body}
+                    </p>
+                  )}
+                  {!chunk.text && (
+                    <p className="mt-3 body-md-regular text-text-tertiary">
+                      {t(($) => $['newKnowledge.emptyChunk'])}
+                    </p>
+                  )}
+                </section>
+              )
+            })}
+          </div>
+        ) : (
+          <div className="flex min-h-72 items-center justify-center px-6 text-center body-sm-regular text-text-tertiary">
+            {t(($) => $['newKnowledge.selectChunk'])}
+          </div>
+        )}
+      </article>
+
+      <aside className="min-w-0 xl:pl-6">
+        <section className="rounded-xl bg-background-default-subtle p-4">
+          <h2 className="system-sm-semibold text-text-primary">
+            {t(($) => $['newKnowledge.metadata'])}
+          </h2>
+          <p className="mt-2 system-xs-regular text-text-tertiary">
+            {t(($) => $['newKnowledge.documentOverviewDescription'])}
+          </p>
+          <Button
+            className="mt-2"
+            onClick={() => toast.info(t(($) => $['newKnowledge.filtersUnavailable']))}
+            variant="primary"
+          >
+            {t(($) => $['metadata.documentMetadata.startLabeling'])}
+          </Button>
+        </section>
+        <section className="mt-6">
+          <dl className="space-y-3">
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.sourceColumn'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular break-words text-text-secondary">
+                {sourceName ??
+                  (document.sourceId
+                    ? t(($) => $['newKnowledge.sourceType.connector'])
+                    : t(($) => $['newKnowledge.manualUpload']))}
+              </dd>
+            </div>
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.fileSize'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular text-text-secondary">
+                {sizeBytes !== undefined ? formatBytes(sizeBytes, locale) : '—'}
+              </dd>
+            </div>
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.createdAt'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular text-text-secondary">
+                {formatDate(document.createdAt, locale)}
+              </dd>
+            </div>
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.lastIndexed'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular text-text-secondary">
+                {formatDate(revision?.activatedAt ?? revision?.createdAt, locale)}
+              </dd>
+            </div>
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.documentRevision'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular text-text-secondary">
+                {revision?.revision ?? document.activeRevision ?? '—'}
+              </dd>
+            </div>
+          </dl>
+        </section>
+        <section className="mt-7">
+          <h2 className="system-sm-semibold text-text-primary">
+            {t(($) => $['newKnowledge.indexInformation'])}
+          </h2>
+          <dl className="mt-3 space-y-3">
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.chunkCount'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular text-text-secondary">
+                {chunksComplete ? new Intl.NumberFormat(locale).format(chunks.length) : '—'}
+              </dd>
+            </div>
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.averageChunkLength'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular text-text-secondary">
+                {chunksComplete ? new Intl.NumberFormat(locale).format(averageChunkLength) : '—'}
+              </dd>
+            </div>
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.retrievalCount'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular text-text-secondary">
+                {retrievalCount === undefined
+                  ? '—'
+                  : new Intl.NumberFormat(locale).format(retrievalCount)}
+              </dd>
+            </div>
+            <div>
+              <dt className="system-2xs-medium text-text-tertiary">
+                {t(($) => $['newKnowledge.mimeType'])}
+              </dt>
+              <dd className="mt-1 system-xs-regular break-words text-text-secondary">
+                {revision?.mimeType ?? document.active?.mimeType ?? '—'}
+              </dd>
+            </div>
+            {selectedChunk && (
+              <>
+                <div>
+                  <dt className="system-2xs-medium text-text-tertiary">
+                    {t(($) => $['newKnowledge.tokenCount'])}
+                  </dt>
+                  <dd className="mt-1 system-xs-regular text-text-secondary">
+                    {new Intl.NumberFormat(locale).format(selectedChunk.tokenCount)}
+                  </dd>
+                </div>
+                <div>
+                  <dt className="system-2xs-medium text-text-tertiary">
+                    {t(($) => $['newKnowledge.characterCount'])}
+                  </dt>
+                  <dd className="mt-1 system-xs-regular text-text-secondary">
+                    {new Intl.NumberFormat(locale).format(chunkCharacterCount(selectedChunk.text))}
+                  </dd>
+                </div>
+                {chunkMetadataEntries(selectedChunk.userMetadata).map(([key, value]) => (
+                  <div key={key}>
+                    <dt className="system-2xs-medium break-words text-text-tertiary">{key}</dt>
+                    <dd className="mt-1 system-xs-regular break-words text-text-secondary">
+                      {value}
+                    </dd>
+                  </div>
+                ))}
+              </>
+            )}
+          </dl>
+        </section>
+      </aside>
+    </>
+  )
+}

web/features/new-rag/document-chunk-tree.tsx

@@ -0,0 +1,277 @@
+'use client'
+
+import type { DocumentChunkTree } from './document-detail-model'
+import { Button } from '@langgenius/dify-ui/button'
+import { cn } from '@langgenius/dify-ui/cn'
+import { defaultRangeExtractor, useVirtualizer } from '@tanstack/react-virtual'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import Loading from '@/app/components/base/loading'
+import { chunkTreeLabel, visibleDocumentChunkNodes } from './document-detail-model'
+
+const VIRTUALIZATION_THRESHOLD = 80
+const TREE_ROW_HEIGHT = 32
+
+export function DocumentChunkTreePanel({
+  chunkCount,
+  error,
+  fetchNextPage,
+  hasNextPage,
+  isFetchNextPageError,
+  isFetchingNextPage,
+  isPending,
+  onRetry,
+  onSelectChunk,
+  selectedChunkId,
+  tree,
+}: {
+  chunkCount: number
+  error: boolean
+  fetchNextPage: () => Promise<unknown>
+  hasNextPage: boolean
+  isFetchNextPageError: boolean
+  isFetchingNextPage: boolean
+  isPending: boolean
+  onRetry: () => void
+  onSelectChunk: (chunkId: string) => void
+  selectedChunkId?: string
+  tree: DocumentChunkTree
+}) {
+  const { t } = useTranslation('dataset')
+  const { t: tCommon } = useTranslation('common')
+  const [collapsedChunkIds, setCollapsedChunkIds] = useState<Set<string>>(() => new Set())
+  const [focusedChunkId, setFocusedChunkId] = useState<string>()
+  const [treeHasFocus, setTreeHasFocus] = useState(false)
+  const treeScrollRef = useRef<HTMLDivElement>(null)
+  const loadMoreRequestedRef = useRef(false)
+  const chunkIdsBeforeLoadRef = useRef<Set<string>>(new Set())
+  const wasFetchingNextPageRef = useRef(false)
+  const expandedChunkIds = useMemo(
+    () => new Set([...tree.byId.keys()].filter((id) => !collapsedChunkIds.has(id))),
+    [collapsedChunkIds, tree.byId],
+  )
+  const visibleNodes = useMemo(
+    () => visibleDocumentChunkNodes(tree.roots, expandedChunkIds),
+    [expandedChunkIds, tree.roots],
+  )
+  const shouldVirtualize = visibleNodes.length > VIRTUALIZATION_THRESHOLD
+  const currentFocusedChunkId = focusedChunkId ?? visibleNodes[0]?.node.chunk.id
+  const focusedIndex = visibleNodes.findIndex(
+    (item) => item.node.chunk.id === currentFocusedChunkId,
+  )
+  const rowVirtualizer = useVirtualizer({
+    count: shouldVirtualize ? visibleNodes.length : 0,
+    estimateSize: () => TREE_ROW_HEIGHT,
+    getItemKey: (index) => visibleNodes[index]?.node.chunk.id ?? index,
+    getScrollElement: () => treeScrollRef.current,
+    overscan: 8,
+    rangeExtractor: (range) => {
+      const indexes = defaultRangeExtractor(range)
+      if (focusedIndex >= 0 && !indexes.includes(focusedIndex)) indexes.push(focusedIndex)
+      return indexes.sort((left, right) => left - right)
+    },
+  })
+  const rowVirtualizerRef = useRef(rowVirtualizer)
+  rowVirtualizerRef.current = rowVirtualizer
+  const virtualRows = rowVirtualizer.getVirtualItems()
+
+  const toggleExpanded = (chunkId: string) => {
+    setCollapsedChunkIds((current) => {
+      const next = new Set(current)
+      if (next.has(chunkId)) next.delete(chunkId)
+      else next.add(chunkId)
+      return next
+    })
+  }
+
+  const focusChunk = (chunkId: string) => {
+    const index = visibleNodes.findIndex((item) => item.node.chunk.id === chunkId)
+    if (index < 0) return
+    setFocusedChunkId(chunkId)
+    if (shouldVirtualize) rowVirtualizer.scrollToIndex(index, { align: 'auto' })
+    treeScrollRef.current?.focus()
+  }
+
+  const handleTreeKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
+    const chunkId = currentFocusedChunkId
+    if (!chunkId) return
+    const index = visibleNodes.findIndex((item) => item.node.chunk.id === chunkId)
+    const current = visibleNodes[index]
+    if (!current) return
+    const parentId = current.node.chunk.parentChunkId
+    let nextId: string | undefined
+    if (event.key === 'ArrowDown') nextId = visibleNodes[index + 1]?.node.chunk.id
+    else if (event.key === 'ArrowUp') nextId = visibleNodes[index - 1]?.node.chunk.id
+    else if (event.key === 'Home') nextId = visibleNodes[0]?.node.chunk.id
+    else if (event.key === 'End') nextId = visibleNodes.at(-1)?.node.chunk.id
+    else if (event.key === 'ArrowRight' && current.node.children.length) {
+      if (collapsedChunkIds.has(chunkId)) toggleExpanded(chunkId)
+      else nextId = current.node.children[0]?.chunk.id
+    } else if (event.key === 'ArrowLeft') {
+      if (current.node.children.length && !collapsedChunkIds.has(chunkId)) toggleExpanded(chunkId)
+      else if (parentId && tree.byId.has(parentId)) nextId = parentId
+    } else if (event.key === 'Enter' || event.key === ' ') onSelectChunk(chunkId)
+    else return
+    event.preventDefault()
+    if (nextId) focusChunk(nextId)
+  }
+
+  const handleLoadMore = () => {
+    if (isFetchingNextPage) return
+    chunkIdsBeforeLoadRef.current = new Set(tree.byId.keys())
+    loadMoreRequestedRef.current = true
+    void fetchNextPage()
+  }
+
+  useEffect(() => {
+    if (isFetchingNextPage) wasFetchingNextPageRef.current = true
+    if (isFetchingNextPage || !wasFetchingNextPageRef.current || !loadMoreRequestedRef.current)
+      return
+    wasFetchingNextPageRef.current = false
+    loadMoreRequestedRef.current = false
+    if (isFetchNextPageError) return
+    const firstNewNode = visibleNodes.find(
+      (item) => !chunkIdsBeforeLoadRef.current.has(item.node.chunk.id),
+    )
+    requestAnimationFrame(() => {
+      if (!firstNewNode) {
+        treeScrollRef.current?.focus()
+        return
+      }
+      const chunkId = firstNewNode.node.chunk.id
+      const index = visibleNodes.findIndex((item) => item.node.chunk.id === chunkId)
+      setFocusedChunkId(chunkId)
+      if (shouldVirtualize) rowVirtualizerRef.current.scrollToIndex(index, { align: 'auto' })
+      treeScrollRef.current?.focus()
+    })
+  }, [isFetchNextPageError, isFetchingNextPage, shouldVirtualize, visibleNodes])
+
+  const renderTreeItem = (item: (typeof visibleNodes)[number], style?: React.CSSProperties) => {
+    const { depth, node, positionInSet, setSize } = item
+    const { chunk } = node
+    const hasChildren = node.children.length > 0
+    const expanded = !collapsedChunkIds.has(chunk.id)
+    const label = chunkTreeLabel(chunk.text, chunk.ordinal)
+    return (
+      <button
+        key={chunk.id}
+        id={`document-chunk-treeitem-${chunk.id}`}
+        aria-expanded={hasChildren ? expanded : undefined}
+        aria-label={label}
+        aria-level={depth + 1}
+        aria-posinset={positionInSet}
+        aria-selected={selectedChunkId === chunk.id}
+        aria-setsize={hasNextPage ? -1 : setSize}
+        className={cn(
+          'flex h-8 w-full items-center gap-1.5 rounded-lg pr-2 text-left system-xs-regular outline-hidden hover:bg-state-base-hover focus-visible:ring-2 focus-visible:ring-state-accent-solid focus-visible:ring-inset',
+          selectedChunkId === chunk.id && 'bg-state-accent-hover text-text-accent',
+          treeHasFocus &&
+            currentFocusedChunkId === chunk.id &&
+            'bg-state-base-hover ring-1 ring-state-accent-solid ring-inset',
+        )}
+        role="treeitem"
+        style={{ ...style, paddingInlineStart: `${8 + depth * 16}px` }}
+        tabIndex={-1}
+        onClick={() => {
+          setFocusedChunkId(chunk.id)
+          treeScrollRef.current?.focus()
+          onSelectChunk(chunk.id)
+          if (hasChildren) toggleExpanded(chunk.id)
+        }}
+      >
+        <span
+          aria-hidden
+          className={cn(
+            'mt-0.5 size-4 shrink-0 rtl:-scale-x-100',
+            hasChildren ? (expanded ? 'i-ri-arrow-down-s-line' : 'i-ri-arrow-right-s-line') : '',
+          )}
+        />
+        <span className="min-w-0 truncate">{label}</span>
+      </button>
+    )
+  }
+
+  return (
+    <aside className="min-h-52 overflow-hidden">
+      <h2 className="px-2 pb-2 system-xs-regular text-text-tertiary">
+        {t(($) => $['newKnowledge.documentContents'])}
+      </h2>
+      {error && !isFetchNextPageError && chunkCount > 0 && (
+        <div
+          className="flex items-center justify-between gap-2 border-b border-divider-subtle bg-state-warning-hover px-3 py-2 system-xs-regular text-text-warning"
+          role="alert"
+        >
+          <span>{t(($) => $['newKnowledge.documentChunksLoadError'])}</span>
+          <Button onClick={onRetry}>{tCommon(($) => $['operation.retry'])}</Button>
+        </div>
+      )}
+      {isPending ? (
+        <div className="flex min-h-40 items-center justify-center" role="status">
+          <Loading />
+          <span className="sr-only">{tCommon(($) => $.loading)}</span>
+        </div>
+      ) : error && !isFetchNextPageError && !chunkCount ? (
+        <div className="p-4 text-center">
+          <p className="system-xs-regular text-text-destructive">
+            {t(($) => $['newKnowledge.documentChunksLoadError'])}
+          </p>
+          <Button className="mt-3" onClick={onRetry}>
+            {tCommon(($) => $['operation.retry'])}
+          </Button>
+        </div>
+      ) : !chunkCount ? (
+        <p className="p-6 text-center system-xs-regular text-text-tertiary">
+          {t(($) => $['newKnowledge.documentChunksEmpty'])}
+        </p>
+      ) : (
+        <div
+          ref={treeScrollRef}
+          aria-activedescendant={
+            currentFocusedChunkId ? `document-chunk-treeitem-${currentFocusedChunkId}` : undefined
+          }
+          aria-label={t(($) => $['newKnowledge.documentContents'])}
+          className="max-h-[70vh] overflow-auto py-1 pr-4 pl-1 outline-hidden"
+          role="tree"
+          tabIndex={0}
+          onBlur={() => setTreeHasFocus(false)}
+          onFocus={() => setTreeHasFocus(true)}
+          onKeyDown={handleTreeKeyDown}
+        >
+          {shouldVirtualize ? (
+            <div className="relative" style={{ height: `${rowVirtualizer.getTotalSize()}px` }}>
+              {virtualRows.map((virtualRow) =>
+                renderTreeItem(visibleNodes[virtualRow.index]!, {
+                  height: `${virtualRow.size}px`,
+                  left: 0,
+                  position: 'absolute',
+                  top: 0,
+                  transform: `translateY(${virtualRow.start}px)`,
+                }),
+              )}
+            </div>
+          ) : (
+            visibleNodes.map((item) => renderTreeItem(item))
+          )}
+        </div>
+      )}
+      {(hasNextPage || isFetchNextPageError) && (
+        <div className="border-t border-divider-subtle p-3 text-center">
+          {isFetchNextPageError && (
+            <p className="mb-2 system-xs-regular text-text-destructive" role="alert">
+              {t(($) => $['newKnowledge.documentChunksLoadMoreError'])}
+            </p>
+          )}
+          <Button
+            disabled={isFetchingNextPage}
+            loading={isFetchingNextPage}
+            onClick={handleLoadMore}
+          >
+            {isFetchNextPageError
+              ? tCommon(($) => $['operation.retry'])
+              : t(($) => $['newKnowledge.loadMore'])}
+          </Button>
+        </div>
+      )}
+    </aside>
+  )
+}

web/features/new-rag/document-detail-header.tsx

@@ -0,0 +1,148 @@
+import type {
+  LogicalDocument,
+  LogicalDocumentRevision,
+} from '@dify/contracts/knowledge-fs/types.gen'
+import type { RefObject } from 'react'
+import { Button } from '@langgenius/dify-ui/button'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectItemIndicator,
+  SelectItemText,
+  SelectLabel,
+  SelectTrigger,
+} from '@langgenius/dify-ui/select'
+import { useEffect, useRef } from 'react'
+import { useTranslation } from 'react-i18next'
+import Link from '@/next/link'
+
+export function DocumentDetailHeader({
+  backPath,
+  document,
+  effectiveRevision,
+  fetchNextRevisionPage,
+  hasNextRevisionPage,
+  isFetchNextRevisionPageError,
+  isFetchingNextRevisionPage,
+  onReindex,
+  onRevisionChange,
+  reindexDisabled,
+  reindexDisabledReasonId,
+  reindexing,
+  revisions,
+  taskIsActive,
+  titleRef,
+}: {
+  backPath: string
+  document: LogicalDocument
+  effectiveRevision?: number
+  fetchNextRevisionPage: () => void
+  hasNextRevisionPage: boolean
+  isFetchNextRevisionPageError: boolean
+  isFetchingNextRevisionPage: boolean
+  onReindex: () => void
+  onRevisionChange: (revision: number) => void
+  reindexDisabled: boolean
+  reindexDisabledReasonId?: string
+  reindexing: boolean
+  revisions: Array<Exclude<LogicalDocumentRevision, null>>
+  taskIsActive: boolean
+  titleRef: RefObject<HTMLHeadingElement | null>
+}) {
+  const { t } = useTranslation('dataset')
+  const { t: tCommon } = useTranslation('common')
+  const revisionTriggerRef = useRef<HTMLButtonElement>(null)
+  const loadMoreRequestedRef = useRef(false)
+  const wasFetchingNextPageRef = useRef(false)
+  useEffect(() => {
+    if (isFetchingNextRevisionPage) wasFetchingNextPageRef.current = true
+    if (
+      isFetchingNextRevisionPage ||
+      !wasFetchingNextPageRef.current ||
+      !loadMoreRequestedRef.current
+    )
+      return
+    wasFetchingNextPageRef.current = false
+    loadMoreRequestedRef.current = false
+    if (!isFetchNextRevisionPageError && !hasNextRevisionPage) revisionTriggerRef.current?.focus()
+  }, [hasNextRevisionPage, isFetchNextRevisionPageError, isFetchingNextRevisionPage])
+
+  return (
+    <>
+      <Link
+        className="inline-flex w-fit items-center gap-1 system-xs-medium text-text-tertiary hover:text-text-secondary focus-visible:rounded focus-visible:ring-2 focus-visible:ring-state-accent-solid focus-visible:outline-hidden"
+        href={backPath}
+      >
+        <span aria-hidden className="i-ri-arrow-left-line size-4" />
+        {t(($) => $['newKnowledge.documents'])}
+      </Link>
+      <div className="mt-7 flex flex-wrap items-start justify-between gap-3">
+        <div className="min-w-0">
+          <h1
+            ref={titleRef}
+            className="truncate title-2xl-semi-bold text-text-primary outline-hidden focus-visible:ring-2 focus-visible:ring-state-accent-solid"
+            tabIndex={-1}
+          >
+            {document.title}
+          </h1>
+        </div>
+        <div className="flex flex-wrap items-center gap-2">
+          {revisions.length > 0 && effectiveRevision !== undefined && (
+            <Select
+              value={String(effectiveRevision)}
+              onValueChange={(value) => {
+                if (value) onRevisionChange(Number(value))
+              }}
+            >
+              <SelectLabel>{t(($) => $['newKnowledge.documentRevision'])}</SelectLabel>
+              <SelectTrigger ref={revisionTriggerRef} className="h-8 w-fit min-w-28">
+                v{effectiveRevision}
+              </SelectTrigger>
+              <SelectContent>
+                {revisions.map((revision) => (
+                  <SelectItem key={revision.revision} value={String(revision.revision)}>
+                    <SelectItemText>
+                      v{revision.revision} ·{' '}
+                      {t(($) => $[`newKnowledge.revisionState.${revision.state}`])}
+                    </SelectItemText>
+                    <SelectItemIndicator />
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          )}
+          {(hasNextRevisionPage || isFetchNextRevisionPageError) && (
+            <Button
+              disabled={isFetchingNextRevisionPage}
+              loading={isFetchingNextRevisionPage}
+              onClick={() => {
+                loadMoreRequestedRef.current = true
+                fetchNextRevisionPage()
+              }}
+            >
+              {isFetchNextRevisionPageError
+                ? tCommon(($) => $['operation.retry'])
+                : t(($) => $['newKnowledge.loadMoreRevisions'])}
+            </Button>
+          )}
+          <Button
+            aria-busy={reindexing || taskIsActive}
+            aria-describedby={reindexDisabledReasonId}
+            disabled={reindexDisabled}
+            loading={reindexing}
+            onClick={onReindex}
+          >
+            <span aria-hidden className="i-ri-refresh-line size-4" />
+            {t(($) => $['newKnowledge.reindexDocument'])}
+          </Button>
+        </div>
+      </div>
+      {isFetchNextRevisionPageError && (
+        <p className="mt-2 system-xs-regular text-text-destructive" role="alert">
+          {t(($) => $['newKnowledge.documentRevisionsLoadError'])}
+        </p>
+      )}
+    </>
+  )
+}

web/features/new-rag/document-detail-model.ts

@@ -0,0 +1,178 @@
+import type {
+  DocumentRevisionChunk,
+  LogicalDocument,
+  LogicalDocumentRevision,
+} from '@dify/contracts/knowledge-fs/types.gen'
+
+export type DocumentChunkTreeNode = {
+  children: DocumentChunkTreeNode[]
+  chunk: DocumentRevisionChunk
+}
+
+export type DocumentChunkTree = {
+  byId: Map<string, DocumentChunkTreeNode>
+  roots: DocumentChunkTreeNode[]
+}
+
+export function responseStatus(error: unknown): number | undefined {
+  if (error instanceof Response) return error.status
+  if (error && typeof error === 'object' && 'status' in error)
+    return typeof error.status === 'number' ? error.status : undefined
+  if (error && typeof error === 'object' && 'data' in error) {
+    const data = error.data
+    if (data && typeof data === 'object' && 'status' in data)
+      return typeof data.status === 'number' ? data.status : undefined
+  }
+}
+
+function compareChunks(left: DocumentRevisionChunk, right: DocumentRevisionChunk) {
+  return left.ordinal - right.ordinal || left.id.localeCompare(right.id)
+}
+
+function cyclicChunkIds(chunksById: Map<string, DocumentRevisionChunk>) {
+  const cycleIds = new Set<string>()
+  const settledIds = new Set<string>()
+
+  for (const chunkId of chunksById.keys()) {
+    if (settledIds.has(chunkId)) continue
+    const path: string[] = []
+    const pathIndexes = new Map<string, number>()
+    let candidateId: string | undefined = chunkId
+    while (candidateId && chunksById.has(candidateId) && !settledIds.has(candidateId)) {
+      const cycleStart = pathIndexes.get(candidateId)
+      if (cycleStart !== undefined) {
+        for (const cycleId of path.slice(cycleStart)) cycleIds.add(cycleId)
+        break
+      }
+      pathIndexes.set(candidateId, path.length)
+      path.push(candidateId)
+      candidateId = chunksById.get(candidateId)?.parentChunkId
+    }
+    for (const pathId of path) settledIds.add(pathId)
+  }
+
+  return cycleIds
+}
+
+export function buildDocumentChunkTree(chunks: DocumentRevisionChunk[]): DocumentChunkTree {
+  const sortedChunks = [...chunks].sort(compareChunks)
+  const chunksById = new Map(sortedChunks.map((chunk) => [chunk.id, chunk]))
+  const cycleIds = cyclicChunkIds(chunksById)
+  const byId = new Map<string, DocumentChunkTreeNode>(
+    sortedChunks.map((chunk) => [
+      chunk.id,
+      { children: [], chunk } satisfies DocumentChunkTreeNode,
+    ]),
+  )
+  const roots: DocumentChunkTreeNode[] = []
+
+  for (const chunk of sortedChunks) {
+    const node = byId.get(chunk.id)!
+    const parentId = chunk.parentChunkId
+    const parent = parentId ? byId.get(parentId) : undefined
+    if (!parent || !parentId || cycleIds.has(chunk.id)) roots.push(node)
+    else parent.children.push(node)
+  }
+
+  for (const node of byId.values())
+    node.children.sort((left, right) => compareChunks(left.chunk, right.chunk))
+  roots.sort((left, right) => compareChunks(left.chunk, right.chunk))
+  return { byId, roots }
+}
+
+export function visibleDocumentChunkNodes(
+  roots: DocumentChunkTreeNode[],
+  expandedChunkIds: Set<string>,
+) {
+  const visible: Array<{
+    depth: number
+    node: DocumentChunkTreeNode
+    positionInSet: number
+    setSize: number
+  }> = []
+  const pending = roots
+    .map((node, index) => ({
+      depth: 0,
+      node,
+      positionInSet: index + 1,
+      setSize: roots.length,
+    }))
+    .reverse()
+  while (pending.length) {
+    const item = pending.pop()!
+    const { depth, node } = item
+    visible.push(item)
+    if (!expandedChunkIds.has(node.chunk.id)) continue
+    for (let index = node.children.length - 1; index >= 0; index--)
+      pending.push({
+        depth: depth + 1,
+        node: node.children[index]!,
+        positionInSet: index + 1,
+        setSize: node.children.length,
+      })
+  }
+  return visible
+}
+
+export function initialDocumentRevision(
+  document: LogicalDocument,
+  revisions: LogicalDocumentRevision[],
+) {
+  const activeRevision = document.activeRevision ?? document.active?.revision
+  if (activeRevision !== undefined) return activeRevision
+  return revisions
+    .filter((revision) => revision?.state === 'active' || revision?.state === 'superseded')
+    .reduce<number | undefined>(
+      (latest, revision) =>
+        revision && (latest === undefined || revision.revision > latest)
+          ? revision.revision
+          : latest,
+      undefined,
+    )
+}
+
+export function chunkTreeLabel(text: string, ordinal: number) {
+  const firstLine = text.split(/\r?\n/, 1)[0]?.trim()
+  if (!firstLine) return `#${ordinal}`
+  const graphemes: string[] = []
+  for (const { segment } of new Intl.Segmenter(undefined, {
+    granularity: 'grapheme',
+  }).segment(firstLine)) {
+    graphemes.push(segment)
+    if (graphemes.length > 120) break
+  }
+  return graphemes.length > 120 ? `${graphemes.slice(0, 119).join('')}…` : firstLine
+}
+
+export function chunkContentParts(text: string) {
+  const lineBreak = text.search(/\r?\n/)
+  if (lineBreak < 0) return { body: '', heading: text }
+  return {
+    body: text.slice(lineBreak).trimStart(),
+    heading: text.slice(0, lineBreak).trim(),
+  }
+}
+
+export function chunkCharacterCount(text: string) {
+  let count = 0
+  for (const _segment of new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(text))
+    count++
+  return count
+}
+
+function metadataValue(value: unknown) {
+  if (typeof value === 'string') return value
+  if (typeof value === 'number' || typeof value === 'boolean' || value === null)
+    return String(value)
+  try {
+    return JSON.stringify(value) ?? ''
+  } catch {
+    return String(value)
+  }
+}
+
+export function chunkMetadataEntries(metadata: Record<string, unknown>) {
+  return Object.entries(metadata)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => [key, metadataValue(value)] as const)
+}

web/features/new-rag/document-detail-page.tsx

@@ -0,0 +1,256 @@
+'use client'
+
+import { Button } from '@langgenius/dify-ui/button'
+import { useInfiniteQuery, useQuery } from '@tanstack/react-query'
+import { useAtomValue } from 'jotai'
+import { createParser, useQueryState } from 'nuqs'
+import { useMemo, useRef } from 'react'
+import { useTranslation } from 'react-i18next'
+import Loading from '@/app/components/base/loading'
+import { datasetDefaultPermissionKeysAtom } from '@/context/permission-state'
+import { consoleQuery } from '@/service/client'
+import { DatasetACLPermission, hasPermission } from '@/utils/permission'
+import { DocumentDetailHeader } from './document-detail-header'
+import { initialDocumentRevision, responseStatus } from './document-detail-model'
+import { DocumentDetailStatus } from './document-detail-status'
+import { DocumentRevisionContent } from './document-revision-content'
+import { newKnowledgeDocumentsPath } from './routes'
+import { useDocumentReindex } from './use-document-reindex'
+
+const REVISION_PAGE_SIZE = 50
+const REINDEX_RESTRICTION_ID = 'document-reindex-restriction'
+const documentRevisionParser = createParser<number>({
+  parse: (value) => {
+    const revision = Number(value)
+    return Number.isInteger(revision) && revision > 0 ? revision : null
+  },
+  serialize: String,
+}).withOptions({ history: 'push' })
+
+function ErrorState({
+  description,
+  onRetry,
+  title,
+}: {
+  description: string
+  onRetry?: () => void
+  title: string
+}) {
+  const { t: tCommon } = useTranslation('common')
+  return (
+    <div className="flex min-h-80 flex-col items-center justify-center px-6 text-center">
+      <span aria-hidden className="i-ri-error-warning-line size-8 text-text-destructive" />
+      <h1 className="mt-3 title-2xl-semi-bold text-text-primary">{title}</h1>
+      <p className="mt-2 max-w-lg body-sm-regular text-text-tertiary">{description}</p>
+      {onRetry && (
+        <Button className="mt-4" onClick={onRetry}>
+          {tCommon(($) => $['operation.retry'])}
+        </Button>
+      )}
+    </div>
+  )
+}
+
+export function DocumentDetailPage({
+  documentId,
+  knowledgeSpaceId,
+}: {
+  documentId: string
+  knowledgeSpaceId: string
+}) {
+  const { i18n, t } = useTranslation('dataset')
+  const { t: tCommon } = useTranslation('common')
+  const permissionKeys = useAtomValue(datasetDefaultPermissionKeysAtom)
+  const [selectedRevision, setSelectedRevision] = useQueryState('revision', documentRevisionParser)
+  const titleRef = useRef<HTMLHeadingElement>(null)
+
+  const documentQueryOptions = useMemo(
+    () =>
+      consoleQuery.knowledgeFs.getKnowledgeSpacesByIdLogicalDocumentsByDocumentId.queryOptions({
+        input: { params: { documentId, id: knowledgeSpaceId } },
+        retry: (failureCount, error) => {
+          const status = responseStatus(error)
+          return status !== 403 && status !== 404 && failureCount < 2
+        },
+      }),
+    [documentId, knowledgeSpaceId],
+  )
+  const documentQuery = useQuery(documentQueryOptions)
+  const revisionsQueryOptions = useMemo(
+    () =>
+      consoleQuery.knowledgeFs.getKnowledgeSpacesByIdDocumentsByDocumentIdRevisions.infiniteOptions(
+        {
+          input: (pageParam) => ({
+            params: { documentId, id: knowledgeSpaceId },
+            query: {
+              limit: REVISION_PAGE_SIZE,
+              ...(typeof pageParam === 'string' ? { cursor: pageParam } : {}),
+            },
+          }),
+          getNextPageParam: (lastPage) => lastPage.nextCursor,
+          initialPageParam: null as string | null,
+        },
+      ),
+    [documentId, knowledgeSpaceId],
+  )
+  const revisionsQuery = useInfiniteQuery(revisionsQueryOptions)
+  const revisions = useMemo(
+    () => revisionsQuery.data?.pages.flatMap((page) => page.items).filter(Boolean) ?? [],
+    [revisionsQuery.data],
+  )
+  const availableRevisions = useMemo(() => {
+    const byRevision = new Map(revisions.map((revision) => [revision.revision, revision]))
+    if (documentQuery.data?.active)
+      byRevision.set(documentQuery.data.active.revision, documentQuery.data.active)
+    return [...byRevision.values()].sort((left, right) => right.revision - left.revision)
+  }, [documentQuery.data?.active, revisions])
+  const effectiveRevision = documentQuery.data
+    ? (selectedRevision ?? initialDocumentRevision(documentQuery.data, availableRevisions))
+    : undefined
+  const chunksQueryKey =
+    consoleQuery.knowledgeFs.getKnowledgeSpacesByIdDocumentsByDocumentIdRevisionsByRevisionChunks.key()
+  const documentActiveRevision =
+    documentQuery.data?.activeRevision ?? documentQuery.data?.active?.revision ?? 0
+  const documentErrorStatus = responseStatus(documentQuery.error)
+  const {
+    continueLookup,
+    documentMissing,
+    isFetchingNextPage: isFetchingNextTaskPage,
+    isLookingUp: isLookingUpTask,
+    isPending: tasksPending,
+    latestTask,
+    lookupExhausted,
+    permissionRecoveryBusy,
+    permissionRecoveryNeeded,
+    refetch: refetchTasks,
+    recheckTimedOutSubmission,
+    reindex,
+    reindexBusy,
+    retryTimedOutSubmission,
+    retryWritePermission,
+    submissionPending,
+    submissionRecoveryBusy,
+    submissionTimedOut,
+    taskIsActive,
+    tasksError,
+    writePermissionRevoked,
+  } = useDocumentReindex({
+    documentActiveRevision,
+    chunksQueryKey,
+    documentId,
+    documentQueryKey: documentQueryOptions.queryKey,
+    enabled:
+      Boolean(documentQuery.data) && documentErrorStatus !== 403 && documentErrorStatus !== 404,
+    knowledgeSpaceId,
+    revisionsQueryKey: revisionsQueryOptions.queryKey,
+  })
+  const hasEditPermission = hasPermission(permissionKeys, DatasetACLPermission.Edit)
+  const canEdit = hasEditPermission && !writePermissionRevoked
+  const activeRevision = availableRevisions.find(
+    (revision) => revision.revision === effectiveRevision,
+  )
+  const backPath = newKnowledgeDocumentsPath(knowledgeSpaceId)
+  const locale = i18n.resolvedLanguage ?? i18n.language
+
+  if (documentQuery.isPending)
+    return (
+      <div className="flex min-h-80 items-center justify-center">
+        <Loading />
+        <span className="sr-only">{tCommon(($) => $.loading)}</span>
+      </div>
+    )
+
+  if (documentMissing || documentErrorStatus === 403 || documentErrorStatus === 404)
+    return (
+      <ErrorState
+        description={t(($) => $['newKnowledge.documentNotFoundDescription'])}
+        title={t(($) => $['newKnowledge.documentNotFoundTitle'])}
+      />
+    )
+
+  if (!documentQuery.data) {
+    return (
+      <ErrorState
+        description={t(($) => $['newKnowledge.documentLoadErrorDescription'])}
+        onRetry={() => void documentQuery.refetch()}
+        title={t(($) => $['newKnowledge.documentLoadErrorTitle'])}
+      />
+    )
+  }
+
+  const document = documentQuery.data
+  return (
+    <section className="flex min-h-0 flex-1 flex-col px-6 py-5 lg:px-8">
+      <DocumentDetailHeader
+        backPath={backPath}
+        document={document}
+        effectiveRevision={effectiveRevision}
+        fetchNextRevisionPage={() => void revisionsQuery.fetchNextPage()}
+        hasNextRevisionPage={revisionsQuery.hasNextPage}
+        isFetchNextRevisionPageError={revisionsQuery.isFetchNextPageError}
+        isFetchingNextRevisionPage={revisionsQuery.isFetchingNextPage}
+        onReindex={() => void reindex()}
+        onRevisionChange={(revision) => void setSelectedRevision(revision)}
+        reindexDisabled={
+          !canEdit ||
+          reindexBusy ||
+          submissionPending ||
+          taskIsActive ||
+          tasksPending ||
+          isFetchingNextTaskPage ||
+          isLookingUpTask ||
+          lookupExhausted ||
+          document.status === 'deleting' ||
+          Boolean(tasksError)
+        }
+        reindexDisabledReasonId={!hasEditPermission ? REINDEX_RESTRICTION_ID : undefined}
+        reindexing={reindexBusy || submissionPending}
+        revisions={availableRevisions}
+        taskIsActive={taskIsActive}
+        titleRef={titleRef}
+      />
+      {!hasEditPermission && (
+        <p id={REINDEX_RESTRICTION_ID} className="mt-2 system-xs-regular text-text-warning">
+          {t(($) => $['newKnowledge.documentPermissionRestricted'])}
+        </p>
+      )}
+
+      <DocumentDetailStatus
+        continueLookup={continueLookup}
+        effectiveRevision={effectiveRevision}
+        isLookingUpTask={isLookingUpTask}
+        latestTask={latestTask}
+        locale={locale}
+        lookupExhausted={lookupExhausted}
+        permissionRecoveryBusy={permissionRecoveryBusy}
+        permissionRecoveryNeeded={permissionRecoveryNeeded}
+        recheckTimedOutSubmission={recheckTimedOutSubmission}
+        refetchRevisions={() => void revisionsQuery.refetch()}
+        refetchTasks={() => void refetchTasks()}
+        retryTimedOutSubmission={retryTimedOutSubmission}
+        retryWritePermission={retryWritePermission}
+        revisionHistoryBackgroundError={Boolean(
+          revisionsQuery.error && !revisionsQuery.isFetchNextPageError,
+        )}
+        submissionRecoveryBusy={submissionRecoveryBusy}
+        submissionTimedOut={submissionTimedOut}
+        taskIsActive={taskIsActive}
+        tasksError={Boolean(tasksError)}
+        titleRef={titleRef}
+      />
+
+      <DocumentRevisionContent
+        key={effectiveRevision ?? 'missing'}
+        document={document}
+        documentId={documentId}
+        effectiveRevision={effectiveRevision}
+        knowledgeSpaceId={knowledgeSpaceId}
+        locale={locale}
+        revision={activeRevision}
+        revisionHistoryError={Boolean(revisionsQuery.error)}
+        revisionHistoryPending={revisionsQuery.isPending}
+        retryRevisionHistory={() => void revisionsQuery.refetch()}
+      />
+    </section>
+  )
+}

web/features/new-rag/document-detail-queries.ts

@@ -0,0 +1,28 @@
+import { consoleQuery } from '@/service/client'
+
+const CHUNK_PAGE_SIZE = 100
+
+export function documentChunksQueryOptions({
+  documentId,
+  effectiveRevision,
+  knowledgeSpaceId,
+}: {
+  documentId: string
+  effectiveRevision: number
+  knowledgeSpaceId: string
+}) {
+  const chunksQuery =
+    consoleQuery.knowledgeFs.getKnowledgeSpacesByIdDocumentsByDocumentIdRevisionsByRevisionChunks
+
+  return chunksQuery.infiniteOptions({
+    input: (pageParam) => ({
+      params: { documentId, id: knowledgeSpaceId, revision: effectiveRevision },
+      query: {
+        limit: CHUNK_PAGE_SIZE,
+        ...(typeof pageParam === 'string' ? { cursor: pageParam } : {}),
+      },
+    }),
+    getNextPageParam: (lastPage) => lastPage.nextCursor,
+    initialPageParam: null as string | null,
+  })
+}

web/features/new-rag/document-detail-status.tsx

@@ -0,0 +1,187 @@
+import type { DocumentProcessingTask } from '@dify/contracts/knowledge-fs/types.gen'
+import type { RefObject } from 'react'
+import { Button } from '@langgenius/dify-ui/button'
+import { useEffect, useRef } from 'react'
+import { useTranslation } from 'react-i18next'
+
+export function DocumentDetailStatus({
+  continueLookup,
+  effectiveRevision,
+  isLookingUpTask,
+  latestTask,
+  locale,
+  lookupExhausted,
+  permissionRecoveryBusy,
+  permissionRecoveryNeeded,
+  recheckTimedOutSubmission,
+  refetchRevisions,
+  refetchTasks,
+  retryTimedOutSubmission,
+  retryWritePermission,
+  revisionHistoryBackgroundError,
+  submissionRecoveryBusy,
+  submissionTimedOut,
+  taskIsActive,
+  tasksError,
+  titleRef,
+}: {
+  continueLookup: () => void
+  effectiveRevision?: number
+  isLookingUpTask: boolean
+  latestTask?: DocumentProcessingTask
+  locale: string
+  lookupExhausted: boolean
+  permissionRecoveryBusy: boolean
+  permissionRecoveryNeeded: boolean
+  recheckTimedOutSubmission: () => Promise<unknown>
+  refetchRevisions: () => void
+  refetchTasks: () => void
+  retryTimedOutSubmission: () => Promise<unknown>
+  retryWritePermission: () => Promise<boolean>
+  revisionHistoryBackgroundError: boolean
+  submissionRecoveryBusy: boolean
+  submissionTimedOut: boolean
+  taskIsActive: boolean
+  tasksError: boolean
+  titleRef: RefObject<HTMLHeadingElement | null>
+}) {
+  const { t } = useTranslation('dataset')
+  const { t: tCommon } = useTranslation('common')
+  const permissionRetryRef = useRef<HTMLButtonElement>(null)
+  const permissionRecoveryWasNeededRef = useRef(false)
+
+  useEffect(() => {
+    if (permissionRecoveryNeeded && !permissionRecoveryWasNeededRef.current)
+      requestAnimationFrame(() => permissionRetryRef.current?.focus())
+    permissionRecoveryWasNeededRef.current = permissionRecoveryNeeded
+  }, [permissionRecoveryNeeded])
+
+  return (
+    <>
+      {taskIsActive && (
+        <div
+          className="mt-4 flex items-center gap-2 rounded-lg bg-state-accent-hover px-3 py-2 system-xs-regular text-text-accent"
+          role="status"
+        >
+          <span
+            aria-hidden
+            className="i-ri-loader-2-line size-4 animate-spin motion-reduce:animate-none"
+          />
+          {t(($) => $['newKnowledge.documentReindexProgress'], {
+            progress: new Intl.NumberFormat(locale).format(latestTask?.progressPercent ?? 0),
+          })}
+        </div>
+      )}
+      {latestTask?.state === 'failed' && (
+        <div
+          className="mt-4 rounded-lg bg-state-destructive-hover px-3 py-2 system-xs-regular text-text-destructive"
+          role="alert"
+        >
+          <p>{t(($) => $['newKnowledge.documentReindexFailed'])}</p>
+          <p className="mt-1 text-text-secondary">
+            {t(($) => $['newKnowledge.lastReadyRevisionHint'])}
+          </p>
+        </div>
+      )}
+
+      {tasksError && (
+        <div
+          className="mt-4 flex flex-wrap items-center justify-between gap-2 rounded-lg bg-state-warning-hover px-3 py-2 system-xs-regular text-text-warning"
+          role="alert"
+        >
+          <span>{t(($) => $['newKnowledge.tasksErrorDescription'])}</span>
+          <Button onClick={refetchTasks}>{tCommon(($) => $['operation.retry'])}</Button>
+        </div>
+      )}
+
+      {permissionRecoveryNeeded && (
+        <div
+          className="mt-4 flex flex-wrap items-center justify-between gap-2 rounded-lg bg-state-warning-hover px-3 py-2 system-xs-regular text-text-warning"
+          role="alert"
+        >
+          <span>{t(($) => $['newKnowledge.documentPermissionRestricted'])}</span>
+          <Button
+            ref={permissionRetryRef}
+            disabled={permissionRecoveryBusy}
+            loading={permissionRecoveryBusy}
+            onClick={() =>
+              void retryWritePermission().then((recovered) => {
+                if (recovered) titleRef.current?.focus()
+                else permissionRetryRef.current?.focus()
+              })
+            }
+          >
+            {tCommon(($) => $['operation.retry'])}
+          </Button>
+        </div>
+      )}
+
+      {(lookupExhausted || isLookingUpTask) && (
+        <div
+          className="mt-4 flex flex-wrap items-center justify-between gap-2 rounded-lg bg-state-warning-hover px-3 py-2 system-xs-regular text-text-warning"
+          role={isLookingUpTask ? 'status' : 'alert'}
+        >
+          {isLookingUpTask ? (
+            <span className="flex items-center gap-2">
+              <span
+                aria-hidden
+                className="i-ri-loader-2-line size-4 animate-spin motion-reduce:animate-none"
+              />
+              {tCommon(($) => $.loading)}
+            </span>
+          ) : (
+            <>
+              <span>{t(($) => $['newKnowledge.documentTaskLookupIncomplete'])}</span>
+              <Button
+                onClick={() => {
+                  continueLookup()
+                  requestAnimationFrame(() => titleRef.current?.focus())
+                }}
+              >
+                {t(($) => $['newKnowledge.continueCheckingTaskStatus'])}
+              </Button>
+            </>
+          )}
+        </div>
+      )}
+
+      {submissionTimedOut && (
+        <div
+          className="mt-4 flex flex-wrap items-center justify-between gap-2 rounded-lg bg-state-warning-hover px-3 py-2 system-xs-regular text-text-warning"
+          role="alert"
+        >
+          <span>{t(($) => $['newKnowledge.documentReindexConfirmationDelayed'])}</span>
+          <div className="flex flex-wrap gap-2">
+            <Button
+              disabled={submissionRecoveryBusy}
+              loading={submissionRecoveryBusy}
+              onClick={() =>
+                void recheckTimedOutSubmission().finally(() => titleRef.current?.focus())
+              }
+            >
+              {t(($) => $['newKnowledge.checkReindexStatus'])}
+            </Button>
+            <Button
+              disabled={submissionRecoveryBusy}
+              onClick={() =>
+                void retryTimedOutSubmission().finally(() => titleRef.current?.focus())
+              }
+            >
+              {t(($) => $['newKnowledge.retryReindexDocument'])}
+            </Button>
+          </div>
+        </div>
+      )}
+
+      {revisionHistoryBackgroundError && effectiveRevision !== undefined && (
+        <div
+          className="mt-4 flex flex-wrap items-center justify-between gap-2 rounded-lg bg-state-warning-hover px-3 py-2 system-xs-regular text-text-warning"
+          role="alert"
+        >
+          <span>{t(($) => $['newKnowledge.documentRevisionsLoadError'])}</span>
+          <Button onClick={refetchRevisions}>{tCommon(($) => $['operation.retry'])}</Button>
+        </div>
+      )}
+    </>
+  )
+}

web/features/new-rag/document-list.tsx

@@ -18,6 +18,7 @@ import { memo, useEffect, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import Loading from '@/app/components/base/loading'
 import { useFormatTimeFromNow } from '@/hooks/use-format-time-from-now'
+import Link from '@/next/link'
 import { sourceName } from './document-model'
 
 export type DocumentFilter = DocumentDisplayStatus | 'all'
@@ -85,6 +86,7 @@ function TaskTrigger({
 const DocumentRow = memo(
   ({
     document,
+    documentHref,
     formatTimeFromNow,
     onSelectedChange,
     readOnlyReasonId,
@@ -96,6 +98,7 @@ const DocumentRow = memo(
     statusPending,
   }: {
     document: LogicalDocument
+    documentHref: string
     formatTimeFromNow: (time: number) => string
     onSelectedChange: (documentId: string) => void
     readOnlyReasonId?: string
@@ -134,9 +137,13 @@ const DocumentRow = memo(
               aria-hidden
               className="i-ri-file-text-line size-[18px] shrink-0 text-text-tertiary"
             />
-            <span id={titleId} className="truncate system-xs-medium text-text-primary">
+            <Link
+              id={titleId}
+              className="truncate rounded system-xs-medium text-text-primary hover:text-text-accent focus-visible:ring-2 focus-visible:ring-state-accent-solid focus-visible:outline-hidden"
+              href={documentHref}
+            >
               {document.title}
-            </span>
+            </Link>
             {revision !== undefined && (
               <span className="shrink-0 rounded border border-divider-regular px-1 system-2xs-medium text-text-tertiary">
                 v{revision}
@@ -306,6 +313,7 @@ export function DocumentsList({
   completingResults,
   documents,
   filter,
+  getDocumentHref,
   hasNextPage,
   hasSelectableDocuments,
   hasTaskError,
@@ -341,6 +349,7 @@ export function DocumentsList({
   completingResults: boolean
   documents: LogicalDocument[]
   filter: DocumentFilter
+  getDocumentHref: (documentId: string) => string
   hasNextPage: boolean
   hasSelectableDocuments: boolean
   hasTaskError: boolean
@@ -498,6 +507,7 @@ export function DocumentsList({
               <DocumentRow
                 key={document.id}
                 document={document}
+                documentHref={getDocumentHref(document.id)}
                 formatTimeFromNow={formatTimeFromNow}
                 onSelectedChange={onSelectDocument}
                 readOnlyReasonId={

web/features/new-rag/document-model.ts

@@ -41,8 +41,7 @@ export function taskVersionIsAfter(candidate: string, baseline: string) {
 
 export function sourceName(document: LogicalDocument) {
   const value = document.userMetadata.sourceName
-  if (typeof value === 'string' && value.trim()) return value
-  return document.sourceId
+  return typeof value === 'string' && value.trim() ? value : undefined
 }
 
 function documentDisabled(document: LogicalDocument, sourceDisabled = false) {

web/features/new-rag/document-revision-content.tsx

@@ -0,0 +1,153 @@
+'use client'
+
+import type {
+  LogicalDocument,
+  LogicalDocumentRevision,
+} from '@dify/contracts/knowledge-fs/types.gen'
+import { Button } from '@langgenius/dify-ui/button'
+import { useInfiniteQuery } from '@tanstack/react-query'
+import { useMemo, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import Loading from '@/app/components/base/loading'
+import { DocumentChunkDetail } from './document-chunk-detail'
+import { DocumentChunkTreePanel } from './document-chunk-tree'
+import { buildDocumentChunkTree } from './document-detail-model'
+import { documentChunksQueryOptions } from './document-detail-queries'
+
+export function DocumentRevisionContent({
+  document,
+  documentId,
+  effectiveRevision,
+  knowledgeSpaceId,
+  locale,
+  revision,
+  revisionHistoryError,
+  revisionHistoryPending,
+  retryRevisionHistory,
+}: {
+  document: LogicalDocument
+  documentId: string
+  effectiveRevision?: number
+  knowledgeSpaceId: string
+  locale: string
+  revision?: Exclude<LogicalDocumentRevision, null>
+  revisionHistoryError: boolean
+  revisionHistoryPending: boolean
+  retryRevisionHistory: () => void
+}) {
+  const { t } = useTranslation('dataset')
+  const { t: tCommon } = useTranslation('common')
+
+  if (effectiveRevision === undefined && revisionHistoryPending)
+    return (
+      <div className="flex min-h-80 items-center justify-center">
+        <Loading />
+      </div>
+    )
+
+  if (effectiveRevision === undefined && revisionHistoryError)
+    return (
+      <div className="flex min-h-80 flex-col items-center justify-center px-6 text-center">
+        <span aria-hidden className="i-ri-error-warning-line size-8 text-text-destructive" />
+        <h2 className="mt-3 title-2xl-semi-bold text-text-primary">
+          {t(($) => $['newKnowledge.documentLoadErrorTitle'])}
+        </h2>
+        <p className="mt-2 max-w-lg body-sm-regular text-text-tertiary">
+          {t(($) => $['newKnowledge.documentLoadErrorDescription'])}
+        </p>
+        <Button className="mt-4" onClick={retryRevisionHistory}>
+          {tCommon(($) => $['operation.retry'])}
+        </Button>
+      </div>
+    )
+
+  if (effectiveRevision === undefined)
+    return (
+      <div className="flex min-h-80 flex-col items-center justify-center text-center">
+        <span aria-hidden className="i-ri-file-warning-line size-8 text-text-tertiary" />
+        <h2 className="mt-3 title-xl-semi-bold text-text-primary">
+          {t(($) => $['newKnowledge.documentRevisionMissingTitle'])}
+        </h2>
+        <p className="mt-2 max-w-lg body-sm-regular text-text-tertiary">
+          {t(($) => $['newKnowledge.documentRevisionMissingDescription'])}
+        </p>
+      </div>
+    )
+
+  return (
+    <LoadedDocumentRevisionContent
+      document={document}
+      documentId={documentId}
+      effectiveRevision={effectiveRevision}
+      knowledgeSpaceId={knowledgeSpaceId}
+      locale={locale}
+      revision={revision}
+    />
+  )
+}
+
+function LoadedDocumentRevisionContent({
+  document,
+  documentId,
+  effectiveRevision,
+  knowledgeSpaceId,
+  locale,
+  revision,
+}: {
+  document: LogicalDocument
+  documentId: string
+  effectiveRevision: number
+  knowledgeSpaceId: string
+  locale: string
+  revision?: Exclude<LogicalDocumentRevision, null>
+}) {
+  const [selectedChunkId, setSelectedChunkId] = useState<string>()
+  const chunksQueryOptions = useMemo(
+    () => documentChunksQueryOptions({ documentId, effectiveRevision, knowledgeSpaceId }),
+    [documentId, effectiveRevision, knowledgeSpaceId],
+  )
+  const chunksQuery = useInfiniteQuery(chunksQueryOptions)
+  const chunks = useMemo(
+    () =>
+      [...(chunksQuery.data?.pages.flatMap((page) => page.items) ?? [])].sort(
+        (left, right) => left.ordinal - right.ordinal || left.id.localeCompare(right.id),
+      ),
+    [chunksQuery.data],
+  )
+  const tree = useMemo(() => buildDocumentChunkTree(chunks), [chunks])
+  const selectedChunk =
+    (selectedChunkId ? tree.byId.get(selectedChunkId)?.chunk : undefined) ?? tree.roots[0]?.chunk
+
+  return (
+    <div className="mt-7 grid min-h-0 flex-1 gap-4 xl:grid-cols-[14rem_minmax(0,1fr)_20rem] xl:gap-0">
+      <DocumentChunkTreePanel
+        chunkCount={chunks.length}
+        error={Boolean(chunksQuery.error)}
+        fetchNextPage={chunksQuery.fetchNextPage}
+        hasNextPage={chunksQuery.hasNextPage}
+        isFetchNextPageError={chunksQuery.isFetchNextPageError}
+        isFetchingNextPage={chunksQuery.isFetchingNextPage}
+        isPending={chunksQuery.isPending}
+        onRetry={() => void chunksQuery.refetch()}
+        onSelectChunk={setSelectedChunkId}
+        selectedChunkId={selectedChunk?.id}
+        tree={tree}
+      />
+
+      <DocumentChunkDetail
+        chunks={chunks}
+        chunksComplete={
+          Boolean(chunksQuery.data) &&
+          !chunksQuery.error &&
+          !chunksQuery.hasNextPage &&
+          !chunksQuery.isFetchingNextPage &&
+          !chunksQuery.isFetchNextPageError
+        }
+        document={document}
+        locale={locale}
+        revision={revision}
+        selectedChunkId={selectedChunk?.id}
+      />
+    </div>
+  )
+}

web/features/new-rag/documents-page.tsx

@@ -37,6 +37,7 @@ import {
 } from './document-model'
 import { DOCUMENT_UPLOAD_ACCEPT, documentUploadIssue } from './document-upload-policy'
 import { ProcessingTasksDrawer } from './processing-tasks-drawer'
+import { newKnowledgeDocumentDetailPath } from './routes'
 import { TaskEventObserver } from './task-event-observer'
 import { createTaskProgressStore } from './task-progress-store'
 import { useQueryDataUpdateCount } from './use-query-data-update-count'
@@ -2125,6 +2126,9 @@ export function DocumentsPage({ knowledgeSpaceId }: { knowledgeSpaceId: string }
             completingResults={completingFilteredResults}
             documents={filteredDocuments}
             filter={filter}
+            getDocumentHref={(documentId) =>
+              newKnowledgeDocumentDetailPath(knowledgeSpaceId, documentId)
+            }
             hasNextPage={Boolean(
               hasNextDocumentPage || hasNextTaskPage || hasRelevantNextSourcePage,
             )}

web/features/new-rag/knowledge-space-shell.tsx

@@ -3,6 +3,7 @@
 import type { ReactNode } from 'react'
 import { Button } from '@langgenius/dify-ui/button'
 import { cn } from '@langgenius/dify-ui/cn'
+import { toast } from '@langgenius/dify-ui/toast'
 import { useQuery } from '@tanstack/react-query'
 import { useTranslation } from 'react-i18next'
 import Loading from '@/app/components/base/loading'
@@ -87,6 +88,7 @@ export function KnowledgeSpaceShell({
   const documentsPath = newKnowledgeDocumentsPath(knowledgeSpaceId)
   const sourcesActive = pathname === sourcesPath || pathname.startsWith(`${sourcesPath}/`)
   const documentsActive = pathname === documentsPath || pathname.startsWith(`${documentsPath}/`)
+  const showDeferredPage = () => toast.info(t(($) => $['cornerLabel.unavailable']))
   const navItemClassName =
     'flex h-8 shrink-0 items-center gap-2 rounded-lg px-3 system-sm-medium outline-hidden hover:bg-state-base-hover focus-visible:ring-2 focus-visible:ring-state-accent-solid'
 
@@ -120,7 +122,9 @@ export function KnowledgeSpaceShell({
                   {knowledgeSpaceQuery.data.name}
                 </h1>
                 <p className="mt-0.5 truncate system-2xs-medium-uppercase text-text-tertiary">
-                  {t(($) => $['newKnowledge.cardType'])}
+                  {t(($) => $['chunkingMode.parentChild'])} ·{' '}
+                  {t(($) => $['indexingTechnique.high_quality'])} ·{' '}
+                  {t(($) => $['retrieval.semantic_search.title'])}
                 </p>
               </div>
             </div>
@@ -129,6 +133,14 @@ export function KnowledgeSpaceShell({
             className="flex gap-0.5 overflow-x-auto px-2 py-1 sm:flex-1 sm:flex-col"
             aria-label={knowledgeSpaceQuery.data.name}
           >
+            <button
+              type="button"
+              className={cn(navItemClassName, 'text-text-secondary')}
+              onClick={showDeferredPage}
+            >
+              <span aria-hidden className="i-ri-layout-grid-line size-4" />
+              {t(($) => $['newKnowledge.overview'])}
+            </button>
             <Link
               href={sourcesPath}
               aria-current={sourcesActive ? 'page' : undefined}
@@ -151,6 +163,38 @@ export function KnowledgeSpaceShell({
               <span aria-hidden className="i-ri-file-text-line size-4" />
               {t(($) => $['newKnowledge.documents'])}
             </Link>
+            <button
+              type="button"
+              className={cn(navItemClassName, 'text-text-secondary')}
+              onClick={showDeferredPage}
+            >
+              <span aria-hidden className="i-ri-test-tube-line size-4" />
+              {tCommon(($) => $['datasetMenus.hitTesting'])}
+            </button>
+            <button
+              type="button"
+              className={cn(navItemClassName, 'text-text-secondary')}
+              onClick={showDeferredPage}
+            >
+              <span aria-hidden className="i-ri-bar-chart-box-line size-4" />
+              {t(($) => $['newKnowledge.quality'])}
+            </button>
+            <button
+              type="button"
+              className={cn(navItemClassName, 'text-text-secondary')}
+              onClick={showDeferredPage}
+            >
+              <span aria-hidden className="i-ri-settings-3-line size-4" />
+              {tCommon(($) => $['datasetMenus.settings'])}
+            </button>
+            <button
+              type="button"
+              className={cn(navItemClassName, 'text-text-secondary')}
+              onClick={showDeferredPage}
+            >
+              <span aria-hidden className="i-ri-code-box-line size-4" />
+              {t(($) => $['newKnowledge.apiAgentAccess'])}
+            </button>
           </nav>
         </aside>
         <section className="min-h-0 min-w-0 flex-1 overflow-auto rounded-lg bg-components-panel-bg shadow-xs">

web/features/new-rag/routes.ts

@@ -188,6 +188,9 @@ export const newKnowledgeDetailPath = (knowledgeSpaceId: string) =>
 export const newKnowledgeDocumentsPath = (knowledgeSpaceId: string) =>
   `/datasets/new/${knowledgeSpaceId}/documents`
 
+export const newKnowledgeDocumentDetailPath = (knowledgeSpaceId: string, documentId: string) =>
+  `/datasets/new/${knowledgeSpaceId}/documents/${documentId}`
+
 export const newKnowledgeAddSourcePath = (
   knowledgeSpaceId: string,
   sourceType?: NewKnowledgeSourceType,

web/features/new-rag/use-document-reindex.ts

@@ -0,0 +1,250 @@
+'use client'
+
+import { toast } from '@langgenius/dify-ui/toast'
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+import { useSetAtom } from 'jotai'
+import { useEffect, useRef, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { refreshWorkspacePermissionKeysAfterMutationDenialAtom } from '@/context/permission-state'
+import { consoleQuery } from '@/service/client'
+import { DatasetACLPermission, hasPermission } from '@/utils/permission'
+import { responseStatus } from './document-detail-model'
+import { useDocumentTaskStatus } from './use-document-task-status'
+
+const REINDEX_CONFIRMATION_TIMEOUT = 30000
+
+export function useDocumentReindex({
+  chunksQueryKey,
+  documentActiveRevision,
+  documentId,
+  documentQueryKey,
+  enabled,
+  knowledgeSpaceId,
+  revisionsQueryKey,
+}: {
+  chunksQueryKey: readonly unknown[]
+  documentActiveRevision: number
+  documentId: string
+  documentQueryKey: readonly unknown[]
+  enabled: boolean
+  knowledgeSpaceId: string
+  revisionsQueryKey: readonly unknown[]
+}) {
+  const { t } = useTranslation('dataset')
+  const queryClient = useQueryClient()
+  const refreshWorkspacePermissionKeysAfterMutationDenial = useSetAtom(
+    refreshWorkspacePermissionKeysAfterMutationDenialAtom,
+  )
+  const [writePermissionRevoked, setWritePermissionRevoked] = useState(false)
+  const [documentMissing, setDocumentMissing] = useState(false)
+  const [permissionRecoveryBusy, setPermissionRecoveryBusy] = useState(false)
+  const [permissionRecoveryNeeded, setPermissionRecoveryNeeded] = useState(false)
+  const [reindexBusy, setReindexBusy] = useState(false)
+  const [submissionRecoveryBusy, setSubmissionRecoveryBusy] = useState(false)
+  const [submittedReindex, setSubmittedReindex] = useState<{
+    baselineRevision: number
+    generation: number
+    timedOut: boolean
+  }>()
+  const nextSubmissionGenerationRef = useRef(0)
+  const permissionRecoveryPendingRef = useRef(false)
+  const reindexPendingRef = useRef(false)
+  const previousTaskStateRef = useRef<string | undefined>(undefined)
+  const acceptedTaskIdRef = useRef<string | undefined>(undefined)
+  const invalidatedTerminalTaskRef = useRef<string | undefined>(undefined)
+  const { mutateAsync: reindexDocument } = useMutation(
+    consoleQuery.knowledgeFs.postKnowledgeSpacesByIdDocumentsBulkReindex.mutationOptions(),
+  )
+  const taskStatus = useDocumentTaskStatus({
+    documentId,
+    enabled,
+    knowledgeSpaceId,
+    minimumRevision: submittedReindex
+      ? submittedReindex.baselineRevision + 1
+      : documentActiveRevision,
+    submissionDiscoveryGeneration: submittedReindex?.generation,
+    submissionNeedsRecheck: Boolean(submittedReindex),
+    submissionPending: Boolean(submittedReindex && !submittedReindex.timedOut),
+  })
+  const { latestTask, taskIsActive } = taskStatus
+  const latestTaskRef = useRef(latestTask)
+  latestTaskRef.current = latestTask
+  const submittedTaskObserved = Boolean(
+    latestTask &&
+    submittedReindex &&
+    latestTask.documentRevision > submittedReindex.baselineRevision,
+  )
+  const submissionPending = Boolean(submittedReindex && !submittedTaskObserved)
+
+  const retryWritePermission = async () => {
+    if (permissionRecoveryPendingRef.current) return false
+    permissionRecoveryPendingRef.current = true
+    setPermissionRecoveryBusy(true)
+    try {
+      const result = await refreshWorkspacePermissionKeysAfterMutationDenial()
+      const refreshedPermissionKeys = result.data?.dataset?.default_permission_keys
+      if (
+        !result.error &&
+        refreshedPermissionKeys &&
+        hasPermission(refreshedPermissionKeys, DatasetACLPermission.Edit)
+      ) {
+        setWritePermissionRevoked(false)
+        setPermissionRecoveryNeeded(false)
+        return true
+      }
+      setPermissionRecoveryNeeded(true)
+      return false
+    } catch {
+      setPermissionRecoveryNeeded(true)
+      return false
+    } finally {
+      permissionRecoveryPendingRef.current = false
+      setPermissionRecoveryBusy(false)
+    }
+  }
+
+  useEffect(() => {
+    if (!submittedReindex || submittedReindex.timedOut || submittedTaskObserved) return
+    const timeout = window.setTimeout(
+      () =>
+        setSubmittedReindex((current) =>
+          current?.baselineRevision === submittedReindex.baselineRevision
+            ? { ...current, timedOut: true }
+            : current,
+        ),
+      REINDEX_CONFIRMATION_TIMEOUT,
+    )
+    return () => window.clearTimeout(timeout)
+  }, [submittedReindex, submittedTaskObserved])
+
+  useEffect(() => {
+    const previousState = previousTaskStateRef.current
+    const previousWasActive =
+      previousState === 'dispatch_pending' ||
+      previousState === 'queued' ||
+      previousState === 'running' ||
+      previousState === 'retry_wait'
+    previousTaskStateRef.current = latestTask?.state
+    const taskMatchesAcceptedSubmission = Boolean(
+      latestTask &&
+      submittedReindex &&
+      latestTask.documentRevision > submittedReindex.baselineRevision,
+    )
+    if (taskMatchesAcceptedSubmission && latestTask) acceptedTaskIdRef.current = latestTask.id
+    const terminalTaskKey = latestTask ? `${latestTask.id}:${latestTask.updatedAt}` : undefined
+    const shouldInvalidateTerminalTask = Boolean(
+      latestTask &&
+      !taskIsActive &&
+      (previousWasActive ||
+        acceptedTaskIdRef.current === latestTask.id ||
+        taskMatchesAcceptedSubmission ||
+        latestTask.documentRevision > documentActiveRevision) &&
+      invalidatedTerminalTaskRef.current !== terminalTaskKey,
+    )
+    if (!shouldInvalidateTerminalTask || !terminalTaskKey) return
+    invalidatedTerminalTaskRef.current = terminalTaskKey
+    void Promise.all([
+      queryClient.invalidateQueries({
+        queryKey: documentQueryKey,
+      }),
+      queryClient.invalidateQueries({
+        queryKey: revisionsQueryKey,
+      }),
+      queryClient.invalidateQueries({
+        queryKey: chunksQueryKey,
+      }),
+      queryClient.invalidateQueries({ queryKey: taskStatus.queryKey }),
+    ])
+  }, [
+    chunksQueryKey,
+    documentActiveRevision,
+    documentQueryKey,
+    latestTask,
+    queryClient,
+    revisionsQueryKey,
+    submittedReindex,
+    taskIsActive,
+    taskStatus.queryKey,
+  ])
+
+  const reindex = async (baselineRevision = documentActiveRevision) => {
+    if (reindexPendingRef.current) return
+    reindexPendingRef.current = true
+    setReindexBusy(true)
+    try {
+      const result = await reindexDocument({
+        body: { documentIds: [documentId] },
+        params: { id: knowledgeSpaceId },
+      })
+      if (!result.items[0] || result.items[0].status === 'not_found') {
+        setDocumentMissing(true)
+        queryClient.removeQueries({ queryKey: documentQueryKey })
+        await queryClient.invalidateQueries({
+          queryKey: documentQueryKey,
+        })
+        toast.error(t(($) => $['newKnowledge.documentNotFoundTitle']))
+        return
+      }
+      setSubmittedReindex({
+        baselineRevision: Math.max(
+          baselineRevision,
+          documentActiveRevision,
+          latestTaskRef.current?.documentRevision ?? documentActiveRevision,
+        ),
+        generation: ++nextSubmissionGenerationRef.current,
+        timedOut: false,
+      })
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: documentQueryKey,
+        }),
+        queryClient.invalidateQueries({
+          queryKey: revisionsQueryKey,
+        }),
+        queryClient.invalidateQueries({
+          queryKey: chunksQueryKey,
+        }),
+        queryClient.invalidateQueries({ queryKey: taskStatus.queryKey }),
+      ])
+      toast.success(t(($) => $['newKnowledge.documentsReindexStarted']))
+    } catch (error) {
+      if (responseStatus(error) === 403) {
+        setWritePermissionRevoked(true)
+        await retryWritePermission()
+      }
+      toast.error(t(($) => $['newKnowledge.documentsReindexFailed']))
+    } finally {
+      reindexPendingRef.current = false
+      setReindexBusy(false)
+    }
+  }
+
+  return {
+    ...taskStatus,
+    documentMissing,
+    permissionRecoveryBusy,
+    permissionRecoveryNeeded,
+    reindex,
+    reindexBusy,
+    recheckTimedOutSubmission: async () => {
+      if (submissionRecoveryBusy) return
+      setSubmissionRecoveryBusy(true)
+      try {
+        await taskStatus.refetch()
+      } finally {
+        setSubmissionRecoveryBusy(false)
+      }
+    },
+    retryTimedOutSubmission: async () => {
+      if (submissionRecoveryBusy) return
+      const baselineRevision = submittedReindex?.baselineRevision ?? documentActiveRevision
+      setSubmittedReindex(undefined)
+      await reindex(baselineRevision)
+    },
+    retryWritePermission,
+    submissionRecoveryBusy,
+    submissionPending,
+    submissionTimedOut: Boolean(submittedReindex?.timedOut && !submittedTaskObserved),
+    writePermissionRevoked,
+  }
+}

web/features/new-rag/use-document-task-status.ts

@@ -0,0 +1,275 @@
+'use client'
+
+import type {
+  DocumentProcessingTask,
+  DocumentProcessingTaskList,
+} from '@dify/contracts/knowledge-fs/types.gen'
+import type { InfiniteData } from '@tanstack/react-query'
+import { skipToken, useInfiniteQuery, useQuery, useQueryClient } from '@tanstack/react-query'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { consoleQuery } from '@/service/client'
+import { responseStatus } from './document-detail-model'
+import { newestTaskByDocument } from './document-model'
+
+const TASK_PAGE_SIZE = 100
+const TASK_LOOKUP_PAGE_BATCH = 3
+const ACTIVE_TASK_REFRESH_INTERVAL = 5000
+const SUBMISSION_DISCOVERY_REFRESH_INTERVAL = 2000
+
+function documentTaskIsActive(task: DocumentProcessingTask | undefined) {
+  return (
+    task?.state === 'dispatch_pending' ||
+    task?.state === 'queued' ||
+    task?.state === 'running' ||
+    task?.state === 'retry_wait'
+  )
+}
+
+export function useDocumentTaskStatus({
+  documentId,
+  enabled,
+  knowledgeSpaceId,
+  minimumRevision,
+  submissionDiscoveryGeneration,
+  submissionNeedsRecheck,
+  submissionPending,
+}: {
+  documentId: string
+  enabled: boolean
+  knowledgeSpaceId: string
+  minimumRevision: number
+  submissionDiscoveryGeneration?: number
+  submissionNeedsRecheck: boolean
+  submissionPending: boolean
+}) {
+  const queryClient = useQueryClient()
+  const completedDiscoveryGenerationRef = useRef<number | undefined>(undefined)
+  const missingTaskIdsRef = useRef(new Set<string>())
+  const [lookupPageLimit, setLookupPageLimit] = useState(TASK_LOOKUP_PAGE_BATCH)
+  const tasksQueryOptions = useMemo(
+    () =>
+      consoleQuery.knowledgeFs.getKnowledgeSpacesByIdDocumentsByDocumentIdProcessingTasks.infiniteOptions(
+        {
+          enabled,
+          input: (pageParam) => ({
+            params: { documentId, id: knowledgeSpaceId },
+            query: {
+              limit: TASK_PAGE_SIZE,
+              ...(typeof pageParam === 'string' ? { cursor: pageParam } : {}),
+            },
+          }),
+          getNextPageParam: (lastPage) => lastPage.nextCursor,
+          initialPageParam: null as string | null,
+        },
+      ),
+    [documentId, enabled, knowledgeSpaceId],
+  )
+  const tasksQuery = useInfiniteQuery(tasksQueryOptions)
+  const {
+    data: tasksData,
+    error: tasksQueryError,
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage,
+    isPending,
+    refetch: refetchTasks,
+  } = tasksQuery
+  const historyTasks = useMemo(
+    () => tasksData?.pages.flatMap((page) => page.items) ?? [],
+    [tasksData],
+  )
+  const historyHasSubmittedTask = historyTasks.some(
+    (task) =>
+      !missingTaskIdsRef.current.has(task.id) &&
+      task.documentId === documentId &&
+      task.documentRevision >= minimumRevision,
+  )
+  const submissionTasksQueryOptions = useMemo(
+    () =>
+      consoleQuery.knowledgeFs.getKnowledgeSpacesByIdDocumentsByDocumentIdProcessingTasks.queryOptions(
+        {
+          enabled: enabled && submissionPending && !historyHasSubmittedTask,
+          input: {
+            params: { documentId, id: knowledgeSpaceId },
+            query: { limit: TASK_PAGE_SIZE },
+          },
+          refetchInterval: (query) => {
+            if (
+              query.state.error ||
+              !submissionDiscoveryGeneration ||
+              completedDiscoveryGenerationRef.current === submissionDiscoveryGeneration
+            )
+              return false
+            const hasSubmittedTask = query.state.data?.items.some(
+              (task) =>
+                !missingTaskIdsRef.current.has(task.id) &&
+                task.documentId === documentId &&
+                task.documentRevision >= minimumRevision,
+            )
+            if (hasSubmittedTask) {
+              completedDiscoveryGenerationRef.current = submissionDiscoveryGeneration
+              return false
+            }
+            return enabled && submissionPending && !hasSubmittedTask
+              ? SUBMISSION_DISCOVERY_REFRESH_INTERVAL
+              : false
+          },
+          refetchOnWindowFocus: false,
+          retry: (failureCount, error) => {
+            const status = responseStatus(error)
+            return status !== 403 && status !== 404 && failureCount < 2
+          },
+        },
+      ),
+    [
+      documentId,
+      enabled,
+      historyHasSubmittedTask,
+      knowledgeSpaceId,
+      minimumRevision,
+      submissionDiscoveryGeneration,
+      submissionPending,
+    ],
+  )
+  const submissionTasksQuery = useQuery(submissionTasksQueryOptions)
+  const tasks = useMemo(
+    () => [...(submissionTasksQuery.data?.items ?? []), ...historyTasks],
+    [historyTasks, submissionTasksQuery.data],
+  )
+  const discoveredTask = useMemo(() => {
+    const candidate = newestTaskByDocument(
+      tasks.filter(
+        (task) =>
+          !missingTaskIdsRef.current.has(task.id) &&
+          task.documentId === documentId &&
+          task.documentRevision >= minimumRevision,
+      ),
+    ).get(documentId)
+    return candidate && candidate.documentRevision >= minimumRevision ? candidate : undefined
+  }, [documentId, minimumRevision, tasks])
+  const discoveredTaskIsActive = documentTaskIsActive(discoveredTask)
+  const taskSnapshotQuery = useQuery(
+    consoleQuery.knowledgeFs.getKnowledgeSpacesByIdDocumentsByDocumentIdProcessingTasksByTaskId.queryOptions(
+      {
+        enabled: enabled && discoveredTaskIsActive,
+        input:
+          enabled && discoveredTaskIsActive && discoveredTask
+            ? {
+                params: {
+                  documentId,
+                  id: knowledgeSpaceId,
+                  taskId: discoveredTask.id,
+                },
+              }
+            : skipToken,
+        refetchInterval: (query) =>
+          !query.state.error && documentTaskIsActive(query.state.data ?? discoveredTask)
+            ? ACTIVE_TASK_REFRESH_INTERVAL
+            : false,
+        retry: (failureCount, error) => {
+          const status = responseStatus(error)
+          return status !== 403 && status !== 404 && failureCount < 2
+        },
+      },
+    ),
+  )
+  const taskSnapshotErrorStatus = responseStatus(taskSnapshotQuery.error)
+  const latestTask =
+    taskSnapshotErrorStatus === 403 || taskSnapshotErrorStatus === 404
+      ? undefined
+      : taskSnapshotQuery.data?.id === discoveredTask?.id
+        ? taskSnapshotQuery.data
+        : discoveredTask
+  const lookupExhausted = Boolean(
+    !latestTask && hasNextPage && (tasksData?.pages.length ?? 0) >= lookupPageLimit,
+  )
+
+  useEffect(() => {
+    if (
+      isPending ||
+      !enabled ||
+      isFetchingNextPage ||
+      tasksQueryError ||
+      latestTask ||
+      !hasNextPage ||
+      lookupExhausted
+    )
+      return
+    void fetchNextPage()
+  }, [
+    fetchNextPage,
+    enabled,
+    hasNextPage,
+    isFetchingNextPage,
+    isPending,
+    latestTask,
+    lookupExhausted,
+    tasksQueryError,
+  ])
+
+  useEffect(() => {
+    if (
+      taskSnapshotErrorStatus !== 404 ||
+      !discoveredTask ||
+      missingTaskIdsRef.current.has(discoveredTask.id)
+    )
+      return
+    missingTaskIdsRef.current.add(discoveredTask.id)
+    if (completedDiscoveryGenerationRef.current === submissionDiscoveryGeneration)
+      completedDiscoveryGenerationRef.current = undefined
+    queryClient.setQueryData<DocumentProcessingTaskList>(
+      submissionTasksQueryOptions.queryKey,
+      (current) =>
+        current
+          ? { ...current, items: current.items.filter((task) => task.id !== discoveredTask.id) }
+          : current,
+    )
+    queryClient.setQueryData<InfiniteData<DocumentProcessingTaskList, string | null>>(
+      tasksQueryOptions.queryKey,
+      (current) =>
+        current
+          ? {
+              ...current,
+              pages: current.pages.map((page) => ({
+                ...page,
+                items: page.items.filter((task) => task.id !== discoveredTask.id),
+              })),
+            }
+          : current,
+    )
+    void Promise.all([
+      queryClient.invalidateQueries({ queryKey: tasksQueryOptions.queryKey }),
+      queryClient.invalidateQueries({ queryKey: submissionTasksQueryOptions.queryKey }),
+    ])
+  }, [
+    discoveredTask,
+    queryClient,
+    submissionDiscoveryGeneration,
+    submissionTasksQueryOptions.queryKey,
+    taskSnapshotErrorStatus,
+    tasksQueryOptions.queryKey,
+  ])
+
+  return {
+    continueLookup: () => setLookupPageLimit((current) => current + TASK_LOOKUP_PAGE_BATCH),
+    isFetchingNextPage,
+    isLookingUp: Boolean(!latestTask && hasNextPage && !lookupExhausted),
+    isPending,
+    latestTask,
+    lookupExhausted,
+    queryKey: tasksQueryOptions.queryKey,
+    refetch: async () => {
+      const results = await Promise.all([
+        refetchTasks(),
+        ...(enabled && submissionNeedsRecheck ? [submissionTasksQuery.refetch()] : []),
+        ...(enabled && discoveredTaskIsActive ? [taskSnapshotQuery.refetch()] : []),
+      ])
+      return results[0]
+    },
+    taskIsActive: documentTaskIsActive(latestTask),
+    tasksError:
+      tasksQueryError ??
+      (submissionPending && !historyHasSubmittedTask ? submissionTasksQuery.error : undefined) ??
+      (taskSnapshotErrorStatus === 404 ? undefined : taskSnapshotQuery.error),
+  }
+}

web/i18n/ar-TN/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "الضبط وإعادة الزحف",
   "newKnowledge.allDocumentStatuses": "كل الوضع",
   "newKnowledge.allSources": "جميع المصادر",
+  "newKnowledge.apiAgentAccess": "الوصول إلى API والوكيل",
   "newKnowledge.appsUnavailable": "— تطبيقات",
   "newKnowledge.authKind.api-key": "مفتاح API",
   "newKnowledge.authKind.endpoint": "نقطة النهاية",
   "newKnowledge.authenticationMethod": "طريقة المصادقة",
+  "newKnowledge.averageChunkLength": "متوسط طول المقطع",
   "newKnowledge.backToList": "العودة إلى قواعد المعرفة",
   "newKnowledge.backgroundTasks": "مهام الخلفية",
   "newKnowledge.backgroundTasksDescription": "يضيف المستند، ويتزامن المصدر، ويعيد فهرسة المهام.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "إجراءات المستندات المجمعة",
   "newKnowledge.cancelAddSource": "إلغاء",
   "newKnowledge.cardType": "مساحة معرفة",
+  "newKnowledge.characterCount": "الأحرف",
+  "newKnowledge.checkReindexStatus": "تحقق من حالة إعادة الفهرسة",
+  "newKnowledge.chunkCount": "المقاطع",
+  "newKnowledge.chunkHeading": "المقطع {{position}}",
+  "newKnowledge.chunkLocation": "الموضع {{position}} في هذه المراجعة",
   "newKnowledge.clearDocumentSelection": "مسح تحديد المستندات",
   "newKnowledge.configureProvider": "تكوين {{provider}}",
   "newKnowledge.connectNotion": "ربط Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "قم بتحديث الاتصال قبل إضافة مصدر موقع الويب.",
   "newKnowledge.connectionProvisioning": "جارٍ الاتصال بـ {{provider}}",
   "newKnowledge.connectionRefreshFailed": "لم نتمكن من تحديث هذا الاتصال. حاول ثانية.",
+  "newKnowledge.continueCheckingTaskStatus": "متابعة التحقق من حالة المهمة",
   "newKnowledge.crawlAndPreview": "الزحف والمعاينة",
   "newKnowledge.crawlFailed": "تعذّر الزحف إلى {{host}}",
   "newKnowledge.crawlFailed403": "أعاد الموقع الخطأ 403 — قد يحظر برامج الزحف أو يتطلب المصادقة. تحقّق من عنوان URL أو عدّل خيارات الزحف أو جرّب موفّرًا آخر.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "لم نتمكن من إنشاء قاعدة المعرفة هذه. تحقق من وصولك وحاول مرة أخرى.",
   "newKnowledge.createIllustrationTitle": "اربط محتواك مرة واحدة — وسيجيب كل تطبيق بأحدث المعارف.",
   "newKnowledge.createTitle": "خلق المعرفة",
+  "newKnowledge.createdAt": "تم الإنشاء",
   "newKnowledge.creators": "المنشئون",
   "newKnowledge.customIntervalHours": "فاصل زمني مخصّص (بالساعات)",
   "newKnowledge.customIntervalInvalid": "أدخل عددًا صحيحًا من 1 إلى 720 ساعة.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "هل تريد تجاهل مسودة المصدر هذه؟",
   "newKnowledge.documentActions": "إجراءات {{name}}",
   "newKnowledge.documentActionsUnavailable": "إجراءات المستند غير متاحة لقاعدة المعرفة هذه حتى الآن.",
+  "newKnowledge.documentChunksEmpty": "لا توجد مقاطع متاحة لهذه المراجعة بعد.",
+  "newKnowledge.documentChunksLoadError": "تعذّر تحميل مقاطع هذه المراجعة.",
+  "newKnowledge.documentChunksLoadMoreError": "تعذّر تحميل المزيد من المقاطع. حاول مرة أخرى.",
   "newKnowledge.documentColumn": "وثيقة",
+  "newKnowledge.documentContentIncomplete": "جارٍ تحميل بقية محتوى المستند…",
+  "newKnowledge.documentContents": "المحتويات",
+  "newKnowledge.documentFacts": "تفاصيل المستند",
   "newKnowledge.documentFilterLabel": "تصفية المستندات حسب الحالة",
+  "newKnowledge.documentLoadErrorDescription": "تعذّر تحميل هذا المستند. حاول مرة أخرى.",
+  "newKnowledge.documentLoadErrorTitle": "تعذّر تحميل المستند",
+  "newKnowledge.documentNotFoundDescription": "ربما تمت إزالة هذا المستند أو لا تملك صلاحية الوصول إليه.",
+  "newKnowledge.documentNotFoundTitle": "المستند غير موجود",
+  "newKnowledge.documentOverviewDescription": "يساعد تصنيف البيانات الوصفية للمستندات الذكاء الاصطناعي على الوصول إليها في الوقت المناسب ويُظهر للمستخدمين مصادر المراجع.",
   "newKnowledge.documentPermissionRestricted": "لا تسمح أذونات مساحة العمل الخاصة بك بإجراءات المستندات أو المهام.",
+  "newKnowledge.documentReindexConfirmationDelayed": "تم قبول إعادة الفهرسة، لكن حالة المهمة متأخرة. تحقق منها قبل الإرسال مرة أخرى.",
+  "newKnowledge.documentReindexFailed": "فشلت إعادة الفهرسة. تظل آخر مراجعة جاهزة متاحة.",
+  "newKnowledge.documentReindexProgress": "جارٍ إعادة الفهرسة · {{progress}}٪",
+  "newKnowledge.documentRevision": "المراجعة",
+  "newKnowledge.documentRevisionMissingDescription": "لا توجد مراجعة جاهزة لهذا المستند بعد. تحقق مجددًا بعد اكتمال المعالجة.",
+  "newKnowledge.documentRevisionMissingTitle": "لا توجد مراجعة متاحة",
+  "newKnowledge.documentRevisionsLoadError": "تعذّر تحميل سجل المراجعات. تظل المراجعة الحالية متاحة.",
   "newKnowledge.documentStatus.disabled": "معطل",
   "newKnowledge.documentStatus.failed": "فشل",
   "newKnowledge.documentStatus.processing": "قيد المعالجة",
   "newKnowledge.documentStatus.queued": "في قائمة الانتظار",
   "newKnowledge.documentStatus.ready": "جاهز",
+  "newKnowledge.documentTaskLookupIncomplete": "يتوفر المزيد من سجل المهام. تابع التحقق للعثور على حالة هذا المستند.",
   "newKnowledge.documentUploadExclusion.batchLimit": "تم تجاوز الحد الأقصى لحجم الدفعة",
   "newKnowledge.documentUploadExclusion.countLimit": "تم تجاوز الحد الأقصى لعدد الملفات",
   "newKnowledge.documentUploadExclusion.fileSize": "الملف كبير جدًا",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— مستندات",
   "newKnowledge.downloadDocuments": "تحميل",
   "newKnowledge.editSource": "تحرير",
+  "newKnowledge.emptyChunk": "مقطع فارغ",
   "newKnowledge.emptyDescription": "أضف مستنداتك ليتمكن الوكلاء من قراءتها مباشرة — من دون إعداد الفهرسة.",
   "newKnowledge.emptyTitle": "طريقة أذكى لبناء قواعد المعرفة",
   "newKnowledge.errorDescription": "تعذر تحميل قواعد المعرفة الجديدة. حاول مرة أخرى.",
   "newKnowledge.errorTitle": "حدث خطأ ما",
+  "newKnowledge.fileSize": "حجم الملف",
   "newKnowledge.filtersUnavailable": "سيصبح هذا المرشح متاحًا عندما يوفر KnowledgeFS بياناته الوصفية.",
   "newKnowledge.firecrawlUnavailable": "الزحف الناري غير متوفر في كتالوج الموفر لمساحة العمل هذه.",
   "newKnowledge.gotIt": "فهمت",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "تعرّف على قاعدة المعرفة الجديدة ✨",
   "newKnowledge.illustrationHeadline": "اربط محتواك مرة واحدة — ليجيب كل تطبيق بأحدث معرفة.",
   "newKnowledge.includeSubpages": "تضمين الصفحات الفرعية",
+  "newKnowledge.indexInformation": "معلومات الفهرسة",
   "newKnowledge.interruptTask": "إيقاف",
   "newKnowledge.invalidRootUrl": "أدخل عنوان URL صالحًا يبدأ بـ http(s).",
   "newKnowledge.keepEditing": "متابعة التحرير",
+  "newKnowledge.lastIndexed": "آخر فهرسة",
   "newKnowledge.lastReadyRevisionHint": "لا تؤدي المعالجة الفاشلة إلى مقاطعة الاسترداد مطلقًا، حيث تظل آخر مراجعة جاهزة متاحة في فهرس المحتوى.",
   "newKnowledge.lastSyncColumn": "آخر مزامنة",
   "newKnowledge.learnMore": "معرفة المزيد",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "مغادرة الإعداد غير المكتمل؟",
   "newKnowledge.legacy": "قديم",
   "newKnowledge.loadMore": "تحميل المزيد",
+  "newKnowledge.loadMoreRevisions": "تحميل مراجعات أقدم",
   "newKnowledge.loadingSyncPolicy": "جارٍ تحميل سياسة المزامنة",
   "newKnowledge.manualUpload": "التحميل اليدوي",
   "newKnowledge.maxPages": "الحد الأقصى للصفحات",
   "newKnowledge.metadata": "بيانات التعريف",
+  "newKnowledge.mimeType": "نوع الملف",
   "newKnowledge.moreProviders": "مزوّدون آخرون",
   "newKnowledge.name": "اسم المعرفة",
   "newKnowledge.namePlaceholder": "على سبيل المثال دليل دعم العملاء",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "اربط Notion لاختيار الصفحات والحفاظ على مزامنتها.",
   "newKnowledge.onlineDocuments": "المستندات عبر الإنترنت",
   "newKnowledge.onlineDrive": "محرك الأقراص عبر الإنترنت",
+  "newKnowledge.overview": "نظرة عامة",
   "newKnowledge.pagesAppearDescription": "ازحف إلى الموقع لمراجعة الصفحات التي ستتم إضافتها.",
   "newKnowledge.pagesAppearTitle": "ستظهر الصفحات هنا",
   "newKnowledge.pagesCrawled": "تم الزحف إلى {{count}} صفحة في {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} لم يتم تكوينه",
   "newKnowledge.providerNotConfiguredDescription": "أضف مفتاح API أو عنوان URL لنقطة النهاية للزحف إلى مواقع الويب باستخدام {{provider}}.",
   "newKnowledge.providerUnavailable": "هذا الموفر غير متوفر.",
+  "newKnowledge.quality": "الجودة",
   "newKnowledge.reCrawl": "إعادة الزحف",
   "newKnowledge.readOnlyEmpty": "اطلب من محرر مساحة العمل إنشاء أول قاعدة معرفة.",
   "newKnowledge.refreshConnectionStatus": "تحديث الحالة",
   "newKnowledge.refreshingConnection": "منعش…",
+  "newKnowledge.reindexDocument": "إعادة الفهرسة",
   "newKnowledge.reindexDocuments": "إعادة الفهرسة",
   "newKnowledge.removeSource": "قم بإزالة المصدر",
+  "newKnowledge.retrievalCount": "عدد مرات الاسترجاع",
   "newKnowledge.retryCrawl": "إعادة محاولة الزحف",
   "newKnowledge.retryProviderLoad": "أعد المحاولة",
+  "newKnowledge.retryReindexDocument": "إعادة الفهرسة مرة أخرى",
   "newKnowledge.retrySyncPolicy": "إعادة محاولة سياسة المزامنة",
   "newKnowledge.retryTask": "أعد المحاولة",
+  "newKnowledge.revisionState.active": "نشطة",
+  "newKnowledge.revisionState.candidate": "قيد المعالجة",
+  "newKnowledge.revisionState.failed": "فشلت",
+  "newKnowledge.revisionState.superseded": "سابقة",
   "newKnowledge.rootUrl": "عنوان URL الجذر",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "سيصبح هذا القسم متاحًا في خطوة الإعداد التالية.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "تحديد الكل",
   "newKnowledge.selectAllDocuments": "حدد كافة المستندات",
   "newKnowledge.selectAllSources": "تحديد كل المصادر",
+  "newKnowledge.selectChunk": "حدد مقطعًا لفحص محتواه.",
   "newKnowledge.selectFilesAndFolders": "حدد الملفات والمجلدات للمزامنة",
   "newKnowledge.skippedFailed": "تم التخطي (فشل)",
   "newKnowledge.skippedOffDomain": "تم التخطي (خارج النطاق)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "المهام",
   "newKnowledge.tasksErrorDescription": "لم نتمكن من تحميل مهام الخلفية. حاول ثانية.",
   "newKnowledge.tasksWithAttention": "المهام، {{count}} تحتاج إلى الاهتمام",
+  "newKnowledge.tokenCount": "الرموز",
   "newKnowledge.unavailableDescription": "KnowledgeFS غير متاح لمساحة العمل هذه حاليًا.",
   "newKnowledge.unavailableTitle": "المعرفة الجديدة غير متاحة",
   "newKnowledge.updated": "تم التحديث في {{date}}",
+  "newKnowledge.updatedAt": "آخر تحديث",
   "newKnowledge.updatedColumn": "تم التحديث",
   "newKnowledge.uploadCharactersUnavailable": "الأحرف: —",
   "newKnowledge.uploadDocuments": "تحميل المستندات",

web/i18n/de-DE/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Anpassen und erneut crawlen",
   "newKnowledge.allDocumentStatuses": "Alle Status",
   "newKnowledge.allSources": "Alle Quellen",
+  "newKnowledge.apiAgentAccess": "API- & Agent-Zugriff",
   "newKnowledge.appsUnavailable": "— Apps",
   "newKnowledge.authKind.api-key": "API-Schlüssel",
   "newKnowledge.authKind.endpoint": "Endpunkt",
   "newKnowledge.authenticationMethod": "Authentifizierungsmethode",
+  "newKnowledge.averageChunkLength": "Durchschnittliche Abschnittslänge",
   "newKnowledge.backToList": "Zurück zu den Wissensdatenbanken",
   "newKnowledge.backgroundTasks": "Hintergrundaufgaben",
   "newKnowledge.backgroundTasksDescription": "Dokumenthinzufügungen, Quellsynchronisierungen und Neuindizierungsaufträge.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Massendokumentaktionen",
   "newKnowledge.cancelAddSource": "Abbrechen",
   "newKnowledge.cardType": "Wissensbereich",
+  "newKnowledge.characterCount": "Zeichen",
+  "newKnowledge.checkReindexStatus": "Neuindizierungsstatus prüfen",
+  "newKnowledge.chunkCount": "Abschnitte",
+  "newKnowledge.chunkHeading": "Abschnitt {{position}}",
+  "newKnowledge.chunkLocation": "Position {{position}} in dieser Revision",
   "newKnowledge.clearDocumentSelection": "Dokumentauswahl löschen",
   "newKnowledge.configureProvider": "{{provider}} konfigurieren",
   "newKnowledge.connectNotion": "Notion verbinden",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Aktualisieren Sie die Verbindung, bevor Sie eine Website-Quelle hinzufügen.",
   "newKnowledge.connectionProvisioning": "{{provider}} stellt eine Verbindung her",
   "newKnowledge.connectionRefreshFailed": "Wir konnten diese Verbindung nicht aktualisieren. Versuchen Sie es erneut.",
+  "newKnowledge.continueCheckingTaskStatus": "Aufgabenstatus weiter prüfen",
   "newKnowledge.crawlAndPreview": "Crawlen und Vorschau",
   "newKnowledge.crawlFailed": "{{host}} konnte nicht gecrawlt werden",
   "newKnowledge.crawlFailed403": "Die Website hat 403 zurückgegeben – möglicherweise blockiert sie Crawler oder erfordert eine Authentifizierung. Prüfe die URL, passe die Crawl-Optionen an oder versuche einen anderen Anbieter.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Wir konnten diese Wissensdatenbank nicht erstellen. Überprüfen Sie Ihren Zugang und versuchen Sie es erneut.",
   "newKnowledge.createIllustrationTitle": "Verbinde deine Inhalte einmal – jede App antwortet mit dem aktuellsten Wissen.",
   "newKnowledge.createTitle": "Wissen schaffen",
+  "newKnowledge.createdAt": "Erstellt",
   "newKnowledge.creators": "Ersteller",
   "newKnowledge.customIntervalHours": "Benutzerdefiniertes Intervall (Stunden)",
   "newKnowledge.customIntervalInvalid": "Gib eine ganze Zahl zwischen 1 und 720 Stunden ein.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Diesen Quellenentwurf verwerfen?",
   "newKnowledge.documentActions": "Aktionen für {{name}}",
   "newKnowledge.documentActionsUnavailable": "Für diese Wissensdatenbank sind noch keine Dokumentaktionen verfügbar.",
+  "newKnowledge.documentChunksEmpty": "Für diese Revision sind noch keine Abschnitte verfügbar.",
+  "newKnowledge.documentChunksLoadError": "Die Abschnitte dieser Revision konnten nicht geladen werden.",
+  "newKnowledge.documentChunksLoadMoreError": "Weitere Abschnitte konnten nicht geladen werden. Versuchen Sie es erneut.",
   "newKnowledge.documentColumn": "Dokument",
+  "newKnowledge.documentContentIncomplete": "Verbleibender Dokumentinhalt wird geladen…",
+  "newKnowledge.documentContents": "Inhalt",
+  "newKnowledge.documentFacts": "Dokumentdetails",
   "newKnowledge.documentFilterLabel": "Dokumente nach Status filtern",
+  "newKnowledge.documentLoadErrorDescription": "Dieses Dokument konnte nicht geladen werden. Versuchen Sie es erneut.",
+  "newKnowledge.documentLoadErrorTitle": "Dokument konnte nicht geladen werden",
+  "newKnowledge.documentNotFoundDescription": "Dieses Dokument wurde möglicherweise entfernt oder Sie haben keinen Zugriff.",
+  "newKnowledge.documentNotFoundTitle": "Dokument nicht gefunden",
+  "newKnowledge.documentOverviewDescription": "Das Kennzeichnen von Dokumentmetadaten ermöglicht der KI einen zeitnahen Zugriff und zeigt Nutzern die Quellen von Verweisen.",
   "newKnowledge.documentPermissionRestricted": "Ihre Workspace-Berechtigungen erlauben keine Dokument- oder Aufgabenaktionen.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Die Neuindizierung wurde angenommen, aber der Aufgabenstatus ist verzögert. Prüfe ihn vor einer erneuten Übermittlung.",
+  "newKnowledge.documentReindexFailed": "Die Neuindizierung ist fehlgeschlagen. Die letzte bereite Revision bleibt verfügbar.",
+  "newKnowledge.documentReindexProgress": "Neuindizierung · {{progress}} %",
+  "newKnowledge.documentRevision": "Versionsstand",
+  "newKnowledge.documentRevisionMissingDescription": "Dieses Dokument hat noch keine bereite Revision. Prüfen Sie es nach Abschluss der Verarbeitung erneut.",
+  "newKnowledge.documentRevisionMissingTitle": "Keine Revision verfügbar",
+  "newKnowledge.documentRevisionsLoadError": "Der Revisionsverlauf konnte nicht geladen werden. Die aktuelle Revision bleibt verfügbar.",
   "newKnowledge.documentStatus.disabled": "Deaktiviert",
   "newKnowledge.documentStatus.failed": "Fehlgeschlagen",
   "newKnowledge.documentStatus.processing": "Verarbeitung",
   "newKnowledge.documentStatus.queued": "In der Warteschlange",
   "newKnowledge.documentStatus.ready": "Bereit",
+  "newKnowledge.documentTaskLookupIncomplete": "Weitere Aufgabenverläufe sind verfügbar. Prüfe weiter, um den Status dieses Dokuments zu finden.",
   "newKnowledge.documentUploadExclusion.batchLimit": "Maximale Batchgröße überschritten",
   "newKnowledge.documentUploadExclusion.countLimit": "Maximale Dateianzahl überschritten",
   "newKnowledge.documentUploadExclusion.fileSize": "Datei ist zu groß",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— Dokumente",
   "newKnowledge.downloadDocuments": "Herunterladen",
   "newKnowledge.editSource": "Bearbeiten",
+  "newKnowledge.emptyChunk": "Leerer Abschnitt",
   "newKnowledge.emptyDescription": "Fügen Sie Ihre Dokumente hinzu, damit Agents sie direkt lesen können — ohne eine Indizierung einzurichten.",
   "newKnowledge.emptyTitle": "Wissensdatenbanken intelligenter aufbauen",
   "newKnowledge.errorDescription": "Die neuen Wissensdatenbanken konnten nicht geladen werden. Versuchen Sie es erneut.",
   "newKnowledge.errorTitle": "Etwas ist schiefgelaufen",
+  "newKnowledge.fileSize": "Dateigröße",
   "newKnowledge.filtersUnavailable": "Dieser Filter wird verfügbar, sobald KnowledgeFS Metadaten bereitstellt.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl ist im Anbieterkatalog für diesen Arbeitsbereich nicht verfügbar.",
   "newKnowledge.gotIt": "Verstanden",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Lernen Sie die neue Wissensdatenbank kennen ✨",
   "newKnowledge.illustrationHeadline": "Verbinde deine Inhalte einmal – und jede App antwortet mit dem neuesten Wissen.",
   "newKnowledge.includeSubpages": "Unterseiten einbeziehen",
+  "newKnowledge.indexInformation": "Indexinformationen",
   "newKnowledge.interruptTask": "Unterbrechen",
   "newKnowledge.invalidRootUrl": "Gib eine gültige http(s)-URL ein.",
   "newKnowledge.keepEditing": "Weiter bearbeiten",
+  "newKnowledge.lastIndexed": "Zuletzt indexiert",
   "newKnowledge.lastReadyRevisionHint": "Eine fehlgeschlagene Verarbeitung unterbricht nie den Abruf – die letzte fertige Revision bleibt im Inhaltsindex verfügbar.",
   "newKnowledge.lastSyncColumn": "Letzte Synchronisierung",
   "newKnowledge.learnMore": "Mehr erfahren",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Unvollständige Einrichtung verlassen?",
   "newKnowledge.legacy": "Legacy",
   "newKnowledge.loadMore": "Mehr laden",
+  "newKnowledge.loadMoreRevisions": "Ältere Revisionen laden",
   "newKnowledge.loadingSyncPolicy": "Synchronisierungsrichtlinie wird geladen",
   "newKnowledge.manualUpload": "Manueller Upload",
   "newKnowledge.maxPages": "Maximale Seitenzahl",
   "newKnowledge.metadata": "Metadaten",
+  "newKnowledge.mimeType": "Dateityp",
   "newKnowledge.moreProviders": "Weitere Anbieter",
   "newKnowledge.name": "Wissensname",
   "newKnowledge.namePlaceholder": "z.B. Kundendiensthandbuch",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Verbinden Sie Notion, um Seiten auszuwählen und synchron zu halten.",
   "newKnowledge.onlineDocuments": "Online-Dokumente",
   "newKnowledge.onlineDrive": "Online-Laufwerk",
+  "newKnowledge.overview": "Übersicht",
   "newKnowledge.pagesAppearDescription": "Crawle die Website, um zu prüfen, welche Seiten hinzugefügt werden.",
   "newKnowledge.pagesAppearTitle": "Seiten werden hier angezeigt",
   "newKnowledge.pagesCrawled": "{{count}} Seiten unter {{host}} gecrawlt",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} ist nicht konfiguriert",
   "newKnowledge.providerNotConfiguredDescription": "Fügen Sie einen API-Schlüssel oder eine Endpunkt-URL hinzu, um Websites mit {{provider}} zu crawlen.",
   "newKnowledge.providerUnavailable": "Dieser Anbieter ist nicht verfügbar.",
+  "newKnowledge.quality": "Qualität",
   "newKnowledge.reCrawl": "Erneut crawlen",
   "newKnowledge.readOnlyEmpty": "Bitten Sie einen Arbeitsbereich-Editor, die erste Wissensdatenbank zu erstellen.",
   "newKnowledge.refreshConnectionStatus": "Status aktualisieren",
   "newKnowledge.refreshingConnection": "Erfrischend…",
+  "newKnowledge.reindexDocument": "Neu indizieren",
   "newKnowledge.reindexDocuments": "Neu indizieren",
   "newKnowledge.removeSource": "Quelle entfernen",
+  "newKnowledge.retrievalCount": "Anzahl der Abrufe",
   "newKnowledge.retryCrawl": "Crawl wiederholen",
   "newKnowledge.retryProviderLoad": "Wiederholen",
+  "newKnowledge.retryReindexDocument": "Erneut neu indizieren",
   "newKnowledge.retrySyncPolicy": "Synchronisierungsrichtlinie erneut laden",
   "newKnowledge.retryTask": "Versuchen Sie es noch einmal",
+  "newKnowledge.revisionState.active": "Aktiv",
+  "newKnowledge.revisionState.candidate": "In Verarbeitung",
+  "newKnowledge.revisionState.failed": "Fehlgeschlagen",
+  "newKnowledge.revisionState.superseded": "Vorherige",
   "newKnowledge.rootUrl": "Stamm-URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Dieser Abschnitt wird im nächsten Einrichtungsschritt verfügbar.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Alle auswählen",
   "newKnowledge.selectAllDocuments": "Wählen Sie alle Dokumente aus",
   "newKnowledge.selectAllSources": "Alle Quellen auswählen",
+  "newKnowledge.selectChunk": "Wählen Sie einen Abschnitt aus, um seinen Inhalt zu prüfen.",
   "newKnowledge.selectFilesAndFolders": "Dateien und Ordner zum Synchronisieren auswählen",
   "newKnowledge.skippedFailed": "Übersprungen (fehlgeschlagen)",
   "newKnowledge.skippedOffDomain": "Übersprungen (außerhalb der Domain)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Aufgaben",
   "newKnowledge.tasksErrorDescription": "Wir konnten keine Hintergrundaufgaben laden. Versuchen Sie es erneut.",
   "newKnowledge.tasksWithAttention": "Aufgaben, {{count}} erfordern Aufmerksamkeit",
+  "newKnowledge.tokenCount": "Token",
   "newKnowledge.unavailableDescription": "KnowledgeFS ist für diesen Arbeitsbereich derzeit nicht verfügbar.",
   "newKnowledge.unavailableTitle": "Neues Wissen ist nicht verfügbar",
   "newKnowledge.updated": "Aktualisiert am {{date}}",
+  "newKnowledge.updatedAt": "Zuletzt aktualisiert",
   "newKnowledge.updatedColumn": "Aktualisiert",
   "newKnowledge.uploadCharactersUnavailable": "Zeichen: —",
   "newKnowledge.uploadDocuments": "Dokumente hochladen",

web/i18n/en-US/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Adjust & re-crawl",
   "newKnowledge.allDocumentStatuses": "All status",
   "newKnowledge.allSources": "All sources",
+  "newKnowledge.apiAgentAccess": "API & Agent Access",
   "newKnowledge.appsUnavailable": "— apps",
   "newKnowledge.authKind.api-key": "API key",
   "newKnowledge.authKind.endpoint": "Endpoint",
   "newKnowledge.authenticationMethod": "Authentication method",
+  "newKnowledge.averageChunkLength": "Average chunk length",
   "newKnowledge.backToList": "Back to knowledge bases",
   "newKnowledge.backgroundTasks": "Background tasks",
   "newKnowledge.backgroundTasksDescription": "Document adds, source syncs, and re-index jobs.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Bulk document actions",
   "newKnowledge.cancelAddSource": "Cancel",
   "newKnowledge.cardType": "Knowledge space",
+  "newKnowledge.characterCount": "Characters",
+  "newKnowledge.checkReindexStatus": "Check re-index status",
+  "newKnowledge.chunkCount": "Chunks",
+  "newKnowledge.chunkHeading": "Chunk {{position}}",
+  "newKnowledge.chunkLocation": "Position {{position}} in this revision",
   "newKnowledge.clearDocumentSelection": "Clear document selection",
   "newKnowledge.configureProvider": "Configure {{provider}}",
   "newKnowledge.connectNotion": "Connect Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Refresh the connection before adding a website source.",
   "newKnowledge.connectionProvisioning": "{{provider}} is connecting",
   "newKnowledge.connectionRefreshFailed": "We couldn't refresh this connection. Try again.",
+  "newKnowledge.continueCheckingTaskStatus": "Continue checking task status",
   "newKnowledge.crawlAndPreview": "Crawl & preview",
   "newKnowledge.crawlFailed": "Couldn't crawl {{host}}",
   "newKnowledge.crawlFailed403": "The site returned 403 — it may block crawlers or require authentication. Check the URL, adjust crawl options, or try another provider.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "We couldn't create this knowledge base. Check your access and try again.",
   "newKnowledge.createIllustrationTitle": "Connect your content once — every app answers with the freshest knowledge.",
   "newKnowledge.createTitle": "Create Knowledge",
+  "newKnowledge.createdAt": "Created",
   "newKnowledge.creators": "Creators",
   "newKnowledge.customIntervalHours": "Custom interval (hours)",
   "newKnowledge.customIntervalInvalid": "Enter a whole number from 1 to 720 hours.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Discard this source draft?",
   "newKnowledge.documentActions": "Actions for {{name}}",
   "newKnowledge.documentActionsUnavailable": "Document actions aren't available for this knowledge base yet.",
+  "newKnowledge.documentChunksEmpty": "No chunks are available for this revision yet.",
+  "newKnowledge.documentChunksLoadError": "We couldn't load chunks for this revision.",
+  "newKnowledge.documentChunksLoadMoreError": "We couldn't load more chunks. Try again.",
   "newKnowledge.documentColumn": "Document",
+  "newKnowledge.documentContentIncomplete": "Loading the remaining document content…",
+  "newKnowledge.documentContents": "Contents",
+  "newKnowledge.documentFacts": "Document details",
   "newKnowledge.documentFilterLabel": "Filter documents by status",
+  "newKnowledge.documentLoadErrorDescription": "We couldn't load this document. Try again.",
+  "newKnowledge.documentLoadErrorTitle": "Document couldn't load",
+  "newKnowledge.documentNotFoundDescription": "This document may have been removed, or you may not have access.",
+  "newKnowledge.documentNotFoundTitle": "Document not found",
+  "newKnowledge.documentOverviewDescription": "Labeling metadata for documents allows AI to access them in a timely manner and exposes the source of references for users.",
   "newKnowledge.documentPermissionRestricted": "Your workspace permissions don't allow document or task actions.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Re-indexing was accepted, but its task status is delayed. Check again before submitting another re-index.",
+  "newKnowledge.documentReindexFailed": "Re-indexing failed. The last ready revision remains available.",
+  "newKnowledge.documentReindexProgress": "Re-indexing · {{progress}}%",
+  "newKnowledge.documentRevision": "Revision",
+  "newKnowledge.documentRevisionMissingDescription": "This document doesn't have a ready revision yet. Check back after processing finishes.",
+  "newKnowledge.documentRevisionMissingTitle": "No revision available",
+  "newKnowledge.documentRevisionsLoadError": "We couldn't load revision history. The current revision remains available.",
   "newKnowledge.documentStatus.disabled": "Disabled",
   "newKnowledge.documentStatus.failed": "Failed",
   "newKnowledge.documentStatus.processing": "Processing",
   "newKnowledge.documentStatus.queued": "Queued",
   "newKnowledge.documentStatus.ready": "Ready",
+  "newKnowledge.documentTaskLookupIncomplete": "More task history is available. Continue checking to find this document's status.",
   "newKnowledge.documentUploadExclusion.batchLimit": "batch size limit exceeded",
   "newKnowledge.documentUploadExclusion.countLimit": "file count limit exceeded",
   "newKnowledge.documentUploadExclusion.fileSize": "file is too large",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— documents",
   "newKnowledge.downloadDocuments": "Download",
   "newKnowledge.editSource": "Edit",
+  "newKnowledge.emptyChunk": "Empty chunk",
   "newKnowledge.emptyDescription": "Add your documents and agents can read them directly — no indexing to configure.",
   "newKnowledge.emptyTitle": "A smarter way to build knowledge bases",
   "newKnowledge.errorDescription": "We couldn't load your new knowledge bases. Try again.",
   "newKnowledge.errorTitle": "Something went wrong",
+  "newKnowledge.fileSize": "File size",
   "newKnowledge.filtersUnavailable": "This filter will become available when KnowledgeFS exposes its metadata.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl isn't available in the provider catalog for this workspace.",
   "newKnowledge.gotIt": "Got it",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Meet the new Knowledge Base ✨",
   "newKnowledge.illustrationHeadline": "Connect your content once — every app answers with the freshest knowledge.",
   "newKnowledge.includeSubpages": "Include sub-pages",
+  "newKnowledge.indexInformation": "Index information",
   "newKnowledge.interruptTask": "Interrupt",
   "newKnowledge.invalidRootUrl": "Enter a valid http(s) URL.",
   "newKnowledge.keepEditing": "Keep editing",
+  "newKnowledge.lastIndexed": "Last indexed",
   "newKnowledge.lastReadyRevisionHint": "Failed processing never interrupts retrieval — the last ready revision stays available in the content index.",
   "newKnowledge.lastSyncColumn": "Last sync",
   "newKnowledge.learnMore": "Learn more",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Leave incomplete setup?",
   "newKnowledge.legacy": "Legacy",
   "newKnowledge.loadMore": "Load more",
+  "newKnowledge.loadMoreRevisions": "Load older revisions",
   "newKnowledge.loadingSyncPolicy": "Loading sync policy",
   "newKnowledge.manualUpload": "Manual upload",
   "newKnowledge.maxPages": "Maximum pages",
-  "newKnowledge.metadata": "Meta Data",
+  "newKnowledge.metadata": "Metadata",
+  "newKnowledge.mimeType": "File type",
   "newKnowledge.moreProviders": "More providers",
   "newKnowledge.name": "Knowledge name",
   "newKnowledge.namePlaceholder": "e.g. Customer Support Handbook",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Connect Notion to choose pages and keep them synchronized.",
   "newKnowledge.onlineDocuments": "Online documents",
   "newKnowledge.onlineDrive": "Online drive",
+  "newKnowledge.overview": "Overview",
   "newKnowledge.pagesAppearDescription": "Crawl the site to review which pages get added.",
   "newKnowledge.pagesAppearTitle": "Pages will appear here",
   "newKnowledge.pagesCrawled": "{{count}} pages crawled at {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} is not configured",
   "newKnowledge.providerNotConfiguredDescription": "Add an API key or endpoint URL to crawl websites with {{provider}}.",
   "newKnowledge.providerUnavailable": "This provider is unavailable.",
+  "newKnowledge.quality": "Quality",
   "newKnowledge.reCrawl": "Re-crawl",
   "newKnowledge.readOnlyEmpty": "Ask a workspace editor to create the first knowledge base.",
   "newKnowledge.refreshConnectionStatus": "Refresh status",
   "newKnowledge.refreshingConnection": "Refreshing…",
+  "newKnowledge.reindexDocument": "Re-index",
   "newKnowledge.reindexDocuments": "Re-index",
   "newKnowledge.removeSource": "Remove source",
+  "newKnowledge.retrievalCount": "Retrieval count",
   "newKnowledge.retryCrawl": "Retry crawl",
   "newKnowledge.retryProviderLoad": "Retry",
+  "newKnowledge.retryReindexDocument": "Re-index again",
   "newKnowledge.retrySyncPolicy": "Retry sync policy",
   "newKnowledge.retryTask": "Retry",
+  "newKnowledge.revisionState.active": "Active",
+  "newKnowledge.revisionState.candidate": "Processing",
+  "newKnowledge.revisionState.failed": "Failed",
+  "newKnowledge.revisionState.superseded": "Previous",
   "newKnowledge.rootUrl": "Root URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "This section will become available in the next setup step.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Select all",
   "newKnowledge.selectAllDocuments": "Select all documents",
   "newKnowledge.selectAllSources": "Select all sources",
+  "newKnowledge.selectChunk": "Select a chunk to inspect its content.",
   "newKnowledge.selectFilesAndFolders": "Select files & folders to sync",
   "newKnowledge.skippedFailed": "Skipped (failed)",
   "newKnowledge.skippedOffDomain": "Skipped (off-domain)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Tasks",
   "newKnowledge.tasksErrorDescription": "We couldn't load background tasks. Try again.",
   "newKnowledge.tasksWithAttention": "Tasks, {{count}} need attention",
+  "newKnowledge.tokenCount": "Tokens",
   "newKnowledge.unavailableDescription": "KnowledgeFS isn't available for this workspace right now.",
   "newKnowledge.unavailableTitle": "New Knowledge is unavailable",
   "newKnowledge.updated": "Updated {{date}}",
+  "newKnowledge.updatedAt": "Last updated",
   "newKnowledge.updatedColumn": "Updated",
   "newKnowledge.uploadCharactersUnavailable": "Characters: —",
   "newKnowledge.uploadDocuments": "Upload documents",

web/i18n/es-ES/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Ajustar y volver a rastrear",
   "newKnowledge.allDocumentStatuses": "Todo el estado",
   "newKnowledge.allSources": "Todas las fuentes",
+  "newKnowledge.apiAgentAccess": "Acceso a API y agentes",
   "newKnowledge.appsUnavailable": "— aplicaciones",
   "newKnowledge.authKind.api-key": "Clave API",
   "newKnowledge.authKind.endpoint": "Punto final",
   "newKnowledge.authenticationMethod": "Método de autenticación",
+  "newKnowledge.averageChunkLength": "Longitud media del fragmento",
   "newKnowledge.backToList": "Volver a las bases de conocimiento",
   "newKnowledge.backgroundTasks": "Tareas en segundo plano",
   "newKnowledge.backgroundTasksDescription": "Agrega documentos, sincroniza fuentes y vuelve a indexar trabajos.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Acciones de documentos masivos",
   "newKnowledge.cancelAddSource": "Cancelar",
   "newKnowledge.cardType": "Espacio de conocimiento",
+  "newKnowledge.characterCount": "Caracteres",
+  "newKnowledge.checkReindexStatus": "Comprobar estado de reindexación",
+  "newKnowledge.chunkCount": "Fragmentos",
+  "newKnowledge.chunkHeading": "Fragmento {{position}}",
+  "newKnowledge.chunkLocation": "Posición {{position}} en esta revisión",
   "newKnowledge.clearDocumentSelection": "Borrar selección de documentos",
   "newKnowledge.configureProvider": "Configurar {{provider}}",
   "newKnowledge.connectNotion": "Conectar Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Actualiza la conexión antes de agregar una fuente de sitio web.",
   "newKnowledge.connectionProvisioning": "{{provider}} se está conectando",
   "newKnowledge.connectionRefreshFailed": "No pudimos actualizar esta conexión. Intentar otra vez.",
+  "newKnowledge.continueCheckingTaskStatus": "Seguir comprobando el estado",
   "newKnowledge.crawlAndPreview": "Rastreo y vista previa",
   "newKnowledge.crawlFailed": "No se pudo rastrear {{host}}",
   "newKnowledge.crawlFailed403": "El sitio devolvió un error 403; puede que bloquee rastreadores o requiera autenticación. Comprueba la URL, ajusta las opciones de rastreo o prueba otro proveedor.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "No pudimos crear esta base de conocimientos. Comprueba tu acceso y vuelve a intentarlo.",
   "newKnowledge.createIllustrationTitle": "Conecta tu contenido una vez: cada aplicación responderá con el conocimiento más reciente.",
   "newKnowledge.createTitle": "Crear conocimiento",
+  "newKnowledge.createdAt": "Creado",
   "newKnowledge.creators": "Creadores",
   "newKnowledge.customIntervalHours": "Intervalo personalizado (horas)",
   "newKnowledge.customIntervalInvalid": "Introduce un número entero de 1 a 720 horas.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "¿Descartar este borrador de fuente?",
   "newKnowledge.documentActions": "Acciones para {{name}}",
   "newKnowledge.documentActionsUnavailable": "Las acciones de documentos aún no están disponibles para esta base de conocimientos.",
+  "newKnowledge.documentChunksEmpty": "Aún no hay fragmentos disponibles para esta revisión.",
+  "newKnowledge.documentChunksLoadError": "No se pudieron cargar los fragmentos de esta revisión.",
+  "newKnowledge.documentChunksLoadMoreError": "No se pudieron cargar más fragmentos. Inténtalo de nuevo.",
   "newKnowledge.documentColumn": "Documento",
+  "newKnowledge.documentContentIncomplete": "Cargando el contenido restante del documento…",
+  "newKnowledge.documentContents": "Contenido",
+  "newKnowledge.documentFacts": "Detalles del documento",
   "newKnowledge.documentFilterLabel": "Filtrar documentos por estado",
+  "newKnowledge.documentLoadErrorDescription": "No se pudo cargar este documento. Inténtalo de nuevo.",
+  "newKnowledge.documentLoadErrorTitle": "No se pudo cargar el documento",
+  "newKnowledge.documentNotFoundDescription": "Es posible que este documento se haya eliminado o que no tengas acceso.",
+  "newKnowledge.documentNotFoundTitle": "Documento no encontrado",
+  "newKnowledge.documentOverviewDescription": "Etiquetar los metadatos de los documentos permite que la IA acceda a ellos a tiempo y muestra a los usuarios las fuentes de las referencias.",
   "newKnowledge.documentPermissionRestricted": "Los permisos de tu espacio de trabajo no permiten acciones sobre documentos o tareas.",
+  "newKnowledge.documentReindexConfirmationDelayed": "La reindexación fue aceptada, pero el estado de la tarea está retrasado. Compruébalo antes de volver a enviarla.",
+  "newKnowledge.documentReindexFailed": "La reindexación falló. La última revisión lista sigue disponible.",
+  "newKnowledge.documentReindexProgress": "Reindexando · {{progress}} %",
+  "newKnowledge.documentRevision": "Revisión",
+  "newKnowledge.documentRevisionMissingDescription": "Este documento aún no tiene una revisión lista. Vuelve cuando termine el procesamiento.",
+  "newKnowledge.documentRevisionMissingTitle": "No hay ninguna revisión disponible",
+  "newKnowledge.documentRevisionsLoadError": "No se pudo cargar el historial de revisiones. La revisión actual sigue disponible.",
   "newKnowledge.documentStatus.disabled": "Desactivado",
   "newKnowledge.documentStatus.failed": "Fallido",
   "newKnowledge.documentStatus.processing": "Procesamiento",
   "newKnowledge.documentStatus.queued": "En cola",
   "newKnowledge.documentStatus.ready": "Listo",
+  "newKnowledge.documentTaskLookupIncomplete": "Hay más historial de tareas disponible. Sigue comprobando para encontrar el estado de este documento.",
   "newKnowledge.documentUploadExclusion.batchLimit": "se superó el límite de tamaño del lote",
   "newKnowledge.documentUploadExclusion.countLimit": "se superó el límite de archivos",
   "newKnowledge.documentUploadExclusion.fileSize": "el archivo es demasiado grande",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— documentos",
   "newKnowledge.downloadDocuments": "Descargar",
   "newKnowledge.editSource": "Editar",
+  "newKnowledge.emptyChunk": "Fragmento vacío",
   "newKnowledge.emptyDescription": "Añade tus documentos y los agentes podrán leerlos directamente, sin configurar la indexación.",
   "newKnowledge.emptyTitle": "Una forma más inteligente de crear bases de conocimiento",
   "newKnowledge.errorDescription": "No pudimos cargar tus nuevas bases de conocimiento. Inténtalo de nuevo.",
   "newKnowledge.errorTitle": "Algo salió mal",
+  "newKnowledge.fileSize": "Tamaño del archivo",
   "newKnowledge.filtersUnavailable": "Este filtro estará disponible cuando KnowledgeFS exponga sus metadatos.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl no está disponible en el catálogo de proveedores para este espacio de trabajo.",
   "newKnowledge.gotIt": "Entendido",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Conoce la nueva base de conocimiento ✨",
   "newKnowledge.illustrationHeadline": "Conecta tu contenido una vez: cada aplicación responderá con el conocimiento más reciente.",
   "newKnowledge.includeSubpages": "Incluir subpáginas",
+  "newKnowledge.indexInformation": "Información del índice",
   "newKnowledge.interruptTask": "Interrumpir",
   "newKnowledge.invalidRootUrl": "Introduce una URL http(s) válida.",
   "newKnowledge.keepEditing": "Seguir editando",
+  "newKnowledge.lastIndexed": "Última indexación",
   "newKnowledge.lastReadyRevisionHint": "El procesamiento fallido nunca interrumpe la recuperación: la última revisión lista permanece disponible en el índice de contenido.",
   "newKnowledge.lastSyncColumn": "Última sincronización",
   "newKnowledge.learnMore": "Más información",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "¿Salir de la configuración incompleta?",
   "newKnowledge.legacy": "Anterior",
   "newKnowledge.loadMore": "Cargar más",
+  "newKnowledge.loadMoreRevisions": "Cargar revisiones anteriores",
   "newKnowledge.loadingSyncPolicy": "Cargando la política de sincronización",
   "newKnowledge.manualUpload": "Carga manual",
   "newKnowledge.maxPages": "Máximo de páginas",
   "newKnowledge.metadata": "Metadatos",
+  "newKnowledge.mimeType": "Tipo de archivo",
   "newKnowledge.moreProviders": "Más proveedores",
   "newKnowledge.name": "Nombre del conocimiento",
   "newKnowledge.namePlaceholder": "por ej. Manual de atención al cliente",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Conecta Notion para elegir páginas y mantenerlas sincronizadas.",
   "newKnowledge.onlineDocuments": "Documentos en línea",
   "newKnowledge.onlineDrive": "Unidad en línea",
+  "newKnowledge.overview": "Resumen",
   "newKnowledge.pagesAppearDescription": "Rastrea el sitio para revisar qué páginas se añadirán.",
   "newKnowledge.pagesAppearTitle": "Las páginas aparecerán aquí",
   "newKnowledge.pagesCrawled": "{{count}} páginas rastreadas en {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} no está configurado",
   "newKnowledge.providerNotConfiguredDescription": "Agregue una clave API o una URL de punto final para rastrear sitios web con {{provider}}.",
   "newKnowledge.providerUnavailable": "Este proveedor no está disponible.",
+  "newKnowledge.quality": "Calidad",
   "newKnowledge.reCrawl": "Volver a rastrear",
   "newKnowledge.readOnlyEmpty": "Pide a un editor del espacio de trabajo que cree la primera base de conocimiento.",
   "newKnowledge.refreshConnectionStatus": "Estado de actualización",
   "newKnowledge.refreshingConnection": "Refrescante…",
+  "newKnowledge.reindexDocument": "Reindexar",
   "newKnowledge.reindexDocuments": "Volver a indexar",
   "newKnowledge.removeSource": "Eliminar fuente",
+  "newKnowledge.retrievalCount": "Número de recuperaciones",
   "newKnowledge.retryCrawl": "Reintentar rastreo",
   "newKnowledge.retryProviderLoad": "Reintentar",
+  "newKnowledge.retryReindexDocument": "Reindexar de nuevo",
   "newKnowledge.retrySyncPolicy": "Reintentar la política de sincronización",
   "newKnowledge.retryTask": "Reintentar",
+  "newKnowledge.revisionState.active": "Activa",
+  "newKnowledge.revisionState.candidate": "Procesando",
+  "newKnowledge.revisionState.failed": "Fallida",
+  "newKnowledge.revisionState.superseded": "Anterior",
   "newKnowledge.rootUrl": "URL raíz",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Esta sección estará disponible en el siguiente paso de configuración.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Seleccionar todo",
   "newKnowledge.selectAllDocuments": "Seleccionar todos los documentos",
   "newKnowledge.selectAllSources": "Seleccionar todos los orígenes",
+  "newKnowledge.selectChunk": "Selecciona un fragmento para revisar su contenido.",
   "newKnowledge.selectFilesAndFolders": "Selecciona archivos y carpetas para sincronizar",
   "newKnowledge.skippedFailed": "Omitido (fallido)",
   "newKnowledge.skippedOffDomain": "Omitido (fuera del dominio)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Tareas",
   "newKnowledge.tasksErrorDescription": "No pudimos cargar tareas en segundo plano. Intentar otra vez.",
   "newKnowledge.tasksWithAttention": "Tareas, {{count}} necesitan atención",
+  "newKnowledge.tokenCount": "Unidades de token",
   "newKnowledge.unavailableDescription": "KnowledgeFS no está disponible para este espacio de trabajo ahora mismo.",
   "newKnowledge.unavailableTitle": "El nuevo conocimiento no está disponible",
   "newKnowledge.updated": "Actualizado el {{date}}",
+  "newKnowledge.updatedAt": "Última actualización",
   "newKnowledge.updatedColumn": "Actualizado",
   "newKnowledge.uploadCharactersUnavailable": "Caracteres: —",
   "newKnowledge.uploadDocuments": "Subir documentos",

web/i18n/fa-IR/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "تنظیم و پیمایش دوباره",
   "newKnowledge.allDocumentStatuses": "همه وضعیت",
   "newKnowledge.allSources": "همه منابع",
+  "newKnowledge.apiAgentAccess": "دسترسی API و عامل",
   "newKnowledge.appsUnavailable": "— برنامه",
   "newKnowledge.authKind.api-key": "کلید API",
   "newKnowledge.authKind.endpoint": "نقطه پایانی",
   "newKnowledge.authenticationMethod": "روش احراز هویت",
+  "newKnowledge.averageChunkLength": "میانگین طول قطعه",
   "newKnowledge.backToList": "بازگشت به پایگاه های دانش",
   "newKnowledge.backgroundTasks": "وظایف پس زمینه",
   "newKnowledge.backgroundTasksDescription": "افزودن اسناد، همگام سازی منبع، و فهرست مجدد مشاغل.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "اقدامات سند انبوه",
   "newKnowledge.cancelAddSource": "لغو",
   "newKnowledge.cardType": "فضای دانش",
+  "newKnowledge.characterCount": "نویسه‌ها",
+  "newKnowledge.checkReindexStatus": "بررسی وضعیت بازفهرست‌سازی",
+  "newKnowledge.chunkCount": "قطعه‌ها",
+  "newKnowledge.chunkHeading": "قطعه {{position}}",
+  "newKnowledge.chunkLocation": "موقعیت {{position}} در این بازبینی",
   "newKnowledge.clearDocumentSelection": "انتخاب سند را پاک کنید",
   "newKnowledge.configureProvider": "{{provider}} را پیکربندی کنید",
   "newKnowledge.connectNotion": "اتصال Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "قبل از افزودن منبع وب سایت، اتصال را تازه کنید.",
   "newKnowledge.connectionProvisioning": "{{provider}} در حال اتصال است",
   "newKnowledge.connectionRefreshFailed": "ما نتوانستیم این اتصال را بازخوانی کنیم. دوباره امتحان کنید.",
+  "newKnowledge.continueCheckingTaskStatus": "ادامه بررسی وضعیت کار",
   "newKnowledge.crawlAndPreview": "خزیدن و پیش‌نمایش",
   "newKnowledge.crawlFailed": "پیمایش {{host}} ممکن نشد",
   "newKnowledge.crawlFailed403": "سایت خطای 403 برگرداند؛ ممکن است خزنده‌ها را مسدود کند یا به احراز هویت نیاز داشته باشد. نشانی را بررسی کنید، گزینه‌های پیمایش را تغییر دهید یا ارائه‌دهندهٔ دیگری را امتحان کنید.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "ما نتوانستیم این پایگاه دانش را ایجاد کنیم. دسترسی خود را بررسی کنید و دوباره امتحان کنید.",
   "newKnowledge.createIllustrationTitle": "محتوای خود را یک‌بار متصل کنید — هر برنامه با تازه‌ترین دانش پاسخ می‌دهد.",
   "newKnowledge.createTitle": "ایجاد دانش",
+  "newKnowledge.createdAt": "ایجادشده",
   "newKnowledge.creators": "ایجادکنندگان",
   "newKnowledge.customIntervalHours": "بازه سفارشی (ساعت)",
   "newKnowledge.customIntervalInvalid": "یک عدد صحیح بین ۱ تا ۷۲۰ ساعت وارد کنید.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "این پیش‌نویس منبع حذف شود؟",
   "newKnowledge.documentActions": "اقدامات برای {{name}}",
   "newKnowledge.documentActionsUnavailable": "اقدامات سند هنوز برای این پایگاه دانش در دسترس نیست.",
+  "newKnowledge.documentChunksEmpty": "هنوز قطعه‌ای برای این بازبینی موجود نیست.",
+  "newKnowledge.documentChunksLoadError": "قطعه‌های این بازبینی بارگیری نشد.",
+  "newKnowledge.documentChunksLoadMoreError": "قطعه‌های بیشتری بارگیری نشد. دوباره تلاش کنید.",
   "newKnowledge.documentColumn": "سند",
+  "newKnowledge.documentContentIncomplete": "در حال بارگذاری ادامه محتوای سند…",
+  "newKnowledge.documentContents": "محتوا",
+  "newKnowledge.documentFacts": "جزئیات سند",
   "newKnowledge.documentFilterLabel": "اسناد را بر اساس وضعیت فیلتر کنید",
+  "newKnowledge.documentLoadErrorDescription": "این سند بارگیری نشد. دوباره تلاش کنید.",
+  "newKnowledge.documentLoadErrorTitle": "سند بارگیری نشد",
+  "newKnowledge.documentNotFoundDescription": "ممکن است این سند حذف شده باشد یا شما دسترسی نداشته باشید.",
+  "newKnowledge.documentNotFoundTitle": "سند پیدا نشد",
+  "newKnowledge.documentOverviewDescription": "برچسب‌گذاری فرادادهٔ اسناد به هوش مصنوعی امکان می‌دهد به‌موقع به آن‌ها دسترسی پیدا کند و منبع ارجاعات را به کاربران نشان می‌دهد.",
   "newKnowledge.documentPermissionRestricted": "مجوزهای فضای کاری شما اجازه انجام عملیات روی اسناد یا وظایف را نمی‌دهد.",
+  "newKnowledge.documentReindexConfirmationDelayed": "بازفهرست‌سازی پذیرفته شد، اما وضعیت کار با تأخیر نمایش داده می‌شود. پیش از ارسال دوباره آن را بررسی کنید.",
+  "newKnowledge.documentReindexFailed": "نمایه‌سازی دوباره ناموفق بود. آخرین بازبینی آماده همچنان در دسترس است.",
+  "newKnowledge.documentReindexProgress": "در حال نمایه‌سازی دوباره · {{progress}}٪",
+  "newKnowledge.documentRevision": "بازبینی",
+  "newKnowledge.documentRevisionMissingDescription": "این سند هنوز بازبینی آماده‌ای ندارد. پس از پایان پردازش دوباره بررسی کنید.",
+  "newKnowledge.documentRevisionMissingTitle": "هیچ بازبینی در دسترس نیست",
+  "newKnowledge.documentRevisionsLoadError": "تاریخچه بازبینی بارگیری نشد. بازبینی فعلی همچنان در دسترس است.",
   "newKnowledge.documentStatus.disabled": "غیرفعال",
   "newKnowledge.documentStatus.failed": "شکست خورد",
   "newKnowledge.documentStatus.processing": "در حال پردازش",
   "newKnowledge.documentStatus.queued": "در صف",
   "newKnowledge.documentStatus.ready": "آماده است",
+  "newKnowledge.documentTaskLookupIncomplete": "سابقه کار بیشتری موجود است. برای یافتن وضعیت این سند بررسی را ادامه دهید.",
   "newKnowledge.documentUploadExclusion.batchLimit": "محدودیت اندازه دسته رد شده است",
   "newKnowledge.documentUploadExclusion.countLimit": "محدودیت تعداد فایل رد شده است",
   "newKnowledge.documentUploadExclusion.fileSize": "فایل بیش از حد بزرگ است",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— سند",
   "newKnowledge.downloadDocuments": "دانلود کنید",
   "newKnowledge.editSource": "ویرایش",
+  "newKnowledge.emptyChunk": "قطعه خالی",
   "newKnowledge.emptyDescription": "اسناد خود را اضافه کنید تا عامل‌ها بتوانند مستقیماً آن‌ها را بخوانند — بدون نیاز به تنظیم نمایه‌سازی.",
   "newKnowledge.emptyTitle": "روشی هوشمندتر برای ساخت پایگاه‌های دانش",
   "newKnowledge.errorDescription": "پایگاه‌های دانش جدید بارگذاری نشدند. دوباره تلاش کنید.",
   "newKnowledge.errorTitle": "مشکلی پیش آمد",
+  "newKnowledge.fileSize": "اندازه فایل",
   "newKnowledge.filtersUnavailable": "این فیلتر پس از ارائه فراداده توسط KnowledgeFS در دسترس خواهد بود.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl در کاتالوگ ارائه دهنده برای این فضای کاری موجود نیست.",
   "newKnowledge.gotIt": "متوجه شدم",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "با پایگاه دانش جدید آشنا شوید ✨",
   "newKnowledge.illustrationHeadline": "محتوای خود را یک‌بار متصل کنید تا هر برنامه با تازه‌ترین دانش پاسخ دهد.",
   "newKnowledge.includeSubpages": "شامل صفحه‌های فرعی",
+  "newKnowledge.indexInformation": "اطلاعات نمایه",
   "newKnowledge.interruptTask": "توقف",
   "newKnowledge.invalidRootUrl": "یک نشانی معتبر http(s) وارد کنید.",
   "newKnowledge.keepEditing": "ادامه ویرایش",
+  "newKnowledge.lastIndexed": "آخرین نمایه‌سازی",
   "newKnowledge.lastReadyRevisionHint": "پردازش ناموفق هرگز بازیابی را قطع نمی کند - آخرین نسخه آماده در فهرست محتوا در دسترس باقی می ماند.",
   "newKnowledge.lastSyncColumn": "آخرین همگام سازی",
   "newKnowledge.learnMore": "بیشتر بدانید",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "از راه‌اندازی ناتمام خارج می‌شوید؟",
   "newKnowledge.legacy": "قدیمی",
   "newKnowledge.loadMore": "بارگذاری بیشتر",
+  "newKnowledge.loadMoreRevisions": "بارگیری بازبینی‌های قدیمی‌تر",
   "newKnowledge.loadingSyncPolicy": "در حال بارگیری سیاست همگام‌سازی",
   "newKnowledge.manualUpload": "آپلود دستی",
   "newKnowledge.maxPages": "حداکثر صفحه‌ها",
   "newKnowledge.metadata": "متا دیتا",
+  "newKnowledge.mimeType": "نوع فایل",
   "newKnowledge.moreProviders": "ارائه‌دهندگان بیشتر",
   "newKnowledge.name": "نام دانش",
   "newKnowledge.namePlaceholder": "به عنوان مثال راهنمای پشتیبانی مشتری",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "برای انتخاب صفحه‌ها و همگام نگه‌داشتن آن‌ها، Notion را متصل کنید.",
   "newKnowledge.onlineDocuments": "اسناد آنلاین",
   "newKnowledge.onlineDrive": "درایو آنلاین",
+  "newKnowledge.overview": "نمای کلی",
   "newKnowledge.pagesAppearDescription": "سایت را پیمایش کنید تا صفحه‌هایی را که افزوده می‌شوند بررسی کنید.",
   "newKnowledge.pagesAppearTitle": "صفحه‌ها اینجا نمایش داده می‌شوند",
   "newKnowledge.pagesCrawled": "{{count}} صفحه در {{host}} پیمایش شد",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} پیکربندی نشده است",
   "newKnowledge.providerNotConfiguredDescription": "برای خزیدن وب‌سایت‌ها با {{provider}}، یک کلید API یا URL نقطه پایانی اضافه کنید.",
   "newKnowledge.providerUnavailable": "این ارائه دهنده در دسترس نیست.",
+  "newKnowledge.quality": "کیفیت",
   "newKnowledge.reCrawl": "پیمایش دوباره",
   "newKnowledge.readOnlyEmpty": "از یک ویرایشگر فضای کاری بخواهید اولین پایگاه دانش را ایجاد کند.",
   "newKnowledge.refreshConnectionStatus": "وضعیت بازخوانی",
   "newKnowledge.refreshingConnection": "تازه‌سازی…",
+  "newKnowledge.reindexDocument": "نمایه‌سازی دوباره",
   "newKnowledge.reindexDocuments": "فهرست مجدد",
   "newKnowledge.removeSource": "حذف منبع",
+  "newKnowledge.retrievalCount": "تعداد بازیابی",
   "newKnowledge.retryCrawl": "تلاش دوباره برای پیمایش",
   "newKnowledge.retryProviderLoad": "دوباره امتحان کنید",
+  "newKnowledge.retryReindexDocument": "بازفهرست‌سازی دوباره",
   "newKnowledge.retrySyncPolicy": "تلاش دوباره برای سیاست همگام‌سازی",
   "newKnowledge.retryTask": "دوباره امتحان کنید",
+  "newKnowledge.revisionState.active": "فعال",
+  "newKnowledge.revisionState.candidate": "در حال پردازش",
+  "newKnowledge.revisionState.failed": "ناموفق",
+  "newKnowledge.revisionState.superseded": "قبلی",
   "newKnowledge.rootUrl": "نشانی ریشه",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "این بخش در مرحله راه اندازی بعدی در دسترس خواهد بود.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "انتخاب همه",
   "newKnowledge.selectAllDocuments": "همه اسناد را انتخاب کنید",
   "newKnowledge.selectAllSources": "انتخاب همه منابع",
+  "newKnowledge.selectChunk": "یک قطعه را برای بررسی محتوای آن انتخاب کنید.",
   "newKnowledge.selectFilesAndFolders": "فایل‌ها و پوشه‌ها را برای همگام‌سازی انتخاب کنید",
   "newKnowledge.skippedFailed": "رد شد (ناموفق)",
   "newKnowledge.skippedOffDomain": "رد شد (خارج از دامنه)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "وظایف",
   "newKnowledge.tasksErrorDescription": "نمی‌توانیم وظایف پس‌زمینه را بارگیری کنیم. دوباره امتحان کنید.",
   "newKnowledge.tasksWithAttention": "وظایف، {{count}} نیاز به توجه دارد",
+  "newKnowledge.tokenCount": "توکن‌ها",
   "newKnowledge.unavailableDescription": "KnowledgeFS اکنون برای این فضای کاری در دسترس نیست.",
   "newKnowledge.unavailableTitle": "دانش جدید در دسترس نیست",
   "newKnowledge.updated": "به‌روزرسانی در {{date}}",
+  "newKnowledge.updatedAt": "آخرین به‌روزرسانی",
   "newKnowledge.updatedColumn": "به روز شد",
   "newKnowledge.uploadCharactersUnavailable": "نویسه‌ها: —",
   "newKnowledge.uploadDocuments": "اسناد را بارگذاری کنید",

web/i18n/fr-FR/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Ajuster et relancer l’exploration",
   "newKnowledge.allDocumentStatuses": "Tous les statuts",
   "newKnowledge.allSources": "Toutes les sources",
+  "newKnowledge.apiAgentAccess": "Accès API et agents",
   "newKnowledge.appsUnavailable": "— applications",
   "newKnowledge.authKind.api-key": "Clé API",
   "newKnowledge.authKind.endpoint": "Point de terminaison",
   "newKnowledge.authenticationMethod": "Méthode d'authentification",
+  "newKnowledge.averageChunkLength": "Longueur moyenne des segments",
   "newKnowledge.backToList": "Retour aux bases de connaissances",
   "newKnowledge.backgroundTasks": "Tâches en arrière-plan",
   "newKnowledge.backgroundTasksDescription": "Ajouts de documents, synchronisations de sources et tâches de réindexation.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Actions de documents en masse",
   "newKnowledge.cancelAddSource": "Annuler",
   "newKnowledge.cardType": "Espace de connaissances",
+  "newKnowledge.characterCount": "Caractères",
+  "newKnowledge.checkReindexStatus": "Vérifier l’état de réindexation",
+  "newKnowledge.chunkCount": "Segments",
+  "newKnowledge.chunkHeading": "Segment {{position}}",
+  "newKnowledge.chunkLocation": "Position {{position}} dans cette révision",
   "newKnowledge.clearDocumentSelection": "Effacer la sélection des documents",
   "newKnowledge.configureProvider": "Configurer {{provider}}",
   "newKnowledge.connectNotion": "Connecter Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Actualisez la connexion avant d'ajouter une source de site Web.",
   "newKnowledge.connectionProvisioning": "{{provider}} se connecte",
   "newKnowledge.connectionRefreshFailed": "Nous n'avons pas pu actualiser cette connexion. Essayer à nouveau.",
+  "newKnowledge.continueCheckingTaskStatus": "Continuer à vérifier l’état",
   "newKnowledge.crawlAndPreview": "Exploration et aperçu",
   "newKnowledge.crawlFailed": "Impossible d’explorer {{host}}",
   "newKnowledge.crawlFailed403": "Le site a renvoyé une erreur 403. Il bloque peut-être les robots d’exploration ou exige une authentification. Vérifiez l’URL, ajustez les options ou essayez un autre fournisseur.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Nous n'avons pas pu créer cette base de connaissances. Vérifiez votre accès et réessayez.",
   "newKnowledge.createIllustrationTitle": "Connectez votre contenu une fois — chaque application répond avec les connaissances les plus récentes.",
   "newKnowledge.createTitle": "Créer des connaissances",
+  "newKnowledge.createdAt": "Créé",
   "newKnowledge.creators": "Créateurs",
   "newKnowledge.customIntervalHours": "Intervalle personnalisé (heures)",
   "newKnowledge.customIntervalInvalid": "Saisissez un nombre entier compris entre 1 et 720 heures.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Abandonner ce brouillon de source ?",
   "newKnowledge.documentActions": "Actions pour {{name}}",
   "newKnowledge.documentActionsUnavailable": "Les actions sur les documents ne sont pas encore disponibles pour cette base de connaissances.",
+  "newKnowledge.documentChunksEmpty": "Aucun segment n’est encore disponible pour cette révision.",
+  "newKnowledge.documentChunksLoadError": "Impossible de charger les segments de cette révision.",
+  "newKnowledge.documentChunksLoadMoreError": "Impossible de charger davantage de segments. Réessayez.",
   "newKnowledge.documentColumn": "Document",
+  "newKnowledge.documentContentIncomplete": "Chargement du reste du document…",
+  "newKnowledge.documentContents": "Contenu",
+  "newKnowledge.documentFacts": "Détails du document",
   "newKnowledge.documentFilterLabel": "Filtrer les documents par statut",
+  "newKnowledge.documentLoadErrorDescription": "Impossible de charger ce document. Réessayez.",
+  "newKnowledge.documentLoadErrorTitle": "Impossible de charger le document",
+  "newKnowledge.documentNotFoundDescription": "Ce document a peut-être été supprimé ou vous n’y avez pas accès.",
+  "newKnowledge.documentNotFoundTitle": "Document introuvable",
+  "newKnowledge.documentOverviewDescription": "L’étiquetage des métadonnées des documents permet à l’IA d’y accéder rapidement et indique aux utilisateurs les sources des références.",
   "newKnowledge.documentPermissionRestricted": "Les autorisations de votre espace de travail ne permettent pas les actions sur les documents ou les tâches.",
+  "newKnowledge.documentReindexConfirmationDelayed": "La réindexation a été acceptée, mais l’état de la tâche est retardé. Vérifiez-le avant un nouvel envoi.",
+  "newKnowledge.documentReindexFailed": "La réindexation a échoué. La dernière révision prête reste disponible.",
+  "newKnowledge.documentReindexProgress": "Réindexation · {{progress}} %",
+  "newKnowledge.documentRevision": "Révision",
+  "newKnowledge.documentRevisionMissingDescription": "Ce document ne possède pas encore de révision prête. Revenez une fois le traitement terminé.",
+  "newKnowledge.documentRevisionMissingTitle": "Aucune révision disponible",
+  "newKnowledge.documentRevisionsLoadError": "Impossible de charger l’historique des révisions. La révision actuelle reste disponible.",
   "newKnowledge.documentStatus.disabled": "Désactivé",
   "newKnowledge.documentStatus.failed": "Échec",
   "newKnowledge.documentStatus.processing": "Traitement",
   "newKnowledge.documentStatus.queued": "En file d'attente",
   "newKnowledge.documentStatus.ready": "Prêt",
+  "newKnowledge.documentTaskLookupIncomplete": "Un historique supplémentaire est disponible. Continuez la vérification pour trouver l’état de ce document.",
   "newKnowledge.documentUploadExclusion.batchLimit": "limite de taille du lot dépassée",
   "newKnowledge.documentUploadExclusion.countLimit": "limite du nombre de fichiers dépassée",
   "newKnowledge.documentUploadExclusion.fileSize": "le fichier est trop volumineux",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— documents",
   "newKnowledge.downloadDocuments": "Télécharger",
   "newKnowledge.editSource": "Modifier",
+  "newKnowledge.emptyChunk": "Segment vide",
   "newKnowledge.emptyDescription": "Ajoutez vos documents et les agents pourront les lire directement, sans indexation à configurer.",
   "newKnowledge.emptyTitle": "Une façon plus intelligente de créer des bases de connaissances",
   "newKnowledge.errorDescription": "Impossible de charger vos nouvelles bases de connaissances. Réessayez.",
   "newKnowledge.errorTitle": "Une erreur s’est produite",
+  "newKnowledge.fileSize": "Taille du fichier",
   "newKnowledge.filtersUnavailable": "Ce filtre sera disponible lorsque KnowledgeFS exposera ses métadonnées.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl n'est pas disponible dans le catalogue des fournisseurs pour cet espace de travail.",
   "newKnowledge.gotIt": "Compris",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Découvrez la nouvelle base de connaissances ✨",
   "newKnowledge.illustrationHeadline": "Connectez votre contenu une fois : chaque application répond avec les connaissances les plus récentes.",
   "newKnowledge.includeSubpages": "Inclure les sous-pages",
+  "newKnowledge.indexInformation": "Informations d’indexation",
   "newKnowledge.interruptTask": "Interrompre",
   "newKnowledge.invalidRootUrl": "Saisissez une URL http(s) valide.",
   "newKnowledge.keepEditing": "Continuer la modification",
+  "newKnowledge.lastIndexed": "Dernière indexation",
   "newKnowledge.lastReadyRevisionHint": "Un traitement échoué n'interrompt jamais la récupération : la dernière révision prête reste disponible dans l'index de contenu.",
   "newKnowledge.lastSyncColumn": "Dernière synchronisation",
   "newKnowledge.learnMore": "En savoir plus",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Quitter la configuration incomplète ?",
   "newKnowledge.legacy": "Ancien",
   "newKnowledge.loadMore": "Charger plus",
+  "newKnowledge.loadMoreRevisions": "Charger les anciennes révisions",
   "newKnowledge.loadingSyncPolicy": "Chargement de la politique de synchronisation",
   "newKnowledge.manualUpload": "Téléchargement manuel",
   "newKnowledge.maxPages": "Nombre maximal de pages",
   "newKnowledge.metadata": "Métadonnées",
+  "newKnowledge.mimeType": "Type de fichier",
   "newKnowledge.moreProviders": "Plus de fournisseurs",
   "newKnowledge.name": "Nom de la connaissance",
   "newKnowledge.namePlaceholder": "par ex. Manuel de support client",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Connectez Notion pour choisir des pages et les maintenir synchronisées.",
   "newKnowledge.onlineDocuments": "Documents en ligne",
   "newKnowledge.onlineDrive": "Drive en ligne",
+  "newKnowledge.overview": "Vue d’ensemble",
   "newKnowledge.pagesAppearDescription": "Explorez le site pour vérifier les pages qui seront ajoutées.",
   "newKnowledge.pagesAppearTitle": "Les pages apparaîtront ici",
   "newKnowledge.pagesCrawled": "{{count}} pages explorées sur {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} n'est pas configuré",
   "newKnowledge.providerNotConfiguredDescription": "Ajoutez une clé API ou une URL de point de terminaison pour explorer les sites Web avec {{provider}}.",
   "newKnowledge.providerUnavailable": "Ce fournisseur n'est pas disponible.",
+  "newKnowledge.quality": "Qualité",
   "newKnowledge.reCrawl": "Relancer l’exploration",
   "newKnowledge.readOnlyEmpty": "Demandez à un éditeur de l’espace de travail de créer la première base de connaissances.",
   "newKnowledge.refreshConnectionStatus": "Actualiser l'état",
   "newKnowledge.refreshingConnection": "Rafraîchissant…",
+  "newKnowledge.reindexDocument": "Réindexer",
   "newKnowledge.reindexDocuments": "Réindexer",
   "newKnowledge.removeSource": "Supprimer la source",
+  "newKnowledge.retrievalCount": "Nombre de récupérations",
   "newKnowledge.retryCrawl": "Réessayer l’exploration",
   "newKnowledge.retryProviderLoad": "Réessayer",
+  "newKnowledge.retryReindexDocument": "Réindexer à nouveau",
   "newKnowledge.retrySyncPolicy": "Réessayer la politique de synchronisation",
   "newKnowledge.retryTask": "Réessayer",
+  "newKnowledge.revisionState.active": "En service",
+  "newKnowledge.revisionState.candidate": "Traitement en cours",
+  "newKnowledge.revisionState.failed": "Échec",
+  "newKnowledge.revisionState.superseded": "Précédente",
   "newKnowledge.rootUrl": "URL racine",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Cette section deviendra disponible lors de la prochaine étape de configuration.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Tout sélectionner",
   "newKnowledge.selectAllDocuments": "Sélectionnez tous les documents",
   "newKnowledge.selectAllSources": "Sélectionner toutes les sources",
+  "newKnowledge.selectChunk": "Sélectionnez un segment pour examiner son contenu.",
   "newKnowledge.selectFilesAndFolders": "Sélectionnez les fichiers et dossiers à synchroniser",
   "newKnowledge.skippedFailed": "Ignoré (échec)",
   "newKnowledge.skippedOffDomain": "Ignoré (hors domaine)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Tâches",
   "newKnowledge.tasksErrorDescription": "Nous ne pouvions pas charger les tâches en arrière-plan. Essayer à nouveau.",
   "newKnowledge.tasksWithAttention": "Tâches, {{count}} nécessitent une attention particulière",
+  "newKnowledge.tokenCount": "Jetons",
   "newKnowledge.unavailableDescription": "KnowledgeFS n’est pas disponible pour cet espace de travail actuellement.",
   "newKnowledge.unavailableTitle": "Les nouvelles connaissances sont indisponibles",
   "newKnowledge.updated": "Mis à jour le {{date}}",
+  "newKnowledge.updatedAt": "Dernière mise à jour",
   "newKnowledge.updatedColumn": "Mis à jour",
   "newKnowledge.uploadCharactersUnavailable": "Caractères : —",
   "newKnowledge.uploadDocuments": "Télécharger des documents",

web/i18n/hi-IN/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "समायोजित करें और फिर से क्रॉल करें",
   "newKnowledge.allDocumentStatuses": "सभी स्थिति",
   "newKnowledge.allSources": "सभी स्रोत",
+  "newKnowledge.apiAgentAccess": "API और एजेंट एक्सेस",
   "newKnowledge.appsUnavailable": "— ऐप",
   "newKnowledge.authKind.api-key": "एपीआई कुंजी",
   "newKnowledge.authKind.endpoint": "समापन बिंदु",
   "newKnowledge.authenticationMethod": "प्रमाणीकरण विधि",
+  "newKnowledge.averageChunkLength": "औसत खंड लंबाई",
   "newKnowledge.backToList": "ज्ञानकोष पर वापस जाएँ",
   "newKnowledge.backgroundTasks": "पृष्ठभूमि कार्य",
   "newKnowledge.backgroundTasksDescription": "दस्तावेज़ जोड़ता है, स्रोत सिंक करता है, और नौकरियों को पुन: अनुक्रमित करता है।",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "थोक दस्तावेज़ क्रियाएँ",
   "newKnowledge.cancelAddSource": "रद्द करें",
   "newKnowledge.cardType": "नॉलेज स्पेस",
+  "newKnowledge.characterCount": "अक्षर",
+  "newKnowledge.checkReindexStatus": "पुनः इंडेक्स स्थिति जाँचें",
+  "newKnowledge.chunkCount": "खंड",
+  "newKnowledge.chunkHeading": "खंड {{position}}",
+  "newKnowledge.chunkLocation": "इस संशोधन में स्थान {{position}}",
   "newKnowledge.clearDocumentSelection": "दस्तावेज़ चयन साफ़ करें",
   "newKnowledge.configureProvider": "{{provider}} कॉन्फ़िगर करें",
   "newKnowledge.connectNotion": "Notion कनेक्ट करें",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "वेबसाइट स्रोत जोड़ने से पहले कनेक्शन को ताज़ा करें।",
   "newKnowledge.connectionProvisioning": "{{provider}} कनेक्ट हो रहा है",
   "newKnowledge.connectionRefreshFailed": "हम इस कनेक्शन को ताज़ा नहीं कर सके। पुनः प्रयास करें।",
+  "newKnowledge.continueCheckingTaskStatus": "कार्य स्थिति जाँचना जारी रखें",
   "newKnowledge.crawlAndPreview": "क्रॉल और पूर्वावलोकन",
   "newKnowledge.crawlFailed": "{{host}} को क्रॉल नहीं किया जा सका",
   "newKnowledge.crawlFailed403": "साइट ने 403 लौटाया — हो सकता है कि वह क्रॉलर को रोकती हो या प्रमाणीकरण मांगती हो। URL जाँचें, क्रॉल विकल्प बदलें या किसी दूसरे प्रदाता को आज़माएँ।",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "हम यह ज्ञानकोष नहीं बना सके। अपनी पहुंच जांचें और पुनः प्रयास करें।",
   "newKnowledge.createIllustrationTitle": "अपनी सामग्री को एक बार जोड़ें — हर ऐप नवीनतम ज्ञान के साथ उत्तर देगा।",
   "newKnowledge.createTitle": "ज्ञान पैदा करें",
+  "newKnowledge.createdAt": "बनाया गया",
   "newKnowledge.creators": "निर्माता",
   "newKnowledge.customIntervalHours": "कस्टम अंतराल (घंटे)",
   "newKnowledge.customIntervalInvalid": "1 से 720 घंटे तक की पूर्ण संख्या दर्ज करें।",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "यह स्रोत ड्राफ़्ट हटाएँ?",
   "newKnowledge.documentActions": "{{name}} के लिए क्रियाएँ",
   "newKnowledge.documentActionsUnavailable": "इस ज्ञानकोष के लिए दस्तावेज़ क्रियाएँ अभी तक उपलब्ध नहीं हैं।",
+  "newKnowledge.documentChunksEmpty": "इस संशोधन के लिए अभी कोई खंड उपलब्ध नहीं है।",
+  "newKnowledge.documentChunksLoadError": "इस संशोधन के खंड लोड नहीं किए जा सके।",
+  "newKnowledge.documentChunksLoadMoreError": "और खंड लोड नहीं किए जा सके। फिर से कोशिश करें।",
   "newKnowledge.documentColumn": "दस्तावेज़",
+  "newKnowledge.documentContentIncomplete": "दस्तावेज़ की शेष सामग्री लोड हो रही है…",
+  "newKnowledge.documentContents": "विषय-सूची",
+  "newKnowledge.documentFacts": "दस्तावेज़ विवरण",
   "newKnowledge.documentFilterLabel": "स्थिति के अनुसार दस्तावेज़ फ़िल्टर करें",
+  "newKnowledge.documentLoadErrorDescription": "यह दस्तावेज़ लोड नहीं किया जा सका। फिर से कोशिश करें।",
+  "newKnowledge.documentLoadErrorTitle": "दस्तावेज़ लोड नहीं हुआ",
+  "newKnowledge.documentNotFoundDescription": "यह दस्तावेज़ हटाया गया हो सकता है या आपके पास पहुँच नहीं है।",
+  "newKnowledge.documentNotFoundTitle": "दस्तावेज़ नहीं मिला",
+  "newKnowledge.documentOverviewDescription": "दस्तावेज़ों के मेटाडेटा को लेबल करने से AI उन्हें समय पर एक्सेस कर सकता है और उपयोगकर्ताओं को संदर्भों के स्रोत दिखा सकता है।",
   "newKnowledge.documentPermissionRestricted": "आपके कार्यस्थान की अनुमतियाँ दस्तावेज़ या कार्य संबंधी कार्रवाइयों की अनुमति नहीं देती हैं।",
+  "newKnowledge.documentReindexConfirmationDelayed": "पुनः इंडेक्स अनुरोध स्वीकार हुआ, लेकिन कार्य स्थिति में देरी है। दोबारा भेजने से पहले जाँचें।",
+  "newKnowledge.documentReindexFailed": "पुनः इंडेक्सिंग विफल हुई। अंतिम तैयार संशोधन उपलब्ध रहेगा।",
+  "newKnowledge.documentReindexProgress": "पुनः इंडेक्स हो रहा है · {{progress}}%",
+  "newKnowledge.documentRevision": "संशोधन",
+  "newKnowledge.documentRevisionMissingDescription": "इस दस्तावेज़ का कोई तैयार संशोधन अभी नहीं है। प्रोसेसिंग पूरी होने के बाद फिर देखें।",
+  "newKnowledge.documentRevisionMissingTitle": "कोई संशोधन उपलब्ध नहीं",
+  "newKnowledge.documentRevisionsLoadError": "संशोधन इतिहास लोड नहीं हुआ। वर्तमान संशोधन उपलब्ध रहेगा।",
   "newKnowledge.documentStatus.disabled": "निष्क्रिय",
   "newKnowledge.documentStatus.failed": "असफल",
   "newKnowledge.documentStatus.processing": "प्रोसेस हो रहा है",
   "newKnowledge.documentStatus.queued": "कतारबद्ध",
   "newKnowledge.documentStatus.ready": "तैयार",
+  "newKnowledge.documentTaskLookupIncomplete": "अधिक कार्य इतिहास उपलब्ध है। इस दस्तावेज़ की स्थिति खोजने के लिए जाँच जारी रखें।",
   "newKnowledge.documentUploadExclusion.batchLimit": "बैच आकार सीमा पार हो गई",
   "newKnowledge.documentUploadExclusion.countLimit": "फ़ाइल संख्या सीमा पार हो गई",
   "newKnowledge.documentUploadExclusion.fileSize": "फ़ाइल बहुत बड़ी है",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— दस्तावेज़",
   "newKnowledge.downloadDocuments": "डाउनलोड करें",
   "newKnowledge.editSource": "संपादित करें",
+  "newKnowledge.emptyChunk": "खाली खंड",
   "newKnowledge.emptyDescription": "अपने दस्तावेज़ जोड़ें ताकि एजेंट उन्हें सीधे पढ़ सकें — इंडेक्सिंग कॉन्फ़िगर करने की ज़रूरत नहीं।",
   "newKnowledge.emptyTitle": "नॉलेज बेस बनाने का अधिक स्मार्ट तरीका",
   "newKnowledge.errorDescription": "नए नॉलेज बेस लोड नहीं हो सके। फिर से कोशिश करें।",
   "newKnowledge.errorTitle": "कुछ गलत हुआ",
+  "newKnowledge.fileSize": "फ़ाइल का आकार",
   "newKnowledge.filtersUnavailable": "KnowledgeFS के मेटाडेटा उपलब्ध कराने पर यह फ़िल्टर उपलब्ध होगा।",
   "newKnowledge.firecrawlUnavailable": "इस कार्यक्षेत्र के लिए प्रदाता कैटलॉग में फायरक्रॉल उपलब्ध नहीं है।",
   "newKnowledge.gotIt": "समझ गया",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "नए नॉलेज बेस से मिलें ✨",
   "newKnowledge.illustrationHeadline": "अपनी सामग्री एक बार कनेक्ट करें — हर ऐप नवीनतम ज्ञान के साथ जवाब देगा।",
   "newKnowledge.includeSubpages": "उप-पेज शामिल करें",
+  "newKnowledge.indexInformation": "अनुक्रमणिका जानकारी",
   "newKnowledge.interruptTask": "रोकें",
   "newKnowledge.invalidRootUrl": "मान्य http(s) URL दर्ज करें।",
   "newKnowledge.keepEditing": "संपादन जारी रखें",
+  "newKnowledge.lastIndexed": "पिछली बार अनुक्रमित",
   "newKnowledge.lastReadyRevisionHint": "विफल प्रसंस्करण कभी भी पुनर्प्राप्ति को बाधित नहीं करता है - अंतिम तैयार संशोधन सामग्री सूचकांक में उपलब्ध रहता है।",
   "newKnowledge.lastSyncColumn": "अंतिम सिंक",
   "newKnowledge.learnMore": "और जानें",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "क्या अधूरा सेटअप छोड़ना है?",
   "newKnowledge.legacy": "पुराना",
   "newKnowledge.loadMore": "और लोड करें",
+  "newKnowledge.loadMoreRevisions": "पुराने संशोधन लोड करें",
   "newKnowledge.loadingSyncPolicy": "सिंक नीति लोड हो रही है",
   "newKnowledge.manualUpload": "मैन्युअल अपलोड",
   "newKnowledge.maxPages": "अधिकतम पेज",
   "newKnowledge.metadata": "मेटा डेटा",
+  "newKnowledge.mimeType": "फ़ाइल प्रकार",
   "newKnowledge.moreProviders": "और प्रदाता",
   "newKnowledge.name": "ज्ञान नाम",
   "newKnowledge.namePlaceholder": "जैसे ग्राहक सहायता पुस्तिका",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "पृष्ठ चुनने और उन्हें सिंक रखने के लिए Notion कनेक्ट करें।",
   "newKnowledge.onlineDocuments": "ऑनलाइन दस्तावेज़",
   "newKnowledge.onlineDrive": "ऑनलाइन ड्राइव",
+  "newKnowledge.overview": "अवलोकन",
   "newKnowledge.pagesAppearDescription": "जोड़े जाने वाले पेज देखने के लिए साइट को क्रॉल करें।",
   "newKnowledge.pagesAppearTitle": "पेज यहाँ दिखाई देंगे",
   "newKnowledge.pagesCrawled": "{{host}} पर {{count}} पेज क्रॉल किए गए",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} कॉन्फ़िगर नहीं है",
   "newKnowledge.providerNotConfiguredDescription": "{{provider}} के साथ वेबसाइटों को क्रॉल करने के लिए एक एपीआई कुंजी या एंडपॉइंट यूआरएल जोड़ें।",
   "newKnowledge.providerUnavailable": "यह प्रदाता अनुपलब्ध है।",
+  "newKnowledge.quality": "गुणवत्ता",
   "newKnowledge.reCrawl": "फिर से क्रॉल करें",
   "newKnowledge.readOnlyEmpty": "पहला नॉलेज बेस बनाने के लिए कार्यस्थान संपादक से कहें।",
   "newKnowledge.refreshConnectionStatus": "स्थिति ताज़ा करें",
   "newKnowledge.refreshingConnection": "ताज़ा…",
+  "newKnowledge.reindexDocument": "पुनः इंडेक्स करें",
   "newKnowledge.reindexDocuments": "पुन: अनुक्रमणिका",
   "newKnowledge.removeSource": "स्रोत हटाएं",
+  "newKnowledge.retrievalCount": "पुनर्प्राप्ति संख्या",
   "newKnowledge.retryCrawl": "क्रॉल का फिर से प्रयास करें",
   "newKnowledge.retryProviderLoad": "पुनः प्रयास करें",
+  "newKnowledge.retryReindexDocument": "फिर से पुनः इंडेक्स करें",
   "newKnowledge.retrySyncPolicy": "सिंक नीति फिर से लोड करें",
   "newKnowledge.retryTask": "पुनः प्रयास करें",
+  "newKnowledge.revisionState.active": "सक्रिय",
+  "newKnowledge.revisionState.candidate": "प्रोसेस हो रहा है",
+  "newKnowledge.revisionState.failed": "विफल",
+  "newKnowledge.revisionState.superseded": "पिछला",
   "newKnowledge.rootUrl": "रूट URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "यह अनुभाग अगले सेटअप चरण में उपलब्ध हो जाएगा.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "सभी चुनें",
   "newKnowledge.selectAllDocuments": "सभी दस्तावेज़ चुनें",
   "newKnowledge.selectAllSources": "सभी स्रोत चुनें",
+  "newKnowledge.selectChunk": "सामग्री देखने के लिए कोई खंड चुनें।",
   "newKnowledge.selectFilesAndFolders": "सिंक करने के लिए फ़ाइलें और फ़ोल्डर चुनें",
   "newKnowledge.skippedFailed": "छोड़ा गया (विफल)",
   "newKnowledge.skippedOffDomain": "छोड़ा गया (डोमेन से बाहर)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "कार्य",
   "newKnowledge.tasksErrorDescription": "हम पृष्ठभूमि कार्य लोड नहीं कर सके. पुनः प्रयास करें।",
   "newKnowledge.tasksWithAttention": "कार्य, {{count}} पर ध्यान देने की आवश्यकता है",
+  "newKnowledge.tokenCount": "टोकन",
   "newKnowledge.unavailableDescription": "KnowledgeFS अभी इस कार्यस्थान के लिए उपलब्ध नहीं है।",
   "newKnowledge.unavailableTitle": "नया नॉलेज उपलब्ध नहीं है",
   "newKnowledge.updated": "{{date}} को अपडेट किया गया",
+  "newKnowledge.updatedAt": "अंतिम अपडेट",
   "newKnowledge.updatedColumn": "अद्यतन किया गया",
   "newKnowledge.uploadCharactersUnavailable": "वर्ण: —",
   "newKnowledge.uploadDocuments": "दस्तावेज़ अपलोड करें",

web/i18n/id-ID/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Sesuaikan dan rayapi ulang",
   "newKnowledge.allDocumentStatuses": "Semua status",
   "newKnowledge.allSources": "Semua sumber",
+  "newKnowledge.apiAgentAccess": "Akses API & Agen",
   "newKnowledge.appsUnavailable": "— aplikasi",
   "newKnowledge.authKind.api-key": "kunci API",
   "newKnowledge.authKind.endpoint": "Titik akhir",
   "newKnowledge.authenticationMethod": "Metode otentikasi",
+  "newKnowledge.averageChunkLength": "Panjang potongan rata-rata",
   "newKnowledge.backToList": "Kembali ke basis pengetahuan",
   "newKnowledge.backgroundTasks": "Tugas latar belakang",
   "newKnowledge.backgroundTasksDescription": "Penambahan dokumen, sinkronisasi sumber, dan mengindeks ulang pekerjaan.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Tindakan dokumen massal",
   "newKnowledge.cancelAddSource": "Batal",
   "newKnowledge.cardType": "Ruang pengetahuan",
+  "newKnowledge.characterCount": "Karakter",
+  "newKnowledge.checkReindexStatus": "Periksa status pengindeksan ulang",
+  "newKnowledge.chunkCount": "Potongan",
+  "newKnowledge.chunkHeading": "Potongan {{position}}",
+  "newKnowledge.chunkLocation": "Posisi {{position}} dalam revisi ini",
   "newKnowledge.clearDocumentSelection": "Hapus pilihan dokumen",
   "newKnowledge.configureProvider": "Konfigurasikan {{provider}}",
   "newKnowledge.connectNotion": "Hubungkan Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Segarkan koneksi sebelum menambahkan sumber situs web.",
   "newKnowledge.connectionProvisioning": "{{provider}} terhubung",
   "newKnowledge.connectionRefreshFailed": "Kami tidak dapat menyegarkan koneksi ini. Coba lagi.",
+  "newKnowledge.continueCheckingTaskStatus": "Lanjutkan pemeriksaan status tugas",
   "newKnowledge.crawlAndPreview": "Perayapan & pratinjau",
   "newKnowledge.crawlFailed": "Tidak dapat merayapi {{host}}",
   "newKnowledge.crawlFailed403": "Situs mengembalikan 403 — situs mungkin memblokir perayap atau memerlukan autentikasi. Periksa URL, sesuaikan opsi perayapan, atau coba penyedia lain.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Kami tidak dapat membuat basis pengetahuan ini. Periksa akses Anda dan coba lagi.",
   "newKnowledge.createIllustrationTitle": "Hubungkan konten sekali — setiap aplikasi menjawab dengan pengetahuan terbaru.",
   "newKnowledge.createTitle": "Ciptakan Pengetahuan",
+  "newKnowledge.createdAt": "Dibuat",
   "newKnowledge.creators": "Pembuat",
   "newKnowledge.customIntervalHours": "Interval khusus (jam)",
   "newKnowledge.customIntervalInvalid": "Masukkan bilangan bulat antara 1 hingga 720 jam.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Buang draf sumber ini?",
   "newKnowledge.documentActions": "Tindakan untuk {{name}}",
   "newKnowledge.documentActionsUnavailable": "Tindakan dokumen belum tersedia untuk basis pengetahuan ini.",
+  "newKnowledge.documentChunksEmpty": "Belum ada potongan yang tersedia untuk revisi ini.",
+  "newKnowledge.documentChunksLoadError": "Potongan untuk revisi ini tidak dapat dimuat.",
+  "newKnowledge.documentChunksLoadMoreError": "Potongan lainnya tidak dapat dimuat. Coba lagi.",
   "newKnowledge.documentColumn": "Dokumen",
+  "newKnowledge.documentContentIncomplete": "Memuat sisa konten dokumen…",
+  "newKnowledge.documentContents": "Isi",
+  "newKnowledge.documentFacts": "Detail dokumen",
   "newKnowledge.documentFilterLabel": "Filter dokumen berdasarkan status",
+  "newKnowledge.documentLoadErrorDescription": "Dokumen ini tidak dapat dimuat. Coba lagi.",
+  "newKnowledge.documentLoadErrorTitle": "Dokumen tidak dapat dimuat",
+  "newKnowledge.documentNotFoundDescription": "Dokumen ini mungkin telah dihapus atau Anda tidak memiliki akses.",
+  "newKnowledge.documentNotFoundTitle": "Dokumen tidak ditemukan",
+  "newKnowledge.documentOverviewDescription": "Pelabelan metadata dokumen membantu AI mengaksesnya tepat waktu dan menampilkan sumber referensi kepada pengguna.",
   "newKnowledge.documentPermissionRestricted": "Izin ruang kerja Anda tidak mengizinkan tindakan pada dokumen atau tugas.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Pengindeksan ulang diterima, tetapi status tugas tertunda. Periksa sebelum mengirim ulang.",
+  "newKnowledge.documentReindexFailed": "Pengindeksan ulang gagal. Revisi siap terakhir tetap tersedia.",
+  "newKnowledge.documentReindexProgress": "Mengindeks ulang · {{progress}}%",
+  "newKnowledge.documentRevision": "Revisi",
+  "newKnowledge.documentRevisionMissingDescription": "Dokumen ini belum memiliki revisi siap. Periksa lagi setelah pemrosesan selesai.",
+  "newKnowledge.documentRevisionMissingTitle": "Tidak ada revisi yang tersedia",
+  "newKnowledge.documentRevisionsLoadError": "Riwayat revisi tidak dapat dimuat. Revisi saat ini tetap tersedia.",
   "newKnowledge.documentStatus.disabled": "Dinonaktifkan",
   "newKnowledge.documentStatus.failed": "Gagal",
   "newKnowledge.documentStatus.processing": "Pemrosesan",
   "newKnowledge.documentStatus.queued": "Mengantri",
   "newKnowledge.documentStatus.ready": "Siap",
+  "newKnowledge.documentTaskLookupIncomplete": "Riwayat tugas lainnya tersedia. Lanjutkan pemeriksaan untuk menemukan status dokumen ini.",
   "newKnowledge.documentUploadExclusion.batchLimit": "batas ukuran batch terlampaui",
   "newKnowledge.documentUploadExclusion.countLimit": "batas jumlah file terlampaui",
   "newKnowledge.documentUploadExclusion.fileSize": "file terlalu besar",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— dokumen",
   "newKnowledge.downloadDocuments": "Unduh",
   "newKnowledge.editSource": "Sunting",
+  "newKnowledge.emptyChunk": "Potongan kosong",
   "newKnowledge.emptyDescription": "Tambahkan dokumen agar agen dapat membacanya langsung — tanpa perlu mengatur pengindeksan.",
   "newKnowledge.emptyTitle": "Cara yang lebih cerdas untuk membuat basis pengetahuan",
   "newKnowledge.errorDescription": "Kami tidak dapat memuat basis pengetahuan baru Anda. Coba lagi.",
   "newKnowledge.errorTitle": "Terjadi kesalahan",
+  "newKnowledge.fileSize": "Ukuran file",
   "newKnowledge.filtersUnavailable": "Filter ini akan tersedia saat KnowledgeFS menyediakan metadatanya.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl tidak tersedia di katalog penyedia untuk ruang kerja ini.",
   "newKnowledge.gotIt": "Mengerti",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Kenali Basis Pengetahuan baru ✨",
   "newKnowledge.illustrationHeadline": "Hubungkan konten Anda sekali — setiap aplikasi menjawab dengan pengetahuan terbaru.",
   "newKnowledge.includeSubpages": "Sertakan subhalaman",
+  "newKnowledge.indexInformation": "Informasi indeks",
   "newKnowledge.interruptTask": "Hentikan",
   "newKnowledge.invalidRootUrl": "Masukkan URL http(s) yang valid.",
   "newKnowledge.keepEditing": "Lanjutkan mengedit",
+  "newKnowledge.lastIndexed": "Terakhir diindeks",
   "newKnowledge.lastReadyRevisionHint": "Pemrosesan yang gagal tidak pernah mengganggu pengambilan — revisi terakhir yang siap tetap tersedia di indeks konten.",
   "newKnowledge.lastSyncColumn": "Sinkronisasi terakhir",
   "newKnowledge.learnMore": "Pelajari lebih lanjut",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Keluar dari penyiapan yang belum selesai?",
   "newKnowledge.legacy": "Lama",
   "newKnowledge.loadMore": "Muat lebih banyak",
+  "newKnowledge.loadMoreRevisions": "Muat revisi lama",
   "newKnowledge.loadingSyncPolicy": "Memuat kebijakan sinkronisasi",
   "newKnowledge.manualUpload": "Unggah secara manual",
   "newKnowledge.maxPages": "Halaman maksimum",
   "newKnowledge.metadata": "Data Meta",
+  "newKnowledge.mimeType": "Jenis file",
   "newKnowledge.moreProviders": "Penyedia lainnya",
   "newKnowledge.name": "Nama pengetahuan",
   "newKnowledge.namePlaceholder": "misalnya Buku Pegangan Dukungan Pelanggan",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Hubungkan Notion untuk memilih halaman dan menjaganya tetap tersinkron.",
   "newKnowledge.onlineDocuments": "Dokumen daring",
   "newKnowledge.onlineDrive": "Perjalanan daring",
+  "newKnowledge.overview": "Ringkasan",
   "newKnowledge.pagesAppearDescription": "Rayapi situs untuk meninjau halaman yang akan ditambahkan.",
   "newKnowledge.pagesAppearTitle": "Halaman akan muncul di sini",
   "newKnowledge.pagesCrawled": "{{count}} halaman dirayapi di {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} tidak dikonfigurasi",
   "newKnowledge.providerNotConfiguredDescription": "Tambahkan kunci API atau URL titik akhir untuk merayapi situs web dengan {{provider}}.",
   "newKnowledge.providerUnavailable": "Penyedia ini tidak tersedia.",
+  "newKnowledge.quality": "Kualitas",
   "newKnowledge.reCrawl": "Rayapi ulang",
   "newKnowledge.readOnlyEmpty": "Minta editor ruang kerja membuat basis pengetahuan pertama.",
   "newKnowledge.refreshConnectionStatus": "Segarkan status",
   "newKnowledge.refreshingConnection": "Menyegarkan…",
+  "newKnowledge.reindexDocument": "Indeks ulang",
   "newKnowledge.reindexDocuments": "Indeks ulang",
   "newKnowledge.removeSource": "Hapus sumber",
+  "newKnowledge.retrievalCount": "Jumlah pengambilan",
   "newKnowledge.retryCrawl": "Coba perayapan lagi",
   "newKnowledge.retryProviderLoad": "Coba lagi",
+  "newKnowledge.retryReindexDocument": "Indeks ulang lagi",
   "newKnowledge.retrySyncPolicy": "Coba lagi kebijakan sinkronisasi",
   "newKnowledge.retryTask": "Coba lagi",
+  "newKnowledge.revisionState.active": "Aktif",
+  "newKnowledge.revisionState.candidate": "Memproses",
+  "newKnowledge.revisionState.failed": "Gagal",
+  "newKnowledge.revisionState.superseded": "Sebelumnya",
   "newKnowledge.rootUrl": "URL root",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Bagian ini akan tersedia pada langkah penyiapan berikutnya.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Pilih semua",
   "newKnowledge.selectAllDocuments": "Pilih semua dokumen",
   "newKnowledge.selectAllSources": "Pilih semua sumber",
+  "newKnowledge.selectChunk": "Pilih potongan untuk memeriksa isinya.",
   "newKnowledge.selectFilesAndFolders": "Pilih file dan folder untuk disinkronkan",
   "newKnowledge.skippedFailed": "Dilewati (gagal)",
   "newKnowledge.skippedOffDomain": "Dilewati (di luar domain)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Tugas",
   "newKnowledge.tasksErrorDescription": "Kami tidak dapat memuat tugas latar belakang. Coba lagi.",
   "newKnowledge.tasksWithAttention": "Tugas, {{count}} perlu perhatian",
+  "newKnowledge.tokenCount": "Token",
   "newKnowledge.unavailableDescription": "KnowledgeFS saat ini tidak tersedia untuk ruang kerja ini.",
   "newKnowledge.unavailableTitle": "Pengetahuan Baru tidak tersedia",
   "newKnowledge.updated": "Diperbarui {{date}}",
+  "newKnowledge.updatedAt": "Terakhir diperbarui",
   "newKnowledge.updatedColumn": "Diperbarui",
   "newKnowledge.uploadCharactersUnavailable": "Karakter: —",
   "newKnowledge.uploadDocuments": "Unggah dokumen",

web/i18n/it-IT/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Modifica e ripeti la scansione",
   "newKnowledge.allDocumentStatuses": "Tutto lo stato",
   "newKnowledge.allSources": "Tutte le fonti",
+  "newKnowledge.apiAgentAccess": "Accesso API e agenti",
   "newKnowledge.appsUnavailable": "— app",
   "newKnowledge.authKind.api-key": "Chiave API",
   "newKnowledge.authKind.endpoint": "Punto finale",
   "newKnowledge.authenticationMethod": "Metodo di autenticazione",
+  "newKnowledge.averageChunkLength": "Lunghezza media dei segmenti",
   "newKnowledge.backToList": "Torniamo alle basi di conoscenza",
   "newKnowledge.backgroundTasks": "Attività in background",
   "newKnowledge.backgroundTasksDescription": "Aggiunte di documenti, sincronizzazioni di origini e processi di reindicizzazione.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Azioni di documenti in blocco",
   "newKnowledge.cancelAddSource": "Annulla",
   "newKnowledge.cardType": "Spazio di conoscenza",
+  "newKnowledge.characterCount": "Caratteri",
+  "newKnowledge.checkReindexStatus": "Controlla stato reindicizzazione",
+  "newKnowledge.chunkCount": "Segmenti",
+  "newKnowledge.chunkHeading": "Segmento {{position}}",
+  "newKnowledge.chunkLocation": "Posizione {{position}} in questa revisione",
   "newKnowledge.clearDocumentSelection": "Cancella la selezione del documento",
   "newKnowledge.configureProvider": "Configura {{provider}}",
   "newKnowledge.connectNotion": "Connetti Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Aggiorna la connessione prima di aggiungere una fonte web.",
   "newKnowledge.connectionProvisioning": "{{provider}} si sta connettendo",
   "newKnowledge.connectionRefreshFailed": "Impossibile aggiornare questa connessione. Riprova.",
+  "newKnowledge.continueCheckingTaskStatus": "Continua a controllare lo stato",
   "newKnowledge.crawlAndPreview": "Scansione e anteprima",
   "newKnowledge.crawlFailed": "Impossibile eseguire la scansione di {{host}}",
   "newKnowledge.crawlFailed403": "Il sito ha restituito un errore 403: potrebbe bloccare i crawler o richiedere l’autenticazione. Controlla l’URL, modifica le opzioni di scansione o prova un altro provider.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Non è stato possibile creare questa base di conoscenza. Controlla il tuo accesso e riprova.",
   "newKnowledge.createIllustrationTitle": "Collega i contenuti una sola volta: ogni app risponde con le conoscenze più aggiornate.",
   "newKnowledge.createTitle": "Creare Conoscenza",
+  "newKnowledge.createdAt": "Creato",
   "newKnowledge.creators": "Autori",
   "newKnowledge.customIntervalHours": "Intervallo personalizzato (ore)",
   "newKnowledge.customIntervalInvalid": "Inserisci un numero intero compreso tra 1 e 720 ore.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Eliminare questa bozza della fonte?",
   "newKnowledge.documentActions": "Azioni per {{name}}",
   "newKnowledge.documentActionsUnavailable": "Le azioni del documento non sono ancora disponibili per questa knowledge base.",
+  "newKnowledge.documentChunksEmpty": "Non sono ancora disponibili segmenti per questa revisione.",
+  "newKnowledge.documentChunksLoadError": "Impossibile caricare i segmenti di questa revisione.",
+  "newKnowledge.documentChunksLoadMoreError": "Impossibile caricare altri segmenti. Riprova.",
   "newKnowledge.documentColumn": "Documento",
+  "newKnowledge.documentContentIncomplete": "Caricamento del contenuto restante del documento…",
+  "newKnowledge.documentContents": "Contenuti",
+  "newKnowledge.documentFacts": "Dettagli documento",
   "newKnowledge.documentFilterLabel": "Filtra i documenti per stato",
+  "newKnowledge.documentLoadErrorDescription": "Impossibile caricare questo documento. Riprova.",
+  "newKnowledge.documentLoadErrorTitle": "Impossibile caricare il documento",
+  "newKnowledge.documentNotFoundDescription": "Il documento potrebbe essere stato rimosso oppure potresti non avere accesso.",
+  "newKnowledge.documentNotFoundTitle": "Documento non trovato",
+  "newKnowledge.documentOverviewDescription": "L’etichettatura dei metadati dei documenti consente all’IA di accedervi tempestivamente e mostra agli utenti le fonti dei riferimenti.",
   "newKnowledge.documentPermissionRestricted": "Le autorizzazioni del workspace non consentono azioni su documenti o attività.",
+  "newKnowledge.documentReindexConfirmationDelayed": "La reindicizzazione è stata accettata, ma lo stato dell’attività è in ritardo. Controllalo prima di inviarne un’altra.",
+  "newKnowledge.documentReindexFailed": "La reindicizzazione non è riuscita. L’ultima revisione pronta resta disponibile.",
+  "newKnowledge.documentReindexProgress": "Reindicizzazione · {{progress}}%",
+  "newKnowledge.documentRevision": "Revisione",
+  "newKnowledge.documentRevisionMissingDescription": "Questo documento non ha ancora una revisione pronta. Ricontrolla al termine dell’elaborazione.",
+  "newKnowledge.documentRevisionMissingTitle": "Nessuna revisione disponibile",
+  "newKnowledge.documentRevisionsLoadError": "Impossibile caricare la cronologia delle revisioni. La revisione corrente resta disponibile.",
   "newKnowledge.documentStatus.disabled": "Disattivato",
   "newKnowledge.documentStatus.failed": "Fallito",
   "newKnowledge.documentStatus.processing": "Elaborazione",
   "newKnowledge.documentStatus.queued": "In coda",
   "newKnowledge.documentStatus.ready": "Pronto",
+  "newKnowledge.documentTaskLookupIncomplete": "È disponibile altra cronologia delle attività. Continua a controllare per trovare lo stato del documento.",
   "newKnowledge.documentUploadExclusion.batchLimit": "limite delle dimensioni del batch superato",
   "newKnowledge.documentUploadExclusion.countLimit": "limite del numero di file superato",
   "newKnowledge.documentUploadExclusion.fileSize": "il file è troppo grande",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— documenti",
   "newKnowledge.downloadDocuments": "Scarica",
   "newKnowledge.editSource": "Modifica",
+  "newKnowledge.emptyChunk": "Segmento vuoto",
   "newKnowledge.emptyDescription": "Aggiungi i tuoi documenti e gli agenti potranno leggerli direttamente, senza configurare l’indicizzazione.",
   "newKnowledge.emptyTitle": "Un modo più intelligente per creare knowledge base",
   "newKnowledge.errorDescription": "Non è stato possibile caricare le nuove knowledge base. Riprova.",
   "newKnowledge.errorTitle": "Si è verificato un problema",
+  "newKnowledge.fileSize": "Dimensione file",
   "newKnowledge.filtersUnavailable": "Questo filtro sarà disponibile quando KnowledgeFS esporrà i relativi metadati.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl non è disponibile nel catalogo del provider per questa area di lavoro.",
   "newKnowledge.gotIt": "Ho capito",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Scopri la nuova Knowledge Base ✨",
   "newKnowledge.illustrationHeadline": "Collega i tuoi contenuti una sola volta: ogni app risponderà con le conoscenze più aggiornate.",
   "newKnowledge.includeSubpages": "Includi sottopagine",
+  "newKnowledge.indexInformation": "Informazioni sull’indice",
   "newKnowledge.interruptTask": "Interrompere",
   "newKnowledge.invalidRootUrl": "Inserisci un URL http(s) valido.",
   "newKnowledge.keepEditing": "Continua a modificare",
+  "newKnowledge.lastIndexed": "Ultima indicizzazione",
   "newKnowledge.lastReadyRevisionHint": "L'elaborazione non riuscita non interrompe mai il recupero: l'ultima revisione pronta rimane disponibile nell'indice del contenuto.",
   "newKnowledge.lastSyncColumn": "Ultima sincronizzazione",
   "newKnowledge.learnMore": "Scopri di più",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Uscire dalla configurazione incompleta?",
   "newKnowledge.legacy": "Legacy",
   "newKnowledge.loadMore": "Carica altro",
+  "newKnowledge.loadMoreRevisions": "Carica revisioni precedenti",
   "newKnowledge.loadingSyncPolicy": "Caricamento dei criteri di sincronizzazione",
   "newKnowledge.manualUpload": "Caricamento manuale",
   "newKnowledge.maxPages": "Numero massimo di pagine",
   "newKnowledge.metadata": "Metadati",
+  "newKnowledge.mimeType": "Tipo di file",
   "newKnowledge.moreProviders": "Altri provider",
   "newKnowledge.name": "Nome della conoscenza",
   "newKnowledge.namePlaceholder": "ad es. Manuale dell'assistenza clienti",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Connetti Notion per scegliere le pagine e mantenerle sincronizzate.",
   "newKnowledge.onlineDocuments": "Documenti online",
   "newKnowledge.onlineDrive": "Unità in linea",
+  "newKnowledge.overview": "Panoramica",
   "newKnowledge.pagesAppearDescription": "Esegui la scansione del sito per verificare quali pagine verranno aggiunte.",
   "newKnowledge.pagesAppearTitle": "Le pagine appariranno qui",
   "newKnowledge.pagesCrawled": "{{count}} pagine sottoposte a scansione su {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} non è configurato",
   "newKnowledge.providerNotConfiguredDescription": "Aggiungi una chiave API o un URL endpoint per eseguire la scansione dei siti web con {{provider}}.",
   "newKnowledge.providerUnavailable": "Questo fornitore non è disponibile.",
+  "newKnowledge.quality": "Qualità",
   "newKnowledge.reCrawl": "Ripeti la scansione",
   "newKnowledge.readOnlyEmpty": "Chiedi a un editor dello spazio di lavoro di creare la prima knowledge base.",
   "newKnowledge.refreshConnectionStatus": "Aggiorna lo stato",
   "newKnowledge.refreshingConnection": "Aggiornamento…",
+  "newKnowledge.reindexDocument": "Reindicizza",
   "newKnowledge.reindexDocuments": "Reindicizzare",
   "newKnowledge.removeSource": "Rimuovi la fonte",
+  "newKnowledge.retrievalCount": "Numero di recuperi",
   "newKnowledge.retryCrawl": "Riprova la scansione",
   "newKnowledge.retryProviderLoad": "Riprova",
+  "newKnowledge.retryReindexDocument": "Reindicizza di nuovo",
   "newKnowledge.retrySyncPolicy": "Riprova i criteri di sincronizzazione",
   "newKnowledge.retryTask": "Riprova",
+  "newKnowledge.revisionState.active": "Attiva",
+  "newKnowledge.revisionState.candidate": "In elaborazione",
+  "newKnowledge.revisionState.failed": "Non riuscita",
+  "newKnowledge.revisionState.superseded": "Precedente",
   "newKnowledge.rootUrl": "URL principale",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Questa sezione diventerà disponibile nella fase di configurazione successiva.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Seleziona tutto",
   "newKnowledge.selectAllDocuments": "Seleziona tutti i documenti",
   "newKnowledge.selectAllSources": "Seleziona tutte le origini",
+  "newKnowledge.selectChunk": "Seleziona un segmento per esaminarne il contenuto.",
   "newKnowledge.selectFilesAndFolders": "Seleziona file e cartelle da sincronizzare",
   "newKnowledge.skippedFailed": "Ignorato (errore)",
   "newKnowledge.skippedOffDomain": "Ignorato (fuori dominio)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Compiti",
   "newKnowledge.tasksErrorDescription": "Non è stato possibile caricare le attività in background. Riprova.",
   "newKnowledge.tasksWithAttention": "I compiti, {{count}} richiedono attenzione",
+  "newKnowledge.tokenCount": "Token",
   "newKnowledge.unavailableDescription": "KnowledgeFS non è al momento disponibile per questo spazio di lavoro.",
   "newKnowledge.unavailableTitle": "La nuova conoscenza non è disponibile",
   "newKnowledge.updated": "Aggiornato il {{date}}",
+  "newKnowledge.updatedAt": "Ultimo aggiornamento",
   "newKnowledge.updatedColumn": "Aggiornato",
   "newKnowledge.uploadCharactersUnavailable": "Caratteri: —",
   "newKnowledge.uploadDocuments": "Carica documenti",

web/i18n/ja-JP/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "調整して再クロール",
   "newKnowledge.allDocumentStatuses": "すべてのステータス",
   "newKnowledge.allSources": "すべてのソース",
+  "newKnowledge.apiAgentAccess": "API とエージェントアクセス",
   "newKnowledge.appsUnavailable": "— 個のアプリ",
   "newKnowledge.authKind.api-key": "APIキー",
   "newKnowledge.authKind.endpoint": "エンドポイント",
   "newKnowledge.authenticationMethod": "認証方法",
+  "newKnowledge.averageChunkLength": "チャンクの平均長",
   "newKnowledge.backToList": "ナレッジベースに戻る",
   "newKnowledge.backgroundTasks": "バックグラウンドタスク",
   "newKnowledge.backgroundTasksDescription": "ドキュメントの追加、ソースの同期、ジョブの再インデックス。",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "一括ドキュメントアクション",
   "newKnowledge.cancelAddSource": "キャンセル",
   "newKnowledge.cardType": "ナレッジスペース",
+  "newKnowledge.characterCount": "文字数",
+  "newKnowledge.checkReindexStatus": "再インデックス状態を確認",
+  "newKnowledge.chunkCount": "チャンク",
+  "newKnowledge.chunkHeading": "チャンク {{position}}",
+  "newKnowledge.chunkLocation": "このリビジョン内の位置 {{position}}",
   "newKnowledge.clearDocumentSelection": "ドキュメントの選択をクリアする",
   "newKnowledge.configureProvider": "{{provider}} を構成する",
   "newKnowledge.connectNotion": "Notion に接続",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Web サイトのソースを追加する前に接続を更新してください。",
   "newKnowledge.connectionProvisioning": "{{provider}} が接続中です",
   "newKnowledge.connectionRefreshFailed": "この接続を更新できませんでした。もう一度やり直してください。",
+  "newKnowledge.continueCheckingTaskStatus": "タスク状態の確認を続ける",
   "newKnowledge.crawlAndPreview": "クロールとプレビュー",
   "newKnowledge.crawlFailed": "{{host}} をクロールできませんでした",
   "newKnowledge.crawlFailed403": "サイトから403が返されました。クローラーがブロックされているか、認証が必要な可能性があります。URLを確認し、クロールオプションを調整するか、別のプロバイダーを試してください。",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "このナレッジ ベースを作成できませんでした。アクセスを確認して再試行してください。",
   "newKnowledge.createIllustrationTitle": "コンテンツを一度接続すれば、すべてのアプリが最新のナレッジで回答します。",
   "newKnowledge.createTitle": "知識の創造",
+  "newKnowledge.createdAt": "作成日時",
   "newKnowledge.creators": "作成者",
   "newKnowledge.customIntervalHours": "カスタム間隔（時間）",
   "newKnowledge.customIntervalInvalid": "1～720 の整数を入力してください。",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "このソースの下書きを破棄しますか？",
   "newKnowledge.documentActions": "{{name}} のアクション",
   "newKnowledge.documentActionsUnavailable": "ドキュメント アクションは、このナレッジ ベースではまだ利用できません。",
+  "newKnowledge.documentChunksEmpty": "このリビジョンで利用できるチャンクはまだありません。",
+  "newKnowledge.documentChunksLoadError": "このリビジョンのチャンクを読み込めませんでした。",
+  "newKnowledge.documentChunksLoadMoreError": "追加のチャンクを読み込めませんでした。もう一度お試しください。",
   "newKnowledge.documentColumn": "文書",
+  "newKnowledge.documentContentIncomplete": "ドキュメントの残りの内容を読み込んでいます…",
+  "newKnowledge.documentContents": "目次",
+  "newKnowledge.documentFacts": "ドキュメントの詳細",
   "newKnowledge.documentFilterLabel": "ドキュメントをステータスでフィルタリングする",
+  "newKnowledge.documentLoadErrorDescription": "このドキュメントを読み込めませんでした。もう一度お試しください。",
+  "newKnowledge.documentLoadErrorTitle": "ドキュメントを読み込めませんでした",
+  "newKnowledge.documentNotFoundDescription": "このドキュメントは削除されたか、アクセス権がない可能性があります。",
+  "newKnowledge.documentNotFoundTitle": "ドキュメントが見つかりません",
+  "newKnowledge.documentOverviewDescription": "ドキュメントのメタデータをラベル付けすると、AI が必要なときにアクセスでき、ユーザーに参照元を示せます。",
   "newKnowledge.documentPermissionRestricted": "ワークスペースの権限では、ドキュメントまたはタスクの操作を実行できません。",
+  "newKnowledge.documentReindexConfirmationDelayed": "再インデックスは受理されましたが、タスク状態の反映が遅れています。再送信前に確認してください。",
+  "newKnowledge.documentReindexFailed": "再インデックスに失敗しました。最後に準備完了となったリビジョンは引き続き利用できます。",
+  "newKnowledge.documentReindexProgress": "再インデックス中 · {{progress}}%",
+  "newKnowledge.documentRevision": "リビジョン",
+  "newKnowledge.documentRevisionMissingDescription": "このドキュメントには準備完了のリビジョンがまだありません。処理完了後に再度確認してください。",
+  "newKnowledge.documentRevisionMissingTitle": "利用可能なリビジョンはありません",
+  "newKnowledge.documentRevisionsLoadError": "リビジョン履歴を読み込めませんでした。現在のリビジョンは引き続き利用できます。",
   "newKnowledge.documentStatus.disabled": "無効",
   "newKnowledge.documentStatus.failed": "失敗しました",
   "newKnowledge.documentStatus.processing": "処理中",
   "newKnowledge.documentStatus.queued": "キューに入れられました",
   "newKnowledge.documentStatus.ready": "準備完了",
+  "newKnowledge.documentTaskLookupIncomplete": "さらにタスク履歴があります。このドキュメントの状態を確認し続けてください。",
   "newKnowledge.documentUploadExclusion.batchLimit": "バッチサイズの上限を超えています",
   "newKnowledge.documentUploadExclusion.countLimit": "ファイル数の上限を超えています",
   "newKnowledge.documentUploadExclusion.fileSize": "ファイルが大きすぎます",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— 件のドキュメント",
   "newKnowledge.downloadDocuments": "ダウンロード",
   "newKnowledge.editSource": "編集",
+  "newKnowledge.emptyChunk": "空のチャンク",
   "newKnowledge.emptyDescription": "ドキュメントを追加すると、エージェントが直接読み取れます。インデックス設定は不要です。",
   "newKnowledge.emptyTitle": "ナレッジベースをよりスマートに構築",
   "newKnowledge.errorDescription": "新しいナレッジベースを読み込めませんでした。もう一度お試しください。",
   "newKnowledge.errorTitle": "問題が発生しました",
+  "newKnowledge.fileSize": "ファイルサイズ",
   "newKnowledge.filtersUnavailable": "KnowledgeFS がメタデータを提供すると、このフィルターを利用できます。",
   "newKnowledge.firecrawlUnavailable": "Firecrawl は、このワークスペースのプロバイダー カタログでは使用できません。",
   "newKnowledge.gotIt": "了解",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "新しいナレッジベースへようこそ ✨",
   "newKnowledge.illustrationHeadline": "コンテンツを一度接続すれば、すべてのアプリが最新のナレッジで回答します。",
   "newKnowledge.includeSubpages": "サブページを含める",
+  "newKnowledge.indexInformation": "インデックス情報",
   "newKnowledge.interruptTask": "中断",
   "newKnowledge.invalidRootUrl": "有効なhttp(s) URLを入力してください。",
   "newKnowledge.keepEditing": "編集を続ける",
+  "newKnowledge.lastIndexed": "最終インデックス日時",
   "newKnowledge.lastReadyRevisionHint": "処理が失敗しても取得が中断されることはありません。準備ができた最後のリビジョンはコンテンツ インデックス内で利用可能なままになります。",
   "newKnowledge.lastSyncColumn": "最終同期",
   "newKnowledge.learnMore": "詳細を見る",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "未完了のセットアップを終了しますか？",
   "newKnowledge.legacy": "旧バージョン",
   "newKnowledge.loadMore": "さらに読み込む",
+  "newKnowledge.loadMoreRevisions": "古いリビジョンを読み込む",
   "newKnowledge.loadingSyncPolicy": "同期ポリシーを読み込み中",
   "newKnowledge.manualUpload": "手動アップロード",
   "newKnowledge.maxPages": "最大ページ数",
   "newKnowledge.metadata": "メタデータ",
+  "newKnowledge.mimeType": "ファイル形式",
   "newKnowledge.moreProviders": "その他のプロバイダー",
   "newKnowledge.name": "ナレッジ名",
   "newKnowledge.namePlaceholder": "例:カスタマーサポートハンドブック",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Notion に接続してページを選択し、同期を維持します。",
   "newKnowledge.onlineDocuments": "オンライン文書",
   "newKnowledge.onlineDrive": "オンラインドライブ",
+  "newKnowledge.overview": "概要",
   "newKnowledge.pagesAppearDescription": "サイトをクロールして、追加されるページを確認します。",
   "newKnowledge.pagesAppearTitle": "ページはここに表示されます",
   "newKnowledge.pagesCrawled": "{{host}} で{{count}}ページをクロールしました",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} が構成されていません",
   "newKnowledge.providerNotConfiguredDescription": "{{provider}} を使用して Web サイトをクロールするための API キーまたはエンドポイント URL を追加します。",
   "newKnowledge.providerUnavailable": "このプロバイダーは利用できません。",
+  "newKnowledge.quality": "品質",
   "newKnowledge.reCrawl": "再クロール",
   "newKnowledge.readOnlyEmpty": "最初のナレッジベースの作成をワークスペース編集者に依頼してください。",
   "newKnowledge.refreshConnectionStatus": "ステータスの更新",
   "newKnowledge.refreshingConnection": "爽やか…",
+  "newKnowledge.reindexDocument": "再インデックス",
   "newKnowledge.reindexDocuments": "インデックスを再作成する",
   "newKnowledge.removeSource": "ソースを削除",
+  "newKnowledge.retrievalCount": "取得回数",
   "newKnowledge.retryCrawl": "クロールを再試行",
   "newKnowledge.retryProviderLoad": "再試行",
+  "newKnowledge.retryReindexDocument": "もう一度再インデックス",
   "newKnowledge.retrySyncPolicy": "同期ポリシーを再読み込み",
   "newKnowledge.retryTask": "再試行",
+  "newKnowledge.revisionState.active": "有効",
+  "newKnowledge.revisionState.candidate": "処理中",
+  "newKnowledge.revisionState.failed": "失敗",
+  "newKnowledge.revisionState.superseded": "以前",
   "newKnowledge.rootUrl": "ルートURL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "このセクションは、次のセットアップ手順で使用できるようになります。",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "すべて選択",
   "newKnowledge.selectAllDocuments": "すべてのドキュメントを選択します",
   "newKnowledge.selectAllSources": "すべてのソースを選択",
+  "newKnowledge.selectChunk": "内容を確認するチャンクを選択してください。",
   "newKnowledge.selectFilesAndFolders": "同期するファイルとフォルダーを選択",
   "newKnowledge.skippedFailed": "スキップ（失敗）",
   "newKnowledge.skippedOffDomain": "スキップ（ドメイン外）",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "タスク",
   "newKnowledge.tasksErrorDescription": "バックグラウンドタスクをロードできませんでした。もう一度やり直してください。",
   "newKnowledge.tasksWithAttention": "タスク、{{count}} は注意が必要です",
+  "newKnowledge.tokenCount": "トークン",
   "newKnowledge.unavailableDescription": "このワークスペースでは現在 KnowledgeFS を利用できません。",
   "newKnowledge.unavailableTitle": "新しいナレッジは利用できません",
   "newKnowledge.updated": "{{date}} に更新",
+  "newKnowledge.updatedAt": "最終更新",
   "newKnowledge.updatedColumn": "更新されました",
   "newKnowledge.uploadCharactersUnavailable": "文字数：—",
   "newKnowledge.uploadDocuments": "書類のアップロード",

web/i18n/ko-KR/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "조정 후 다시 크롤링",
   "newKnowledge.allDocumentStatuses": "모든 상태",
   "newKnowledge.allSources": "모든 소스",
+  "newKnowledge.apiAgentAccess": "API 및 에이전트 액세스",
   "newKnowledge.appsUnavailable": "앱 —개",
   "newKnowledge.authKind.api-key": "API 키",
   "newKnowledge.authKind.endpoint": "종점",
   "newKnowledge.authenticationMethod": "인증 방법",
+  "newKnowledge.averageChunkLength": "평균 청크 길이",
   "newKnowledge.backToList": "지식 베이스로 돌아가기",
   "newKnowledge.backgroundTasks": "백그라운드 작업",
   "newKnowledge.backgroundTasksDescription": "문서 추가, 소스 동기화 및 재색인 작업.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "대량 문서 작업",
   "newKnowledge.cancelAddSource": "취소",
   "newKnowledge.cardType": "지식 공간",
+  "newKnowledge.characterCount": "문자 수",
+  "newKnowledge.checkReindexStatus": "재인덱싱 상태 확인",
+  "newKnowledge.chunkCount": "청크",
+  "newKnowledge.chunkHeading": "청크 {{position}}",
+  "newKnowledge.chunkLocation": "이 리비전의 위치 {{position}}",
   "newKnowledge.clearDocumentSelection": "문서 선택 지우기",
   "newKnowledge.configureProvider": "{{provider}} 구성",
   "newKnowledge.connectNotion": "Notion 연결",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "웹사이트 소스를 추가하기 전에 연결을 새로 고치세요.",
   "newKnowledge.connectionProvisioning": "{{provider}}이 연결 중입니다.",
   "newKnowledge.connectionRefreshFailed": "이 연결을 새로 고칠 수 없습니다. 다시 시도해 보세요.",
+  "newKnowledge.continueCheckingTaskStatus": "작업 상태 계속 확인",
   "newKnowledge.crawlAndPreview": "크롤링 및 미리보기",
   "newKnowledge.crawlFailed": "{{host}}을(를) 크롤링할 수 없습니다",
   "newKnowledge.crawlFailed403": "사이트에서 403을 반환했습니다. 크롤러를 차단하거나 인증이 필요할 수 있습니다. URL을 확인하고 크롤링 옵션을 조정하거나 다른 제공업체를 사용해 보세요.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "이 기술 자료를 만들 수 없습니다. 액세스 권한을 확인하고 다시 시도하세요.",
   "newKnowledge.createIllustrationTitle": "콘텐츠를 한 번 연결하면 모든 앱이 최신 지식으로 답변합니다.",
   "newKnowledge.createTitle": "지식 창조",
+  "newKnowledge.createdAt": "생성됨",
   "newKnowledge.creators": "생성자",
   "newKnowledge.customIntervalHours": "사용자 지정 간격(시간)",
   "newKnowledge.customIntervalInvalid": "1~720 사이의 정수를 입력하세요.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "이 소스 초안을 삭제할까요?",
   "newKnowledge.documentActions": "{{name}}에 대한 작업",
   "newKnowledge.documentActionsUnavailable": "이 기술 자료에는 아직 문서 작업을 사용할 수 없습니다.",
+  "newKnowledge.documentChunksEmpty": "이 리비전에 사용할 수 있는 청크가 아직 없습니다.",
+  "newKnowledge.documentChunksLoadError": "이 리비전의 청크를 불러오지 못했습니다.",
+  "newKnowledge.documentChunksLoadMoreError": "청크를 더 불러오지 못했습니다. 다시 시도하세요.",
   "newKnowledge.documentColumn": "문서",
+  "newKnowledge.documentContentIncomplete": "나머지 문서 콘텐츠를 불러오는 중…",
+  "newKnowledge.documentContents": "목차",
+  "newKnowledge.documentFacts": "문서 세부 정보",
   "newKnowledge.documentFilterLabel": "상태별로 문서 필터링",
+  "newKnowledge.documentLoadErrorDescription": "이 문서를 불러오지 못했습니다. 다시 시도하세요.",
+  "newKnowledge.documentLoadErrorTitle": "문서를 불러오지 못함",
+  "newKnowledge.documentNotFoundDescription": "이 문서가 삭제되었거나 접근 권한이 없을 수 있습니다.",
+  "newKnowledge.documentNotFoundTitle": "문서를 찾을 수 없음",
+  "newKnowledge.documentOverviewDescription": "문서 메타데이터에 레이블을 지정하면 AI가 적시에 문서에 접근하고 사용자에게 참조 출처를 표시할 수 있습니다.",
   "newKnowledge.documentPermissionRestricted": "워크스페이스 권한으로는 문서 또는 작업 동작을 수행할 수 없습니다.",
+  "newKnowledge.documentReindexConfirmationDelayed": "재인덱싱이 접수되었지만 작업 상태 반영이 지연되고 있습니다. 다시 제출하기 전에 확인하세요.",
+  "newKnowledge.documentReindexFailed": "재인덱싱에 실패했습니다. 마지막 준비 완료 리비전은 계속 사용할 수 있습니다.",
+  "newKnowledge.documentReindexProgress": "재인덱싱 중 · {{progress}}%",
+  "newKnowledge.documentRevision": "리비전",
+  "newKnowledge.documentRevisionMissingDescription": "이 문서에는 아직 준비 완료된 리비전이 없습니다. 처리가 끝난 후 다시 확인하세요.",
+  "newKnowledge.documentRevisionMissingTitle": "사용 가능한 리비전 없음",
+  "newKnowledge.documentRevisionsLoadError": "리비전 기록을 불러오지 못했습니다. 현재 리비전은 계속 사용할 수 있습니다.",
   "newKnowledge.documentStatus.disabled": "비활성화",
   "newKnowledge.documentStatus.failed": "실패",
   "newKnowledge.documentStatus.processing": "처리 중",
   "newKnowledge.documentStatus.queued": "대기 중",
   "newKnowledge.documentStatus.ready": "준비됨",
+  "newKnowledge.documentTaskLookupIncomplete": "더 많은 작업 기록이 있습니다. 이 문서의 상태를 찾으려면 계속 확인하세요.",
   "newKnowledge.documentUploadExclusion.batchLimit": "배치 크기 제한을 초과했습니다",
   "newKnowledge.documentUploadExclusion.countLimit": "파일 수 제한을 초과했습니다",
   "newKnowledge.documentUploadExclusion.fileSize": "파일이 너무 큽니다",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "문서 —개",
   "newKnowledge.downloadDocuments": "다운로드",
   "newKnowledge.editSource": "편집",
+  "newKnowledge.emptyChunk": "빈 청크",
   "newKnowledge.emptyDescription": "문서를 추가하면 에이전트가 직접 읽을 수 있습니다. 인덱싱 설정은 필요하지 않습니다.",
   "newKnowledge.emptyTitle": "지식 베이스를 구축하는 더 스마트한 방법",
   "newKnowledge.errorDescription": "새 지식 베이스를 불러오지 못했습니다. 다시 시도하세요.",
   "newKnowledge.errorTitle": "문제가 발생했습니다",
+  "newKnowledge.fileSize": "파일 크기",
   "newKnowledge.filtersUnavailable": "KnowledgeFS에서 메타데이터를 제공하면 이 필터를 사용할 수 있습니다.",
   "newKnowledge.firecrawlUnavailable": "이 작업공간의 공급자 카탈로그에서는 Firecrawl을 사용할 수 없습니다.",
   "newKnowledge.gotIt": "확인",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "새로운 지식 베이스를 만나보세요 ✨",
   "newKnowledge.illustrationHeadline": "콘텐츠를 한 번 연결하면 모든 앱이 최신 지식으로 답변합니다.",
   "newKnowledge.includeSubpages": "하위 페이지 포함",
+  "newKnowledge.indexInformation": "인덱스 정보",
   "newKnowledge.interruptTask": "중단",
   "newKnowledge.invalidRootUrl": "유효한 http(s) URL을 입력하세요.",
   "newKnowledge.keepEditing": "계속 편집",
+  "newKnowledge.lastIndexed": "마지막 인덱싱",
   "newKnowledge.lastReadyRevisionHint": "실패한 처리는 검색을 중단하지 않습니다. 마지막으로 준비된 개정은 콘텐츠 인덱스에서 계속 사용할 수 있습니다.",
   "newKnowledge.lastSyncColumn": "마지막 동기화",
   "newKnowledge.learnMore": "자세히 알아보기",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "완료되지 않은 설정을 나갈까요?",
   "newKnowledge.legacy": "레거시",
   "newKnowledge.loadMore": "더 보기",
+  "newKnowledge.loadMoreRevisions": "이전 리비전 불러오기",
   "newKnowledge.loadingSyncPolicy": "동기화 정책 불러오는 중",
   "newKnowledge.manualUpload": "수동 업로드",
   "newKnowledge.maxPages": "최대 페이지 수",
   "newKnowledge.metadata": "메타데이터",
+  "newKnowledge.mimeType": "파일 형식",
   "newKnowledge.moreProviders": "더 많은 공급자",
   "newKnowledge.name": "지식 이름",
   "newKnowledge.namePlaceholder": "예를 들어 고객 지원 핸드북",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "페이지를 선택하고 동기화 상태를 유지하려면 Notion을 연결하세요.",
   "newKnowledge.onlineDocuments": "온라인 문서",
   "newKnowledge.onlineDrive": "온라인 드라이브",
+  "newKnowledge.overview": "개요",
   "newKnowledge.pagesAppearDescription": "사이트를 크롤링하여 추가될 페이지를 확인하세요.",
   "newKnowledge.pagesAppearTitle": "페이지가 여기에 표시됩니다",
   "newKnowledge.pagesCrawled": "{{host}}에서 {{count}}개 페이지를 크롤링했습니다",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}}이 구성되지 않았습니다.",
   "newKnowledge.providerNotConfiguredDescription": "{{provider}}을(를) 사용하여 웹사이트를 크롤링하려면 API 키 또는 엔드포인트 URL을 추가하세요.",
   "newKnowledge.providerUnavailable": "이 제공자를 사용할 수 없습니다.",
+  "newKnowledge.quality": "품질",
   "newKnowledge.reCrawl": "다시 크롤링",
   "newKnowledge.readOnlyEmpty": "워크스페이스 편집자에게 첫 번째 지식 베이스 생성을 요청하세요.",
   "newKnowledge.refreshConnectionStatus": "새로 고침 상태",
   "newKnowledge.refreshingConnection": "상쾌하다…",
+  "newKnowledge.reindexDocument": "재인덱싱",
   "newKnowledge.reindexDocuments": "재인덱싱",
   "newKnowledge.removeSource": "소스 제거",
+  "newKnowledge.retrievalCount": "검색 횟수",
   "newKnowledge.retryCrawl": "크롤링 다시 시도",
   "newKnowledge.retryProviderLoad": "재시도",
+  "newKnowledge.retryReindexDocument": "다시 재인덱싱",
   "newKnowledge.retrySyncPolicy": "동기화 정책 다시 시도",
   "newKnowledge.retryTask": "재시도",
+  "newKnowledge.revisionState.active": "활성",
+  "newKnowledge.revisionState.candidate": "처리 중",
+  "newKnowledge.revisionState.failed": "실패",
+  "newKnowledge.revisionState.superseded": "이전",
   "newKnowledge.rootUrl": "루트 URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "이 섹션은 다음 설정 단계에서 사용할 수 있습니다.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "모두 선택",
   "newKnowledge.selectAllDocuments": "모든 문서 선택",
   "newKnowledge.selectAllSources": "모든 소스 선택",
+  "newKnowledge.selectChunk": "내용을 확인할 청크를 선택하세요.",
   "newKnowledge.selectFilesAndFolders": "동기화할 파일과 폴더 선택",
   "newKnowledge.skippedFailed": "건너뜀(실패)",
   "newKnowledge.skippedOffDomain": "건너뜀(도메인 외부)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "작업",
   "newKnowledge.tasksErrorDescription": "백그라운드 작업을 로드할 수 없습니다. 다시 시도해 보세요.",
   "newKnowledge.tasksWithAttention": "작업, {{count}}에 주의가 필요합니다.",
+  "newKnowledge.tokenCount": "토큰",
   "newKnowledge.unavailableDescription": "현재 이 워크스페이스에서 KnowledgeFS를 사용할 수 없습니다.",
   "newKnowledge.unavailableTitle": "새 지식을 사용할 수 없음",
   "newKnowledge.updated": "{{date}} 업데이트",
+  "newKnowledge.updatedAt": "마지막 업데이트",
   "newKnowledge.updatedColumn": "업데이트됨",
   "newKnowledge.uploadCharactersUnavailable": "문자 수: —",
   "newKnowledge.uploadDocuments": "문서 업로드",

web/i18n/nl-NL/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Aanpassen en opnieuw crawlen",
   "newKnowledge.allDocumentStatuses": "Alle status",
   "newKnowledge.allSources": "Alle bronnen",
+  "newKnowledge.apiAgentAccess": "API- en agenttoegang",
   "newKnowledge.appsUnavailable": "— apps",
   "newKnowledge.authKind.api-key": "API-sleutel",
   "newKnowledge.authKind.endpoint": "Eindpunt",
   "newKnowledge.authenticationMethod": "Authenticatiemethode",
+  "newKnowledge.averageChunkLength": "Gemiddelde segmentlengte",
   "newKnowledge.backToList": "Terug naar kennisbanken",
   "newKnowledge.backgroundTasks": "Achtergrondtaken",
   "newKnowledge.backgroundTasksDescription": "Documenten toevoegen, bronsynchronisaties en taken opnieuw indexeren.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Bulkdocumentacties",
   "newKnowledge.cancelAddSource": "Annuleren",
   "newKnowledge.cardType": "Kennisruimte",
+  "newKnowledge.characterCount": "Tekens",
+  "newKnowledge.checkReindexStatus": "Status van herindexering controleren",
+  "newKnowledge.chunkCount": "Segmenten",
+  "newKnowledge.chunkHeading": "Fragment {{position}}",
+  "newKnowledge.chunkLocation": "Positie {{position}} in deze revisie",
   "newKnowledge.clearDocumentSelection": "Documentselectie wissen",
   "newKnowledge.configureProvider": "{{provider}} configureren",
   "newKnowledge.connectNotion": "Notion verbinden",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Vernieuw de verbinding voordat u een websitebron toevoegt.",
   "newKnowledge.connectionProvisioning": "{{provider}} maakt verbinding",
   "newKnowledge.connectionRefreshFailed": "We konden deze verbinding niet vernieuwen. Probeer het opnieuw.",
+  "newKnowledge.continueCheckingTaskStatus": "Taakstatus blijven controleren",
   "newKnowledge.crawlAndPreview": "Crawlen en bekijken",
   "newKnowledge.crawlFailed": "Kan {{host}} niet crawlen",
   "newKnowledge.crawlFailed403": "De site retourneerde 403. Mogelijk worden crawlers geblokkeerd of is authenticatie vereist. Controleer de URL, pas de crawlopties aan of probeer een andere provider.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "We konden deze kennisbank niet creëren. Controleer uw toegang en probeer het opnieuw.",
   "newKnowledge.createIllustrationTitle": "Koppel je inhoud één keer — elke app antwoordt met de meest actuele kennis.",
   "newKnowledge.createTitle": "Creëer kennis",
+  "newKnowledge.createdAt": "Aangemaakt",
   "newKnowledge.creators": "Makers",
   "newKnowledge.customIntervalHours": "Aangepast interval (uren)",
   "newKnowledge.customIntervalInvalid": "Voer een geheel getal van 1 tot 720 uur in.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Dit bronconcept verwijderen?",
   "newKnowledge.documentActions": "Acties voor {{name}}",
   "newKnowledge.documentActionsUnavailable": "Documentacties zijn nog niet beschikbaar voor deze kennisbank.",
+  "newKnowledge.documentChunksEmpty": "Er zijn nog geen fragmenten beschikbaar voor deze revisie.",
+  "newKnowledge.documentChunksLoadError": "De fragmenten voor deze revisie konden niet worden geladen.",
+  "newKnowledge.documentChunksLoadMoreError": "Meer fragmenten konden niet worden geladen. Probeer het opnieuw.",
   "newKnowledge.documentColumn": "Document",
+  "newKnowledge.documentContentIncomplete": "Resterende documentinhoud laden…",
+  "newKnowledge.documentContents": "Inhoud",
+  "newKnowledge.documentFacts": "Documentdetails",
   "newKnowledge.documentFilterLabel": "Documenten filteren op status",
+  "newKnowledge.documentLoadErrorDescription": "Dit document kon niet worden geladen. Probeer het opnieuw.",
+  "newKnowledge.documentLoadErrorTitle": "Document kon niet worden geladen",
+  "newKnowledge.documentNotFoundDescription": "Dit document is mogelijk verwijderd of je hebt geen toegang.",
+  "newKnowledge.documentNotFoundTitle": "Document niet gevonden",
+  "newKnowledge.documentOverviewDescription": "Door documentmetadata te labelen kan AI er tijdig toegang toe krijgen en worden de bronnen van verwijzingen aan gebruikers getoond.",
   "newKnowledge.documentPermissionRestricted": "Uw werkruimtemachtigingen staan geen document- of taakacties toe.",
+  "newKnowledge.documentReindexConfirmationDelayed": "De herindexering is geaccepteerd, maar de taakstatus is vertraagd. Controleer deze voordat je opnieuw indient.",
+  "newKnowledge.documentReindexFailed": "Opnieuw indexeren is mislukt. De laatste gereedstaande revisie blijft beschikbaar.",
+  "newKnowledge.documentReindexProgress": "Opnieuw indexeren · {{progress}}%",
+  "newKnowledge.documentRevision": "Revisie",
+  "newKnowledge.documentRevisionMissingDescription": "Dit document heeft nog geen gereedstaande revisie. Kijk opnieuw nadat de verwerking is voltooid.",
+  "newKnowledge.documentRevisionMissingTitle": "Geen revisie beschikbaar",
+  "newKnowledge.documentRevisionsLoadError": "De revisiegeschiedenis kon niet worden geladen. De huidige revisie blijft beschikbaar.",
   "newKnowledge.documentStatus.disabled": "Uitgeschakeld",
   "newKnowledge.documentStatus.failed": "Mislukt",
   "newKnowledge.documentStatus.processing": "Verwerking",
   "newKnowledge.documentStatus.queued": "In de wachtrij",
   "newKnowledge.documentStatus.ready": "Klaar",
+  "newKnowledge.documentTaskLookupIncomplete": "Er is meer taakgeschiedenis beschikbaar. Blijf controleren om de status van dit document te vinden.",
   "newKnowledge.documentUploadExclusion.batchLimit": "limiet voor batchgrootte overschreden",
   "newKnowledge.documentUploadExclusion.countLimit": "limiet voor aantal bestanden overschreden",
   "newKnowledge.documentUploadExclusion.fileSize": "bestand is te groot",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— documenten",
   "newKnowledge.downloadDocuments": "Downloaden",
   "newKnowledge.editSource": "Bewerken",
+  "newKnowledge.emptyChunk": "Leeg fragment",
   "newKnowledge.emptyDescription": "Voeg je documenten toe zodat agents ze direct kunnen lezen, zonder indexering te configureren.",
   "newKnowledge.emptyTitle": "Een slimmere manier om kennisbanken te bouwen",
   "newKnowledge.errorDescription": "We konden je nieuwe kennisbanken niet laden. Probeer het opnieuw.",
   "newKnowledge.errorTitle": "Er is iets misgegaan",
+  "newKnowledge.fileSize": "Bestandsgrootte",
   "newKnowledge.filtersUnavailable": "Dit filter wordt beschikbaar zodra KnowledgeFS metadata aanbiedt.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl is niet beschikbaar in de providercatalogus voor deze werkruimte.",
   "newKnowledge.gotIt": "Begrepen",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Maak kennis met de nieuwe Kennisbank ✨",
   "newKnowledge.illustrationHeadline": "Koppel je content één keer — elke app antwoordt met de meest actuele kennis.",
   "newKnowledge.includeSubpages": "Subpagina’s opnemen",
+  "newKnowledge.indexInformation": "Indexinformatie",
   "newKnowledge.interruptTask": "Onderbreken",
   "newKnowledge.invalidRootUrl": "Voer een geldige http(s)-URL in.",
   "newKnowledge.keepEditing": "Doorgaan met bewerken",
+  "newKnowledge.lastIndexed": "Laatst geïndexeerd",
   "newKnowledge.lastReadyRevisionHint": "Een mislukte verwerking onderbreekt het ophalen nooit; de laatste gereedstaande revisie blijft beschikbaar in de inhoudsindex.",
   "newKnowledge.lastSyncColumn": "Laatste synchronisatie",
   "newKnowledge.learnMore": "Meer informatie",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Onvoltooide configuratie verlaten?",
   "newKnowledge.legacy": "Oud",
   "newKnowledge.loadMore": "Meer laden",
+  "newKnowledge.loadMoreRevisions": "Oudere revisies laden",
   "newKnowledge.loadingSyncPolicy": "Synchronisatiebeleid laden",
   "newKnowledge.manualUpload": "Handmatig uploaden",
   "newKnowledge.maxPages": "Maximumaantal pagina’s",
   "newKnowledge.metadata": "Metagegevens",
+  "newKnowledge.mimeType": "Bestandstype",
   "newKnowledge.moreProviders": "Meer providers",
   "newKnowledge.name": "Kennis naam",
   "newKnowledge.namePlaceholder": "bijv. Handboek voor klantenondersteuning",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Verbind Notion om pagina’s te kiezen en gesynchroniseerd te houden.",
   "newKnowledge.onlineDocuments": "Onlinedocumenten",
   "newKnowledge.onlineDrive": "Online rijden",
+  "newKnowledge.overview": "Overzicht",
   "newKnowledge.pagesAppearDescription": "Crawl de site om te bekijken welke pagina’s worden toegevoegd.",
   "newKnowledge.pagesAppearTitle": "Pagina’s verschijnen hier",
   "newKnowledge.pagesCrawled": "{{count}} pagina’s gecrawld op {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} is niet geconfigureerd",
   "newKnowledge.providerNotConfiguredDescription": "Voeg een API-sleutel of eindpunt-URL toe om websites te crawlen met {{provider}}.",
   "newKnowledge.providerUnavailable": "Deze aanbieder is niet beschikbaar.",
+  "newKnowledge.quality": "Kwaliteit",
   "newKnowledge.reCrawl": "Opnieuw crawlen",
   "newKnowledge.readOnlyEmpty": "Vraag een werkruimte-editor om de eerste kennisbank te maken.",
   "newKnowledge.refreshConnectionStatus": "Vernieuwingsstatus",
   "newKnowledge.refreshingConnection": "Verfrissen…",
+  "newKnowledge.reindexDocument": "Opnieuw indexeren",
   "newKnowledge.reindexDocuments": "Opnieuw indexeren",
   "newKnowledge.removeSource": "Bron verwijderen",
+  "newKnowledge.retrievalCount": "Aantal zoekacties",
   "newKnowledge.retryCrawl": "Crawl opnieuw proberen",
   "newKnowledge.retryProviderLoad": "Probeer het opnieuw",
+  "newKnowledge.retryReindexDocument": "Opnieuw herindexeren",
   "newKnowledge.retrySyncPolicy": "Synchronisatiebeleid opnieuw proberen",
   "newKnowledge.retryTask": "Opnieuw proberen",
+  "newKnowledge.revisionState.active": "Actief",
+  "newKnowledge.revisionState.candidate": "Wordt verwerkt",
+  "newKnowledge.revisionState.failed": "Mislukt",
+  "newKnowledge.revisionState.superseded": "Vorige",
   "newKnowledge.rootUrl": "Hoofd-URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Deze sectie komt beschikbaar in de volgende installatiestap.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Alles selecteren",
   "newKnowledge.selectAllDocuments": "Selecteer alle documenten",
   "newKnowledge.selectAllSources": "Alle bronnen selecteren",
+  "newKnowledge.selectChunk": "Selecteer een fragment om de inhoud te bekijken.",
   "newKnowledge.selectFilesAndFolders": "Selecteer bestanden en mappen om te synchroniseren",
   "newKnowledge.skippedFailed": "Overgeslagen (mislukt)",
   "newKnowledge.skippedOffDomain": "Overgeslagen (buiten domein)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Taken",
   "newKnowledge.tasksErrorDescription": "We konden achtergrondtaken niet laden. Probeer het opnieuw.",
   "newKnowledge.tasksWithAttention": "Taken, {{count}} hebben aandacht nodig",
+  "newKnowledge.tokenCount": "Tokeneenheden",
   "newKnowledge.unavailableDescription": "KnowledgeFS is momenteel niet beschikbaar voor deze werkruimte.",
   "newKnowledge.unavailableTitle": "Nieuwe kennis is niet beschikbaar",
   "newKnowledge.updated": "Bijgewerkt op {{date}}",
+  "newKnowledge.updatedAt": "Laatst bijgewerkt",
   "newKnowledge.updatedColumn": "Bijgewerkt",
   "newKnowledge.uploadCharactersUnavailable": "Tekens: —",
   "newKnowledge.uploadDocuments": "Documenten uploaden",

web/i18n/pl-PL/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Dostosuj i przeskanuj ponownie",
   "newKnowledge.allDocumentStatuses": "Wszystkie stany",
   "newKnowledge.allSources": "Wszystkie źródła",
+  "newKnowledge.apiAgentAccess": "Dostęp do API i agentów",
   "newKnowledge.appsUnavailable": "— aplikacji",
   "newKnowledge.authKind.api-key": "Klucz API",
   "newKnowledge.authKind.endpoint": "Punkt końcowy",
   "newKnowledge.authenticationMethod": "Metoda uwierzytelniania",
+  "newKnowledge.averageChunkLength": "Średnia długość fragmentu",
   "newKnowledge.backToList": "Powrót do baz wiedzy",
   "newKnowledge.backgroundTasks": "Zadania w tle",
   "newKnowledge.backgroundTasksDescription": "Dodawanie dokumentów, synchronizacja źródeł i ponowne indeksowanie zadań.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Zbiorcze akcje dokumentów",
   "newKnowledge.cancelAddSource": "Anuluj",
   "newKnowledge.cardType": "Przestrzeń wiedzy",
+  "newKnowledge.characterCount": "Znaki",
+  "newKnowledge.checkReindexStatus": "Sprawdź stan ponownego indeksowania",
+  "newKnowledge.chunkCount": "Fragmenty",
+  "newKnowledge.chunkHeading": "Fragment {{position}}",
+  "newKnowledge.chunkLocation": "Pozycja {{position}} w tej wersji",
   "newKnowledge.clearDocumentSelection": "Wyczyść wybór dokumentu",
   "newKnowledge.configureProvider": "Skonfiguruj {{provider}}",
   "newKnowledge.connectNotion": "Połącz z Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Odśwież połączenie przed dodaniem źródła strony internetowej.",
   "newKnowledge.connectionProvisioning": "{{provider}} łączy się",
   "newKnowledge.connectionRefreshFailed": "Nie mogliśmy odświeżyć tego połączenia. Spróbuj ponownie.",
+  "newKnowledge.continueCheckingTaskStatus": "Kontynuuj sprawdzanie stanu zadania",
   "newKnowledge.crawlAndPreview": "Indeksowanie i podgląd",
   "newKnowledge.crawlFailed": "Nie udało się przeskanować {{host}}",
   "newKnowledge.crawlFailed403": "Witryna zwróciła błąd 403 — może blokować roboty indeksujące lub wymagać uwierzytelnienia. Sprawdź adres URL, dostosuj opcje skanowania albo użyj innego dostawcy.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Nie mogliśmy utworzyć tej bazy wiedzy. Sprawdź swój dostęp i spróbuj ponownie.",
   "newKnowledge.createIllustrationTitle": "Połącz treści raz — każda aplikacja odpowie, korzystając z najnowszej wiedzy.",
   "newKnowledge.createTitle": "Twórz wiedzę",
+  "newKnowledge.createdAt": "Utworzono",
   "newKnowledge.creators": "Twórcy",
   "newKnowledge.customIntervalHours": "Niestandardowy interwał (godziny)",
   "newKnowledge.customIntervalInvalid": "Wprowadź liczbę całkowitą od 1 do 720 godzin.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Odrzucić tę wersję roboczą źródła?",
   "newKnowledge.documentActions": "Działania dla {{name}}",
   "newKnowledge.documentActionsUnavailable": "Działania dotyczące dokumentów nie są jeszcze dostępne dla tej bazy wiedzy.",
+  "newKnowledge.documentChunksEmpty": "Dla tej wersji nie ma jeszcze dostępnych fragmentów.",
+  "newKnowledge.documentChunksLoadError": "Nie udało się wczytać fragmentów tej wersji.",
+  "newKnowledge.documentChunksLoadMoreError": "Nie udało się wczytać kolejnych fragmentów. Spróbuj ponownie.",
   "newKnowledge.documentColumn": "Dokument",
+  "newKnowledge.documentContentIncomplete": "Wczytywanie pozostałej treści dokumentu…",
+  "newKnowledge.documentContents": "Zawartość",
+  "newKnowledge.documentFacts": "Szczegóły dokumentu",
   "newKnowledge.documentFilterLabel": "Filtruj dokumenty według statusu",
+  "newKnowledge.documentLoadErrorDescription": "Nie udało się wczytać tego dokumentu. Spróbuj ponownie.",
+  "newKnowledge.documentLoadErrorTitle": "Nie udało się wczytać dokumentu",
+  "newKnowledge.documentNotFoundDescription": "Dokument mógł zostać usunięty lub nie masz do niego dostępu.",
+  "newKnowledge.documentNotFoundTitle": "Nie znaleziono dokumentu",
+  "newKnowledge.documentOverviewDescription": "Oznaczanie metadanych dokumentów umożliwia AI szybki dostęp do nich i pokazuje użytkownikom źródła odwołań.",
   "newKnowledge.documentPermissionRestricted": "Uprawnienia Twojego obszaru roboczego nie pozwalają na działania na dokumentach ani zadaniach.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Ponowne indeksowanie zostało przyjęte, ale stan zadania jest opóźniony. Sprawdź go przed ponownym wysłaniem.",
+  "newKnowledge.documentReindexFailed": "Ponowne indeksowanie nie powiodło się. Ostatnia gotowa wersja pozostaje dostępna.",
+  "newKnowledge.documentReindexProgress": "Ponowne indeksowanie · {{progress}}%",
+  "newKnowledge.documentRevision": "Wersja",
+  "newKnowledge.documentRevisionMissingDescription": "Ten dokument nie ma jeszcze gotowej wersji. Sprawdź ponownie po zakończeniu przetwarzania.",
+  "newKnowledge.documentRevisionMissingTitle": "Brak dostępnej wersji",
+  "newKnowledge.documentRevisionsLoadError": "Nie udało się wczytać historii wersji. Bieżąca wersja pozostaje dostępna.",
   "newKnowledge.documentStatus.disabled": "Wyłączony",
   "newKnowledge.documentStatus.failed": "Nie udało się",
   "newKnowledge.documentStatus.processing": "Przetwarzanie",
   "newKnowledge.documentStatus.queued": "W kolejce",
   "newKnowledge.documentStatus.ready": "Gotowy",
+  "newKnowledge.documentTaskLookupIncomplete": "Dostępna jest dalsza historia zadań. Kontynuuj sprawdzanie, aby znaleźć stan tego dokumentu.",
   "newKnowledge.documentUploadExclusion.batchLimit": "przekroczono limit rozmiaru partii",
   "newKnowledge.documentUploadExclusion.countLimit": "przekroczono limit liczby plików",
   "newKnowledge.documentUploadExclusion.fileSize": "plik jest zbyt duży",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— dokumentów",
   "newKnowledge.downloadDocuments": "Pobierz",
   "newKnowledge.editSource": "Edytuj",
+  "newKnowledge.emptyChunk": "Pusty fragment",
   "newKnowledge.emptyDescription": "Dodaj dokumenty, aby agenci mogli je czytać bezpośrednio — bez konfigurowania indeksowania.",
   "newKnowledge.emptyTitle": "Inteligentniejszy sposób tworzenia baz wiedzy",
   "newKnowledge.errorDescription": "Nie udało się wczytać nowych baz wiedzy. Spróbuj ponownie.",
   "newKnowledge.errorTitle": "Coś poszło nie tak",
+  "newKnowledge.fileSize": "Rozmiar pliku",
   "newKnowledge.filtersUnavailable": "Filtr będzie dostępny, gdy KnowledgeFS udostępni metadane.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl nie jest dostępny w katalogu dostawców dla tego obszaru roboczego.",
   "newKnowledge.gotIt": "Rozumiem",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Poznaj nową bazę wiedzy ✨",
   "newKnowledge.illustrationHeadline": "Połącz treści raz — każda aplikacja odpowie, korzystając z najnowszej wiedzy.",
   "newKnowledge.includeSubpages": "Uwzględnij podstrony",
+  "newKnowledge.indexInformation": "Informacje o indeksie",
   "newKnowledge.interruptTask": "Przerwij",
   "newKnowledge.invalidRootUrl": "Wprowadź prawidłowy adres URL http(s).",
   "newKnowledge.keepEditing": "Kontynuuj edycję",
+  "newKnowledge.lastIndexed": "Ostatnio zindeksowano",
   "newKnowledge.lastReadyRevisionHint": "Nieudane przetwarzanie nigdy nie przerywa pobierania — ostatnia gotowa wersja pozostaje dostępna w indeksie zawartości.",
   "newKnowledge.lastSyncColumn": "Ostatnia synchronizacja",
   "newKnowledge.learnMore": "Dowiedz się więcej",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Opuścić nieukończoną konfigurację?",
   "newKnowledge.legacy": "Starsza wersja",
   "newKnowledge.loadMore": "Załaduj więcej",
+  "newKnowledge.loadMoreRevisions": "Wczytaj starsze wersje",
   "newKnowledge.loadingSyncPolicy": "Ładowanie zasad synchronizacji",
   "newKnowledge.manualUpload": "Przesyłanie ręczne",
   "newKnowledge.maxPages": "Maksymalna liczba stron",
   "newKnowledge.metadata": "Metadane",
+  "newKnowledge.mimeType": "Typ pliku",
   "newKnowledge.moreProviders": "Więcej dostawców",
   "newKnowledge.name": "Nazwa wiedzy",
   "newKnowledge.namePlaceholder": "np. Podręcznik obsługi klienta",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Połącz z Notion, aby wybrać strony i utrzymywać ich synchronizację.",
   "newKnowledge.onlineDocuments": "Dokumenty online",
   "newKnowledge.onlineDrive": "Dysk online",
+  "newKnowledge.overview": "Przegląd",
   "newKnowledge.pagesAppearDescription": "Przeskanuj witrynę, aby sprawdzić, które strony zostaną dodane.",
   "newKnowledge.pagesAppearTitle": "Strony pojawią się tutaj",
   "newKnowledge.pagesCrawled": "Przeskanowano {{count}} stron w {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} nie jest skonfigurowany",
   "newKnowledge.providerNotConfiguredDescription": "Dodaj klucz API lub adres URL punktu końcowego, aby indeksować strony internetowe za pomocą {{provider}}.",
   "newKnowledge.providerUnavailable": "Ten dostawca jest niedostępny.",
+  "newKnowledge.quality": "Jakość",
   "newKnowledge.reCrawl": "Przeskanuj ponownie",
   "newKnowledge.readOnlyEmpty": "Poproś edytora obszaru roboczego o utworzenie pierwszej bazy wiedzy.",
   "newKnowledge.refreshConnectionStatus": "Odśwież status",
   "newKnowledge.refreshingConnection": "Odświeżanie…",
+  "newKnowledge.reindexDocument": "Indeksuj ponownie",
   "newKnowledge.reindexDocuments": "Ponowne indeksowanie",
   "newKnowledge.removeSource": "Usuń źródło",
+  "newKnowledge.retrievalCount": "Liczba pobrań",
   "newKnowledge.retryCrawl": "Ponów skanowanie",
   "newKnowledge.retryProviderLoad": "Spróbuj ponownie",
+  "newKnowledge.retryReindexDocument": "Indeksuj ponownie",
   "newKnowledge.retrySyncPolicy": "Ponów ładowanie zasad synchronizacji",
   "newKnowledge.retryTask": "Spróbuj ponownie",
+  "newKnowledge.revisionState.active": "Aktywna",
+  "newKnowledge.revisionState.candidate": "Przetwarzanie",
+  "newKnowledge.revisionState.failed": "Niepowodzenie",
+  "newKnowledge.revisionState.superseded": "Poprzednia",
   "newKnowledge.rootUrl": "Główny adres URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Ta sekcja będzie dostępna w następnym kroku konfiguracji.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Zaznacz wszystko",
   "newKnowledge.selectAllDocuments": "Wybierz wszystkie dokumenty",
   "newKnowledge.selectAllSources": "Wybierz wszystkie źródła",
+  "newKnowledge.selectChunk": "Wybierz fragment, aby sprawdzić jego zawartość.",
   "newKnowledge.selectFilesAndFolders": "Wybierz pliki i foldery do synchronizacji",
   "newKnowledge.skippedFailed": "Pominięto (błąd)",
   "newKnowledge.skippedOffDomain": "Pominięto (poza domeną)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Zadania",
   "newKnowledge.tasksErrorDescription": "Nie udało się wczytać zadań w tle. Spróbuj ponownie.",
   "newKnowledge.tasksWithAttention": "Zadania, {{count}} wymagają uwagi",
+  "newKnowledge.tokenCount": "Tokeny",
   "newKnowledge.unavailableDescription": "KnowledgeFS nie jest obecnie dostępny dla tego obszaru roboczego.",
   "newKnowledge.unavailableTitle": "Nowa wiedza jest niedostępna",
   "newKnowledge.updated": "Zaktualizowano {{date}}",
+  "newKnowledge.updatedAt": "Ostatnia aktualizacja",
   "newKnowledge.updatedColumn": "Zaktualizowano",
   "newKnowledge.uploadCharactersUnavailable": "Znaki: —",
   "newKnowledge.uploadDocuments": "Prześlij dokumenty",

web/i18n/pt-BR/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Ajustar e rastrear novamente",
   "newKnowledge.allDocumentStatuses": "Todos os status",
   "newKnowledge.allSources": "Todas as fontes",
+  "newKnowledge.apiAgentAccess": "Acesso à API e aos agentes",
   "newKnowledge.appsUnavailable": "— apps",
   "newKnowledge.authKind.api-key": "Chave de API",
   "newKnowledge.authKind.endpoint": "Ponto final",
   "newKnowledge.authenticationMethod": "Método de autenticação",
+  "newKnowledge.averageChunkLength": "Comprimento médio do segmento",
   "newKnowledge.backToList": "Voltar às bases de conhecimento",
   "newKnowledge.backgroundTasks": "Tarefas em segundo plano",
   "newKnowledge.backgroundTasksDescription": "Adições de documentos, sincronizações de origem e reindexação de trabalhos.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Ações de documentos em massa",
   "newKnowledge.cancelAddSource": "Cancelar",
   "newKnowledge.cardType": "Espaço de conhecimento",
+  "newKnowledge.characterCount": "Caracteres",
+  "newKnowledge.checkReindexStatus": "Verificar status da reindexação",
+  "newKnowledge.chunkCount": "Segmentos",
+  "newKnowledge.chunkHeading": "Trecho {{position}}",
+  "newKnowledge.chunkLocation": "Posição {{position}} nesta revisão",
   "newKnowledge.clearDocumentSelection": "Limpar seleção de documentos",
   "newKnowledge.configureProvider": "Configurar {{provider}}",
   "newKnowledge.connectNotion": "Conectar o Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Atualize a conexão antes de adicionar uma fonte de site.",
   "newKnowledge.connectionProvisioning": "{{provider}} está se conectando",
   "newKnowledge.connectionRefreshFailed": "Não foi possível atualizar esta conexão. Tente novamente.",
+  "newKnowledge.continueCheckingTaskStatus": "Continuar verificando o status",
   "newKnowledge.crawlAndPreview": "Rastreamento e visualização",
   "newKnowledge.crawlFailed": "Não foi possível rastrear {{host}}",
   "newKnowledge.crawlFailed403": "O site retornou 403 — ele pode bloquear rastreadores ou exigir autenticação. Verifique a URL, ajuste as opções de rastreamento ou tente outro provedor.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Não foi possível criar esta base de conhecimento. Verifique seu acesso e tente novamente.",
   "newKnowledge.createIllustrationTitle": "Conecte seu conteúdo uma vez — cada aplicativo responde com o conhecimento mais atualizado.",
   "newKnowledge.createTitle": "Crie Conhecimento",
+  "newKnowledge.createdAt": "Criado",
   "newKnowledge.creators": "Criadores",
   "newKnowledge.customIntervalHours": "Intervalo personalizado (horas)",
   "newKnowledge.customIntervalInvalid": "Digite um número inteiro de 1 a 720 horas.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Descartar este rascunho de fonte?",
   "newKnowledge.documentActions": "Ações para {{name}}",
   "newKnowledge.documentActionsUnavailable": "As ações do documento ainda não estão disponíveis para esta base de conhecimento.",
+  "newKnowledge.documentChunksEmpty": "Ainda não há trechos disponíveis para esta revisão.",
+  "newKnowledge.documentChunksLoadError": "Não foi possível carregar os trechos desta revisão.",
+  "newKnowledge.documentChunksLoadMoreError": "Não foi possível carregar mais trechos. Tente novamente.",
   "newKnowledge.documentColumn": "Documento",
+  "newKnowledge.documentContentIncomplete": "Carregando o restante do conteúdo do documento…",
+  "newKnowledge.documentContents": "Conteúdo",
+  "newKnowledge.documentFacts": "Detalhes do documento",
   "newKnowledge.documentFilterLabel": "Filtrar documentos por status",
+  "newKnowledge.documentLoadErrorDescription": "Não foi possível carregar este documento. Tente novamente.",
+  "newKnowledge.documentLoadErrorTitle": "Não foi possível carregar o documento",
+  "newKnowledge.documentNotFoundDescription": "Este documento pode ter sido removido ou você pode não ter acesso.",
+  "newKnowledge.documentNotFoundTitle": "Documento não encontrado",
+  "newKnowledge.documentOverviewDescription": "Rotular os metadados dos documentos permite que a IA os acesse no momento certo e mostra aos usuários as fontes das referências.",
   "newKnowledge.documentPermissionRestricted": "As permissões do seu workspace não permitem ações em documentos ou tarefas.",
+  "newKnowledge.documentReindexConfirmationDelayed": "A reindexação foi aceita, mas o status da tarefa está atrasado. Verifique antes de enviar novamente.",
+  "newKnowledge.documentReindexFailed": "A reindexação falhou. A última revisão pronta continua disponível.",
+  "newKnowledge.documentReindexProgress": "Reindexando · {{progress}}%",
+  "newKnowledge.documentRevision": "Revisão",
+  "newKnowledge.documentRevisionMissingDescription": "Este documento ainda não tem uma revisão pronta. Volte após o processamento terminar.",
+  "newKnowledge.documentRevisionMissingTitle": "Nenhuma revisão disponível",
+  "newKnowledge.documentRevisionsLoadError": "Não foi possível carregar o histórico de revisões. A revisão atual continua disponível.",
   "newKnowledge.documentStatus.disabled": "Desativado",
   "newKnowledge.documentStatus.failed": "Falha",
   "newKnowledge.documentStatus.processing": "Processamento",
   "newKnowledge.documentStatus.queued": "Na fila",
   "newKnowledge.documentStatus.ready": "Pronto",
+  "newKnowledge.documentTaskLookupIncomplete": "Há mais histórico de tarefas disponível. Continue verificando para encontrar o status deste documento.",
   "newKnowledge.documentUploadExclusion.batchLimit": "limite de tamanho do lote excedido",
   "newKnowledge.documentUploadExclusion.countLimit": "limite de quantidade de arquivos excedido",
   "newKnowledge.documentUploadExclusion.fileSize": "o arquivo é muito grande",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— documentos",
   "newKnowledge.downloadDocuments": "Baixar",
   "newKnowledge.editSource": "Editar",
+  "newKnowledge.emptyChunk": "Trecho vazio",
   "newKnowledge.emptyDescription": "Adicione seus documentos para que os agentes possam lê-los diretamente, sem configurar a indexação.",
   "newKnowledge.emptyTitle": "Uma forma mais inteligente de criar bases de conhecimento",
   "newKnowledge.errorDescription": "Não foi possível carregar suas novas bases de conhecimento. Tente novamente.",
   "newKnowledge.errorTitle": "Algo deu errado",
+  "newKnowledge.fileSize": "Tamanho do arquivo",
   "newKnowledge.filtersUnavailable": "Este filtro ficará disponível quando o KnowledgeFS expuser seus metadados.",
   "newKnowledge.firecrawlUnavailable": "O Firecrawl não está disponível no catálogo de provedores deste espaço de trabalho.",
   "newKnowledge.gotIt": "Entendi",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Conheça a nova Base de Conhecimento ✨",
   "newKnowledge.illustrationHeadline": "Conecte seu conteúdo uma vez — cada aplicativo responderá com o conhecimento mais recente.",
   "newKnowledge.includeSubpages": "Incluir subpáginas",
+  "newKnowledge.indexInformation": "Informações do índice",
   "newKnowledge.interruptTask": "Interromper",
   "newKnowledge.invalidRootUrl": "Insira uma URL http(s) válida.",
   "newKnowledge.keepEditing": "Continuar editando",
+  "newKnowledge.lastIndexed": "Última indexação",
   "newKnowledge.lastReadyRevisionHint": "O processamento com falha nunca interrompe a recuperação — a última revisão pronta permanece disponível no índice de conteúdo.",
   "newKnowledge.lastSyncColumn": "Última sincronização",
   "newKnowledge.learnMore": "Saiba mais",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Sair da configuração incompleta?",
   "newKnowledge.legacy": "Legado",
   "newKnowledge.loadMore": "Carregar mais",
+  "newKnowledge.loadMoreRevisions": "Carregar revisões anteriores",
   "newKnowledge.loadingSyncPolicy": "Carregando política de sincronização",
   "newKnowledge.manualUpload": "Carregamento manual",
   "newKnowledge.maxPages": "Máximo de páginas",
   "newKnowledge.metadata": "Metadados",
+  "newKnowledge.mimeType": "Tipo de arquivo",
   "newKnowledge.moreProviders": "Mais provedores",
   "newKnowledge.name": "Nome do conhecimento",
   "newKnowledge.namePlaceholder": "por exemplo Manual de Suporte ao Cliente",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Conecte o Notion para escolher páginas e mantê-las sincronizadas.",
   "newKnowledge.onlineDocuments": "Documentos on-line",
   "newKnowledge.onlineDrive": "Unidade on-line",
+  "newKnowledge.overview": "Visão geral",
   "newKnowledge.pagesAppearDescription": "Rastreie o site para revisar quais páginas serão adicionadas.",
   "newKnowledge.pagesAppearTitle": "As páginas aparecerão aqui",
   "newKnowledge.pagesCrawled": "{{count}} páginas rastreadas em {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} não está configurado",
   "newKnowledge.providerNotConfiguredDescription": "Adicione uma chave de API ou URL de endpoint para rastrear sites com {{provider}}.",
   "newKnowledge.providerUnavailable": "Este provedor não está disponível.",
+  "newKnowledge.quality": "Qualidade",
   "newKnowledge.reCrawl": "Rastrear novamente",
   "newKnowledge.readOnlyEmpty": "Peça a um editor do espaço de trabalho para criar a primeira base de conhecimento.",
   "newKnowledge.refreshConnectionStatus": "Atualizar status",
   "newKnowledge.refreshingConnection": "Refrescante…",
+  "newKnowledge.reindexDocument": "Reindexar",
   "newKnowledge.reindexDocuments": "Reindexar",
   "newKnowledge.removeSource": "Remover fonte",
+  "newKnowledge.retrievalCount": "Quantidade de recuperações",
   "newKnowledge.retryCrawl": "Tentar rastreamento novamente",
   "newKnowledge.retryProviderLoad": "Tentar novamente",
+  "newKnowledge.retryReindexDocument": "Reindexar novamente",
   "newKnowledge.retrySyncPolicy": "Tentar novamente a política de sincronização",
   "newKnowledge.retryTask": "Tentar novamente",
+  "newKnowledge.revisionState.active": "Ativa",
+  "newKnowledge.revisionState.candidate": "Processando",
+  "newKnowledge.revisionState.failed": "Falhou",
+  "newKnowledge.revisionState.superseded": "Anterior",
   "newKnowledge.rootUrl": "URL raiz",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Esta seção estará disponível na próxima etapa de configuração.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Selecionar tudo",
   "newKnowledge.selectAllDocuments": "Selecione todos os documentos",
   "newKnowledge.selectAllSources": "Selecionar todas as origens",
+  "newKnowledge.selectChunk": "Selecione um trecho para inspecionar seu conteúdo.",
   "newKnowledge.selectFilesAndFolders": "Selecione arquivos e pastas para sincronizar",
   "newKnowledge.skippedFailed": "Ignorado (falha)",
   "newKnowledge.skippedOffDomain": "Ignorado (fora do domínio)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Tarefas",
   "newKnowledge.tasksErrorDescription": "Não foi possível carregar tarefas em segundo plano. Tente novamente.",
   "newKnowledge.tasksWithAttention": "Tarefas, {{count}} precisam de atenção",
+  "newKnowledge.tokenCount": "Unidades de token",
   "newKnowledge.unavailableDescription": "O KnowledgeFS não está disponível para este espaço de trabalho no momento.",
   "newKnowledge.unavailableTitle": "O Novo Conhecimento não está disponível",
   "newKnowledge.updated": "Atualizado em {{date}}",
+  "newKnowledge.updatedAt": "Última atualização",
   "newKnowledge.updatedColumn": "Atualizado",
   "newKnowledge.uploadCharactersUnavailable": "Caracteres: —",
   "newKnowledge.uploadDocuments": "Carregar documentos",

web/i18n/ro-RO/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Ajustează și explorează din nou",
   "newKnowledge.allDocumentStatuses": "Toate statutul",
   "newKnowledge.allSources": "Toate sursele",
+  "newKnowledge.apiAgentAccess": "Acces API și agenți",
   "newKnowledge.appsUnavailable": "— aplicații",
   "newKnowledge.authKind.api-key": "cheie API",
   "newKnowledge.authKind.endpoint": "Punct final",
   "newKnowledge.authenticationMethod": "Metoda de autentificare",
+  "newKnowledge.averageChunkLength": "Lungimea medie a segmentului",
   "newKnowledge.backToList": "Înapoi la bazele de cunoștințe",
   "newKnowledge.backgroundTasks": "Sarcini de fundal",
   "newKnowledge.backgroundTasksDescription": "Adăugări de documente, sincronizare sursă și reindexare lucrări.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Acțiuni în bloc pentru documente",
   "newKnowledge.cancelAddSource": "Anula",
   "newKnowledge.cardType": "Spațiu de cunoștințe",
+  "newKnowledge.characterCount": "Caractere",
+  "newKnowledge.checkReindexStatus": "Verifică starea reindexării",
+  "newKnowledge.chunkCount": "Segmente",
+  "newKnowledge.chunkHeading": "Fragment {{position}}",
+  "newKnowledge.chunkLocation": "Poziția {{position}} în această revizie",
   "newKnowledge.clearDocumentSelection": "Ștergeți selecția documentului",
   "newKnowledge.configureProvider": "Configurați {{provider}}",
   "newKnowledge.connectNotion": "Conectează Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Reîmprospătați conexiunea înainte de a adăuga o sursă de site.",
   "newKnowledge.connectionProvisioning": "{{provider}} se conectează",
   "newKnowledge.connectionRefreshFailed": "Nu am putut reîmprospăta această conexiune. Încearcă din nou.",
+  "newKnowledge.continueCheckingTaskStatus": "Continuă verificarea stării",
   "newKnowledge.crawlAndPreview": "Accesați cu crawlere și previzualizați",
   "newKnowledge.crawlFailed": "Nu s-a putut explora {{host}}",
   "newKnowledge.crawlFailed403": "Site-ul a returnat 403 — este posibil să blocheze crawlerele sau să necesite autentificare. Verifică adresa URL, ajustează opțiunile de explorare sau încearcă alt furnizor.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Nu am putut crea această bază de cunoștințe. Verificați accesul și încercați din nou.",
   "newKnowledge.createIllustrationTitle": "Conectează conținutul o singură dată — fiecare aplicație răspunde cu cele mai noi cunoștințe.",
   "newKnowledge.createTitle": "Creați cunoștințe",
+  "newKnowledge.createdAt": "Creat",
   "newKnowledge.creators": "Creatori",
   "newKnowledge.customIntervalHours": "Interval personalizat (ore)",
   "newKnowledge.customIntervalInvalid": "Introdu un număr întreg între 1 și 720 de ore.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Elimini această schiță de sursă?",
   "newKnowledge.documentActions": "Acțiuni pentru {{name}}",
   "newKnowledge.documentActionsUnavailable": "Acțiunile documentului nu sunt încă disponibile pentru această bază de cunoștințe.",
+  "newKnowledge.documentChunksEmpty": "Nu există încă fragmente disponibile pentru această revizie.",
+  "newKnowledge.documentChunksLoadError": "Nu am putut încărca fragmentele acestei revizii.",
+  "newKnowledge.documentChunksLoadMoreError": "Nu am putut încărca mai multe fragmente. Încearcă din nou.",
   "newKnowledge.documentColumn": "Fișier",
+  "newKnowledge.documentContentIncomplete": "Se încarcă restul conținutului documentului…",
+  "newKnowledge.documentContents": "Conținut",
+  "newKnowledge.documentFacts": "Detalii document",
   "newKnowledge.documentFilterLabel": "Filtrați documentele după stare",
+  "newKnowledge.documentLoadErrorDescription": "Nu am putut încărca acest document. Încearcă din nou.",
+  "newKnowledge.documentLoadErrorTitle": "Documentul nu a putut fi încărcat",
+  "newKnowledge.documentNotFoundDescription": "Este posibil ca documentul să fi fost eliminat sau să nu ai acces.",
+  "newKnowledge.documentNotFoundTitle": "Document negăsit",
+  "newKnowledge.documentOverviewDescription": "Etichetarea metadatelor documentelor permite inteligenței artificiale să le acceseze la timp și le arată utilizatorilor sursele referințelor.",
   "newKnowledge.documentPermissionRestricted": "Permisiunile spațiului de lucru nu permit acțiuni asupra documentelor sau sarcinilor.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Reindexarea a fost acceptată, dar starea activității întârzie. Verific-o înainte de a retrimite.",
+  "newKnowledge.documentReindexFailed": "Reindexarea a eșuat. Ultima revizie pregătită rămâne disponibilă.",
+  "newKnowledge.documentReindexProgress": "Se reindexează · {{progress}}%",
+  "newKnowledge.documentRevision": "Revizie",
+  "newKnowledge.documentRevisionMissingDescription": "Acest document nu are încă o revizie pregătită. Revino după finalizarea procesării.",
+  "newKnowledge.documentRevisionMissingTitle": "Nicio revizie disponibilă",
+  "newKnowledge.documentRevisionsLoadError": "Nu am putut încărca istoricul reviziilor. Revizia curentă rămâne disponibilă.",
   "newKnowledge.documentStatus.disabled": "Dezactivat",
   "newKnowledge.documentStatus.failed": "A eșuat",
   "newKnowledge.documentStatus.processing": "Prelucrare",
   "newKnowledge.documentStatus.queued": "În coadă",
   "newKnowledge.documentStatus.ready": "Gata",
+  "newKnowledge.documentTaskLookupIncomplete": "Este disponibil mai mult istoric al activităților. Continuă verificarea pentru a găsi starea documentului.",
   "newKnowledge.documentUploadExclusion.batchLimit": "limita dimensiunii lotului a fost depășită",
   "newKnowledge.documentUploadExclusion.countLimit": "limita numărului de fișiere a fost depășită",
   "newKnowledge.documentUploadExclusion.fileSize": "fișierul este prea mare",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— documente",
   "newKnowledge.downloadDocuments": "Descărcați",
   "newKnowledge.editSource": "Edita",
+  "newKnowledge.emptyChunk": "Fragment gol",
   "newKnowledge.emptyDescription": "Adaugă documentele, iar agenții le pot citi direct — fără indexare de configurat.",
   "newKnowledge.emptyTitle": "O modalitate mai inteligentă de a crea baze de cunoștințe",
   "newKnowledge.errorDescription": "Nu am putut încărca noile baze de cunoștințe. Încearcă din nou.",
   "newKnowledge.errorTitle": "Ceva nu a funcționat",
+  "newKnowledge.fileSize": "Dimensiunea fișierului",
   "newKnowledge.filtersUnavailable": "Acest filtru va fi disponibil când KnowledgeFS va furniza metadatele.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl nu este disponibil în catalogul furnizorilor pentru acest spațiu de lucru.",
   "newKnowledge.gotIt": "Am înțeles",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Descoperă noua bază de cunoștințe ✨",
   "newKnowledge.illustrationHeadline": "Conectează conținutul o singură dată — fiecare aplicație răspunde cu cele mai noi informații.",
   "newKnowledge.includeSubpages": "Include subpaginile",
+  "newKnowledge.indexInformation": "Informații despre index",
   "newKnowledge.interruptTask": "Întrerupe",
   "newKnowledge.invalidRootUrl": "Introdu o adresă URL http(s) validă.",
   "newKnowledge.keepEditing": "Continuă editarea",
+  "newKnowledge.lastIndexed": "Ultima indexare",
   "newKnowledge.lastReadyRevisionHint": "Procesarea eșuată nu întrerupe niciodată recuperarea — ultima revizuire gata rămâne disponibilă în indexul de conținut.",
   "newKnowledge.lastSyncColumn": "Ultima sincronizare",
   "newKnowledge.learnMore": "Află mai multe",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Ieșiți din configurarea incompletă?",
   "newKnowledge.legacy": "Versiune veche",
   "newKnowledge.loadMore": "Încarcă mai multe",
+  "newKnowledge.loadMoreRevisions": "Încarcă revizii mai vechi",
   "newKnowledge.loadingSyncPolicy": "Se încarcă politica de sincronizare",
   "newKnowledge.manualUpload": "Încărcare manuală",
   "newKnowledge.maxPages": "Număr maxim de pagini",
   "newKnowledge.metadata": "Metadate",
+  "newKnowledge.mimeType": "Tip de fișier",
   "newKnowledge.moreProviders": "Mai mulți furnizori",
   "newKnowledge.name": "Nume de cunoștințe",
   "newKnowledge.namePlaceholder": "de ex. Manual de asistență pentru clienți",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Conectează Notion pentru a alege pagini și a le menține sincronizate.",
   "newKnowledge.onlineDocuments": "Documente online",
   "newKnowledge.onlineDrive": "Conducere online",
+  "newKnowledge.overview": "Prezentare generală",
   "newKnowledge.pagesAppearDescription": "Explorează site-ul pentru a verifica paginile care vor fi adăugate.",
   "newKnowledge.pagesAppearTitle": "Paginile vor apărea aici",
   "newKnowledge.pagesCrawled": "{{count}} pagini explorate la {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} nu este configurat",
   "newKnowledge.providerNotConfiguredDescription": "Adăugați o cheie API sau o adresă URL a punctului final pentru a accesa cu crawlere site-urile web cu {{provider}}.",
   "newKnowledge.providerUnavailable": "Acest furnizor nu este disponibil.",
+  "newKnowledge.quality": "Calitate",
   "newKnowledge.reCrawl": "Explorează din nou",
   "newKnowledge.readOnlyEmpty": "Cere unui editor al spațiului de lucru să creeze prima bază de cunoștințe.",
   "newKnowledge.refreshConnectionStatus": "Starea de reîmprospătare",
   "newKnowledge.refreshingConnection": "Înviorare…",
+  "newKnowledge.reindexDocument": "Reindexează",
   "newKnowledge.reindexDocuments": "Reindexați",
   "newKnowledge.removeSource": "Eliminați sursa",
+  "newKnowledge.retrievalCount": "Număr de regăsiri",
   "newKnowledge.retryCrawl": "Reîncearcă explorarea",
   "newKnowledge.retryProviderLoad": "Reîncercați",
+  "newKnowledge.retryReindexDocument": "Reindexează din nou",
   "newKnowledge.retrySyncPolicy": "Reîncearcă politica de sincronizare",
   "newKnowledge.retryTask": "Reîncercați",
+  "newKnowledge.revisionState.active": "Activă",
+  "newKnowledge.revisionState.candidate": "În procesare",
+  "newKnowledge.revisionState.failed": "Eșuată",
+  "newKnowledge.revisionState.superseded": "Anterioară",
   "newKnowledge.rootUrl": "URL rădăcină",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Această secțiune va deveni disponibilă în următorul pas de configurare.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Selectează tot",
   "newKnowledge.selectAllDocuments": "Selectați toate documentele",
   "newKnowledge.selectAllSources": "Selectează toate sursele",
+  "newKnowledge.selectChunk": "Selectează un fragment pentru a-i verifica conținutul.",
   "newKnowledge.selectFilesAndFolders": "Selectează fișierele și folderele de sincronizat",
   "newKnowledge.skippedFailed": "Omis (eșuat)",
   "newKnowledge.skippedOffDomain": "Omis (în afara domeniului)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Sarcini",
   "newKnowledge.tasksErrorDescription": "Nu am putut încărca sarcinile de fundal. Încearcă din nou.",
   "newKnowledge.tasksWithAttention": "Sarcini, {{count}} necesită atenție",
+  "newKnowledge.tokenCount": "Tokenuri",
   "newKnowledge.unavailableDescription": "KnowledgeFS nu este disponibil momentan pentru acest spațiu de lucru.",
   "newKnowledge.unavailableTitle": "Noua bază de cunoștințe nu este disponibilă",
   "newKnowledge.updated": "Actualizat la {{date}}",
+  "newKnowledge.updatedAt": "Ultima actualizare",
   "newKnowledge.updatedColumn": "Actualizat",
   "newKnowledge.uploadCharactersUnavailable": "Caractere: —",
   "newKnowledge.uploadDocuments": "Încărcați documente",

web/i18n/ru-RU/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Настроить и просканировать снова",
   "newKnowledge.allDocumentStatuses": "Все статусы",
   "newKnowledge.allSources": "Все источники",
+  "newKnowledge.apiAgentAccess": "Доступ к API и агентам",
   "newKnowledge.appsUnavailable": "— приложений",
   "newKnowledge.authKind.api-key": "API-ключ",
   "newKnowledge.authKind.endpoint": "Конечная точка",
   "newKnowledge.authenticationMethod": "Метод аутентификации",
+  "newKnowledge.averageChunkLength": "Средняя длина фрагмента",
   "newKnowledge.backToList": "Вернуться к базам знаний",
   "newKnowledge.backgroundTasks": "Фоновые задачи",
   "newKnowledge.backgroundTasksDescription": "Добавление документов, синхронизация источников и переиндексация заданий.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Массовые действия с документами",
   "newKnowledge.cancelAddSource": "Отмена",
   "newKnowledge.cardType": "Пространство знаний",
+  "newKnowledge.characterCount": "Символы",
+  "newKnowledge.checkReindexStatus": "Проверить статус переиндексации",
+  "newKnowledge.chunkCount": "Фрагменты",
+  "newKnowledge.chunkHeading": "Фрагмент {{position}}",
+  "newKnowledge.chunkLocation": "Позиция {{position}} в этой редакции",
   "newKnowledge.clearDocumentSelection": "Очистить выбор документа",
   "newKnowledge.configureProvider": "Настроить {{provider}}",
   "newKnowledge.connectNotion": "Подключить Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Обновите соединение перед добавлением источника веб-сайта.",
   "newKnowledge.connectionProvisioning": "{{provider}} подключается",
   "newKnowledge.connectionRefreshFailed": "Не удалось обновить это соединение. Попробуйте еще раз.",
+  "newKnowledge.continueCheckingTaskStatus": "Продолжить проверку статуса",
   "newKnowledge.crawlAndPreview": "Сканирование и предварительный просмотр",
   "newKnowledge.crawlFailed": "Не удалось просканировать {{host}}",
   "newKnowledge.crawlFailed403": "Сайт вернул ошибку 403 — возможно, он блокирует поисковых роботов или требует авторизации. Проверьте URL, измените параметры сканирования или попробуйте другого провайдера.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Мы не смогли создать эту базу знаний. Проверьте доступ и повторите попытку.",
   "newKnowledge.createIllustrationTitle": "Подключите контент один раз — каждое приложение будет отвечать на основе самых свежих знаний.",
   "newKnowledge.createTitle": "Создавайте знания",
+  "newKnowledge.createdAt": "Создано",
   "newKnowledge.creators": "Создатели",
   "newKnowledge.customIntervalHours": "Пользовательский интервал (часы)",
   "newKnowledge.customIntervalInvalid": "Введите целое число от 1 до 720 часов.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Удалить этот черновик источника?",
   "newKnowledge.documentActions": "Действия для {{name}}",
   "newKnowledge.documentActionsUnavailable": "Действия с документами пока недоступны для этой базы знаний.",
+  "newKnowledge.documentChunksEmpty": "Для этой редакции пока нет доступных фрагментов.",
+  "newKnowledge.documentChunksLoadError": "Не удалось загрузить фрагменты этой редакции.",
+  "newKnowledge.documentChunksLoadMoreError": "Не удалось загрузить дополнительные фрагменты. Повторите попытку.",
   "newKnowledge.documentColumn": "Документ",
+  "newKnowledge.documentContentIncomplete": "Загружается оставшееся содержимое документа…",
+  "newKnowledge.documentContents": "Содержание",
+  "newKnowledge.documentFacts": "Сведения о документе",
   "newKnowledge.documentFilterLabel": "Фильтровать документы по статусу",
+  "newKnowledge.documentLoadErrorDescription": "Не удалось загрузить этот документ. Повторите попытку.",
+  "newKnowledge.documentLoadErrorTitle": "Не удалось загрузить документ",
+  "newKnowledge.documentNotFoundDescription": "Возможно, документ удалён или у вас нет доступа.",
+  "newKnowledge.documentNotFoundTitle": "Документ не найден",
+  "newKnowledge.documentOverviewDescription": "Разметка метаданных документов позволяет ИИ своевременно получать к ним доступ и показывает пользователям источники ссылок.",
   "newKnowledge.documentPermissionRestricted": "Разрешения вашего рабочего пространства не позволяют выполнять действия с документами или задачами.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Переиндексация принята, но статус задачи задерживается. Проверьте его перед повторной отправкой.",
+  "newKnowledge.documentReindexFailed": "Переиндексация завершилась с ошибкой. Последняя готовая редакция остаётся доступной.",
+  "newKnowledge.documentReindexProgress": "Переиндексация · {{progress}}%",
+  "newKnowledge.documentRevision": "Редакция",
+  "newKnowledge.documentRevisionMissingDescription": "У этого документа пока нет готовой редакции. Проверьте снова после завершения обработки.",
+  "newKnowledge.documentRevisionMissingTitle": "Нет доступной редакции",
+  "newKnowledge.documentRevisionsLoadError": "Не удалось загрузить историю редакций. Текущая редакция остаётся доступной.",
   "newKnowledge.documentStatus.disabled": "Отключено",
   "newKnowledge.documentStatus.failed": "Не удалось",
   "newKnowledge.documentStatus.processing": "Обработка",
   "newKnowledge.documentStatus.queued": "В очереди",
   "newKnowledge.documentStatus.ready": "Готово",
+  "newKnowledge.documentTaskLookupIncomplete": "Доступна дополнительная история задач. Продолжите проверку, чтобы найти статус документа.",
   "newKnowledge.documentUploadExclusion.batchLimit": "превышен предел размера пакета",
   "newKnowledge.documentUploadExclusion.countLimit": "превышен предел количества файлов",
   "newKnowledge.documentUploadExclusion.fileSize": "файл слишком большой",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— документов",
   "newKnowledge.downloadDocuments": "Скачать",
   "newKnowledge.editSource": "Править",
+  "newKnowledge.emptyChunk": "Пустой фрагмент",
   "newKnowledge.emptyDescription": "Добавьте документы, и агенты смогут читать их напрямую — без настройки индексации.",
   "newKnowledge.emptyTitle": "Более умный способ создавать базы знаний",
   "newKnowledge.errorDescription": "Не удалось загрузить новые базы знаний. Повторите попытку.",
   "newKnowledge.errorTitle": "Что-то пошло не так",
+  "newKnowledge.fileSize": "Размер файла",
   "newKnowledge.filtersUnavailable": "Фильтр станет доступен, когда KnowledgeFS предоставит метаданные.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl недоступен в каталоге поставщиков для этой рабочей области.",
   "newKnowledge.gotIt": "Понятно",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Познакомьтесь с новой базой знаний ✨",
   "newKnowledge.illustrationHeadline": "Подключите контент один раз — и каждое приложение будет отвечать на основе самых свежих знаний.",
   "newKnowledge.includeSubpages": "Включать вложенные страницы",
+  "newKnowledge.indexInformation": "Сведения об индексе",
   "newKnowledge.interruptTask": "Прерывание",
   "newKnowledge.invalidRootUrl": "Введите корректный URL с http(s).",
   "newKnowledge.keepEditing": "Продолжить редактирование",
+  "newKnowledge.lastIndexed": "Последняя индексация",
   "newKnowledge.lastReadyRevisionHint": "Неудачная обработка никогда не прерывает извлечение — последняя готовая редакция остается доступной в индексе контента.",
   "newKnowledge.lastSyncColumn": "Последняя синхронизация",
   "newKnowledge.learnMore": "Подробнее",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Выйти из незавершённой настройки?",
   "newKnowledge.legacy": "Предыдущая версия",
   "newKnowledge.loadMore": "Загрузить ещё",
+  "newKnowledge.loadMoreRevisions": "Загрузить предыдущие редакции",
   "newKnowledge.loadingSyncPolicy": "Загрузка политики синхронизации",
   "newKnowledge.manualUpload": "Загрузка вручную",
   "newKnowledge.maxPages": "Максимум страниц",
   "newKnowledge.metadata": "Метаданные",
+  "newKnowledge.mimeType": "Тип файла",
   "newKnowledge.moreProviders": "Другие провайдеры",
   "newKnowledge.name": "Название знания",
   "newKnowledge.namePlaceholder": "например Руководство по поддержке клиентов",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Подключите Notion, чтобы выбирать страницы и поддерживать их синхронизацию.",
   "newKnowledge.onlineDocuments": "Онлайн-документы",
   "newKnowledge.onlineDrive": "Онлайн-диск",
+  "newKnowledge.overview": "Обзор",
   "newKnowledge.pagesAppearDescription": "Просканируйте сайт, чтобы проверить, какие страницы будут добавлены.",
   "newKnowledge.pagesAppearTitle": "Здесь появятся страницы",
   "newKnowledge.pagesCrawled": "Просканировано страниц на {{host}}: {{count}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} не настроено",
   "newKnowledge.providerNotConfiguredDescription": "Добавьте ключ API или URL-адрес конечной точки для сканирования веб-сайтов с помощью {{provider}}.",
   "newKnowledge.providerUnavailable": "Этот провайдер недоступен.",
+  "newKnowledge.quality": "Качество",
   "newKnowledge.reCrawl": "Просканировать снова",
   "newKnowledge.readOnlyEmpty": "Попросите редактора рабочего пространства создать первую базу знаний.",
   "newKnowledge.refreshConnectionStatus": "Обновить статус",
   "newKnowledge.refreshingConnection": "Обновление…",
+  "newKnowledge.reindexDocument": "Переиндексировать",
   "newKnowledge.reindexDocuments": "Переиндексация",
   "newKnowledge.removeSource": "Удалить источник",
+  "newKnowledge.retrievalCount": "Количество извлечений",
   "newKnowledge.retryCrawl": "Повторить сканирование",
   "newKnowledge.retryProviderLoad": "Повторить попытку",
+  "newKnowledge.retryReindexDocument": "Переиндексировать снова",
   "newKnowledge.retrySyncPolicy": "Повторить загрузку политики синхронизации",
   "newKnowledge.retryTask": "Повторить попытку",
+  "newKnowledge.revisionState.active": "Активная",
+  "newKnowledge.revisionState.candidate": "Обработка",
+  "newKnowledge.revisionState.failed": "Ошибка",
+  "newKnowledge.revisionState.superseded": "Предыдущая",
   "newKnowledge.rootUrl": "Корневой URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Этот раздел станет доступен на следующем этапе настройки.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Выбрать все",
   "newKnowledge.selectAllDocuments": "Выбрать все документы",
   "newKnowledge.selectAllSources": "Выбрать все источники",
+  "newKnowledge.selectChunk": "Выберите фрагмент, чтобы просмотреть его содержимое.",
   "newKnowledge.selectFilesAndFolders": "Выберите файлы и папки для синхронизации",
   "newKnowledge.skippedFailed": "Пропущено (ошибка)",
   "newKnowledge.skippedOffDomain": "Пропущено (вне домена)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Задачи",
   "newKnowledge.tasksErrorDescription": "Не удалось загрузить фоновые задачи. Попробуйте еще раз.",
   "newKnowledge.tasksWithAttention": "Задачи, {{count}} требуют внимания",
+  "newKnowledge.tokenCount": "Токены",
   "newKnowledge.unavailableDescription": "KnowledgeFS сейчас недоступен для этого рабочего пространства.",
   "newKnowledge.unavailableTitle": "Новая база знаний недоступна",
   "newKnowledge.updated": "Обновлено {{date}}",
+  "newKnowledge.updatedAt": "Последнее обновление",
   "newKnowledge.updatedColumn": "Обновлено",
   "newKnowledge.uploadCharactersUnavailable": "Символы: —",
   "newKnowledge.uploadDocuments": "Загрузить документы",

web/i18n/sl-SI/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Prilagodi in ponovno preišči",
   "newKnowledge.allDocumentStatuses": "Vsi statusi",
   "newKnowledge.allSources": "Vsi viri",
+  "newKnowledge.apiAgentAccess": "Dostop do API-ja in agentov",
   "newKnowledge.appsUnavailable": "— aplikacij",
   "newKnowledge.authKind.api-key": "API ključ",
   "newKnowledge.authKind.endpoint": "Končna točka",
   "newKnowledge.authenticationMethod": "Metoda avtentikacije",
+  "newKnowledge.averageChunkLength": "Povprečna dolžina odseka",
   "newKnowledge.backToList": "Nazaj k bazam znanja",
   "newKnowledge.backgroundTasks": "Naloge v ozadju",
   "newKnowledge.backgroundTasksDescription": "Dodajanje dokumentov, sinhronizacija virov in ponovno indeksiranje opravil.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Dejanja množičnih dokumentov",
   "newKnowledge.cancelAddSource": "Prekliči",
   "newKnowledge.cardType": "Prostor znanja",
+  "newKnowledge.characterCount": "Znaki",
+  "newKnowledge.checkReindexStatus": "Preveri stanje ponovnega indeksiranja",
+  "newKnowledge.chunkCount": "Odseki",
+  "newKnowledge.chunkHeading": "Del {{position}}",
+  "newKnowledge.chunkLocation": "Položaj {{position}} v tej različici",
   "newKnowledge.clearDocumentSelection": "Počisti izbiro dokumenta",
   "newKnowledge.configureProvider": "Konfigurirajte {{provider}}",
   "newKnowledge.connectNotion": "Poveži Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Osvežite povezavo, preden dodate vir spletnega mesta.",
   "newKnowledge.connectionProvisioning": "{{provider}} vzpostavlja povezavo",
   "newKnowledge.connectionRefreshFailed": "Te povezave nismo mogli osvežiti. Poskusite znova.",
+  "newKnowledge.continueCheckingTaskStatus": "Nadaljuj preverjanje stanja opravila",
   "newKnowledge.crawlAndPreview": "Iskanje in predogled",
   "newKnowledge.crawlFailed": "Spletnega mesta {{host}} ni bilo mogoče preiskati",
   "newKnowledge.crawlFailed403": "Spletno mesto je vrnilo napako 403 — morda blokira pajke ali zahteva prijavo. Preverite URL, prilagodite možnosti preiskovanja ali poskusite drugega ponudnika.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Te baze znanja nismo mogli ustvariti. Preverite dostop in poskusite znova.",
   "newKnowledge.createIllustrationTitle": "Vsebino povežite enkrat — vsaka aplikacija odgovarja z najnovejšim znanjem.",
   "newKnowledge.createTitle": "Ustvarite znanje",
+  "newKnowledge.createdAt": "Ustvarjeno",
   "newKnowledge.creators": "Ustvarjalci",
   "newKnowledge.customIntervalHours": "Interval po meri (ure)",
   "newKnowledge.customIntervalInvalid": "Vnesite celo število od 1 do 720 ur.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Želite zavreči ta osnutek vira?",
   "newKnowledge.documentActions": "Dejanja za {{name}}",
   "newKnowledge.documentActionsUnavailable": "Dejanja dokumentov še niso na voljo za to bazo znanja.",
+  "newKnowledge.documentChunksEmpty": "Za to različico še ni razpoložljivih delov.",
+  "newKnowledge.documentChunksLoadError": "Delov te različice ni bilo mogoče naložiti.",
+  "newKnowledge.documentChunksLoadMoreError": "Dodatnih delov ni bilo mogoče naložiti. Poskusite znova.",
   "newKnowledge.documentColumn": "Dokument",
+  "newKnowledge.documentContentIncomplete": "Nalaganje preostale vsebine dokumenta…",
+  "newKnowledge.documentContents": "Vsebina",
+  "newKnowledge.documentFacts": "Podrobnosti dokumenta",
   "newKnowledge.documentFilterLabel": "Filtrirajte dokumente po statusu",
+  "newKnowledge.documentLoadErrorDescription": "Tega dokumenta ni bilo mogoče naložiti. Poskusite znova.",
+  "newKnowledge.documentLoadErrorTitle": "Dokumenta ni bilo mogoče naložiti",
+  "newKnowledge.documentNotFoundDescription": "Dokument je bil morda odstranjen ali pa nimate dostopa.",
+  "newKnowledge.documentNotFoundTitle": "Dokument ni najden",
+  "newKnowledge.documentOverviewDescription": "Označevanje metapodatkov dokumentov omogoča umetni inteligenci pravočasen dostop in uporabnikom prikaže vire sklicev.",
   "newKnowledge.documentPermissionRestricted": "Dovoljenja vašega delovnega prostora ne omogočajo dejanj dokumentov ali opravil.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Ponovno indeksiranje je bilo sprejeto, vendar stanje opravila zamuja. Preverite ga pred ponovno oddajo.",
+  "newKnowledge.documentReindexFailed": "Ponovno indeksiranje ni uspelo. Zadnja pripravljena različica ostaja na voljo.",
+  "newKnowledge.documentReindexProgress": "Ponovno indeksiranje · {{progress}}%",
+  "newKnowledge.documentRevision": "Različica",
+  "newKnowledge.documentRevisionMissingDescription": "Ta dokument še nima pripravljene različice. Preverite po končani obdelavi.",
+  "newKnowledge.documentRevisionMissingTitle": "Ni razpoložljive različice",
+  "newKnowledge.documentRevisionsLoadError": "Zgodovine različic ni bilo mogoče naložiti. Trenutna različica ostaja na voljo.",
   "newKnowledge.documentStatus.disabled": "Onemogočeno",
   "newKnowledge.documentStatus.failed": "Ni uspelo",
   "newKnowledge.documentStatus.processing": "Obdelava",
   "newKnowledge.documentStatus.queued": "V čakalni vrsti",
   "newKnowledge.documentStatus.ready": "Pripravljeno",
+  "newKnowledge.documentTaskLookupIncomplete": "Na voljo je več zgodovine opravil. Nadaljujte preverjanje, da najdete stanje dokumenta.",
   "newKnowledge.documentUploadExclusion.batchLimit": "omejitev velikosti paketa je presežena",
   "newKnowledge.documentUploadExclusion.countLimit": "omejitev števila datotek je presežena",
   "newKnowledge.documentUploadExclusion.fileSize": "datoteka je prevelika",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— dokumentov",
   "newKnowledge.downloadDocuments": "Prenos",
   "newKnowledge.editSource": "Uredi",
+  "newKnowledge.emptyChunk": "Prazen del",
   "newKnowledge.emptyDescription": "Dodajte dokumente in agenti jih lahko berejo neposredno — brez nastavljanja indeksiranja.",
   "newKnowledge.emptyTitle": "Pametnejši način ustvarjanja baz znanja",
   "newKnowledge.errorDescription": "Novih baz znanja ni bilo mogoče naložiti. Poskusite znova.",
   "newKnowledge.errorTitle": "Prišlo je do napake",
+  "newKnowledge.fileSize": "Velikost datoteke",
   "newKnowledge.filtersUnavailable": "Ta filter bo na voljo, ko bo KnowledgeFS razkril metapodatke.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl ni na voljo v katalogu ponudnika za ta delovni prostor.",
   "newKnowledge.gotIt": "Razumem",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Spoznajte novo bazo znanja ✨",
   "newKnowledge.illustrationHeadline": "Vsebino povežite enkrat — vsaka aplikacija bo odgovarjala z najnovejšim znanjem.",
   "newKnowledge.includeSubpages": "Vključi podstrani",
+  "newKnowledge.indexInformation": "Podatki o indeksu",
   "newKnowledge.interruptTask": "Prekini",
   "newKnowledge.invalidRootUrl": "Vnesite veljaven URL http(s).",
   "newKnowledge.keepEditing": "Nadaljuj urejanje",
+  "newKnowledge.lastIndexed": "Nazadnje indeksirano",
   "newKnowledge.lastReadyRevisionHint": "Neuspešna obdelava nikoli ne prekine pridobivanja — zadnja pripravljena revizija ostane na voljo v indeksu vsebine.",
   "newKnowledge.lastSyncColumn": "Zadnja sinhronizacija",
   "newKnowledge.learnMore": "Več informacij",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Želite zapustiti nedokončano nastavitev?",
   "newKnowledge.legacy": "Staro",
   "newKnowledge.loadMore": "Naloži več",
+  "newKnowledge.loadMoreRevisions": "Naloži starejše različice",
   "newKnowledge.loadingSyncPolicy": "Nalaganje pravilnika sinhronizacije",
   "newKnowledge.manualUpload": "Ročno nalaganje",
   "newKnowledge.maxPages": "Največje število strani",
   "newKnowledge.metadata": "Meta podatki",
+  "newKnowledge.mimeType": "Vrsta datoteke",
   "newKnowledge.moreProviders": "Več ponudnikov",
   "newKnowledge.name": "Ime znanja",
   "newKnowledge.namePlaceholder": "npr. Priročnik za podporo strankam",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Povežite Notion, da izberete strani in jih ohranite sinhronizirane.",
   "newKnowledge.onlineDocuments": "Spletni dokumenti",
   "newKnowledge.onlineDrive": "Spletna vožnja",
+  "newKnowledge.overview": "Pregled",
   "newKnowledge.pagesAppearDescription": "Preiščite spletno mesto in preverite, katere strani bodo dodane.",
   "newKnowledge.pagesAppearTitle": "Strani bodo prikazane tukaj",
   "newKnowledge.pagesCrawled": "Preiskanih strani na {{host}}: {{count}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} ni konfiguriran",
   "newKnowledge.providerNotConfiguredDescription": "Dodajte ključ API ali URL končne točke za iskanje po spletnih mestih z {{provider}}.",
   "newKnowledge.providerUnavailable": "Ta ponudnik ni dosegljiv.",
+  "newKnowledge.quality": "Kakovost",
   "newKnowledge.reCrawl": "Ponovno preišči",
   "newKnowledge.readOnlyEmpty": "Prosite urednika delovnega prostora, naj ustvari prvo bazo znanja.",
   "newKnowledge.refreshConnectionStatus": "Osveži stanje",
   "newKnowledge.refreshingConnection": "Osvežitev …",
+  "newKnowledge.reindexDocument": "Ponovno indeksiraj",
   "newKnowledge.reindexDocuments": "Ponovno indeksiraj",
   "newKnowledge.removeSource": "Odstrani vir",
+  "newKnowledge.retrievalCount": "Število pridobitev",
   "newKnowledge.retryCrawl": "Ponovi preiskovanje",
   "newKnowledge.retryProviderLoad": "Poskusi znova",
+  "newKnowledge.retryReindexDocument": "Ponovno indeksiraj",
   "newKnowledge.retrySyncPolicy": "Znova poskusi naložiti pravilnik sinhronizacije",
   "newKnowledge.retryTask": "Poskusite znova",
+  "newKnowledge.revisionState.active": "Aktivna",
+  "newKnowledge.revisionState.candidate": "Obdelava",
+  "newKnowledge.revisionState.failed": "Neuspešno",
+  "newKnowledge.revisionState.superseded": "Prejšnja",
   "newKnowledge.rootUrl": "Korenski URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Ta razdelek bo na voljo v naslednjem koraku nastavitve.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Izberi vse",
   "newKnowledge.selectAllDocuments": "Izberite vse dokumente",
   "newKnowledge.selectAllSources": "Izberi vse vire",
+  "newKnowledge.selectChunk": "Izberite del za pregled njegove vsebine.",
   "newKnowledge.selectFilesAndFolders": "Izberite datoteke in mape za sinhronizacijo",
   "newKnowledge.skippedFailed": "Preskočeno (neuspešno)",
   "newKnowledge.skippedOffDomain": "Preskočeno (zunaj domene)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Naloge",
   "newKnowledge.tasksErrorDescription": "Opravil v ozadju nismo mogli naložiti. poskusi ponovno",
   "newKnowledge.tasksWithAttention": "Naloge, {{count}} potrebujejo pozornost",
+  "newKnowledge.tokenCount": "Žetoni",
   "newKnowledge.unavailableDescription": "KnowledgeFS trenutno ni na voljo za ta delovni prostor.",
   "newKnowledge.unavailableTitle": "Novo znanje ni na voljo",
   "newKnowledge.updated": "Posodobljeno {{date}}",
+  "newKnowledge.updatedAt": "Nazadnje posodobljeno",
   "newKnowledge.updatedColumn": "Posodobljeno",
   "newKnowledge.uploadCharactersUnavailable": "Znaki: —",
   "newKnowledge.uploadDocuments": "Nalaganje dokumentov",

web/i18n/th-TH/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "ปรับและรวบรวมข้อมูลอีกครั้ง",
   "newKnowledge.allDocumentStatuses": "สถานะทั้งหมด",
   "newKnowledge.allSources": "แหล่งที่มาทั้งหมด",
+  "newKnowledge.apiAgentAccess": "การเข้าถึง API และเอเจนต์",
   "newKnowledge.appsUnavailable": "— แอป",
   "newKnowledge.authKind.api-key": "คีย์ API",
   "newKnowledge.authKind.endpoint": "จุดสิ้นสุด",
   "newKnowledge.authenticationMethod": "วิธีการตรวจสอบความถูกต้อง",
+  "newKnowledge.averageChunkLength": "ความยาวส่วนข้อมูลเฉลี่ย",
   "newKnowledge.backToList": "กลับสู่ฐานความรู้",
   "newKnowledge.backgroundTasks": "งานเบื้องหลัง",
   "newKnowledge.backgroundTasksDescription": "การเพิ่มเอกสาร การซิงค์แหล่งที่มา และงานจัดทำดัชนีใหม่",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "การดำเนินการกับเอกสารจำนวนมาก",
   "newKnowledge.cancelAddSource": "ยกเลิก",
   "newKnowledge.cardType": "พื้นที่ความรู้",
+  "newKnowledge.characterCount": "อักขระ",
+  "newKnowledge.checkReindexStatus": "ตรวจสอบสถานะการทำดัชนีใหม่",
+  "newKnowledge.chunkCount": "ส่วนข้อมูล",
+  "newKnowledge.chunkHeading": "ส่วนข้อมูล {{position}}",
+  "newKnowledge.chunkLocation": "ตำแหน่ง {{position}} ในรุ่นแก้ไขนี้",
   "newKnowledge.clearDocumentSelection": "ล้างการเลือกเอกสาร",
   "newKnowledge.configureProvider": "กำหนดค่า {{provider}}",
   "newKnowledge.connectNotion": "เชื่อมต่อ Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "รีเฟรชการเชื่อมต่อก่อนที่จะเพิ่มแหล่งที่มาของเว็บไซต์",
   "newKnowledge.connectionProvisioning": "กำลังเชื่อมต่อ {{provider}}",
   "newKnowledge.connectionRefreshFailed": "เราไม่สามารถรีเฟรชการเชื่อมต่อนี้ได้ ลองอีกครั้ง",
+  "newKnowledge.continueCheckingTaskStatus": "ตรวจสอบสถานะงานต่อ",
   "newKnowledge.crawlAndPreview": "รวบรวมข้อมูลและดูตัวอย่าง",
   "newKnowledge.crawlFailed": "ไม่สามารถรวบรวมข้อมูล {{host}} ได้",
   "newKnowledge.crawlFailed403": "เว็บไซต์ส่งคืนข้อผิดพลาด 403 ซึ่งอาจบล็อกโปรแกรมรวบรวมข้อมูลหรือต้องมีการยืนยันตัวตน ตรวจสอบ URL ปรับตัวเลือกการรวบรวมข้อมูล หรือลองใช้ผู้ให้บริการรายอื่น",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "เราไม่สามารถสร้างฐานความรู้นี้ได้ ตรวจสอบการเข้าถึงของคุณแล้วลองอีกครั้ง",
   "newKnowledge.createIllustrationTitle": "เชื่อมต่อเนื้อหาเพียงครั้งเดียว — ทุกแอปจะตอบด้วยความรู้ล่าสุด",
   "newKnowledge.createTitle": "สร้างองค์ความรู้",
+  "newKnowledge.createdAt": "สร้างเมื่อ",
   "newKnowledge.creators": "ผู้สร้าง",
   "newKnowledge.customIntervalHours": "ช่วงเวลาแบบกำหนดเอง (ชั่วโมง)",
   "newKnowledge.customIntervalInvalid": "ป้อนจำนวนเต็มตั้งแต่ 1 ถึง 720 ชั่วโมง",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "ละทิ้งฉบับร่างแหล่งข้อมูลนี้หรือไม่",
   "newKnowledge.documentActions": "การดำเนินการสำหรับ {{name}}",
   "newKnowledge.documentActionsUnavailable": "การดำเนินการกับเอกสารยังไม่พร้อมใช้งานสำหรับฐานความรู้นี้",
+  "newKnowledge.documentChunksEmpty": "ยังไม่มีส่วนข้อมูลสำหรับรุ่นแก้ไขนี้",
+  "newKnowledge.documentChunksLoadError": "ไม่สามารถโหลดส่วนข้อมูลของรุ่นแก้ไขนี้ได้",
+  "newKnowledge.documentChunksLoadMoreError": "ไม่สามารถโหลดส่วนข้อมูลเพิ่มเติมได้ โปรดลองอีกครั้ง",
   "newKnowledge.documentColumn": "เอกสาร",
+  "newKnowledge.documentContentIncomplete": "กำลังโหลดเนื้อหาเอกสารที่เหลือ…",
+  "newKnowledge.documentContents": "สารบัญ",
+  "newKnowledge.documentFacts": "รายละเอียดเอกสาร",
   "newKnowledge.documentFilterLabel": "กรองเอกสารตามสถานะ",
+  "newKnowledge.documentLoadErrorDescription": "ไม่สามารถโหลดเอกสารนี้ได้ โปรดลองอีกครั้ง",
+  "newKnowledge.documentLoadErrorTitle": "โหลดเอกสารไม่ได้",
+  "newKnowledge.documentNotFoundDescription": "เอกสารนี้อาจถูกลบหรือคุณอาจไม่มีสิทธิ์เข้าถึง",
+  "newKnowledge.documentNotFoundTitle": "ไม่พบเอกสาร",
+  "newKnowledge.documentOverviewDescription": "การติดป้ายกำกับข้อมูลเมตาของเอกสารช่วยให้ AI เข้าถึงเอกสารได้ทันท่วงทีและแสดงแหล่งที่มาของการอ้างอิงแก่ผู้ใช้",
   "newKnowledge.documentPermissionRestricted": "สิทธิ์ของพื้นที่ทำงานไม่อนุญาตให้ดำเนินการกับเอกสารหรืองาน",
+  "newKnowledge.documentReindexConfirmationDelayed": "ระบบรับคำขอทำดัชนีใหม่แล้ว แต่สถานะงานล่าช้า โปรดตรวจสอบก่อนส่งอีกครั้ง",
+  "newKnowledge.documentReindexFailed": "การจัดทำดัชนีใหม่ล้มเหลว รุ่นแก้ไขล่าสุดที่พร้อมใช้งานยังคงอยู่",
+  "newKnowledge.documentReindexProgress": "กำลังจัดทำดัชนีใหม่ · {{progress}}%",
+  "newKnowledge.documentRevision": "รุ่นแก้ไข",
+  "newKnowledge.documentRevisionMissingDescription": "เอกสารนี้ยังไม่มีรุ่นแก้ไขที่พร้อม โปรดตรวจสอบอีกครั้งหลังประมวลผลเสร็จ",
+  "newKnowledge.documentRevisionMissingTitle": "ไม่มีรุ่นแก้ไขที่พร้อมใช้งาน",
+  "newKnowledge.documentRevisionsLoadError": "ไม่สามารถโหลดประวัติรุ่นแก้ไขได้ รุ่นปัจจุบันยังคงใช้งานได้",
   "newKnowledge.documentStatus.disabled": "ปิดการใช้งาน",
   "newKnowledge.documentStatus.failed": "ล้มเหลว",
   "newKnowledge.documentStatus.processing": "กำลังประมวลผล",
   "newKnowledge.documentStatus.queued": "เข้าคิว",
   "newKnowledge.documentStatus.ready": "พร้อม",
+  "newKnowledge.documentTaskLookupIncomplete": "ยังมีประวัติงานเพิ่มเติม โปรดตรวจสอบต่อเพื่อค้นหาสถานะของเอกสารนี้",
   "newKnowledge.documentUploadExclusion.batchLimit": "เกินขีดจำกัดขนาดแบตช์",
   "newKnowledge.documentUploadExclusion.countLimit": "เกินขีดจำกัดจำนวนไฟล์",
   "newKnowledge.documentUploadExclusion.fileSize": "ไฟล์มีขนาดใหญ่เกินไป",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— เอกสาร",
   "newKnowledge.downloadDocuments": "ดาวน์โหลด",
   "newKnowledge.editSource": "แก้ไข",
+  "newKnowledge.emptyChunk": "ส่วนข้อมูลว่าง",
   "newKnowledge.emptyDescription": "เพิ่มเอกสารของคุณ แล้วเอเจนต์จะอ่านได้โดยตรง โดยไม่ต้องตั้งค่าการทำดัชนี",
   "newKnowledge.emptyTitle": "วิธีที่ชาญฉลาดกว่าในการสร้างฐานความรู้",
   "newKnowledge.errorDescription": "ไม่สามารถโหลดฐานความรู้ใหม่ได้ โปรดลองอีกครั้ง",
   "newKnowledge.errorTitle": "เกิดข้อผิดพลาด",
+  "newKnowledge.fileSize": "ขนาดไฟล์",
   "newKnowledge.filtersUnavailable": "ตัวกรองนี้จะพร้อมใช้งานเมื่อ KnowledgeFS เปิดเผยข้อมูลเมตา",
   "newKnowledge.firecrawlUnavailable": "Firecrawl ไม่พร้อมใช้งานในแค็ตตาล็อกผู้ให้บริการสำหรับพื้นที่ทำงานนี้",
   "newKnowledge.gotIt": "เข้าใจแล้ว",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "พบกับฐานความรู้แบบใหม่ ✨",
   "newKnowledge.illustrationHeadline": "เชื่อมต่อเนื้อหาครั้งเดียว ทุกแอปจะตอบด้วยความรู้ล่าสุด",
   "newKnowledge.includeSubpages": "รวมหน้าย่อย",
+  "newKnowledge.indexInformation": "ข้อมูลดัชนี",
   "newKnowledge.interruptTask": "ขัดจังหวะ",
   "newKnowledge.invalidRootUrl": "ป้อน URL http(s) ที่ถูกต้อง",
   "newKnowledge.keepEditing": "แก้ไขต่อ",
+  "newKnowledge.lastIndexed": "จัดทำดัชนีล่าสุด",
   "newKnowledge.lastReadyRevisionHint": "การประมวลผลที่ล้มเหลวจะไม่ขัดจังหวะการดึงข้อมูล — การแก้ไขที่พร้อมใช้ครั้งล่าสุดจะยังคงอยู่ในดัชนีเนื้อหา",
   "newKnowledge.lastSyncColumn": "ซิงค์ครั้งล่าสุด",
   "newKnowledge.learnMore": "เรียนรู้เพิ่มเติม",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "ออกจากการตั้งค่าที่ยังไม่เสร็จหรือไม่?",
   "newKnowledge.legacy": "แบบเดิม",
   "newKnowledge.loadMore": "โหลดเพิ่มเติม",
+  "newKnowledge.loadMoreRevisions": "โหลดรุ่นแก้ไขก่อนหน้า",
   "newKnowledge.loadingSyncPolicy": "กำลังโหลดนโยบายการซิงค์",
   "newKnowledge.manualUpload": "อัพโหลดด้วยตนเอง",
   "newKnowledge.maxPages": "จำนวนหน้าสูงสุด",
   "newKnowledge.metadata": "ข้อมูลเมตา",
+  "newKnowledge.mimeType": "ประเภทไฟล์",
   "newKnowledge.moreProviders": "ผู้ให้บริการเพิ่มเติม",
   "newKnowledge.name": "ชื่อความรู้",
   "newKnowledge.namePlaceholder": "เช่น คู่มือการสนับสนุนลูกค้า",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "เชื่อมต่อ Notion เพื่อเลือกหน้าและคงการซิงค์ไว้",
   "newKnowledge.onlineDocuments": "เอกสารออนไลน์",
   "newKnowledge.onlineDrive": "ไดรฟ์ออนไลน์",
+  "newKnowledge.overview": "ภาพรวม",
   "newKnowledge.pagesAppearDescription": "รวบรวมข้อมูลเว็บไซต์เพื่อตรวจสอบหน้าที่จะเพิ่ม",
   "newKnowledge.pagesAppearTitle": "หน้าจะแสดงที่นี่",
   "newKnowledge.pagesCrawled": "รวบรวมข้อมูล {{count}} หน้าที่ {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} ไม่ได้กำหนดค่า",
   "newKnowledge.providerNotConfiguredDescription": "เพิ่มคีย์ API หรือ URL ปลายทางเพื่อรวบรวมข้อมูลเว็บไซต์ด้วย {{provider}}",
   "newKnowledge.providerUnavailable": "ผู้ให้บริการนี้ไม่พร้อมใช้งาน",
+  "newKnowledge.quality": "คุณภาพ",
   "newKnowledge.reCrawl": "รวบรวมข้อมูลอีกครั้ง",
   "newKnowledge.readOnlyEmpty": "ขอให้ผู้แก้ไขพื้นที่ทำงานสร้างฐานความรู้แรก",
   "newKnowledge.refreshConnectionStatus": "รีเฟรชสถานะ",
   "newKnowledge.refreshingConnection": "สดชื่น...",
+  "newKnowledge.reindexDocument": "จัดทำดัชนีใหม่",
   "newKnowledge.reindexDocuments": "จัดทำดัชนีใหม่",
   "newKnowledge.removeSource": "ลบแหล่งสัญญาณ",
+  "newKnowledge.retrievalCount": "จำนวนการเรียกค้น",
   "newKnowledge.retryCrawl": "ลองรวบรวมข้อมูลอีกครั้ง",
   "newKnowledge.retryProviderLoad": "ลองอีกครั้ง",
+  "newKnowledge.retryReindexDocument": "ทำดัชนีใหม่อีกครั้ง",
   "newKnowledge.retrySyncPolicy": "ลองโหลดนโยบายการซิงค์อีกครั้ง",
   "newKnowledge.retryTask": "ลองอีกครั้ง",
+  "newKnowledge.revisionState.active": "ใช้งานอยู่",
+  "newKnowledge.revisionState.candidate": "กำลังประมวลผล",
+  "newKnowledge.revisionState.failed": "ล้มเหลว",
+  "newKnowledge.revisionState.superseded": "ก่อนหน้า",
   "newKnowledge.rootUrl": "URL หลัก",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "ส่วนนี้จะพร้อมใช้งานในขั้นตอนการตั้งค่าถัดไป",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "เลือกทั้งหมด",
   "newKnowledge.selectAllDocuments": "เลือกเอกสารทั้งหมด",
   "newKnowledge.selectAllSources": "เลือกแหล่งที่มาทั้งหมด",
+  "newKnowledge.selectChunk": "เลือกส่วนข้อมูลเพื่อตรวจสอบเนื้อหา",
   "newKnowledge.selectFilesAndFolders": "เลือกไฟล์และโฟลเดอร์ที่จะซิงค์",
   "newKnowledge.skippedFailed": "ข้าม (ล้มเหลว)",
   "newKnowledge.skippedOffDomain": "ข้าม (นอกโดเมน)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "งาน",
   "newKnowledge.tasksErrorDescription": "เราไม่สามารถโหลดงานพื้นหลังได้ ลองอีกครั้ง",
   "newKnowledge.tasksWithAttention": "งาน {{count}} ต้องการความสนใจ",
+  "newKnowledge.tokenCount": "โทเค็น",
   "newKnowledge.unavailableDescription": "ขณะนี้ KnowledgeFS ไม่พร้อมใช้งานสำหรับพื้นที่ทำงานนี้",
   "newKnowledge.unavailableTitle": "ความรู้แบบใหม่ไม่พร้อมใช้งาน",
   "newKnowledge.updated": "อัปเดตเมื่อ {{date}}",
+  "newKnowledge.updatedAt": "อัปเดตล่าสุด",
   "newKnowledge.updatedColumn": "อัปเดตแล้ว",
   "newKnowledge.uploadCharactersUnavailable": "อักขระ: —",
   "newKnowledge.uploadDocuments": "อัพโหลดเอกสาร",

web/i18n/tr-TR/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Ayarla ve yeniden tara",
   "newKnowledge.allDocumentStatuses": "Tüm durum",
   "newKnowledge.allSources": "Tüm kaynaklar",
+  "newKnowledge.apiAgentAccess": "API ve Ajan Erişimi",
   "newKnowledge.appsUnavailable": "— uygulama",
   "newKnowledge.authKind.api-key": "API anahtarı",
   "newKnowledge.authKind.endpoint": "Uç nokta",
   "newKnowledge.authenticationMethod": "Kimlik doğrulama yöntemi",
+  "newKnowledge.averageChunkLength": "Ortalama parça uzunluğu",
   "newKnowledge.backToList": "Bilgi tabanlarına geri dön",
   "newKnowledge.backgroundTasks": "Arka plan görevleri",
   "newKnowledge.backgroundTasksDescription": "Belge ekleme, kaynak senkronizasyonu ve işleri yeniden indeksleme.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Toplu belge işlemleri",
   "newKnowledge.cancelAddSource": "İptal et",
   "newKnowledge.cardType": "Bilgi alanı",
+  "newKnowledge.characterCount": "Karakterler",
+  "newKnowledge.checkReindexStatus": "Yeniden indeksleme durumunu kontrol et",
+  "newKnowledge.chunkCount": "Parçalar",
+  "newKnowledge.chunkHeading": "Parça {{position}}",
+  "newKnowledge.chunkLocation": "Bu revizyondaki {{position}}. konum",
   "newKnowledge.clearDocumentSelection": "Belge seçimini temizle",
   "newKnowledge.configureProvider": "{{provider}}'ı Yapılandır",
   "newKnowledge.connectNotion": "Notion’a bağlan",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Bir web sitesi kaynağı eklemeden önce bağlantıyı yenileyin.",
   "newKnowledge.connectionProvisioning": "{{provider}} bağlanıyor",
   "newKnowledge.connectionRefreshFailed": "Bu bağlantıyı yenileyemedik. Tekrar deneyin.",
+  "newKnowledge.continueCheckingTaskStatus": "Görev durumunu kontrol etmeye devam et",
   "newKnowledge.crawlAndPreview": "Tara ve önizle",
   "newKnowledge.crawlFailed": "{{host}} taranamadı",
   "newKnowledge.crawlFailed403": "Site 403 yanıtı verdi — tarayıcıları engelliyor veya kimlik doğrulaması gerektiriyor olabilir. URL’yi kontrol edin, tarama seçeneklerini ayarlayın ya da başka bir sağlayıcı deneyin.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Bu bilgi tabanını oluşturamadık. Erişiminizi kontrol edip tekrar deneyin.",
   "newKnowledge.createIllustrationTitle": "İçeriğinizi bir kez bağlayın — her uygulama en güncel bilgilerle yanıt versin.",
   "newKnowledge.createTitle": "Bilgi Yaratın",
+  "newKnowledge.createdAt": "Oluşturuldu",
   "newKnowledge.creators": "Oluşturanlar",
   "newKnowledge.customIntervalHours": "Özel aralık (saat)",
   "newKnowledge.customIntervalInvalid": "1 ile 720 saat arasında bir tam sayı girin.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Bu kaynak taslağı silinsin mi?",
   "newKnowledge.documentActions": "{{name}} için eylemler",
   "newKnowledge.documentActionsUnavailable": "Belge eylemleri henüz bu bilgi tabanında kullanılamıyor.",
+  "newKnowledge.documentChunksEmpty": "Bu revizyon için henüz parça yok.",
+  "newKnowledge.documentChunksLoadError": "Bu revizyonun parçaları yüklenemedi.",
+  "newKnowledge.documentChunksLoadMoreError": "Daha fazla parça yüklenemedi. Tekrar deneyin.",
   "newKnowledge.documentColumn": "Belge",
+  "newKnowledge.documentContentIncomplete": "Belgenin kalan içeriği yükleniyor…",
+  "newKnowledge.documentContents": "İçerik",
+  "newKnowledge.documentFacts": "Belge ayrıntıları",
   "newKnowledge.documentFilterLabel": "Belgeleri duruma göre filtreleyin",
+  "newKnowledge.documentLoadErrorDescription": "Bu belge yüklenemedi. Tekrar deneyin.",
+  "newKnowledge.documentLoadErrorTitle": "Belge yüklenemedi",
+  "newKnowledge.documentNotFoundDescription": "Bu belge kaldırılmış olabilir veya erişiminiz olmayabilir.",
+  "newKnowledge.documentNotFoundTitle": "Belge bulunamadı",
+  "newKnowledge.documentOverviewDescription": "Belge meta verilerini etiketlemek, yapay zekânın belgelere zamanında erişmesini ve kullanıcılara referans kaynaklarını göstermesini sağlar.",
   "newKnowledge.documentPermissionRestricted": "Çalışma alanı izinleriniz belge veya görev işlemlerine izin vermiyor.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Yeniden indeksleme kabul edildi ancak görev durumu gecikiyor. Tekrar göndermeden önce kontrol edin.",
+  "newKnowledge.documentReindexFailed": "Yeniden dizinleme başarısız oldu. Son hazır revizyon kullanılabilir durumda.",
+  "newKnowledge.documentReindexProgress": "Yeniden dizinleniyor · %{{progress}}",
+  "newKnowledge.documentRevision": "Revizyon",
+  "newKnowledge.documentRevisionMissingDescription": "Bu belgenin henüz hazır bir revizyonu yok. İşlem tamamlandıktan sonra tekrar kontrol edin.",
+  "newKnowledge.documentRevisionMissingTitle": "Kullanılabilir revizyon yok",
+  "newKnowledge.documentRevisionsLoadError": "Revizyon geçmişi yüklenemedi. Geçerli revizyon kullanılabilir durumda.",
   "newKnowledge.documentStatus.disabled": "Devre dışı",
   "newKnowledge.documentStatus.failed": "Başarısız",
   "newKnowledge.documentStatus.processing": "İşleme",
   "newKnowledge.documentStatus.queued": "Sıraya alındı",
   "newKnowledge.documentStatus.ready": "Hazır",
+  "newKnowledge.documentTaskLookupIncomplete": "Daha fazla görev geçmişi var. Bu belgenin durumunu bulmak için kontrol etmeye devam edin.",
   "newKnowledge.documentUploadExclusion.batchLimit": "toplu iş boyutu sınırı aşıldı",
   "newKnowledge.documentUploadExclusion.countLimit": "dosya sayısı sınırı aşıldı",
   "newKnowledge.documentUploadExclusion.fileSize": "dosya çok büyük",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— belge",
   "newKnowledge.downloadDocuments": "İndir",
   "newKnowledge.editSource": "Düzenle",
+  "newKnowledge.emptyChunk": "Boş parça",
   "newKnowledge.emptyDescription": "Belgelerinizi ekleyin; ajanlar indeksleme yapılandırmadan belgeleri doğrudan okuyabilsin.",
   "newKnowledge.emptyTitle": "Bilgi tabanları oluşturmanın daha akıllı yolu",
   "newKnowledge.errorDescription": "Yeni bilgi tabanlarınız yüklenemedi. Tekrar deneyin.",
   "newKnowledge.errorTitle": "Bir şeyler yanlış gitti",
+  "newKnowledge.fileSize": "Dosya boyutu",
   "newKnowledge.filtersUnavailable": "KnowledgeFS meta verilerini sunduğunda bu filtre kullanılabilir olacak.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl bu çalışma alanının sağlayıcı kataloğunda mevcut değil.",
   "newKnowledge.gotIt": "Anladım",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Yeni Bilgi Tabanı ile tanışın ✨",
   "newKnowledge.illustrationHeadline": "İçeriğinizi bir kez bağlayın — her uygulama en güncel bilgilerle yanıt versin.",
   "newKnowledge.includeSubpages": "Alt sayfaları dahil et",
+  "newKnowledge.indexInformation": "Dizin bilgileri",
   "newKnowledge.interruptTask": "Kesinti",
   "newKnowledge.invalidRootUrl": "Geçerli bir http(s) URL’si girin.",
   "newKnowledge.keepEditing": "Düzenlemeye devam et",
+  "newKnowledge.lastIndexed": "Son dizinleme",
   "newKnowledge.lastReadyRevisionHint": "Başarısız işleme hiçbir zaman alımı kesintiye uğratmaz; son hazır revizyon içerik dizininde mevcut kalır.",
   "newKnowledge.lastSyncColumn": "Son senkronizasyon",
   "newKnowledge.learnMore": "Daha fazla bilgi",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Tamamlanmamış kurulumdan çıkılsın mı?",
   "newKnowledge.legacy": "Eski",
   "newKnowledge.loadMore": "Daha fazla yükle",
+  "newKnowledge.loadMoreRevisions": "Eski revizyonları yükle",
   "newKnowledge.loadingSyncPolicy": "Eşitleme politikası yükleniyor",
   "newKnowledge.manualUpload": "Manuel yükleme",
   "newKnowledge.maxPages": "En fazla sayfa",
   "newKnowledge.metadata": "Meta Veriler",
+  "newKnowledge.mimeType": "Dosya türü",
   "newKnowledge.moreProviders": "Daha fazla sağlayıcı",
   "newKnowledge.name": "Bilgi adı",
   "newKnowledge.namePlaceholder": "örneğin Müşteri Desteği El Kitabı",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Sayfaları seçmek ve eşitlenmiş tutmak için Notion’a bağlanın.",
   "newKnowledge.onlineDocuments": "Çevrimiçi belgeler",
   "newKnowledge.onlineDrive": "Çevrimiçi sürücü",
+  "newKnowledge.overview": "Genel bakış",
   "newKnowledge.pagesAppearDescription": "Hangi sayfaların ekleneceğini görmek için siteyi tarayın.",
   "newKnowledge.pagesAppearTitle": "Sayfalar burada görünecek",
   "newKnowledge.pagesCrawled": "{{host}} üzerinde {{count}} sayfa tarandı",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} yapılandırılmadı",
   "newKnowledge.providerNotConfiguredDescription": "{{provider}} ile web sitelerini taramak için bir API anahtarı veya uç nokta URL'si ekleyin.",
   "newKnowledge.providerUnavailable": "Bu sağlayıcı kullanılamıyor.",
+  "newKnowledge.quality": "Kalite",
   "newKnowledge.reCrawl": "Yeniden tara",
   "newKnowledge.readOnlyEmpty": "İlk bilgi tabanını oluşturması için bir çalışma alanı editörüne başvurun.",
   "newKnowledge.refreshConnectionStatus": "Durumu yenile",
   "newKnowledge.refreshingConnection": "Yenileniyor…",
+  "newKnowledge.reindexDocument": "Yeniden dizinle",
   "newKnowledge.reindexDocuments": "Yeniden indeksle",
   "newKnowledge.removeSource": "Kaynağı kaldır",
+  "newKnowledge.retrievalCount": "Getirme sayısı",
   "newKnowledge.retryCrawl": "Taramayı yeniden dene",
   "newKnowledge.retryProviderLoad": "Tekrar dene",
+  "newKnowledge.retryReindexDocument": "Yeniden indeksle",
   "newKnowledge.retrySyncPolicy": "Eşitleme politikasını yeniden dene",
   "newKnowledge.retryTask": "Yeniden dene",
+  "newKnowledge.revisionState.active": "Etkin",
+  "newKnowledge.revisionState.candidate": "İşleniyor",
+  "newKnowledge.revisionState.failed": "Başarısız",
+  "newKnowledge.revisionState.superseded": "Önceki",
   "newKnowledge.rootUrl": "Kök URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Bu bölüm bir sonraki kurulum adımında kullanılabilir hale gelecektir.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Tümünü seç",
   "newKnowledge.selectAllDocuments": "Tüm belgeleri seç",
   "newKnowledge.selectAllSources": "Tüm kaynakları seç",
+  "newKnowledge.selectChunk": "İçeriğini incelemek için bir parça seçin.",
   "newKnowledge.selectFilesAndFolders": "Senkronize edilecek dosya ve klasörleri seçin",
   "newKnowledge.skippedFailed": "Atlandı (başarısız)",
   "newKnowledge.skippedOffDomain": "Atlandı (alan adı dışında)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Görevler",
   "newKnowledge.tasksErrorDescription": "Arka plan görevlerini yükleyemedik. Tekrar deneyin.",
   "newKnowledge.tasksWithAttention": "Görevler, {{count}} tanesiyle ilgilenilmesi gerekiyor",
+  "newKnowledge.tokenCount": "Jetonlar",
   "newKnowledge.unavailableDescription": "KnowledgeFS şu anda bu çalışma alanında kullanılamıyor.",
   "newKnowledge.unavailableTitle": "Yeni Bilgi kullanılamıyor",
   "newKnowledge.updated": "{{date}} tarihinde güncellendi",
+  "newKnowledge.updatedAt": "Son güncelleme",
   "newKnowledge.updatedColumn": "Güncellendi",
   "newKnowledge.uploadCharactersUnavailable": "Karakterler: —",
   "newKnowledge.uploadDocuments": "Belgeleri yükleyin",

web/i18n/uk-UA/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Налаштувати й просканувати знову",
   "newKnowledge.allDocumentStatuses": "Всі статуси",
   "newKnowledge.allSources": "Усі джерела",
+  "newKnowledge.apiAgentAccess": "Доступ до API та агентів",
   "newKnowledge.appsUnavailable": "— застосунків",
   "newKnowledge.authKind.api-key": "API ключ",
   "newKnowledge.authKind.endpoint": "Кінцева точка",
   "newKnowledge.authenticationMethod": "Метод автентифікації",
+  "newKnowledge.averageChunkLength": "Середня довжина фрагмента",
   "newKnowledge.backToList": "Назад до баз знань",
   "newKnowledge.backgroundTasks": "Фонові завдання",
   "newKnowledge.backgroundTasksDescription": "Додавання документів, синхронізація джерела та повторне індексування завдань.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Масові дії з документами",
   "newKnowledge.cancelAddSource": "Скасувати",
   "newKnowledge.cardType": "Простір знань",
+  "newKnowledge.characterCount": "Символи",
+  "newKnowledge.checkReindexStatus": "Перевірити стан переіндексації",
+  "newKnowledge.chunkCount": "Фрагменти",
+  "newKnowledge.chunkHeading": "Фрагмент {{position}}",
+  "newKnowledge.chunkLocation": "Позиція {{position}} у цій редакції",
   "newKnowledge.clearDocumentSelection": "Очистити вибір документів",
   "newKnowledge.configureProvider": "Налаштувати {{provider}}",
   "newKnowledge.connectNotion": "Підключити Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Оновіть з’єднання, перш ніж додавати джерело веб-сайту.",
   "newKnowledge.connectionProvisioning": "{{provider}} підключається",
   "newKnowledge.connectionRefreshFailed": "Нам не вдалося оновити це з’єднання. Спробуйте знову.",
+  "newKnowledge.continueCheckingTaskStatus": "Продовжити перевірку стану",
   "newKnowledge.crawlAndPreview": "Сканування та попередній перегляд",
   "newKnowledge.crawlFailed": "Не вдалося просканувати {{host}}",
   "newKnowledge.crawlFailed403": "Сайт повернув помилку 403 — можливо, він блокує пошукових роботів або вимагає автентифікації. Перевірте URL-адресу, змініть параметри сканування або спробуйте іншого постачальника.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Ми не змогли створити цю базу знань. Перевірте свій доступ і повторіть спробу.",
   "newKnowledge.createIllustrationTitle": "Підключіть вміст один раз — кожен застосунок відповідатиме на основі найсвіжіших знань.",
   "newKnowledge.createTitle": "Створюйте знання",
+  "newKnowledge.createdAt": "Створено",
   "newKnowledge.creators": "Автори",
   "newKnowledge.customIntervalHours": "Власний інтервал (години)",
   "newKnowledge.customIntervalInvalid": "Введіть ціле число від 1 до 720 годин.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Відхилити цю чернетку джерела?",
   "newKnowledge.documentActions": "Дії для {{name}}",
   "newKnowledge.documentActionsUnavailable": "Дії з документами поки що недоступні для цієї бази знань.",
+  "newKnowledge.documentChunksEmpty": "Для цієї редакції ще немає доступних фрагментів.",
+  "newKnowledge.documentChunksLoadError": "Не вдалося завантажити фрагменти цієї редакції.",
+  "newKnowledge.documentChunksLoadMoreError": "Не вдалося завантажити додаткові фрагменти. Спробуйте ще раз.",
   "newKnowledge.documentColumn": "документ",
+  "newKnowledge.documentContentIncomplete": "Завантажується решта вмісту документа…",
+  "newKnowledge.documentContents": "Зміст",
+  "newKnowledge.documentFacts": "Відомості про документ",
   "newKnowledge.documentFilterLabel": "Фільтр документів за статусом",
+  "newKnowledge.documentLoadErrorDescription": "Не вдалося завантажити цей документ. Спробуйте ще раз.",
+  "newKnowledge.documentLoadErrorTitle": "Не вдалося завантажити документ",
+  "newKnowledge.documentNotFoundDescription": "Можливо, документ видалено або у вас немає доступу.",
+  "newKnowledge.documentNotFoundTitle": "Документ не знайдено",
+  "newKnowledge.documentOverviewDescription": "Позначення метаданих документів дає ШІ змогу своєчасно отримувати до них доступ і показує користувачам джерела посилань.",
   "newKnowledge.documentPermissionRestricted": "Дозволи вашого робочого простору не дозволяють виконувати дії з документами або завданнями.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Переіндексацію прийнято, але стан завдання затримується. Перевірте його перед повторним надсиланням.",
+  "newKnowledge.documentReindexFailed": "Повторне індексування завершилося помилкою. Остання готова редакція залишається доступною.",
+  "newKnowledge.documentReindexProgress": "Повторне індексування · {{progress}}%",
+  "newKnowledge.documentRevision": "Редакція",
+  "newKnowledge.documentRevisionMissingDescription": "Цей документ ще не має готової редакції. Перевірте після завершення обробки.",
+  "newKnowledge.documentRevisionMissingTitle": "Немає доступної редакції",
+  "newKnowledge.documentRevisionsLoadError": "Не вдалося завантажити історію редакцій. Поточна редакція залишається доступною.",
   "newKnowledge.documentStatus.disabled": "Вимкнено",
   "newKnowledge.documentStatus.failed": "Не вдалося",
   "newKnowledge.documentStatus.processing": "Обробка",
   "newKnowledge.documentStatus.queued": "У черзі",
   "newKnowledge.documentStatus.ready": "Готовий",
+  "newKnowledge.documentTaskLookupIncomplete": "Доступна додаткова історія завдань. Продовжте перевірку, щоб знайти стан документа.",
   "newKnowledge.documentUploadExclusion.batchLimit": "перевищено обмеження розміру пакета",
   "newKnowledge.documentUploadExclusion.countLimit": "перевищено обмеження кількості файлів",
   "newKnowledge.documentUploadExclusion.fileSize": "файл завеликий",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— документів",
   "newKnowledge.downloadDocuments": "Завантажити",
   "newKnowledge.editSource": "Редагувати",
+  "newKnowledge.emptyChunk": "Порожній фрагмент",
   "newKnowledge.emptyDescription": "Додайте документи, і агенти зможуть читати їх безпосередньо — без налаштування індексації.",
   "newKnowledge.emptyTitle": "Розумніший спосіб створювати бази знань",
   "newKnowledge.errorDescription": "Не вдалося завантажити нові бази знань. Спробуйте ще раз.",
   "newKnowledge.errorTitle": "Щось пішло не так",
+  "newKnowledge.fileSize": "Розмір файлу",
   "newKnowledge.filtersUnavailable": "Фільтр стане доступним, коли KnowledgeFS надасть метадані.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl недоступний у каталозі постачальників для цієї робочої області.",
   "newKnowledge.gotIt": "Зрозуміло",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Познайомтеся з новою базою знань ✨",
   "newKnowledge.illustrationHeadline": "Підключіть вміст один раз — і кожна програма відповідатиме на основі найсвіжіших знань.",
   "newKnowledge.includeSubpages": "Включати підсторінки",
+  "newKnowledge.indexInformation": "Відомості про індекс",
   "newKnowledge.interruptTask": "Переривати",
   "newKnowledge.invalidRootUrl": "Введіть дійсну URL-адресу http(s).",
   "newKnowledge.keepEditing": "Продовжити редагування",
+  "newKnowledge.lastIndexed": "Останнє індексування",
   "newKnowledge.lastReadyRevisionHint": "Невдала обробка ніколи не перериває пошук — остання готова версія залишається доступною в індексі вмісту.",
   "newKnowledge.lastSyncColumn": "Остання синхронізація",
   "newKnowledge.learnMore": "Докладніше",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Вийти з незавершеного налаштування?",
   "newKnowledge.legacy": "Попередня версія",
   "newKnowledge.loadMore": "Завантажити ще",
+  "newKnowledge.loadMoreRevisions": "Завантажити попередні редакції",
   "newKnowledge.loadingSyncPolicy": "Завантаження політики синхронізації",
   "newKnowledge.manualUpload": "Ручне завантаження",
   "newKnowledge.maxPages": "Максимум сторінок",
   "newKnowledge.metadata": "Метадані",
+  "newKnowledge.mimeType": "Тип файлу",
   "newKnowledge.moreProviders": "Інші провайдери",
   "newKnowledge.name": "Назва знання",
   "newKnowledge.namePlaceholder": "напр. Посібник із підтримки клієнтів",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Підключіть Notion, щоб вибирати сторінки й підтримувати їх синхронізацію.",
   "newKnowledge.onlineDocuments": "Документи онлайн",
   "newKnowledge.onlineDrive": "Онлайн драйв",
+  "newKnowledge.overview": "Огляд",
   "newKnowledge.pagesAppearDescription": "Проскануйте сайт, щоб переглянути сторінки, які буде додано.",
   "newKnowledge.pagesAppearTitle": "Тут з’являться сторінки",
   "newKnowledge.pagesCrawled": "Проскановано сторінок на {{host}}: {{count}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} не налаштовано",
   "newKnowledge.providerNotConfiguredDescription": "Додайте ключ API або URL-адресу кінцевої точки, щоб сканувати веб-сайти за допомогою {{provider}}.",
   "newKnowledge.providerUnavailable": "Цей провайдер недоступний.",
+  "newKnowledge.quality": "Якість",
   "newKnowledge.reCrawl": "Просканувати знову",
   "newKnowledge.readOnlyEmpty": "Попросіть редактора робочого простору створити першу базу знань.",
   "newKnowledge.refreshConnectionStatus": "Оновити статус",
   "newKnowledge.refreshingConnection": "Оновлення…",
+  "newKnowledge.reindexDocument": "Переіндексувати",
   "newKnowledge.reindexDocuments": "Переіндексувати",
   "newKnowledge.removeSource": "Видалити джерело",
+  "newKnowledge.retrievalCount": "Кількість отримань",
   "newKnowledge.retryCrawl": "Повторити сканування",
   "newKnowledge.retryProviderLoad": "Спробуйте ще раз",
+  "newKnowledge.retryReindexDocument": "Переіндексувати знову",
   "newKnowledge.retrySyncPolicy": "Повторити завантаження політики синхронізації",
   "newKnowledge.retryTask": "Повторіть спробу",
+  "newKnowledge.revisionState.active": "Активна",
+  "newKnowledge.revisionState.candidate": "Обробка",
+  "newKnowledge.revisionState.failed": "Помилка",
+  "newKnowledge.revisionState.superseded": "Попередня",
   "newKnowledge.rootUrl": "Коренева URL-адреса",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Цей розділ стане доступним на наступному кроці налаштування.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Вибрати все",
   "newKnowledge.selectAllDocuments": "Виберіть усі документи",
   "newKnowledge.selectAllSources": "Вибрати всі джерела",
+  "newKnowledge.selectChunk": "Виберіть фрагмент, щоб переглянути його вміст.",
   "newKnowledge.selectFilesAndFolders": "Виберіть файли й папки для синхронізації",
   "newKnowledge.skippedFailed": "Пропущено (помилка)",
   "newKnowledge.skippedOffDomain": "Пропущено (поза доменом)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "завдання",
   "newKnowledge.tasksErrorDescription": "Не вдалося завантажити фонові завдання. Спробуйте знову.",
   "newKnowledge.tasksWithAttention": "Завдання, {{count}} потребують уваги",
+  "newKnowledge.tokenCount": "Токени",
   "newKnowledge.unavailableDescription": "KnowledgeFS зараз недоступний для цього робочого простору.",
   "newKnowledge.unavailableTitle": "Нова база знань недоступна",
   "newKnowledge.updated": "Оновлено {{date}}",
+  "newKnowledge.updatedAt": "Останнє оновлення",
   "newKnowledge.updatedColumn": "Оновлено",
   "newKnowledge.uploadCharactersUnavailable": "Символи: —",
   "newKnowledge.uploadDocuments": "Завантажити документи",

web/i18n/vi-VN/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "Điều chỉnh và thu thập lại",
   "newKnowledge.allDocumentStatuses": "Tất cả trạng thái",
   "newKnowledge.allSources": "Tất cả các nguồn",
+  "newKnowledge.apiAgentAccess": "Quyền truy cập API và tác nhân",
   "newKnowledge.appsUnavailable": "— ứng dụng",
   "newKnowledge.authKind.api-key": "Khóa API",
   "newKnowledge.authKind.endpoint": "Điểm cuối",
   "newKnowledge.authenticationMethod": "Phương thức xác thực",
+  "newKnowledge.averageChunkLength": "Độ dài đoạn trung bình",
   "newKnowledge.backToList": "Quay lại cơ sở kiến thức",
   "newKnowledge.backgroundTasks": "Tác vụ nền",
   "newKnowledge.backgroundTasksDescription": "Tài liệu thêm, đồng bộ hóa nguồn và lập chỉ mục lại công việc.",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "Hành động tài liệu hàng loạt",
   "newKnowledge.cancelAddSource": "Hủy",
   "newKnowledge.cardType": "Không gian kiến thức",
+  "newKnowledge.characterCount": "Ký tự",
+  "newKnowledge.checkReindexStatus": "Kiểm tra trạng thái lập chỉ mục lại",
+  "newKnowledge.chunkCount": "Đoạn",
+  "newKnowledge.chunkHeading": "Đoạn {{position}}",
+  "newKnowledge.chunkLocation": "Vị trí {{position}} trong bản sửa đổi này",
   "newKnowledge.clearDocumentSelection": "Xóa lựa chọn tài liệu",
   "newKnowledge.configureProvider": "Định cấu hình {{provider}}",
   "newKnowledge.connectNotion": "Kết nối Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "Làm mới kết nối trước khi thêm nguồn trang web.",
   "newKnowledge.connectionProvisioning": "{{provider}} đang kết nối",
   "newKnowledge.connectionRefreshFailed": "Chúng tôi không thể làm mới kết nối này. Hãy thử lại.",
+  "newKnowledge.continueCheckingTaskStatus": "Tiếp tục kiểm tra trạng thái tác vụ",
   "newKnowledge.crawlAndPreview": "Thu thập thông tin và xem trước",
   "newKnowledge.crawlFailed": "Không thể thu thập dữ liệu từ {{host}}",
   "newKnowledge.crawlFailed403": "Trang web trả về lỗi 403 — có thể trang đang chặn trình thu thập hoặc yêu cầu xác thực. Kiểm tra URL, điều chỉnh tùy chọn thu thập hoặc thử nhà cung cấp khác.",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "Chúng tôi không thể tạo ra nền tảng kiến thức này. Hãy kiểm tra quyền truy cập của bạn và thử lại.",
   "newKnowledge.createIllustrationTitle": "Kết nối nội dung một lần — mọi ứng dụng đều trả lời bằng kiến thức mới nhất.",
   "newKnowledge.createTitle": "Tạo kiến thức",
+  "newKnowledge.createdAt": "Đã tạo",
   "newKnowledge.creators": "Người tạo",
   "newKnowledge.customIntervalHours": "Khoảng thời gian tùy chỉnh (giờ)",
   "newKnowledge.customIntervalInvalid": "Nhập số nguyên từ 1 đến 720 giờ.",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "Hủy bản nháp nguồn này?",
   "newKnowledge.documentActions": "Các hành động dành cho {{name}}",
   "newKnowledge.documentActionsUnavailable": "Hành động tài liệu chưa có sẵn cho cơ sở kiến thức này.",
+  "newKnowledge.documentChunksEmpty": "Chưa có đoạn nào cho bản sửa đổi này.",
+  "newKnowledge.documentChunksLoadError": "Không thể tải các đoạn của bản sửa đổi này.",
+  "newKnowledge.documentChunksLoadMoreError": "Không thể tải thêm đoạn. Hãy thử lại.",
   "newKnowledge.documentColumn": "tài liệu",
+  "newKnowledge.documentContentIncomplete": "Đang tải phần nội dung tài liệu còn lại…",
+  "newKnowledge.documentContents": "Nội dung",
+  "newKnowledge.documentFacts": "Chi tiết tài liệu",
   "newKnowledge.documentFilterLabel": "Lọc tài liệu theo trạng thái",
+  "newKnowledge.documentLoadErrorDescription": "Không thể tải tài liệu này. Hãy thử lại.",
+  "newKnowledge.documentLoadErrorTitle": "Không thể tải tài liệu",
+  "newKnowledge.documentNotFoundDescription": "Tài liệu có thể đã bị xóa hoặc bạn không có quyền truy cập.",
+  "newKnowledge.documentNotFoundTitle": "Không tìm thấy tài liệu",
+  "newKnowledge.documentOverviewDescription": "Gắn nhãn siêu dữ liệu cho tài liệu giúp AI truy cập kịp thời và hiển thị nguồn tham chiếu cho người dùng.",
   "newKnowledge.documentPermissionRestricted": "Quyền trong không gian làm việc của bạn không cho phép thao tác với tài liệu hoặc tác vụ.",
+  "newKnowledge.documentReindexConfirmationDelayed": "Yêu cầu lập chỉ mục lại đã được chấp nhận nhưng trạng thái tác vụ bị trễ. Hãy kiểm tra trước khi gửi lại.",
+  "newKnowledge.documentReindexFailed": "Lập chỉ mục lại thất bại. Bản sửa đổi sẵn sàng gần nhất vẫn khả dụng.",
+  "newKnowledge.documentReindexProgress": "Đang lập chỉ mục lại · {{progress}}%",
+  "newKnowledge.documentRevision": "Bản sửa đổi",
+  "newKnowledge.documentRevisionMissingDescription": "Tài liệu này chưa có bản sửa đổi sẵn sàng. Hãy kiểm tra lại sau khi xử lý xong.",
+  "newKnowledge.documentRevisionMissingTitle": "Không có bản sửa đổi",
+  "newKnowledge.documentRevisionsLoadError": "Không thể tải lịch sử sửa đổi. Bản sửa đổi hiện tại vẫn khả dụng.",
   "newKnowledge.documentStatus.disabled": "Đã tắt",
   "newKnowledge.documentStatus.failed": "thất bại",
   "newKnowledge.documentStatus.processing": "Đang xử lý",
   "newKnowledge.documentStatus.queued": "Đã xếp hàng",
   "newKnowledge.documentStatus.ready": "Sẵn sàng",
+  "newKnowledge.documentTaskLookupIncomplete": "Còn thêm lịch sử tác vụ. Hãy tiếp tục kiểm tra để tìm trạng thái của tài liệu này.",
   "newKnowledge.documentUploadExclusion.batchLimit": "đã vượt quá giới hạn kích thước lô",
   "newKnowledge.documentUploadExclusion.countLimit": "đã vượt quá giới hạn số lượng tệp",
   "newKnowledge.documentUploadExclusion.fileSize": "tệp quá lớn",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— tài liệu",
   "newKnowledge.downloadDocuments": "Tải xuống",
   "newKnowledge.editSource": "Chỉnh sửa",
+  "newKnowledge.emptyChunk": "Đoạn trống",
   "newKnowledge.emptyDescription": "Thêm tài liệu để tác nhân có thể đọc trực tiếp — không cần cấu hình lập chỉ mục.",
   "newKnowledge.emptyTitle": "Cách thông minh hơn để xây dựng cơ sở kiến thức",
   "newKnowledge.errorDescription": "Không thể tải các cơ sở kiến thức mới. Hãy thử lại.",
   "newKnowledge.errorTitle": "Đã xảy ra lỗi",
+  "newKnowledge.fileSize": "Kích thước tệp",
   "newKnowledge.filtersUnavailable": "Bộ lọc này sẽ khả dụng khi KnowledgeFS cung cấp siêu dữ liệu.",
   "newKnowledge.firecrawlUnavailable": "Firecrawl không có sẵn trong danh mục nhà cung cấp cho không gian làm việc này.",
   "newKnowledge.gotIt": "Đã hiểu",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "Khám phá Cơ sở kiến thức mới ✨",
   "newKnowledge.illustrationHeadline": "Kết nối nội dung một lần — mọi ứng dụng sẽ trả lời bằng kiến thức mới nhất.",
   "newKnowledge.includeSubpages": "Bao gồm các trang con",
+  "newKnowledge.indexInformation": "Thông tin chỉ mục",
   "newKnowledge.interruptTask": "Ngắt",
   "newKnowledge.invalidRootUrl": "Nhập URL http(s) hợp lệ.",
   "newKnowledge.keepEditing": "Tiếp tục chỉnh sửa",
+  "newKnowledge.lastIndexed": "Lập chỉ mục gần nhất",
   "newKnowledge.lastReadyRevisionHint": "Quá trình xử lý không thành công không bao giờ làm gián đoạn quá trình truy xuất — bản sửa đổi sẵn sàng cuối cùng vẫn có sẵn trong chỉ mục nội dung.",
   "newKnowledge.lastSyncColumn": "Đồng bộ hóa lần cuối",
   "newKnowledge.learnMore": "Tìm hiểu thêm",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "Thoát khỏi thiết lập chưa hoàn tất?",
   "newKnowledge.legacy": "Cũ",
   "newKnowledge.loadMore": "Tải thêm",
+  "newKnowledge.loadMoreRevisions": "Tải các bản sửa đổi cũ hơn",
   "newKnowledge.loadingSyncPolicy": "Đang tải chính sách đồng bộ",
   "newKnowledge.manualUpload": "Tải lên thủ công",
   "newKnowledge.maxPages": "Số trang tối đa",
   "newKnowledge.metadata": "Siêu dữ liệu",
+  "newKnowledge.mimeType": "Loại tệp",
   "newKnowledge.moreProviders": "Nhà cung cấp khác",
   "newKnowledge.name": "Tên kiến thức",
   "newKnowledge.namePlaceholder": "ví dụ: Sổ tay hỗ trợ khách hàng",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "Kết nối Notion để chọn trang và duy trì đồng bộ.",
   "newKnowledge.onlineDocuments": "Tài liệu trực tuyến",
   "newKnowledge.onlineDrive": "Ổ đĩa trực tuyến",
+  "newKnowledge.overview": "Tổng quan",
   "newKnowledge.pagesAppearDescription": "Thu thập trang web để xem những trang nào sẽ được thêm.",
   "newKnowledge.pagesAppearTitle": "Các trang sẽ xuất hiện ở đây",
   "newKnowledge.pagesCrawled": "Đã thu thập {{count}} trang tại {{host}}",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} chưa được định cấu hình",
   "newKnowledge.providerNotConfiguredDescription": "Thêm khóa API hoặc URL điểm cuối để thu thập dữ liệu trang web bằng {{provider}}.",
   "newKnowledge.providerUnavailable": "Nhà cung cấp này không có sẵn.",
+  "newKnowledge.quality": "Chất lượng",
   "newKnowledge.reCrawl": "Thu thập lại",
   "newKnowledge.readOnlyEmpty": "Yêu cầu biên tập viên không gian làm việc tạo cơ sở kiến thức đầu tiên.",
   "newKnowledge.refreshConnectionStatus": "Trạng thái làm mới",
   "newKnowledge.refreshingConnection": "Đang làm mới…",
+  "newKnowledge.reindexDocument": "Lập chỉ mục lại",
   "newKnowledge.reindexDocuments": "Lập chỉ mục lại",
   "newKnowledge.removeSource": "Xóa nguồn",
+  "newKnowledge.retrievalCount": "Số lần truy xuất",
   "newKnowledge.retryCrawl": "Thử thu thập lại",
   "newKnowledge.retryProviderLoad": "Thử lại",
+  "newKnowledge.retryReindexDocument": "Lập chỉ mục lại lần nữa",
   "newKnowledge.retrySyncPolicy": "Thử lại chính sách đồng bộ",
   "newKnowledge.retryTask": "Thử lại",
+  "newKnowledge.revisionState.active": "Đang hoạt động",
+  "newKnowledge.revisionState.candidate": "Đang xử lý",
+  "newKnowledge.revisionState.failed": "Thất bại",
+  "newKnowledge.revisionState.superseded": "Trước đó",
   "newKnowledge.rootUrl": "URL gốc",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "Phần này sẽ có sẵn trong bước thiết lập tiếp theo.",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "Chọn tất cả",
   "newKnowledge.selectAllDocuments": "Chọn tất cả tài liệu",
   "newKnowledge.selectAllSources": "Chọn tất cả nguồn",
+  "newKnowledge.selectChunk": "Chọn một đoạn để xem nội dung.",
   "newKnowledge.selectFilesAndFolders": "Chọn tệp và thư mục để đồng bộ",
   "newKnowledge.skippedFailed": "Đã bỏ qua (thất bại)",
   "newKnowledge.skippedOffDomain": "Đã bỏ qua (ngoài miền)",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "Nhiệm vụ",
   "newKnowledge.tasksErrorDescription": "Chúng tôi không thể tải tác vụ nền. Hãy thử lại.",
   "newKnowledge.tasksWithAttention": "Nhiệm vụ, {{count}} cần chú ý",
+  "newKnowledge.tokenCount": "Token",
   "newKnowledge.unavailableDescription": "KnowledgeFS hiện không khả dụng cho không gian làm việc này.",
   "newKnowledge.unavailableTitle": "Kiến thức mới không khả dụng",
   "newKnowledge.updated": "Cập nhật {{date}}",
+  "newKnowledge.updatedAt": "Cập nhật gần nhất",
   "newKnowledge.updatedColumn": "Đã cập nhật",
   "newKnowledge.uploadCharactersUnavailable": "Ký tự: —",
   "newKnowledge.uploadDocuments": "Tải tài liệu lên",

web/i18n/zh-Hans/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "调整并重新抓取",
   "newKnowledge.allDocumentStatuses": "全部状态",
   "newKnowledge.allSources": "所有来源",
+  "newKnowledge.apiAgentAccess": "API 与智能体访问",
   "newKnowledge.appsUnavailable": "— 个应用",
   "newKnowledge.authKind.api-key": "API 密钥",
   "newKnowledge.authKind.endpoint": "端点",
   "newKnowledge.authenticationMethod": "认证方式",
+  "newKnowledge.averageChunkLength": "平均分段长度",
   "newKnowledge.backToList": "返回知识库列表",
   "newKnowledge.backgroundTasks": "后台任务",
   "newKnowledge.backgroundTasksDescription": "文档添加、数据源同步和重新索引任务。",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "批量文档操作",
   "newKnowledge.cancelAddSource": "取消",
   "newKnowledge.cardType": "知识空间",
+  "newKnowledge.characterCount": "字符数",
+  "newKnowledge.checkReindexStatus": "检查重新索引状态",
+  "newKnowledge.chunkCount": "分段数",
+  "newKnowledge.chunkHeading": "分段 {{position}}",
+  "newKnowledge.chunkLocation": "此修订版本中的第 {{position}} 个位置",
   "newKnowledge.clearDocumentSelection": "清除文档选择",
   "newKnowledge.configureProvider": "配置{{provider}}",
   "newKnowledge.connectNotion": "连接 Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "添加网站源之前刷新连接。",
   "newKnowledge.connectionProvisioning": "{{provider}} 正在连接",
   "newKnowledge.connectionRefreshFailed": "我们无法刷新此连接。再试一次。",
+  "newKnowledge.continueCheckingTaskStatus": "继续检查任务状态",
   "newKnowledge.crawlAndPreview": "抓取和预览",
   "newKnowledge.crawlFailed": "无法抓取 {{host}}",
   "newKnowledge.crawlFailed403": "网站返回了 403，可能阻止抓取工具访问或需要身份验证。请检查 URL、调整抓取选项，或尝试其他提供商。",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "无法创建此知识库，请检查权限后重试。",
   "newKnowledge.createIllustrationTitle": "只需连接一次内容——每个应用都能用最新知识作答。",
   "newKnowledge.createTitle": "创建知识库",
+  "newKnowledge.createdAt": "创建时间",
   "newKnowledge.creators": "创建者",
   "newKnowledge.customIntervalHours": "自定义间隔（小时）",
   "newKnowledge.customIntervalInvalid": "请输入 1 到 720 之间的整数小时数。",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "放弃此来源草稿？",
   "newKnowledge.documentActions": "{{name}} 的操作",
   "newKnowledge.documentActionsUnavailable": "此知识库暂不支持文档操作。",
+  "newKnowledge.documentChunksEmpty": "此修订版本暂时没有可用分段。",
+  "newKnowledge.documentChunksLoadError": "无法加载此修订版本的分段。",
+  "newKnowledge.documentChunksLoadMoreError": "无法加载更多分段，请重试。",
   "newKnowledge.documentColumn": "文档",
+  "newKnowledge.documentContentIncomplete": "正在加载剩余文档内容…",
+  "newKnowledge.documentContents": "目录",
+  "newKnowledge.documentFacts": "文档详情",
   "newKnowledge.documentFilterLabel": "按状态筛选文档",
+  "newKnowledge.documentLoadErrorDescription": "无法加载此文档，请重试。",
+  "newKnowledge.documentLoadErrorTitle": "文档加载失败",
+  "newKnowledge.documentNotFoundDescription": "此文档可能已被删除，或你没有访问权限。",
+  "newKnowledge.documentNotFoundTitle": "未找到文档",
+  "newKnowledge.documentOverviewDescription": "为文档标注元数据可帮助 AI 及时访问内容，并向用户展示引用来源。",
   "newKnowledge.documentPermissionRestricted": "你的工作区权限不允许执行文档或任务操作。",
+  "newKnowledge.documentReindexConfirmationDelayed": "重新索引已受理，但任务状态同步延迟。再次提交前请先检查状态。",
+  "newKnowledge.documentReindexFailed": "重新索引失败，最后一个就绪的修订版本仍然可用。",
+  "newKnowledge.documentReindexProgress": "正在重新索引 · {{progress}}%",
+  "newKnowledge.documentRevision": "修订版本",
+  "newKnowledge.documentRevisionMissingDescription": "此文档还没有就绪的修订版本，请在处理完成后再查看。",
+  "newKnowledge.documentRevisionMissingTitle": "没有可用的修订版本",
+  "newKnowledge.documentRevisionsLoadError": "无法加载修订历史，当前修订版本仍然可用。",
   "newKnowledge.documentStatus.disabled": "已禁用",
   "newKnowledge.documentStatus.failed": "失败",
   "newKnowledge.documentStatus.processing": "处理中",
   "newKnowledge.documentStatus.queued": "排队中",
   "newKnowledge.documentStatus.ready": "就绪",
+  "newKnowledge.documentTaskLookupIncomplete": "还有更多任务历史记录。继续检查以查找此文档的状态。",
   "newKnowledge.documentUploadExclusion.batchLimit": "超出批次大小限制",
   "newKnowledge.documentUploadExclusion.countLimit": "超出文件数量限制",
   "newKnowledge.documentUploadExclusion.fileSize": "文件过大",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— 篇文档",
   "newKnowledge.downloadDocuments": "下载",
   "newKnowledge.editSource": "编辑",
+  "newKnowledge.emptyChunk": "空分段",
   "newKnowledge.emptyDescription": "添加文档后，智能体即可直接读取，无需配置索引。",
   "newKnowledge.emptyTitle": "更智能的知识库构建方式",
   "newKnowledge.errorDescription": "无法加载新知识库，请重试。",
   "newKnowledge.errorTitle": "出现错误",
+  "newKnowledge.fileSize": "文件大小",
   "newKnowledge.filtersUnavailable": "KnowledgeFS 提供元数据后即可使用此筛选器。",
   "newKnowledge.firecrawlUnavailable": "Firecrawl 在此工作区的提供程序目录中不可用。",
   "newKnowledge.gotIt": "知道了",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "认识全新的知识库 ✨",
   "newKnowledge.illustrationHeadline": "只需连接一次内容，每个应用都能基于最新知识回答。",
   "newKnowledge.includeSubpages": "包含子页面",
+  "newKnowledge.indexInformation": "索引信息",
   "newKnowledge.interruptTask": "中断",
   "newKnowledge.invalidRootUrl": "请输入有效的 http(s) URL。",
   "newKnowledge.keepEditing": "继续编辑",
+  "newKnowledge.lastIndexed": "最近索引时间",
   "newKnowledge.lastReadyRevisionHint": "处理失败不会中断检索，内容索引中会继续保留上一个就绪的修订。",
   "newKnowledge.lastSyncColumn": "上次同步",
   "newKnowledge.learnMore": "了解更多",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "离开未完成的设置？",
   "newKnowledge.legacy": "旧版",
   "newKnowledge.loadMore": "加载更多",
+  "newKnowledge.loadMoreRevisions": "加载更早的修订版本",
   "newKnowledge.loadingSyncPolicy": "正在加载同步策略",
   "newKnowledge.manualUpload": "手动上传",
   "newKnowledge.maxPages": "最大页面数",
   "newKnowledge.metadata": "元数据",
+  "newKnowledge.mimeType": "文件类型",
   "newKnowledge.moreProviders": "更多提供商",
   "newKnowledge.name": "知识库名称",
   "newKnowledge.namePlaceholder": "例如：客户支持手册",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "连接 Notion 以选择页面并保持同步。",
   "newKnowledge.onlineDocuments": "在线文档",
   "newKnowledge.onlineDrive": "在线驱动器",
+  "newKnowledge.overview": "概览",
   "newKnowledge.pagesAppearDescription": "抓取网站以查看将添加哪些页面。",
   "newKnowledge.pagesAppearTitle": "页面将显示在此处",
   "newKnowledge.pagesCrawled": "已抓取 {{host}} 的 {{count}} 个页面",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} 未配置",
   "newKnowledge.providerNotConfiguredDescription": "添加 API 密钥或端点 URL 以使用 {{provider}} 抓取网站。",
   "newKnowledge.providerUnavailable": "该提供商不可用。",
+  "newKnowledge.quality": "质量",
   "newKnowledge.reCrawl": "重新抓取",
   "newKnowledge.readOnlyEmpty": "请联系工作区编辑者创建第一个知识库。",
   "newKnowledge.refreshConnectionStatus": "刷新状态",
   "newKnowledge.refreshingConnection": "正在刷新……",
+  "newKnowledge.reindexDocument": "重新索引",
   "newKnowledge.reindexDocuments": "重新索引",
   "newKnowledge.removeSource": "删除来源",
+  "newKnowledge.retrievalCount": "检索次数",
   "newKnowledge.retryCrawl": "重试抓取",
   "newKnowledge.retryProviderLoad": "重试",
+  "newKnowledge.retryReindexDocument": "再次重新索引",
   "newKnowledge.retrySyncPolicy": "重试同步策略",
   "newKnowledge.retryTask": "重试",
+  "newKnowledge.revisionState.active": "活跃",
+  "newKnowledge.revisionState.candidate": "处理中",
+  "newKnowledge.revisionState.failed": "失败",
+  "newKnowledge.revisionState.superseded": "上一个",
   "newKnowledge.rootUrl": "根 URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "此部分将在下一设置步骤中开放。",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "全选",
   "newKnowledge.selectAllDocuments": "选择全部文档",
   "newKnowledge.selectAllSources": "选择所有来源",
+  "newKnowledge.selectChunk": "选择一个分段以查看其内容。",
   "newKnowledge.selectFilesAndFolders": "选择要同步的文件和文件夹",
   "newKnowledge.skippedFailed": "已跳过（失败）",
   "newKnowledge.skippedOffDomain": "已跳过（域外）",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "任务",
   "newKnowledge.tasksErrorDescription": "无法加载后台任务，请重试。",
   "newKnowledge.tasksWithAttention": "任务，{{count}} 个需要关注",
+  "newKnowledge.tokenCount": "Token 数",
   "newKnowledge.unavailableDescription": "KnowledgeFS 当前在此工作区不可用。",
   "newKnowledge.unavailableTitle": "新版知识库不可用",
   "newKnowledge.updated": "更新于 {{date}}",
+  "newKnowledge.updatedAt": "最后更新",
   "newKnowledge.updatedColumn": "更新时间",
   "newKnowledge.uploadCharactersUnavailable": "字符数：—",
   "newKnowledge.uploadDocuments": "上传文档",

web/i18n/zh-Hant/dataset.json

@@ -140,10 +140,12 @@
   "newKnowledge.adjustAndRecrawl": "調整並重新抓取",
   "newKnowledge.allDocumentStatuses": "全部狀態",
   "newKnowledge.allSources": "所有來源",
+  "newKnowledge.apiAgentAccess": "API 與智慧體存取",
   "newKnowledge.appsUnavailable": "— 個應用程式",
   "newKnowledge.authKind.api-key": "API 金鑰",
   "newKnowledge.authKind.endpoint": "端點",
   "newKnowledge.authenticationMethod": "認證方式",
+  "newKnowledge.averageChunkLength": "平均分段長度",
   "newKnowledge.backToList": "返回知識庫列表",
   "newKnowledge.backgroundTasks": "背景任務",
   "newKnowledge.backgroundTasksDescription": "文件新增、資料來源同步和重新索引任務。",
@@ -152,6 +154,11 @@
   "newKnowledge.bulkDocumentActions": "批次文件操作",
   "newKnowledge.cancelAddSource": "取消",
   "newKnowledge.cardType": "知識空間",
+  "newKnowledge.characterCount": "字元數",
+  "newKnowledge.checkReindexStatus": "檢查重新索引狀態",
+  "newKnowledge.chunkCount": "分段數",
+  "newKnowledge.chunkHeading": "分段 {{position}}",
+  "newKnowledge.chunkLocation": "此修訂版本中的第 {{position}} 個位置",
   "newKnowledge.clearDocumentSelection": "清除文件選取",
   "newKnowledge.configureProvider": "配置{{provider}}",
   "newKnowledge.connectNotion": "連接 Notion",
@@ -165,6 +172,7 @@
   "newKnowledge.connectionNeedsAttentionDescription": "新增網站來源之前刷新連線。",
   "newKnowledge.connectionProvisioning": "{{provider}} 正在連接",
   "newKnowledge.connectionRefreshFailed": "我們無法刷新此連線。再試一次。",
+  "newKnowledge.continueCheckingTaskStatus": "繼續檢查任務狀態",
   "newKnowledge.crawlAndPreview": "抓取與預覽",
   "newKnowledge.crawlFailed": "無法抓取 {{host}}",
   "newKnowledge.crawlFailed403": "網站傳回了 403，可能阻擋抓取工具或需要驗證。請檢查 URL、調整抓取選項，或嘗試其他供應商。",
@@ -184,6 +192,7 @@
   "newKnowledge.createFailed": "無法建立此知識庫，請檢查權限後再試一次。",
   "newKnowledge.createIllustrationTitle": "只需連接一次內容——每個應用都能以最新知識作答。",
   "newKnowledge.createTitle": "建立知識庫",
+  "newKnowledge.createdAt": "建立時間",
   "newKnowledge.creators": "建立者",
   "newKnowledge.customIntervalHours": "自訂間隔（小時）",
   "newKnowledge.customIntervalInvalid": "請輸入 1 到 720 之間的整數小時數。",
@@ -205,14 +214,33 @@
   "newKnowledge.discardSourceDraftTitle": "捨棄此來源草稿？",
   "newKnowledge.documentActions": "{{name}} 的操作",
   "newKnowledge.documentActionsUnavailable": "此知識庫暫不支援文件操作。",
+  "newKnowledge.documentChunksEmpty": "此修訂版本暫時沒有可用分段。",
+  "newKnowledge.documentChunksLoadError": "無法載入此修訂版本的分段。",
+  "newKnowledge.documentChunksLoadMoreError": "無法載入更多分段，請再試一次。",
   "newKnowledge.documentColumn": "文件",
+  "newKnowledge.documentContentIncomplete": "正在載入剩餘文件內容…",
+  "newKnowledge.documentContents": "目錄",
+  "newKnowledge.documentFacts": "文件詳細資料",
   "newKnowledge.documentFilterLabel": "依狀態篩選文件",
+  "newKnowledge.documentLoadErrorDescription": "無法載入此文件，請再試一次。",
+  "newKnowledge.documentLoadErrorTitle": "文件載入失敗",
+  "newKnowledge.documentNotFoundDescription": "此文件可能已被移除，或你沒有存取權限。",
+  "newKnowledge.documentNotFoundTitle": "找不到文件",
+  "newKnowledge.documentOverviewDescription": "為文件標註中繼資料可協助 AI 及時存取內容，並向使用者顯示引用來源。",
   "newKnowledge.documentPermissionRestricted": "你的工作區權限不允許執行文件或任務操作。",
+  "newKnowledge.documentReindexConfirmationDelayed": "重新索引已受理，但任務狀態同步延遲。再次提交前請先檢查狀態。",
+  "newKnowledge.documentReindexFailed": "重新建立索引失敗，最後一個就緒的修訂版本仍然可用。",
+  "newKnowledge.documentReindexProgress": "正在重新建立索引 · {{progress}}%",
+  "newKnowledge.documentRevision": "修訂版本",
+  "newKnowledge.documentRevisionMissingDescription": "此文件尚未有就緒的修訂版本，請在處理完成後再查看。",
+  "newKnowledge.documentRevisionMissingTitle": "沒有可用的修訂版本",
+  "newKnowledge.documentRevisionsLoadError": "無法載入修訂歷程，目前的修訂版本仍然可用。",
   "newKnowledge.documentStatus.disabled": "已停用",
   "newKnowledge.documentStatus.failed": "失敗",
   "newKnowledge.documentStatus.processing": "處理中",
   "newKnowledge.documentStatus.queued": "排隊中",
   "newKnowledge.documentStatus.ready": "就緒",
+  "newKnowledge.documentTaskLookupIncomplete": "還有更多任務歷史記錄。繼續檢查以尋找此文件的狀態。",
   "newKnowledge.documentUploadExclusion.batchLimit": "超出批次大小限制",
   "newKnowledge.documentUploadExclusion.countLimit": "超出檔案數量限制",
   "newKnowledge.documentUploadExclusion.fileSize": "檔案過大",
@@ -241,10 +269,12 @@
   "newKnowledge.documentsUnavailable": "— 份文件",
   "newKnowledge.downloadDocuments": "下載",
   "newKnowledge.editSource": "編輯",
+  "newKnowledge.emptyChunk": "空分段",
   "newKnowledge.emptyDescription": "加入文件後，智慧代理即可直接讀取，無需設定索引。",
   "newKnowledge.emptyTitle": "更聰明的知識庫建立方式",
   "newKnowledge.errorDescription": "無法載入新知識庫，請再試一次。",
   "newKnowledge.errorTitle": "發生錯誤",
+  "newKnowledge.fileSize": "檔案大小",
   "newKnowledge.filtersUnavailable": "KnowledgeFS 提供中繼資料後即可使用此篩選器。",
   "newKnowledge.firecrawlUnavailable": "Firecrawl 在此工作區的提供者目錄中不可用。",
   "newKnowledge.gotIt": "知道了",
@@ -252,9 +282,11 @@
   "newKnowledge.guideTitle": "認識全新的知識庫 ✨",
   "newKnowledge.illustrationHeadline": "只需連接一次內容，每個應用程式都能以最新知識回答。",
   "newKnowledge.includeSubpages": "包含子頁面",
+  "newKnowledge.indexInformation": "索引資訊",
   "newKnowledge.interruptTask": "中斷",
   "newKnowledge.invalidRootUrl": "請輸入有效的 http(s) URL。",
   "newKnowledge.keepEditing": "繼續編輯",
+  "newKnowledge.lastIndexed": "最近建立索引時間",
   "newKnowledge.lastReadyRevisionHint": "處理失敗不會中斷檢索，內容索引中會繼續保留上一個就緒的修訂。",
   "newKnowledge.lastSyncColumn": "上次同步",
   "newKnowledge.learnMore": "瞭解更多",
@@ -263,10 +295,12 @@
   "newKnowledge.leavePartialSetupTitle": "離開未完成的設定？",
   "newKnowledge.legacy": "舊版",
   "newKnowledge.loadMore": "載入更多",
+  "newKnowledge.loadMoreRevisions": "載入較早的修訂版本",
   "newKnowledge.loadingSyncPolicy": "正在載入同步政策",
   "newKnowledge.manualUpload": "手動上傳",
   "newKnowledge.maxPages": "頁面數上限",
   "newKnowledge.metadata": "中繼資料",
+  "newKnowledge.mimeType": "檔案類型",
   "newKnowledge.moreProviders": "更多提供者",
   "newKnowledge.name": "知識庫名稱",
   "newKnowledge.namePlaceholder": "例如：客戶支援手冊",
@@ -284,6 +318,7 @@
   "newKnowledge.notionNotConnectedDescription": "連接 Notion 以選擇頁面並保持同步。",
   "newKnowledge.onlineDocuments": "線上文檔",
   "newKnowledge.onlineDrive": "線上驅動器",
+  "newKnowledge.overview": "概覽",
   "newKnowledge.pagesAppearDescription": "抓取網站以查看將新增哪些頁面。",
   "newKnowledge.pagesAppearTitle": "頁面將顯示在此處",
   "newKnowledge.pagesCrawled": "已抓取 {{host}} 的 {{count}} 個頁面",
@@ -314,16 +349,24 @@
   "newKnowledge.providerNotConfigured": "{{provider}} 未配置",
   "newKnowledge.providerNotConfiguredDescription": "新增 API 金鑰或端點 URL 以使用 {{provider}} 抓取網站。",
   "newKnowledge.providerUnavailable": "該提供者不可用。",
+  "newKnowledge.quality": "品質",
   "newKnowledge.reCrawl": "重新抓取",
   "newKnowledge.readOnlyEmpty": "請聯絡工作區編輯者建立第一個知識庫。",
   "newKnowledge.refreshConnectionStatus": "刷新狀態",
   "newKnowledge.refreshingConnection": "正在重新整理…",
+  "newKnowledge.reindexDocument": "重新建立索引",
   "newKnowledge.reindexDocuments": "重新索引",
   "newKnowledge.removeSource": "刪除來源",
+  "newKnowledge.retrievalCount": "檢索次數",
   "newKnowledge.retryCrawl": "重試抓取",
   "newKnowledge.retryProviderLoad": "重試",
+  "newKnowledge.retryReindexDocument": "再次重新索引",
   "newKnowledge.retrySyncPolicy": "重試同步政策",
   "newKnowledge.retryTask": "重試",
+  "newKnowledge.revisionState.active": "啟用中",
+  "newKnowledge.revisionState.candidate": "處理中",
+  "newKnowledge.revisionState.failed": "失敗",
+  "newKnowledge.revisionState.superseded": "上一個",
   "newKnowledge.rootUrl": "根 URL",
   "newKnowledge.rootUrlPlaceholder": "https://docs.example.com",
   "newKnowledge.routeUnavailable": "此區段將在下一個設定步驟中開放。",
@@ -332,6 +375,7 @@
   "newKnowledge.selectAll": "全選",
   "newKnowledge.selectAllDocuments": "選取全部文件",
   "newKnowledge.selectAllSources": "選擇所有來源",
+  "newKnowledge.selectChunk": "選取一個分段以查看其內容。",
   "newKnowledge.selectFilesAndFolders": "選擇要同步的檔案與資料夾",
   "newKnowledge.skippedFailed": "已略過（失敗）",
   "newKnowledge.skippedOffDomain": "已略過（網域外）",
@@ -383,9 +427,11 @@
   "newKnowledge.tasks": "任務",
   "newKnowledge.tasksErrorDescription": "無法載入背景任務，請再試一次。",
   "newKnowledge.tasksWithAttention": "任務，{{count}} 個需要注意",
+  "newKnowledge.tokenCount": "Token 數",
   "newKnowledge.unavailableDescription": "KnowledgeFS 目前在此工作區不可用。",
   "newKnowledge.unavailableTitle": "新版知識庫不可用",
   "newKnowledge.updated": "更新於 {{date}}",
+  "newKnowledge.updatedAt": "最後更新",
   "newKnowledge.updatedColumn": "更新時間",
   "newKnowledge.uploadCharactersUnavailable": "字元數：—",
   "newKnowledge.uploadDocuments": "上傳文件",