@semiont/react-ui 0.5.2 → 0.5.3

package/src/components/resource/panels/TaggingPanel.tsx

@@ -9,7 +9,6 @@ import type { components, Selector } from '@semiont/core';
 import { getTextPositionSelector, getTargetSelector } from '@semiont/core';
 import { TagEntry } from './TagEntry';
 import { PanelHeader } from './PanelHeader';
-import { getAllTagSchemas } from '../../../lib/tag-schemas';
 import './TaggingPanel.css';
 
 import type { Annotation } from '@semiont/core';
@@ -76,8 +75,34 @@ export function TaggingPanel({
 }: TaggingPanelProps) {
   const t = useTranslations('TaggingPanel');
   const session = useObservable(useSemiont().activeSession$);
-  const [selectedSchemaId, setSelectedSchemaId] = useState<string>('legal-irac');
+
+  // Subscribe to the per-KB tag-schema registry. Schemas are runtime-
+  // registered by the KB at session start (see frame.addTagSchema).
+  // During the initial load the observable yields `undefined` — render an
+  // empty schemas list and let the picker render no options until the
+  // first emission lands.
+  const tagSchemas$ = useMemo(
+    () => session?.client.browse.tagSchemas() ?? null,
+    [session],
+  );
+  const schemasObserved = useObservable(tagSchemas$);
+  const schemas = schemasObserved ?? [];
+  // True only AFTER the registry has resolved AND it's empty — distinct
+  // from the initial-loading state (`schemasObserved === undefined`),
+  // which renders nothing rather than an empty-state message.
+  const noSchemasRegistered = schemasObserved !== undefined && schemasObserved.length === 0;
+
+  const [selectedSchemaId, setSelectedSchemaId] = useState<string>('');
   const [selectedCategories, setSelectedCategories] = useState<Set<string>>(new Set());
+
+  // Default the schema selection to the first registered schema once
+  // the registry resolves. We don't reset on schemas changing to avoid
+  // clobbering an explicit user choice.
+  useEffect(() => {
+    if (!selectedSchemaId && schemas.length > 0) {
+      setSelectedSchemaId(schemas[0]!.id);
+    }
+  }, [schemas, selectedSchemaId]);
   const [focusedAnnotationId, setFocusedAnnotationId] = useState<string | null>(null);
   const containerRef = useRef<HTMLDivElement>(null);
 
@@ -165,7 +190,6 @@ export function TaggingPanel({
     // Pulse effect is handled by isHovered prop on TagEntry
   }, [hoveredAnnotationId]);
 
-  const schemas = getAllTagSchemas();
   const selectedSchema = schemas.find(s => s.id === selectedSchemaId);
 
   const handleSchemaChange = (schemaId: string) => {
@@ -248,23 +272,32 @@ export function TaggingPanel({
               </p>
             </div>
 
+            {/* Empty-state — registry has resolved with no schemas. */}
+            {noSchemasRegistered && (
+              <p className="semiont-form__help" data-type="tag-no-schemas">
+                {t('noSchemas')}
+              </p>
+            )}
+
             {/* Schema and Category Selection for Manual Tag */}
-            <div className="semiont-form-field">
-              <label className="semiont-form-field__label">
-                {t('selectSchema')}
-              </label>
-              <select
-                value={selectedSchemaId}
-                onChange={(e) => handleSchemaChange(e.target.value)}
-                className="semiont-select"
-              >
-                {schemas.map(schema => (
-                  <option key={schema.id} value={schema.id}>
-                    {t(`schema${schema.id === 'legal-irac' ? 'Legal' : schema.id === 'scientific-imrad' ? 'Scientific' : 'Argument'}`)}
-                  </option>
-                ))}
-              </select>
-            </div>
+            {!noSchemasRegistered && (
+              <div className="semiont-form-field">
+                <label className="semiont-form-field__label">
+                  {t('selectSchema')}
+                </label>
+                <select
+                  value={selectedSchemaId}
+                  onChange={(e) => handleSchemaChange(e.target.value)}
+                  className="semiont-select"
+                >
+                  {schemas.map(schema => (
+                    <option key={schema.id} value={schema.id}>
+                      {schema.name}
+                    </option>
+                  ))}
+                </select>
+              </div>
+            )}
 
             {selectedSchema && (
               <div className="semiont-form-field">
@@ -334,28 +367,37 @@ export function TaggingPanel({
               <div className="semiont-assist-widget" data-assisting={isAssisting && progress ? 'true' : 'false'} data-type="tag">
               {!isAssisting && !progress && (
                 <>
+                  {/* Empty-state — registry has resolved with no schemas. */}
+                  {noSchemasRegistered && (
+                    <p className="semiont-form__help" data-type="tag-no-schemas">
+                      {t('noSchemas')}
+                    </p>
+                  )}
+
                   {/* Schema Selector */}
-                  <div className="semiont-form-field">
-                    <label className="semiont-form-field__label">
-                      {t('selectSchema')}
-                    </label>
-                    <select
-                      value={selectedSchemaId}
-                      onChange={(e) => handleSchemaChange(e.target.value)}
-                      className="semiont-select"
-                    >
-                      {schemas.map(schema => (
-                        <option key={schema.id} value={schema.id}>
-                          {t(`schema${schema.id === 'legal-irac' ? 'Legal' : schema.id === 'scientific-imrad' ? 'Scientific' : 'Argument'}`)}
-                        </option>
-                      ))}
-                    </select>
-                    {selectedSchema && (
-                      <p className="semiont-form__help">
-                        {selectedSchema.description}
-                      </p>
-                    )}
-                  </div>
+                  {!noSchemasRegistered && (
+                    <div className="semiont-form-field">
+                      <label className="semiont-form-field__label">
+                        {t('selectSchema')}
+                      </label>
+                      <select
+                        value={selectedSchemaId}
+                        onChange={(e) => handleSchemaChange(e.target.value)}
+                        className="semiont-select"
+                      >
+                        {schemas.map(schema => (
+                          <option key={schema.id} value={schema.id}>
+                            {schema.name}
+                          </option>
+                        ))}
+                      </select>
+                      {selectedSchema && (
+                        <p className="semiont-form__help">
+                          {selectedSchema.description}
+                        </p>
+                      )}
+                    </div>
+                  )}
 
                   {/* Category Selector */}
                   {selectedSchema && (
@@ -398,7 +440,7 @@ export function TaggingPanel({
                               style={{ display: 'flex', flexDirection: 'column', gap: '0.25rem' }}
                             >
                               <span style={{ fontWeight: 500 }}>
-                                {t(`category${category.name.replace(/\s+/g, '')}`)}
+                                {category.name}
                               </span>
                               <span style={{ fontSize: 'var(--semiont-text-xs)', color: 'var(--semiont-text-secondary)' }}>
                                 {category.description}

package/src/components/resource/panels/__tests__/TagEntry.test.tsx

@@ -1,10 +1,12 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import React from 'react';
-import { screen } from '@testing-library/react';
+import { render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
-import { renderWithProviders } from '../../../../test-utils';
+import { of } from 'rxjs';
+import { CacheObservable } from '@semiont/sdk';
+import { renderWithProviders, createTestSemiontWrapper } from '../../../../test-utils';
 import userEvent from '@testing-library/user-event';
-import type { components } from '@semiont/core';
+import type { components, TagSchema } from '@semiont/core';
 
 import type { Annotation } from '@semiont/core';
 
@@ -23,21 +25,15 @@ vi.mock('@semiont/ontology', () => ({
   getTagSchemaId: vi.fn(),
 }));
 
-// Mock tag-schemas
-vi.mock('../../../../lib/tag-schemas', () => ({
-  getTagSchema: vi.fn(),
-}));
-
 import { getAnnotationExactText } from '@semiont/core';
 import { getTagCategory, getTagSchemaId } from '@semiont/ontology';
-import { getTagSchema } from '../../../../lib/tag-schemas';
 import type { MockedFunction } from 'vitest';
 import { TagEntry } from '../TagEntry';
 
 const mockGetAnnotationExactText = getAnnotationExactText as MockedFunction<typeof getAnnotationExactText>;
 const mockGetTagCategory = getTagCategory as MockedFunction<typeof getTagCategory>;
 const mockGetTagSchemaId = getTagSchemaId as MockedFunction<typeof getTagSchemaId>;
-const mockGetTagSchema = getTagSchema as MockedFunction<typeof getTagSchema>;
+
 
 const createMockTag = (overrides?: Partial<Annotation>): Annotation => ({
   '@context': 'http://www.w3.org/ns/anno.jsonld',
@@ -76,7 +72,6 @@ describe('TagEntry', () => {
     mockGetAnnotationExactText.mockReturnValue('Tagged text content');
     mockGetTagCategory.mockReturnValue('Entity');
     mockGetTagSchemaId.mockReturnValue(null);
-    mockGetTagSchema.mockReturnValue(null);
   });
 
   describe('Rendering', () => {
@@ -115,24 +110,36 @@ describe('TagEntry', () => {
 
     it('should render schema name when available', () => {
       mockGetTagSchemaId.mockReturnValue('schema-ner-v1');
-      mockGetTagSchema.mockReturnValue({
+      const NER_SCHEMA: TagSchema = {
         id: 'schema-ner-v1',
         name: 'Named Entity Recognition',
+        description: 'NER',
         domain: 'nlp',
-        version: '1.0',
-        categories: [],
-      });
-
-      renderWithProviders(<TagEntry {...defaultProps} />);
+        tags: [],
+      };
+
+      // Stub the cache to resolve immediately with the test schema —
+      // exercises the rendering path without round-tripping through the
+      // transport's HTTP plumbing.
+      const { SemiontWrapper, client } = createTestSemiontWrapper();
+      vi.spyOn(client.browse, 'tagSchemas').mockReturnValue(
+        CacheObservable.from(of([NER_SCHEMA]))
+      );
+      render(<TagEntry {...defaultProps} />, { wrapper: SemiontWrapper });
 
       expect(screen.getByText('Named Entity Recognition')).toBeInTheDocument();
     });
 
     it('should not render schema name when schema is not found', () => {
       mockGetTagSchemaId.mockReturnValue('unknown-schema');
-      mockGetTagSchema.mockReturnValue(null);
 
-      const { container } = renderWithProviders(<TagEntry {...defaultProps} />);
+      // Stub the cache to resolve to an empty list — the schema lookup
+      // misses, the schema-name `<span>` is not rendered.
+      const { SemiontWrapper, client } = createTestSemiontWrapper();
+      vi.spyOn(client.browse, 'tagSchemas').mockReturnValue(
+        CacheObservable.from(of([]))
+      );
+      const { container } = render(<TagEntry {...defaultProps} />, { wrapper: SemiontWrapper });
 
       expect(container.querySelector('.semiont-annotation-entry__meta')).not.toBeInTheDocument();
     });

package/src/components/resource/panels/__tests__/TaggingPanel.test.tsx

@@ -4,8 +4,10 @@ import React from 'react';
 import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import '@testing-library/jest-dom';
+import { of } from 'rxjs';
+import { CacheObservable } from '@semiont/sdk';
 import { TaggingPanel } from '../TaggingPanel';
-import type { components, EventBus } from '@semiont/core';
+import type { components, EventBus, TagSchema } from '@semiont/core';
 import { createTestSemiontWrapper } from '../../../../test-utils';
 
 import type { Annotation } from '@semiont/core';
@@ -32,8 +34,30 @@ function createEventTracker() {
   };
 }
 
+// Test tag schemas — the panel subscribes to `client.browse.tagSchemas()`.
+// We stub that method directly to return a `CacheObservable` that emits
+// these schemas synchronously, mirroring the post-resolve cache state
+// without the round-trip through bus/transport plumbing.
+const TEST_TAG_SCHEMAS: TagSchema[] = [
+  {
+    id: 'legal-irac',
+    name: 'Legal (IRAC)',
+    description: 'Issue, Rule, Application, Conclusion framework for legal analysis',
+    domain: 'legal',
+    tags: [
+      { name: 'Issue',       description: 'Legal question to be resolved', examples: [] },
+      { name: 'Rule',        description: 'Legal principle or statute',    examples: [] },
+      { name: 'Application', description: 'Application of rule to facts',  examples: [] },
+      { name: 'Conclusion',  description: 'Resolution of the issue',       examples: [] },
+    ],
+  },
+];
+
 const renderWithEventBus = (component: React.ReactElement, tracker?: ReturnType<typeof createEventTracker>) => {
-  const { SemiontWrapper, eventBus } = createTestSemiontWrapper();
+  const { SemiontWrapper, eventBus, client } = createTestSemiontWrapper();
+  vi.spyOn(client.browse, 'tagSchemas').mockReturnValue(
+    CacheObservable.from(of(TEST_TAG_SCHEMAS))
+  );
   if (tracker) tracker._attach(eventBus);
   const Wrapper = ({ children }: { children: React.ReactNode }) => (
     <SemiontWrapper>{children}</SemiontWrapper>
@@ -41,20 +65,36 @@ const renderWithEventBus = (component: React.ReactElement, tracker?: ReturnType<
   return render(component, { wrapper: Wrapper });
 };
 
-// Mock TranslationContext
+// Variant for the empty-registry case: the cache resolves to `[]`
+// (post-bootstrap, no schemas registered). Distinct from the still-
+// loading case where the observable yields `undefined`.
+const renderWithEmptyRegistry = (component: React.ReactElement) => {
+  const { SemiontWrapper, client } = createTestSemiontWrapper();
+  vi.spyOn(client.browse, 'tagSchemas').mockReturnValue(
+    CacheObservable.from(of([]))
+  );
+  const Wrapper = ({ children }: { children: React.ReactNode }) => (
+    <SemiontWrapper>{children}</SemiontWrapper>
+  );
+  return render(component, { wrapper: Wrapper });
+};
+
+// Mock TranslationContext. The component now uses `schema.name` /
+// `category.name` directly off the registered TagSchema objects (Stage 2.B
+// of TAG-SCHEMAS-GAP), so the per-schema/per-category translation keys
+// the older mock carried (`schemaLegal`, `categoryIssue`, etc.) are no
+// longer referenced — kept the mock minimal.
 vi.mock('../../../../contexts/TranslationContext', () => ({
   useTranslations: vi.fn(() => (key: string, params?: Record<string, any>) => {
     const translations: Record<string, string> = {
       title: 'Tags',
       noTags: 'No tags yet. Select text to add a tag.',
+      noSchemas: 'No tag schemas registered for this knowledge base.',
       createTagForSelection: 'Create tag for selection',
       selectSchema: 'Select schema',
       selectCategory: 'Select category',
       selectCategories: 'Select categories',
       chooseCategory: 'Choose a category',
-      schemaLegal: 'Legal (IRAC)',
-      schemaScientific: 'Scientific (IMRAD)',
-      schemaArgument: 'Argument',
       annotateTags: 'Annotate Tags',
       annotate: 'Annotate',
       cancel: 'Cancel',
@@ -62,10 +102,6 @@ vi.mock('../../../../contexts/TranslationContext', () => ({
       selectAll: 'Select All',
       deselectAll: 'Deselect All',
       categoriesSelected: '{count} categories selected',
-      categoryIssue: 'Issue',
-      categoryRule: 'Rule',
-      categoryApplication: 'Application',
-      categoryConclusion: 'Conclusion',
     };
     let result = translations[key] || key;
     if (params?.count !== undefined) {
@@ -95,23 +131,6 @@ vi.mock('../TagEntry', () => ({
   ),
 }));
 
-// Mock tag schemas
-vi.mock('../../../../lib/tag-schemas', () => ({
-  getAllTagSchemas: vi.fn(() => [
-    {
-      id: 'legal-irac',
-      name: 'Legal (IRAC)',
-      description: 'Issue, Rule, Application, Conclusion framework for legal analysis',
-      tags: [
-        { name: 'Issue', description: 'Legal question to be resolved', color: '#3b82f6' },
-        { name: 'Rule', description: 'Legal principle or statute', color: '#10b981' },
-        { name: 'Application', description: 'Application of rule to facts', color: '#f59e0b' },
-        { name: 'Conclusion', description: 'Resolution of the issue', color: '#ef4444' },
-      ],
-    },
-  ]),
-}));
-
 import { getTextPositionSelector, getTargetSelector } from '@semiont/core';
 const mockGetTextPositionSelector = getTextPositionSelector as MockedFunction<typeof getTextPositionSelector>;
 const mockGetTargetSelector = getTargetSelector as MockedFunction<typeof getTargetSelector>;
@@ -307,7 +326,7 @@ describe('TaggingPanel Component', () => {
       expect(selects.length).toBeGreaterThan(0);
     });
 
-    it('should show category selector in tag creation form', () => {
+    it('should show category selector in tag creation form', async () => {
       const pendingAnnotation = createPendingAnnotation('Selected text');
 
       renderWithEventBus(
@@ -317,7 +336,10 @@ describe('TaggingPanel Component', () => {
         />
       );
 
-      expect(screen.getByText(/Select category/)).toBeInTheDocument();
+      // The category selector only renders once the schema list has
+      // resolved and the default schema (first registered) has been
+      // picked — async because the schemas come from `browse.tagSchemas()`.
+      expect(await screen.findByText(/Select category/)).toBeInTheDocument();
     });
 
     it('should emit mark:submitevent when category is selected', async () => {
@@ -332,7 +354,10 @@ describe('TaggingPanel Component', () => {
         tracker
       );
 
-      // Find the category selector (the one in the pending annotation form)
+      // Wait for the schema list to load — `browse.tagSchemas()` is
+      // async, so the category dropdown only renders after the bus
+      // response lands.
+      await screen.findByText(/Select category/);
       const categorySelects = screen.getAllByRole('combobox');
       const categorySelect = categorySelects.find(select =>
         select.querySelector('option[value=""]')?.textContent === 'Choose a category'
@@ -366,6 +391,7 @@ describe('TaggingPanel Component', () => {
         tracker
       );
 
+      await screen.findByText(/Select category/);
       const categorySelects = screen.getAllByRole('combobox');
       const categorySelect = categorySelects.find(select =>
         select.querySelector('option[value=""]')?.textContent === 'Choose a category'
@@ -474,7 +500,7 @@ describe('TaggingPanel Component', () => {
       expect(selects.length).toBeGreaterThan(0);
     });
 
-    it('should show Select All and Deselect All buttons', () => {
+    it('should show Select All and Deselect All buttons', async () => {
       renderWithEventBus(
         <TaggingPanel
           {...defaultProps}
@@ -482,11 +508,11 @@ describe('TaggingPanel Component', () => {
         />
       );
 
-      expect(screen.getByText('Select All')).toBeInTheDocument();
+      expect(await screen.findByText('Select All')).toBeInTheDocument();
       expect(screen.getByText('Deselect All')).toBeInTheDocument();
     });
 
-    it('should show category checkboxes', () => {
+    it('should show category checkboxes', async () => {
       renderWithEventBus(
         <TaggingPanel
           {...defaultProps}
@@ -494,7 +520,9 @@ describe('TaggingPanel Component', () => {
         />
       );
 
-      expect(screen.getByText('Issue')).toBeInTheDocument();
+      // Categories appear once `browse.tagSchemas()` resolves and the
+      // default schema is selected.
+      expect(await screen.findByText('Issue')).toBeInTheDocument();
       expect(screen.getByText('Rule')).toBeInTheDocument();
       expect(screen.getByText('Application')).toBeInTheDocument();
       expect(screen.getByText('Conclusion')).toBeInTheDocument();
@@ -520,7 +548,7 @@ describe('TaggingPanel Component', () => {
         />
       );
 
-      const issueCheckbox = screen.getByLabelText(/Issue/);
+      const issueCheckbox = await screen.findByLabelText(/Issue/);
       await userEvent.click(issueCheckbox);
 
       const annotateButton = screen.getByRole('button', { name: /✨\s*Annotate/i });
@@ -537,7 +565,7 @@ describe('TaggingPanel Component', () => {
         tracker
       );
 
-      const issueCheckbox = screen.getByLabelText(/Issue/);
+      const issueCheckbox = await screen.findByLabelText(/Issue/);
       const ruleCheckbox = screen.getByLabelText(/Rule/);
 
       await userEvent.click(issueCheckbox);
@@ -581,7 +609,7 @@ describe('TaggingPanel Component', () => {
       expect(headings[0]).toHaveClass('semiont-panel-header__text');
     });
 
-    it('should have proper checkbox labels', () => {
+    it('should have proper checkbox labels', async () => {
       renderWithEventBus(
         <TaggingPanel
           {...defaultProps}
@@ -589,8 +617,70 @@ describe('TaggingPanel Component', () => {
         />
       );
 
-      expect(screen.getByLabelText(/Issue/)).toBeInTheDocument();
+      expect(await screen.findByLabelText(/Issue/)).toBeInTheDocument();
       expect(screen.getByLabelText(/Rule/)).toBeInTheDocument();
     });
   });
+
+  describe('Empty registry (no tag schemas registered)', () => {
+    // The empty path: `browse.tagSchemas()` resolves to `[]` (KB has
+    // not run `register-tag-schemas` yet, no skill has registered a
+    // schema either). The panel should surface a clear message in
+    // both contexts where the schema picker would otherwise render —
+    // not just leave the dropdown empty.
+
+    it('shows the noSchemas message in the assist section instead of the picker', async () => {
+      renderWithEmptyRegistry(
+        <TaggingPanel {...defaultProps} annotateMode={true} />
+      );
+
+      // The empty-state message renders…
+      expect(
+        await screen.findByText(/No tag schemas registered for this knowledge base/i),
+      ).toBeInTheDocument();
+
+      // …and the picker UI does NOT (the form-field label `Select schema`
+      // is gated on `!noSchemasRegistered`).
+      expect(screen.queryByLabelText(/Select schema/i)).not.toBeInTheDocument();
+    });
+
+    it('shows the noSchemas message in the pending tag-creation form instead of the picker', async () => {
+      const pendingAnnotation = createPendingAnnotation('Selected text');
+
+      renderWithEmptyRegistry(
+        <TaggingPanel
+          {...defaultProps}
+          pendingAnnotation={pendingAnnotation}
+          annotateMode={false}
+        />
+      );
+
+      // The pending form opens. With annotateMode={false} the assist
+      // section is skipped so we get exactly one empty-state message —
+      // the one inside the pending form. (Default annotateMode=true
+      // renders the message in both places, which is the right product
+      // behavior; a separate test covers the assist-section path.)
+      expect(screen.getByText(/Create tag for selection/)).toBeInTheDocument();
+      expect(
+        await screen.findByText(/No tag schemas registered for this knowledge base/i),
+      ).toBeInTheDocument();
+      // No "Select category" label — the second dropdown renders only
+      // when `selectedSchema` exists, which requires a schema to be
+      // registered first.
+      expect(screen.queryByText(/Select category/i)).not.toBeInTheDocument();
+    });
+
+    it('keeps the panel rendering tags in the list section even with an empty registry', () => {
+      // The existing tag annotations on the resource still render —
+      // schema-registration is a write-side concern; reading existing
+      // tags doesn't depend on the registry being populated.
+      renderWithEmptyRegistry(
+        <TaggingPanel {...defaultProps} annotations={mockTags.multiple} />
+      );
+
+      expect(screen.getByTestId('tag-1')).toBeInTheDocument();
+      expect(screen.getByTestId('tag-2')).toBeInTheDocument();
+      expect(screen.getByTestId('tag-3')).toBeInTheDocument();
+    });
+  });
 });

package/src/features/moderate-tag-schemas/components/TagSchemasPage.tsx

@@ -12,7 +12,7 @@ import {
   LightBulbIcon
 } from '@heroicons/react/24/outline';
 import { COMMON_PANELS, type ToolbarPanelType } from '../../../state/shell-state-unit';
-import type { TagSchema } from '@semiont/react-ui';
+import type { TagSchema } from '@semiont/sdk';
 
 export interface TagSchemasPageProps {
   // Data props
@@ -43,7 +43,7 @@ const domainIcons: Record<string, React.ComponentType<any>> = {
   general: LightBulbIcon
 };
 
-const domainClasses = {
+const domainClasses: Record<string, string> = {
   legal: 'semiont-schema-domain--legal',
   scientific: 'semiont-schema-domain--scientific',
   general: 'semiont-schema-domain--general'
@@ -84,7 +84,7 @@ export function TagSchemasPage({
         <div className="semiont-card-grid semiont-card-grid--two-columns">
           {schemas.map((schema) => {
             const Icon = domainIcons[schema.domain] || LightBulbIcon;
-            const domainClass = domainClasses[schema.domain] || domainClasses.general;
+            const domainClass = domainClasses[schema.domain] || domainClasses.general!;
 
             return (
               <div

package/translations/ar.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "العلامات",
     "noTags": "لا توجد علامات بعد. استخدم التوضيح بالذكاء الاصطناعي لتحديد الأدوار الهيكلية.",
+    "noSchemas": "لا توجد مخططات وسوم مسجلة لقاعدة المعارف هذه. يجب على مسؤول قاعدة المعارف تسجيل مخطط تحليل هيكلي واحد على الأقل (مثلاً عبر مهارة `register-tag-schemas`) قبل استخدام الوسم.",
     "annotateTags": "توضيح العلامات",
     "selectSchema": "اختيار الإطار",
-    "schemaLegal": "التحليل القانوني (IRAC)",
-    "schemaScientific": "الورقة العلمية (IMRAD)",
-    "schemaArgument": "بنية الحجة (Toulmin)",
     "selectCategories": "اختيار الفئات",
-    "categoryIssue": "القضية",
-    "categoryRule": "القاعدة",
-    "categoryApplication": "التطبيق",
-    "categoryConclusion": "الخاتمة",
-    "categoryIntroduction": "المقدمة",
-    "categoryMethods": "المناهج",
-    "categoryResults": "النتائج",
-    "categoryDiscussion": "المناقشة",
-    "categoryClaim": "الادعاء",
-    "categoryEvidence": "الدليل",
-    "categoryWarrant": "المبرر",
-    "categoryCounterargument": "الحجة المضادة",
-    "categoryRebuttal": "الدحض",
     "annotate": "توضيح",
     "annotating": "جارٍ التوضيح...",
     "cancel": "إلغاء",

package/translations/bn.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "ট্যাগসমূহ",
     "noTags": "এখনো কোনো ট্যাগ নেই। কাঠামোগত ভূমিকা শনাক্ত করতে AI টীকাকরণ ব্যবহার করুন।",
+    "noSchemas": "এই জ্ঞান ভাণ্ডারের জন্য কোনো ট্যাগ স্কিমা নিবন্ধিত নেই। ট্যাগিং ব্যবহার করার আগে একজন KB প্রশাসককে কমপক্ষে একটি কাঠামোগত-বিশ্লেষণ স্কিমা নিবন্ধন করতে হবে (যেমন `register-tag-schemas` দক্ষতার মাধ্যমে)।",
     "annotateTags": "ট্যাগ টীকাকরণ",
     "selectSchema": "ফ্রেমওয়ার্ক নির্বাচন করুন",
-    "schemaLegal": "আইনি বিশ্লেষণ (IRAC)",
-    "schemaScientific": "বৈজ্ঞানিক গবেষণাপত্র (IMRAD)",
-    "schemaArgument": "যুক্তি কাঠামো (Toulmin)",
     "selectCategories": "বিভাগ নির্বাচন করুন",
-    "categoryIssue": "বিষয়",
-    "categoryRule": "নিয়ম",
-    "categoryApplication": "প্রয়োগ",
-    "categoryConclusion": "উপসংহার",
-    "categoryIntroduction": "ভূমিকা",
-    "categoryMethods": "পদ্ধতি",
-    "categoryResults": "ফলাফল",
-    "categoryDiscussion": "আলোচনা",
-    "categoryClaim": "দাবি",
-    "categoryEvidence": "প্রমাণ",
-    "categoryWarrant": "যুক্তিসূত্র",
-    "categoryCounterargument": "প্রতিযুক্তি",
-    "categoryRebuttal": "খণ্ডন",
     "annotate": "টীকাকরণ",
     "annotating": "টীকাকরণ হচ্ছে...",
     "cancel": "বাতিল করুন",

package/translations/cs.json

@@ -148,25 +148,10 @@
   "TaggingPanel": {
     "title": "Štítky",
     "noTags": "Zatím žádné štítky. Použijte AI anotaci pro identifikaci strukturálních rolí.",
+    "noSchemas": "Pro tuto znalostní bázi nejsou registrována žádná schémata značek. Správce KB musí zaregistrovat alespoň jedno schéma strukturální analýzy (např. pomocí dovednosti `register-tag-schemas`), než bude možné používat značkování.",
     "annotateTags": "Anotovat štítky",
     "selectSchema": "Vybrat rámec",
-    "schemaLegal": "Právní analýza (IRAC)",
-    "schemaScientific": "Vědecký článek (IMRAD)",
-    "schemaArgument": "Struktura argumentace (Toulmin)",
     "selectCategories": "Vybrat kategorie",
-    "categoryIssue": "Otázka",
-    "categoryRule": "Pravidlo",
-    "categoryApplication": "Aplikace",
-    "categoryConclusion": "Závěr",
-    "categoryIntroduction": "Úvod",
-    "categoryMethods": "Metody",
-    "categoryResults": "Výsledky",
-    "categoryDiscussion": "Diskuze",
-    "categoryClaim": "Tvrzení",
-    "categoryEvidence": "Důkaz",
-    "categoryWarrant": "Odůvodnění",
-    "categoryCounterargument": "Protiargument",
-    "categoryRebuttal": "Vyvrácení",
     "annotate": "Anotovat",
     "annotating": "Anotování...",
     "cancel": "Zrušit",